diff options
Diffstat (limited to 'sys/netatm/spans/spans_print.c')
| -rw-r--r-- | sys/netatm/spans/spans_print.c | 1062 |
1 files changed, 1062 insertions, 0 deletions
diff --git a/sys/netatm/spans/spans_print.c b/sys/netatm/spans/spans_print.c new file mode 100644 index 0000000..60dc670 --- /dev/null +++ b/sys/netatm/spans/spans_print.c @@ -0,0 +1,1062 @@ +/* + * + * =================================== + * HARP | Host ATM Research Platform + * =================================== + * + * + * This Host ATM Research Platform ("HARP") file (the "Software") is + * made available by Network Computing Services, Inc. ("NetworkCS") + * "AS IS". NetworkCS does not provide maintenance, improvements or + * support of any kind. + * + * NETWORKCS MAKES NO WARRANTIES OR REPRESENTATIONS, EXPRESS OR IMPLIED, + * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE, AS TO ANY ELEMENT OF THE + * SOFTWARE OR ANY SUPPORT PROVIDED IN CONNECTION WITH THIS SOFTWARE. + * In no event shall NetworkCS be responsible for any damages, including + * but not limited to consequential damages, arising from or relating to + * any use of the Software or related support. + * + * Copyright 1994-1998 Network Computing Services, Inc. + * + * Copies of this Software may be made, however, the above copyright + * notice must be reproduced on all copies. + * + * @(#) $Id: spans_print.c,v 1.4 1997/05/06 22:17:11 mks Exp $ + * + */ + +/* + * SPANS Signalling Manager + * --------------------------- + * + * SPANS Print Routines. + * + */ + +#ifndef lint +static char *RCSid = "@(#) $Id: spans_print.c,v 1.4 1997/05/06 22:17:11 mks Exp $"; +#endif + +#include <netatm/kern_include.h> + +#include "spans_xdr.h" +#include <netatm/spans/spans_var.h> + +/* + * If LONGPRINT is defined, every field of the SPANS message will be + * printed. If not, a shorter summary (useful for debugging without + * swamping the console) is printed. + */ +/* #define LONGPRINT */ + +/* + * Local functions + */ +static void inc_indent __P((void)); +static void dec_indent __P((void)); +static void spans_aal_str __P((spans_aal *, char *)); +static void spans_result_str __P((spans_result *, char *)); +static void spans_msgtype_str __P((spans_msgtype *, char *)); +static void spans_query_type_str __P((spans_query_type *, char *)); +static void spans_state_str __P((spans_query_type *, char *)); +static void spans_print_version __P((spans_version *)); +static void spans_print_vpvc __P((spans_vpvc *)); +static void spans_print_vpvc_pref __P((spans_vpvc_pref *)); +static void spans_print_addr __P((spans_addr *)); +static void spans_print_sap __P((spans_sap *)); +static void spans_print_atm_conn __P((spans_atm_conn *)); +static void spans_print_resrc __P((spans_resrc *)); +static void spans_print_aal __P((spans_aal *)); +static void spans_print_result __P((spans_result *)); +static void spans_print_msgtype __P((spans_msgtype *)); +static void spans_print_parm_stat_req __P((spans_parm_stat_req *)); +static void spans_print_parm_stat_ind __P((spans_parm_stat_ind *)); +static void spans_print_parm_stat_rsp __P((spans_parm_stat_rsp *)); +static void spans_print_parm_open_req __P((spans_parm_open_req *)); +static void spans_print_parm_open_ind __P((spans_parm_open_ind *)); +static void spans_print_parm_open_rsp __P((spans_parm_open_rsp *)); +static void spans_print_parm_open_cnf __P((spans_parm_open_cnf *)); +static void spans_print_parm_close_req __P((spans_parm_close_req *)); +static void spans_print_parm_close_ind __P((spans_parm_close_ind *)); +static void spans_print_parm_close_rsp __P((spans_parm_close_rsp *)); +static void spans_print_parm_close_cnf __P((spans_parm_close_cnf *)); +static void spans_print_parm_rclose_req __P((spans_parm_rclose_req *)); +static void spans_print_parm_rclose_ind __P((spans_parm_rclose_ind *)); +static void spans_print_parm_rclose_rsp __P((spans_parm_rclose_rsp *)); +static void spans_print_parm_rclose_cnf __P((spans_parm_rclose_cnf *)); +static void spans_print_parm_multi_req __P((spans_parm_multi_req *)); +static void spans_print_parm_multi_ind __P((spans_parm_multi_ind *)); +static void spans_print_parm_multi_rsp __P((spans_parm_multi_rsp *)); +static void spans_print_parm_multi_cnf __P((spans_parm_multi_cnf *)); +static void spans_print_parm_add_req __P((spans_parm_add_req *)); +static void spans_print_parm_add_ind __P((spans_parm_add_ind *)); +static void spans_print_parm_add_rsp __P((spans_parm_add_rsp *)); +static void spans_print_parm_add_cnf __P((spans_parm_add_cnf *)); +static void spans_print_parm_join_req __P((spans_parm_join_req *)); +static void spans_print_parm_join_cnf __P((spans_parm_join_cnf *)); +static void spans_print_parm_leave_req __P((spans_parm_leave_req *)); +static void spans_print_parm_leave_cnf __P((spans_parm_leave_cnf *)); +static void spans_print_parm_vcir_ind __P((spans_parm_vcir_ind *)); +static void spans_print_parm_query_req __P((spans_parm_query_req *)); +static void spans_print_parm_query_rsp __P((spans_parm_query_rsp *)); +static void spans_print_msgbody __P((spans_msgbody *)); + + +/* + * Local variables + */ +#define MAX_INDENT 10 +#define INIT_INDENT &indent_str[MAX_INDENT] +static char *spans_indent; +static char indent_str[11] = " "; + +static void +inc_indent() +{ + if (spans_indent != &indent_str[0]) { + *spans_indent--; + } +} + +static void +dec_indent() +{ + if (spans_indent != INIT_INDENT) { + *spans_indent++; + } +} + +static void +spans_aal_str(objp, dest) + spans_aal *objp; + char *dest; +{ + static char *aal_names[] = { + "SPANS_AAL0", + "SPANS_AAL1", + "SPANS_AAL2", + "SPANS_AAL3", + "SPANS_AAL4", + "SPANS_AAL5" + }; + + if (*objp < SPANS_AAL0 || *objp > SPANS_AAL5) { + sprintf(dest, "Invalid (%d)", (int)*objp); + } else { + sprintf(dest, "%s (%d)", aal_names[(int)*objp], + (int)*objp); + } +} + +static void +spans_result_str(objp, dest) + spans_result *objp; + char *dest; +{ + static char *result_names[] = { + "SPANS_OK", + "SPANS_FAIL", + "SPANS_NOVPVC", + "SPANS_NORSC", + "SPANS_BADDEST" + }; + + if (*objp < SPANS_OK || *objp > SPANS_BADDEST) { + sprintf(dest, "Invalid (%d)", (int)*objp); + } else { + sprintf(dest, "%s (%d)", + result_names[(int)*objp], (int)*objp); + } +} + +static void +spans_msgtype_str(objp, dest) + spans_msgtype *objp; + char *dest; +{ + int i; + + static struct { + spans_msgtype type; + char *name; + } msgtype_names[] = { + { SPANS_STAT_REQ, "SPANS_STAT_REQ" }, + { SPANS_STAT_IND, "SPANS_STAT_IND" }, + { SPANS_STAT_RSP, "SPANS_STAT_RSP" }, + { SPANS_OPEN_REQ, "SPANS_OPEN_REQ" }, + { SPANS_OPEN_IND, "SPANS_OPEN_IND" }, + { SPANS_OPEN_RSP, "SPANS_OPEN_RSP" }, + { SPANS_OPEN_CNF, "SPANS_OPEN_CNF" }, + { SPANS_CLOSE_REQ, "SPANS_CLOSE_REQ" }, + { SPANS_CLOSE_IND, "SPANS_CLOSE_IND" }, + { SPANS_CLOSE_RSP, "SPANS_CLOSE_RSP" }, + { SPANS_CLOSE_CNF, "SPANS_CLOSE_CNF" }, + { SPANS_RCLOSE_REQ, "SPANS_RCLOSE_REQ" }, + { SPANS_RCLOSE_IND, "SPANS_RCLOSE_IND" }, + { SPANS_RCLOSE_RSP, "SPANS_RCLOSE_RSP" }, + { SPANS_RCLOSE_CNF, "SPANS_RCLOSE_CNF" }, + { SPANS_MULTI_REQ, "SPANS_MULTI_REQ" }, + { SPANS_MULTI_IND, "SPANS_MULTI_IND" }, + { SPANS_MULTI_RSP, "SPANS_MULTI_RSP" }, + { SPANS_MULTI_CNF, "SPANS_MULTI_CNF" }, + { SPANS_ADD_REQ, "SPANS_ADD_REQ" }, + { SPANS_ADD_IND, "SPANS_ADD_IND" }, + { SPANS_ADD_RSP, "SPANS_ADD_RSP" }, + { SPANS_ADD_CNF, "SPANS_ADD_CNF" }, + { SPANS_JOIN_REQ, "SPANS_JOIN_REQ" }, + { SPANS_JOIN_CNF, "SPANS_JOIN_CNF" }, + { SPANS_LEAVE_REQ, "SPANS_LEAVE_REQ" }, + { SPANS_LEAVE_CNF, "SPANS_LEAVE_CNF" }, + { SPANS_VCIR_IND, "SPANS_VCIR_IND" }, + { SPANS_QUERY_REQ, "SPANS_QUERY_REQ" }, + { SPANS_QUERY_RSP, "SPANS_QUERY_RSP" }, + { 0, (char *) 0 } + }; + + /* + * Search the name table for the specified type + */ + for (i=0; msgtype_names[i].name; i++) { + if (*objp == msgtype_names[i].type) { + sprintf(dest, "%s (%d)", + msgtype_names[i].name, + (int)*objp); + return; + } + } + + /* + * Type was not found--return an error indicator + */ + sprintf(dest, "Invalid (%d)", (int)*objp); +} + +static void +spans_query_type_str(objp, dest) + spans_query_type *objp; + char *dest; +{ + static char *query_names[] = { + "SPANS_QUERY_NORMAL", + "SPANS_QUERY_DEBUG", + "SPANS_QUERY_END_TO_END" + }; + + if (*objp < SPANS_QUERY_NORMAL || + *objp > SPANS_QUERY_END_TO_END) { + sprintf(dest, "Invalid (%d)", (int)*objp); + } else { + sprintf(dest, "%s (%d)", query_names[(int)*objp], + (int)*objp); + } +} + +static void +spans_state_str(objp, dest) + spans_query_type *objp; + char *dest; +{ + static char *state_names[] = { + "SPANS_CONN_OPEN", + "SPANS_CONN_OPEN_PEND", + "SPANS_CONN_CLOSE_PEND", + "SPANS_CONN_CLOSED" + }; + + if (*objp < SPANS_CONN_OPEN || *objp > SPANS_CONN_CLOSED) { + sprintf(dest, "Invalid (%d)", (int)*objp); + } else { + sprintf(dest, "%s (%d)", state_names[(int)*objp], + (int)*objp); + } +} + +#ifdef LONGPRINT + +static void +spans_print_version(objp) + spans_version *objp; +{ + printf("%sspans_version 0x%x\n", spans_indent, *objp); +} + +static void +spans_print_vpvc(objp) + spans_vpvc *objp; +{ + printf("%sVP/VC %d/%d\n", spans_indent, + SPANS_EXTRACT_VPI(*objp), + SPANS_EXTRACT_VCI(*objp)); +} + +static void +spans_print_vpvc_pref(objp) + spans_vpvc_pref *objp; +{ + printf("%sspans_vpvc_pref\n", spans_indent); + inc_indent(); + printf("%s%s\n", spans_indent, + (objp->vpf_valid ? "Valid" : "Not valid")); + spans_print_vpvc(&objp->vpf_vpvc); + dec_indent(); +} + +static void +spans_print_addr(objp) + spans_addr *objp; +{ + char addr_str[80]; + + strncpy(addr_str, spans_addr_print(objp), sizeof(addr_str)); + printf("%sspans_addr %s\n", spans_indent, addr_str); +} + +static void +spans_print_sap(objp) + spans_sap *objp; +{ + printf("%sSAP %d\n", spans_indent, *objp); +} + +static void +spans_print_atm_conn(objp) + spans_atm_conn *objp; +{ + printf("%sspans_atm_conn\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->con_dst); + spans_print_addr(&objp->con_src); + spans_print_sap(&objp->con_dsap); + spans_print_sap(&objp->con_ssap); + dec_indent(); +} + +static void +spans_print_resrc(objp) + spans_resrc *objp; +{ + printf("%sspans_resrc\n", spans_indent); + inc_indent(); + printf("%srsc_peak %d\n", spans_indent, objp->rsc_peak); + printf("%srsc_mean %d\n", spans_indent, objp->rsc_mean); + printf("%srsc_burst %d\n", spans_indent, objp->rsc_burst); + dec_indent(); +} + +static void +spans_print_aal(objp) + spans_aal *objp; +{ + char aal_str[80]; + + spans_aal_str(objp, aal_str); + printf("%sspans_aal %s\n", spans_indent, aal_str); +} + +static void +spans_print_result(objp) + spans_result *objp; +{ + char result_str[80]; + + spans_result_str(objp, result_str); + printf("%sspans_result %s\n", spans_indent, result_str); +} + +static void +spans_print_msgtype(objp) + spans_msgtype *objp; +{ + char msgtype_str[80]; + + spans_msgtype_str(objp, msgtype_str); + printf("%sspans_msgtype %s\n", spans_indent, msgtype_str); +} + +static void +spans_print_parm_stat_req(objp) + spans_parm_stat_req *objp; +{ + printf("%sspans_parm_stat_req\n", spans_indent); + inc_indent(); + printf("%sstreq_es_epoch %d\n", spans_indent, + objp->streq_es_epoch); + dec_indent(); +} + +static void +spans_print_parm_stat_ind(objp) + spans_parm_stat_ind *objp; +{ + printf("%sspans_parm_stat_ind\n", spans_indent); + inc_indent(); + printf("%sstind_sw_epoch %d\n", spans_indent, + objp->stind_sw_epoch); + spans_print_addr(&objp->stind_es_addr); + spans_print_addr(&objp->stind_sw_addr); + dec_indent(); +} + +static void +spans_print_parm_stat_rsp(objp) + spans_parm_stat_rsp *objp; +{ + printf("%sspans_parm_stat_rsp\n", spans_indent); + inc_indent(); + printf("%sstrsp_es_epoch %d\n", spans_indent, + objp->strsp_es_epoch); + spans_print_addr(&objp->strsp_es_addr); + dec_indent(); +} + +static void +spans_print_parm_open_req(objp) + spans_parm_open_req *objp; +{ + printf("%sspans_parm_open_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->opreq_conn); + spans_print_aal(&objp->opreq_aal); + spans_print_resrc(&objp->opreq_desrsrc); + spans_print_resrc(&objp->opreq_minrsrc); + spans_print_vpvc_pref(&objp->opreq_vpvc); + dec_indent(); +} + +static void +spans_print_parm_open_ind(objp) + spans_parm_open_ind *objp; +{ + printf("%sspans_parm_open_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->opind_conn); + spans_print_aal(&objp->opind_aal); + spans_print_resrc(&objp->opind_desrsrc); + spans_print_resrc(&objp->opind_minrsrc); + spans_print_vpvc_pref(&objp->opind_vpvc); + dec_indent(); +} + +static void +spans_print_parm_open_rsp(objp) + spans_parm_open_rsp *objp; +{ + printf("%sspans_parm_open_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->oprsp_conn); + spans_print_result(&objp->oprsp_result); + spans_print_resrc(&objp->oprsp_rsrc); + spans_print_vpvc(&objp->oprsp_vpvc); + dec_indent(); +} + +static void +spans_print_parm_open_cnf(objp) + spans_parm_open_cnf *objp; +{ + printf("%sspans_parm_open_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->opcnf_conn); + spans_print_result(&objp->opcnf_result); + spans_print_resrc(&objp->opcnf_rsrc); + spans_print_vpvc(&objp->opcnf_vpvc); + dec_indent(); +} + +static void +spans_print_parm_close_req(objp) + spans_parm_close_req *objp; +{ + printf("%sspans_parm_close_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->clreq_conn); + dec_indent(); +} + +static void +spans_print_parm_close_ind(objp) + spans_parm_close_ind *objp; +{ + printf("%sspans_parm_close_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->clind_conn); + dec_indent(); +} + +static void +spans_print_parm_close_rsp(objp) + spans_parm_close_rsp *objp; +{ + printf("%sspans_parm_close_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->clrsp_conn); + spans_print_result(&objp->clrsp_result); + dec_indent(); +} + +static void +spans_print_parm_close_cnf(objp) + spans_parm_close_cnf *objp; +{ + printf("%sspans_parm_close_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->clcnf_conn); + spans_print_result(&objp->clcnf_result); + dec_indent(); +} + +static void +spans_print_parm_rclose_req(objp) + spans_parm_rclose_req *objp; +{ + printf("%sspans_parm_rclose_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->rcreq_conn); + dec_indent(); +} + +static void +spans_print_parm_rclose_ind(objp) + spans_parm_rclose_ind *objp; +{ + printf("%sspans_parm_rclose_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->rcind_conn); + dec_indent(); +} + +static void +spans_print_parm_rclose_rsp(objp) + spans_parm_rclose_rsp *objp; +{ + printf("%sspans_parm_rclose_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->rcrsp_conn); + spans_print_result(&objp->rcrsp_result); + dec_indent(); +} + +static void +spans_print_parm_rclose_cnf(objp) + spans_parm_rclose_cnf *objp; +{ + printf("%sspans_parm_rclose_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->rccnf_conn); + spans_print_result(&objp->rccnf_result); + dec_indent(); +} + +static void +spans_print_parm_multi_req(objp) + spans_parm_multi_req *objp; +{ + printf("%sspans_parm_multi_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->mureq_conn); + spans_print_aal(&objp->mureq_aal); + spans_print_resrc(&objp->mureq_desrsrc); + spans_print_resrc(&objp->mureq_minrsrc); + spans_print_vpvc(&objp->mureq_vpvc); + dec_indent(); +} + +static void +spans_print_parm_multi_ind(objp) + spans_parm_multi_ind *objp; +{ + printf("%sspans_parm_multi_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->muind_conn); + spans_print_aal(&objp->muind_aal); + spans_print_resrc(&objp->muind_desrsrc); + spans_print_resrc(&objp->muind_minrsrc); + spans_print_vpvc(&objp->muind_vpvc); + dec_indent(); +} + +static void +spans_print_parm_multi_rsp(objp) + spans_parm_multi_rsp *objp; +{ + printf("%sspans_parm_multi_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->mursp_conn); + spans_print_result(&objp->mursp_result); + spans_print_resrc(&objp->mursp_rsrc); + spans_print_vpvc(&objp->mursp_vpvc); + dec_indent(); +} + +static void +spans_print_parm_multi_cnf(objp) + spans_parm_multi_cnf *objp; +{ + printf("%sspans_parm_multi_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->mucnf_conn); + spans_print_result(&objp->mucnf_result); + spans_print_resrc(&objp->mucnf_rsrc); + spans_print_vpvc(&objp->mucnf_vpvc); + dec_indent(); +} + +static void +spans_print_parm_add_req(objp) + spans_parm_add_req *objp; +{ + printf("%sspans_parm_add_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->adreq_desconn); + spans_print_atm_conn(&objp->adreq_xstconn); + dec_indent(); +} + +static void +spans_print_parm_add_ind(objp) + spans_parm_add_ind *objp; +{ + printf("%sspans_parm_add_ind\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->adind_desconn); + spans_print_atm_conn(&objp->adind_xstconn); + dec_indent(); +} + +static void +spans_print_parm_add_rsp(objp) + spans_parm_add_rsp *objp; +{ + printf("%sspans_parm_add_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->adrsp_conn); + spans_print_result(&objp->adrsp_result); + spans_print_resrc(&objp->adrsp_rsrc); + dec_indent(); +} + +static void +spans_print_parm_add_cnf(objp) + spans_parm_add_cnf *objp; +{ + printf("%sspans_parm_add_cnf\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->adcnf_conn); + spans_print_result(&objp->adcnf_result); + spans_print_resrc(&objp->adcnf_rsrc); + dec_indent(); +} + +static void +spans_print_parm_join_req(objp) + spans_parm_join_req *objp; +{ + printf("%sspans_parm_join_req\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->jnreq_addr); + dec_indent(); +} + +static void +spans_print_parm_join_cnf(objp) + spans_parm_join_cnf *objp; +{ + printf("%sspans_print_parm_join_cnf\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->jncnf_addr); + spans_print_result(&objp->jncnf_result); + dec_indent(); +} + +static void +spans_print_parm_leave_req(objp) + spans_parm_leave_req *objp; +{ + printf("%sspans_print_parm_leave_req\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->lvreq_addr); + dec_indent(); +} + +static void +spans_print_parm_leave_cnf(objp) + spans_parm_leave_cnf *objp; +{ + printf("%sspans_parm_leave_cnf\n", spans_indent); + inc_indent(); + spans_print_addr(&objp->lvcnf_addr); + spans_print_result(&objp->lvcnf_result); + dec_indent(); +} + +static void +spans_print_parm_vcir_ind(objp) + spans_parm_vcir_ind *objp; +{ + printf("%sspans_parm_vcir_ind\n", spans_indent); + inc_indent(); + printf("%svrind_min %d\n", spans_indent, objp->vrind_min); + printf("%svrind_max %d\n", spans_indent, objp->vrind_max); + dec_indent(); +} + +static void +spans_print_parm_query_req(objp) + spans_parm_query_req *objp; +{ + char query_type_str[80]; + + printf("%sspans_parm_query_req\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->qyreq_conn); + spans_query_type_str(&objp->qyreq_type, query_type_str); + printf("%sqyreq_type %s\n", spans_indent, query_type_str); + dec_indent(); +} + +static void +spans_print_parm_query_rsp(objp) + spans_parm_query_rsp *objp; +{ + char query_type_str[80], state_type_str[80]; + + printf("%sspans_parm_query_rsp\n", spans_indent); + inc_indent(); + spans_print_atm_conn(&objp->qyrsp_conn); + spans_query_type_str(&objp->qyrsp_type, query_type_str); + printf("%sqyrsp_type %s\n", spans_indent, query_type_str); + spans_state_str(&objp->qyrsp_state, state_type_str); + printf("%sqyrsp_state %s\n", spans_indent, state_type_str); + printf("%sqyrsp_data 0x%x\n", spans_indent, + objp->qyrsp_data); + dec_indent(); +} + +static void +spans_print_msgbody(objp) + spans_msgbody *objp; +{ + printf("%sspans_msgbody\n", spans_indent); + inc_indent(); + spans_print_msgtype(&objp->mb_type); + switch (objp->mb_type) { + case SPANS_STAT_REQ: + spans_print_parm_stat_req(&objp->spans_msgbody_u.mb_stat_req); + break; + case SPANS_STAT_IND: + spans_print_parm_stat_ind(&objp->spans_msgbody_u.mb_stat_ind); + break; + case SPANS_STAT_RSP: + spans_print_parm_stat_rsp(&objp->spans_msgbody_u.mb_stat_rsp); + break; + case SPANS_OPEN_REQ: + spans_print_parm_open_req(&objp->spans_msgbody_u.mb_open_req); + break; + case SPANS_OPEN_IND: + spans_print_parm_open_ind(&objp->spans_msgbody_u.mb_open_ind); + break; + case SPANS_OPEN_RSP: + spans_print_parm_open_rsp(&objp->spans_msgbody_u.mb_open_rsp); + break; + case SPANS_OPEN_CNF: + spans_print_parm_open_cnf(&objp->spans_msgbody_u.mb_open_cnf); + break; + case SPANS_CLOSE_REQ: + spans_print_parm_close_req(&objp->spans_msgbody_u.mb_close_req); + break; + case SPANS_CLOSE_IND: + spans_print_parm_close_ind(&objp->spans_msgbody_u.mb_close_ind); + break; + case SPANS_CLOSE_RSP: + spans_print_parm_close_rsp(&objp->spans_msgbody_u.mb_close_rsp); + break; + case SPANS_CLOSE_CNF: + spans_print_parm_close_cnf(&objp->spans_msgbody_u.mb_close_cnf); + break; + case SPANS_RCLOSE_REQ: + spans_print_parm_rclose_req(&objp->spans_msgbody_u.mb_rclose_req); + break; + case SPANS_RCLOSE_IND: + spans_print_parm_rclose_ind(&objp->spans_msgbody_u.mb_rclose_ind); + break; + case SPANS_RCLOSE_RSP: + spans_print_parm_rclose_rsp(&objp->spans_msgbody_u.mb_rclose_rsp); + break; + case SPANS_RCLOSE_CNF: + spans_print_parm_rclose_cnf(&objp->spans_msgbody_u.mb_rclose_cnf); + break; + case SPANS_MULTI_REQ: + spans_print_parm_multi_req(&objp->spans_msgbody_u.mb_multi_req); + break; + case SPANS_MULTI_IND: + spans_print_parm_multi_ind(&objp->spans_msgbody_u.mb_multi_ind); + break; + case SPANS_MULTI_RSP: + spans_print_parm_multi_rsp(&objp->spans_msgbody_u.mb_multi_rsp); + break; + case SPANS_MULTI_CNF: + spans_print_parm_multi_cnf(&objp->spans_msgbody_u.mb_multi_cnf); + break; + case SPANS_ADD_REQ: + spans_print_parm_add_req(&objp->spans_msgbody_u.mb_add_req); + break; + case SPANS_ADD_IND: + spans_print_parm_add_ind(&objp->spans_msgbody_u.mb_add_ind); + break; + case SPANS_ADD_RSP: + spans_print_parm_add_rsp(&objp->spans_msgbody_u.mb_add_rsp); + break; + case SPANS_ADD_CNF: + spans_print_parm_add_cnf(&objp->spans_msgbody_u.mb_add_cnf); + break; + case SPANS_JOIN_REQ: + spans_print_parm_join_req(&objp->spans_msgbody_u.mb_join_req); + break; + case SPANS_JOIN_CNF: + spans_print_parm_join_cnf(&objp->spans_msgbody_u.mb_join_cnf); + break; + case SPANS_LEAVE_REQ: + spans_print_parm_leave_req(&objp->spans_msgbody_u.mb_leave_req); + break; + case SPANS_LEAVE_CNF: + spans_print_parm_leave_cnf(&objp->spans_msgbody_u.mb_leave_cnf); + break; + case SPANS_VCIR_IND: + spans_print_parm_vcir_ind(&objp->spans_msgbody_u.mb_vcir_ind); + break; + case SPANS_QUERY_REQ: + spans_print_parm_query_req(&objp->spans_msgbody_u.mb_query_req); + break; + case SPANS_QUERY_RSP: + spans_print_parm_query_rsp(&objp->spans_msgbody_u.mb_query_rsp); + break; + } + dec_indent(); +} + +void +spans_print_msg(objp) + spans_msg *objp; +{ + spans_indent = INIT_INDENT; + printf("%sspans_msg\n", spans_indent); + inc_indent(); + spans_print_version(&objp->sm_vers); + spans_print_msgbody(&objp->sm_body); + dec_indent(); +} + +#else /* ifdef LONGPRINT */ + +static void +spans_print_msgbody(objp) + spans_msgbody *objp; +{ + char daddr[80], msgtype_str[80], result_str[80], saddr[80]; + spans_parm_stat_req *streq_p; + spans_parm_stat_ind *stind_p; + spans_parm_stat_rsp *strsp_p; + spans_parm_open_req *opreq_p; + spans_parm_open_ind *opind_p; + spans_parm_open_rsp *oprsp_p; + spans_parm_open_cnf *opcnf_p; + spans_parm_close_req *clreq_p; + spans_parm_close_ind *clind_p; + spans_parm_close_rsp *clrsp_p; + spans_parm_close_cnf *clcnf_p; + spans_parm_rclose_req *rcreq_p; + spans_parm_rclose_ind *rcind_p; + spans_parm_rclose_rsp *rcrsp_p; + spans_parm_rclose_cnf *rccnf_p; + + spans_msgtype_str(&objp->mb_type, msgtype_str); + printf("%s: ", msgtype_str); + switch (objp->mb_type) { + case SPANS_STAT_REQ: + streq_p = &objp->spans_msgbody_u.mb_stat_req; + printf("es_epoch=0x%x", streq_p->streq_es_epoch); + break; + case SPANS_STAT_IND: + stind_p = &objp->spans_msgbody_u.mb_stat_ind; + strncpy(daddr, spans_addr_print(&stind_p->stind_es_addr), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&stind_p->stind_sw_addr), + sizeof(daddr)); + printf("sw_epoch=0x%x, es_addr=%s, sw_addr=0x%s", + stind_p->stind_sw_epoch, + daddr, saddr); + break; + case SPANS_STAT_RSP: + strsp_p = &objp->spans_msgbody_u.mb_stat_rsp; + strncpy(daddr, spans_addr_print(&strsp_p->strsp_es_addr), + sizeof(daddr)); + printf("es_epoch=0x%x, es_addr=%s", + strsp_p->strsp_es_epoch, daddr); + break; + case SPANS_OPEN_REQ: + opreq_p = &objp->spans_msgbody_u.mb_open_req; + strncpy(daddr, spans_addr_print(&opreq_p->opreq_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&opreq_p->opreq_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d, aal=%d", + daddr, saddr, + opreq_p->opreq_conn.con_dsap, + opreq_p->opreq_conn.con_ssap, + opreq_p->opreq_aal); + if (opreq_p->opreq_vpvc.vpf_valid) + printf(", vp.vc=%d.%d", + SPANS_EXTRACT_VPI(opreq_p->opreq_vpvc.vpf_vpvc), + SPANS_EXTRACT_VCI(opreq_p->opreq_vpvc.vpf_vpvc)); + break; + case SPANS_OPEN_IND: + opind_p = &objp->spans_msgbody_u.mb_open_ind; + strncpy(daddr, spans_addr_print(&opind_p->opind_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&opind_p->opind_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d, aal=%d", + daddr, saddr, + opind_p->opind_conn.con_dsap, + opind_p->opind_conn.con_ssap, + opind_p->opind_aal); + if (opind_p->opind_vpvc.vpf_valid) + printf(", vp.vc=%d.%d", + SPANS_EXTRACT_VPI(opind_p->opind_vpvc.vpf_vpvc), + SPANS_EXTRACT_VCI(opind_p->opind_vpvc.vpf_vpvc)); + break; + case SPANS_OPEN_RSP: + oprsp_p = &objp->spans_msgbody_u.mb_open_rsp; + strncpy(daddr, spans_addr_print(&oprsp_p->oprsp_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&oprsp_p->oprsp_conn.con_src), + sizeof(saddr)); + spans_result_str(&oprsp_p->oprsp_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d, vp.vc=%d.%d", + result_str, daddr, saddr, + oprsp_p->oprsp_conn.con_dsap, + oprsp_p->oprsp_conn.con_ssap, + SPANS_EXTRACT_VPI(oprsp_p->oprsp_vpvc), + SPANS_EXTRACT_VCI(oprsp_p->oprsp_vpvc)); + break; + case SPANS_OPEN_CNF: + opcnf_p = &objp->spans_msgbody_u.mb_open_cnf; + strncpy(daddr, spans_addr_print(&opcnf_p->opcnf_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&opcnf_p->opcnf_conn.con_src), + sizeof(saddr)); + spans_result_str(&opcnf_p->opcnf_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d, vp.vc=%d.%d", + result_str, daddr, saddr, + opcnf_p->opcnf_conn.con_dsap, + opcnf_p->opcnf_conn.con_ssap, + SPANS_EXTRACT_VPI(opcnf_p->opcnf_vpvc), + SPANS_EXTRACT_VCI(opcnf_p->opcnf_vpvc)); + break; + case SPANS_CLOSE_REQ: + clreq_p = &objp->spans_msgbody_u.mb_close_req; + strncpy(daddr, spans_addr_print(&clreq_p->clreq_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&clreq_p->clreq_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d", + daddr, saddr, + clreq_p->clreq_conn.con_dsap, + clreq_p->clreq_conn.con_ssap); + break; + case SPANS_CLOSE_IND: + clind_p = &objp->spans_msgbody_u.mb_close_ind; + strncpy(daddr, spans_addr_print(&clind_p->clind_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&clind_p->clind_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d", + daddr, saddr, + clind_p->clind_conn.con_dsap, + clind_p->clind_conn.con_ssap); + break; + case SPANS_CLOSE_RSP: + clrsp_p = &objp->spans_msgbody_u.mb_close_rsp; + strncpy(daddr, spans_addr_print(&clrsp_p->clrsp_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&clrsp_p->clrsp_conn.con_src), + sizeof(saddr)); + spans_result_str(&clrsp_p->clrsp_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d", + result_str, daddr, saddr, + clrsp_p->clrsp_conn.con_dsap, + clrsp_p->clrsp_conn.con_ssap); + break; + case SPANS_CLOSE_CNF: + clcnf_p = &objp->spans_msgbody_u.mb_close_cnf; + strncpy(daddr, spans_addr_print(&clcnf_p->clcnf_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&clcnf_p->clcnf_conn.con_src), + sizeof(saddr)); + spans_result_str(&clcnf_p->clcnf_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d", + result_str, daddr, saddr, + clcnf_p->clcnf_conn.con_dsap, + clcnf_p->clcnf_conn.con_ssap); + break; + case SPANS_RCLOSE_REQ: + rcreq_p = &objp->spans_msgbody_u.mb_rclose_req; + strncpy(daddr, spans_addr_print(&rcreq_p->rcreq_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&rcreq_p->rcreq_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d", + daddr, saddr, + rcreq_p->rcreq_conn.con_dsap, + rcreq_p->rcreq_conn.con_ssap); + break; + case SPANS_RCLOSE_IND: + rcind_p = &objp->spans_msgbody_u.mb_rclose_ind; + strncpy(daddr, spans_addr_print(&rcind_p->rcind_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&rcind_p->rcind_conn.con_src), + sizeof(saddr)); + printf("daddr=%s, saddr=%s, dsap=%d, ssap=%d", + daddr, saddr, + rcind_p->rcind_conn.con_dsap, + rcind_p->rcind_conn.con_ssap); + break; + case SPANS_RCLOSE_RSP: + rcrsp_p = &objp->spans_msgbody_u.mb_rclose_rsp; + strncpy(daddr, spans_addr_print(&rcrsp_p->rcrsp_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&rcrsp_p->rcrsp_conn.con_src), + sizeof(saddr)); + spans_result_str(&rcrsp_p->rcrsp_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d", + result_str, daddr, saddr, + rcrsp_p->rcrsp_conn.con_dsap, + rcrsp_p->rcrsp_conn.con_ssap); + break; + case SPANS_RCLOSE_CNF: + rccnf_p = &objp->spans_msgbody_u.mb_rclose_cnf; + strncpy(daddr, spans_addr_print(&rccnf_p->rccnf_conn.con_dst), + sizeof(daddr)); + strncpy(saddr, spans_addr_print(&rccnf_p->rccnf_conn.con_src), + sizeof(saddr)); + spans_result_str(&rccnf_p->rccnf_result, result_str); + printf("result=%s, daddr=%s, saddr=%s, dsap=%d, ssap=%d", + result_str, daddr, saddr, + rccnf_p->rccnf_conn.con_dsap, + rccnf_p->rccnf_conn.con_ssap); + break; + } + printf("\n"); +} + +void +spans_print_msg(objp) + spans_msg *objp; +{ + spans_indent = INIT_INDENT; + spans_print_msgbody(&objp->sm_body); +} + +#endif /* ifdef LONGPRINT */ |
