llib-lnet

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

}

int       check_dap_ctxlist (ctxlist)
struct PSAPctxlist      * ctxlist;
{
	return (check_dap_ctxlist (ctxlist));
}

int       check_dsp_ctxlist (ctxlist)
struct PSAPctxlist      * ctxlist;
{
	return (check_dsp_ctxlist (ctxlist));
}

int       check_qsp_ctxlist (ctxlist)
struct PSAPctxlist      * ctxlist;
{
	return (check_qsp_ctxlist (ctxlist));
}

int       DapErrorRequest (sd, id, err, di)
int                       sd;
int                       id;
struct DSError          * err;
struct DSAPindication   * di;
{
	return (DapErrorRequest (sd, id, err, di));
}

int       DspErrorRequest (sd, id, err, di)
int                       sd;
int                       id;
struct DSError          * err;
struct DSAPindication   * di;
{
	return (DspErrorRequest (sd, id, err, di));
}

int       QspErrorRequest (sd, id, err, di)
int                       sd;
int                       id;
struct DSError          * err;
struct DSAPindication   * di;
{
	return (QspErrorRequest (sd, id, err, di));
}

int             DEncodeError(pep, err)
PE              *pep;
struct DSError  *err;
{
	return (DEncodeError(pep, err));
}

int       DapInvokeRequest (sd, id, arg, di)
int                       sd;
int                       id;
struct DSArgument       * arg;
struct DSAPindication   * di;
{
	return (DapInvokeRequest (sd, id, arg, di));
}

int       DapEncodeInvoke (pep, arg)
PE                      * pep;
struct DSArgument       * arg;
{
	return (DapEncodeInvoke (pep, arg));
}

int       DspInvokeRequest (sd, id, arg, di)
int       sd;
int       id;
struct ds_op_arg        * arg;
struct DSAPindication   * di;
{
	return (DspInvokeRequest (sd, id, arg, di));
}

int       DspEncodeInvoke (pep, arg)
PE                      * pep;
struct ds_op_arg        * arg;
{
	return (DspEncodeInvoke (pep, arg));
}

int       QspInvokeRequest (sd, id, arg, di)
int       sd;
int       id;
struct ds_op_arg        * arg;
struct DSAPindication   * di;
{
	return (QspInvokeRequest (sd, id, arg, di));
}

int       QspEncodeInvoke (pep, arg)
PE                      * pep;
struct ds_op_arg        * arg;
{
	return (QspEncodeInvoke (pep, arg));
}

int     dsaplose (di, reason, what, fmt)
struct DSAPindication *di;
int     reason;
char   *what,
       *fmt;
{
    return dsaplose (di, reason, what, fmt);
}

int     dsapreject (di, reason, id, what, fmt)
struct DSAPindication *di;
int     reason;
int     id;
char   *what,
       *fmt;
{
    return dsapreject (di, reason, id, what, fmt);
}

int       DRejectRequest (sd, reason, id)
int       sd;
int       reason;
int       id;
{
	return (DRejectRequest (sd, reason, id));
}

int       DapResultRequest (sd, id, res, di)
int                       sd;
int                       id;
struct DSResult         * res;
struct DSAPindication   * di;
{
	return ( DapResultRequest (sd, id, res, di));
}

int       DapEncodeResult (pep, res)
PE              * pep;
struct DSResult * res;
{
	return (DapEncodeResult (pep, res));
}

int       DspResultRequest (sd, id, res, di)
int                       sd;
int                       id;
struct ds_op_res        * res;
struct DSAPindication   * di;
{
	return (DspResultRequest (sd, id, res, di));
}

int       DspEncodeResult (pep, res)
PE                      * pep;
struct ds_op_res        * res;
{
	return (DspEncodeResult (pep, res));
}

int       QspResultRequest (sd, id, res, di)
int                       sd;
int                       id;
struct ds_op_res        * res;
struct DSAPindication   * di;
{
	return (QspResultRequest (sd, id, res, di));
}

int       QspEncodeResult (pep, res)
PE                      * pep;
struct ds_op_res        * res;
{
	return ( QspEncodeResult (pep, res));
}

int       ronot2dsaplose (di, event, rni)
struct DSAPindication   * di;
char                    * event;
struct RoNOTindication  * rni;
{
	return (ronot2dsaplose (di, event, rni));
}

int       ros2dsaplose (di, event, rop)
struct DSAPindication   * di;
char                    * event;
struct RoSAPpreject     * rop;
{
	return (ros2dsaplose (di, event, rop));
}

int       ros2dsapreject (di, event, rou)
struct DSAPindication   * di;
char                    * event;
struct RoSAPureject     * rou;
{
	return (ros2dsapreject (di, event, rou));
}

int       DUnBindRequest (sd, secs, dr, di)
int                       sd;
int                       secs;
struct DSAPrelease      * dr;
struct DSAPindication   * di;
{
	return (DUnBindRequest (sd, secs, dr, di));
}

int       DUnBindRetry (sd, secs, dr, di)
int                       sd;
int                       secs;
struct DSAPrelease      * dr;
struct DSAPindication   * di;
{
	return (DUnBindRetry (sd, secs, dr, di));
}

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

int       DUnBindReject (sd, status, reason, di)
int                       sd;
int                       status;
int                       reason;
struct DSAPindication   * di;
{
	return (DUnBindReject (sd, status, reason, di));
}

int       DWaitRequest (ctx, sd, secs, di)
int                       ctx;
int                       sd;
int                       secs;
struct DSAPindication   * di;
{
	return (DWaitRequest (ctx, sd, secs, di));
}

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

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

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

int       DapDecodeInvoke (sd, rox, di)
int                       sd;
struct RoSAPinvoke      * rox;
struct DSAPindication   * di;
{
	return ( DapDecodeInvoke (sd, rox, di));
}

int       DDecodeUnbind (sd, acf, di)
int                       sd;
struct AcSAPfinish      * acf;
struct DSAPindication   * di;
{
	return (DDecodeUnbind (sd, acf, di));
}

int       DspDecodeInvoke (sd, rox, di)
int                       sd;
struct RoSAPinvoke      * rox;
struct DSAPindication   * di;
{
	return (DspDecodeInvoke (sd, rox, di));
}

int       DspDecodeResult (sd, ror, di)
int                       sd;
struct RoSAPresult      * ror;
struct DSAPindication   * di;
{
	return (DspDecodeResult (sd, ror, di));
}

int       DspDecodeError (sd, roe, di)
int       sd;
struct RoSAPerror       * roe;
struct DSAPindication   * di;
{
	return (DspDecodeError (sd, roe, di));
}

int       DspDecodeUnbind (sd, acf, di)
int       sd;
struct AcSAPfinish      * acf;
struct DSAPindication   * di;
{
	return (DspDecodeUnbind (sd, acf, di));
}

int       QspDecodeInvoke (sd, rox, di)
int                       sd;
struct RoSAPinvoke      * rox;
struct DSAPindication   * di;
{
	return (QspDecodeInvoke (sd, rox, di));
}

int       QspDecodeResult (sd, ror, di)
int                       sd;
struct RoSAPresult      * ror;
struct DSAPindication   * di;
{
	return ( QspDecodeResult (sd, ror, di));
}

int       QspDecodeError (sd, roe, di)
int       sd;
struct RoSAPerror       * roe;
struct DSAPindication   * di;
{
	return (QspDecodeError (sd, roe, di));
}

int       QspDecodeUnbind (sd, acf, di)
int       sd;
struct AcSAPfinish      * acf;
struct DSAPindication   * di;
{
	return (QspDecodeUnbind (sd, acf, di));
}

/* Some types routines */

bind_arg_free (arg)
struct ds_bind_arg          *arg;
{
	(void) bind_arg_free (arg);
}

op_arg_free (arg)
struct ds_op_arg * arg;
{
	(void) op_arg_free (arg);
}

ch_arg_free (arg)
struct chain_arg * arg;
{
	(void) ch_arg_free (arg);
}

ds_arg_free (arg)
struct DSArgument * arg;
{
	(void) ds_arg_free (arg);
}

read_arg_free (arg)
struct ds_read_arg      * arg;
{
	(void) read_arg_free (arg);
}

compare_arg_free (arg)
struct ds_compare_arg   * arg;
{
	(void) compare_arg_free (arg);
}

list_arg_free (arg)
struct ds_list_arg      * arg;
{
	(void) list_arg_free (arg);
}

search_arg_free (arg)
struct ds_search_arg    * arg;
{
	(void) search_arg_free (arg);
}

addentry_arg_free (arg)
struct ds_addentry_arg  * arg;
{
	(void) addentry_arg_free (arg);
}

removeentry_arg_free (arg)
struct ds_removeentry_arg       * arg;
{
	(void) removeentry_arg_free (arg);
}

modifyentry_arg_free (arg)
struct ds_modifyentry_arg       * arg;
{
	(void) modifyentry_arg_free (arg);
}

modifyrdn_arg_free (arg)
struct ds_modifyrdn_arg * arg;
{
	(void) modifyrdn_arg_free (arg);
}

getedb_arg_free (arg)
struct getedb_arg       * arg;
{
	(void) getedb_arg_free (arg);
}

op_res_free (res)
struct ds_op_res * res;
{
	(void) op_res_free (res);
}

ch_res_free (res)
struct chain_res        * res;
{
	(void) ch_res_free (res);
}

ds_res_free (res)
struct DSResult * res;
{
	(void) ds_res_free (res);
}

trace_info_free (ti)
struct trace_info * ti;
{
	(void) trace_info_free (ti);
}

ca_free (ca)
CommonArgs * ca;
{
	(void) ca_free (ca);
}

extension_free (ext)
struct extension * ext;
{
	(void) extension_free (ext);
}

cross_refs_free (xref)
struct cross_ref * xref;
{
	(void) cross_refs_free (xref);
}

watch_dog (where)
char * where;
{
	(void) watch_dog (where);
}

watch_dog_aux (where,secs)
char * where;
unsigned secs;
{
	(void) watch_dog_aux (where,secs);
}

watch_dog_reset ()
{
	(void) watch_dog_reset ();
}



int       IspAsynBindReqAux (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 (IspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
                calledaddr, prequirements, srequirements, isn, settings,
                sf, bindarg, qos, dc, di, async));
}

int       IspAsynBindRequest (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 (IspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async));
}

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

int       check_isp_ctxlist (ctxlist)
struct PSAPctxlist      * ctxlist;
{
	return (check_isp_ctxlist (ctxlist));
}
int       IspErrorRequest (sd, id, err, di)
int                       sd;
int                       id;
struct DSError          * err;
struct DSAPindication   * di;
{
	return (IspErrorRequest (sd, id, err, di));
}

int       IspInvokeRequest (sd, id, arg, di)
int       sd;
int       id;
struct ds_op_arg        * arg;
struct DSAPindication   * di;
{
	return (IspInvokeRequest (sd, id, arg, di));
}

int       IspEncodeInvoke (pep, arg)
PE                      * pep;
struct ds_op_arg        * arg;
{
	return (IspEncodeInvoke (pep, arg));
}
int       IspResultRequest (sd, id, res, di)
int                       sd;
int                       id;
struct ds_op_res        * res;
struct DSAPindication   * di;
{
	return (IspResultRequest (sd, id, res, di));
}

int       IspEncodeResult (pep, res)
PE                      * pep;
struct ds_op_res        * res;
{
	return ( IspEncodeResult (pep, res));
}

int       IspWaitRequest (sd, secs, di)
int                       sd;
int                       secs;
struct DSAPindication   * di;
{
	return (IspWaitRequest (sd, secs, di));
}
int       IspDecodeInvoke (sd, rox, di)
int                       sd;
struct RoSAPinvoke      * rox;
struct DSAPindication   * di;
{
	return (IspDecodeInvoke (sd, rox, di));
}

int       IspDecodeResult (sd, ror, di)
int                       sd;
struct RoSAPresult      * ror;
struct DSAPindication   * di;
{
	return ( IspDecodeResult (sd, ror, di));
}

int       IspDecodeError (sd, roe, di)
int       sd;
struct RoSAPerror       * roe;
struct DSAPindication   * di;
{
	return (IspDecodeError (sd, roe, di));
}

int       IspDecodeUnbind (sd, acf, di)
int       sd;
struct AcSAPfinish      * acf;
struct DSAPindication   * di;
{
	return (IspDecodeUnbind (sd, acf, di));
}