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