tsdu2spkt.c

来自「ftam等标准协议服务器和客户端的源代码。」· C语言 代码 · 共 2,171 行 · 第 1/4 页

{
    if (c -> len)
	*(c -> top + c -> pgi) = (c -> len - c -> left) - (c -> pgi + 1);
}

/*  */

static	put2spdu (code, li, value, c)
int code;
int li;
char *value;
struct	local_buf *c;
{
    int     cl = li;
    char   *p1,
           *p2;

    if (c -> len) {
	cl += (li < 255) ? 2 : 4;
	if (c -> left >= cl)
	    c -> left -= cl;
	else {
/* XXX:	this clause of Dwight's is all WRONG, WRONG, WRONG.  I think we
	should make start_spdu() smarter, if necessary and change this to

	c -> len = 0;
	return;
*/
	char   *cp;
	    if (c -> allocli < 255)
		cl += 2;
	    cp = realloc (c -> top, (unsigned) (c -> len += cl));
	    if (cp == NULL) {
		c -> len = 0;
		return;
	    }
	    c -> ptr = (c -> top = cp) + (c -> len - c -> left);
	    if (c -> allocli < 255) {
		c -> allocli += cl;
		cl = c -> len - c -> left + 2;
		for (p1 = c -> ptr, p2 = p1 + 2; cl; cl--)
		    *p2-- = *p1--;
		c -> pgi += 2;
		c -> left -= 2;
	    }
	}
	*c -> ptr++ = code & 0xff;
	if (li < 255) {
	    *c -> ptr++ = li;
	    c -> li += 2 + li;
	}
	else {
	    *c -> ptr++ = 255;
	    *c -> ptr++ = (li >> 8) & 0xff;
	    *c -> ptr++ = li & 0xff;
	    c -> li += 4 + li;
	}

	bcopy (value, c -> ptr, li);
	c -> ptr += li;
    }
}

/*  */

int	spkt2tsdu (s, base, len)
register struct ssapkt *s;
char  **base;
int    *len;
{
    struct local_buf    c;
    char    isn[SIZE_CN_ISN + 1];

    c.len = 0;
    switch (s -> s_code) {
	case SPDU_CN: 
	    start_spdu (s, &c, CN_BASE_SIZE);
	    If_Set (SMASK_CN_REF)
		Put_Ref (s -> s_cn_reference, PI_CALLING_SS);
	    If_Set (SMASK_CN_OPT | SMASK_CN_TSDU | SMASK_CN_VRSN | SMASK_CN_ISN
		    | SMASK_CN_SET) {
		start_pgi (PGI_CN_ITEMS, &c);
		If_Set (SMASK_CN_OPT)
		    Put_Item (PI_PROTOCOL_OPT, (char *) &s -> s_options);
		If_Set (SMASK_CN_TSDU) {
		    u_long tsdu_maxsize = (s -> s_tsdu_init & 0xffff) << 16
			| s -> s_tsdu_resp & 0xffff;
		    tsdu_maxsize = htonl (tsdu_maxsize);
		    Put_Item (PI_TSDU_MAXSIZ, (char *) &tsdu_maxsize);
		}
		If_Set (SMASK_CN_VRSN)
		    Put_Item (PI_VERSION, (char *) &s -> s_cn_version);
		If_Set (SMASK_CN_ISN)
		    Put_SSN (PI_ISN, s -> s_isn);
		If_Set (SMASK_CN_SET)
		    Put_Item (PI_TOKEN_SET, (char *) &s -> s_settings);
		end_pgi (&c);
	    }
    	    If_Set (SMASK_CN_REQ) {
		u_short requirements = htons (s -> s_cn_require);
		Put_Item (PI_USER_REQ, (char *) &requirements);
	    }
	    If_Set (SMASK_CN_CALLING)
		put2spdu (PI_SSAP_CALLING, s -> s_callinglen, 
			    s -> s_calling, &c);
	    If_Set (SMASK_CN_CALLED)
		put2spdu (PI_SSAP_CALLED, s -> s_calledlen, 
			    s -> s_called, &c);
	    Put_XData (CN_SIZE);
	    break;

	case SPDU_AC: 
	    start_spdu (s, &c, AC_BASE_SIZE);
	    If_Set (SMASK_CN_REF)
		Put_Ref (s -> s_cn_reference, PI_CALLED_SS);
	    If_Set (SMASK_CN_OPT | SMASK_CN_TSDU | SMASK_CN_VRSN | SMASK_CN_ISN
		    | SMASK_CN_SET) {
		start_pgi (PGI_CN_ITEMS, &c);
		If_Set (SMASK_CN_OPT)
		    Put_Item (PI_PROTOCOL_OPT, (char *) &s -> s_options);
		If_Set (SMASK_CN_TSDU) {
		    u_long tsdu_maxsize = (s -> s_tsdu_init & 0xffff) << 16
			| s -> s_tsdu_resp & 0xffff;
		    tsdu_maxsize = htonl (tsdu_maxsize);
		    Put_Item (PI_TSDU_MAXSIZ, (char *) &tsdu_maxsize);
		}
		If_Set (SMASK_CN_VRSN)
		    Put_Item (PI_VERSION, (char *) &s -> s_cn_version);
		If_Set (SMASK_CN_ISN)
		    Put_SSN (PI_ISN, s -> s_isn);
		If_Set (SMASK_CN_SET)
		    Put_Item (PI_TOKEN_SET, (char *) &s -> s_settings);
		end_pgi (&c);
	    }
	    If_Set (SMASK_AC_TOKEN)
		Put_Item (PI_TOKEN, (char *) &s -> s_ac_token);
	    If_Set (SMASK_CN_REQ) {
		u_short requirements = htons (s -> s_cn_require);
		Put_Item (PI_USER_REQ, (char *) &requirements);
	    }
	    If_Set (SMASK_CN_CALLING)
		put2spdu (PI_SSAP_CALLING, s -> s_callinglen,
			    s -> s_calling, &c);
	    If_Set (SMASK_CN_CALLED)
		put2spdu (PI_SSAP_CALLED, s -> s_calledlen, 
			    s -> s_called, &c);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (AC_SIZE);
	    break;

	case SPDU_RF: 
	    start_spdu (s, &c, RF_BASE_SIZE);
	    If_Set (SMASK_RF_REF)
		Put_Ref (s -> s_rf_reference, PI_CALLED_SS);
	    If_Set (SMASK_RF_DISC)
		Put_Item (PI_TDISC, (char *) &s -> s_rf_disconnect);
	    If_Set (SMASK_RF_REQ) {
		u_short requirements = htons (s -> s_rf_require);
		Put_Item (PI_USER_REQ, (char *) &requirements);
	    }
	    If_Set (SMASK_RF_VRSN)
		Put_Item (PI_VERSION, (char *) &s -> s_rf_version);
	    if (s -> s_rlen > RF_SIZE) {
		if (c.len)
		    free (c.top);
		s -> s_errno = SC_PROTOCOL;
		return NOTOK;
	    }
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    if (s -> s_rlen > 0)
		put2spdu (PI_REASON, s -> s_rlen, s -> s_rdata, &c);
	    break;

	case SPDU_FN: 
	    start_spdu (s, &c, FN_BASE_SIZE);
	    If_Set (SMASK_FN_DISC)
		Put_Item (PI_TDISC, (char *) &s -> s_fn_disconnect);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (FN_SIZE);
	    break;

	case SPDU_DN: 
	    start_spdu (s, &c, DN_BASE_SIZE);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (DN_SIZE);
	    break;

	case SPDU_NF: 
	    start_spdu (s, &c, NF_BASE_SIZE);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (NF_SIZE);
	    break;

	case SPDU_AB: 
#ifdef	notdef
	case SPDU_AI:		/* aka SPDU_AB */
#endif
	    If_Set (SMASK_SPDU_AB) {
		start_spdu (s, &c, AB_BASE_SIZE);
		If_Reset (SMASK_AB_DISC) {
		    s -> s_errno = SC_PROTOCOL;
		    break;
		}
		Put_Item (PI_TDISC, (char *) &s -> s_ab_disconnect);
		If_Set (SMASK_AB_REFL)
		    put2spdu (PI_REFLECT, AB_REFL_SIZE,
				(char *) s -> s_reflect, &c);
		If_Set (SMASK_ENCLOSE)
		    Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
		Put_UData (AB_SIZE);
		break;
	    }
	    start_spdu (s, &c, AI_BASE_SIZE);
	    If_Set (SMASK_AI_REASON)
		put2spdu (PI_REASON, 1, (char *) &s -> s_ai_reason, &c);
	    break;

	case SPDU_AA: 
#ifdef	notdef
	case SPDU_AIA:		/* aka SPDU_AA */
#endif
	    If_Set (SMASK_SPDU_AA) {
		start_spdu (s, &c, AA_BASE_SIZE);
		break;
	    }
	    start_spdu (s, &c, AIA_BASE_SIZE);
	    break;

	case SPDU_GT:
#ifdef	notdef
	case SPDU_DT:		/* aka SPDU_GT */
#endif
	    If_Set (SMASK_SPDU_GT) {
		start_spdu (s, &c, GT_BASE_SIZE);
		If_Set (SMASK_GT_TOKEN)
		    Put_Item (PI_TOKEN, (char *) &s -> s_gt_token);
		break;
	    }			/* else fall */
	    start_spdu (s, &c, DT_BASE_SIZE);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
/* NB: caller responsible for mapping s -> s_udata to user info */
	    break;

#ifdef HULA

	case SPDU_UD:
#ifdef HULADEBUG
	    printf ("\n     spkt2tsdu:  formatting the  SUNITDATA \n");
#endif	    
	    start_spdu (s, &c, UD_BASE_SIZE);
	    If_Set (SMASK_UD_VERSION)
		Put_Item (PI_VERSION, (char *) &s -> s_ud_version);
	    If_Set (SMASK_UD_CALLING)
		put2spdu (PI_SSAP_CALLING, s -> s_ud_callinglen, 
			    s -> s_ud_calling, &c);
	    If_Set (SMASK_UD_CALLED)
		put2spdu (PI_SSAP_CALLED, s -> s_ud_calledlen, 
			    s -> s_ud_called, &c);
/* NB: caller responsible for mapping s -> s_udata to user info */
	    break;
	
#endif

	case SPDU_TD: 
	    start_spdu (s, &c, TD_BASE_SIZE);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
/* NB: caller responsible for mapping s -> s_udata to user info */
	    break;

	case SPDU_EX: 
	    start_spdu (s, &c, EX_BASE_SIZE);
/* NB: caller responsible for mapping s -> s_udata to user info */
	    break;

	case SPDU_CD: 
	    start_spdu (s, &c, CD_BASE_SIZE);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (CD_SIZE);
	    break;

	case SPDU_CDA: 
	    start_spdu (s, &c, CDA_BASE_SIZE);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (CDA_SIZE);
	    break;

	case SPDU_PT: 
	    start_spdu (s, &c, PT_BASE_SIZE);
	    If_Set (SMASK_PT_TOKEN)
		Put_Item (PI_TOKEN, (char *) &s -> s_pt_token);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (PT_SIZE);
	    break;

	case SPDU_GTC: 
	    start_spdu (s, &c, GTC_BASE_SIZE);
	    break;

	case SPDU_GTA: 
	    start_spdu (s, &c, GTA_BASE_SIZE);
	    break;

	case SPDU_MIP: 
	    start_spdu (s, &c, MIP_BASE_SIZE);
	    If_Set (SMASK_MIP_SYNC)
		Put_Item (PI_SYNC, (char *) &s -> s_mip_sync);
	    If_Reset (SMASK_MIP_SERIAL) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    Put_SSN (PI_SERIAL, s -> s_mip_serial);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (MIP_SIZE);
	    break;

	case SPDU_MAP: 
#ifdef	notdef
	case SPDU_AE:		/* aka SPDU_MAP */
#endif
	    If_Set (SMASK_MAP_SYNC) {
		start_spdu (s, &c, MAP_BASE_SIZE);
		Put_Item (PI_SYNC, (char *) &s -> s_map_sync);
	    }
	    else
		start_spdu (s, &c, AE_BASE_SIZE);
	    If_Reset (SMASK_MAP_SERIAL) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    Put_SSN (PI_SERIAL, s -> s_map_serial);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (MAP_SIZE);
	    break;

	case SPDU_MIA: 
	    start_spdu (s, &c, MIA_BASE_SIZE);
	    If_Reset (SMASK_MIA_SERIAL) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    Put_SSN (PI_SERIAL, s -> s_mia_serial);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_MData (MIA_SIZE);
	    break;

	case SPDU_MAA: 
#ifdef	notdef
	case SPDU_AEA:		/* aka SPDU_MAA */
#endif
	    start_spdu (s, &c, MAA_BASE_SIZE);
	    If_Reset (SMASK_MAA_SERIAL) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    Put_SSN (PI_SERIAL, s -> s_maa_serial);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (MAA_SIZE);
	    break;

	case SPDU_RS:
	    start_spdu (s, &c, RS_BASE_SIZE);
	    If_Set (SMASK_RS_SET)
		Put_Item (PI_TOKEN_SET, (char *) &s -> s_rs_settings);
	    If_Reset (SMASK_RS_TYPE) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    Put_Item (PI_RESYNC, (char *) &s -> s_rs_type);
	    If_Reset (SMASK_RS_SSN) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    Put_SSN (PI_SERIAL, s -> s_rs_serial);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (RS_SIZE);
	    break;

	case SPDU_RA:
	    start_spdu (s, &c, RA_BASE_SIZE);
	    If_Set (SMASK_RA_SET)
		Put_Item (PI_TOKEN_SET, (char *) &s -> s_ra_settings);
	    If_Reset (SMASK_RA_SSN) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    Put_SSN (PI_SERIAL, s -> s_ra_serial);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (RA_SIZE);
	    break;

	case SPDU_PR: 
	    start_spdu (s, &c, PR_BASE_SIZE);
	    If_Reset (SMASK_PR_TYPE) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    Put_Item (PI_PREPARE, (char *) &s -> s_pr_type);
	    break;

	case SPDU_ER:		/* we don't do these! */
	    s -> s_errno = SC_PROTOCOL;
	    break;

	case SPDU_ED: 
	    start_spdu (s, &c, ED_BASE_SIZE);
	    If_Reset (SMASK_ED_REASON) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    put2spdu (PI_REASON, 1, (char *) &s -> s_ed_reason, &c);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (ED_SIZE);
	    break;

	case SPDU_AS: 
	    start_spdu (s, &c, AS_BASE_SIZE);
	    If_Reset (SMASK_AS_ID) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    put2spdu (PI_ACT_ID, (int) s -> s_as_id.sd_len,
		s -> s_as_id.sd_data, &c);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (AS_SIZE);
	    break;

	case SPDU_AR:
	    start_spdu (s, &c, AR_BASE_SIZE);
	    start_pgi (PGI_AR_LINK, &c);
	    If_Set (SMASK_AR_REF) {
		if (s -> s_ar_reference.sr_called_len)
		    put2spdu (PI_AR_CALLED,
			    (int) s -> s_ar_reference.sr_called_len,
			    s -> s_ar_reference.sr_called, &c);
		if (s -> s_ar_reference.sr_calling_len)
		    put2spdu (PI_AR_CALLING,
			    (int) s -> s_ar_reference.sr_calling_len,
			    s -> s_ar_reference.sr_calling, &c);
		if (s -> s_ar_reference.sr_clen)
		    put2spdu (PI_AR_COMMON, (int) s -> s_ar_reference.sr_clen,
			    s -> s_ar_reference.sr_cdata, &c);
		if (s -> s_ar_reference.sr_alen)
		    put2spdu (PI_AR_ADDT, (int) s -> s_ar_reference.sr_alen,
			    s -> s_ar_reference.sr_adata, &c);
	    }
	    If_Reset (SMASK_AR_OID) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    put2spdu (PI_ACT_ID, (int) s -> s_ar_oid.sd_len,
		    s -> s_ar_oid.sd_data, &c);
	    If_Reset (SMASK_AR_SSN) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    Put_SSN (PI_SERIAL, s -> s_ar_serial);
	    end_pgi (&c);	    
	    If_Reset (SMASK_AR_ID) {
		s -> s_errno = SC_PROTOCOL;
		break;
	    }
	    put2spdu (PI_ACT_ID, (int) s -> s_ar_id.sd_len,
		s -> s_ar_id.sd_data, &c);
	    If_Set (SMASK_ENCLOSE)
		Put_Item (PI_ENCLOSE, (char *) &s -> s_enclose);
	    Put_UData (AR_SIZE);
	    break;

	case SPDU_AD: 
	    start_spdu (s, &c, AD_BASE_SIZE);
	    If_Set (SMASK_AD_REASON) 
		put2spdu (PI_REASON, 1, (char *) &s -> s_ad_reason, &c);
	    break;

	case SPDU_ADA: 
	    start_spdu (s, &c, ADA_BASE_SIZE);
	    break;

	default: 
	    s -> s_errno = SC_PROTOCOL;
	    break;
    }   /* end switch */

    if ((end_spdu (s -> s_code, &c) == NOTOK) || (s -> s_errno != SC_ACCEPT)) {
	if (s -> s_errno == SC_ACCEPT)
	    s -> s_errno = SC_CONGEST;
	if (c.len) {
	    free (c.top);
	    c.len = 0;
	}
	*base = NULL;
	*len = 0;
    }
    else {
	*base = c.top;
	*len = c.len;
	s -> s_li = c.li;
#ifdef HULADEBUG
	printf ("\n     encoded hdr: len = %d, li = %d \n", c.len, c.li);
#endif	
    }

#ifdef	DEBUG
    if (ssaplevel & ISODELOG_PDUS) {
	if (strcmp (ssapfile, "-")) {
	    char    file[BUFSIZ];
	    FILE   *fp;

	    (void) sprintf (file, ssapfile, getpid ());
	    if (fp = fopen (file, "a")) {
		spkt2text (fp, s, 0);
		(void) fclose (fp);
	    }
	}
	else {
	    (void) fflush (stdout);
	    spkt2text (stderr, s, 0);
	}
    }
#endif

    return c.len ? OK : NOTOK;
}

/*  */