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         gone_in(14, "ng_ccatm: netgraph ATM modules");
 352
 353         priv = malloc(sizeof(*priv), M_NG_CCATM, M_WAITOK | M_ZERO);
 354
 355         priv->node = node;
 356         priv->data = cc_create(&cc_funcs);
 357         if (priv->data == NULL) {
 358                 free(priv, M_NG_CCATM);
 359                 return (ENOMEM);
 360         }
 361
 362         NG_NODE_SET_PRIVATE(node, priv);
 363
 364         return (0);
 365 }
 366
 367 /*
 368  * Destroy a node. The user list is empty here, because all hooks are
 369  * previously disconnected. The connection lists may not be empty, because
 370  * connections may be waiting for responses from the stack. This also means,
 371  * that no orphaned connections will be made by the port_destroy routine.
 372  */
 373 static int
 374 ng_ccatm_shutdown(node_p node)
 375 {
 376         struct ccnode *priv = NG_NODE_PRIVATE(node);
 377
 378         cc_destroy(priv->data);
 379
 380         free(priv, M_NG_CCATM);
 381         NG_NODE_SET_PRIVATE(node, NULL);
 382
 383         NG_NODE_UNREF(node);
 384
 385         return (0);
 386 }
 387
 388 /*
 389  * Retrieve the registered addresses for one port or all ports.
 390  * Returns an error code or 0 on success.
 391  */
 392 static int
 393 ng_ccatm_get_addresses(node_p node, uint32_t portno, struct ng_mesg *msg,
 394     struct ng_mesg **resp)
 395 {
 396         struct ccnode *priv = NG_NODE_PRIVATE(node);
 397         struct uni_addr *addrs;
 398         u_int *ports;
 399         struct ngm_ccatm_get_addresses *list;
 400         u_int count, i;
 401         size_t len;
 402         int err;
 403
 404         err = cc_get_addrs(priv->data, portno, &addrs, &ports, &count);
 405         if (err != 0)
 406                 return (err);
 407
 408         len = sizeof(*list) + count * sizeof(list->addr[0]);
 409         NG_MKRESPONSE(*resp, msg, len, M_NOWAIT);
 410         if (*resp == NULL) {
 411                 free(addrs, M_NG_CCATM);
 412                 free(ports, M_NG_CCATM);
 413                 return (ENOMEM);
 414         }
 415         list = (struct ngm_ccatm_get_addresses *)(*resp)->data;
 416
 417         list->count = count;
 418         for (i = 0; i < count; i++) {
 419                 list->addr[i].port = ports[i];
 420                 list->addr[i].addr = addrs[i];
 421         }
 422
 423         free(addrs, M_NG_CCATM);
 424         free(ports, M_NG_CCATM);
 425
 426         return (0);
 427 }
 428
 429 /*
 430  * Dumper function. Pack the data into an mbuf chain.
 431  */
 432 static int
 433 send_dump(struct ccdata *data, void *uarg, const char *buf)
 434 {
 435         struct mbuf *m;
 436         struct ccnode *priv = uarg;
 437
 438         if (priv->dump == NULL) {
 439                 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
 440                 if (m == NULL)
 441                         return (ENOBUFS);
 442                 priv->dump_first = priv->dump_last = m;
 443                 m->m_pkthdr.len = 0;
 444         } else {
 445                 m = m_getcl(M_NOWAIT, MT_DATA, 0);
 446                 if (m == NULL) {
 447                         m_freem(priv->dump_first);
 448                         return (ENOBUFS);
 449                 }
 450                 priv->dump_last->m_next = m;
 451                 priv->dump_last = m;
 452         }
 453
 454         strcpy(m->m_data, buf);
 455         priv->dump_first->m_pkthdr.len += (m->m_len = strlen(buf));
 456
 457         return (0);
 458 }
 459
 460 /*
 461  * Dump current status to dump hook
 462  */
 463 static int
 464 ng_ccatm_dump(node_p node)
 465 {
 466         struct ccnode *priv = NG_NODE_PRIVATE(node);
 467         struct mbuf *m;
 468         int error;
 469
 470         priv->dump_first = priv->dump_last = NULL;
 471         error = cc_dump(priv->data, MCLBYTES, send_dump, priv);
 472         if (error != 0)
 473                 return (error);
 474
 475         if ((m = priv->dump_first) != NULL) {
 476                 priv->dump_first = priv->dump_last = NULL;
 477                 NG_SEND_DATA_ONLY(error, priv->dump, m);
 478                 return (error);
 479         }
 480         return (0);
 481 }
 482
 483 /*
 484  * Control message
 485  */
 486 static int
 487 ng_ccatm_rcvmsg(node_p node, item_p item, hook_p lasthook)
 488 {
 489         struct ng_mesg *resp = NULL;
 490         struct ng_mesg *msg;
 491         struct ccnode *priv = NG_NODE_PRIVATE(node);
 492         int error = 0;
 493
 494         NGI_GET_MSG(item, msg);
 495
 496         switch (msg->header.typecookie) {
 497           case NGM_CCATM_COOKIE:
 498                 switch (msg->header.cmd) {
 499                   case NGM_CCATM_DUMP:
 500                         if (priv->dump)
 501                                 error = ng_ccatm_dump(node);
 502                         else
 503                                 error = ENOTCONN;
 504                         break;
 505
 506                   case NGM_CCATM_STOP:
 507                     {
 508                         struct ngm_ccatm_port *arg;
 509
 510                         if (msg->header.arglen != sizeof(*arg)) {
 511                                 error = EINVAL;
 512                                 break;
 513                         }
 514                         arg = (struct ngm_ccatm_port *)msg->data;
 515                         error = cc_port_stop(priv->data, arg->port);
 516                         break;
 517                     }
 518
 519                   case NGM_CCATM_START:
 520                     {
 521                         struct ngm_ccatm_port *arg;
 522
 523                         if (msg->header.arglen != sizeof(*arg)) {
 524                                 error = EINVAL;
 525                                 break;
 526                         }
 527                         arg = (struct ngm_ccatm_port *)msg->data;
 528                         error = cc_port_start(priv->data, arg->port);
 529                         break;
 530                     }
 531
 532                   case NGM_CCATM_GETSTATE:
 533                     {
 534                         struct ngm_ccatm_port *arg;
 535                         int state;
 536
 537                         if (msg->header.arglen != sizeof(*arg)) {
 538                                 error = EINVAL;
 539                                 break;
 540                         }
 541                         arg = (struct ngm_ccatm_port *)msg->data;
 542                         error = cc_port_isrunning(priv->data, arg->port,
 543                             &state);
 544                         if (error == 0) {
 545                                 NG_MKRESPONSE(resp, msg, sizeof(uint32_t),
 546                                     M_NOWAIT);
 547                                 if (resp == NULL) {
 548                                         error = ENOMEM;
 549                                         break;
 550                                 }
 551                                 *(uint32_t *)resp->data = state;
 552                         }
 553                         break;
 554                     }
 555
 556                   case NGM_CCATM_GET_ADDRESSES:
 557                    {
 558                         struct ngm_ccatm_port *arg;
 559
 560                         if (msg->header.arglen != sizeof(*arg)) {
 561                                 error = EINVAL;
 562                                 break;
 563                         }
 564                         arg = (struct ngm_ccatm_port *)msg->data;
 565                         error = ng_ccatm_get_addresses(node, arg->port, msg,
 566                             &resp);
 567                         break;
 568                     }
 569
 570                   case NGM_CCATM_CLEAR:
 571                     {
 572                         struct ngm_ccatm_port *arg;
 573
 574                         if (msg->header.arglen != sizeof(*arg)) {
 575                                 error = EINVAL;
 576                                 break;
 577                         }
 578                         arg = (struct ngm_ccatm_port *)msg->data;
 579                         error = cc_port_clear(priv->data, arg->port);
 580                         break;
 581                     }
 582
 583                   case NGM_CCATM_ADDRESS_REGISTERED:
 584                     {
 585                         struct ngm_ccatm_addr_req *arg;
 586
 587                         if (msg->header.arglen != sizeof(*arg)) {
 588                                 error = EINVAL;
 589                                 break;
 590                         }
 591                         arg = (struct ngm_ccatm_addr_req *)msg->data;
 592                         error = cc_addr_register(priv->data, arg->port,
 593                             &arg->addr);
 594                         break;
 595                     }
 596
 597                   case NGM_CCATM_ADDRESS_UNREGISTERED:
 598                     {
 599                         struct ngm_ccatm_addr_req *arg;
 600
 601                         if (msg->header.arglen != sizeof(*arg)) {
 602                                 error = EINVAL;
 603                                 break;
 604                         }
 605                         arg = (struct ngm_ccatm_addr_req *)msg->data;
 606                         error = cc_addr_unregister(priv->data, arg->port,
 607                             &arg->addr);
 608                         break;
 609                     }
 610
 611                   case NGM_CCATM_GET_PORT_PARAM:
 612                     {
 613                         struct ngm_ccatm_port *arg;
 614
 615                         if (msg->header.arglen != sizeof(*arg)) {
 616                                 error = EINVAL;
 617                                 break;
 618                         }
 619                         arg = (struct ngm_ccatm_port *)msg->data;
 620                         NG_MKRESPONSE(resp, msg, sizeof(struct atm_port_info),
 621                             M_NOWAIT);
 622                         if (resp == NULL) {
 623                                 error = ENOMEM;
 624                                 break;
 625                         }
 626                         error = cc_port_get_param(priv->data, arg->port,
 627                             (struct atm_port_info *)resp->data);
 628                         if (error != 0) {
 629                                 free(resp, M_NETGRAPH_MSG);
 630                                 resp = NULL;
 631                         }
 632                         break;
 633                     }
 634
 635                   case NGM_CCATM_SET_PORT_PARAM:
 636                     {
 637                         struct atm_port_info *arg;
 638
 639                         if (msg->header.arglen != sizeof(*arg)) {
 640                                 error = EINVAL;
 641                                 break;
 642                         }
 643                         arg = (struct atm_port_info *)msg->data;
 644                         error = cc_port_set_param(priv->data, arg);
 645                         break;
 646                     }
 647
 648                   case NGM_CCATM_GET_PORTLIST:
 649                     {
 650                         struct ngm_ccatm_portlist *arg;
 651                         u_int n, *ports;
 652
 653                         if (msg->header.arglen != 0) {
 654                                 error = EINVAL;
 655                                 break;
 656                         }
 657                         error = cc_port_getlist(priv->data, &n, &ports);
 658                         if (error != 0)
 659                                 break;
 660
 661                         NG_MKRESPONSE(resp, msg, sizeof(*arg) +
 662                             n * sizeof(arg->ports[0]), M_NOWAIT);
 663                         if (resp == NULL) {
 664                                 free(ports, M_NG_CCATM);
 665                                 error = ENOMEM;
 666                                 break;
 667                         }
 668                         arg = (struct ngm_ccatm_portlist *)resp->data;
 669
 670                         arg->nports = 0;
 671                         for (arg->nports = 0; arg->nports < n; arg->nports++)
 672                                 arg->ports[arg->nports] = ports[arg->nports];
 673                         free(ports, M_NG_CCATM);
 674                         break;
 675                     }
 676
 677                   case NGM_CCATM_SETLOG:
 678                     {
 679                         uint32_t log_level;
 680
 681                         log_level = cc_get_log(priv->data);
 682                         if (msg->header.arglen != 0) {
 683                                 if (msg->header.arglen != sizeof(log_level)) {
 684                                         error = EINVAL;
 685                                         break;
 686                                 }
 687                                 cc_set_log(priv->data, *(uint32_t *)msg->data);
 688                         }
 689
 690                         NG_MKRESPONSE(resp, msg, sizeof(uint32_t), M_NOWAIT);
 691                         if (resp == NULL) {
 692                                 error = ENOMEM;
 693                                 if (msg->header.arglen != 0)
 694                                         cc_set_log(priv->data, log_level);
 695                                 break;
 696                         }
 697                         *(uint32_t *)resp->data = log_level;
 698                         break;
 699                     }
 700
 701                   case NGM_CCATM_RESET:
 702                         if (msg->header.arglen != 0) {
 703                                 error = EINVAL;
 704                                 break;
 705                         }
 706
 707                         if (priv->hook_cnt != 0) {
 708                                 error = EBUSY;
 709                                 break;
 710                         }
 711                         cc_reset(priv->data);
 712                         break;
 713
 714                   case NGM_CCATM_GET_EXSTAT:
 715                     {
 716                         struct atm_exstatus s;
 717                         struct atm_exstatus_ep *eps;
 718                         struct atm_exstatus_port *ports;
 719                         struct atm_exstatus_conn *conns;
 720                         struct atm_exstatus_party *parties;
 721                         size_t offs;
 722
 723                         if (msg->header.arglen != 0) {
 724                                 error = EINVAL;
 725                                 break;
 726                         }
 727                         error = cc_get_extended_status(priv->data,
 728                             &s, &eps, &ports, &conns, &parties);
 729                         if (error != 0)
 730                                 break;
 731
 732                         offs = sizeof(s) + s.neps * sizeof(*eps) +
 733                             s.nports * sizeof(*ports) +
 734                             s.nconns * sizeof(*conns) +
 735                             s.nparties * sizeof(*parties);
 736
 737                         NG_MKRESPONSE(resp, msg, offs, M_NOWAIT);
 738                         if (resp == NULL) {
 739                                 error = ENOMEM;
 740                                 break;
 741                         }
 742
 743                         memcpy(resp->data, &s, sizeof(s));
 744                         offs = sizeof(s);
 745
 746                         memcpy(resp->data + offs, eps,
 747                             sizeof(*eps) * s.neps);
 748                         offs += sizeof(*eps) * s.neps;
 749
 750                         memcpy(resp->data + offs, ports,
 751                             sizeof(*ports) * s.nports);
 752                         offs += sizeof(*ports) * s.nports;
 753
 754                         memcpy(resp->data + offs, conns,
 755                             sizeof(*conns) * s.nconns);
 756                         offs += sizeof(*conns) * s.nconns;
 757
 758                         memcpy(resp->data + offs, parties,
 759                             sizeof(*parties) * s.nparties);
 760                         offs += sizeof(*parties) * s.nparties;
 761
 762                         free(eps, M_NG_CCATM);
 763                         free(ports, M_NG_CCATM);
 764                         free(conns, M_NG_CCATM);
 765                         free(parties, M_NG_CCATM);
 766                         break;
 767                     }
 768
 769                   default:
 770                         error = EINVAL;
 771                         break;
 772                 }
 773                 break;
 774
 775           default:
 776                 error = EINVAL;
 777                 break;
 778         }
 779
 780         NG_RESPOND_MSG(error, node, item, resp);
 781         NG_FREE_MSG(msg);
 782         return (error);
 783 }
 784
 785 /************************************************************
 786  *
 787  * New hook arrival
 788  */
 789 static int
 790 ng_ccatm_newhook(node_p node, hook_p hook, const char *name)
 791 {
 792         struct ccnode *priv = NG_NODE_PRIVATE(node);
 793         struct ccport *port;
 794         struct ccuser *user;
 795         struct cchook *hd;
 796         u_long lport;
 797         char *end;
 798
 799         if (strncmp(name, "uni", 3) == 0) {
 800                 /*
 801                  * This is a UNI hook. Should be a new port.
 802                  */
 803                 if (name[3] == '\0')
 804                         return (EINVAL);
 805                 lport = strtoul(name + 3, &end, 10);
 806                 if (*end != '\0' || lport == 0 || lport > 0xffffffff)
 807                         return (EINVAL);
 808
 809                 hd = malloc(sizeof(*hd), M_NG_CCATM, M_NOWAIT);
 810                 if (hd == NULL)
 811                         return (ENOMEM);
 812                 hd->is_uni = 1;
 813                 hd->node = priv;
 814                 hd->hook = hook;
 815
 816                 port = cc_port_create(priv->data, hd, (u_int)lport);
 817                 if (port == NULL) {
 818                         free(hd, M_NG_CCATM);
 819                         return (ENOMEM);
 820                 }
 821                 hd->inst = port;
 822
 823                 NG_HOOK_SET_PRIVATE(hook, hd);
 824                 NG_HOOK_SET_RCVDATA(hook, ng_ccatm_rcvuni);
 825                 NG_HOOK_FORCE_QUEUE(hook);
 826
 827                 priv->hook_cnt++;
 828
 829                 return (0);
 830         }
 831
 832         if (strcmp(name, "dump") == 0) {
 833                 priv->dump = hook;
 834                 NG_HOOK_SET_RCVDATA(hook, ng_ccatm_rcvdump);
 835                 return (0);
 836         }
 837
 838         if (strcmp(name, "manage") == 0) {
 839                 priv->manage = hook;
 840                 NG_HOOK_SET_RCVDATA(hook, ng_ccatm_rcvmanage);
 841                 return (0);
 842         }
 843
 844         /*
 845          * User hook
 846          */
 847         hd = malloc(sizeof(*hd), M_NG_CCATM, M_NOWAIT);
 848         if (hd == NULL)
 849                 return (ENOMEM);
 850         hd->is_uni = 0;
 851         hd->node = priv;
 852         hd->hook = hook;
 853
 854         user = cc_user_create(priv->data, hd, NG_HOOK_NAME(hook));
 855         if (user == NULL) {
 856                 free(hd, M_NG_CCATM);
 857                 return (ENOMEM);
 858         }
 859
 860         hd->inst = user;
 861         NG_HOOK_SET_PRIVATE(hook, hd);
 862         NG_HOOK_FORCE_QUEUE(hook);
 863
 864         priv->hook_cnt++;
 865
 866         return (0);
 867 }
 868
 869 /*
 870  * Disconnect a hook
 871  */
 872 static int
 873 ng_ccatm_disconnect(hook_p hook)
 874 {
 875         node_p node = NG_HOOK_NODE(hook);
 876         struct ccnode *priv = NG_NODE_PRIVATE(node);
 877         struct cchook *hd = NG_HOOK_PRIVATE(hook);
 878         struct ccdata *cc;
 879
 880         if (hook == priv->dump) {
 881                 priv->dump = NULL;
 882
 883         } else if (hook == priv->manage) {
 884                 priv->manage = NULL;
 885                 cc_unmanage(priv->data);
 886
 887         } else {
 888                 if (hd->is_uni)
 889                         cc_port_destroy(hd->inst, 0);
 890                 else
 891                         cc_user_destroy(hd->inst);
 892
 893                 cc = hd->node->data;
 894
 895                 free(hd, M_NG_CCATM);
 896                 NG_HOOK_SET_PRIVATE(hook, NULL);
 897
 898                 priv->hook_cnt--;
 899
 900                 cc_work(cc);
 901         }
 902
 903         /*
 904          * When the number of hooks drops to zero, delete the node.
 905          */
 906         if (NG_NODE_NUMHOOKS(node) == 0 && NG_NODE_IS_VALID(node))
 907                 ng_rmnode_self(node);
 908
 909         return (0);
 910 }
 911
 912 /************************************************************
 913  *
 914  * Receive data from user hook
 915  */
 916 static int
 917 ng_ccatm_rcvdata(hook_p hook, item_p item)
 918 {
 919         struct cchook *hd = NG_HOOK_PRIVATE(hook);
 920         struct uni_msg *msg;
 921         struct mbuf *m;
 922         struct ccatm_op op;
 923         int err;
 924
 925         NGI_GET_M(item, m);
 926         NG_FREE_ITEM(item);
 927
 928         if ((err = uni_msg_unpack_mbuf(m, &msg)) != 0) {
 929                 m_freem(m);
 930                 return (err);
 931         }
 932         m_freem(m);
 933
 934         if (uni_msg_len(msg) < sizeof(op)) {
 935                 printf("%s: packet too short\n", __func__);
 936                 uni_msg_destroy(msg);
 937                 return (EINVAL);
 938         }
 939
 940         bcopy(msg->b_rptr, &op, sizeof(op));
 941         msg->b_rptr += sizeof(op);
 942
 943         err = cc_user_signal(hd->inst, op.op, msg);
 944         cc_work(hd->node->data);
 945         return (err);
 946 }
 947
 948 /*
 949  * Pack a header and a data area into an mbuf chain
 950  */
 951 static struct mbuf *
 952 pack_buf(void *h, size_t hlen, void *t, size_t tlen)
 953 {
 954         struct mbuf *m, *m0, *last;
 955         u_char *buf = (u_char *)t;
 956         size_t n;
 957
 958         /* header should fit into a normal mbuf */
 959         MGETHDR(m0, M_NOWAIT, MT_DATA);
 960         if (m0 == NULL)
 961                 return NULL;
 962
 963         KASSERT(hlen <= MHLEN, ("hlen > MHLEN"));
 964
 965         bcopy(h, m0->m_data, hlen);
 966         m0->m_len = hlen;
 967         m0->m_pkthdr.len = hlen;
 968
 969         last = m0;
 970         while ((n = tlen) != 0) {
 971                 if (n > MLEN) {
 972                         m = m_getcl(M_NOWAIT, MT_DATA, 0);
 973                         if (n > MCLBYTES)
 974                                 n = MCLBYTES;
 975                 } else
 976                         MGET(m, M_NOWAIT, MT_DATA);
 977
 978                 if(m == NULL)
 979                         goto drop;
 980
 981                 last->m_next = m;
 982                 last = m;
 983
 984                 bcopy(buf, m->m_data, n);
 985                 buf += n;
 986                 tlen -= n;
 987                 m->m_len = n;
 988                 m0->m_pkthdr.len += n;
 989         }
 990
 991         return (m0);
 992
 993   drop:
 994         m_freem(m0);
 995         return NULL;
 996 }
 997
 998 /*
 999  * Send an indication to the user.
1000  */
1001 static void
1002 ng_ccatm_send_user(struct ccuser *user, void *uarg, u_int op,
1003     void *val, size_t len)
1004 {
1005         struct cchook *hd = uarg;
1006         struct mbuf *m;
1007         struct ccatm_op h;
1008         int error;
1009
1010         h.op = op;
1011         m = pack_buf(&h, sizeof(h), val, len);
1012         if (m == NULL)
1013                 return;
1014
1015         NG_SEND_DATA_ONLY(error, hd->hook, m);
1016         if (error != 0)
1017                 printf("%s: error=%d\n", __func__, error);
1018 }
1019
1020 /*
1021  * Send a response to the user.
1022  */
1023 static void
1024 ng_ccatm_respond_user(struct ccuser *user, void *uarg, int err, u_int data,
1025     void *val, size_t len)
1026 {
1027         struct cchook *hd = uarg;
1028         struct mbuf *m;
1029         struct {
1030                 struct ccatm_op op;
1031                 struct atm_resp resp;
1032         } resp;
1033         int error;
1034
1035         resp.op.op = ATMOP_RESP;
1036         resp.resp.resp = err;
1037         resp.resp.data = data;
1038         m = pack_buf(&resp, sizeof(resp), val, len);
1039         if (m == NULL)
1040                 return;
1041
1042         NG_SEND_DATA_ONLY(error, hd->hook, m);
1043         if (error != 0)
1044                 printf("%s: error=%d\n", __func__, error);
1045 }
1046
1047 /*
1048  * Receive data from UNI.
1049  */
1050 static int
1051 ng_ccatm_rcvuni(hook_p hook, item_p item)
1052 {
1053         struct cchook *hd = NG_HOOK_PRIVATE(hook);
1054         struct uni_msg *msg;
1055         struct uni_arg arg;
1056         struct mbuf *m;
1057         int err;
1058
1059         NGI_GET_M(item, m);
1060         NG_FREE_ITEM(item);
1061
1062         if ((err = uni_msg_unpack_mbuf(m, &msg)) != 0) {
1063                 m_freem(m);
1064                 return (err);
1065         }
1066         m_freem(m);
1067
1068         if (uni_msg_len(msg) < sizeof(arg)) {
1069                 printf("%s: packet too short\n", __func__);
1070                 uni_msg_destroy(msg);
1071                 return (EINVAL);
1072         }
1073
1074         bcopy(msg->b_rptr, &arg, sizeof(arg));
1075         msg->b_rptr += sizeof(arg);
1076
1077         if (arg.sig == UNIAPI_ERROR) {
1078                 if (uni_msg_len(msg) != sizeof(struct uniapi_error)) {
1079                         printf("%s: bad UNIAPI_ERROR size %zu\n", __func__,
1080                             uni_msg_len(msg));
1081                         uni_msg_destroy(msg);
1082                         return (EINVAL);
1083                 }
1084                 err = cc_uni_response(hd->inst, arg.cookie,
1085                     ((struct uniapi_error *)msg->b_rptr)->reason,
1086                     ((struct uniapi_error *)msg->b_rptr)->state);
1087                 uni_msg_destroy(msg);
1088         } else
1089                 err = cc_uni_signal(hd->inst, arg.cookie, arg.sig, msg);
1090
1091         cc_work(hd->node->data);
1092         return (err);
1093 }
1094
1095 /*
1096  * Uarg is the port's uarg.
1097  */
1098 static void
1099 ng_ccatm_send_uni(struct ccconn *conn, void *uarg, u_int op, u_int cookie,
1100     struct uni_msg *msg)
1101 {
1102         struct cchook *hd = uarg;
1103         struct uni_arg arg;
1104         struct mbuf *m;
1105         int error;
1106
1107         arg.sig = op;
1108         arg.cookie = cookie;
1109
1110         m = uni_msg_pack_mbuf(msg, &arg, sizeof(arg));
1111         uni_msg_destroy(msg);
1112         if (m == NULL)
1113                 return;
1114
1115         NG_SEND_DATA_ONLY(error, hd->hook, m);
1116         if (error != 0)
1117                 printf("%s: error=%d\n", __func__, error);
1118 }
1119
1120 /*
1121  * Send a global message to the UNI
1122  */
1123 static void
1124 ng_ccatm_send_uni_glob(struct ccport *port, void *uarg, u_int op, u_int cookie,
1125     struct uni_msg *msg)
1126 {
1127         struct cchook *hd = uarg;
1128         struct uni_arg arg;
1129         struct mbuf *m;
1130         int error;
1131
1132         arg.sig = op;
1133         arg.cookie = cookie;
1134
1135         m = uni_msg_pack_mbuf(msg, &arg, sizeof(arg));
1136         if (msg != NULL)
1137                 uni_msg_destroy(msg);
1138         if (m == NULL)
1139                 return;
1140
1141         NG_SEND_DATA_ONLY(error, hd->hook, m);
1142         if (error != 0)
1143                 printf("%s: error=%d\n", __func__, error);
1144 }
1145 /*
1146  * Receive from ILMID
1147  */
1148 static int
1149 ng_ccatm_rcvmanage(hook_p hook, item_p item)
1150 {
1151         NG_FREE_ITEM(item);
1152         return (0);
1153 }
1154
1155 static int
1156 ng_ccatm_rcvdump(hook_p hook, item_p item)
1157 {
1158         NG_FREE_ITEM(item);
1159         return (0);
1160 }
1161
1162 static void
1163 ng_ccatm_log(const char *fmt, ...)
1164 {
1165         va_list ap;
1166
1167         va_start(ap, fmt);
1168         vprintf(fmt, ap);
1169         printf("\n");
1170         va_end(ap);
1171 }
1172
1173 /*
1174  * Loading and unloading of node type
1175  */
1176 static int
1177 ng_ccatm_mod_event(module_t mod, int event, void *data)
1178 {
1179         int error = 0;
1180
1181         switch (event) {
1182           case MOD_LOAD:
1183                 break;
1184
1185           case MOD_UNLOAD:
1186                 break;
1187
1188           default:
1189                 error = EOPNOTSUPP;
1190                 break;
1191         }
1192         return (error);
1193 }