![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ryresponder.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 / others / idist|
Return to ryresponder.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / idist |
1.1 root 1: /* ryresponder.c - generic idempotent responder */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/others/idist/RCS/ryresponder.c,v 7.1 90/07/09 14:39:27 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/others/idist/RCS/ryresponder.c,v 7.1 90/07/09 14:39:27 mrose Exp $
9: *
10: *
11: * $Log: ryresponder.c,v $
12: * Revision 7.1 90/07/09 14:39:27 mrose
13: * sync
14: *
15: * Revision 7.0 89/11/23 21:58:43 mrose
16: * Release 6.0
17: *
18: */
19:
20: #include <stdio.h>
21: #include <setjmp.h>
22: #include <varargs.h>
23: #include "ryresponder.h"
24: #include "tsap.h" /* for listening */
25: #include "Idist-ops.h"
26:
27: /* DATA */
28:
29: int debug = 0;
30:
31: static LLog _pgm_log = {
32: "responder.log", NULLCP, NULLCP,
33: LLOG_FATAL | LLOG_EXCEPTIONS | LLOG_NOTICE, LLOG_FATAL, -1,
34: LLOGCLS | LLOGCRT | LLOGZER, NOTOK
35: };
36: LLog *pgm_log = &_pgm_log;
37:
38: static char *myname = "ryresponder";
39:
40:
41: static jmp_buf toplevel;
42:
43:
44: static IFP startfnx;
45: static IFP stopfnx;
46:
47: int ros_init (), ros_work (), ros_indication (), ros_lose ();
48:
49:
50: extern int errno;
51:
52: /* RESPONDER */
53:
54: int ryresponder (argc, argv, host, myservice, dispatches, ops, start, stop)
55: int argc;
56: char **argv,
57: *host,
58: *myservice;
59: struct dispatch *dispatches;
60: struct RyOperation *ops;
61: IFP start,
62: stop;
63: {
64: struct RyOperation *op;
65: register struct dispatch *ds;
66: AEI aei;
67: struct TSAPdisconnect tds;
68: struct TSAPdisconnect *td = &tds;
69: struct RoSAPindication rois;
70: register struct RoSAPindication *roi = &rois;
71: register struct RoSAPpreject *rop = &roi -> roi_preject;
72:
73: if (myname = rindex (argv[0], '/'))
74: myname++;
75: if (myname == NULL || *myname == NULL)
76: myname = argv[0];
77:
78: isodetailor (myname, 0);
79:
80: if (debug = isatty (fileno (stderr)))
81: ll_dbinit (pgm_log, myname);
82: else {
83: static char myfile[BUFSIZ];
84:
85: (void) sprintf (myfile, "%s.log",
86: (strncmp (myname, "ros.", 4)
87: && strncmp (myname, "lpp.", 4))
88: || myname[4] == NULL
89: ? myname : myname + 4);
90: pgm_log -> ll_file = myfile;
91: ll_hdinit (pgm_log, myname);
92: }
93:
94: advise (LLOG_NOTICE, NULLCP, "starting");
95:
96: if ((aei = _str2aei (host, myservice, mycontext, 0)) == NULLAEI)
97: adios (NULLCP, "unable to resolve service: %s", PY_pepy);
98:
99: if (op = findopbyop (ops, operation_Idist_transfer))
100: op -> ryo_arg_free = NULLIFP;
101:
102: for (ds = dispatches; ds -> ds_name; ds++)
103: if (RyDispatch (NOTOK, ops, ds -> ds_operation, ds -> ds_vector, roi)
104: == NOTOK)
105: ros_adios (rop, ds -> ds_name);
106:
107: startfnx = start;
108: stopfnx = stop;
109:
110: if (isodeserver (argc, argv, aei, ros_init, ros_work, ros_lose, td)
111: == NOTOK) {
112: if (td -> td_cc > 0)
113: adios (NULLCP, "isodeserver: [%s] %*.*s",
114: TErrString (td -> td_reason),
115: td -> td_cc, td -> td_cc, td -> td_data);
116: else
117: adios (NULLCP, "isodeserver: [%s]",
118: TErrString (td -> td_reason));
119: }
120:
121: return 0;
122: }
123:
124: /* */
125:
126: static int ros_init (vecp, vec)
127: int vecp;
128: char **vec;
129: {
130: int reply,
131: result,
132: sd;
133: struct AcSAPstart acss;
134: register struct AcSAPstart *acs = &acss;
135: struct AcSAPindication acis;
136: register struct AcSAPindication *aci = &acis;
137: register struct AcSAPabort *aca = &aci -> aci_abort;
138: register struct PSAPstart *ps = &acs -> acs_start;
139: struct RoSAPindication rois;
140: register struct RoSAPindication *roi = &rois;
141: register struct RoSAPpreject *rop = &roi -> roi_preject;
142: PE pe[1];
143:
144: if (AcInit (vecp, vec, acs, aci) == NOTOK) {
145: acs_advise (aca, "initialization fails");
146: return NOTOK;
147: }
148: advise (LLOG_NOTICE, NULLCP,
149: "A-ASSOCIATE.INDICATION: <%d, %s, %s, %s, %d>",
150: acs -> acs_sd, oid2ode (acs -> acs_context),
151: sprintaei (&acs -> acs_callingtitle),
152: sprintaei (&acs -> acs_calledtitle), acs -> acs_ninfo);
153:
154: sd = acs -> acs_sd;
155:
156: for (vec++; *vec; vec++)
157: advise (LLOG_EXCEPTIONS, NULLCP, "unknown argument \"%s\"", *vec);
158:
159: reply = startfnx ? (*startfnx) (sd, acs, &pe[0]) : ACS_ACCEPT;
160:
161: result = AcAssocResponse (sd, reply,
162: reply != ACS_ACCEPT ? ACS_USER_NOREASON : ACS_USER_NULL,
163: NULLOID, NULLAEI, NULLPA, NULLPC, ps -> ps_defctxresult,
164: ps -> ps_prequirements, ps -> ps_srequirements, SERIAL_NONE,
165: ps -> ps_settings, &ps -> ps_connect, pe,
166: reply != ACS_ACCEPT ? 1 : 0, aci);
167:
168: ACSFREE (acs);
169:
170: if (result == NOTOK) {
171: acs_advise (aca, "A-ASSOCIATE.RESPONSE");
172: return NOTOK;
173: }
174: if (reply != ACS_ACCEPT)
175: return NOTOK;
176:
177: if (RoSetService (sd, RoPService, roi) == NOTOK)
178: ros_adios (rop, "set RO/PS fails");
179:
180: return sd;
181: }
182:
183: /* */
184:
185: static int ros_work (fd)
186: int fd;
187: {
188: int result;
189: caddr_t out;
190: struct AcSAPindication acis;
191: struct RoSAPindication rois;
192: register struct RoSAPindication *roi = &rois;
193: register struct RoSAPpreject *rop = &roi -> roi_preject;
194:
195: switch (setjmp (toplevel)) {
196: case OK:
197: break;
198:
199: default:
200: if (stopfnx)
201: (*stopfnx) (fd, (struct AcSAPfinish *) 0);
202: case DONE:
203: (void) AcUAbortRequest (fd, NULLPEP, 0, &acis);
204: (void) RyLose (fd, roi);
205: return NOTOK;
206: }
207:
208: switch (result = RyWait (fd, NULLIP, &out, OK, roi)) {
209: case NOTOK:
210: if (rop -> rop_reason == ROS_TIMER)
211: break;
212: case OK:
213: case DONE:
214: ros_indication (fd, roi);
215: break;
216:
217: default:
218: adios (NULLCP, "unknown return from RoWaitRequest=%d", result);
219: }
220:
221: return OK;
222: }
223:
224: /* */
225:
226: static int ros_indication (sd, roi)
227: int sd;
228: register struct RoSAPindication *roi;
229: {
230: int reply,
231: result;
232:
233: switch (roi -> roi_type) {
234: case ROI_INVOKE:
235: case ROI_RESULT:
236: case ROI_ERROR:
237: adios (NULLCP, "unexpected indication type=%d", roi -> roi_type);
238: break;
239:
240: case ROI_UREJECT:
241: {
242: register struct RoSAPureject *rou = &roi -> roi_ureject;
243:
244: if (rou -> rou_noid)
245: advise (LLOG_EXCEPTIONS, NULLCP, "RO-REJECT-U.INDICATION/%d: %s",
246: sd, RoErrString (rou -> rou_reason));
247: else
248: advise (LLOG_EXCEPTIONS, NULLCP,
249: "RO-REJECT-U.INDICATION/%d: %s (id=%d)",
250: sd, RoErrString (rou -> rou_reason),
251: rou -> rou_id);
252: }
253: break;
254:
255: case ROI_PREJECT:
256: {
257: register struct RoSAPpreject *rop = &roi -> roi_preject;
258:
259: if (ROS_FATAL (rop -> rop_reason))
260: ros_adios (rop, "RO-REJECT-P.INDICATION");
261: ros_advise (rop, "RO-REJECT-P.INDICATION");
262: }
263: break;
264:
265: case ROI_FINISH:
266: {
267: register struct AcSAPfinish *acf = &roi -> roi_finish;
268: struct AcSAPindication acis;
269: register struct AcSAPabort *aca = &acis.aci_abort;
270:
271: advise (LLOG_NOTICE, NULLCP, "A-RELEASE.INDICATION/%d: %d",
272: sd, acf -> acf_reason);
273:
274: reply = stopfnx ? (*stopfnx) (sd, acf) : ACS_ACCEPT;
275:
276: result = AcRelResponse (sd, reply, ACR_NORMAL, NULLPEP, 0,
277: &acis);
278:
279: ACFFREE (acf);
280:
281: if (result == NOTOK)
282: acs_advise (aca, "A-RELEASE.RESPONSE");
283: else
284: if (reply != ACS_ACCEPT)
285: break;
286: longjmp (toplevel, DONE);
287: }
288: /* NOTREACHED */
289:
290: default:
291: adios (NULLCP, "unknown indication type=%d", roi -> roi_type);
292: }
293: }
294:
295: /* */
296:
297: static int ros_lose (td)
298: struct TSAPdisconnect *td;
299: {
300: if (td -> td_cc > 0)
301: adios (NULLCP, "TNetAccept: [%s] %*.*s",
302: TErrString (td -> td_reason), td -> td_cc, td -> td_cc,
303: td -> td_data);
304: else
305: adios (NULLCP, "TNetAccept: [%s]", TErrString (td -> td_reason));
306: }
307:
308: /* ERRORS */
309:
310: void ros_adios (rop, event)
311: register struct RoSAPpreject *rop;
312: char *event;
313: {
314: ros_advise (rop, event);
315:
316: cleanup ();
317:
318: longjmp (toplevel, NOTOK);
319: }
320:
321:
322: void ros_advise (rop, event)
323: register struct RoSAPpreject *rop;
324: char *event;
325: {
326: char buffer[BUFSIZ];
327:
328: if (rop -> rop_cc > 0)
329: (void) sprintf (buffer, "[%s] %*.*s", RoErrString (rop -> rop_reason),
330: rop -> rop_cc, rop -> rop_cc, rop -> rop_data);
331: else
332: (void) sprintf (buffer, "[%s]", RoErrString (rop -> rop_reason));
333:
334: advise (LLOG_EXCEPTIONS, NULLCP, "%s: %s", event, buffer);
335: }
336:
337: /* */
338:
339: void acs_advise (aca, event)
340: register struct AcSAPabort *aca;
341: char *event;
342: {
343: char buffer[BUFSIZ];
344:
345: if (aca -> aca_cc > 0)
346: (void) sprintf (buffer, "[%s] %*.*s",
347: AcErrString (aca -> aca_reason),
348: aca -> aca_cc, aca -> aca_cc, aca -> aca_data);
349: else
350: (void) sprintf (buffer, "[%s]", AcErrString (aca -> aca_reason));
351:
352: advise (LLOG_EXCEPTIONS, NULLCP, "%s: %s (source %d)", event, buffer,
353: aca -> aca_source);
354: }
355:
356: /* */
357:
358: #ifndef lint
359:
360: void adios (va_alist)
361: va_dcl
362: {
363: char *what;
364: va_list ap;
365:
366: va_start (ap);
367:
368: _ll_log (pgm_log, LLOG_FATAL, ap);
369:
370: va_end (ap);
371:
372: cleanup ();
373:
374: _exit (1);
375: }
376: #else
377: /* VARARGS2 */
378:
379: void adios (what, fmt)
380: char *what,
381: *fmt;
382: {
383: adios (what, fmt);
384: }
385: #endif
386:
387:
388: #ifndef lint
389: void advise (va_alist)
390: va_dcl
391: {
392: int code;
393: va_list ap;
394:
395: va_start (ap);
396:
397: code = va_arg (ap, int);
398:
399: _ll_log (pgm_log, code, ap);
400:
401: va_end (ap);
402: }
403:
404: #else
405: /* VARARGS */
406:
407: void advise (code, what, fmt)
408: char *what,
409: *fmt;
410: int code;
411: {
412: advise (code, what, fmt);
413: }
414: #endif
415:
416:
417:
418: #ifndef lint
419: void ryr_advise (va_alist)
420: va_dcl
421: {
422: va_list ap;
423:
424: va_start (ap);
425:
426: _ll_log (pgm_log, LLOG_NOTICE, ap);
427:
428: va_end (ap);
429: }
430: #else
431: /* VARARGS2 */
432: void ryr_advise (what, fmt)
433: char *what,
434: *fmt;
435: {
436: ryr_advise (what, fmt);
437: }
438: #endif
439:
440: #ifdef lint
441: /* VARARGS1 */
442: note (fmt)
443: char *fmt;
444: {
445: note (fmt);
446: }
447:
448: #else
449: note (va_alist)
450: va_dcl
451: {
452: char buffer[BUFSIZ];
453: struct type_Idist_IA5List **ia5p;
454: va_list ap;
455:
456: va_start (ap);
457:
458: _asprintf (buffer, NULLCP, ap);
459:
460: addtoia5 (buffer, strlen (buffer));
461:
462: va_end (ap);
463: }
464: #endif
465:
466: #ifdef lint
467: /* VARARGS2 */
468: nadvise (what, fmt)
469: char *what, *fmt;
470: {
471: nadvise (what, fmt);
472: }
473: #else
474: nadvise (va_alist)
475: va_dcl
476: {
477: va_list ap;
478: char buf[BUFSIZ], *cp;
479: extern char *host;
480:
481: va_start (ap);
482:
483: (void) sprintf (buf, "%s (%s): ", myname, host);
484: cp = buf + strlen (buf);
485:
486: asprintf (cp, ap);
487:
488: addtoia5 (buf, strlen (buf));
489:
490: va_end (ap);
491: }
492: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.