![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dapinvoke.c 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 dapinvoke.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / net |
1.1 root 1: /* dapinvoke.c - DAP : Invoke DAP operations */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/dsap/net/RCS/dapinvoke.c,v 7.0 90/07/26 14:45:21 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/dsap/net/RCS/dapinvoke.c,v 7.0 90/07/26 14:45:21 mrose Exp $
9: *
10: *
11: * $Log: dapinvoke.c,v $
12: * Revision 7.0 90/07/26 14:45:21 mrose
13: * *** empty log message ***
14: *
15: */
16:
17: /*
18: * NOTICE
19: *
20: * Acquisition, use, and distribution of this module and related
21: * materials are subject to the restrictions of a license agreement.
22: * Consult the Preface in the User's Manual for the full terms of
23: * this agreement.
24: *
25: */
26:
27:
28: /* LINTLIBRARY */
29:
30: #include <stdio.h>
31: #include "logger.h"
32: #include "quipu/util.h"
33: #include "quipu/dap2.h"
34:
35: extern LLog * log_dsap;
36: extern void ros_log();
37:
38: #ifdef PDU_DUMP
39: #define DUMP_ARG "arg"
40: #define DUMP_RES "res"
41: #define DUMP_ERR "err"
42: #endif
43:
44: int DapInvokeReqAux (sd, id, op, pe, di, asyn)
45: int sd;
46: int id;
47: int op;
48: PE pe;
49: struct DAPindication * di;
50: int asyn;
51: {
52:
53: #ifdef PDU_DUMP
54: pdu_dump (pe,DUMP_ARG,op);
55: #endif
56:
57: #ifdef HEAVY_DEBUG
58: pdu_arg_log (pe, op);
59: #endif
60:
61: switch (asyn)
62: {
63: case ROS_SYNC:
64: return (DapSyncInvokeRequest (sd, id, op, pe, di));
65:
66: case ROS_INTR:
67: return (DapIntrInvokeRequest (sd, id, op, pe, di));
68:
69: case ROS_ASYNC:
70: return (DapAsynInvokeRequest (sd, id, op, pe, di));
71:
72: default:
73: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapInvokeReqAux(): asyn has unknown value: %d", asyn));
74: return (daplose (di, DP_INVOKE, NULLCP, "Unknown synchronicity"));
75: }
76: }
77:
78: int DapSyncInvokeRequest (sd, id, op, pe, di)
79: int sd;
80: int id;
81: int op;
82: PE pe;
83: struct DAPindication * di;
84: {
85: int result;
86: struct RoSAPindication roi_s;
87: struct RoSAPindication * roi = &(roi_s);
88: struct RoSAPpreject * rop = &(roi->roi_preject);
89:
90: DLOG (log_dsap,LLOG_TRACE,( "DapSyncInvokeRequest()"));
91:
92: result = RoInvokeRequest (sd, op, ROS_SYNC, pe,
93: id, NULLIP, ROS_NOPRIO, roi);
94:
95: if (result != OK)
96: {
97: if (roi->roi_type != ROI_PREJECT)
98: {
99: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapSyncInvokeRequest(): Failed without rejection"));
100: return (daplose (di, DP_INVOKE, NULLCP, "RoInvokeRequest inconsistent result"));
101: }
102:
103: if (ROS_FATAL (rop->rop_reason) || (rop->rop_reason == ROS_PARAMETER))
104: {
105: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapSyncInvokeRequest(): Fatal rejection"));
106: return (daplose (di, DP_INVOKE, NULLCP, "RoInvokeRequest failed"));
107: }
108: else
109: {
110: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapSyncInvokeRequest(): Non-Fatal rejection"));
111: return (dapreject (di, DP_INVOKE, id, NULLCP, "RoInvokeRequest failed"));
112: }
113: }
114:
115: switch(roi->roi_type)
116: {
117: case ROI_INVOKE:
118: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapSyncInvokeRequest: Invocation received"));
119: DRejectRequest (sd, ROS_IP_UNRECOG, roi->roi_invoke.rox_id);
120: return (daplose (di, DP_ROS, NULLCP, "DAP initiator cannot accept invokes"));
121:
122: case ROI_RESULT:
123: return (DapDecodeResult (sd, &(roi->roi_result), di));
124:
125: case ROI_ERROR:
126: return (DapDecodeError (sd, &(roi->roi_error), di));
127:
128: case ROI_UREJECT:
129: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapSyncInvokeRequest: Operation (%d) user rejected (%d)", roi->roi_ureject.rou_id, roi->roi_ureject.rou_reason));
130: return (ros2dapreject (di, "ROI_UREJECT", &(roi->roi_ureject)));
131:
132: case ROI_PREJECT:
133: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapSyncInvokeRequest: Operation (%d) provider rejected", roi->roi_preject.rop_id));
134: return (ros2daplose (di, "ROI_PREJECT", &(roi->roi_preject)));
135:
136: case ROI_FINISH:
137: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapSyncInvokeRequest: Unbind request received"));
138: return (daplose (di, DP_ROS, NULLCP, "DAP initiator cannot accept unbind requests"));
139:
140: default:
141: LLOG (log_dsap,LLOG_EXCEPTIONS,( "Unknown indication type : %d", roi->roi_type));
142: break;
143: }
144:
145: return (OK);
146: }
147:
148: int DapIntrInvokeRequest (sd, id, op, pe, di)
149: int sd;
150: int id;
151: int op;
152: PE pe;
153: struct DAPindication * di;
154: {
155: int result;
156: struct RoSAPindication roi_s;
157: struct RoSAPindication * roi = &(roi_s);
158: struct RoSAPpreject * rop = &(roi->roi_preject);
159:
160: DLOG (log_dsap,LLOG_TRACE,( "DapIntrInvokeRequest()"));
161:
162: result = RoIntrRequest (sd, op, pe, id, NULLIP, ROS_NOPRIO, roi);
163:
164: if (result != OK)
165: {
166: if (roi->roi_type != ROI_PREJECT)
167: {
168: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapIntrInvokeRequest(): Failed without rejection"));
169: return (daplose (di, DP_INVOKE, NULLCP, "RoInvokeRequest inconsistent result"));
170: }
171:
172: if (rop->rop_reason == ROS_INTERRUPTED)
173: {
174: return (DapInterrupt(sd, id, op, di));
175: }
176:
177: if (ROS_FATAL (rop->rop_reason) || (rop->rop_reason == ROS_PARAMETER))
178: {
179: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapIntrInvokeRequest(): Fatal rejection"));
180: return (daplose (di, DP_INVOKE, NULLCP, "RoInvokeRequest failed"));
181: }
182: else
183: {
184: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapIntrInvokeRequest(): Non-Fatal rejection"));
185: return (dapreject (di, DP_INVOKE, id, NULLCP, "RoInvokeRequest failed"));
186: }
187: }
188:
189: switch(roi->roi_type)
190: {
191: case ROI_INVOKE:
192: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapIntrInvokeRequest: Invocation received"));
193: DRejectRequest (sd, ROS_IP_UNRECOG, roi->roi_invoke.rox_id);
194: return (daplose (di, DP_ROS, NULLCP, "DAP initiator cannot accept invokes"));
195:
196: case ROI_RESULT:
197: return (DapDecodeResult (sd, &(roi->roi_result), di));
198:
199: case ROI_ERROR:
200: return (DapDecodeError (sd, &(roi->roi_error), di));
201:
202: case ROI_UREJECT:
203: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapIntrInvokeRequest: Operation (%d) user rejected (%d)", roi->roi_ureject.rou_id, roi->roi_ureject.rou_reason));
204: return (ros2dapreject (di, "ROI_UREJECT", &(roi->roi_ureject)));
205:
206: case ROI_PREJECT:
207: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapIntrInvokeRequest: Operation (%d) provider rejected", roi->roi_preject.rop_id));
208: return (ros2daplose (di, "ROI_PREJECT", &(roi->roi_preject)));
209:
210: case ROI_FINISH:
211: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapIntrInvokeRequest: Unbind request received"));
212: return (daplose (di, DP_ROS, NULLCP, "DAP initiator cannot accept unbind requests"));
213:
214: default:
215: LLOG (log_dsap,LLOG_EXCEPTIONS,( "Unknown indication type : %d", roi->roi_type));
216: break;
217: }
218:
219: return (OK);
220: }
221:
222: int DapAsynInvokeRequest (sd, id, op, pe, di)
223: int sd;
224: int id;
225: int op;
226: PE pe;
227: struct DAPindication * di;
228: {
229: int result;
230: struct RoSAPindication roi_s;
231: struct RoSAPindication * roi = &(roi_s);
232: struct RoSAPpreject * rop = &(roi->roi_preject);
233:
234: result = RoInvokeRequest (sd, op, ROS_ASYNC, pe,
235: id, NULLIP, ROS_NOPRIO, roi);
236:
237: if (result != OK)
238: {
239: if (roi->roi_type != ROI_PREJECT)
240: {
241: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapAsynInvokeRequest(): Failed without rejection"));
242: return (daplose (di, DP_INVOKE, NULLCP, "RoInvokeRequest inconsistent result"));
243: }
244:
245: if (ROS_FATAL (rop->rop_reason) || (rop->rop_reason == ROS_PARAMETER))
246: {
247: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapAsynInvokeRequest(): Fatal rejection"));
248: return (daplose (di, DP_INVOKE, NULLCP, "RoInvokeRequest failed"));
249: }
250: else
251: {
252: LLOG (log_dsap, LLOG_EXCEPTIONS, ("DapAsynInvokeRequest(): Non-Fatal rejection"));
253: return (dapreject (di, DP_INVOKE, id, NULLCP, "RoInvokeRequest failed"));
254: }
255: }
256:
257: return (OK);
258: }
259:
260: int DapInterrupt(sd, id, op, di)
261: int sd;
262: int id;
263: int op;
264: struct DAPindication * di;
265: {
266: /*
267: * Abandoning. Trickier than it looks!
268: * Need to RoInvoke an abandon op, which will receive
269: * One of the following:
270: * Result/Error for op being abandoned sent before
271: * this abandon arrived at the DSA;
272: * Abandoned error for op being abandoned;
273: * Result for abandon op which has overtaken the
274: * abandoned error for previous op between DSA and DUA
275: * Error for abandon because DSA has screwed up.
276: *
277: * Unless something goes wrong there should be 2 Ro events to
278: * collect before returning.
279: */
280:
281: /* abandon operation */
282: struct ds_abandon_arg ab_arg;
283: struct DSError ab_err;
284: PE ab_req_pe;
285: int old_id;
286: int new_id;
287: int ret1;
288: int ret2;
289: struct RoSAPindication roi1_s;
290: struct RoSAPindication * roi1 = &(roi1_s);
291: struct RoSAPpreject * rop1 = &(roi1->roi_preject);
292: struct RoSAPindication roi2_s;
293: struct RoSAPindication * roi2 = &(roi2_s);
294: struct RoSAPpreject * rop2 = &(roi2->roi_preject);
295: struct RoSAPindication * result_roi;
296:
297: ab_arg.aba_invokeid = old_id = id;
298: new_id = ++id;
299:
300: if(encode_DAS_AbandonArgument(&ab_req_pe,1,0,NULLCP,&ab_arg) != OK)
301: {
302: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Failed to encode an abandon operation"));
303: /* Go on listening for result or dump out ?? */
304: return(dapreject (di, DP_INVOKE, old_id, NULLCP, "DapInterrupt: Abandon argument encoding failed"));
305: }
306: else
307: {
308: DLOG(log_dsap, LLOG_DEBUG, ("Abandon invoke request"));
309:
310: ret1 = RoInvokeRequest(sd,OP_ABANDON,ROS_SYNC,ab_req_pe,new_id,NULLIP,ROS_NOPRIO,roi1);
311:
312: DLOG(log_dsap, LLOG_DEBUG, ("Abandon RoInvoke returns: %d", ret1));
313:
314: if (ab_req_pe != NULLPE)
315: pe_free(ab_req_pe);
316:
317: switch(ret1)
318: {
319: case OK:
320: /* What have we got? */
321: switch(roi1->roi_type)
322: {
323: case ROI_RESULT:
324: if(roi1->roi_result.ror_id == old_id)
325: {
326: /* Ferret result away for later */
327: result_roi = roi1;
328: }
329: else if(roi1->roi_result.ror_id == (old_id + 1))
330: {
331: RORFREE (&(roi1->roi_result));
332: }
333: else
334: {
335: LLOG(log_dsap, LLOG_EXCEPTIONS, ("ARRGH! Abandon sent: event for neither op nor abandon op returned!!"));
336: return(dapreject (di, DP_INVOKE, roi1->roi_result.ror_id, NULLCP, "Unexpected operation identifier"));
337: }
338: break;
339:
340: case ROI_ERROR:
341: #ifdef PDU_DUMP
342: pdu_dump (roi1->roi_error.roe_param,DUMP_ERR,op);
343: #endif
344:
345: if(roi1->roi_error.roe_id == old_id)
346: {
347: /* Ferret error away for later */
348: result_roi = roi1;
349: }
350: else if(roi1->roi_error.roe_id == (old_id + 1))
351: {
352: if (roi1->roi_error.roe_error != DSE_ABANDON_FAILED)
353: {
354: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Failed to abandon correctly"));
355: return(dapreject (di, DP_INVOKE, roi1->roi_error.roe_id, NULLCP, "Error mistyped for abandon"));
356: }
357: else
358: {
359: if(decode_DAS_AbandonFailedParm (roi1->roi_error.roe_param, 1, NULLIP, NULLVP, &(ab_err.dse_un.dse_un_abandon_fail)) != OK)
360: {
361: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Failed to decode abandonFailed"));
362: return(dapreject (di, DP_INVOKE, old_id, NULLCP, "Abandon error decoding failed"));
363: }
364: else
365: {
366: LLOG(log_dsap, LLOG_NOTICE, ("Abandon failed error!!!"));
367: ab_err.dse_type = DSE_ABANDON_FAILED;
368: log_ds_error(&ab_err);
369: ds_error_free(&ab_err);
370: }
371: }
372: }
373: else
374: {
375: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Abandon sent : event for neither op nor abandon op returned!!"));
376: return(dapreject (di, DP_INVOKE, roi1->roi_error.roe_id, NULLCP, "Unrecognised op id"));
377: }
378: break;
379:
380: default:
381: LLOG(log_dsap, LLOG_FATAL, ("Unexpected roi_type : %d", roi1->roi_type));
382: return(dapreject (di, DP_INVOKE, -1, NULLCP, "Unrecognised event"));
383: }
384: break;
385:
386: case NOTOK:
387: ros_log(rop1, "RO-INVOKE.REQUEST");
388: if (ROS_FATAL (rop2->rop_reason))
389: {
390: return (ros2daplose (di, "DapInterrupt", rop2));
391: }
392: else
393: {
394: return (dapreject (di, DP_ROS, -1, NULLCP, "DapInterrupt: Non-fatal reject"));
395: }
396:
397: case DONE:
398: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Responder has sent Finish!"));
399: return(daplose (di, DP_ROS, NULLCP, "Received Finish"));
400:
401: default:
402: LLOG(log_dsap, LLOG_FATAL, ("Unknown return from RoInvokeRequest : %d", ret1));
403: return(daplose (di, DP_ROS, NULLCP, "RoInvokeRequest error"));
404: }
405:
406: ret2 = RoWaitRequest(sd, NOTOK, roi2);
407:
408: DLOG(log_dsap, LLOG_DEBUG, ("Abandon RoInvoke returns: %d", ret1));
409:
410: switch(ret2)
411: {
412: case OK:
413: /* What have we got? */
414: switch(roi2->roi_type)
415: {
416: case ROI_RESULT:
417: if(roi2->roi_result.ror_id == old_id)
418: {
419: /* Ferret result away for later */
420: result_roi = roi2;
421: }
422: else if(roi2->roi_result.ror_id == (old_id + 1))
423: {
424: RORFREE (&(roi2->roi_result));
425: }
426: else
427: {
428: LLOG(log_dsap, LLOG_EXCEPTIONS, ("ARRGH! Abandon sent and event for neither op nor abandon op returned!!"));
429: return(dapreject (di, DP_INVOKE, roi1->roi_result.ror_id, NULLCP, "Unexpected operation identifier"));
430: }
431: break;
432:
433: case ROI_ERROR:
434: #ifdef PDU_DUMP
435: pdu_dump (roi1->roi_error.roe_param,DUMP_ERR,op);
436: #endif
437:
438: if(roi2->roi_error.roe_id == old_id)
439: {
440: /* Ferret error away for later */
441: result_roi = roi2;
442: }
443: else if(roi2->roi_error.roe_id == (old_id + 1))
444: {
445: if (roi2->roi_error.roe_error != DSE_ABANDON_FAILED)
446: {
447: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Failed to abandon correctly"));
448: return(dapreject (di, DP_INVOKE, roi2->roi_error.roe_id, NULLCP, "Error mistyped for abandon"));
449: }
450: else
451: {
452: if(decode_DAS_AbandonFailedParm (roi2->roi_error.roe_param, 1, NULLIP, NULLVP, &(ab_err.dse_un.dse_un_abandon_fail)) != OK)
453: {
454: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Failed to decode abandonFailed"));
455: return(dapreject (di, DP_INVOKE, old_id, NULLCP, "Abandon error decoding failed"));
456: }
457: else
458: {
459: LLOG(log_dsap, LLOG_NOTICE, ("Abandon failed error!!!"));
460: ab_err.dse_type = DSE_ABANDON_FAILED;
461: log_ds_error(&ab_err);
462: ds_error_free(&ab_err);
463: }
464: }
465: }
466: else
467: {
468: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Abandon sent : event for neither op nor abandon op returned!!"));
469: return(dapreject (di, DP_INVOKE, roi1->roi_error.roe_id, NULLCP, "Unrecognised op id"));
470: }
471: break;
472:
473: default:
474: LLOG(log_dsap, LLOG_FATAL, ("Unexpected roi_type : %d", roi2->roi_type));
475: return(dapreject (di, DP_INVOKE, -1, NULLCP, "Unrecognised event"));
476: }
477: break;
478:
479: case NOTOK:
480: ros_log(rop2, "RO-WAIT.REQUEST (Abandon)");
481: if (ROS_FATAL (rop1->rop_reason))
482: {
483: return (ros2daplose (di, "DapInterrupt", rop2));
484: }
485: else
486: {
487: return (dapreject (di, DP_ROS, -1, NULLCP, "DapInterrupt: Non-fatal reject"));
488: }
489:
490: case DONE:
491: LLOG(log_dsap, LLOG_EXCEPTIONS, ("Responder has sent Finish!"));
492: return(daplose (di, DP_ROS, NULLCP, "Received Finish"));
493:
494: default:
495: LLOG(log_dsap, LLOG_FATAL, ("Unknown return from RoInvokeRequest : %d", ret2));
496: return(daplose (di, DP_ROS, NULLCP, "RoInvokeRequest error"));
497: }
498: }
499:
500: switch(result_roi->roi_type)
501: {
502: case ROI_RESULT:
503: return (DapDecodeResult (sd, &(result_roi->roi_result), di));
504:
505: case ROI_ERROR:
506: return (DapDecodeError (sd, &(result_roi->roi_error), di));
507:
508: default:
509: return (dapreject (di, DP_ROS, old_id, NULLCP, "DapInterrupt erroneous"));
510: }
511: }
512:
513: #ifdef PDU_DUMP
514:
515: static int pdu_count = -1;
516: static char * pdu_dir = NULLCP;
517:
518: pdu_dump_init (dir)
519: char * dir;
520: {
521: pdu_count = 0;
522: pdu_dir = strdup (dir);
523: LLOG (log_dsap, LLOG_NOTICE, ("PDU Tracing enabled - %s",dir));
524:
525: (void) mkdir (pdu_dir,0755);
526: }
527:
528: pdu_dump (pe,type,op)
529: PE pe;
530: char * type;
531: int op;
532: {
533: char filename [BUFSIZE];
534: char * oper;
535: PS ps;
536: FILE * fptr;
537:
538: if ( pdu_count == -1)
539: return;
540:
541: if (strcmp (type,DUMP_ARG) == 0)
542: pdu_count++;
543:
544: switch (op) {
545: case OP_READ:
546: oper = "read";
547: break;
548: case OP_COMPARE:
549: oper = "compare";
550: break;
551: case OP_ABANDON: /* Humm ... */
552: oper = "abandon";
553: break;
554: case OP_LIST:
555: oper = "list";
556: break;
557: case OP_SEARCH:
558: oper = "search";
559: break;
560: case OP_ADDENTRY:
561: oper = "add";
562: break;
563: case OP_REMOVEENTRY:
564: oper = "remove";
565: break;
566: case OP_MODIFYENTRY:
567: oper = "modify";
568: break;
569: case OP_MODIFYRDN:
570: oper = "modifyrdn";
571: break;
572: case OP_GETEDB:
573: oper = "getedb";
574: break;
575: case 100: /* special case for bind */
576: oper = "bind";
577: break;
578: }
579:
580: (void) sprintf (filename, "%s/%s_%s.%d",pdu_dir,oper,type,pdu_count);
581: DLOG (log_dsap,LLOG_DEBUG,("Writing PDU to file %s",filename));
582:
583: if ((fptr = fopen (filename,"w")) == (FILE *) NULL) {
584: LLOG(log_dsap,LLOG_EXCEPTIONS,("Cant open PDU file %s",filename));
585: return;
586: }
587:
588: ps = ps_alloc (std_open);
589: if (std_setup (ps,fptr) != OK) {
590: (void) fclose (fptr);
591: return;
592: }
593:
594: (void) pe2pl (ps,pe);
595:
596: (void) fclose (fptr);
597: ps_free (ps);
598:
599: }
600: #endif
601:
602: #ifdef HEAVY_DEBUG
603: pdu_arg_log (pe,op)
604: PE pe;
605: int op;
606: {
607: /* PDU Level Logging */
608: switch (op) {
609: case OP_READ:
610: PLOG (log_dsap, print_DAS_ReadArgument, pe, "Read", 0);
611: break;
612: case OP_COMPARE:
613: PLOG (log_dsap, print_DAS_CompareArgument, pe, "Compare", 0);
614: break;
615: case OP_ABANDON:
616: PLOG (log_dsap, print_DAS_AbandonArgument, pe, "Abandon", 0);
617: break;
618: case OP_LIST:
619: PLOG (log_dsap, print_DAS_ListArgument, pe, "List", 0);
620: break;
621: case OP_SEARCH:
622: PLOG (log_dsap, print_DAS_SearchArgument, pe, "Search", 0);
623: break;
624: case OP_ADDENTRY:
625: PLOG (log_dsap, print_DAS_AddEntryArgument, pe, "AddEntry", 0);
626: break;
627: case OP_REMOVEENTRY:
628: PLOG (log_dsap, print_DAS_RemoveEntryArgument, pe, "RemoveEntry", 0);
629: break;
630: case OP_MODIFYENTRY:
631: PLOG (log_dsap, print_DAS_ModifyEntryArgument, pe, "ModifyEntry", 0);
632: break;
633: case OP_MODIFYRDN:
634: PLOG (log_dsap, print_DAS_ModifyRDNArgument, pe, "ModifyRDN", 0);
635: break;
636: case OP_GETEDB:
637: PLOG (log_dsap, print_Quipu_GetEntryDataBlockArgument, pe, "GetEDB", 0);
638: break;
639: default:
640: LLOG (log_dsap, LLOG_PDUS, ("Unknown operation (%d) - no argument PDU logged",op));
641: }
642: }
643:
644: pdu_res_log (pe, op)
645: PE pe;
646: int op;
647: {
648: /* PDU Level Logging */
649: switch (op)
650: {
651: case OP_READ:
652: PLOG (log_dsap, print_DAS_ReadResult, pe, "Read", 1);
653: break;
654:
655: case OP_COMPARE:
656: PLOG (log_dsap, print_DAS_CompareResult, pe, "Compare", 1);
657: break;
658: case OP_ABANDON:
659: PLOG (log_dsap, print_DAS_AbandonResult, pe, "Abandon", 1);
660: break;
661: case OP_LIST:
662: PLOG (log_dsap, print_DAS_ListResult, pe, "List", 1);
663: break;
664: case OP_SEARCH:
665: PLOG (log_dsap, print_DAS_SearchResult, pe, "Search", 1);
666: break;
667: case OP_ADDENTRY:
668: PLOG (log_dsap, print_DAS_AddEntryResult, pe, "AddEntry", 1);
669: break;
670: case OP_REMOVEENTRY:
671: PLOG (log_dsap, print_DAS_RemoveEntryResult, pe, "RemoveEntry",1);
672: break;
673: case OP_MODIFYENTRY:
674: PLOG (log_dsap, print_DAS_ModifyEntryResult, pe, "ModifyEntry",1);
675: break;
676: case OP_MODIFYRDN:
677: PLOG (log_dsap, print_DAS_ModifyRDNResult, pe, "ModifyRDN", 1);
678: break;
679: case OP_GETEDB:
680: PLOG (log_dsap, print_Quipu_GetEntryDataBlockResult, pe, "GetEDB", 1);
681: break;
682: default:
683: LLOG (log_dsap, LLOG_PDUS, ("Unknown operation (%d) - no result PDU logged",op));
684: }
685: }
686: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.