psapunitdata.c

ftam等标准协议服务器和客户端的源代码。

    if ( pb -> pb_ncontext > 0 )
        if ( contexts2pdu ( pb, pdu ) == NOTOK )
            goto no_mem;


    if (data && ndata > 0
	     && (pdu -> user__data = info2_ppdu (pb, pi, data, ndata,
						  PPDU_UD)) == NULL)
	goto no_good;   


    pe = NULLPE;
    if (encode_PS_UD__type (&pe, 1, 0, NULLCP, pdu) == NOTOK) {
       (void) pusaplose (pi, PC_CONGEST, NULLCP, "error encoding PDU: %s",
            PY_pepy);
        goto no_good;
        }		


#ifdef	DEBUG
    if (psap2level & ISODELOG_PDUS)
	PS_print (pe, "UD-type", 0, print_PS_UD__type);
#endif


    if (pe2ssdu (pe, &pb -> pb_retry, &len) == NOTOK)
	goto no_mem;

    free_PS_UD__type (pdu);
    pdu = NULL;

    pe_free (pe);
    pe = NULLPE;

    if ((result = SUnitDataWrite ( sd, pb -> pb_retry, len, si )) == NOTOK ) 
	(void) ss2pulose (NULLPB, pi, "SUnitDataWrite", sa);
    goto out;



no_mem: ;
    (void) pusaplose (pi, PC_CONGEST, NULLCP, "out of memory");
no_good: ;
    result = NOTOK;
    if (pe) pe_free (pe);
    if (pdu) free_PS_UD__type (pdu);
out: ;
    if ( pb -> pb_retry ) free ( pb -> pb_retry );    /* ??? */   
    (void) sigiomask (smask);
    return result;
}





/*---------------------------------------------------------------------------*/
/*    get P-UNIT-DATA.INDICATON over locally bound association */
/*      socket must have been previously bound by PUnitDataBind() */
/*---------------------------------------------------------------------------*/
int	PUnitDataRead ( sd, ps, secs, pi )
/*---------------------------------------------------------------------------*/
int	sd;
struct  PuSAPstart *ps;
int	secs;
struct  PSAPindication *pi;
{
    SBV     smask;
    int     result, i, len;
    PE	    pe = NULLPE;
    char    *base;
    register struct psapblk *pb;
    struct SuSAPstart sss;
    register struct SuSAPstart *ss = &sss;
    struct SSAPindication sis;
    register struct SSAPindication *si = &sis;
    register struct SSAPabort *sa = &si -> si_abort;
    struct type_PS_UD__type *pdu;

    missingP (ps);
    missingP (pi);

    smask = sigioblock ();

    if ((pb = findpublk (sd)) == NULLPB || !(pb -> pb_flags & PB_PUDT)) {
        (void) sigiomask (smask);
        return pusaplose (pi, PC_PARAMETER, NULLCP,
	    "invalid presentation descriptor");
        }

    bzero ((char *) ps, sizeof *ps);
    bzero ((char *) pi, sizeof *pi);
    pdu = NULL;

    if ((result = SUnitDataRead (pb -> pb_fd, ss, secs, si)) == NOTOK) {
        (void) sigiomask (smask);
        if (sa -> sa_reason == SC_TIMER)
            return pusaplose (pi, PC_TIMER, NULLCP, NULLCP);
        return ss2pulose (pb, pi, NULLCP, sa);
	}

    if ((pe = ssdu2pe (ss -> ss_data, ss -> ss_cc, NULLCP, &result))
	    == NULLPE) {
	if (result == PS_ERR_NMEM) goto no_mem;
	(void) pusaplose ( pi, PC_PROTOCOL, NULLCP, "%s", ps_error (result));
	goto no_good;
        }

    SUSFREE (ss);    /* free the ss_data */

    if (decode_PS_UD__type (pe, 1, NULLIP, NULLVP, &pdu) == NOTOK) {
       (void) pusaplose (pi, PC_UNRECOGNIZED, NULLCP, "error decoding PDU: %s",
            PY_pepy);
        goto no_good;
        }		

#ifdef	DEBUG
    if (psap2level & ISODELOG_PDUS)
	PS_print (pe, "UD-type", 1, print_PS_UD__type);
#endif

    pe_free (pe);
    pe = ps -> ps_info[0] = NULLPE;


/*  build PuSAPstart structure */

    ps -> ps_sd = pb -> pb_fd;
    ps -> ps_ssdusize = ss -> ss_ssdusize;
    ps -> ps_sversion = ss -> ss_version; 
    ps -> ps_qos = ss -> ss_qos;    /* struct copy, because its there */ 

    ps -> ps_calling.pa_addr = ss -> ss_calling;    /* struct copy */
    if (pdu -> calling) {
	if ((base = qb2str (pdu -> calling)) == NULLCP)
	    goto no_mem;
	if ((len = pdu -> calling -> qb_len) >
	         sizeof ps -> ps_calling.pa_selector)
	    len = sizeof ps -> ps_calling.pa_selector;
	bcopy (base, ps -> ps_calling.pa_selector,
		ps -> ps_calling.pa_selectlen = len);
	free (base);
    }
    ps -> ps_called.pa_addr = ss -> ss_called;      /* struct copy */
    if (pdu -> called) {
	if ((base = qb2str (pdu -> called)) == NULLCP)
	    goto no_mem;
	if ((len = pdu -> called -> qb_len) >
	         sizeof ps -> ps_called.pa_selector)
	    len = sizeof ps -> ps_called.pa_selector;
	bcopy (base, ps -> ps_called.pa_selector,
		ps -> ps_called.pa_selectlen = len);
	free (base);
    }

    if ( pdu2contexts (pb, pdu -> context__list, &ps -> ps_ctxlist) == NOTOK ) {
        (void) pusaplose (pi, PC_TRANSFER, NULLCP,
			 "transfer syntax not supported");
	goto no_good;
	}
	
    result = ppdu2data (pb, pi, ps, pdu -> user__data);
    goto out;
 
no_mem: ;
    (void) pusaplose (pi, PC_CONGEST, NULLCP, "out of memory");
no_good: ;
    result = NOTOK;
    SUSFREE (ss);
    if (pe) pe_free (pe);
out: ;
    if (pdu) free_PS_UD__type (pdu);
    (void) sigiomask (smask);
    return result;
}



/*---------------------------------------------------------------------------*/
/*    clear local binding for P-UNIT-DATA */
/*---------------------------------------------------------------------------*/
int	PUnitDataUnbind ( sd, pi)
/*---------------------------------------------------------------------------*/
int	sd;
struct  PSAPindication *pi;
{
    SBV     smask;
    int     result;
    register struct psapblk *pb;
    struct SSAPindication sis;
    register struct SSAPindication *si = &sis;
    register struct SSAPabort *sa = &si -> si_abort;

    missingP (pi);
    smask = sigioblock ();

    if ((pb = findpublk (sd)) == NULLPB || !(pb -> pb_flags & PB_PUDT)) {
        (void) sigiomask (smask);
        return pusaplose (pi, PC_PARAMETER, NULLCP,
	    "invalid presentation descriptor");
        }

    if ((result = SUnitDataUnbind (pb -> pb_fd, si))
	    	== NOTOK) {
        (void) ss2pulose (pb, pi, "PUnitDataUnbind", sa);
	if (SC_FATAL (sa -> sa_reason))
	    goto out2;
	else
	    goto out1;
	}
    result = OK;

out2: ;
    freepublk (pb);

out1: ;
    (void) sigiomask (smask);
    return result;
}



/*---------------------------------------------------------------------------*/
/*    save magic args (TPDU) for local P-UNIT-DATA binding                 */
/*---------------------------------------------------------------------------*/
int	PuSave ( sd, vecp, vec, pi )
/*---------------------------------------------------------------------------*/
int	sd;
int	vecp;
char    **vec;
struct  PSAPindication *pi;
{
    int     result;
    register struct psapblk *pb;
    struct SSAPindication sis;
    register struct SSAPindication *si = &sis;
    register struct SSAPabort *sa = &si -> si_abort;

    isodetailor ("psap");

    missingP (vec);
    missingP (pi);

/*  assumes here only when process spawned for initial UD indication */
/*  but may precede (sd == NOTOK) or follow call to PUnitDataBind() */

    if ( sd == NOTOK ) {
	if ( (pb = newpublk ()) == NULL )
	    return pusaplose (pi, PC_CONGEST, NULLCP, "out of memory");
	pb->pb_fd = NOTOK;
	}
    else 
        if ( (pb = findpublk (sd)) == NULLPB || !(pb -> pb_flags & PB_PUDT)) 
	    return pusaplose (pi, PC_PARAMETER, NULLCP,
		"invalid presentation descriptor");
	    

    if ( (result = SuSave ( sd, vecp, vec, si) ) == NOTOK) {
        (void) ss2pulose (NULLPB, pi, "PuSave", sa);
        if ( sd == NOTOK ) freepublk (pb);
	return NOTOK;
	}

    pb->pb_fd = result;
    return result;
}


/*---------------------------------------------------------------------------*/
int	addrs2block ( callingaddr, calledaddr, pb, pi )
/*---------------------------------------------------------------------------*/
struct PSAPaddr *callingaddr,
		*calledaddr;
struct psapblk *pb;
struct PSAPindication *pi;
{
register struct PSAPaddr *pa;

    if ( !calledaddr )
	pb -> pb_called = NULLPA;
    else if ( calledaddr != pb -> pb_called ){
        if ( pb -> pb_called ) free (pb -> pb_called);
        if ( (pa = (struct PSAPaddr *) calloc (1, sizeof *calledaddr))
		 == NULLPA ) goto no_mem;
        *pa = *calledaddr;	/* struct copy */
	pb -> pb_called = pa;
	}

    if ( !callingaddr )
	pb -> pb_calling = NULLPA;
    else if ( callingaddr != pb -> pb_calling ){
        if ( pb -> pb_calling ) free (pb -> pb_calling);
        if ( (pa = (struct PSAPaddr *) calloc (1, sizeof *callingaddr))
		 == NULLPA) goto no_mem;
        *pa = *callingaddr;	/* struct copy */
	pb -> pb_calling = pa;
	}
    return OK;
	
no_mem: ;
    pusaplose (pi, PC_CONGEST, NULLCP, "out of memory");
    return NOTOK;
}


/*----------------------------------------------------------------------------*/
int	contexts2block ( contexts, nctx, pb, pi )
/*----------------------------------------------------------------------------*/
struct  PSAPcontext *contexts;
int     nctx;
struct  psapblk *pb;
struct	PSAPindication *pi;
{
    int i;
    register struct PSAPcontext *pp, *qp;

	i = nctx - 1;
	for (pp = contexts, qp = pb -> pb_contexts;
		i >= 0;
		i--, pp++, qp++){
	    if (!((qp -> pc_id = pp -> pc_id) & 01)) {
		(void) pusaplose (pi, PC_PARAMETER, NULLCP,
			    "only odd values allowed for context identifiers");
		goto out2;
	    }

	    if (pp -> pc_asn == NULLOID) {
		(void) pusaplose (pi, PC_PARAMETER, NULLCP,
			    "no abstract syntax name given for context %d",
			    pp -> pc_id);
		goto out2;
	    }
	    if ((qp -> pc_asn = oid_cpy (pp -> pc_asn)) == NULLOID)
		goto no_mem;

	    if (pp -> pc_atn && !atn_is_ok (pb, pp -> pc_atn)) {
		(void) pusaplose (pi, PC_TRANSFER, NULLCP,
			    "unknown transfer syntax name given for context %d",
			    pp -> pc_id);
		goto out2;
	    }
	    if ((qp -> pc_atn = oid_cpy (pp -> pc_atn ? pp -> pc_atn
			: pb -> pb_atn)) == NULLOID)
		goto no_mem;

/*  The following line is superfluous since P-UNIT.DATA is unconfirmed */
	    qp -> pc_result = PC_ACCEPT;

	    pb -> pb_ncontext++;
	}
	return OK;


no_mem: ;
    (void) pusaplose (pi, PC_CONGEST, NULLCP, "out of memory");
out2: ;
    return NOTOK;
}


/*----------------------------------------------------------------------------*/
int	contexts2pdu ( pb, pdu )
/*----------------------------------------------------------------------------*/
struct psapblk *pb;
struct type_PS_UD__type *pdu;
{
    int i;
    register struct PSAPcontext  *qp;
    register struct type_PS_Definition__list *cd, **cp;

    cp = &pdu -> context__list;

    i = pb -> pb_ncontext - 1;

    for ( qp = pb -> pb_contexts; i >= 0; i--, qp++) 
	{
        if ((cd =(struct type_PS_Definition__list *) calloc(1, sizeof *cd))
                == NULL)
	    goto no_mem;

        *cp = cd;
        cp = &cd -> next;

        if ((cd -> element_PS_5 = (struct element_PS_6 *)
	        calloc (1, sizeof *cd -> element_PS_5)) == NULL)
	    goto no_mem;

        cd -> element_PS_5 -> identifier = qp -> pc_id;
        if ((cd -> element_PS_5 -> abstract__syntax = oid_cpy (qp -> pc_asn))
	        == NULLOID
            || (cd -> element_PS_5 -> transfer__syntax__list =
	        (struct element_PS_7 *)calloc (1, sizeof (struct element_PS_7)))
	        == NULL
            || (cd -> element_PS_5 -> transfer__syntax__list ->
	            Transfer__syntax__name = oid_cpy (qp -> pc_atn))
	        == NULL)
	    goto no_mem;
	}

    return OK;

no_mem: ;
    return NOTOK;
}



/*----------------------------------------------------------------------------*/
int	pdu2contexts ( pb, ctxdeflist, ctxlist )
/*----------------------------------------------------------------------------*/
struct psapblk *pb;
struct type_PS_Definition__list *ctxdeflist;
struct PSAPctxlist *ctxlist;
{
    int i, j, result;
    register struct PSAPcontext  *pp, *qp;
    register struct type_PS_Definition__list *lp;

    result = OK;
    i = 0;
    for (lp = ctxdeflist, pp = ctxlist -> pc_ctx;
	    lp;
	    lp = lp -> next, pp++, i++)
        {
	register struct element_PS_6 *pctx = lp -> element_PS_5;
	register struct element_PS_7 *atn;

	pp -> pc_id = pctx -> identifier;
        pp -> pc_asn = pctx -> abstract__syntax;
        pctx -> abstract__syntax = NULLOID;

/*    assure context has been previously bound */

        j = pb -> pb_ncontext;
   	for ( qp = pb -> pb_contexts; j > 0; j--, qp++)  
	    if ( oid_cmp ( pp -> pc_asn, qp -> pc_asn ) == 0 ) { 
	        pp -> pc_result = PC_ACCEPT;
	        break;
		}
	if ( j == 0 )
            pp -> pc_result = PC_REJECTED;

/* PUDT standard is mixed up about the list of transfer syntax names > 1 */
/* but let's process it anyway since thats the ASN.1 for ctxlist */

	for (atn = pctx -> transfer__syntax__list; atn; atn = atn -> next)
	    if (atn_is_ok (pb, atn -> Transfer__syntax__name)) {
		pp -> pc_atn = atn -> Transfer__syntax__name;
		atn -> Transfer__syntax__name = NULLOID;
		break;
		}
	if (atn == NULL) {
	    result = NOTOK;
	    pp -> pc_result = PC_TRANSFER;
	    }
	}
    ctxlist -> pc_nctx = i;
    return result;
}

/* HULA ends */