llib-lnet

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

/* llib-lnet - lint library for QUIPU-net */

/*
 * $Header: /xtel/isode/isode/dsap/net/RCS/llib-lnet,v 9.0 1992/06/16 12:14:05 isode Rel $
 *
 *
 * $Log: llib-lnet,v $
 * Revision 9.0  1992/06/16  12:14:05  isode
 * Release 8.0
 *
 */

/*
 *                                NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include "quipu/util.h"
#include "quipu/common.h"
#include "quipu/dap2.h"
#include "quipu/dsap.h"
#include "tsap.h"

/* DAP operations */

ds_bind (arg, error, result) 
struct ds_bind_arg *arg; 
struct ds_bind_arg *result; 
struct ds_bind_error *error; 
{
	return ds_bind (arg, error, result) ;
} 

secure_ds_bind (arg, error, result) 
struct ds_bind_arg *arg; 
struct ds_bind_arg *result; 
struct ds_bind_error *error; 
{
	return secure_ds_bind (arg, error, result);
} 

dap_bind (ad, arg, error, result, addr) 
int * ad; 
struct ds_bind_arg *arg; 
struct ds_bind_arg *result; 
struct ds_bind_error *error; 
struct PSAPaddr *addr; 
{
	return dap_bind (ad, arg, error, result, addr);
} 

int       DapAsynBindRequest (calledaddr, bindarg, dc, di, async)
struct PSAPaddr         * calledaddr;
struct ds_bind_arg      * bindarg;
struct DAPconnect       * dc;
struct DAPindication    * di;
int                       async;
{
	return (DapAsynBindRequest (calledaddr, bindarg, dc, di, async));
}

int       DapAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async)
AEI                       callingtitle;
AEI                       calledtitle;
struct PSAPaddr         * callingaddr;
struct PSAPaddr         * calledaddr;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * sf;
struct ds_bind_arg      * bindarg;
struct QOStype          * qos;
struct DAPconnect       * dc;
struct DAPindication    * di;
int                       async;
{
        return ( DapAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async));
}

int       DapAsynBindRetry (sd, do_next_nsap, dc, di)
int                       sd;
int                       do_next_nsap;
struct DAPconnect       * dc;
struct DAPindication    * di;
{
	return (DapAsynBindRetry (sd, do_next_nsap, dc, di));
}

int       DapBindDecode (acc, dc, rni)
struct AcSAPconnect     * acc;
struct DAPconnect       * dc;
struct RoNOTindication	* rni;
{
	return (DapBindDecode (acc, dc, rni));
}

ds_unbind () 
{
	return ds_unbind();
} 

dap_unbind (ad) 
int ad; 
{
	return dap_unbind(ad);
} 

int	  DapUnBindRequest (sd, secs, dr, di)
int			  sd;
int			  secs;
struct DAPrelease	* dr;
struct DAPindication	* di;
{
	return (DapUnBindRequest (sd, secs, dr, di));
}

int	  DapUnBindRetry (sd, secs, dr, di)
int			  sd;
int			  secs;
struct DAPrelease	* dr;
struct DAPindication	* di;
{
	return (DapUnBindRetry (sd, secs, dr, di));
}

int       DapInitWaitRequest (sd, secs, di)
int                       sd;
int                       secs;
struct DAPindication    * di;
{
	return (DapInitWaitRequest (sd, secs, di));
}

int       DapDecodeResult (sd, ror, di)
int                       sd;
struct RoSAPresult      * ror;
struct DAPindication    * di;
{
	return (DapDecodeResult (sd, ror, di));
}

int       DapDecodeError (sd, roe, di)
int                       sd;
struct RoSAPerror       * roe;
struct DAPindication    * di;
{
	return (DapDecodeError (sd, roe, di));
}

int       DapInvokeReqAux (sd, id, op, pe, di, asyn)
int                       sd;
int                       id;
int                       op;
PE                        pe;
struct DAPindication    * di;
int                       asyn;
{
	return (DapInvokeReqAux (sd, id, op, pe, di, asyn));
}

int       DapSyncInvokeRequest (sd, id, op, pe, di)
int                       sd;
int                       id;
int                       op;
PE                        pe;
struct DAPindication    * di;
{
	return (DapSyncInvokeRequest (sd, id, op, pe, di));
}

int       DapIntrInvokeRequest (sd, id, op, pe, di)
int                       sd;
int                       id;
int                       op;
PE                        pe;
struct DAPindication    * di;
{
	return (DapIntrInvokeRequest (sd, id, op, pe, di));
}

int       DapAsynInvokeRequest (sd, id, op, pe, di)
int                       sd;
int                       id;
int                       op;
PE                        pe;
struct DAPindication    * di;
{
	return (DapAsynInvokeRequest (sd, id, op, pe, di));
}

int       DapInterrupt(sd, id, op, di)
int                       sd;
int                       id;
int                       op;
struct DAPindication    * di;
{
	return (DapInterrupt(sd, id, op, di));
}

pdu_dump_init (dir) 
char * dir; 
{
	(void) pdu_dump_init(dir);
} 

pdu_dump (pe,type,op) 
PE pe; 
char * type; 
int op; 
{
	(void) pdu_dump(pe,type,op);
} 

pdu_arg_log (pe,op)
PE pe;
int op;
{
	return (pdu_arg_log (pe,op));
}

pdu_res_log (pe,op)
PE pe;
int op;
{
	return (pdu_arg_log (pe,op));
}

dap_abandon (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_abandon_arg *arg; 
struct DSError *error; 
{
	return dap_abandon (ad, id, arg, error);
} 

int       DapAbandon (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_abandon_arg   * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapAbandon (ad, id, arg, di, asyn));
}

dap_addentry (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_addentry_arg *arg; 
struct DSError *error; 
{
	return dap_addentry (ad, id, arg, error);
} 

int       DapAddEntry (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_addentry_arg  * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapAddEntry (ad, id, arg, di, asyn));
}

dap_compare (ad, id, arg, error, result) 
int ad; 
int * id; 
struct ds_compare_arg *arg; 
struct ds_compare_result *result; 
struct DSError *error; 
{
	return dap_compare (ad, id, arg, error, result);
} 

int       DapCompare (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_compare_arg   * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapCompare (ad, id, arg, di, asyn));
}

dap_list (ad, id, arg, error, result) 
int ad; 
int * id; 
struct ds_list_arg *arg; 
struct ds_list_result *result; 
struct DSError *error; 
{
	return dap_list (ad, id, arg, error, result) ;
} 

int       DapList (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_list_arg      * arg;
struct DAPindication    * di;
int                       asyn;
{
	return ( DapList (ad, id, arg, di, asyn));
}

dap_modifyentry (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_modifyentry_arg *arg; 
struct DSError *error; 
{
	return dap_modifyentry (ad, id, arg, error) ;
} 

int       DapModifyEntry (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_modifyentry_arg       * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapModifyEntry (ad, id, arg, di, asyn));
}

dap_modifyrdn (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_modifyrdn_arg *arg; 
struct DSError *error; 
{
	return dap_modifyrdn (ad, id, arg, error) ;
} 

int       DapModifyRDN (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_modifyrdn_arg * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapModifyRDN (ad, id, arg, di, asyn));
}

dap_read (ad, id, arg, error, result) 
int ad; 
int * id; 
struct ds_read_arg *arg; 
struct ds_read_result *result; 
struct DSError *error; 
{
	return dap_read (ad, id, arg, error, result) ;
} 

int       DapRead (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_read_arg      * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapRead (ad, id, arg, di, asyn));
}

dap_removeentry (ad, id, arg, error) 
int ad; 
int * id; 
struct ds_removeentry_arg *arg; 
struct DSError *error; 
{
	return dap_removeentry (ad, id, arg, error) ;
} 

int       DapRemoveEntry (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_removeentry_arg       * arg;
struct DAPindication    * di;
int                       asyn;
{
	return (DapRemoveEntry (ad, id, arg, di, asyn));
}

dap_search (ad, id, arg, error, result) 
int ad; 
int * id; 
struct ds_search_arg *arg; 
struct ds_search_result *result; 
struct DSError *error; 
{
	return dap_search (ad, id, arg, error, result) ;
} 

int       DapSearch (ad, id, arg, di, asyn)
int                       ad;
int                       id;
struct ds_search_arg    * arg;
struct DAPindication    * di;
int                       asyn;
{
	return ( DapSearch (ad, id, arg, di, asyn));
}

void ros_log(rop, event) 
register struct RoSAPpreject *rop; 
char *event; 
{
	ros_log(rop,event);
} 

void acs_log(aca, event) 
register struct AcSAPabort *aca; 
char *event; 
{
	acs_log(aca,event);
} 

td_log(td, event) 
struct TSAPdisconnect *td; 
char *event; 
{
	(void) td_log(td,event);
} 

int       DUAbortRequest (sd, di)
int                       sd;
struct DSAPindication   * di;
{
	return (DUAbortRequest (sd, di));
}

int       DspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async)
AEI                       callingtitle;
AEI                       calledtitle;
struct PSAPaddr         * callingaddr;
struct PSAPaddr         * calledaddr;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * sf;
struct ds_bind_arg      * bindarg;
struct QOStype          * qos;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (DspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async));
}

int       DspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async)
struct PSAPaddr         * calledaddr;
struct ds_bind_arg      * bindarg;
int                       qos_maxtime;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (DspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async));
}

int       QspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async)
AEI                       callingtitle;
AEI                       calledtitle;
struct PSAPaddr         * callingaddr;
struct PSAPaddr         * calledaddr;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * sf;
struct ds_bind_arg      * bindarg;
struct QOStype          * qos;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (QspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async));
}

int       QspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async)
struct PSAPaddr         * calledaddr;
struct ds_bind_arg      * bindarg;
int                       qos_maxtime;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
int                       async;
{
	return (QspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async));
}

int       DspAsynBindRetry (sd, do_next_nsap, dc, di)
int                       sd;
int                       do_next_nsap;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
{
	return (DspAsynBindRetry (sd, do_next_nsap, dc, di));
}

int       QspAsynBindRetry (sd, do_next_nsap, dc, di)
int                       sd;
int                       do_next_nsap;
struct DSAPconnect      * dc;
struct DSAPindication   * di;
{
	return (QspAsynBindRetry (sd, do_next_nsap, dc, di));
}

int       DBindDecode (acc, dc)
struct AcSAPconnect     * acc;
struct DSAPconnect      * dc;
{
	return (DBindDecode (acc, dc));
}

int       DBindInit (vecp, vec, ds, di)
int                       vecp;
char                    **vec;
struct DSAPstart        * ds;
struct DSAPindication   * di;
{
	return (DBindInit (vecp, vec, ds, di));
}

int       DBindResult (sd, context, respondtitle,
                respondaddr, ctxlist, defctxresult, prequirements,
                srequirements, isn, settings, ref, bind_res, pctx_id, di)
int                       sd;
OID                       context;
AEI                       respondtitle;
struct PSAPaddr         * respondaddr;
struct PSAPctxlist      * ctxlist;
int                       defctxresult;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * ref;
struct ds_bind_arg      * bind_res;
int                       pctx_id;
struct DSAPindication   * di;
{
	return (DBindResult (sd, context, respondtitle,
                respondaddr, ctxlist, defctxresult, prequirements,
                srequirements, isn, settings, ref, bind_res, pctx_id, di));
}

int       DBindError (sd, context, respondtitle, respondaddr, ctxlist,
                defctxresult, prequirements, srequirements, isn, settings,
                ref, bind_err, pctx_id, di)
int                       sd;
OID                       context;
AEI                       respondtitle;
struct PSAPaddr         * respondaddr;
struct PSAPctxlist      * ctxlist;
int                       defctxresult;
int                       prequirements;
int                       srequirements;
long                      isn;
int                       settings;
struct SSAPref          * ref;
struct ds_bind_error    * bind_err;
int                       pctx_id;
struct DSAPindication   * di;
{
	return (DBindError (sd, context, respondtitle, respondaddr, ctxlist,
                defctxresult, prequirements, srequirements, isn, settings,
                ref, bind_err, pctx_id, di));
}

int       DBindReject (ds, status, reason, di)
struct DSAPstart        * ds;
int                       status;
int                       reason;
struct DSAPindication   * di;
{
	return (DBindReject (ds, status, reason, di));
}

int       select_context (app_ctx)
OID                       app_ctx;
{
	return (select_context (app_ctx));
}

int       judge_ctxlist(req_ctxlist, ok_ctxlist)
struct PSAPctxlist      * req_ctxlist;
struct PSAPctxlist      * ok_ctxlist;
{
	return (judge_ctxlist(req_ctxlist, ok_ctxlist));
}

int       find_ctx_id(pcdl, ctx_oid)
struct PSAPctxlist      * pcdl;
OID                       ctx_oid;
{
	return (find_ctx_id(pcdl, ctx_oid));