![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to llib-lnet CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / net|
Return to llib-lnet CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / net |
1.1 root 1: /* llib-lnet - lint library for QUIPU-net */
2:
3: /*
4: * $Header: /f/osi/dsap/net/RCS/llib-lnet,v 7.0 90/07/26 14:46:06 mrose Exp $
5: *
6: *
7: * $Log: llib-lnet,v $
8: # Revision 7.0 90/07/26 14:46:06 mrose
9: # *** empty log message ***
10: #
11: * Revision 7.3 90/07/09 14:35:37 mrose
12: * sync
13: *
14: * Revision 7.2 89/12/19 16:19:37 mrose
15: * sync
16: *
17: * Revision 7.1 89/11/24 16:21:47 mrose
18: * sync
19: *
20: * Revision 7.0 89/11/23 21:48:21 mrose
21: * Release 6.0
22: *
23: */
24:
25: /*
26: * NOTICE
27: *
28: * Acquisition, use, and distribution of this module and related
29: * materials are subject to the restrictions of a license agreement.
30: * Consult the Preface in the User's Manual for the full terms of
31: * this agreement.
32: *
33: */
34:
35:
36: /* LINTLIBRARY */
37:
38: #include "quipu/util.h"
39: #include "quipu/common.h"
40: #include "quipu/dap2.h"
41: #include "quipu/dsap.h"
42: #include "tsap.h"
43:
44: /* DAP operations */
45:
46: ds_bind (arg, error, result)
47: struct ds_bind_arg *arg;
48: struct ds_bind_arg *result;
49: struct ds_bind_error *error;
50: {
51: return ds_bind (arg, error, result) ;
52: }
53:
54: secure_ds_bind (arg, error, result)
55: struct ds_bind_arg *arg;
56: struct ds_bind_arg *result;
57: struct ds_bind_error *error;
58: {
59: return secure_ds_bind (arg, error, result);
60: }
61:
62: dap_bind (ad, arg, error, result, addr)
63: int * ad;
64: struct ds_bind_arg *arg;
65: struct ds_bind_arg *result;
66: struct ds_bind_error *error;
67: struct PSAPaddr *addr;
68: {
69: return dap_bind (ad, arg, error, result, addr);
70: }
71:
72: int DapAsynBindRequest (calledaddr, bindarg, dc, di, async)
73: struct PSAPaddr * calledaddr;
74: struct ds_bind_arg * bindarg;
75: struct DAPconnect * dc;
76: struct DAPindication * di;
77: int async;
78: {
79: return (DapAsynBindRequest (calledaddr, bindarg, dc, di, async));
80: }
81:
82: int DapAsynBindReqAux (callingtitle, calledtitle, callingaddr,
83: calledaddr, prequirements, srequirements, isn, settings,
84: sf, bindarg, qos, dc, di, async)
85: AEI callingtitle;
86: AEI calledtitle;
87: struct PSAPaddr * callingaddr;
88: struct PSAPaddr * calledaddr;
89: int prequirements;
90: int srequirements;
91: long isn;
92: int settings;
93: struct SSAPref * sf;
94: struct ds_bind_arg * bindarg;
95: struct QOStype * qos;
96: struct DAPconnect * dc;
97: struct DAPindication * di;
98: int async;
99: {
100: return ( DapAsynBindReqAux (callingtitle, calledtitle, callingaddr,
101: calledaddr, prequirements, srequirements, isn, settings,
102: sf, bindarg, qos, dc, di, async));
103: }
104:
105: int DapAsynBindRetry (sd, do_next_nsap, dc, di)
106: int sd;
107: int do_next_nsap;
108: struct DAPconnect * dc;
109: struct DAPindication * di;
110: {
111: return (DapAsynBindRetry (sd, do_next_nsap, dc, di));
112: }
113:
114: int DapBindDecode (acc, dc)
115: struct AcSAPconnect * acc;
116: struct DAPconnect * dc;
117: {
118: return (DapBindDecode (acc, dc));
119: }
120:
121: ds_unbind ()
122: {
123: return ds_unbind();
124: }
125:
126: dap_unbind (ad)
127: int ad;
128: {
129: return dap_unbind(ad);
130: }
131:
132: int DapUnBindRequest (sd, secs, dr, di)
133: int sd;
134: int secs;
135: struct DAPrelease * dr;
136: struct DAPindication * di;
137: {
138: return (DapUnBindRequest (sd, secs, dr, di));
139: }
140:
141: int DapUnBindRetry (sd, secs, dr, di)
142: int sd;
143: int secs;
144: struct DAPrelease * dr;
145: struct DAPindication * di;
146: {
147: return (DapUnBindRetry (sd, secs, dr, di));
148: }
149:
150: int DapInitWaitRequest (sd, secs, di)
151: int sd;
152: int secs;
153: struct DAPindication * di;
154: {
155: return (DapInitWaitRequest (sd, secs, di));
156: }
157:
158: int DapDecodeResult (sd, ror, di)
159: int sd;
160: struct RoSAPresult * ror;
161: struct DAPindication * di;
162: {
163: return (DapDecodeResult (sd, ror, di));
164: }
165:
166: int DapDecodeError (sd, roe, di)
167: int sd;
168: struct RoSAPerror * roe;
169: struct DAPindication * di;
170: {
171: return (DapDecodeError (sd, roe, di));
172: }
173:
174: int DapInvokeReqAux (sd, id, op, pe, di, asyn)
175: int sd;
176: int id;
177: int op;
178: PE pe;
179: struct DAPindication * di;
180: int asyn;
181: {
182: return (DapInvokeReqAux (sd, id, op, pe, di, asyn));
183: }
184:
185: int DapSyncInvokeRequest (sd, id, op, pe, di)
186: int sd;
187: int id;
188: int op;
189: PE pe;
190: struct DAPindication * di;
191: {
192: return (DapSyncInvokeRequest (sd, id, op, pe, di));
193: }
194:
195: int DapIntrInvokeRequest (sd, id, op, pe, di)
196: int sd;
197: int id;
198: int op;
199: PE pe;
200: struct DAPindication * di;
201: {
202: return (DapIntrInvokeRequest (sd, id, op, pe, di));
203: }
204:
205: int DapAsynInvokeRequest (sd, id, op, pe, di)
206: int sd;
207: int id;
208: int op;
209: PE pe;
210: struct DAPindication * di;
211: {
212: return (DapAsynInvokeRequest (sd, id, op, pe, di));
213: }
214:
215: int DapInterrupt(sd, id, op, di)
216: int sd;
217: int id;
218: int op;
219: struct DAPindication * di;
220: {
221: return (DapInterrupt(sd, id, op, di));
222: }
223:
224: pdu_dump_init (dir)
225: char * dir;
226: {
227: (void) pdu_dump_init(dir);
228: }
229:
230: pdu_dump (pe,type,op)
231: PE pe;
232: char * type;
233: int op;
234: {
235: (void) pdu_dump(pe,type,op);
236: }
237:
238: pdu_arg_log (pe,op)
239: PE pe;
240: int op;
241: {
242: return (pdu_arg_log (pe,op));
243: }
244:
245: pdu_res_log (pe,op)
246: PE pe;
247: int op;
248: {
249: return (pdu_arg_log (pe,op));
250: }
251:
252: dap_abandon (ad, id, arg, error)
253: int ad;
254: int * id;
255: struct ds_abandon_arg *arg;
256: struct DSError *error;
257: {
258: return dap_abandon (ad, id, arg, error);
259: }
260:
261: int DapAbandon (ad, id, arg, di, asyn)
262: int ad;
263: int id;
264: struct ds_abandon_arg * arg;
265: struct DAPindication * di;
266: int asyn;
267: {
268: return (DapAbandon (ad, id, arg, di, asyn));
269: }
270:
271: dap_addentry (ad, id, arg, error)
272: int ad;
273: int * id;
274: struct ds_addentry_arg *arg;
275: struct DSError *error;
276: {
277: return dap_addentry (ad, id, arg, error);
278: }
279:
280: int DapAddEntry (ad, id, arg, di, asyn)
281: int ad;
282: int id;
283: struct ds_addentry_arg * arg;
284: struct DAPindication * di;
285: int asyn;
286: {
287: return (DapAddEntry (ad, id, arg, di, asyn));
288: }
289:
290: dap_compare (ad, id, arg, error, result)
291: int ad;
292: int * id;
293: struct ds_compare_arg *arg;
294: struct ds_compare_result *result;
295: struct DSError *error;
296: {
297: return dap_compare (ad, id, arg, error, result);
298: }
299:
300: int DapCompare (ad, id, arg, di, asyn)
301: int ad;
302: int id;
303: struct ds_compare_arg * arg;
304: struct DAPindication * di;
305: int asyn;
306: {
307: return (DapCompare (ad, id, arg, di, asyn));
308: }
309:
310: dap_list (ad, id, arg, error, result)
311: int ad;
312: int * id;
313: struct ds_list_arg *arg;
314: struct ds_list_result *result;
315: struct DSError *error;
316: {
317: return dap_list (ad, id, arg, error, result) ;
318: }
319:
320: int DapList (ad, id, arg, di, asyn)
321: int ad;
322: int id;
323: struct ds_list_arg * arg;
324: struct DAPindication * di;
325: int asyn;
326: {
327: return ( DapList (ad, id, arg, di, asyn));
328: }
329:
330: dap_modifyentry (ad, id, arg, error)
331: int ad;
332: int * id;
333: struct ds_modifyentry_arg *arg;
334: struct DSError *error;
335: {
336: return dap_modifyentry (ad, id, arg, error) ;
337: }
338:
339: int DapModifyEntry (ad, id, arg, di, asyn)
340: int ad;
341: int id;
342: struct ds_modifyentry_arg * arg;
343: struct DAPindication * di;
344: int asyn;
345: {
346: return (DapModifyEntry (ad, id, arg, di, asyn));
347: }
348:
349: dap_modifyrdn (ad, id, arg, error)
350: int ad;
351: int * id;
352: struct ds_modifyrdn_arg *arg;
353: struct DSError *error;
354: {
355: return dap_modifyrdn (ad, id, arg, error) ;
356: }
357:
358: int DapModifyRDN (ad, id, arg, di, asyn)
359: int ad;
360: int id;
361: struct ds_modifyrdn_arg * arg;
362: struct DAPindication * di;
363: int asyn;
364: {
365: return (DapModifyRDN (ad, id, arg, di, asyn));
366: }
367:
368: dap_read (ad, id, arg, error, result)
369: int ad;
370: int * id;
371: struct ds_read_arg *arg;
372: struct ds_read_result *result;
373: struct DSError *error;
374: {
375: return dap_read (ad, id, arg, error, result) ;
376: }
377:
378: int DapRead (ad, id, arg, di, asyn)
379: int ad;
380: int id;
381: struct ds_read_arg * arg;
382: struct DAPindication * di;
383: int asyn;
384: {
385: return (DapRead (ad, id, arg, di, asyn));
386: }
387:
388: dap_removeentry (ad, id, arg, error)
389: int ad;
390: int * id;
391: struct ds_removeentry_arg *arg;
392: struct DSError *error;
393: {
394: return dap_removeentry (ad, id, arg, error) ;
395: }
396:
397: int DapRemoveEntry (ad, id, arg, di, asyn)
398: int ad;
399: int id;
400: struct ds_removeentry_arg * arg;
401: struct DAPindication * di;
402: int asyn;
403: {
404: return (DapRemoveEntry (ad, id, arg, di, asyn));
405: }
406:
407: dap_search (ad, id, arg, error, result)
408: int ad;
409: int * id;
410: struct ds_search_arg *arg;
411: struct ds_search_result *result;
412: struct DSError *error;
413: {
414: return dap_search (ad, id, arg, error, result) ;
415: }
416:
417: int DapSearch (ad, id, arg, di, asyn)
418: int ad;
419: int id;
420: struct ds_search_arg * arg;
421: struct DAPindication * di;
422: int asyn;
423: {
424: return ( DapSearch (ad, id, arg, di, asyn));
425: }
426:
427: void ros_log(rop, event)
428: register struct RoSAPpreject *rop;
429: char *event;
430: {
431: ros_log(rop,event);
432: }
433:
434: void acs_log(aca, event)
435: register struct AcSAPabort *aca;
436: char *event;
437: {
438: acs_log(aca,event);
439: }
440:
441: td_log(td, event)
442: struct TSAPdisconnect *td;
443: char *event;
444: {
445: (void) td_log(td,event);
446: }
447:
448: int DUAbortRequest (sd, di)
449: int sd;
450: struct DSAPindication * di;
451: {
452: return (DUAbortRequest (sd, di));
453: }
454:
455: int DspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
456: calledaddr, prequirements, srequirements, isn, settings,
457: sf, bindarg, qos, dc, di, async)
458: AEI callingtitle;
459: AEI calledtitle;
460: struct PSAPaddr * callingaddr;
461: struct PSAPaddr * calledaddr;
462: int prequirements;
463: int srequirements;
464: long isn;
465: int settings;
466: struct SSAPref * sf;
467: struct ds_bind_arg * bindarg;
468: struct QOStype * qos;
469: struct DSAPconnect * dc;
470: struct DSAPindication * di;
471: int async;
472: {
473: return (DspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
474: calledaddr, prequirements, srequirements, isn, settings,
475: sf, bindarg, qos, dc, di, async));
476: }
477:
478: int DspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async)
479: struct PSAPaddr * calledaddr;
480: struct ds_bind_arg * bindarg;
481: int qos_maxtime;
482: struct DSAPconnect * dc;
483: struct DSAPindication * di;
484: int async;
485: {
486: return (DspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async));
487: }
488:
489: int QspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
490: calledaddr, prequirements, srequirements, isn, settings,
491: sf, bindarg, qos, dc, di, async)
492: AEI callingtitle;
493: AEI calledtitle;
494: struct PSAPaddr * callingaddr;
495: struct PSAPaddr * calledaddr;
496: int prequirements;
497: int srequirements;
498: long isn;
499: int settings;
500: struct SSAPref * sf;
501: struct ds_bind_arg * bindarg;
502: struct QOStype * qos;
503: struct DSAPconnect * dc;
504: struct DSAPindication * di;
505: int async;
506: {
507: return (QspAsynBindReqAux (callingtitle, calledtitle, callingaddr,
508: calledaddr, prequirements, srequirements, isn, settings,
509: sf, bindarg, qos, dc, di, async));
510: }
511:
512: int QspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async)
513: struct PSAPaddr * calledaddr;
514: struct ds_bind_arg * bindarg;
515: int qos_maxtime;
516: struct DSAPconnect * dc;
517: struct DSAPindication * di;
518: int async;
519: {
520: return (QspAsynBindRequest (calledaddr, bindarg, qos_maxtime, dc, di, async));
521: }
522:
523: int DspAsynBindRetry (sd, do_next_nsap, dc, di)
524: int sd;
525: int do_next_nsap;
526: struct DSAPconnect * dc;
527: struct DSAPindication * di;
528: {
529: return (DspAsynBindRetry (sd, do_next_nsap, dc, di));
530: }
531:
532: int QspAsynBindRetry (sd, do_next_nsap, dc, di)
533: int sd;
534: int do_next_nsap;
535: struct DSAPconnect * dc;
536: struct DSAPindication * di;
537: {
538: return (QspAsynBindRetry (sd, do_next_nsap, dc, di));
539: }
540:
541: int DBindDecode (acc, dc)
542: struct AcSAPconnect * acc;
543: struct DSAPconnect * dc;
544: {
545: return (DBindDecode (acc, dc));
546: }
547:
548: int DBindInit (vecp, vec, ds, di)
549: int vecp;
550: char **vec;
551: struct DSAPstart * ds;
552: struct DSAPindication * di;
553: {
554: return (DBindInit (vecp, vec, ds, di));
555: }
556:
557: int DBindResult (sd, context, respondtitle,
558: respondaddr, ctxlist, defctxresult, prequirements,
559: srequirements, isn, settings, ref, bind_res, pctx_id, di)
560: int sd;
561: OID context;
562: AEI respondtitle;
563: struct PSAPaddr * respondaddr;
564: struct PSAPctxlist * ctxlist;
565: int defctxresult;
566: int prequirements;
567: int srequirements;
568: long isn;
569: int settings;
570: struct SSAPref * ref;
571: struct ds_bind_arg * bind_res;
572: int pctx_id;
573: struct DSAPindication * di;
574: {
575: return (DBindResult (sd, context, respondtitle,
576: respondaddr, ctxlist, defctxresult, prequirements,
577: srequirements, isn, settings, ref, bind_res, pctx_id, di));
578: }
579:
580: int DBindError (sd, context, respondtitle, respondaddr, ctxlist,
581: defctxresult, prequirements, srequirements, isn, settings,
582: ref, bind_err, pctx_id, di)
583: int sd;
584: OID context;
585: AEI respondtitle;
586: struct PSAPaddr * respondaddr;
587: struct PSAPctxlist * ctxlist;
588: int defctxresult;
589: int prequirements;
590: int srequirements;
591: long isn;
592: int settings;
593: struct SSAPref * ref;
594: struct ds_bind_error * bind_err;
595: int pctx_id;
596: struct DSAPindication * di;
597: {
598: return (DBindError (sd, context, respondtitle, respondaddr, ctxlist,
599: defctxresult, prequirements, srequirements, isn, settings,
600: ref, bind_err, pctx_id, di));
601: }
602:
603: int DBindReject (ds, status, reason, di)
604: struct DSAPstart * ds;
605: int status;
606: int reason;
607: struct DSAPindication * di;
608: {
609: return (DBindReject (ds, status, reason, di));
610: }
611:
612: int select_context (app_ctx)
613: OID app_ctx;
614: {
615: return (select_context (app_ctx));
616: }
617:
618: int judge_ctxlist(req_ctxlist, ok_ctxlist)
619: struct PSAPctxlist * req_ctxlist;
620: struct PSAPctxlist * ok_ctxlist;
621: {
622: return (judge_ctxlist(req_ctxlist, ok_ctxlist));
623: }
624:
625: int find_ctx_id(pcdl, ctx_oid)
626: struct PSAPctxlist * pcdl;
627: OID ctx_oid;
628: {
629: return (find_ctx_id(pcdl, ctx_oid));
630: }
631:
632: int check_dap_ctxlist (ctxlist)
633: struct PSAPctxlist * ctxlist;
634: {
635: return (check_dap_ctxlist (ctxlist));
636: }
637:
638: int check_dsp_ctxlist (ctxlist)
639: struct PSAPctxlist * ctxlist;
640: {
641: return (check_dsp_ctxlist (ctxlist));
642: }
643:
644: int check_qsp_ctxlist (ctxlist)
645: struct PSAPctxlist * ctxlist;
646: {
647: return (check_qsp_ctxlist (ctxlist));
648: }
649:
650: int DapErrorRequest (sd, id, err, di)
651: int sd;
652: int id;
653: struct DSError * err;
654: struct DSAPindication * di;
655: {
656: return (DapErrorRequest (sd, id, err, di));
657: }
658:
659: int DspErrorRequest (sd, id, err, di)
660: int sd;
661: int id;
662: struct DSError * err;
663: struct DSAPindication * di;
664: {
665: return (DspErrorRequest (sd, id, err, di));
666: }
667:
668: int QspErrorRequest (sd, id, err, di)
669: int sd;
670: int id;
671: struct DSError * err;
672: struct DSAPindication * di;
673: {
674: return (QspErrorRequest (sd, id, err, di));
675: }
676:
677: int DEncodeError(pep, err)
678: PE *pep;
679: struct DSError *err;
680: {
681: return (DEncodeError(pep, err));
682: }
683:
684: int DapInvokeRequest (sd, id, arg, di)
685: int sd;
686: int id;
687: struct DSArgument * arg;
688: struct DSAPindication * di;
689: {
690: return (DapInvokeRequest (sd, id, arg, di));
691: }
692:
693: int DapEncodeInvoke (pep, arg)
694: PE * pep;
695: struct DSArgument * arg;
696: {
697: return (DapEncodeInvoke (pep, arg));
698: }
699:
700: int DspInvokeRequest (sd, id, arg, di)
701: int sd;
702: int id;
703: struct ds_op_arg * arg;
704: struct DSAPindication * di;
705: {
706: return (DspInvokeRequest (sd, id, arg, di));
707: }
708:
709: int DspEncodeInvoke (pep, arg)
710: PE * pep;
711: struct ds_op_arg * arg;
712: {
713: return (DspEncodeInvoke (pep, arg));
714: }
715:
716: int QspInvokeRequest (sd, id, arg, di)
717: int sd;
718: int id;
719: struct ds_op_arg * arg;
720: struct DSAPindication * di;
721: {
722: return (QspInvokeRequest (sd, id, arg, di));
723: }
724:
725: int QspEncodeInvoke (pep, arg)
726: PE * pep;
727: struct ds_op_arg * arg;
728: {
729: return (QspEncodeInvoke (pep, arg));
730: }
731:
732: int dsaplose (di, reason, what, fmt)
733: struct DSAPindication *di;
734: int reason;
735: char *what,
736: *fmt;
737: {
738: return dsaplose (di, reason, what, fmt);
739: }
740:
741: int dsapreject (di, reason, id, what, fmt)
742: struct DSAPindication *di;
743: int reason;
744: int id;
745: char *what,
746: *fmt;
747: {
748: return dsapreject (di, reason, id, what, fmt);
749: }
750:
751: int DRejectRequest (sd, reason, id)
752: int sd;
753: int reason;
754: int id;
755: {
756: return (DRejectRequest (sd, reason, id));
757: }
758:
759: int DapResultRequest (sd, id, res, di)
760: int sd;
761: int id;
762: struct DSResult * res;
763: struct DSAPindication * di;
764: {
765: return ( DapResultRequest (sd, id, res, di));
766: }
767:
768: int DapEncodeResult (pep, res)
769: PE * pep;
770: struct DSResult * res;
771: {
772: return (DapEncodeResult (pep, res));
773: }
774:
775: int DspResultRequest (sd, id, res, di)
776: int sd;
777: int id;
778: struct ds_op_res * res;
779: struct DSAPindication * di;
780: {
781: return (DspResultRequest (sd, id, res, di));
782: }
783:
784: int DspEncodeResult (pep, res)
785: PE * pep;
786: struct ds_op_res * res;
787: {
788: return (DspEncodeResult (pep, res));
789: }
790:
791: int QspResultRequest (sd, id, res, di)
792: int sd;
793: int id;
794: struct ds_op_res * res;
795: struct DSAPindication * di;
796: {
797: return (QspResultRequest (sd, id, res, di));
798: }
799:
800: int QspEncodeResult (pep, res)
801: PE * pep;
802: struct ds_op_res * res;
803: {
804: return ( QspEncodeResult (pep, res));
805: }
806:
807: int ronot2dsaplose (di, event, rni)
808: struct DSAPindication * di;
809: char * event;
810: struct RoNOTindication * rni;
811: {
812: return (ronot2dsaplose (di, event, rni));
813: }
814:
815: int ros2dsaplose (di, event, rop)
816: struct DSAPindication * di;
817: char * event;
818: struct RoSAPpreject * rop;
819: {
820: return (ros2dsaplose (di, event, rop));
821: }
822:
823: int ros2dsapreject (di, event, rou)
824: struct DSAPindication * di;
825: char * event;
826: struct RoSAPureject * rou;
827: {
828: return (ros2dsapreject (di, event, rou));
829: }
830:
831: int DUnBindRequest (sd, secs, dr, di)
832: int sd;
833: int secs;
834: struct DSAPrelease * dr;
835: struct DSAPindication * di;
836: {
837: return (DUnBindRequest (sd, secs, dr, di));
838: }
839:
840: int DUnBindRetry (sd, secs, dr, di)
841: int sd;
842: int secs;
843: struct DSAPrelease * dr;
844: struct DSAPindication * di;
845: {
846: return (DUnBindRetry (sd, secs, dr, di));
847: }
848:
849: int DUnBindAccept (sd, di)
850: int sd;
851: struct DSAPindication * di;
852: {
853: return (DUnBindAccept (sd, di));
854: }
855:
856: int DUnBindReject (sd, status, reason, di)
857: int sd;
858: int status;
859: int reason;
860: struct DSAPindication * di;
861: {
862: return (DUnBindReject (sd, status, reason, di));
863: }
864:
865: int DWaitRequest (ctx, sd, secs, di)
866: int ctx;
867: int sd;
868: int secs;
869: struct DSAPindication * di;
870: {
871: return (DWaitRequest (ctx, sd, secs, di));
872: }
873:
874: int DapRespWaitRequest (sd, secs, di)
875: int sd;
876: int secs;
877: struct DSAPindication * di;
878: {
879: return (DapRespWaitRequest (sd, secs, di));
880: }
881:
882: int DspWaitRequest (sd, secs, di)
883: int sd;
884: int secs;
885: struct DSAPindication * di;
886: {
887: return (DspWaitRequest (sd, secs, di));
888: }
889:
890: int QspWaitRequest (sd, secs, di)
891: int sd;
892: int secs;
893: struct DSAPindication * di;
894: {
895: return (QspWaitRequest (sd, secs, di));
896: }
897:
898: int DapDecodeInvoke (sd, rox, di)
899: int sd;
900: struct RoSAPinvoke * rox;
901: struct DSAPindication * di;
902: {
903: return ( DapDecodeInvoke (sd, rox, di));
904: }
905:
906: int DDecodeUnbind (sd, acf, di)
907: int sd;
908: struct AcSAPfinish * acf;
909: struct DSAPindication * di;
910: {
911: return (DDecodeUnbind (sd, acf, di));
912: }
913:
914: int DspDecodeInvoke (sd, rox, di)
915: int sd;
916: struct RoSAPinvoke * rox;
917: struct DSAPindication * di;
918: {
919: return (DspDecodeInvoke (sd, rox, di));
920: }
921:
922: int DspDecodeResult (sd, ror, di)
923: int sd;
924: struct RoSAPresult * ror;
925: struct DSAPindication * di;
926: {
927: return (DspDecodeResult (sd, ror, di));
928: }
929:
930: int DspDecodeError (sd, roe, di)
931: int sd;
932: struct RoSAPerror * roe;
933: struct DSAPindication * di;
934: {
935: return (DspDecodeError (sd, roe, di));
936: }
937:
938: int DspDecodeUnbind (sd, acf, di)
939: int sd;
940: struct AcSAPfinish * acf;
941: struct DSAPindication * di;
942: {
943: return (DspDecodeUnbind (sd, acf, di));
944: }
945:
946: int QspDecodeInvoke (sd, rox, di)
947: int sd;
948: struct RoSAPinvoke * rox;
949: struct DSAPindication * di;
950: {
951: return (QspDecodeInvoke (sd, rox, di));
952: }
953:
954: int QspDecodeResult (sd, ror, di)
955: int sd;
956: struct RoSAPresult * ror;
957: struct DSAPindication * di;
958: {
959: return ( QspDecodeResult (sd, ror, di));
960: }
961:
962: int QspDecodeError (sd, roe, di)
963: int sd;
964: struct RoSAPerror * roe;
965: struct DSAPindication * di;
966: {
967: return (QspDecodeError (sd, roe, di));
968: }
969:
970: int QspDecodeUnbind (sd, acf, di)
971: int sd;
972: struct AcSAPfinish * acf;
973: struct DSAPindication * di;
974: {
975: return (QspDecodeUnbind (sd, acf, di));
976: }
977:
978: /* Some types routines */
979:
980: bind_arg_free (arg)
981: struct ds_bind_arg *arg;
982: {
983: return (bind_arg_free (arg));
984: }
985:
986: op_arg_free (arg)
987: struct ds_op_arg * arg;
988: {
989: return (op_arg_free (arg));
990: }
991:
992: ch_arg_free (arg)
993: struct chain_arg * arg;
994: {
995: return (ch_arg_free (arg));
996: }
997:
998: ds_arg_free (arg)
999: struct DSArgument * arg;
1000: {
1001: return (ds_arg_free (arg));
1002: }
1003:
1004: read_arg_free (arg)
1005: struct ds_read_arg * arg;
1006: {
1007: return (read_arg_free (arg));
1008: }
1009:
1010: compare_arg_free (arg)
1011: struct ds_compare_arg * arg;
1012: {
1013: return (compare_arg_free (arg));
1014: }
1015:
1016: list_arg_free (arg)
1017: struct ds_list_arg * arg;
1018: {
1019: return (list_arg_free (arg));
1020: }
1021:
1022: search_arg_free (arg)
1023: struct ds_search_arg * arg;
1024: {
1025: return (search_arg_free (arg));
1026: }
1027:
1028: addentry_arg_free (arg)
1029: struct ds_addentry_arg * arg;
1030: {
1031: return (addentry_arg_free (arg));
1032: }
1033:
1034: removeentry_arg_free (arg)
1035: struct ds_removeentry_arg * arg;
1036: {
1037: return (removeentry_arg_free (arg));
1038: }
1039:
1040: modifyentry_arg_free (arg)
1041: struct ds_modifyentry_arg * arg;
1042: {
1043: return (modifyentry_arg_free (arg));
1044: }
1045:
1046: modifyrdn_arg_free (arg)
1047: struct ds_modifyrdn_arg * arg;
1048: {
1049: return (modifyrdn_arg_free (arg));
1050: }
1051:
1052: getedb_arg_free (arg)
1053: struct getedb_arg * arg;
1054: {
1055: return (getedb_arg_free (arg));
1056: }
1057:
1058: op_res_free (res)
1059: struct ds_op_res * res;
1060: {
1061: return (op_res_free (res));
1062: }
1063:
1064: ch_res_free (res)
1065: struct chain_res * res;
1066: {
1067: return (ch_res_free (res));
1068: }
1069:
1070: ds_res_free (res)
1071: struct DSResult * res;
1072: {
1073: return (ds_res_free (res));
1074: }
1075:
1076: trace_info_free (ti)
1077: struct trace_info * ti;
1078: {
1079: return (trace_info_free (ti));
1080: }
1081:
1082: ca_free (ca)
1083: CommonArgs * ca;
1084: {
1085: return (ca_free (ca));
1086: }
1087:
1088: extension_free (ext)
1089: struct extension * ext;
1090: {
1091: return (extension_free (ext));
1092: }
1093:
1094: cross_refs_free (xref)
1095: struct cross_ref * xref;
1096: {
1097: return (cross_refs_free (xref));
1098: }
1099:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.