psaputils.c

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

    for (d = data, i = 0; i < ndata; i++) {
	pe = *d++;
	switch (pe -> pe_context) {
	    case PE_DFLT_CTX:
		atn = pb -> pb_atn;
		break;

	    default:
		for (j = 0, qp = pb -> pb_contexts;
			j < pb -> pb_ncontext;
			j++, qp++)
		    if (qp -> pc_id == pe -> pe_context)
			break;
		if (j >= pb -> pb_ncontext) {
		    (void) pusaplose (pi, PC_PARAMETER, NULLCP,
				"context %d is undefined", pe -> pe_context);
		    goto out;
		}
		if (qp -> pc_result != PC_ACCEPT) {
		    (void) pusaplose (pi, PC_PARAMETER, NULLCP,
				"context %d is unsupported", pe -> pe_context);
		    goto out;
		}
		atn = qp -> pc_atn;
		break;
	}

	if (!atn_is_asn1 (atn)) {
	    (void) pusaplose (pi, PC_PARAMETER, NULLCP, "not ASN.1");
	    goto out;
	}

	if (pdu -> offset == type_PS_User__data_simple) {
	    if (info2_qb (pe, qb, pi) == NULL)
		goto out;
	}
	else {
	    if ((full = (struct type_PS_Fully__encoded__data *)
		 	    calloc (1, sizeof *full)) == NULL)
		goto no_mem;
	    *complex = full;
	    complex = &full -> next;
	    if ((full -> PDV__list = (struct type_PS_PDV__list *)
				    calloc (1, sizeof *full -> PDV__list))
		    == NULL)
		goto no_mem;
	    full -> PDV__list -> identifier = pe -> pe_context;
	    if ((full -> PDV__list -> presentation__data__values =
		     (struct choice_PS_0 *)
		     	calloc (1, sizeof (struct choice_PS_0))) == NULL)
		goto no_mem;

	    if (ndata == 1) {
		full -> PDV__list -> presentation__data__values ->
		    offset = choice_PS_0_single__ASN1__type;
		(full -> PDV__list -> presentation__data__values ->
		    un.single__ASN1__type = pe) -> pe_refcnt++;
	    }
	    else {
		register struct qbuf *qb2;

		full -> PDV__list -> presentation__data__values ->
		    offset = choice_PS_0_octet__aligned;
		if ((qb2 = (struct qbuf *) malloc (sizeof *qb2)) == NULL)
		    goto no_mem;
		full -> PDV__list -> presentation__data__values ->
		    un.octet__aligned = qb2;
		qb2 -> qb_forw = qb2 -> qb_back = qb2;
		qb2 -> qb_data = NULL, qb2 -> qb_len = 0;
		if ((qb = info2_qb (pe, (struct qbuf *) NULL, pi)) == NULL)
		    goto out;
		qb2 -> qb_len = qb -> qb_len;
		insque (qb, qb2);
	    }
	}
    }

    return pdu;
    
out: ;
    if (pdu)
	free_PS_User__data (pdu);

    return NULL;
}



/*----------------------------------------------------------------------------*/
/*    SSAP interface */
/*----------------------------------------------------------------------------*/
int	ss2pulose (pb, pi, event, sa)
register struct psapblk *pb;
register struct PSAPindication *pi;
char   *event;
register struct SSAPabort *sa;
{
    int     reason;
    char   *cp,
            buffer[BUFSIZ];

    if ((psap2level & ISODELOG_EXCEPTIONS)
	    && event
	    && SC_FATAL (sa -> sa_reason))
	xsprintf (NULLCP, NULLCP,
		sa -> sa_cc > 0 ? "%s: %s\n\t%*.*s": "%s: %s", event,
		SuErrString (sa -> sa_reason), sa -> sa_cc, sa -> sa_cc,
		sa -> sa_data);

    cp = "";
    switch (sa -> sa_reason) {
	case SC_SSAPID: 
	case SC_SSUSER: 
	case SC_ADDRESS: 
	    reason = PC_ADDRESS;
	    break;

	case SC_REFUSED:
	    reason = PC_REFUSED;
	    break;

	case SC_CONGEST: 
	    reason = PC_CONGEST;
	    break;

	case SC_TRANSPORT:
	case SC_ABORT:
	    reason = PC_SESSION;
	    break;

	default: 
	    reason = PC_SESSION;
	    if (pb == NULLPB)
		switch (sa -> sa_reason) {
		    case SC_PARAMETER:
			reason = PC_PARAMETER;
			break;

		    case SC_OPERATION:
			reason = PC_OPERATION;
			break;

		    case SC_TIMER:
			reason = PC_TIMER;
			break;

		    case SC_WAITING:
			reason = PC_WAITING;
			break;
		}
	    (void) sprintf (cp = buffer, " (%s at session)",
			SuErrString (sa -> sa_reason));
	    break;
    }

    if (sa -> sa_cc > 0)
        return pusaplose (pi, reason, NULLCP, "%*.*s%s",
	        sa -> sa_cc, sa -> sa_cc, sa -> sa_data, cp);
    else
        return pusaplose (pi, reason, NULLCP, "%s",
	        *cp ? cp + 1 : cp);
}


/*  */

#ifndef	lint
/*----------------------------------------------------------------------------*/
int	pusaplose (va_alist)
/*----------------------------------------------------------------------------*/
va_dcl
{
    int     reason,
    	    result;
    struct PSAPindication *pi;
    va_list ap;

    va_start (ap);
    pi = va_arg (ap, struct PSAPindication *);
    reason = va_arg (ap, int);
    result = _pusaplose (pi, reason, ap);
    va_end (ap);
    return result;
}
#else
/* VARARGS */
int	pusaplose (pi, reason, what, fmt)
struct PSAPindication *pi;
int     reason;
char   *what,
       *fmt;
{
    return pusaplose (pi, reason, what, fmt);
}
#endif

#ifndef	lint
/*----------------------------------------------------------------------------*/
static int  _pusaplose (pi, reason, ap)	/* what, fmt, args ... */
/*----------------------------------------------------------------------------*/
register struct PSAPindication *pi;
int     reason;
va_list	ap;
{
    register char  *bp;
    char    buffer[BUFSIZ];
    register struct PSAPabort *pa;

    if (pi) {
	bzero ((char *) pi, sizeof *pi);
	pi -> pi_type = PI_ABORT;
	pa = &pi -> pi_abort;

	asprintf (bp = buffer, ap);
	bp += strlen (bp);

	pa -> pa_peer = 0;
	pa -> pa_reason = reason;
	pa -> pa_ninfo = 0;
	copyPSAPdata (buffer, bp - buffer, pa);
    }

    return NOTOK;
}
#endif


/*  */
/* stolen from psap2error.c */
/*----------------------------------------------------------------------------*/
static char *reject_err0[] = {
/*----------------------------------------------------------------------------*/
    "Rejected by peer",
    "Reason not specified",
    "Temporary congestion",
    "Local limit exceeded",
    "Called presentation address unknown",
    "Protocol version not supported",
    "Default context not supported",
    "User-data not readable",
    "No PSAP available",
    "Unrecognized PPDU",
    "Unexpected PPDU",
    "Unexpected session service primitive",
    "Unrecognized PPDU parameter",
    "Unexpected PPDU parameter",
    "Invalid PPDU parameter value",
    "Abstract syntax not supported",
    "Proposed transfer syntaxes not supported",
    "Local limit on DCS exceeded",
    "Connect request refused on this network connection",
    "Session disconnect",
    "Protocol error",
    "Peer aborted connection",
    "Invalid parameter",
    "Invalid operation",
    "Timer expired",
    "Indications waiting"
};

static int reject_err0_cnt = sizeof reject_err0 / sizeof reject_err0[0];


/*  */
/*---------------------------------------------------------------------------*/
char   *PuErrString (code)
/*---------------------------------------------------------------------------*/
register int code;
{
    static char buffer[BUFSIZ];

    if (code < reject_err0_cnt)
	return reject_err0[code];
    (void) sprintf (buffer, "unknown error code %d", code);
    return buffer;
}


/*   INTERNAL */
/*----------------------------------------------------------------------------*/
struct psapblk  *newpublk ()
/*----------------------------------------------------------------------------*/
{
    register struct psapblk *pb;

    pb = (struct psapblk   *) calloc (1, sizeof *pb);
    if (pb == NULL)
	return NULL;

    pb -> pb_fd = NOTOK;

    if (once_only == 0) {
	PuHead -> pb_forw = PuHead -> pb_back = PuHead;
	once_only++;
        }
    insque (pb, PuHead -> pb_back);
    return pb;
}


/*  */
/*----------------------------------------------------------------------------*/
struct psapblk   *findpublk (sd)
/*----------------------------------------------------------------------------*/
register int sd;
{
    register struct psapblk *pb;

    if (once_only == 0)
	return NULL;

    for (pb = PuHead -> pb_forw; pb != PuHead; pb = pb -> pb_forw)
	if (pb -> pb_fd == sd)
	    return pb;

    return NULL;
}


/*  */
/*----------------------------------------------------------------------------*/
int	freepublk (pb)
/*----------------------------------------------------------------------------*/
register struct psapblk *pb;
{
    register int    i;
    register struct PSAPcontext *qp;

    if (pb == NULL) return;

    if ( pb -> pb_calling ) free (pb -> pb_calling);
    if ( pb -> pb_called ) free (pb -> pb_called);

    if (pb -> pb_retry) free (pb -> pb_retry);

    for (qp = pb -> pb_contexts, i = pb -> pb_ncontext - 1;
	    i >= 0;
	    qp++, i--) {
	if (qp -> pc_asn)
	    oid_free (qp -> pc_asn);
	if (qp -> pc_atn)
	    oid_free (qp -> pc_atn);
        }

    if (pb -> pb_asn) oid_free (pb -> pb_asn);
    if (pb -> pb_atn) oid_free (pb -> pb_atn);


    remque (pb);
    free ((char *) pb);
}



/*  */
#ifdef	DEBUG
/*----------------------------------------------------------------------------*/
int	PS_print (pe, text, rw, fnx)
/*----------------------------------------------------------------------------*/
PE	pe;
char   *text;
int	rw;
IFP	fnx;
{
    int	    isopen;
    FILE   *fp;

    if (strcmp (psap2file, "-")) {
	char	file[BUFSIZ];

	(void) sprintf (file, psap2file, getpid ());
	fp = fopen (file, "a"), isopen = 1;
    }
    else
	fp = stderr, isopen = 0, (void) fflush (stdout);

    if (fp) {
	vpushfp (fp, pe, text, rw);
	(void) (*fnx) (pe, 1, NULLIP, NULLVP, NULLCP);
	vpopfp ();

	if (isopen)
	    (void) fclose (fp);
	else
	    (void) fflush (fp);
    }
}
#endif