SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/tipc/config.c

   1 /*
   2  * net/tipc/config.c: TIPC configuration management code
   3  *
   4  * Copyright (c) 2003-2005, Ericsson Research Canada
   5  * Copyright (c) 2004-2005, Wind River Systems
   6  * Copyright (c) 2005-2006, Ericsson AB
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions are met:
  11  *
  12  * Redistributions of source code must retain the above copyright notice, this
  13  * list of conditions and the following disclaimer.
  14  * Redistributions in binary form must reproduce the above copyright notice,
  15  * this list of conditions and the following disclaimer in the documentation
  16  * and/or other materials provided with the distribution.
  17  * Neither the names of the copyright holders nor the names of its
  18  * contributors may be used to endorse or promote products derived from this
  19  * software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include "core.h"
  35 #include "dbg.h"
  36 #include "bearer.h"
  37 #include "port.h"
  38 #include "link.h"
  39 #include "zone.h"
  40 #include "addr.h"
  41 #include "name_table.h"
  42 #include "node.h"
  43 #include "config.h"
  44 #include "discover.h"
  45
  46 struct subscr_data {
  47         char usr_handle[8];
  48         u32 domain;
  49         u32 port_ref;
  50         struct list_head subd_list;
  51 };
  52
  53 struct manager {
  54         u32 user_ref;
  55         u32 port_ref;
  56         u32 subscr_ref;
  57         u32 link_subscriptions;
  58         struct list_head link_subscribers;
  59 };
  60
  61 static struct manager mng = { 0};
  62
  63 static spinlock_t config_lock = SPIN_LOCK_UNLOCKED;
  64
  65 static const void *req_tlv_area;        /* request message TLV area */
  66 static int req_tlv_space;               /* request message TLV area size */
  67 static int rep_headroom;                /* reply message headroom to use */
  68
  69
  70 void cfg_link_event(u32 addr, char *name, int up)
  71 {
  72         /* TIPC DOESN'T HANDLE LINK EVENT SUBSCRIPTIONS AT THE MOMENT */
  73 }
  74
  75
  76 struct sk_buff *cfg_reply_alloc(int payload_size)
  77 {
  78         struct sk_buff *buf;
  79
  80         buf = alloc_skb(rep_headroom + payload_size, GFP_ATOMIC);
  81         if (buf)
  82                 skb_reserve(buf, rep_headroom);
  83         return buf;
  84 }
  85
  86 int cfg_append_tlv(struct sk_buff *buf, int tlv_type,
  87                    void *tlv_data, int tlv_data_size)
  88 {
  89         struct tlv_desc *tlv = (struct tlv_desc *)buf->tail;
  90         int new_tlv_space = TLV_SPACE(tlv_data_size);
  91
  92         if (skb_tailroom(buf) < new_tlv_space) {
  93                 dbg("cfg_append_tlv unable to append TLV\n");
  94                 return 0;
  95         }
  96         skb_put(buf, new_tlv_space);
  97         tlv->tlv_type = htons(tlv_type);
  98         tlv->tlv_len  = htons(TLV_LENGTH(tlv_data_size));
  99         if (tlv_data_size && tlv_data)
 100                 memcpy(TLV_DATA(tlv), tlv_data, tlv_data_size);
 101         return 1;
 102 }
 103
 104 struct sk_buff *cfg_reply_unsigned_type(u16 tlv_type, u32 value)
 105 {
 106         struct sk_buff *buf;
 107         u32 value_net;
 108
 109         buf = cfg_reply_alloc(TLV_SPACE(sizeof(value)));
 110         if (buf) {
 111                 value_net = htonl(value);
 112                 cfg_append_tlv(buf, tlv_type, &value_net,
 113                                sizeof(value_net));
 114         }
 115         return buf;
 116 }
 117
 118 struct sk_buff *cfg_reply_string_type(u16 tlv_type, char *string)
 119 {
 120         struct sk_buff *buf;
 121         int string_len = strlen(string) + 1;
 122
 123         buf = cfg_reply_alloc(TLV_SPACE(string_len));
 124         if (buf)
 125                 cfg_append_tlv(buf, tlv_type, string, string_len);
 126         return buf;
 127 }
 128
 129
 130
 131
 132 #if 0
 133
 134 /* Now obsolete code for handling commands not yet implemented the new way */
 135
 136 int tipc_cfg_cmd(const struct tipc_cmd_msg * msg,
 137                  char *data,
 138                  u32 sz,
 139                  u32 *ret_size,
 140                  struct tipc_portid *orig)
 141 {
 142         int rv = -EINVAL;
 143         u32 cmd = msg->cmd;
 144
 145         *ret_size = 0;
 146         switch (cmd) {
 147         case TIPC_REMOVE_LINK:
 148         case TIPC_CMD_BLOCK_LINK:
 149         case TIPC_CMD_UNBLOCK_LINK:
 150                 if (!cfg_check_connection(orig))
 151                         rv = link_control(msg->argv.link_name, msg->cmd, 0);
 152                 break;
 153         case TIPC_ESTABLISH:
 154                 {
 155                         int connected;
 156
 157                         tipc_isconnected(mng.conn_port_ref, &connected);
 158                         if (connected || !orig) {
 159                                 rv = TIPC_FAILURE;
 160                                 break;
 161                         }
 162                         rv = tipc_connect2port(mng.conn_port_ref, orig);
 163                         if (rv == TIPC_OK)
 164                                 orig = 0;
 165                         break;
 166                 }
 167         case TIPC_GET_PEER_ADDRESS:
 168                 *ret_size = link_peer_addr(msg->argv.link_name, data, sz);
 169                 break;
 170         case TIPC_GET_ROUTES:
 171                 rv = TIPC_OK;
 172                 break;
 173         default: {}
 174         }
 175         if (*ret_size)
 176                 rv = TIPC_OK;
 177         return rv;
 178 }
 179
 180 static void cfg_cmd_event(struct tipc_cmd_msg *msg,
 181                           char *data,
 182                           u32 sz,
 183                           struct tipc_portid const *orig)
 184 {
 185         int rv = -EINVAL;
 186         struct tipc_cmd_result_msg rmsg;
 187         struct iovec msg_sect[2];
 188         int *arg;
 189
 190         msg->cmd = ntohl(msg->cmd);
 191
 192         cfg_prepare_res_msg(msg->cmd, msg->usr_handle, rv, &rmsg, msg_sect,
 193                             data, 0);
 194         if (ntohl(msg->magic) != TIPC_MAGIC)
 195                 goto exit;
 196
 197         switch (msg->cmd) {
 198         case TIPC_CREATE_LINK:
 199                 if (!cfg_check_connection(orig))
 200                         rv = disc_create_link(&msg->argv.create_link);
 201                 break;
 202         case TIPC_LINK_SUBSCRIBE:
 203                 {
 204                         struct subscr_data *sub;
 205
 206                         if (mng.link_subscriptions > 64)
 207                                 break;
 208                         sub = (struct subscr_data *)kmalloc(sizeof(*sub),
 209                                                             GFP_ATOMIC);
 210                         if (sub == NULL) {
 211                                 warn("Memory squeeze; dropped remote link subscription\n");
 212                                 break;
 213                         }
 214                         INIT_LIST_HEAD(&sub->subd_list);
 215                         tipc_createport(mng.user_ref,
 216                                         (void *)sub,
 217                                         TIPC_HIGH_IMPORTANCE,
 218                                         0,
 219                                         0,
 220                                         (tipc_conn_shutdown_event)cfg_linksubscr_cancel,
 221                                         0,
 222                                         0,
 223                                         (tipc_conn_msg_event)cfg_linksubscr_cancel,
 224                                         0,
 225                                         &sub->port_ref);
 226                         if (!sub->port_ref) {
 227                                 kfree(sub);
 228                                 break;
 229                         }
 230                         memcpy(sub->usr_handle,msg->usr_handle,
 231                                sizeof(sub->usr_handle));
 232                         sub->domain = msg->argv.domain;
 233                         list_add_tail(&sub->subd_list, &mng.link_subscribers);
 234                         tipc_connect2port(sub->port_ref, orig);
 235                         rmsg.retval = TIPC_OK;
 236                         tipc_send(sub->port_ref, 2u, msg_sect);
 237                         mng.link_subscriptions++;
 238                         return;
 239                 }
 240         default:
 241                 rv = tipc_cfg_cmd(msg, data, sz, (u32 *)&msg_sect[1].iov_len, orig);
 242         }
 243         exit:
 244         rmsg.result_len = htonl(msg_sect[1].iov_len);
 245         rmsg.retval = htonl(rv);
 246         cfg_respond(msg_sect, 2u, orig);
 247 }
 248 #endif
 249
 250 static struct sk_buff *cfg_enable_bearer(void)
 251 {
 252         struct tipc_bearer_config *args;
 253
 254         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_CONFIG))
 255                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 256
 257         args = (struct tipc_bearer_config *)TLV_DATA(req_tlv_area);
 258         if (tipc_enable_bearer(args->name,
 259                                ntohl(args->detect_scope),
 260                                ntohl(args->priority)))
 261                 return cfg_reply_error_string("unable to enable bearer");
 262
 263         return cfg_reply_none();
 264 }
 265
 266 static struct sk_buff *cfg_disable_bearer(void)
 267 {
 268         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_NAME))
 269                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 270
 271         if (tipc_disable_bearer((char *)TLV_DATA(req_tlv_area)))
 272                 return cfg_reply_error_string("unable to disable bearer");
 273
 274         return cfg_reply_none();
 275 }
 276
 277 static struct sk_buff *cfg_set_own_addr(void)
 278 {
 279         u32 addr;
 280
 281         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
 282                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 283
 284         addr = *(u32 *)TLV_DATA(req_tlv_area);
 285         addr = ntohl(addr);
 286         if (addr == tipc_own_addr)
 287                 return cfg_reply_none();
 288         if (!addr_node_valid(addr))
 289                 return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
 290                                               " (node address)");
 291         if (tipc_own_addr)
 292                 return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
 293                                               " (cannot change node address once assigned)");
 294
 295         spin_unlock_bh(&config_lock);
 296         stop_net();
 297         tipc_own_addr = addr;
 298         start_net();
 299         spin_lock_bh(&config_lock);
 300         return cfg_reply_none();
 301 }
 302
 303 static struct sk_buff *cfg_set_remote_mng(void)
 304 {
 305         u32 value;
 306
 307         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
 308                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 309
 310         value = *(u32 *)TLV_DATA(req_tlv_area);
 311         value = ntohl(value);
 312         tipc_remote_management = (value != 0);
 313         return cfg_reply_none();
 314 }
 315
 316 static struct sk_buff *cfg_set_max_publications(void)
 317 {
 318         u32 value;
 319
 320         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
 321                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 322
 323         value = *(u32 *)TLV_DATA(req_tlv_area);
 324         value = ntohl(value);
 325         if (value != delimit(value, 1, 65535))
 326                 return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
 327                                               " (max publications must be 1-65535)");
 328         tipc_max_publications = value;
 329         return cfg_reply_none();
 330 }
 331
 332 static struct sk_buff *cfg_set_max_subscriptions(void)
 333 {
 334         u32 value;
 335
 336         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
 337                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 338
 339         value = *(u32 *)TLV_DATA(req_tlv_area);
 340         value = ntohl(value);
 341         if (value != delimit(value, 1, 65535))
 342                 return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
 343                                               " (max subscriptions must be 1-65535");
 344         tipc_max_subscriptions = value;
 345         return cfg_reply_none();
 346 }
 347
 348 static struct sk_buff *cfg_set_max_ports(void)
 349 {
 350         int orig_mode;
 351         u32 value;
 352
 353         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
 354                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 355         value = *(u32 *)TLV_DATA(req_tlv_area);
 356         value = ntohl(value);
 357         if (value != delimit(value, 127, 65535))
 358                 return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
 359                                               " (max ports must be 127-65535)");
 360
 361         if (value == tipc_max_ports)
 362                 return cfg_reply_none();
 363
 364         if (atomic_read(&tipc_user_count) > 2)
 365                 return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
 366                                               " (cannot change max ports while TIPC users exist)");
 367
 368         spin_unlock_bh(&config_lock);
 369         orig_mode = tipc_get_mode();
 370         if (orig_mode == TIPC_NET_MODE)
 371                 stop_net();
 372         stop_core();
 373         tipc_max_ports = value;
 374         start_core();
 375         if (orig_mode == TIPC_NET_MODE)
 376                 start_net();
 377         spin_lock_bh(&config_lock);
 378         return cfg_reply_none();
 379 }
 380
 381 static struct sk_buff *set_net_max(int value, int *parameter)
 382 {
 383         int orig_mode;
 384
 385         if (value != *parameter) {
 386                 orig_mode = tipc_get_mode();
 387                 if (orig_mode == TIPC_NET_MODE)
 388                         stop_net();
 389                 *parameter = value;
 390                 if (orig_mode == TIPC_NET_MODE)
 391                         start_net();
 392         }
 393
 394         return cfg_reply_none();
 395 }
 396
 397 static struct sk_buff *cfg_set_max_zones(void)
 398 {
 399         u32 value;
 400
 401         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
 402                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 403         value = *(u32 *)TLV_DATA(req_tlv_area);
 404         value = ntohl(value);
 405         if (value != delimit(value, 1, 255))
 406                 return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
 407                                               " (max zones must be 1-255)");
 408         return set_net_max(value, &tipc_max_zones);
 409 }
 410
 411 static struct sk_buff *cfg_set_max_clusters(void)
 412 {
 413         u32 value;
 414
 415         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
 416                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 417         value = *(u32 *)TLV_DATA(req_tlv_area);
 418         value = ntohl(value);
 419         if (value != 1)
 420                 return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
 421                                               " (max clusters fixed at 1)");
 422         return cfg_reply_none();
 423 }
 424
 425 static struct sk_buff *cfg_set_max_nodes(void)
 426 {
 427         u32 value;
 428
 429         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
 430                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 431         value = *(u32 *)TLV_DATA(req_tlv_area);
 432         value = ntohl(value);
 433         if (value != delimit(value, 8, 2047))
 434                 return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
 435                                               " (max nodes must be 8-2047)");
 436         return set_net_max(value, &tipc_max_nodes);
 437 }
 438
 439 static struct sk_buff *cfg_set_max_slaves(void)
 440 {
 441         u32 value;
 442
 443         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
 444                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 445         value = *(u32 *)TLV_DATA(req_tlv_area);
 446         value = ntohl(value);
 447         if (value != 0)
 448                 return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
 449                                               " (max secondary nodes fixed at 0)");
 450         return cfg_reply_none();
 451 }
 452
 453 static struct sk_buff *cfg_set_netid(void)
 454 {
 455         u32 value;
 456
 457         if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
 458                 return cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
 459         value = *(u32 *)TLV_DATA(req_tlv_area);
 460         value = ntohl(value);
 461         if (value != delimit(value, 1, 9999))
 462                 return cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
 463                                               " (network id must be 1-9999)");
 464
 465         if (tipc_own_addr)
 466                 return cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
 467                                               " (cannot change network id once part of network)");
 468
 469         return set_net_max(value, &tipc_net_id);
 470 }
 471
 472 struct sk_buff *cfg_do_cmd(u32 orig_node, u16 cmd, const void *request_area,
 473                            int request_space, int reply_headroom)
 474 {
 475         struct sk_buff *rep_tlv_buf;
 476
 477         spin_lock_bh(&config_lock);
 478
 479         /* Save request and reply details in a well-known location */
 480
 481         req_tlv_area = request_area;
 482         req_tlv_space = request_space;
 483         rep_headroom = reply_headroom;
 484
 485         /* Check command authorization */
 486
 487         if (likely(orig_node == tipc_own_addr)) {
 488                 /* command is permitted */
 489         } else if (cmd >= 0x8000) {
 490                 rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
 491                                                      " (cannot be done remotely)");
 492                 goto exit;
 493         } else if (!tipc_remote_management) {
 494                 rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NO_REMOTE);
 495                 goto exit;
 496         }
 497         else if (cmd >= 0x4000) {
 498                 u32 domain = 0;
 499
 500                 if ((nametbl_translate(TIPC_ZM_SRV, 0, &domain) == 0) ||
 501                     (domain != orig_node)) {
 502                         rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NOT_ZONE_MSTR);
 503                         goto exit;
 504                 }
 505         }
 506
 507         /* Call appropriate processing routine */
 508
 509         switch (cmd) {
 510         case TIPC_CMD_NOOP:
 511                 rep_tlv_buf = cfg_reply_none();
 512                 break;
 513         case TIPC_CMD_GET_NODES:
 514                 rep_tlv_buf = node_get_nodes(req_tlv_area, req_tlv_space);
 515                 break;
 516         case TIPC_CMD_GET_LINKS:
 517                 rep_tlv_buf = node_get_links(req_tlv_area, req_tlv_space);
 518                 break;
 519         case TIPC_CMD_SHOW_LINK_STATS:
 520                 rep_tlv_buf = link_cmd_show_stats(req_tlv_area, req_tlv_space);
 521                 break;
 522         case TIPC_CMD_RESET_LINK_STATS:
 523                 rep_tlv_buf = link_cmd_reset_stats(req_tlv_area, req_tlv_space);
 524                 break;
 525         case TIPC_CMD_SHOW_NAME_TABLE:
 526                 rep_tlv_buf = nametbl_get(req_tlv_area, req_tlv_space);
 527                 break;
 528         case TIPC_CMD_GET_BEARER_NAMES:
 529                 rep_tlv_buf = bearer_get_names();
 530                 break;
 531         case TIPC_CMD_GET_MEDIA_NAMES:
 532                 rep_tlv_buf = media_get_names();
 533                 break;
 534         case TIPC_CMD_SHOW_PORTS:
 535                 rep_tlv_buf = port_get_ports();
 536                 break;
 537 #if 0
 538         case TIPC_CMD_SHOW_PORT_STATS:
 539                 rep_tlv_buf = port_show_stats(req_tlv_area, req_tlv_space);
 540                 break;
 541         case TIPC_CMD_RESET_PORT_STATS:
 542                 rep_tlv_buf = cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED);
 543                 break;
 544 #endif
 545         case TIPC_CMD_SET_LOG_SIZE:
 546                 rep_tlv_buf = log_resize(req_tlv_area, req_tlv_space);
 547                 break;
 548         case TIPC_CMD_DUMP_LOG:
 549                 rep_tlv_buf = log_dump();
 550                 break;
 551         case TIPC_CMD_SET_LINK_TOL:
 552         case TIPC_CMD_SET_LINK_PRI:
 553         case TIPC_CMD_SET_LINK_WINDOW:
 554                 rep_tlv_buf = link_cmd_config(req_tlv_area, req_tlv_space, cmd);
 555                 break;
 556         case TIPC_CMD_ENABLE_BEARER:
 557                 rep_tlv_buf = cfg_enable_bearer();
 558                 break;
 559         case TIPC_CMD_DISABLE_BEARER:
 560                 rep_tlv_buf = cfg_disable_bearer();
 561                 break;
 562         case TIPC_CMD_SET_NODE_ADDR:
 563                 rep_tlv_buf = cfg_set_own_addr();
 564                 break;
 565         case TIPC_CMD_SET_REMOTE_MNG:
 566                 rep_tlv_buf = cfg_set_remote_mng();
 567                 break;
 568         case TIPC_CMD_SET_MAX_PORTS:
 569                 rep_tlv_buf = cfg_set_max_ports();
 570                 break;
 571         case TIPC_CMD_SET_MAX_PUBL:
 572                 rep_tlv_buf = cfg_set_max_publications();
 573                 break;
 574         case TIPC_CMD_SET_MAX_SUBSCR:
 575                 rep_tlv_buf = cfg_set_max_subscriptions();
 576                 break;
 577         case TIPC_CMD_SET_MAX_ZONES:
 578                 rep_tlv_buf = cfg_set_max_zones();
 579                 break;
 580         case TIPC_CMD_SET_MAX_CLUSTERS:
 581                 rep_tlv_buf = cfg_set_max_clusters();
 582                 break;
 583         case TIPC_CMD_SET_MAX_NODES:
 584                 rep_tlv_buf = cfg_set_max_nodes();
 585                 break;
 586         case TIPC_CMD_SET_MAX_SLAVES:
 587                 rep_tlv_buf = cfg_set_max_slaves();
 588                 break;
 589         case TIPC_CMD_SET_NETID:
 590                 rep_tlv_buf = cfg_set_netid();
 591                 break;
 592         case TIPC_CMD_GET_REMOTE_MNG:
 593                 rep_tlv_buf = cfg_reply_unsigned(tipc_remote_management);
 594                 break;
 595         case TIPC_CMD_GET_MAX_PORTS:
 596                 rep_tlv_buf = cfg_reply_unsigned(tipc_max_ports);
 597                 break;
 598         case TIPC_CMD_GET_MAX_PUBL:
 599                 rep_tlv_buf = cfg_reply_unsigned(tipc_max_publications);
 600                 break;
 601         case TIPC_CMD_GET_MAX_SUBSCR:
 602                 rep_tlv_buf = cfg_reply_unsigned(tipc_max_subscriptions);
 603                 break;
 604         case TIPC_CMD_GET_MAX_ZONES:
 605                 rep_tlv_buf = cfg_reply_unsigned(tipc_max_zones);
 606                 break;
 607         case TIPC_CMD_GET_MAX_CLUSTERS:
 608                 rep_tlv_buf = cfg_reply_unsigned(tipc_max_clusters);
 609                 break;
 610         case TIPC_CMD_GET_MAX_NODES:
 611                 rep_tlv_buf = cfg_reply_unsigned(tipc_max_nodes);
 612                 break;
 613         case TIPC_CMD_GET_MAX_SLAVES:
 614                 rep_tlv_buf = cfg_reply_unsigned(tipc_max_slaves);
 615                 break;
 616         case TIPC_CMD_GET_NETID:
 617                 rep_tlv_buf = cfg_reply_unsigned(tipc_net_id);
 618                 break;
 619         default:
 620                 rep_tlv_buf = NULL;
 621                 break;
 622         }
 623
 624         /* Return reply buffer */
 625 exit:
 626         spin_unlock_bh(&config_lock);
 627         return rep_tlv_buf;
 628 }
 629
 630 static void cfg_named_msg_event(void *userdata,
 631                                 u32 port_ref,
 632                                 struct sk_buff **buf,
 633                                 const unchar *msg,
 634                                 u32 size,
 635                                 u32 importance,
 636                                 struct tipc_portid const *orig,
 637                                 struct tipc_name_seq const *dest)
 638 {
 639         struct tipc_cfg_msg_hdr *req_hdr;
 640         struct tipc_cfg_msg_hdr *rep_hdr;
 641         struct sk_buff *rep_buf;
 642
 643         /* Validate configuration message header (ignore invalid message) */
 644
 645         req_hdr = (struct tipc_cfg_msg_hdr *)msg;
 646         if ((size < sizeof(*req_hdr)) ||
 647             (size != TCM_ALIGN(ntohl(req_hdr->tcm_len))) ||
 648             (ntohs(req_hdr->tcm_flags) != TCM_F_REQUEST)) {
 649                 warn("discarded invalid configuration message\n");
 650                 return;
 651         }
 652
 653         /* Generate reply for request (if can't, return request) */
 654
 655         rep_buf = cfg_do_cmd(orig->node,
 656                              ntohs(req_hdr->tcm_type),
 657                              msg + sizeof(*req_hdr),
 658                              size - sizeof(*req_hdr),
 659                              BUF_HEADROOM + MAX_H_SIZE + sizeof(*rep_hdr));
 660         if (rep_buf) {
 661                 skb_push(rep_buf, sizeof(*rep_hdr));
 662                 rep_hdr = (struct tipc_cfg_msg_hdr *)rep_buf->data;
 663                 memcpy(rep_hdr, req_hdr, sizeof(*rep_hdr));
 664                 rep_hdr->tcm_len = htonl(rep_buf->len);
 665                 rep_hdr->tcm_flags &= htons(~TCM_F_REQUEST);
 666         } else {
 667                 rep_buf = *buf;
 668                 *buf = NULL;
 669         }
 670
 671         /* NEED TO ADD CODE TO HANDLE FAILED SEND (SUCH AS CONGESTION) */
 672         tipc_send_buf2port(port_ref, orig, rep_buf, rep_buf->len);
 673 }
 674
 675 int cfg_init(void)
 676 {
 677         struct tipc_name_seq seq;
 678         int res;
 679
 680         memset(&mng, 0, sizeof(mng));
 681         INIT_LIST_HEAD(&mng.link_subscribers);
 682
 683         res = tipc_attach(&mng.user_ref, 0, 0);
 684         if (res)
 685                 goto failed;
 686
 687         res = tipc_createport(mng.user_ref, 0, TIPC_CRITICAL_IMPORTANCE,
 688                               NULL, NULL, NULL,
 689                               NULL, cfg_named_msg_event, NULL,
 690                               NULL, &mng.port_ref);
 691         if (res)
 692                 goto failed;
 693
 694         seq.type = TIPC_CFG_SRV;
 695         seq.lower = seq.upper = tipc_own_addr;
 696         res = nametbl_publish_rsv(mng.port_ref, TIPC_ZONE_SCOPE, &seq);
 697         if (res)
 698                 goto failed;
 699
 700         return 0;
 701
 702 failed:
 703         err("Unable to create configuration service\n");
 704         tipc_detach(mng.user_ref);
 705         mng.user_ref = 0;
 706         return res;
 707 }
 708
 709 void cfg_stop(void)
 710 {
 711         if (mng.user_ref) {
 712                 tipc_detach(mng.user_ref);
 713                 mng.user_ref = 0;
 714         }
 715 }