![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ro2ss.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 / rosap|
Return to ro2ss.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / rosap |
1.1 root 1: /* ro2ss.c - ROPM: SSAP interface */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/rosap/RCS/ro2ss.c,v 7.1 90/07/01 21:05:48 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/rosap/RCS/ro2ss.c,v 7.1 90/07/01 21:05:48 mrose Exp $
9: *
10: * Based on an TCP-based implementation by George Michaelson of University
11: * College London.
12: *
13: *
14: * $Log: ro2ss.c,v $
15: * Revision 7.1 90/07/01 21:05:48 mrose
16: * pepsy
17: *
18: * Revision 6.0 89/03/18 23:42:14 mrose
19: * Release 5.0
20: *
21: */
22:
23: /*
24: * NOTICE
25: *
26: * Acquisition, use, and distribution of this module and related
27: * materials are subject to the restrictions of a license agreement.
28: * Consult the Preface in the User's Manual for the full terms of
29: * this agreement.
30: *
31: */
32:
33:
34: /* LINTLIBRARY */
35:
36: #include <stdio.h>
37: #include "ROS-types.h"
38: #include "../acsap/OACS-types.h"
39: #include "ropkt.h"
40: #include "tailor.h"
41:
42: /* DATA */
43:
44: #define doSSabort ss2rosabort
45:
46:
47: int ssDATAser (), ssTOKENser (), ssSYNCser (), ssACTIVITYser (),
48: ssREPORTser (), ssFINISHser (), ssABORTser ();
49:
50: /* bind underlying service */
51:
52: int RoSService (acb, roi)
53: register struct assocblk *acb;
54: struct RoSAPindication *roi;
55: {
56: if (acb -> acb_flags & (ACB_ACS | ACB_RTS))
57: return rosaplose (roi, ROS_OPERATION, NULLCP,
58: "not an association descriptor for ROS on session");
59:
60: acb -> acb_putosdu = ro2sswrite;
61: acb -> acb_rowaitrequest = ro2sswait;
62: acb -> acb_getosdu = qbuf2pe;
63: acb -> acb_ready = ro2ssready;
64: acb -> acb_rosetindications = ro2ssasync;
65: acb -> acb_roselectmask = ro2ssmask;
66: acb -> acb_ropktlose = ro2sslose;
67:
68: return OK;
69: }
70:
71: /* define vectors for INDICATION events */
72:
73: #define e(i) (indication ? (i) : NULLIFP)
74:
75:
76: /* ARGSUSED */
77:
78: int ro2ssasync (acb, indication, roi)
79: register struct assocblk *acb;
80: IFP indication;
81: struct RoSAPindication *roi;
82: {
83: struct SSAPindication sis;
84: register struct SSAPabort *sa = &sis.si_abort;
85:
86: if (SSetIndications (acb -> acb_fd, e (ssDATAser), e (ssTOKENser),
87: e (ssSYNCser), e (ssACTIVITYser), e (ssREPORTser),
88: e (ssFINISHser), e (ssABORTser), &sis) == NOTOK)
89: switch (sa -> sa_reason) {
90: case SC_WAITING:
91: return rosaplose (roi, ROS_WAITING, NULLCP, NULLCP);
92:
93: default:
94: (void) ss2roslose (acb, roi, "SSetIndications", sa);
95: freeacblk (acb);
96: return NOTOK;
97: }
98:
99: if (acb -> acb_rosindication = indication)
100: acb -> acb_flags |= ACB_ASYN;
101: else
102: acb -> acb_flags &= ~ACB_ASYN;
103:
104: return OK;
105: }
106:
107: #undef e
108:
109: /* map association descriptors for select() */
110:
111: /* ARGSUSED */
112:
113: int ro2ssmask (acb, mask, nfds, roi)
114: register struct assocblk *acb;
115: fd_set *mask;
116: int *nfds;
117: struct RoSAPindication *roi;
118: {
119: struct SSAPindication sis;
120: register struct SSAPabort *sa = &sis.si_abort;
121:
122: if (SSelectMask (acb -> acb_fd, mask, nfds, &sis) == NOTOK)
123: switch (sa -> sa_reason) {
124: case SC_WAITING:
125: return rosaplose (roi, ROS_WAITING, NULLCP, NULLCP);
126:
127: default:
128: (void) ss2roslose (acb, roi, "SSelectMask", sa);
129: freeacblk (acb);
130: return NOTOK;
131: }
132:
133: return OK;
134: }
135:
136: /* protocol-level abort */
137:
138: int ro2sslose (acb, result)
139: register struct assocblk *acb;
140: int result;
141: {
142: int len;
143: char *base;
144: PE pe;
145: struct SSAPindication sis;
146:
147: base = NULL, len = 0;
148: /* begin AbortInformation PSDU (pseudo) */
149: if (pe = pe_alloc (PE_CLASS_UNIV, PE_FORM_CONS, PE_CONS_SET)) {
150: if (set_add (pe, num2prim (result, PE_CLASS_CONT, 0)) != NOTOK)
151: (void) pe2ssdu (pe, &base, &len);
152:
153: PLOGP (rosap_log,OACS_AbortInformation, pe, "AbortInformation",
154: 0);
155:
156: pe_free (pe);
157: }
158: /* end AbortInformation PSDU */
159:
160: (void) SUAbortRequest (acb -> acb_fd, base, len, &sis);
161: acb -> acb_fd = NOTOK;
162:
163: if (base)
164: free (base);
165: }
166:
167: /* SSAP interface */
168:
169: int ro2sswait (acb, invokeID, secs, roi)
170: register struct assocblk *acb;
171: int *invokeID,
172: secs;
173: register struct RoSAPindication *roi;
174: {
175: int result;
176: struct SSAPdata sxs;
177: register struct SSAPdata *sx = &sxs;
178: struct SSAPindication sis;
179: register struct SSAPindication *si = &sis;
180:
181: if (acb -> acb_apdu) {
182: result = acb2osdu (acb, NULLIP, acb -> acb_apdu, roi);
183: acb -> acb_apdu = NULLPE;
184:
185: return result;
186: }
187:
188: for (;;) {
189: switch (result = SReadRequest (acb -> acb_fd, sx, secs, si)) {
190: case NOTOK:
191: return doSSabort (acb, &si -> si_abort, roi);
192:
193: case OK:
194: if ((result = doSSdata (acb, invokeID, sx, roi)) != OK)
195: return (result != DONE ? result : OK);
196: continue;
197:
198: case DONE:
199: switch (si -> si_type) {
200: case SI_TOKEN:
201: if (doSStokens (acb, &si -> si_token, roi) == NOTOK)
202: return NOTOK;
203: continue;
204:
205: case SI_SYNC:
206: if (doSSsync (acb, &si -> si_sync, roi) == NOTOK)
207: return NOTOK;
208: continue;
209:
210: case SI_ACTIVITY:
211: if (doSSactivity (acb, &si -> si_activity, roi) == NOTOK)
212: return NOTOK;
213: continue;
214:
215: case SI_REPORT:
216: if (doSSreport (acb, &si -> si_report, roi) == NOTOK)
217: return NOTOK;
218: continue;
219:
220: case SI_FINISH:
221: if (doSSfinish (acb, &si -> si_finish, roi) == NOTOK)
222: return NOTOK;
223: return DONE;
224:
225: default:
226: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
227: "unknown indication (0x%x) from session",
228: si -> si_type);
229: break;
230: }
231: break;
232:
233: default:
234: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
235: "unexpected return from SReadRequest=%d", result);
236: break;
237: }
238: break;
239: }
240:
241: freeacblk (acb);
242:
243: return NOTOK;
244: }
245:
246: /* */
247:
248: /* ARGSUSED */
249:
250: int ro2ssready (acb, priority, roi)
251: register struct assocblk *acb;
252: int priority;
253: struct RoSAPindication *roi;
254: {
255: int result;
256: PE pe;
257: struct SSAPdata sxs;
258: register struct SSAPdata *sx = &sxs;
259: struct SSAPindication sis;
260: struct SSAPindication *si = &sis;
261: struct SSAPabort *sa = &si -> si_abort;
262:
263: if (acb -> acb_apdu || (acb -> acb_flags & ACB_CLOSING))
264: return rosaplose (roi, ROS_WAITING, NULLCP, NULLCP);
265:
266: if (!(acb -> acb_requirements & SR_HALFDUPLEX)
267: || (acb -> acb_flags & ACB_TURN))
268: return OK;
269:
270: if (!(acb -> acb_flags & ACB_PLEASE)) {
271: if (SPTokenRequest (acb -> acb_fd, ST_DAT_TOKEN, NULLCP, 0, si)
272: == NOTOK) {
273: (void) ss2roslose (acb, roi, "SPTokenRequest", sa);
274: goto out;
275: }
276:
277: acb -> acb_flags |= ACB_PLEASE;
278: }
279:
280: for (;;) {
281: switch (result = SReadRequest (acb -> acb_fd, sx, NOTOK, si)) {
282: case NOTOK:
283: return doSSabort (acb, &si -> si_abort, roi);
284:
285: case OK:
286: if (sx -> sx_type != SX_NORMAL) {
287: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
288: "unexpected data indication (0x%x)",
289: sx -> sx_type);
290: goto bad_sx;
291: }
292: if (pe = qbuf2pe (&sx -> sx_qbuf, sx -> sx_cc, &result)) {
293: acb -> acb_apdu = pe;
294: return rosaplose (roi, ROS_WAITING, NULLCP, NULLCP);
295: }
296: if (result != PS_ERR_NMEM) {
297: (void) rosapreject (acb, roi, ROS_GP_STRUCT, NULLCP, "%s",
298: ps_error (result));
299: continue;
300: }
301:
302: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP, "%s",
303: ps_error (result));
304: bad_sx: ;
305: SXFREE (sx);
306: goto out;
307:
308: case DONE:
309: switch (si -> si_type) {
310: case SI_TOKEN:
311: if (doSStokens (acb, &si -> si_token, roi) == NOTOK)
312: return NOTOK;
313: return OK;
314:
315: case SI_SYNC:
316: if (doSSsync (acb, &si -> si_sync, roi) == NOTOK)
317: return NOTOK;
318: continue;
319:
320: case SI_ACTIVITY:
321: if (doSSactivity (acb, &si -> si_activity, roi) == NOTOK)
322: return NOTOK;
323: continue;
324:
325: case SI_REPORT:
326: if (doSSreport (acb, &si -> si_report, roi) == NOTOK)
327: return NOTOK;
328: continue;
329:
330: case SI_FINISH:
331: if (doSSfinish (acb, &si -> si_finish, roi) == NOTOK)
332: return NOTOK;
333: return DONE;
334:
335: default:
336: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
337: "unknown indication (0x%x) from session",
338: si -> si_type);
339: break;
340: }
341: break;
342:
343: default:
344: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
345: "unexpected return from SReadRequest=%d", result);
346: break;
347: }
348: break;
349: }
350:
351: out: ;
352: freeacblk (acb);
353:
354: return NOTOK;
355: }
356:
357: /* */
358:
359: /* ARGSUSED */
360:
361: int ro2sswrite (acb, pe, fe, priority, roi)
362: register struct assocblk *acb;
363: register PE pe;
364: PE fe;
365: int priority;
366: struct RoSAPindication *roi;
367: {
368: int result;
369: register struct udvec *vv;
370: struct udvec *uv;
371: struct SSAPindication sis;
372: register struct SSAPindication *si = &sis;
373: register struct SSAPabort *sa = &si -> si_abort;
374:
375: PLOGP (rosap_log,ROS_OPDU, pe, "OPDU", 0);
376:
377: uv = NULL;
378: if ((result = pe2uvec (pe, &uv)) == NOTOK)
379: (void) rosaplose (roi, ROS_CONGEST, NULLCP, "out of memory");
380: else
381: if ((result = SWriteRequest (acb -> acb_fd, 0, uv, si)) == NOTOK)
382: (void) ss2roslose (acb, roi, "SWriteRequest", sa);
383: else
384: result = OK;
385:
386: if (fe)
387: (void) pe_extract (pe, fe);
388: pe_free (pe);
389:
390: if (uv) {
391: for (vv = uv; vv -> uv_base; vv++)
392: if (!vv -> uv_inline)
393: free ((char *) vv -> uv_base);
394: free ((char *) uv);
395: }
396:
397: if (result == NOTOK)
398: freeacblk (acb);
399:
400: return result;
401: }
402:
403: /* */
404:
405: static int doSSdata (acb, invokeID, sx, roi)
406: register struct assocblk *acb;
407: int *invokeID;
408: register struct SSAPdata *sx;
409: struct RoSAPindication *roi;
410: {
411: int result;
412: register PE pe;
413:
414: if (sx -> sx_type != SX_NORMAL) {
415: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
416: "unexpected data indication (0x%x)", sx -> sx_type);
417: goto out;
418: }
419:
420: if (pe = (*acb -> acb_getosdu) (&sx -> sx_qbuf, sx -> sx_cc, &result))
421: return acb2osdu (acb, invokeID, pe, roi);
422:
423: if (result != PS_ERR_NMEM)
424: return rosapreject (acb, roi, ROS_GP_STRUCT, NULLCP, "%s",
425: ps_error (result));
426:
427: (void) ropktlose (acb, roi, ROS_CONGEST, NULLCP, "%s",
428: ps_error (result));
429:
430: out: ;
431: SXFREE (sx);
432:
433: freeacblk (acb);
434: return NOTOK;
435: }
436:
437: /* */
438:
439: static int doSStokens (acb, st, roi)
440: register struct assocblk *acb;
441: register struct SSAPtoken *st;
442: struct RoSAPindication *roi;
443: {
444: int result;
445: struct SSAPindication sis;
446: struct SSAPindication *si = &sis;
447: struct SSAPabort *sa = &si -> si_abort;
448:
449: switch (st -> st_type) {
450: case ST_CONTROL:
451: break;
452:
453: case ST_PLEASE:
454: if (!(acb -> acb_requirements & SR_HALFDUPLEX))
455: break;
456: if (!(acb -> acb_flags & ACB_TURN))
457: break; /* error - do not have turn */
458:
459: result = SGTokenRequest (acb -> acb_fd, ST_DAT_TOKEN, si);
460:
461: if (result == NOTOK) {
462: (void) ss2roslose (acb, roi, "SGTokenRequest", sa);
463: goto out;
464: }
465: acb -> acb_flags &= ~ACB_TURN;
466: STFREE (st);
467: return result;
468:
469: case ST_GIVE:
470: if (!(acb -> acb_requirements & SR_HALFDUPLEX))
471: break;
472: if (acb -> acb_flags & ACB_TURN)
473: break; /* error - have turn already */
474:
475: if (st -> st_tokens & ST_DAT_TOKEN) {
476: acb -> acb_flags |= ACB_TURN;
477: acb -> acb_flags &= ~ACB_PLEASE;
478: }
479: return result;
480:
481: default:
482: break;
483: }
484:
485: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
486: "unexpected token indication (0x%x)", st -> st_type);
487:
488: out: ;
489: STFREE (st);
490:
491: freeacblk (acb);
492: return NOTOK;
493: }
494:
495: /* */
496:
497: static int doSSsync (acb, sn, roi)
498: register struct assocblk *acb;
499: register struct SSAPsync *sn;
500: struct RoSAPindication *roi;
501: {
502: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
503: "unexpected sync indication (0x%x)", sn -> sn_type);
504:
505: SNFREE (sn);
506:
507: freeacblk (acb);
508: return NOTOK;
509: }
510:
511: /* */
512:
513: static int doSSactivity (acb, sv, roi)
514: register struct assocblk *acb;
515: register struct SSAPactivity *sv;
516: struct RoSAPindication *roi;
517: {
518: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
519: "unexpected activity indication (0x%x)", sv -> sv_type);
520:
521: SVFREE (sv);
522:
523: freeacblk (acb);
524: return NOTOK;
525: }
526:
527: /* */
528:
529: static int doSSreport (acb, sp, roi)
530: register struct assocblk *acb;
531: register struct SSAPreport *sp;
532: struct RoSAPindication *roi;
533: {
534: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
535: "unexpected exception report indication (0x%x)", sp -> sp_peer);
536:
537: SPFREE (sp);
538:
539: freeacblk (acb);
540: return NOTOK;
541: }
542:
543: /* */
544:
545: static int doSSfinish (acb, sf, roi)
546: register struct assocblk *acb;
547: struct SSAPfinish *sf;
548: struct RoSAPindication *roi;
549: {
550: SFFREE (sf);
551:
552: if (acb -> acb_flags & ACB_INIT) {
553: (void) ropktlose (acb, roi, ROS_PROTOCOL, NULLCP,
554: "association management botched");
555: freeacblk (acb);
556: return NOTOK;
557: }
558:
559: acb -> acb_flags |= ACB_FINN;
560: roi -> roi_type = ROI_END;
561: {
562: register struct RoSAPend *roe = &roi -> roi_end;
563:
564: bzero ((char *) roe, sizeof *roe);
565: }
566:
567: return DONE;
568: }
569:
570: /* */
571:
572: int ss2rosabort (acb, sa, roi)
573: register struct assocblk *acb;
574: register struct SSAPabort *sa;
575: struct RoSAPindication *roi;
576: {
577: int result;
578: register PE pe;
579: struct type_OACS_AbortInformation *pabort
580: = (struct type_OACS_AbortInformation *) 0;
581: int acsap_abort = -1;
582:
583: if (!sa -> sa_peer) {
584: if (sa -> sa_reason == SC_TIMER)
585: return rosaplose (roi, ROS_TIMER, NULLCP, NULLCP);
586:
587: (void) ss2roslose (acb, roi, NULLCP, sa);
588: goto out;
589: }
590:
591: if (sa -> sa_cc == 0) {
592: (void) rosaplose (roi, ROS_ABORTED, NULLCP, NULLCP);
593: goto out;
594: }
595:
596: if ((pe = ssdu2pe (sa -> sa_info, sa -> sa_cc, NULLCP, &result))
597: == NULLPE) {
598: (void) rosaplose (roi, ROS_PROTOCOL, NULLCP, NULLCP);
599: goto out;
600: }
601: result = parse_OACS_AbortInformation (pe, 1, NULLIP, NULLVP, NULLCP);
602:
603: #ifdef DEBUG
604: if (result != NOTOK && (rosap_log -> ll_events & LLOG_PDUS))
605: pvpdu (rosap_log, print_OACS_AbortInformation_P, pe,
606: "AbortInformation", 1);
607: #endif
608:
609: pe_free (pe);
610: if (result == NOTOK) {
611: (void) rosaplose (roi, ROS_PROTOCOL, "%s", PY_pepy);
612: goto out;
613: }
614: acsap_abort = pabort->member_OACS_6->parm;
615: switch (acsap_abort) {
616: case ABORT_LSP:
617: case ABORT_TMP:
618: result = ROS_REMOTE;
619: break;
620:
621: default:
622: result = ROS_PROTOCOL;
623: break;
624: }
625: (void) rosaplose (roi, result, NULLCP, NULLCP);
626:
627: out: ;
628: SAFREE (sa);
629: acb -> acb_fd = NOTOK;
630: freeacblk (acb);
631: if (pabort)
632: free_OACS_AbortInformation(pabort);
633:
634: return NOTOK;
635: }
636:
637: /* */
638:
639: static int ssDATAser (sd, sx)
640: int sd;
641: register struct SSAPdata *sx;
642: {
643: IFP handler;
644: register struct assocblk *acb;
645: struct RoSAPindication rois;
646: register struct RoSAPindication *roi = &rois;
647:
648: if ((acb = findacblk (sd)) == NULL)
649: return;
650: handler = acb -> acb_rosindication;
651:
652: if (doSSdata (acb, NULLIP, sx, roi) != OK)
653: (*handler) (sd, roi);
654: }
655:
656: /* */
657:
658: static int ssTOKENser (sd, st)
659: int sd;
660: register struct SSAPtoken *st;
661: {
662: IFP handler;
663: register struct assocblk *acb;
664: struct RoSAPindication rois;
665: register struct RoSAPindication *roi = &rois;
666:
667: if ((acb = findacblk (sd)) == NULL)
668: return;
669: handler = acb -> acb_rosindication;
670:
671: if (doSStokens (acb, st, roi) != OK)
672: (*handler) (sd, roi);
673: }
674:
675: /* */
676:
677: static int ssSYNCser (sd, sn)
678: int sd;
679: register struct SSAPsync *sn;
680: {
681: IFP handler;
682: register struct assocblk *acb;
683: struct RoSAPindication rois;
684: register struct RoSAPindication *roi = &rois;
685:
686: if ((acb = findacblk (sd)) == NULL)
687: return;
688: handler = acb -> acb_rosindication;
689:
690: if (doSSsync (acb, sn, roi) != OK)
691: (*handler) (sd, roi);
692: }
693:
694: /* */
695:
696: static int ssACTIVITYser (sd, sv)
697: int sd;
698: register struct SSAPactivity *sv;
699: {
700: IFP handler;
701: register struct assocblk *acb;
702: struct RoSAPindication rois;
703: register struct RoSAPindication *roi = &rois;
704:
705: if ((acb = findacblk (sd)) == NULL)
706: return;
707: handler = acb -> acb_rosindication;
708:
709: if (doSSactivity (acb, sv, roi) != OK)
710: (*handler) (sd, roi);
711: }
712:
713: /* */
714:
715: static int ssREPORTser (sd, sp)
716: int sd;
717: register struct SSAPreport *sp;
718: {
719: IFP handler;
720: register struct assocblk *acb;
721: struct RoSAPindication rois;
722: register struct RoSAPindication *roi = &rois;
723:
724: if ((acb = findacblk (sd)) == NULL)
725: return;
726: handler = acb -> acb_rosindication;
727:
728: if (doSSreport (acb, sp, roi) != OK)
729: (*handler) (sd, roi);
730: }
731:
732: /* */
733:
734: static int ssFINISHser (sd, sf)
735: int sd;
736: struct SSAPfinish *sf;
737: {
738: IFP handler;
739: register struct assocblk *acb;
740: struct RoSAPindication rois;
741: register struct RoSAPindication *roi = &rois;
742:
743: if ((acb = findacblk (sd)) == NULL)
744: return;
745: handler = acb -> acb_rosindication;
746:
747: (void) doSSfinish (acb, sf, roi);
748:
749: (*handler) (sd, roi);
750: }
751:
752: /* */
753:
754: static int ssABORTser (sd, sa)
755: int sd;
756: register struct SSAPabort *sa;
757: {
758: IFP handler;
759: register struct assocblk *acb;
760: struct RoSAPindication rois;
761: register struct RoSAPindication *roi = &rois;
762:
763: if ((acb = findacblk (sd)) == NULL)
764: return;
765: handler = acb -> acb_rosindication;
766:
767: (void) doSSabort (acb, sa, roi);
768:
769: (*handler) (sd, roi);
770: }
771:
772: /* */
773:
774: int ss2roslose (acb, roi, event, sa)
775: register struct assocblk *acb;
776: register struct RoSAPindication *roi;
777: char *event;
778: register struct SSAPabort *sa;
779: {
780: int reason;
781: char *cp,
782: buffer[BUFSIZ];
783:
784: if (event)
785: SLOG (rosap_log, LLOG_EXCEPTIONS, NULLCP,
786: (sa -> sa_cc > 0 ? "%s: %s [%*.*s]": "%s: %s", event,
787: SErrString (sa -> sa_reason), sa -> sa_cc, sa -> sa_cc,
788: sa -> sa_data));
789:
790: cp = "";
791: switch (sa -> sa_reason) {
792: case SC_SSAPID:
793: case SC_SSUSER:
794: case SC_ADDRESS:
795: reason = ROS_ADDRESS;
796: break;
797:
798: case SC_REFUSED:
799: reason = ROS_REFUSED;
800: break;
801:
802: case SC_CONGEST:
803: reason = ROS_CONGEST;
804: break;
805:
806: default:
807: (void) sprintf (cp = buffer, " (%s at session)",
808: SErrString (sa -> sa_reason));
809: case SC_TRANSPORT:
810: case SC_ABORT:
811: reason = ROS_SESSION;
812: break;
813: }
814:
815: if (sa -> sa_cc > 0)
816: return ropktlose (acb, roi, reason, NULLCP, "%*.*s%s",
817: sa -> sa_cc, sa -> sa_cc, sa -> sa_data, cp);
818: else
819: return ropktlose (acb, roi, reason, NULLCP, "%s", *cp ? cp + 1 : cp);
820: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.