sys/netproto/atm/spans/spans_print.c

   1 /*
   2  *
   3  * ===================================
   4  * HARP  |  Host ATM Research Platform
   5  * ===================================
   6  *
   7  *
   8  * This Host ATM Research Platform ("HARP") file (the "Software") is
   9  * made available by Network Computing Services, Inc. ("NetworkCS")
  10  * "AS IS".  NetworkCS does not provide maintenance, improvements or
  11  * support of any kind.
  12  *
  13  * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED,
  14  * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
  15  * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE
  16  * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE.
  17  * In no event shall NetworkCS be responsible for any damages, including
  18  * but not limited to consequential damages, arising from or relating to
  19  * any use of the Software or related support.
  20  *
  21  * Copyright 1994-1998 Network Computing Services, Inc.
  22  *
  23  * Copies of this Software may be made, however, the above copyright
  24  * notice must be reproduced on all copies.
  25  *
  26  *      @(#) $FreeBSD: src/sys/netatm/spans/spans_print.c,v 1.6 1999/08/28 00:48:50 peter Exp $
  27  *      @(#) $DragonFly: src/sys/netproto/atm/spans/spans_print.c,v 1.4 2003/08/07 21:54:34 dillon Exp $
  28  */
  29
  30 /*
  31  * SPANS Signalling Manager
  32  * ---------------------------
  33  *
  34  * SPANS Print Routines.
  35  *
  36  */
  37
  38 #include <netproto/atm/kern_include.h>
  39
  40 #include "spans_xdr.h"
  41 #include "spans_var.h"
  42
  43 /*
  44  * If LONGPRINT is defined, every field of the SPANS message will be
  45  * printed.  If not, a shorter summary (useful for debugging without
  46  * swamping the console) is printed.
  47  */
  48 /* #define LONGPRINT */
  49
  50 /*
  51  * Local functions
  52  */
  53 static void     spans_msgtype_str __P((spans_msgtype *, char *, int));
  54 static void     spans_print_msgbody __P((spans_msgbody *));
  55 static void     spans_result_str __P((spans_result *, char *, int));
  56
  57 #ifdef LONGPRINT
  58
  59 static void     inc_indent __P((void));
  60 static void     dec_indent __P((void));
  61 static void     spans_aal_str __P((spans_aal *, char *, int));
  62 static void     spans_query_type_str __P((spans_query_type *, char *, int));
  63 static void     spans_state_str __P((spans_query_type *, char *, int));
  64 static void     spans_print_version __P((spans_version *));
  65 static void     spans_print_vpvc __P((spans_vpvc *));
  66 static void     spans_print_vpvc_pref __P((spans_vpvc_pref *));
  67 static void     spans_print_addr __P((spans_addr *));
  68 static void     spans_print_sap __P((spans_sap *));
  69 static void     spans_print_atm_conn __P((spans_atm_conn *));
  70 static void     spans_print_resrc __P((spans_resrc *));
  71 static void     spans_print_aal __P((spans_aal *));
  72 static void     spans_print_result __P((spans_result *));
  73 static void     spans_print_msgtype __P((spans_msgtype *));
  74 static void     spans_print_parm_stat_req __P((spans_parm_stat_req *));
  75 static void     spans_print_parm_stat_ind __P((spans_parm_stat_ind *));
  76 static void     spans_print_parm_stat_rsp __P((spans_parm_stat_rsp *));
  77 static void     spans_print_parm_open_req __P((spans_parm_open_req *));
  78 static void     spans_print_parm_open_ind __P((spans_parm_open_ind *));
  79 static void     spans_print_parm_open_rsp __P((spans_parm_open_rsp *));
  80 static void     spans_print_parm_open_cnf __P((spans_parm_open_cnf *));
  81 static void     spans_print_parm_close_req __P((spans_parm_close_req *));
  82 static void     spans_print_parm_close_ind __P((spans_parm_close_ind *));
  83 static void     spans_print_parm_close_rsp __P((spans_parm_close_rsp *));
  84 static void     spans_print_parm_close_cnf __P((spans_parm_close_cnf *));
  85 static void     spans_print_parm_rclose_req __P((spans_parm_rclose_req *));
  86 static void     spans_print_parm_rclose_ind __P((spans_parm_rclose_ind *));
  87 static void     spans_print_parm_rclose_rsp __P((spans_parm_rclose_rsp *));
  88 static void     spans_print_parm_rclose_cnf __P((spans_parm_rclose_cnf *));
  89 static void     spans_print_parm_multi_req __P((spans_parm_multi_req *));
  90 static void     spans_print_parm_multi_ind __P((spans_parm_multi_ind *));
  91 static void     spans_print_parm_multi_rsp __P((spans_parm_multi_rsp *));
  92 static void     spans_print_parm_multi_cnf __P((spans_parm_multi_cnf *));
  93 static void     spans_print_parm_add_req __P((spans_parm_add_req *));
  94 static void     spans_print_parm_add_ind __P((spans_parm_add_ind *));
  95 static void     spans_print_parm_add_rsp __P((spans_parm_add_rsp *));
  96 static void     spans_print_parm_add_cnf __P((spans_parm_add_cnf *));
  97 static void     spans_print_parm_join_req __P((spans_parm_join_req *));
  98 static void     spans_print_parm_join_cnf __P((spans_parm_join_cnf *));
  99 static void     spans_print_parm_leave_req __P((spans_parm_leave_req *));
 100 static void     spans_print_parm_leave_cnf __P((spans_parm_leave_cnf *));
 101 static void     spans_print_parm_vcir_ind __P((spans_parm_vcir_ind *));
 102 static void     spans_print_parm_query_req __P((spans_parm_query_req *));
 103 static void     spans_print_parm_query_rsp __P((spans_parm_query_rsp *));
 104
 105
 106 /*
 107  * Local variables
 108  */
 109 #define MAX_INDENT      10
 110 #define INIT_INDENT     &indent_str[MAX_INDENT]
 111 static char *spans_indent;
 112 static char indent_str[11] = "          ";
 113
 114 static void
 115 inc_indent()
 116 {
 117         if (spans_indent != &indent_str[0]) {
 118                 spans_indent--;
 119         }
 120 }
 121
 122 static void
 123 dec_indent()
 124 {
 125         if (spans_indent != INIT_INDENT) {
 126                 spans_indent++;
 127         }
 128 }
 129
 130 static void
 131 spans_aal_str(objp, dest, len)
 132         spans_aal *objp;
 133         char *dest;
 134         int len;
 135 {
 136         static char     *aal_names[] = {
 137                 "SPANS_AAL0",
 138                 "SPANS_AAL1",
 139                 "SPANS_AAL2",
 140                 "SPANS_AAL3",
 141                 "SPANS_AAL4",
 142                 "SPANS_AAL5"
 143         };
 144
 145         if (*objp < SPANS_AAL0 || *objp > SPANS_AAL5) {
 146                 snprintf(dest, len, "Invalid (%d)", (int)*objp);
 147         } else {
 148                 snprintf(dest, len, "%s (%d)", aal_names[(int)*objp],
 149                                 (int)*objp);
 150         }
 151 }
 152
 153 #endif
 154
 155 static void
 156 spans_result_str(objp, dest, len)
 157         spans_result *objp;
 158         char *dest;
 159         int len;
 160 {
 161         static char     *result_names[] = {
 162                 "SPANS_OK",
 163                 "SPANS_FAIL",
 164                 "SPANS_NOVPVC",
 165                 "SPANS_NORSC",
 166                 "SPANS_BADDEST"
 167         };
 168
 169         if (*objp < SPANS_OK || *objp > SPANS_BADDEST) {
 170                 snprintf(dest, len, "Invalid (%d)", (int)*objp);
 171         } else {
 172                 snprintf(dest, len, "%s (%d)",
 173                                 result_names[(int)*objp], (int)*objp);
 174         }
 175 }
 176
 177 static void
 178 spans_msgtype_str(objp, dest, len)
 179         spans_msgtype *objp;
 180         char *dest;
 181         int len;
 182 {
 183         int     i;
 184
 185         static struct {
 186                 spans_msgtype   type;
 187                 char            *name;
 188         } msgtype_names[] = {
 189                 { SPANS_STAT_REQ,       "SPANS_STAT_REQ" },
 190                 { SPANS_STAT_IND,       "SPANS_STAT_IND" },
 191                 { SPANS_STAT_RSP,       "SPANS_STAT_RSP" },
 192                 { SPANS_OPEN_REQ,       "SPANS_OPEN_REQ" },
 193                 { SPANS_OPEN_IND,       "SPANS_OPEN_IND" },
 194                 { SPANS_OPEN_RSP,       "SPANS_OPEN_RSP" },
 195                 { SPANS_OPEN_CNF,       "SPANS_OPEN_CNF" },
 196                 { SPANS_CLOSE_REQ,      "SPANS_CLOSE_REQ" },
 197                 { SPANS_CLOSE_IND,      "SPANS_CLOSE_IND" },
 198                 { SPANS_CLOSE_RSP,      "SPANS_CLOSE_RSP" },
 199                 { SPANS_CLOSE_CNF,      "SPANS_CLOSE_CNF" },
 200                 { SPANS_RCLOSE_REQ,     "SPANS_RCLOSE_REQ" },
 201                 { SPANS_RCLOSE_IND,     "SPANS_RCLOSE_IND" },
 202                 { SPANS_RCLOSE_RSP,     "SPANS_RCLOSE_RSP" },
 203                 { SPANS_RCLOSE_CNF,     "SPANS_RCLOSE_CNF" },
 204                 { SPANS_MULTI_REQ,      "SPANS_MULTI_REQ" },
 205                 { SPANS_MULTI_IND,      "SPANS_MULTI_IND" },
 206                 { SPANS_MULTI_RSP,      "SPANS_MULTI_RSP" },
 207                 { SPANS_MULTI_CNF,      "SPANS_MULTI_CNF" },
 208                 { SPANS_ADD_REQ,        "SPANS_ADD_REQ" },
 209                 { SPANS_ADD_IND,        "SPANS_ADD_IND" },
 210                 { SPANS_ADD_RSP,        "SPANS_ADD_RSP" },
 211                 { SPANS_ADD_CNF,        "SPANS_ADD_CNF" },
 212                 { SPANS_JOIN_REQ,       "SPANS_JOIN_REQ" },
 213                 { SPANS_JOIN_CNF,       "SPANS_JOIN_CNF" },
 214                 { SPANS_LEAVE_REQ,      "SPANS_LEAVE_REQ" },
 215                 { SPANS_LEAVE_CNF,      "SPANS_LEAVE_CNF" },
 216                 { SPANS_VCIR_IND,       "SPANS_VCIR_IND" },
 217                 { SPANS_QUERY_REQ,      "SPANS_QUERY_REQ" },
 218                 { SPANS_QUERY_RSP,      "SPANS_QUERY_RSP" },
 219                 { 0,                    (char *) 0 }
 220         };
 221
 222         /*
 223          * Search the name table for the specified type
 224          */
 225         for (i=0; msgtype_names[i].name; i++) {
 226                 if (*objp == msgtype_names[i].type) {
 227                         snprintf(dest, len, "%s (%d)",
 228                                         msgtype_names[i].name,
 229                                         (int)*objp);
 230                         return;
 231                 }
 232         }
 233
 234         /*
 235          * Type was not found--return an error indicator
 236          */
 237         snprintf(dest, len, "Invalid (%d)", (int)*objp);
 238 }
 239
 240 #ifdef LONGPRINT
 241
 242 static void
 243 spans_query_type_str(objp, dest, len)
 244         spans_query_type *objp;
 245         char *dest;
 246         int len;
 247 {
 248         static char     *query_names[] = {
 249                 "SPANS_QUERY_NORMAL",
 250                 "SPANS_QUERY_DEBUG",
 251                 "SPANS_QUERY_END_TO_END"
 252         };
 253
 254         if (*objp < SPANS_QUERY_NORMAL ||
 255                         *objp > SPANS_QUERY_END_TO_END) {
 256                 snprintf(dest, len, "Invalid (%d)", (int)*objp);
 257         } else {
 258                 snprintf(dest, len, "%s (%d)", query_names[(int)*objp],
 259                                 (int)*objp);
 260         }
 261 }
 262
 263 static void
 264 spans_state_str(objp, dest, len)
 265         spans_query_type *objp;
 266         char *dest;
 267         int len;
 268 {
 269         static char     *state_names[] = {
 270                 "SPANS_CONN_OPEN",
 271                 "SPANS_CONN_OPEN_PEND",
 272                 "SPANS_CONN_CLOSE_PEND",
 273                 "SPANS_CONN_CLOSED"
 274         };
 275
 276         if (*objp < SPANS_CONN_OPEN || *objp > SPANS_CONN_CLOSED) {
 277                 snprintf(dest, len, "Invalid (%d)", (int)*objp);
 278         } else {
 279                 snprintf(dest, len, "%s (%d)", state_names[(int)*objp],
 280                                 (int)*objp);
 281         }
 282 }
 283
 284
 285 static void
 286 spans_print_version(objp)
 287         spans_version *objp;
 288 {
 289         printf("%sspans_version        0x%x\n", spans_indent, *objp);
 290 }
 291
 292 static void
 293 spans_print_vpvc(objp)
 294         spans_vpvc *objp;
 295 {
 296         printf("%sVP/VC                %d/%d\n", spans_indent,
 297                         SPANS_EXTRACT_VPI(*objp),
 298                         SPANS_EXTRACT_VCI(*objp));
 299 }
 300
 301 static void
 302 spans_print_vpvc_pref(objp)
 303         spans_vpvc_pref *objp;
 304 {
 305         printf("%sspans_vpvc_pref\n", spans_indent);
 306         inc_indent();
 307         printf("%s%s\n", spans_indent,
 308                         (objp->vpf_valid ? "Valid" : "Not valid"));
 309         spans_print_vpvc(&objp->vpf_vpvc);
 310         dec_indent();
 311 }
 312
 313 static void
 314 spans_print_addr(objp)
 315         spans_addr *objp;
 316 {
 317         char    addr_str[80];
 318
 319         strncpy(addr_str, spans_addr_print(objp), sizeof(addr_str));
 320         printf("%sspans_addr           %s\n", spans_indent, addr_str);
 321 }
 322
 323 static void
 324 spans_print_sap(objp)
 325         spans_sap *objp;
 326 {
 327         printf("%sSAP                  %d\n", spans_indent, *objp);
 328 }
 329
 330 static void
 331 spans_print_atm_conn(objp)
 332         spans_atm_conn *objp;
 333 {
 334         printf("%sspans_atm_conn\n", spans_indent);
 335         inc_indent();
 336         spans_print_addr(&objp->con_dst);
 337         spans_print_addr(&objp->con_src);
 338         spans_print_sap(&objp->con_dsap);
 339         spans_print_sap(&objp->con_ssap);
 340         dec_indent();
 341 }
 342
 343 static void
 344 spans_print_resrc(objp)
 345         spans_resrc *objp;
 346 {
 347         printf("%sspans_resrc\n", spans_indent);
 348         inc_indent();
 349         printf("%srsc_peak             %d\n", spans_indent, objp->rsc_peak);
 350         printf("%srsc_mean             %d\n", spans_indent, objp->rsc_mean);
 351         printf("%srsc_burst            %d\n", spans_indent, objp->rsc_burst);
 352         dec_indent();
 353 }
 354
 355 static void
 356 spans_print_aal(objp)
 357         spans_aal *objp;
 358 {
 359         char            aal_str[80];
 360
 361         spans_aal_str(objp, aal_str, sizeof(aal_str));
 362         printf("%sspans_aal            %s\n", spans_indent, aal_str);
 363 }
 364
 365 static void
 366 spans_print_result(objp)
 367         spans_result *objp;
 368 {
 369         char            result_str[80];
 370
 371         spans_result_str(objp, result_str, sizeof(result_str));
 372         printf("%sspans_result         %s\n", spans_indent, result_str);
 373 }
 374
 375 static void
 376 spans_print_msgtype(objp)
 377         spans_msgtype *objp;
 378 {
 379         char            msgtype_str[80];
 380
 381         spans_msgtype_str(objp, msgtype_str, sizeof(msgtype_str));
 382         printf("%sspans_msgtype        %s\n", spans_indent, msgtype_str);
 383 }
 384
 385 static void
 386 spans_print_parm_stat_req(objp)
 387         spans_parm_stat_req *objp;
 388 {
 389         printf("%sspans_parm_stat_req\n", spans_indent);
 390         inc_indent();
 391         printf("%sstreq_es_epoch       %d\n", spans_indent,
 392                         objp->streq_es_epoch);
 393         dec_indent();
 394 }
 395
 396 static void
 397 spans_print_parm_stat_ind(objp)
 398         spans_parm_stat_ind *objp;
 399 {
 400         printf("%sspans_parm_stat_ind\n", spans_indent);
 401         inc_indent();
 402         printf("%sstind_sw_epoch       %d\n", spans_indent,
 403                         objp->stind_sw_epoch);
 404         spans_print_addr(&objp->stind_es_addr);
 405         spans_print_addr(&objp->stind_sw_addr);
 406         dec_indent();
 407 }
 408
 409 static void
 410 spans_print_parm_stat_rsp(objp)
 411         spans_parm_stat_rsp *objp;
 412 {
 413         printf("%sspans_parm_stat_rsp\n", spans_indent);
 414         inc_indent();
 415         printf("%sstrsp_es_epoch       %d\n", spans_indent,
 416                         objp->strsp_es_epoch);
 417         spans_print_addr(&objp->strsp_es_addr);
 418         dec_indent();
 419 }
 420
 421 static void
 422 spans_print_parm_open_req(objp)
 423         spans_parm_open_req *objp;
 424 {
 425         printf("%sspans_parm_open_req\n", spans_indent);
 426         inc_indent();
 427         spans_print_atm_conn(&objp->opreq_conn);
 428         spans_print_aal(&objp->opreq_aal);
 429         spans_print_resrc(&objp->opreq_desrsrc);
 430         spans_print_resrc(&objp->opreq_minrsrc);
 431         spans_print_vpvc_pref(&objp->opreq_vpvc);
 432         dec_indent();
 433 }
 434
 435 static void
 436 spans_print_parm_open_ind(objp)
 437         spans_parm_open_ind *objp;
 438 {
 439         printf("%sspans_parm_open_ind\n", spans_indent);
 440         inc_indent();
 441         spans_print_atm_conn(&objp->opind_conn);
 442         spans_print_aal(&objp->opind_aal);
 443         spans_print_resrc(&objp->opind_desrsrc);
 444         spans_print_resrc(&objp->opind_minrsrc);
 445         spans_print_vpvc_pref(&objp->opind_vpvc);
 446         dec_indent();
 447 }
 448
 449 static void
 450 spans_print_parm_open_rsp(objp)
 451         spans_parm_open_rsp *objp;
 452 {
 453         printf("%sspans_parm_open_rsp\n", spans_indent);
 454         inc_indent();
 455         spans_print_atm_conn(&objp->oprsp_conn);
 456         spans_print_result(&objp->oprsp_result);
 457         spans_print_resrc(&objp->oprsp_rsrc);
 458         spans_print_vpvc(&objp->oprsp_vpvc);
 459         dec_indent();
 460 }
 461
 462 static void
 463 spans_print_parm_open_cnf(objp)
 464         spans_parm_open_cnf *objp;
 465 {
 466         printf("%sspans_parm_open_cnf\n", spans_indent);
 467         inc_indent();
 468         spans_print_atm_conn(&objp->opcnf_conn);
 469         spans_print_result(&objp->opcnf_result);
 470         spans_print_resrc(&objp->opcnf_rsrc);
 471         spans_print_vpvc(&objp->opcnf_vpvc);
 472         dec_indent();
 473 }
 474
 475 static void
 476 spans_print_parm_close_req(objp)
 477         spans_parm_close_req *objp;
 478 {
 479         printf("%sspans_parm_close_req\n", spans_indent);
 480         inc_indent();
 481         spans_print_atm_conn(&objp->clreq_conn);
 482         dec_indent();
 483 }
 484
 485 static void
 486 spans_print_parm_close_ind(objp)
 487         spans_parm_close_ind *objp;
 488 {
 489         printf("%sspans_parm_close_ind\n", spans_indent);
 490         inc_indent();
 491         spans_print_atm_conn(&objp->clind_conn);
 492         dec_indent();
 493 }
 494
 495 static void
 496 spans_print_parm_close_rsp(objp)
 497         spans_parm_close_rsp *objp;
 498 {
 499         printf("%sspans_parm_close_rsp\n", spans_indent);
 500         inc_indent();
 501         spans_print_atm_conn(&objp->clrsp_conn);
 502         spans_print_result(&objp->clrsp_result);
 503         dec_indent();
 504 }
 505
 506 static void
 507 spans_print_parm_close_cnf(objp)
 508         spans_parm_close_cnf *objp;
 509 {
 510         printf("%sspans_parm_close_cnf\n", spans_indent);
 511         inc_indent();
 512         spans_print_atm_conn(&objp->clcnf_conn);
 513         spans_print_result(&objp->clcnf_result);
 514         dec_indent();
 515 }
 516
 517 static void
 518 spans_print_parm_rclose_req(objp)
 519         spans_parm_rclose_req *objp;
 520 {
 521         printf("%sspans_parm_rclose_req\n", spans_indent);
 522         inc_indent();
 523         spans_print_atm_conn(&objp->rcreq_conn);
 524         dec_indent();
 525 }
 526
 527 static void
 528 spans_print_parm_rclose_ind(objp)
 529         spans_parm_rclose_ind *objp;
 530 {
 531         printf("%sspans_parm_rclose_ind\n", spans_indent);
 532         inc_indent();
 533         spans_print_atm_conn(&objp->rcind_conn);
 534         dec_indent();
 535 }
 536
 537 static void
 538 spans_print_parm_rclose_rsp(objp)
 539         spans_parm_rclose_rsp *objp;
 540 {
 541         printf("%sspans_parm_rclose_rsp\n", spans_indent);
 542         inc_indent();
 543         spans_print_atm_conn(&objp->rcrsp_conn);
 544         spans_print_result(&objp->rcrsp_result);
 545         dec_indent();
 546 }
 547
 548 static void
 549 spans_print_parm_rclose_cnf(objp)
 550         spans_parm_rclose_cnf *objp;
 551 {
 552         printf("%sspans_parm_rclose_cnf\n", spans_indent);
 553         inc_indent();
 554         spans_print_atm_conn(&objp->rccnf_conn);
 555         spans_print_result(&objp->rccnf_result);
 556         dec_indent();
 557 }
 558
 559 static void
 560 spans_print_parm_multi_req(objp)
 561         spans_parm_multi_req *objp;
 562 {
 563         printf("%sspans_parm_multi_req\n", spans_indent);
 564         inc_indent();
 565         spans_print_atm_conn(&objp->mureq_conn);
 566         spans_print_aal(&objp->mureq_aal);
 567         spans_print_resrc(&objp->mureq_desrsrc);
 568         spans_print_resrc(&objp->mureq_minrsrc);
 569         spans_print_vpvc(&objp->mureq_vpvc);
 570         dec_indent();
 571 }
 572
 573 static void
 574 spans_print_parm_multi_ind(objp)
 575         spans_parm_multi_ind *objp;
 576 {
 577         printf("%sspans_parm_multi_ind\n", spans_indent);
 578         inc_indent();
 579         spans_print_atm_conn(&objp->muind_conn);
 580         spans_print_aal(&objp->muind_aal);
 581         spans_print_resrc(&objp->muind_desrsrc);
 582         spans_print_resrc(&objp->muind_minrsrc);
 583         spans_print_vpvc(&objp->muind_vpvc);
 584         dec_indent();
 585 }
 586
 587 static void
 588 spans_print_parm_multi_rsp(objp)
 589         spans_parm_multi_rsp *objp;
 590 {
 591         printf("%sspans_parm_multi_rsp\n", spans_indent);
 592         inc_indent();
 593         spans_print_atm_conn(&objp->mursp_conn);
 594         spans_print_result(&objp->mursp_result);
 595         spans_print_resrc(&objp->mursp_rsrc);
 596         spans_print_vpvc(&objp->mursp_vpvc);
 597         dec_indent();
 598 }
 599
 600 static void
 601 spans_print_parm_multi_cnf(objp)
 602         spans_parm_multi_cnf *objp;
 603 {
 604         printf("%sspans_parm_multi_cnf\n", spans_indent);
 605         inc_indent();
 606         spans_print_atm_conn(&objp->mucnf_conn);
 607         spans_print_result(&objp->mucnf_result);
 608         spans_print_resrc(&objp->mucnf_rsrc);
 609         spans_print_vpvc(&objp->mucnf_vpvc);
 610         dec_indent();
 611 }
 612
 613 static void
 614 spans_print_parm_add_req(objp)
 615         spans_parm_add_req *objp;
 616 {
 617         printf("%sspans_parm_add_req\n", spans_indent);
 618         inc_indent();
 619         spans_print_atm_conn(&objp->adreq_desconn);
 620         spans_print_atm_conn(&objp->adreq_xstconn);
 621         dec_indent();
 622 }
 623
 624 static void
 625 spans_print_parm_add_ind(objp)
 626         spans_parm_add_ind *objp;
 627 {
 628         printf("%sspans_parm_add_ind\n", spans_indent);
 629         inc_indent();
 630         spans_print_atm_conn(&objp->adind_desconn);
 631         spans_print_atm_conn(&objp->adind_xstconn);
 632         dec_indent();
 633 }
 634
 635 static void
 636 spans_print_parm_add_rsp(objp)
 637         spans_parm_add_rsp *objp;
 638 {
 639         printf("%sspans_parm_add_rsp\n", spans_indent);
 640         inc_indent();
 641         spans_print_atm_conn(&objp->adrsp_conn);
 642         spans_print_result(&objp->adrsp_result);
 643         spans_print_resrc(&objp->adrsp_rsrc);
 644         dec_indent();
 645 }
 646
 647 static void
 648 spans_print_parm_add_cnf(objp)
 649         spans_parm_add_cnf *objp;
 650 {
 651         printf("%sspans_parm_add_cnf\n", spans_indent);
 652         inc_indent();
 653         spans_print_atm_conn(&objp->adcnf_conn);
 654         spans_print_result(&objp->adcnf_result);
 655         spans_print_resrc(&objp->adcnf_rsrc);
 656         dec_indent();
 657 }
 658
 659 static void
 660 spans_print_parm_join_req(objp)
 661         spans_parm_join_req *objp;
 662 {
 663         printf("%sspans_parm_join_req\n", spans_indent);
 664         inc_indent();
 665         spans_print_addr(&objp->jnreq_addr);
 666         dec_indent();
 667 }
 668
 669 static void
 670 spans_print_parm_join_cnf(objp)
 671         spans_parm_join_cnf *objp;
 672 {
 673         printf("%sspans_print_parm_join_cnf\n", spans_indent);
 674         inc_indent();
 675         spans_print_addr(&objp->jncnf_addr);
 676         spans_print_result(&objp->jncnf_result);
 677         dec_indent();
 678 }
 679
 680 static void
 681 spans_print_parm_leave_req(objp)
 682         spans_parm_leave_req *objp;
 683 {
 684         printf("%sspans_print_parm_leave_req\n", spans_indent);
 685         inc_indent();
 686         spans_print_addr(&objp->lvreq_addr);
 687         dec_indent();
 688 }
 689
 690 static void
 691 spans_print_parm_leave_cnf(objp)
 692         spans_parm_leave_cnf *objp;
 693 {
 694         printf("%sspans_parm_leave_cnf\n", spans_indent);
 695         inc_indent();
 696         spans_print_addr(&objp->lvcnf_addr);
 697         spans_print_result(&objp->lvcnf_result);
 698         dec_indent();
 699 }
 700
 701 static void
 702 spans_print_parm_vcir_ind(objp)
 703         spans_parm_vcir_ind *objp;
 704 {
 705         printf("%sspans_parm_vcir_ind\n", spans_indent);
 706         inc_indent();
 707         printf("%svrind_min            %d\n", spans_indent, objp->vrind_min);
 708         printf("%svrind_max            %d\n", spans_indent, objp->vrind_max);
 709         dec_indent();
 710 }
 711
 712 static void
 713 spans_print_parm_query_req(objp)
 714         spans_parm_query_req *objp;
 715 {
 716         char query_type_str[80];
 717
 718         printf("%sspans_parm_query_req\n", spans_indent);
 719         inc_indent();
 720         spans_print_atm_conn(&objp->qyreq_conn);
 721         spans_query_type_str(&objp->qyreq_type,
 722                 query_type_str, sizeof(query_type_str));
 723         printf("%sqyreq_type           %s\n", spans_indent, query_type_str);
 724         dec_indent();
 725 }
 726
 727 static void
 728 spans_print_parm_query_rsp(objp)
 729         spans_parm_query_rsp *objp;
 730 {
 731         char query_type_str[80], state_type_str[80];
 732
 733         printf("%sspans_parm_query_rsp\n", spans_indent);
 734         inc_indent();
 735         spans_print_atm_conn(&objp->qyrsp_conn);
 736         spans_query_type_str(&objp->qyrsp_type,
 737                 query_type_str, sizeof(query_type_str));
 738         printf("%sqyrsp_type           %s\n", spans_indent, query_type_str);
 739         spans_state_str(&objp->qyrsp_state,
 740                 state_type_str, sizeof(state_type_str));
 741         printf("%sqyrsp_state          %s\n", spans_indent, state_type_str);
 742         printf("%sqyrsp_data           0x%x\n", spans_indent,
 743                         objp->qyrsp_data);
 744         dec_indent();
 745 }
 746
 747 static void
 748 spans_print_msgbody(objp)
 749         spans_msgbody *objp;
 750 {
 751         printf("%sspans_msgbody\n", spans_indent);
 752         inc_indent();
 753         spans_print_msgtype(&objp->mb_type);
 754         switch (objp->mb_type) {
 755         case SPANS_STAT_REQ:
 756                 spans_print_parm_stat_req(&objp->spans_msgbody_u.mb_stat_req);
 757                 break;
 758         case SPANS_STAT_IND:
 759                 spans_print_parm_stat_ind(&objp->spans_msgbody_u.mb_stat_ind);
 760                 break;
 761         case SPANS_STAT_RSP:
 762                 spans_print_parm_stat_rsp(&objp->spans_msgbody_u.mb_stat_rsp);
 763                 break;
 764         case SPANS_OPEN_REQ:
 765                 spans_print_parm_open_req(&objp->spans_msgbody_u.mb_open_req);
 766                 break;
 767         case SPANS_OPEN_IND:
 768                 spans_print_parm_open_ind(&objp->spans_msgbody_u.mb_open_ind);
 769                 break;
 770         case SPANS_OPEN_RSP:
 771                 spans_print_parm_open_rsp(&objp->spans_msgbody_u.mb_open_rsp);
 772                 break;
 773         case SPANS_OPEN_CNF:
 774                 spans_print_parm_open_cnf(&objp->spans_msgbody_u.mb_open_cnf);
 775                 break;
 776         case SPANS_CLOSE_REQ:
 777                 spans_print_parm_close_req(&objp->spans_msgbody_u.mb_close_req);
 778                 break;
 779         case SPANS_CLOSE_IND:
 780                 spans_print_parm_close_ind(&objp->spans_msgbody_u.mb_close_ind);
 781                 break;
 782         case SPANS_CLOSE_RSP:
 783                 spans_print_parm_close_rsp(&objp->spans_msgbody_u.mb_close_rsp);
 784                 break;
 785         case SPANS_CLOSE_CNF:
 786                 spans_print_parm_close_cnf(&objp->spans_msgbody_u.mb_close_cnf);
 787                 break;
 788         case SPANS_RCLOSE_REQ:
 789                 spans_print_parm_rclose_req(&objp->spans_msgbody_u.mb_rclose_req);
 790                 break;
 791         case SPANS_RCLOSE_IND:
 792                 spans_print_parm_rclose_ind(&objp->spans_msgbody_u.mb_rclose_ind);
 793                 break;
 794         case SPANS_RCLOSE_RSP:
 795                 spans_print_parm_rclose_rsp(&objp->spans_msgbody_u.mb_rclose_rsp);
 796                 break;
 797         case SPANS_RCLOSE_CNF:
 798                 spans_print_parm_rclose_cnf(&objp->spans_msgbody_u.mb_rclose_cnf);
 799                 break;
 800         case SPANS_MULTI_REQ:
 801                 spans_print_parm_multi_req(&objp->spans_msgbody_u.mb_multi_req);
 802                 break;
 803         case SPANS_MULTI_IND:
 804                 spans_print_parm_multi_ind(&objp->spans_msgbody_u.mb_multi_ind);
 805                 break;
 806         case SPANS_MULTI_RSP:
 807                 spans_print_parm_multi_rsp(&objp->spans_msgbody_u.mb_multi_rsp);
 808                 break;
 809         case SPANS_MULTI_CNF:
 810                 spans_print_parm_multi_cnf(&objp->spans_msgbody_u.mb_multi_cnf);
 811                 break;
 812         case SPANS_ADD_REQ:
 813                 spans_print_parm_add_req(&objp->spans_msgbody_u.mb_add_req);
 814                 break;
 815         case SPANS_ADD_IND:
 816                 spans_print_parm_add_ind(&objp->spans_msgbody_u.mb_add_ind);
 817                 break;
 818         case SPANS_ADD_RSP:
 819                 spans_print_parm_add_rsp(&objp->spans_msgbody_u.mb_add_rsp);
 820                 break;
 821         case SPANS_ADD_CNF:
 822                 spans_print_parm_add_cnf(&objp->spans_msgbody_u.mb_add_cnf);
 823                 break;
 824         case SPANS_JOIN_REQ:
 825                 spans_print_parm_join_req(&objp->spans_msgbody_u.mb_join_req);
 826                 break;
 827         case SPANS_JOIN_CNF:
 828                 spans_print_parm_join_cnf(&objp->spans_msgbody_u.mb_join_cnf);
 829                 break;
 830         case SPANS_LEAVE_REQ:
 831                 spans_print_parm_leave_req(&objp->spans_msgbody_u.mb_leave_req);
 832                 break;
 833         case SPANS_LEAVE_CNF:
 834                 spans_print_parm_leave_cnf(&objp->spans_msgbody_u.mb_leave_cnf);
 835                 break;
 836         case SPANS_VCIR_IND:
 837                 spans_print_parm_vcir_ind(&objp->spans_msgbody_u.mb_vcir_ind);
 838                 break;
 839         case SPANS_QUERY_REQ:
 840                 spans_print_parm_query_req(&objp->spans_msgbody_u.mb_query_req);
 841                 break;
 842         case SPANS_QUERY_RSP:
 843                 spans_print_parm_query_rsp(&objp->spans_msgbody_u.mb_query_rsp);
 844                 break;
 845         }
 846         dec_indent();
 847 }
 848
 849 void
 850 spans_print_msg(objp)
 851         spans_msg *objp;
 852 {
 853         spans_indent = INIT_INDENT;
 854         printf("%sspans_msg\n", spans_indent);
 855         inc_indent();
 856         spans_print_version(&objp->sm_vers);
 857         spans_print_msgbody(&objp->sm_body);
 858         dec_indent();
 859 }
 860
 861 #else   /* ifdef LONGPRINT */
 862
 863 static void
 864 spans_print_msgbody(objp)
 865         spans_msgbody *objp;
 866 {
 867         char    daddr[80], msgtype_str[80], result_str[80], saddr[80];
 868         spans_parm_stat_req     *streq_p;
 869         spans_parm_stat_ind     *stind_p;
 870         spans_parm_stat_rsp     *strsp_p;
 871         spans_parm_open_req     *opreq_p;
 872         spans_parm_open_ind     *opind_p;
 873         spans_parm_open_rsp     *oprsp_p;
 874         spans_parm_open_cnf     *opcnf_p;
 875         spans_parm_close_req    *clreq_p;
 876         spans_parm_close_ind    *clind_p;
 877         spans_parm_close_rsp    *clrsp_p;
 878         spans_parm_close_cnf    *clcnf_p;
 879         spans_parm_rclose_req   *rcreq_p;
 880         spans_parm_rclose_ind   *rcind_p;
 881         spans_parm_rclose_rsp   *rcrsp_p;
 882         spans_parm_rclose_cnf   *rccnf_p;
 883
 884         spans_msgtype_str(&objp->mb_type, msgtype_str, sizeof(msgtype_str));
 885         printf("%s: ", msgtype_str);
 886         switch (objp->mb_type) {
 887         case SPANS_STAT_REQ:
 888                 streq_p = &objp->spans_msgbody_u.mb_stat_req;
 889                 printf("es_epoch=0x%lx", streq_p->streq_es_epoch);
 890                 break;
 891         case SPANS_STAT_IND:
 892                 stind_p = &objp->spans_msgbody_u.mb_stat_ind;
 893                 strncpy(daddr, spans_addr_print(&stind_p->stind_es_addr),
 894                                 sizeof(daddr));
 895                 strncpy(saddr, spans_addr_print(&stind_p->stind_sw_addr),
 896                                 sizeof(saddr));
 897                 printf("sw_epoch=0x%lx, es_addr=%s, sw_addr=0x%s",
 898                                 stind_p->stind_sw_epoch,
 899                                 daddr, saddr);
 900                 break;
 901         case SPANS_STAT_RSP:
 902                 strsp_p = &objp->spans_msgbody_u.mb_stat_rsp;
 903                 strncpy(daddr, spans_addr_print(&strsp_p->strsp_es_addr),
 904                                 sizeof(daddr));
 905                 printf("es_epoch=0x%lx, es_addr=%s",
 906                                 strsp_p->strsp_es_epoch, daddr);
 907                 break;
 908         case SPANS_OPEN_REQ:
 909                 opreq_p = &objp->spans_msgbody_u.mb_open_req;
 910                 strncpy(daddr, spans_addr_print(&opreq_p->opreq_conn.con_dst),
 911                                 sizeof(daddr));
 912                 strncpy(saddr, spans_addr_print(&opreq_p->opreq_conn.con_src),
 913                                 sizeof(saddr));
 914                 printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d, aal=%d",
 915                                 daddr, saddr,
 916                                 opreq_p->opreq_conn.con_dsap,
 917                                 opreq_p->opreq_conn.con_ssap,
 918                                 opreq_p->opreq_aal);
 919                 if (opreq_p->opreq_vpvc.vpf_valid)
 920                         printf(", vp.vc=%d.%d",
 921                                         SPANS_EXTRACT_VPI(opreq_p->opreq_vpvc.vpf_vpvc),
 922                                         SPANS_EXTRACT_VCI(opreq_p->opreq_vpvc.vpf_vpvc));
 923                 break;
 924         case SPANS_OPEN_IND:
 925                 opind_p = &objp->spans_msgbody_u.mb_open_ind;
 926                 strncpy(daddr, spans_addr_print(&opind_p->opind_conn.con_dst),
 927                                 sizeof(daddr));
 928                 strncpy(saddr, spans_addr_print(&opind_p->opind_conn.con_src),
 929                                 sizeof(saddr));
 930                 printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d, aal=%d",
 931                                 daddr, saddr,
 932                                 opind_p->opind_conn.con_dsap,
 933                                 opind_p->opind_conn.con_ssap,
 934                                 opind_p->opind_aal);
 935                 if (opind_p->opind_vpvc.vpf_valid)
 936                         printf(", vp.vc=%d.%d",
 937                                         SPANS_EXTRACT_VPI(opind_p->opind_vpvc.vpf_vpvc),
 938                                         SPANS_EXTRACT_VCI(opind_p->opind_vpvc.vpf_vpvc));
 939                 break;
 940         case SPANS_OPEN_RSP:
 941                 oprsp_p = &objp->spans_msgbody_u.mb_open_rsp;
 942                 strncpy(daddr, spans_addr_print(&oprsp_p->oprsp_conn.con_dst),
 943                                 sizeof(daddr));
 944                 strncpy(saddr, spans_addr_print(&oprsp_p->oprsp_conn.con_src),
 945                                 sizeof(saddr));
 946                 spans_result_str(&oprsp_p->oprsp_result, result_str,
 947                         sizeof(result_str));
 948                 printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d, vp.vc=%d.%d",
 949                                 result_str, daddr, saddr,
 950                                 oprsp_p->oprsp_conn.con_dsap,
 951                                 oprsp_p->oprsp_conn.con_ssap,
 952                                 SPANS_EXTRACT_VPI(oprsp_p->oprsp_vpvc),
 953                                 SPANS_EXTRACT_VCI(oprsp_p->oprsp_vpvc));
 954                 break;
 955         case SPANS_OPEN_CNF:
 956                 opcnf_p = &objp->spans_msgbody_u.mb_open_cnf;
 957                 strncpy(daddr, spans_addr_print(&opcnf_p->opcnf_conn.con_dst),
 958                                 sizeof(daddr));
 959                 strncpy(saddr, spans_addr_print(&opcnf_p->opcnf_conn.con_src),
 960                                 sizeof(saddr));
 961                 spans_result_str(&opcnf_p->opcnf_result, result_str,
 962                         sizeof(result_str));
 963                 printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d, vp.vc=%d.%d",
 964                                 result_str, daddr, saddr,
 965                                 opcnf_p->opcnf_conn.con_dsap,
 966                                 opcnf_p->opcnf_conn.con_ssap,
 967                                 SPANS_EXTRACT_VPI(opcnf_p->opcnf_vpvc),
 968                                 SPANS_EXTRACT_VCI(opcnf_p->opcnf_vpvc));
 969                 break;
 970         case SPANS_CLOSE_REQ:
 971                 clreq_p = &objp->spans_msgbody_u.mb_close_req;
 972                 strncpy(daddr, spans_addr_print(&clreq_p->clreq_conn.con_dst),
 973                                 sizeof(daddr));
 974                 strncpy(saddr, spans_addr_print(&clreq_p->clreq_conn.con_src),
 975                                 sizeof(saddr));
 976                 printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d",
 977                                 daddr, saddr,
 978                                 clreq_p->clreq_conn.con_dsap,
 979                                 clreq_p->clreq_conn.con_ssap);
 980                 break;
 981         case SPANS_CLOSE_IND:
 982                 clind_p = &objp->spans_msgbody_u.mb_close_ind;
 983                 strncpy(daddr, spans_addr_print(&clind_p->clind_conn.con_dst),
 984                                 sizeof(daddr));
 985                 strncpy(saddr, spans_addr_print(&clind_p->clind_conn.con_src),
 986                                 sizeof(saddr));
 987                 printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d",
 988                                 daddr, saddr,
 989                                 clind_p->clind_conn.con_dsap,
 990                                 clind_p->clind_conn.con_ssap);
 991                 break;
 992         case SPANS_CLOSE_RSP:
 993                 clrsp_p = &objp->spans_msgbody_u.mb_close_rsp;
 994                 strncpy(daddr, spans_addr_print(&clrsp_p->clrsp_conn.con_dst),
 995                                 sizeof(daddr));
 996                 strncpy(saddr, spans_addr_print(&clrsp_p->clrsp_conn.con_src),
 997                                 sizeof(saddr));
 998                 spans_result_str(&clrsp_p->clrsp_result, result_str,
 999                         sizeof(result_str));
1000                 printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d",
1001                                 result_str, daddr, saddr,
1002                                 clrsp_p->clrsp_conn.con_dsap,
1003                                 clrsp_p->clrsp_conn.con_ssap);
1004                 break;
1005         case SPANS_CLOSE_CNF:
1006                 clcnf_p = &objp->spans_msgbody_u.mb_close_cnf;
1007                 strncpy(daddr, spans_addr_print(&clcnf_p->clcnf_conn.con_dst),
1008                                 sizeof(daddr));
1009                 strncpy(saddr, spans_addr_print(&clcnf_p->clcnf_conn.con_src),
1010                                 sizeof(saddr));
1011                 spans_result_str(&clcnf_p->clcnf_result, result_str,
1012                         sizeof(result_str));
1013                 printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d",
1014                                 result_str, daddr, saddr,
1015                                 clcnf_p->clcnf_conn.con_dsap,
1016                                 clcnf_p->clcnf_conn.con_ssap);
1017                 break;
1018         case SPANS_RCLOSE_REQ:
1019                 rcreq_p = &objp->spans_msgbody_u.mb_rclose_req;
1020                 strncpy(daddr, spans_addr_print(&rcreq_p->rcreq_conn.con_dst),
1021                                 sizeof(daddr));
1022                 strncpy(saddr, spans_addr_print(&rcreq_p->rcreq_conn.con_src),
1023                                 sizeof(saddr));
1024                 printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d",
1025                                 daddr, saddr,
1026                                 rcreq_p->rcreq_conn.con_dsap,
1027                                 rcreq_p->rcreq_conn.con_ssap);
1028                 break;
1029         case SPANS_RCLOSE_IND:
1030                 rcind_p = &objp->spans_msgbody_u.mb_rclose_ind;
1031                 strncpy(daddr, spans_addr_print(&rcind_p->rcind_conn.con_dst),
1032                                 sizeof(daddr));
1033                 strncpy(saddr, spans_addr_print(&rcind_p->rcind_conn.con_src),
1034                                 sizeof(saddr));
1035                 printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d",
1036                                 daddr, saddr,
1037                                 rcind_p->rcind_conn.con_dsap,
1038                                 rcind_p->rcind_conn.con_ssap);
1039                 break;
1040         case SPANS_RCLOSE_RSP:
1041                 rcrsp_p = &objp->spans_msgbody_u.mb_rclose_rsp;
1042                 strncpy(daddr, spans_addr_print(&rcrsp_p->rcrsp_conn.con_dst),
1043                                 sizeof(daddr));
1044                 strncpy(saddr, spans_addr_print(&rcrsp_p->rcrsp_conn.con_src),
1045                                 sizeof(saddr));
1046                 spans_result_str(&rcrsp_p->rcrsp_result, result_str,
1047                         sizeof(result_str));
1048                 printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d",
1049                                 result_str, daddr, saddr,
1050                                 rcrsp_p->rcrsp_conn.con_dsap,
1051                                 rcrsp_p->rcrsp_conn.con_ssap);
1052                 break;
1053         case SPANS_RCLOSE_CNF:
1054                 rccnf_p = &objp->spans_msgbody_u.mb_rclose_cnf;
1055                 strncpy(daddr, spans_addr_print(&rccnf_p->rccnf_conn.con_dst),
1056                                 sizeof(daddr));
1057                 strncpy(saddr, spans_addr_print(&rccnf_p->rccnf_conn.con_src),
1058                                 sizeof(saddr));
1059                 spans_result_str(&rccnf_p->rccnf_result, result_str,
1060                         sizeof(result_str));
1061                 printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d",
1062                                 result_str, daddr, saddr,
1063                                 rccnf_p->rccnf_conn.con_dsap,
1064                                 rccnf_p->rccnf_conn.con_ssap);
1065                 break;
1066         default:
1067                 break;
1068         }
1069         printf("\n");
1070 }
1071
1072 void
1073 spans_print_msg(objp)
1074         spans_msg *objp;
1075 {
1076 #ifdef LONGPRINT
1077         spans_indent = INIT_INDENT;
1078 #endif
1079         spans_print_msgbody(&objp->sm_body);
1080 }
1081
1082 #endif  /* ifdef LONGPRINT */