sig_print.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * Copyright (c) 2002-2003
    3  *      Fraunhofer Institute for Open Communication Systems (FhG Fokus).
    4  *      All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  *
   27  * Author: Hartmut Brandt <harti@freebsd.org>
   28  *         Kendy Kutzner <kutzner@fokus.fraunhofer.de>
   29  *
   30  * $Begemot: libunimsg/netnatm/sig/sig_print.c,v 1.6 2004/08/05 07:11:02 brandt Exp $
   31  */
   32 
   33 #include <sys/types.h>
   34 #ifdef _KERNEL
   35 #include <sys/param.h>
   36 #include <sys/systm.h>
   37 #include <sys/libkern.h>
   38 #include <machine/stdarg.h>
   39 #else
   40 #include <stdio.h>
   41 #include <stdlib.h>
   42 #include <string.h>
   43 #include <stdarg.h>
   44 #endif
   45 
   46 #include <netnatm/saal/sscfu.h>
   47 #include <netnatm/msg/uni_hdr.h>
   48 #include <netnatm/msg/unistruct.h>
   49 #include <netnatm/msg/unimsglib.h>
   50 #include <netnatm/msg/uniprint.h>
   51 #include <netnatm/sig/uni.h>
   52 #include <netnatm/sig/unisig.h>
   53 #include <netnatm/sig/unidef.h>
   54 
   55 const char * 
   56 uni_strerr(u_int err)
   57 {
   58         static const char *const errstr[] = {
   59 #define DEF(NAME, VAL, STR) [UNIAPI_##NAME] = STR,
   60 UNIAPI_DEF_ERRORS(DEF)
   61 #undef DEF
   62         };
   63         static char buf[100];
   64 
   65         if (err >= sizeof(errstr)/sizeof(errstr[0]) || errstr[err] == NULL) {
   66                 sprintf(buf, "Unknown error %u", err);
   67                 return (buf);
   68         }
   69         return (errstr[err]);
   70 }
   71 
   72 #define D(M) [M] = #M
   73 static const char *const msgs[] = {
   74         D(UNIAPI_ERROR),
   75         D(UNIAPI_CALL_CREATED),
   76         D(UNIAPI_CALL_DESTROYED),
   77         D(UNIAPI_PARTY_CREATED),
   78         D(UNIAPI_PARTY_DESTROYED),
   79         D(UNIAPI_LINK_ESTABLISH_request),
   80         D(UNIAPI_LINK_ESTABLISH_confirm),
   81         D(UNIAPI_LINK_RELEASE_request),
   82         D(UNIAPI_LINK_RELEASE_confirm),
   83         D(UNIAPI_RESET_request),
   84         D(UNIAPI_RESET_confirm),
   85         D(UNIAPI_RESET_indication),
   86         D(UNIAPI_RESET_ERROR_indication),
   87         D(UNIAPI_RESET_response),
   88         D(UNIAPI_RESET_ERROR_response),
   89         D(UNIAPI_RESET_STATUS_indication),
   90         D(UNIAPI_SETUP_request),
   91         D(UNIAPI_SETUP_indication),
   92         D(UNIAPI_SETUP_response),
   93         D(UNIAPI_SETUP_confirm),
   94         D(UNIAPI_SETUP_COMPLETE_indication),
   95         D(UNIAPI_SETUP_COMPLETE_request),
   96         D(UNIAPI_ALERTING_request),
   97         D(UNIAPI_ALERTING_indication),
   98         D(UNIAPI_PROCEEDING_request),
   99         D(UNIAPI_PROCEEDING_indication),
  100         D(UNIAPI_RELEASE_request),
  101         D(UNIAPI_RELEASE_indication),
  102         D(UNIAPI_RELEASE_response),
  103         D(UNIAPI_RELEASE_confirm),
  104         D(UNIAPI_NOTIFY_request),
  105         D(UNIAPI_NOTIFY_indication),
  106         D(UNIAPI_STATUS_indication),
  107         D(UNIAPI_STATUS_ENQUIRY_request),
  108         D(UNIAPI_ADD_PARTY_request),
  109         D(UNIAPI_ADD_PARTY_indication),
  110         D(UNIAPI_PARTY_ALERTING_request),
  111         D(UNIAPI_PARTY_ALERTING_indication),
  112         D(UNIAPI_ADD_PARTY_ACK_request),
  113         D(UNIAPI_ADD_PARTY_ACK_indication),
  114         D(UNIAPI_ADD_PARTY_REJ_request),
  115         D(UNIAPI_ADD_PARTY_REJ_indication),
  116         D(UNIAPI_DROP_PARTY_request),
  117         D(UNIAPI_DROP_PARTY_indication),
  118         D(UNIAPI_DROP_PARTY_ACK_request),
  119         D(UNIAPI_DROP_PARTY_ACK_indication),
  120         D(UNIAPI_ABORT_CALL_request),
  121 };
  122 #undef D
  123 
  124 void
  125 uni_print_api(char *buf, size_t bufsiz, u_int type, u_int cookie,
  126     const void *msg, struct unicx *cx)
  127 {
  128         int old_dont_init = cx->dont_init;
  129 
  130         uni_print_init(buf, bufsiz, cx);
  131         cx->dont_init = 1;
  132 
  133         if (type >= sizeof(msgs) / sizeof(msgs[0]) || msgs[type] == NULL) {
  134                 uni_print_flag("UNIAPI_UNKNOWN", cx);
  135                 uni_print_entry(cx, "sig", "%u", type);
  136                 uni_print_entry(cx, "cookie", "%u", cookie);
  137                 goto out;
  138         }
  139 
  140         uni_print_flag(msgs[type], cx);
  141         uni_print_entry(cx, "cookie", "%u", cookie);
  142         cx->indent++;
  143 
  144         switch (type) {
  145 
  146           case UNIAPI_ERROR:
  147             {
  148                 const struct uniapi_error *api = msg;
  149 
  150                 uni_print_eol(cx);
  151                 uni_print_entry(cx, "reason", "%s", uni_strerr(api->reason));
  152                 uni_print_entry(cx, "state", "U%u", api->state);
  153                 break;
  154             }
  155 
  156           case UNIAPI_CALL_CREATED:
  157             {
  158                 const struct uniapi_call_created *api = msg;
  159 
  160                 uni_print_cref(NULL, 0, &api->cref, cx);
  161                 break;
  162             }
  163 
  164           case UNIAPI_CALL_DESTROYED:
  165             {
  166                 const struct uniapi_call_destroyed *api = msg;
  167 
  168                 uni_print_cref(NULL, 0, &api->cref, cx);
  169                 break;
  170             }
  171 
  172           case UNIAPI_PARTY_CREATED:
  173             {
  174                 const struct uniapi_party_created *api = msg;
  175 
  176                 uni_print_cref(NULL, 0, &api->cref, cx);
  177                 uni_print_eol(cx);
  178                 uni_print_ie(NULL, 0, UNI_IE_EPREF,
  179                     (const union uni_ieall *)&api->epref, cx);
  180                 break;
  181             }
  182 
  183           case UNIAPI_PARTY_DESTROYED:
  184             {
  185                 const struct uniapi_party_destroyed *api = msg;
  186 
  187                 uni_print_cref(NULL, 0, &api->cref, cx);
  188                 uni_print_eol(cx);
  189                 uni_print_ie(NULL, 0, UNI_IE_EPREF,
  190                     (const union uni_ieall *)&api->epref, cx);
  191                 break;
  192             }
  193 
  194           case UNIAPI_LINK_ESTABLISH_request:
  195           case UNIAPI_LINK_ESTABLISH_confirm:
  196           case UNIAPI_LINK_RELEASE_request:
  197           case UNIAPI_LINK_RELEASE_confirm:
  198                 break;
  199 
  200           case UNIAPI_RESET_request:
  201             {
  202                 const struct uniapi_reset_request *api = msg;
  203 
  204                 uni_print_eol(cx);
  205                 uni_print_ie(NULL, 0, UNI_IE_RESTART,
  206                     (const union uni_ieall *)&api->restart, cx);
  207                 uni_print_eol(cx);
  208                 uni_print_ie(NULL, 0, UNI_IE_CONNID,
  209                     (const union uni_ieall *)&api->restart, cx);
  210                 break;
  211             }
  212 
  213           case UNIAPI_RESET_confirm:
  214             {
  215                 const struct uniapi_reset_confirm *api = msg;
  216 
  217                 uni_print_eol(cx);
  218                 uni_print_ie(NULL, 0, UNI_IE_RESTART,
  219                     (const union uni_ieall *)&api->restart, cx);
  220                 uni_print_eol(cx);
  221                 uni_print_ie(NULL, 0, UNI_IE_CONNID,
  222                     (const union uni_ieall *)&api->restart, cx);
  223                 break;
  224             }
  225 
  226           case UNIAPI_RESET_indication:
  227             {
  228                 const struct uniapi_reset_indication *api = msg;
  229 
  230                 uni_print_eol(cx);
  231                 uni_print_ie(NULL, 0, UNI_IE_RESTART,
  232                     (const union uni_ieall *)&api->restart, cx);
  233                 uni_print_eol(cx);
  234                 uni_print_ie(NULL, 0, UNI_IE_CONNID,
  235                     (const union uni_ieall *)&api->restart, cx);
  236                 break;
  237             }
  238 
  239           case UNIAPI_RESET_ERROR_indication:
  240             {
  241                 const struct uniapi_reset_error_indication *api = msg;
  242                 static const struct uni_print_tbl reason[] = {
  243 #define DEF(NAME, VALUE, STR) { STR, VALUE },
  244                         UNIAPI_DEF_RESET_ERRORS(DEF)
  245 #undef DEF
  246                         { NULL, 0 }
  247                 };
  248                 static const struct uni_print_tbl source[] = {
  249                         { "start", 0 },
  250                         { "respond", 1 },
  251                         { NULL, 0 }
  252                 };
  253 
  254                 uni_print_eol(cx);
  255                 uni_print_tbl("source", api->source, source, cx);
  256                 uni_print_tbl("reason", api->reason, reason, cx);
  257                 break;
  258             }
  259 
  260           case UNIAPI_RESET_response:
  261             {
  262                 const struct uniapi_reset_response *api = msg;
  263 
  264                 uni_print_eol(cx);
  265                 uni_print_ie(NULL, 0, UNI_IE_RESTART,
  266                     (const union uni_ieall *)&api->restart, cx);
  267                 uni_print_eol(cx);
  268                 uni_print_ie(NULL, 0, UNI_IE_CONNID,
  269                     (const union uni_ieall *)&api->restart, cx);
  270                 break;
  271             }
  272 
  273           case UNIAPI_RESET_ERROR_response:
  274             {
  275                 const struct uniapi_reset_error_response *api = msg;
  276 
  277                 uni_print_eol(cx);
  278                 uni_print_ie(NULL, 0, UNI_IE_CAUSE,
  279                     (const union uni_ieall *)&api->cause, cx);
  280                 break;
  281             }
  282 
  283           case UNIAPI_RESET_STATUS_indication:
  284             {
  285                 const struct uniapi_reset_status_indication *api = msg;
  286 
  287                 uni_print_cref(NULL, 0, &api->cref, cx);
  288                 uni_print_eol(cx);
  289                 uni_print_ie(NULL, 0, UNI_IE_CALLSTATE,
  290                     (const union uni_ieall *)&api->callstate, cx);
  291                 uni_print_eol(cx);
  292                 uni_print_ie(NULL, 0, UNI_IE_CAUSE,
  293                     (const union uni_ieall *)&api->cause, cx);
  294                 break;
  295             }
  296 
  297           case UNIAPI_SETUP_request:
  298             {
  299                 const struct uniapi_setup_request *api = msg;
  300 
  301                 uni_print_eol(cx);
  302                 uni_print_msg(NULL, 0, UNI_SETUP,
  303                     (const union uni_msgall *)&api->setup, cx);
  304                 break;
  305             }
  306 
  307           case UNIAPI_SETUP_indication:
  308             {
  309                 const struct uniapi_setup_indication *api = msg;
  310 
  311                 uni_print_eol(cx);
  312                 uni_print_msg(NULL, 0, UNI_SETUP,
  313                     (const union uni_msgall *)&api->setup, cx);
  314                 break;
  315             }
  316 
  317           case UNIAPI_SETUP_response:
  318             {
  319                 const struct uniapi_setup_response *api = msg;
  320 
  321                 uni_print_eol(cx);
  322                 uni_print_msg(NULL, 0, UNI_CONNECT,
  323                     (const union uni_msgall *)&api->connect, cx);
  324                 break;
  325             }
  326 
  327           case UNIAPI_SETUP_confirm:
  328             {
  329                 const struct uniapi_setup_confirm *api = msg;
  330 
  331                 uni_print_eol(cx);
  332                 uni_print_msg(NULL, 0, UNI_CONNECT,
  333                     (const union uni_msgall *)&api->connect, cx);
  334                 break;
  335             }
  336 
  337           case UNIAPI_SETUP_COMPLETE_indication:
  338             {
  339                 const struct uniapi_setup_complete_indication *api = msg;
  340 
  341                 uni_print_eol(cx);
  342                 uni_print_msg(NULL, 0, UNI_CONNECT_ACK,
  343                     (const union uni_msgall *)&api->connect_ack, cx);
  344                 break;
  345             }
  346 
  347           case UNIAPI_SETUP_COMPLETE_request:
  348             {
  349                 const struct uniapi_setup_complete_request *api = msg;
  350 
  351                 uni_print_eol(cx);
  352                 uni_print_msg(NULL, 0, UNI_CONNECT_ACK,
  353                     (const union uni_msgall *)&api->connect_ack, cx);
  354                 break;
  355             }
  356 
  357           case UNIAPI_ALERTING_request:
  358             {
  359                 const struct uniapi_alerting_request *api = msg;
  360 
  361                 uni_print_eol(cx);
  362                 uni_print_msg(NULL, 0, UNI_ALERTING,
  363                     (const union uni_msgall *)&api->alerting, cx);
  364                 break;
  365             }
  366 
  367           case UNIAPI_ALERTING_indication:
  368             {
  369                 const struct uniapi_alerting_indication *api = msg;
  370 
  371                 uni_print_eol(cx);
  372                 uni_print_msg(NULL, 0, UNI_ALERTING,
  373                     (const union uni_msgall *)&api->alerting, cx);
  374                 break;
  375             }
  376 
  377           case UNIAPI_PROCEEDING_request:
  378             {
  379                 const struct uniapi_proceeding_request *api = msg;
  380 
  381                 uni_print_eol(cx);
  382                 uni_print_msg(NULL, 0, UNI_CALL_PROC,
  383                     (const union uni_msgall *)&api->call_proc, cx);
  384                 break;
  385             }
  386 
  387           case UNIAPI_PROCEEDING_indication:
  388             {
  389                 const struct uniapi_proceeding_indication *api = msg;
  390 
  391                 uni_print_eol(cx);
  392                 uni_print_msg(NULL, 0, UNI_CALL_PROC,
  393                     (const union uni_msgall *)&api->call_proc, cx);
  394                 break;
  395             }
  396 
  397           case UNIAPI_RELEASE_request:
  398             {
  399                 const struct uniapi_release_request *api = msg;
  400 
  401                 uni_print_eol(cx);
  402                 uni_print_msg(NULL, 0, UNI_RELEASE,
  403                     (const union uni_msgall *)&api->release, cx);
  404                 break;
  405             }
  406 
  407           case UNIAPI_RELEASE_indication:
  408             {
  409                 const struct uniapi_release_indication *api = msg;
  410 
  411                 uni_print_eol(cx);
  412                 uni_print_msg(NULL, 0, UNI_RELEASE,
  413                     (const union uni_msgall *)&api->release, cx);
  414                 break;
  415             }
  416 
  417           case UNIAPI_RELEASE_response:
  418             {
  419                 const struct uniapi_release_response *api = msg;
  420 
  421                 uni_print_eol(cx);
  422                 uni_print_msg(NULL, 0, UNI_RELEASE_COMPL,
  423                     (const union uni_msgall *)&api->release_compl, cx);
  424                 break;
  425             }
  426           case UNIAPI_RELEASE_confirm:
  427             {
  428                 const struct uniapi_release_confirm *api = msg;
  429 
  430                 uni_print_eol(cx);
  431                 uni_print_msg(NULL, 0, UNI_RELEASE,
  432                     (const union uni_msgall *)&api->release, cx);
  433                 break;
  434             }
  435 
  436           case UNIAPI_NOTIFY_request:
  437             {
  438                 const struct uniapi_notify_request *api = msg;
  439 
  440                 uni_print_eol(cx);
  441                 uni_print_msg(NULL, 0, UNI_NOTIFY,
  442                     (const union uni_msgall *)&api->notify, cx);
  443                 break;
  444             }
  445 
  446           case UNIAPI_NOTIFY_indication:
  447             {
  448                 const struct uniapi_notify_indication *api = msg;
  449 
  450                 uni_print_eol(cx);
  451                 uni_print_msg(NULL, 0, UNI_NOTIFY,
  452                     (const union uni_msgall *)&api->notify, cx);
  453                 break;
  454             }
  455 
  456           case UNIAPI_STATUS_indication:
  457             {
  458                 const struct uniapi_status_indication *api = msg;
  459 
  460                 uni_print_cref(NULL, 0, &api->cref, cx);
  461                 uni_print_eol(cx);
  462                 uni_print_entry(cx, "my_state", "U%u", api->my_state);
  463                 uni_print_entry(cx, "my_cause", "%s",
  464                     uni_ie_cause2str(UNI_CODING_ITU, api->my_cause));
  465                 uni_print_eol(cx);
  466                 uni_print_ie(NULL, 0, UNI_IE_CALLSTATE,
  467                     (const union uni_ieall *)&api->his_state, cx);
  468                 uni_print_eol(cx);
  469                 uni_print_ie(NULL, 0, UNI_IE_CAUSE,
  470                     (const union uni_ieall *)&api->his_cause, cx);
  471                 uni_print_eol(cx);
  472                 uni_print_ie(NULL, 0, UNI_IE_EPREF,
  473                     (const union uni_ieall *)&api->epref, cx);
  474                 break;
  475             }
  476 
  477           case UNIAPI_STATUS_ENQUIRY_request:
  478             {
  479                 const struct uniapi_status_enquiry_request *api = msg;
  480 
  481                 uni_print_cref(NULL, 0, &api->cref, cx);
  482                 uni_print_eol(cx);
  483                 uni_print_ie(NULL, 0, UNI_IE_EPREF,
  484                     (const union uni_ieall *)&api->epref, cx);
  485                 break;
  486             }
  487 
  488           case UNIAPI_ADD_PARTY_request:
  489             {
  490                 const struct uniapi_add_party_request *api = msg;
  491 
  492                 uni_print_eol(cx);
  493                 uni_print_msg(NULL, 0, UNI_ADD_PARTY,
  494                     (const union uni_msgall *)&api->add, cx);
  495                 break;
  496             }
  497 
  498           case UNIAPI_ADD_PARTY_indication:
  499             {
  500                 const struct uniapi_add_party_indication *api = msg;
  501 
  502                 uni_print_eol(cx);
  503                 uni_print_msg(NULL, 0, UNI_ADD_PARTY,
  504                     (const union uni_msgall *)&api->add, cx);
  505                 break;
  506             }
  507 
  508           case UNIAPI_PARTY_ALERTING_request:
  509             {
  510                 const struct uniapi_party_alerting_request *api = msg;
  511 
  512                 uni_print_eol(cx);
  513                 uni_print_msg(NULL, 0, UNI_PARTY_ALERTING,
  514                     (const union uni_msgall *)&api->alert, cx);
  515                 break;
  516             }
  517 
  518           case UNIAPI_PARTY_ALERTING_indication:
  519             {
  520                 const struct uniapi_party_alerting_indication *api = msg;
  521 
  522                 uni_print_eol(cx);
  523                 uni_print_msg(NULL, 0, UNI_PARTY_ALERTING,
  524                     (const union uni_msgall *)&api->alert, cx);
  525                 break;
  526             }
  527 
  528           case UNIAPI_ADD_PARTY_ACK_request:
  529             {
  530                 const struct uniapi_add_party_ack_request *api = msg;
  531 
  532                 uni_print_eol(cx);
  533                 uni_print_msg(NULL, 0, UNI_ADD_PARTY_ACK,
  534                     (const union uni_msgall *)&api->ack, cx);
  535                 break;
  536             }
  537 
  538           case UNIAPI_ADD_PARTY_ACK_indication:
  539             {
  540                 const struct uniapi_add_party_ack_indication *api = msg;
  541 
  542                 uni_print_eol(cx);
  543                 uni_print_msg(NULL, 0, UNI_ADD_PARTY_ACK,
  544                     (const union uni_msgall *)&api->ack, cx);
  545                 break;
  546             }
  547 
  548           case UNIAPI_ADD_PARTY_REJ_request:
  549             {
  550                 const struct uniapi_add_party_rej_request *api = msg;
  551 
  552                 uni_print_eol(cx);
  553                 uni_print_msg(NULL, 0, UNI_ADD_PARTY_REJ,
  554                     (const union uni_msgall *)&api->rej, cx);
  555                 break;
  556             }
  557 
  558           case UNIAPI_ADD_PARTY_REJ_indication:
  559             {
  560                 const struct uniapi_add_party_rej_indication *api = msg;
  561 
  562                 uni_print_eol(cx);
  563                 uni_print_msg(NULL, 0, UNI_ADD_PARTY_REJ,
  564                     (const union uni_msgall *)&api->rej, cx);
  565                 break;
  566             }
  567 
  568           case UNIAPI_DROP_PARTY_request:
  569             {
  570                 const struct uniapi_drop_party_request *api = msg;
  571 
  572                 uni_print_eol(cx);
  573                 uni_print_msg(NULL, 0, UNI_DROP_PARTY,
  574                     (const union uni_msgall *)&api->drop, cx);
  575                 break;
  576             }
  577 
  578           case UNIAPI_DROP_PARTY_indication:
  579             {
  580                 const struct uniapi_drop_party_indication *api = msg;
  581 
  582                 uni_print_eol(cx);
  583                 uni_print_msg(NULL, 0, UNI_DROP_PARTY,
  584                     (const union uni_msgall *)&api->drop, cx);
  585                 break;
  586             }
  587 
  588           case UNIAPI_DROP_PARTY_ACK_request:
  589             {
  590                 const struct uniapi_drop_party_ack_request *api = msg;
  591 
  592                 uni_print_eol(cx);
  593                 uni_print_msg(NULL, 0, UNI_DROP_PARTY_ACK,
  594                     (const union uni_msgall *)&api->ack, cx);
  595                 break;
  596             }
  597 
  598           case UNIAPI_DROP_PARTY_ACK_indication:
  599             {
  600                 const struct uniapi_drop_party_ack_indication *api = msg;
  601 
  602                 uni_print_eol(cx);
  603                 uni_print_msg(NULL, 0, UNI_DROP_PARTY,
  604                     (const union uni_msgall *)&api->drop, cx);
  605                 uni_print_eol(cx);
  606                 uni_print_ie(NULL, 0, UNI_IE_CRANKBACK,
  607                     (const union uni_ieall *)&api->crankback, cx);
  608                 break;
  609             }
  610 
  611           case UNIAPI_ABORT_CALL_request:
  612             {
  613                 const struct uniapi_abort_call_request *api = msg;
  614 
  615                 uni_print_cref(NULL, 0, &api->cref, cx);
  616                 break;
  617             }
  618         }
  619 
  620   out:
  621         cx->dont_init = old_dont_init;
  622 }
Cache object: dfba3fcc6b9f246cf17f05c152abe98a
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/contrib/ngatm/netnatm/sig/sig_print.c

FreeBSD/Linux Kernel Cross Reference
sys/contrib/ngatm/netnatm/sig/sig_print.c
