sys/netgraph/atm/ccatm/ng_ccatm.c

   1 /*-
   2  * Copyright (c) 2001-2002
   3  *      Fraunhofer Institute for Open Communication Systems (FhG Fokus).
   4  *      All rights reserved.
   5  * Copyright (c) 2003-2004
   6  *      Hartmut Brandt
   7  *      All rights reserved.
   8  *
   9  * Author: Harti Brandt <harti@freebsd.org>
  10  *
  11  * Redistribution of this software and documentation and use in source and
  12  * binary forms, with or without modification, are permitted provided that
  13  * the following conditions are met:
  14  *
  15  * 1. Redistributions of source code or documentation must retain the above
  16  *    copyright notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE AUTHOR
  22  * AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  23  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  24  * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
  25  * THE AUTHOR OR ITS CONTRIBUTORS  BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  28  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  29  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  30  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  31  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * $FreeBSD$
  34  *
  35  * ATM call control and API
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/kernel.h>
  44 #include <sys/malloc.h>
  45 #include <sys/mbuf.h>
  46 #include <sys/errno.h>
  47 #include <sys/socket.h>
  48 #include <sys/socketvar.h>
  49 #include <sys/sbuf.h>
  50 #include <machine/stdarg.h>
  51
  52 #include <netgraph/ng_message.h>
  53 #include <netgraph/netgraph.h>
  54 #include <netgraph/ng_parse.h>
  55 #include <netnatm/unimsg.h>
  56 #include <netnatm/msg/unistruct.h>
  57 #include <netnatm/api/unisap.h>
  58 #include <netnatm/sig/unidef.h>
  59 #include <netgraph/atm/ngatmbase.h>
  60 #include <netgraph/atm/ng_uni.h>
  61 #include <netnatm/api/atmapi.h>
  62 #include <netgraph/atm/ng_ccatm.h>
  63 #include <netnatm/api/ccatm.h>
  64
  65 MODULE_DEPEND(ng_ccatm, ngatmbase, 1, 1, 1);
  66
  67 MALLOC_DEFINE(M_NG_CCATM, "ng_ccatm", "netgraph uni api node");
  68
  69 /*
  70  * Command structure parsing
  71  */
  72
  73 /* ESI */
  74 static const struct ng_parse_fixedarray_info ng_ccatm_esi_type_info =
  75     NGM_CCATM_ESI_INFO;
  76 static const struct ng_parse_type ng_ccatm_esi_type = {
  77         &ng_parse_fixedarray_type,
  78         &ng_ccatm_esi_type_info
  79 };
  80
  81 /* PORT PARAMETERS */
  82 static const struct ng_parse_struct_field ng_ccatm_atm_port_type_info[] =
  83     NGM_CCATM_ATM_PORT_INFO;
  84 static const struct ng_parse_type ng_ccatm_atm_port_type = {
  85         &ng_parse_struct_type,
  86         ng_ccatm_atm_port_type_info
  87 };
  88
  89 /* PORT structure */
  90 static const struct ng_parse_struct_field ng_ccatm_port_type_info[] =
  91     NGM_CCATM_PORT_INFO;
  92 static const struct ng_parse_type ng_ccatm_port_type = {
  93         &ng_parse_struct_type,
  94         ng_ccatm_port_type_info
  95 };
  96
  97 /* the ADDRESS array itself */
  98 static const struct ng_parse_fixedarray_info ng_ccatm_addr_array_type_info =
  99     NGM_CCATM_ADDR_ARRAY_INFO;
 100 static const struct ng_parse_type ng_ccatm_addr_array_type = {
 101         &ng_parse_fixedarray_type,
 102         &ng_ccatm_addr_array_type_info
 103 };
 104
 105 /* one ADDRESS */
 106 static const struct ng_parse_struct_field ng_ccatm_uni_addr_type_info[] =
 107     NGM_CCATM_UNI_ADDR_INFO;
 108 static const struct ng_parse_type ng_ccatm_uni_addr_type = {
 109         &ng_parse_struct_type,
 110         ng_ccatm_uni_addr_type_info
 111 };
 112
 113 /* ADDRESS request */
 114 static const struct ng_parse_struct_field ng_ccatm_addr_req_type_info[] =
 115     NGM_CCATM_ADDR_REQ_INFO;
 116 static const struct ng_parse_type ng_ccatm_addr_req_type = {
 117         &ng_parse_struct_type,
 118         ng_ccatm_addr_req_type_info
 119 };
 120
 121 /* ADDRESS var-array */
 122 static int
 123 ng_ccatm_addr_req_array_getlen(const struct ng_parse_type *type,
 124     const u_char *start, const u_char *buf)
 125 {
 126         const struct ngm_ccatm_get_addresses *p;
 127
 128         p = (const struct ngm_ccatm_get_addresses *)
 129             (buf - offsetof(struct ngm_ccatm_get_addresses, addr));
 130         return (p->count);
 131 }
 132 static const struct ng_parse_array_info ng_ccatm_addr_req_array_type_info =
 133     NGM_CCATM_ADDR_REQ_ARRAY_INFO;
 134 static const struct ng_parse_type ng_ccatm_addr_req_array_type = {
 135         &ng_parse_array_type,
 136         &ng_ccatm_addr_req_array_type_info
 137 };
 138
 139 /* Outer get_ADDRESSes structure */
 140 static const struct ng_parse_struct_field ng_ccatm_get_addresses_type_info[] =
 141     NGM_CCATM_GET_ADDRESSES_INFO;
 142 static const struct ng_parse_type ng_ccatm_get_addresses_type = {
 143         &ng_parse_struct_type,
 144         ng_ccatm_get_addresses_type_info
 145 };
 146
 147 /* Port array */
 148 static int
 149 ng_ccatm_port_array_getlen(const struct ng_parse_type *type,
 150     const u_char *start, const u_char *buf)
 151 {
 152         const struct ngm_ccatm_portlist *p;
 153
 154         p = (const struct ngm_ccatm_portlist *)
 155             (buf - offsetof(struct ngm_ccatm_portlist, ports));
 156         return (p->nports);
 157 }
 158 static const struct ng_parse_array_info ng_ccatm_port_array_type_info =
 159     NGM_CCATM_PORT_ARRAY_INFO;
 160 static const struct ng_parse_type ng_ccatm_port_array_type = {
 161         &ng_parse_array_type,
 162         &ng_ccatm_port_array_type_info
 163 };
 164
 165 /* Portlist structure */
 166 static const struct ng_parse_struct_field ng_ccatm_portlist_type_info[] =
 167     NGM_CCATM_PORTLIST_INFO;
 168 static const struct ng_parse_type ng_ccatm_portlist_type = {
 169         &ng_parse_struct_type,
 170         ng_ccatm_portlist_type_info
 171 };
 172
 173 /*
 174  * Command list
 175  */
 176 static const struct ng_cmdlist ng_ccatm_cmdlist[] = {
 177         {
 178           NGM_CCATM_COOKIE,
 179           NGM_CCATM_DUMP,
 180           "dump",
 181           NULL,
 182           NULL
 183         },
 184         {
 185           NGM_CCATM_COOKIE,
 186           NGM_CCATM_STOP,
 187           "stop",
 188           &ng_ccatm_port_type,
 189           NULL
 190         },
 191         {
 192           NGM_CCATM_COOKIE,
 193           NGM_CCATM_START,
 194           "start",
 195           &ng_ccatm_port_type,
 196           NULL
 197         },
 198         {
 199           NGM_CCATM_COOKIE,
 200           NGM_CCATM_GETSTATE,
 201           "getstate",
 202           &ng_ccatm_port_type,
 203           &ng_parse_uint32_type
 204         },
 205         {
 206           NGM_CCATM_COOKIE,
 207           NGM_CCATM_GET_ADDRESSES,
 208           "get_addresses",
 209           &ng_ccatm_port_type,
 210           &ng_ccatm_get_addresses_type
 211         },
 212         {
 213           NGM_CCATM_COOKIE,
 214           NGM_CCATM_CLEAR,
 215           "clear",
 216           &ng_ccatm_port_type,
 217           NULL
 218         },
 219         {
 220           NGM_CCATM_COOKIE,
 221           NGM_CCATM_ADDRESS_REGISTERED,
 222           "address_reg",
 223           &ng_ccatm_addr_req_type,
 224           NULL
 225         },
 226         {
 227           NGM_CCATM_COOKIE,
 228           NGM_CCATM_ADDRESS_UNREGISTERED,
 229           "address_unreg",
 230           &ng_ccatm_addr_req_type,
 231           NULL
 232         },
 233         {
 234           NGM_CCATM_COOKIE,
 235           NGM_CCATM_SET_PORT_PARAM,
 236           "set_port_param",
 237           &ng_ccatm_atm_port_type,
 238           NULL
 239         },
 240         {
 241           NGM_CCATM_COOKIE,
 242           NGM_CCATM_GET_PORT_PARAM,
 243           "get_port_param",
 244           &ng_ccatm_port_type,
 245           &ng_ccatm_atm_port_type,
 246         },
 247         {
 248           NGM_CCATM_COOKIE,
 249           NGM_CCATM_GET_PORTLIST,
 250           "get_portlist",
 251           NULL,
 252           &ng_ccatm_portlist_type,
 253         },
 254         {
 255           NGM_CCATM_COOKIE,
 256           NGM_CCATM_SETLOG,
 257           "setlog",
 258           &ng_parse_hint32_type,
 259           &ng_parse_hint32_type,
 260         },
 261         {
 262           NGM_CCATM_COOKIE,
 263           NGM_CCATM_RESET,
 264           "reset",
 265           NULL,
 266           NULL,
 267         },
 268         { 0 }
 269 };
 270
 271 /*
 272  * Module data
 273  */
 274 static ng_constructor_t         ng_ccatm_constructor;
 275 static ng_rcvmsg_t              ng_ccatm_rcvmsg;
 276 static ng_shutdown_t            ng_ccatm_shutdown;
 277 static ng_newhook_t             ng_ccatm_newhook;
 278 static ng_rcvdata_t             ng_ccatm_rcvdata;
 279 static ng_disconnect_t          ng_ccatm_disconnect;
 280 static int ng_ccatm_mod_event(module_t, int, void *);
 281
 282 static struct ng_type ng_ccatm_typestruct = {
 283         .version =      NG_ABI_VERSION,
 284         .name =         NG_CCATM_NODE_TYPE,
 285         .mod_event =    ng_ccatm_mod_event,
 286         .constructor =  ng_ccatm_constructor,   /* Node constructor */
 287         .rcvmsg =       ng_ccatm_rcvmsg,        /* Control messages */
 288         .shutdown =     ng_ccatm_shutdown,      /* Node destructor */
 289         .newhook =      ng_ccatm_newhook,       /* Arrival of new hook */
 290         .rcvdata =      ng_ccatm_rcvdata,       /* receive data */
 291         .disconnect =   ng_ccatm_disconnect,    /* disconnect a hook */
 292         .cmdlist =      ng_ccatm_cmdlist,
 293 };
 294 NETGRAPH_INIT(ccatm, &ng_ccatm_typestruct);
 295
 296 static ng_rcvdata_t     ng_ccatm_rcvuni;
 297 static ng_rcvdata_t     ng_ccatm_rcvdump;
 298 static ng_rcvdata_t     ng_ccatm_rcvmanage;
 299
 300 /*
 301  * Private node data.
 302  */
 303 struct ccnode {
 304         node_p  node;           /* the owning node */
 305         hook_p  dump;           /* dump hook */
 306         hook_p  manage;         /* hook to ILMI */
 307
 308         struct ccdata *data;
 309         struct mbuf *dump_first;
 310         struct mbuf *dump_last; /* first and last mbuf when dumping */
 311
 312         u_int   hook_cnt;       /* count user and port hooks */
 313 };
 314
 315 /*
 316  * Private UNI hook data
 317  */
 318 struct cchook {
 319         int             is_uni; /* true if uni hook, user otherwise */
 320         struct ccnode   *node;  /* the owning node */
 321         hook_p          hook;
 322         void            *inst;  /* port or user */
 323 };
 324
 325 static void ng_ccatm_send_user(struct ccuser *, void *, u_int, void *, size_t);
 326 static void ng_ccatm_respond_user(struct ccuser *, void *, int, u_int,
 327     void *, size_t);
 328 static void ng_ccatm_send_uni(struct ccconn *, void *, u_int, u_int,
 329     struct uni_msg *);
 330 static void ng_ccatm_send_uni_glob(struct ccport *, void *, u_int, u_int,
 331     struct uni_msg *);
 332 static void ng_ccatm_log(const char *, ...) __printflike(1, 2);
 333
 334 static const struct cc_funcs cc_funcs = {
 335         .send_user =            ng_ccatm_send_user,
 336         .respond_user =         ng_ccatm_respond_user,
 337         .send_uni =             ng_ccatm_send_uni,
 338         .send_uni_glob =        ng_ccatm_send_uni_glob,
 339         .log =                  ng_ccatm_log,
 340 };
 341
 342 /************************************************************
 343  *
 344  * Create a new node
 345  */
 346 static int
 347 ng_ccatm_constructor(node_p node)
 348 {
 349         struct ccnode *priv;
 350
 351         priv = malloc(sizeof(*priv), M_NG_CCATM, M_WAITOK | M_ZERO);
 352
 353         priv->node = node;
 354         priv->data = cc_create(&cc_funcs);
 355         if (priv->data == NULL) {
 356                 free(priv, M_NG_CCATM);
 357                 return (ENOMEM);
 358         }
 359
 360         NG_NODE_SET_PRIVATE(node, priv);
 361
 362         return (0);
 363 }
 364
 365 /*
 366  * Destroy a node. The user list is empty here, because all hooks are
 367  * previously disconnected. The connection lists may not be empty, because
 368  * connections may be waiting for responses from the stack. This also means,
 369  * that no orphaned connections will be made by the port_destroy routine.
 370  */
 371 static int
 372 ng_ccatm_shutdown(node_p node)
 373 {
 374         struct ccnode *priv = NG_NODE_PRIVATE(node);
 375
 376         cc_destroy(priv->data);
 377
 378         free(priv, M_NG_CCATM);
 379         NG_NODE_SET_PRIVATE(node, NULL);
 380
 381         NG_NODE_UNREF(node);
 382
 383         return (0);
 384 }
 385
 386 /*
 387  * Retrieve the registered addresses for one port or all ports.
 388  * Returns an error code or 0 on success.
 389  */
 390 static int
 391 ng_ccatm_get_addresses(node_p node, uint32_t portno, struct ng_mesg *msg,
 392     struct ng_mesg **resp)
 393 {
 394         struct ccnode *priv = NG_NODE_PRIVATE(node);
 395         struct uni_addr *addrs;
 396         u_int *ports;
 397         struct ngm_ccatm_get_addresses *list;
 398         u_int count, i;
 399         size_t len;
 400         int err;
 401
 402         err = cc_get_addrs(priv->data, portno, &addrs, &ports, &count);
 403         if (err != 0)
 404                 return (err);
 405
 406         len = sizeof(*list) + count * sizeof(list->addr[0]);
 407         NG_MKRESPONSE(*resp, msg, len, M_NOWAIT);
 408         if (*resp == NULL) {
 409                 free(addrs, M_NG_CCATM);
 410                 free(ports, M_NG_CCATM);
 411                 return (ENOMEM);
 412         }
 413         list = (struct ngm_ccatm_get_addresses *)(*resp)->data;
 414
 415         list->count = count;
 416         for (i = 0; i < count; i++) {
 417                 list->addr[i].port = ports[i];
 418                 list->addr[i].addr = addrs[i];
 419         }
 420
 421         free(addrs, M_NG_CCATM);
 422         free(ports, M_NG_CCATM);
 423
 424         return (0);
 425 }
 426
 427 /*
 428  * Dumper function. Pack the data into an mbuf chain.
 429  */
 430 static int
 431 send_dump(struct ccdata *data, void *uarg, const char *buf)
 432 {
 433         struct mbuf *m;
 434         struct ccnode *priv = uarg;
 435
 436         if (priv->dump == NULL) {
 437                 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
 438                 if (m == NULL)
 439                         return (ENOBUFS);
 440                 priv->dump_first = priv->dump_last = m;
 441                 m->m_pkthdr.len = 0;
 442         } else {
 443                 m = m_getcl(M_NOWAIT, MT_DATA, 0);
 444                 if (m == NULL) {
 445                         m_freem(priv->dump_first);
 446                         return (ENOBUFS);
 447                 }
 448                 priv->dump_last->m_next = m;
 449                 priv->dump_last = m;
 450         }
 451
 452         strcpy(m->m_data, buf);
 453         priv->dump_first->m_pkthdr.len += (m->m_len = strlen(buf));
 454
 455         return (0);
 456 }
 457
 458 /*
 459  * Dump current status to dump hook
 460  */
 461 static int
 462 ng_ccatm_dump(node_p node)
 463 {
 464         struct ccnode *priv = NG_NODE_PRIVATE(node);
 465         struct mbuf *m;
 466         int error;
 467
 468         priv->dump_first = priv->dump_last = NULL;
 469         error = cc_dump(priv->data, MCLBYTES, send_dump, priv);
 470         if (error != 0)
 471                 return (error);
 472
 473         if ((m = priv->dump_first) != NULL) {
 474                 priv->dump_first = priv->dump_last = NULL;
 475                 NG_SEND_DATA_ONLY(error, priv->dump, m);
 476                 return (error);
 477         }
 478         return (0);
 479 }
 480
 481 /*
 482  * Control message
 483  */
 484 static int
 485 ng_ccatm_rcvmsg(node_p node, item_p item, hook_p lasthook)
 486 {
 487         struct ng_mesg *resp = NULL;
 488         struct ng_mesg *msg;
 489         struct ccnode *priv = NG_NODE_PRIVATE(node);
 490         int error = 0;
 491
 492         NGI_GET_MSG(item, msg);
 493
 494         switch (msg->header.typecookie) {
 495           case NGM_CCATM_COOKIE:
 496                 switch (msg->header.cmd) {
 497                   case NGM_CCATM_DUMP:
 498                         if (priv->dump)
 499                                 error = ng_ccatm_dump(node);
 500                         else
 501                                 error = ENOTCONN;
 502                         break;
 503
 504                   case NGM_CCATM_STOP:
 505                     {
 506                         struct ngm_ccatm_port *arg;
 507
 508                         if (msg->header.arglen != sizeof(*arg)) {
 509                                 error = EINVAL;
 510                                 break;
 511                         }
 512                         arg = (struct ngm_ccatm_port *)msg->data;
 513                         error = cc_port_stop(priv->data, arg->port);
 514                         break;
 515                     }
 516
 517                   case NGM_CCATM_START:
 518                     {
 519                         struct ngm_ccatm_port *arg;
 520
 521                         if (msg->header.arglen != sizeof(*arg)) {
 522                                 error = EINVAL;
 523                                 break;
 524                         }
 525                         arg = (struct ngm_ccatm_port *)msg->data;
 526                         error = cc_port_start(priv->data, arg->port);
 527                         break;
 528                     }
 529
 530                   case NGM_CCATM_GETSTATE:
 531                     {
 532                         struct ngm_ccatm_port *arg;
 533                         int state;
 534
 535                         if (msg->header.arglen != sizeof(*arg)) {
 536                                 error = EINVAL;
 537                                 break;
 538                         }
 539                         arg = (struct ngm_ccatm_port *)msg->data;
 540                         error = cc_port_isrunning(priv->data, arg->port,
 541                             &state);
 542                         if (error == 0) {
 543                                 NG_MKRESPONSE(resp, msg, sizeof(uint32_t),
 544                                     M_NOWAIT);
 545                                 if (resp == NULL) {
 546                                         error = ENOMEM;
 547                                         break;
 548                                 }
 549                                 *(uint32_t *)resp->data = state;
 550                         }
 551                         break;
 552                     }
 553
 554                   case NGM_CCATM_GET_ADDRESSES:
 555                    {
 556                         struct ngm_ccatm_port *arg;
 557
 558                         if (msg->header.arglen != sizeof(*arg)) {
 559                                 error = EINVAL;
 560                                 break;
 561                         }
 562                         arg = (struct ngm_ccatm_port *)msg->data;
 563                         error = ng_ccatm_get_addresses(node, arg->port, msg,
 564                             &resp);
 565                         break;
 566                     }
 567
 568                   case NGM_CCATM_CLEAR:
 569                     {
 570                         struct ngm_ccatm_port *arg;
 571
 572                         if (msg->header.arglen != sizeof(*arg)) {
 573                                 error = EINVAL;
 574                                 break;
 575                         }
 576                         arg = (struct ngm_ccatm_port *)msg->data;
 577                         error = cc_port_clear(priv->data, arg->port);
 578                         break;
 579                     }
 580
 581                   case NGM_CCATM_ADDRESS_REGISTERED:
 582                     {
 583                         struct ngm_ccatm_addr_req *arg;
 584
 585                         if (msg->header.arglen != sizeof(*arg)) {
 586                                 error = EINVAL;
 587                                 break;
 588                         }
 589                         arg = (struct ngm_ccatm_addr_req *)msg->data;
 590                         error = cc_addr_register(priv->data, arg->port,
 591                             &arg->addr);
 592                         break;
 593                     }
 594
 595                   case NGM_CCATM_ADDRESS_UNREGISTERED:
 596                     {
 597                         struct ngm_ccatm_addr_req *arg;
 598
 599                         if (msg->header.arglen != sizeof(*arg)) {
 600                                 error = EINVAL;
 601                                 break;
 602                         }
 603                         arg = (struct ngm_ccatm_addr_req *)msg->data;
 604                         error = cc_addr_unregister(priv->data, arg->port,
 605                             &arg->addr);
 606                         break;
 607                     }
 608
 609                   case NGM_CCATM_GET_PORT_PARAM:
 610                     {
 611                         struct ngm_ccatm_port *arg;
 612
 613                         if (msg->header.arglen != sizeof(*arg)) {
 614                                 error = EINVAL;
 615                                 break;
 616                         }
 617                         arg = (struct ngm_ccatm_port *)msg->data;
 618                         NG_MKRESPONSE(resp, msg, sizeof(struct atm_port_info),
 619                             M_NOWAIT);
 620                         if (resp == NULL) {
 621                                 error = ENOMEM;
 622                                 break;
 623                         }
 624                         error = cc_port_get_param(priv->data, arg->port,
 625                             (struct atm_port_info *)resp->data);
 626                         if (error != 0) {
 627                                 free(resp, M_NETGRAPH_MSG);
 628                                 resp = NULL;
 629                         }
 630                         break;
 631                     }
 632
 633                   case NGM_CCATM_SET_PORT_PARAM:
 634                     {
 635                         struct atm_port_info *arg;
 636
 637                         if (msg->header.arglen != sizeof(*arg)) {
 638                                 error = EINVAL;
 639                                 break;
 640                         }
 641                         arg = (struct atm_port_info *)msg->data;
 642                         error = cc_port_set_param(priv->data, arg);
 643                         break;
 644                     }
 645
 646                   case NGM_CCATM_GET_PORTLIST:
 647                     {
 648                         struct ngm_ccatm_portlist *arg;
 649                         u_int n, *ports;
 650
 651                         if (msg->header.arglen != 0) {
 652                                 error = EINVAL;
 653                                 break;
 654                         }
 655                         error = cc_port_getlist(priv->data, &n, &ports);
 656                         if (error != 0)
 657                                 break;
 658
 659                         NG_MKRESPONSE(resp, msg, sizeof(*arg) +
 660                             n * sizeof(arg->ports[0]), M_NOWAIT);
 661                         if (resp == NULL) {
 662                                 free(ports, M_NG_CCATM);
 663                                 error = ENOMEM;
 664                                 break;
 665                         }
 666                         arg = (struct ngm_ccatm_portlist *)resp->data;
 667
 668                         arg->nports = 0;
 669                         for (arg->nports = 0; arg->nports < n; arg->nports++)
 670                                 arg->ports[arg->nports] = ports[arg->nports];
 671                         free(ports, M_NG_CCATM);
 672                         break;
 673                     }
 674
 675                   case NGM_CCATM_SETLOG:
 676                     {
 677                         uint32_t log_level;
 678
 679                         log_level = cc_get_log(priv->data);
 680                         if (msg->header.arglen != 0) {
 681                                 if (msg->header.arglen != sizeof(log_level)) {
 682                                         error = EINVAL;
 683                                         break;
 684                                 }
 685                                 cc_set_log(priv->data, *(uint32_t *)msg->data);
 686                         }
 687
 688                         NG_MKRESPONSE(resp, msg, sizeof(uint32_t), M_NOWAIT);
 689                         if (resp == NULL) {
 690                                 error = ENOMEM;
 691                                 if (msg->header.arglen != 0)
 692                                         cc_set_log(priv->data, log_level);
 693                                 break;
 694                         }
 695                         *(uint32_t *)resp->data = log_level;
 696                         break;
 697                     }
 698
 699                   case NGM_CCATM_RESET:
 700                         if (msg->header.arglen != 0) {
 701                                 error = EINVAL;
 702                                 break;
 703                         }
 704
 705                         if (priv->hook_cnt != 0) {
 706                                 error = EBUSY;
 707                                 break;
 708                         }
 709                         cc_reset(priv->data);
 710                         break;
 711
 712                   case NGM_CCATM_GET_EXSTAT:
 713                     {
 714                         struct atm_exstatus s;
 715                         struct atm_exstatus_ep *eps;
 716                         struct atm_exstatus_port *ports;
 717                         struct atm_exstatus_conn *conns;
 718                         struct atm_exstatus_party *parties;
 719                         size_t offs;
 720
 721                         if (msg->header.arglen != 0) {
 722                                 error = EINVAL;
 723                                 break;
 724                         }
 725                         error = cc_get_extended_status(priv->data,
 726                             &s, &eps, &ports, &conns, &parties);
 727                         if (error != 0)
 728                                 break;
 729
 730                         offs = sizeof(s) + s.neps * sizeof(*eps) +
 731                             s.nports * sizeof(*ports) +
 732                             s.nconns * sizeof(*conns) +
 733                             s.nparties * sizeof(*parties);
 734
 735                         NG_MKRESPONSE(resp, msg, offs, M_NOWAIT);
 736                         if (resp == NULL) {
 737                                 error = ENOMEM;
 738                                 break;
 739                         }
 740
 741                         memcpy(resp->data, &s, sizeof(s));
 742                         offs = sizeof(s);
 743
 744                         memcpy(resp->data + offs, eps,
 745                             sizeof(*eps) * s.neps);
 746                         offs += sizeof(*eps) * s.neps;
 747
 748                         memcpy(resp->data + offs, ports,
 749                             sizeof(*ports) * s.nports);
 750                         offs += sizeof(*ports) * s.nports;
 751
 752                         memcpy(resp->data + offs, conns,
 753                             sizeof(*conns) * s.nconns);
 754                         offs += sizeof(*conns) * s.nconns;
 755
 756                         memcpy(resp->data + offs, parties,
 757                             sizeof(*parties) * s.nparties);
 758                         offs += sizeof(*parties) * s.nparties;
 759
 760                         free(eps, M_NG_CCATM);
 761                         free(ports, M_NG_CCATM);
 762                         free(conns, M_NG_CCATM);
 763                         free(parties, M_NG_CCATM);
 764                         break;
 765                     }
 766
 767                   default:
 768                         error = EINVAL;
 769                         break;
 770                 }
 771                 break;
 772
 773           default:
 774                 error = EINVAL;
 775                 break;
 776         }
 777
 778         NG_RESPOND_MSG(error, node, item, resp);
 779         NG_FREE_MSG(msg);
 780         return (error);
 781 }
 782
 783 /************************************************************
 784  *
 785  * New hook arrival
 786  */
 787 static int
 788 ng_ccatm_newhook(node_p node, hook_p hook, const char *name)
 789 {
 790         struct ccnode *priv = NG_NODE_PRIVATE(node);
 791         struct ccport *port;
 792         struct ccuser *user;
 793         struct cchook *hd;
 794         u_long lport;
 795         char *end;
 796
 797         if (strncmp(name, "uni", 3) == 0) {
 798                 /*
 799                  * This is a UNI hook. Should be a new port.
 800                  */
 801                 if (name[3] == '\0')
 802                         return (EINVAL);
 803                 lport = strtoul(name + 3, &end, 10);
 804                 if (*end != '\0' || lport == 0 || lport > 0xffffffff)
 805                         return (EINVAL);
 806
 807                 hd = malloc(sizeof(*hd), M_NG_CCATM, M_NOWAIT);
 808                 if (hd == NULL)
 809                         return (ENOMEM);
 810                 hd->is_uni = 1;
 811                 hd->node = priv;
 812                 hd->hook = hook;
 813
 814                 port = cc_port_create(priv->data, hd, (u_int)lport);
 815                 if (port == NULL) {
 816                         free(hd, M_NG_CCATM);
 817                         return (ENOMEM);
 818                 }
 819                 hd->inst = port;
 820
 821                 NG_HOOK_SET_PRIVATE(hook, hd);
 822                 NG_HOOK_SET_RCVDATA(hook, ng_ccatm_rcvuni);
 823                 NG_HOOK_FORCE_QUEUE(hook);
 824
 825                 priv->hook_cnt++;
 826
 827                 return (0);
 828         }
 829
 830         if (strcmp(name, "dump") == 0) {
 831                 priv->dump = hook;
 832                 NG_HOOK_SET_RCVDATA(hook, ng_ccatm_rcvdump);
 833                 return (0);
 834         }
 835
 836         if (strcmp(name, "manage") == 0) {
 837                 priv->manage = hook;
 838                 NG_HOOK_SET_RCVDATA(hook, ng_ccatm_rcvmanage);
 839                 return (0);
 840         }
 841
 842         /*
 843          * User hook
 844          */
 845         hd = malloc(sizeof(*hd), M_NG_CCATM, M_NOWAIT);
 846         if (hd == NULL)
 847                 return (ENOMEM);
 848         hd->is_uni = 0;
 849         hd->node = priv;
 850         hd->hook = hook;
 851
 852         user = cc_user_create(priv->data, hd, NG_HOOK_NAME(hook));
 853         if (user == NULL) {
 854                 free(hd, M_NG_CCATM);
 855                 return (ENOMEM);
 856         }
 857
 858         hd->inst = user;
 859         NG_HOOK_SET_PRIVATE(hook, hd);
 860         NG_HOOK_FORCE_QUEUE(hook);
 861
 862         priv->hook_cnt++;
 863
 864         return (0);
 865 }
 866
 867 /*
 868  * Disconnect a hook
 869  */
 870 static int
 871 ng_ccatm_disconnect(hook_p hook)
 872 {
 873         node_p node = NG_HOOK_NODE(hook);
 874         struct ccnode *priv = NG_NODE_PRIVATE(node);
 875         struct cchook *hd = NG_HOOK_PRIVATE(hook);
 876         struct ccdata *cc;
 877
 878         if (hook == priv->dump) {
 879                 priv->dump = NULL;
 880
 881         } else if (hook == priv->manage) {
 882                 priv->manage = NULL;
 883                 cc_unmanage(priv->data);
 884
 885         } else {
 886                 if (hd->is_uni)
 887                         cc_port_destroy(hd->inst, 0);
 888                 else
 889                         cc_user_destroy(hd->inst);
 890
 891                 cc = hd->node->data;
 892
 893                 free(hd, M_NG_CCATM);
 894                 NG_HOOK_SET_PRIVATE(hook, NULL);
 895
 896                 priv->hook_cnt--;
 897
 898                 cc_work(cc);
 899         }
 900
 901         /*
 902          * When the number of hooks drops to zero, delete the node.
 903          */
 904         if (NG_NODE_NUMHOOKS(node) == 0 && NG_NODE_IS_VALID(node))
 905                 ng_rmnode_self(node);
 906
 907         return (0);
 908 }
 909
 910 /************************************************************
 911  *
 912  * Receive data from user hook
 913  */
 914 static int
 915 ng_ccatm_rcvdata(hook_p hook, item_p item)
 916 {
 917         struct cchook *hd = NG_HOOK_PRIVATE(hook);
 918         struct uni_msg *msg;
 919         struct mbuf *m;
 920         struct ccatm_op op;
 921         int err;
 922
 923         NGI_GET_M(item, m);
 924         NG_FREE_ITEM(item);
 925
 926         if ((err = uni_msg_unpack_mbuf(m, &msg)) != 0) {
 927                 m_freem(m);
 928                 return (err);
 929         }
 930         m_freem(m);
 931
 932         if (uni_msg_len(msg) < sizeof(op)) {
 933                 printf("%s: packet too short\n", __func__);
 934                 uni_msg_destroy(msg);
 935                 return (EINVAL);
 936         }
 937
 938         bcopy(msg->b_rptr, &op, sizeof(op));
 939         msg->b_rptr += sizeof(op);
 940
 941         err = cc_user_signal(hd->inst, op.op, msg);
 942         cc_work(hd->node->data);
 943         return (err);
 944 }
 945
 946 /*
 947  * Pack a header and a data area into an mbuf chain
 948  */
 949 static struct mbuf *
 950 pack_buf(void *h, size_t hlen, void *t, size_t tlen)
 951 {
 952         struct mbuf *m, *m0, *last;
 953         u_char *buf = (u_char *)t;
 954         size_t n;
 955
 956         /* header should fit into a normal mbuf */
 957         MGETHDR(m0, M_NOWAIT, MT_DATA);
 958         if (m0 == NULL)
 959                 return NULL;
 960
 961         KASSERT(hlen <= MHLEN, ("hlen > MHLEN"));
 962
 963         bcopy(h, m0->m_data, hlen);
 964         m0->m_len = hlen;
 965         m0->m_pkthdr.len = hlen;
 966
 967         last = m0;
 968         while ((n = tlen) != 0) {
 969                 if (n > MLEN) {
 970                         m = m_getcl(M_NOWAIT, MT_DATA, 0);
 971                         if (n > MCLBYTES)
 972                                 n = MCLBYTES;
 973                 } else
 974                         MGET(m, M_NOWAIT, MT_DATA);
 975
 976                 if(m == NULL)
 977                         goto drop;
 978
 979                 last->m_next = m;
 980                 last = m;
 981
 982                 bcopy(buf, m->m_data, n);
 983                 buf += n;
 984                 tlen -= n;
 985                 m->m_len = n;
 986                 m0->m_pkthdr.len += n;
 987         }
 988
 989         return (m0);
 990
 991   drop:
 992         m_freem(m0);
 993         return NULL;
 994 }
 995
 996 /*
 997  * Send an indication to the user.
 998  */
 999 static void
1000 ng_ccatm_send_user(struct ccuser *user, void *uarg, u_int op,
1001     void *val, size_t len)
1002 {
1003         struct cchook *hd = uarg;
1004         struct mbuf *m;
1005         struct ccatm_op h;
1006         int error;
1007
1008         h.op = op;
1009         m = pack_buf(&h, sizeof(h), val, len);
1010         if (m == NULL)
1011                 return;
1012
1013         NG_SEND_DATA_ONLY(error, hd->hook, m);
1014         if (error != 0)
1015                 printf("%s: error=%d\n", __func__, error);
1016 }
1017
1018 /*
1019  * Send a response to the user.
1020  */
1021 static void
1022 ng_ccatm_respond_user(struct ccuser *user, void *uarg, int err, u_int data,
1023     void *val, size_t len)
1024 {
1025         struct cchook *hd = uarg;
1026         struct mbuf *m;
1027         struct {
1028                 struct ccatm_op op;
1029                 struct atm_resp resp;
1030         } resp;
1031         int error;
1032
1033         resp.op.op = ATMOP_RESP;
1034         resp.resp.resp = err;
1035         resp.resp.data = data;
1036         m = pack_buf(&resp, sizeof(resp), val, len);
1037         if (m == NULL)
1038                 return;
1039
1040         NG_SEND_DATA_ONLY(error, hd->hook, m);
1041         if (error != 0)
1042                 printf("%s: error=%d\n", __func__, error);
1043 }
1044
1045 /*
1046  * Receive data from UNI.
1047  */
1048 static int
1049 ng_ccatm_rcvuni(hook_p hook, item_p item)
1050 {
1051         struct cchook *hd = NG_HOOK_PRIVATE(hook);
1052         struct uni_msg *msg;
1053         struct uni_arg arg;
1054         struct mbuf *m;
1055         int err;
1056
1057         NGI_GET_M(item, m);
1058         NG_FREE_ITEM(item);
1059
1060         if ((err = uni_msg_unpack_mbuf(m, &msg)) != 0) {
1061                 m_freem(m);
1062                 return (err);
1063         }
1064         m_freem(m);
1065
1066         if (uni_msg_len(msg) < sizeof(arg)) {
1067                 printf("%s: packet too short\n", __func__);
1068                 uni_msg_destroy(msg);
1069                 return (EINVAL);
1070         }
1071
1072         bcopy(msg->b_rptr, &arg, sizeof(arg));
1073         msg->b_rptr += sizeof(arg);
1074
1075         if (arg.sig == UNIAPI_ERROR) {
1076                 if (uni_msg_len(msg) != sizeof(struct uniapi_error)) {
1077                         printf("%s: bad UNIAPI_ERROR size %zu\n", __func__,
1078                             uni_msg_len(msg));
1079                         uni_msg_destroy(msg);
1080                         return (EINVAL);
1081                 }
1082                 err = cc_uni_response(hd->inst, arg.cookie,
1083                     ((struct uniapi_error *)msg->b_rptr)->reason,
1084                     ((struct uniapi_error *)msg->b_rptr)->state);
1085                 uni_msg_destroy(msg);
1086         } else
1087                 err = cc_uni_signal(hd->inst, arg.cookie, arg.sig, msg);
1088
1089         cc_work(hd->node->data);
1090         return (err);
1091 }
1092
1093 /*
1094  * Uarg is the port's uarg.
1095  */
1096 static void
1097 ng_ccatm_send_uni(struct ccconn *conn, void *uarg, u_int op, u_int cookie,
1098     struct uni_msg *msg)
1099 {
1100         struct cchook *hd = uarg;
1101         struct uni_arg arg;
1102         struct mbuf *m;
1103         int error;
1104
1105         arg.sig = op;
1106         arg.cookie = cookie;
1107
1108         m = uni_msg_pack_mbuf(msg, &arg, sizeof(arg));
1109         uni_msg_destroy(msg);
1110         if (m == NULL)
1111                 return;
1112
1113         NG_SEND_DATA_ONLY(error, hd->hook, m);
1114         if (error != 0)
1115                 printf("%s: error=%d\n", __func__, error);
1116 }
1117
1118 /*
1119  * Send a global message to the UNI
1120  */
1121 static void
1122 ng_ccatm_send_uni_glob(struct ccport *port, void *uarg, u_int op, u_int cookie,
1123     struct uni_msg *msg)
1124 {
1125         struct cchook *hd = uarg;
1126         struct uni_arg arg;
1127         struct mbuf *m;
1128         int error;
1129
1130         arg.sig = op;
1131         arg.cookie = cookie;
1132
1133         m = uni_msg_pack_mbuf(msg, &arg, sizeof(arg));
1134         if (msg != NULL)
1135                 uni_msg_destroy(msg);
1136         if (m == NULL)
1137                 return;
1138
1139         NG_SEND_DATA_ONLY(error, hd->hook, m);
1140         if (error != 0)
1141                 printf("%s: error=%d\n", __func__, error);
1142 }
1143 /*
1144  * Receive from ILMID
1145  */
1146 static int
1147 ng_ccatm_rcvmanage(hook_p hook, item_p item)
1148 {
1149         NG_FREE_ITEM(item);
1150         return (0);
1151 }
1152
1153 static int
1154 ng_ccatm_rcvdump(hook_p hook, item_p item)
1155 {
1156         NG_FREE_ITEM(item);
1157         return (0);
1158 }
1159
1160 static void
1161 ng_ccatm_log(const char *fmt, ...)
1162 {
1163         va_list ap;
1164
1165         va_start(ap, fmt);
1166         vprintf(fmt, ap);
1167         printf("\n");
1168         va_end(ap);
1169 }
1170
1171 /*
1172  * Loading and unloading of node type
1173  */
1174 static int
1175 ng_ccatm_mod_event(module_t mod, int event, void *data)
1176 {
1177         int error = 0;
1178
1179         switch (event) {
1180           case MOD_LOAD:
1181                 break;
1182
1183           case MOD_UNLOAD:
1184                 break;
1185
1186           default:
1187                 error = EOPNOTSUPP;
1188                 break;
1189         }
1190         return (error);
1191 }