![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aetdase.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 / acsap|
Return to aetdase.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / acsap |
1.1 root 1: /* aetdase.c - DASE-based DSE */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/acsap/RCS/aetdase.c,v 7.1 90/07/09 14:30:48 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/acsap/RCS/aetdase.c,v 7.1 90/07/09 14:30:48 mrose Exp $
9: *
10: *
11: * $Log: aetdase.c,v $
12: * Revision 7.1 90/07/09 14:30:48 mrose
13: * sync
14: *
15: * Revision 7.0 90/07/07 16:11:32 mrose
16: * *** empty log message ***
17: *
18: */
19:
20: /*
21: * NOTICE
22: *
23: * Acquisition, use, and distribution of this module and related
24: * materials are subject to the restrictions of a license agreement.
25: * Consult the Preface in the User's Manual for the full terms of
26: * this agreement.
27: *
28: */
29:
30:
31: /* LINTLIBRARY */
32:
33: #include <ctype.h>
34: #include <setjmp.h>
35: #include <signal.h>
36: #include <stdio.h>
37: #include "DASE-types.h"
38: #include "psap.h"
39: #include "tsap.h"
40: #include "dgram.h"
41: #include "tailor.h"
42:
43:
44: /* DATA */
45:
46: static int stayopen = 0;
47:
48: static struct TSAPconnect tcs;
49: static PS ps = NULLPS;
50:
51:
52: static int armed = 0;
53: static int interrupted;
54: static jmp_buf intrenv;
55:
56: SFD intrser ();
57:
58:
59: struct element_DASE_1 *read_el ();
60:
61: /* LOOKUP */
62:
63: /* ARGSUSED */
64:
65: PE name2value_dase (name, qualifier, context, ontty, real_name)
66: char *name,
67: *qualifier,
68: *context;
69: int ontty;
70: PE *real_name;
71: {
72: int done,
73: err,
74: nfds,
75: vecp;
76: fd_set ifds;
77: char *vec[NVEC + 1];
78: PE pe = NULLPE,
79: result = NULLPE;
80: SFP istat;
81: register struct type_DASE_Query__REQ *parm = NULL;
82:
83: *real_name = NULLPE;
84:
85: if (ontty) {
86: istat = signal (SIGINT, intrser);
87: interrupted = 0;
88: }
89:
90: if (ps == NULLPS && dase_init () == NOTOK) {
91: if (ontty)
92: (void) signal (SIGINT, istat);
93:
94: return NULLPE;
95: }
96: err = 0;
97:
98: if ((vecp = sstr2arg (name, NVEC, vec, ",")) == NOTOK) {
99: PY_advise (NULLCP, "invalid name");
100: goto out;
101: }
102:
103: if ((parm = (struct type_DASE_Query__REQ *) calloc (1, sizeof *parm))
104: == NULL) {
105: no_mem: ;
106: PY_advise (NULLCP, "name2value_dase: out of memory");
107: goto out;
108: }
109: {
110: register char **vp;
111: register struct element_DASE_0 *dl,
112: **dp;
113:
114: dp = &parm -> name;
115: for (vp = vec; vecp > 0; vp++, vecp--) {
116: if ((dl = (struct element_DASE_0 *) calloc (1, sizeof *dl))
117: == NULL)
118: goto no_mem;
119: *dp = dl;
120: dp = &dl -> next;
121:
122: if ((dl -> IA5String = str2qb (*vp, strlen (*vp), 1)) == NULL)
123: goto no_mem;
124: }
125: }
126: parm -> interactive = ontty ? 1 : 0;
127: if ((parm -> envlist = read_el ()) == NULL
128: || (parm -> context = str2qb (context, strlen (context), 1))
129: == NULL)
130: goto out;
131:
132: if (encode_DASE_Query__REQ (&pe, 1, NULL, NULLCP, parm) == NOTOK)
133: goto out;
134:
135: if ((err = pe2ps (ps, pe)) == NOTOK) {
136: PY_advise (NULLCP, "unable to write query [%s]",
137: ps_error (ps -> ps_errno));
138: goto out;
139: }
140: PLOGP (addr_log,DASE_Message, pe, "message", 0);
141:
142: FD_ZERO (&ifds);
143:
144: nfds = tcs.tc_sd + 1;
145: FD_SET (tcs.tc_sd, &ifds);
146:
147: for (done = 0; !done; ) {
148: fd_set rfds;
149: struct type_DASE_Provider__RSP *rsp = NULL;
150: PE in;
151:
152: if (!interrupted) {
153: rfds = ifds; /* struct copy */
154:
155: (void) xselect (nfds, &rfds, NULLFD, NULLFD, NOTOK);
156: }
157:
158: if (interrupted) {
159: PY_advise (NULLCP, "interrupted");
160: break;
161: }
162:
163: if (!FD_ISSET (tcs.tc_sd, &rfds))
164: continue;
165:
166: if ((in = ps2pe (ps)) == NULLPE) {
167: PY_advise (NULLCP, "unable to read response [%s]",
168: ps_error (ps -> ps_errno));
169: err++;
170: break;
171: }
172:
173: if (decode_DASE_Provider__RSP (in, 1, NULLIP, NULLVP, &rsp) == NOTOK) {
174: you_lose: ;
175: pe_free (in);
176: if (rsp)
177: free_DASE_Provider__RSP (rsp);
178: err++;
179: break;
180: }
181: PLOGP (addr_log,DASE_Message, in, "message", 1);
182:
183: switch (rsp -> offset) {
184: case type_DASE_Provider__RSP_callback:
185: if (!ontty) {
186: PY_advise (NULLCP, "unexpected callback from nameservice");
187: goto you_lose;
188: }
189: if (dase_callback (rsp -> un.callback) == NOTOK)
190: goto you_lose;
191: break;
192:
193: case type_DASE_Provider__RSP_answer:
194: {
195: register char *pp,
196: *ep;
197: register struct qbuf *p,
198: *q;
199: register struct type_DASE_Query__RSP *ans
200: = rsp -> un.answer;
201:
202: if ((q = ans -> friendly) && ontty) {
203: printf ("[ using ");
204: print_qb (q);
205: printf (" ]\n");
206: (void) fflush (stdout);
207: }
208: *real_name = ans -> name, ans -> name = NULLPE;
209: result = ans -> value, ans -> value = NULLPE;
210: ep = (pp = PY_pepy) + BUFSIZ - 1;
211: if (q = ans -> diagnostic)
212: for (p = q -> qb_forw;
213: p != q && pp < ep;
214: pp += p -> qb_len, p = p -> qb_forw)
215: bcopy (p -> qb_data, pp, p -> qb_len);
216: *pp = NULL;
217:
218: done = 1;
219: }
220: break;
221:
222: default:
223: PY_advise (NULLCP, "unexpected response from nameservice: %d",
224: rsp -> offset);
225: goto you_lose;
226: }
227:
228: pe_free (in);
229: free_DASE_Provider__RSP (rsp);
230: }
231:
232: out: ;
233: if (result == NULLPE)
234: SLOG (addr_log, LLOG_EXCEPTIONS, NULLCP, ("%s", PY_pepy));
235: if (parm)
236: free_DASE_Query__REQ (parm);
237: if (pe)
238: pe_free (pe);
239: if (ps && (err || !stayopen)) {
240: struct TSAPdisconnect tds;
241:
242: (void) TDiscRequest (tcs.tc_sd, NULLCP, 0, &tds);
243: ps_free (ps);
244: ps = NULLPS;
245: }
246:
247: if (ontty)
248: (void) signal (SIGINT, istat);
249:
250: return result;
251: }
252:
253: /* */
254:
255: static int dase_init () {
256: int i,
257: nfds;
258: fd_set ifds;
259: register struct TSAPaddr *tz;
260: register struct TSAPconnect *tc = &tcs;
261: struct TSAPdisconnect tds;
262: register struct TSAPdisconnect *td = &tds;
263:
264: if ((tz = str2taddr (ns_address)) == NULL) {
265: PY_advise (NULLCP, "unable to parse nameservice address \"%s\"",
266: ns_address);
267: out: ;
268: SLOG (addr_log, LLOG_EXCEPTIONS, NULLCP, ("%s", PY_pepy));
269: return NOTOK;
270: }
271:
272: if ((i = TAsynConnRequest (NULLTA, tz, 0, NULLCP, 0, NULLQOS, tc, td, 1))
273: == NOTOK) {
274: you_lose: ;
275: PY_advise (NULLCP, td -> td_cc > 0
276: ? "unable to connect to nameservice: [%s] %*.*s"
277: : "unable to connect to nameservice: [%s]",
278: TErrString (td -> td_reason),
279: td -> td_cc, td -> td_cc, td -> td_data);
280: goto out;
281: }
282:
283: FD_ZERO (&ifds);
284:
285: nfds = tc -> tc_sd + 1;
286: FD_SET (tc -> tc_sd, &ifds);
287:
288: while (i == CONNECTING_1 || i == CONNECTING_2) {
289: fd_set mask,
290: *rmask,
291: *wmask;
292:
293: if (!interrupted) {
294: mask = ifds; /* struct copy */
295: if (i == CONNECTING_2)
296: rmask = &mask, wmask = NULLFD;
297: else
298: rmask = NULLFD, wmask = &mask;
299:
300: (void) xselect (nfds, rmask, wmask, NULLFD, NOTOK);
301: }
302:
303: if (interrupted) {
304: PY_advise (NULLCP, "interrupted");
305: goto oops;
306: }
307:
308: if ((rmask && !FD_ISSET (tc -> tc_sd, rmask))
309: || (wmask && !FD_ISSET (tc -> tc_sd, wmask)))
310: continue;
311:
312: if ((i = TAsynRetryRequest (tc -> tc_sd, tc, td)) == NOTOK)
313: goto you_lose;
314: }
315:
316: if ((ps = ps_alloc (dg_open)) == NULLPS
317: || dg_setup (ps, tc -> tc_sd, MAXDGRAM, ts_read, ts_write)
318: == NOTOK) {
319: if (ps == NULLPS)
320: PY_advise (NULLCP, "ps_alloc: out of memory");
321: else {
322: PY_advise (NULLCP, "dg_setup: %s", ps_error (ps -> ps_errno));
323: ps_free (ps);
324: ps = NULL;
325: }
326:
327: oops: ;
328: (void) TDiscRequest (tcs.tc_sd, NULLCP, 0, td);
329: goto out;
330: }
331:
332: return OK;
333: }
334:
335: /* */
336:
337: static int dase_callback (arg)
338: register struct type_DASE_Callback__REQ *arg;
339: {
340: register int i,
341: j;
342: int result;
343: register struct element_DASE_3 *choice;
344: struct type_DASE_Callback__RSP *rsp = NULL;
345: register struct type_DASE_Callback__RSP **rp = &rsp;
346: PE pe = NULLPE;
347:
348: i = 0;
349: for (choice = arg -> choices; choice; choice = choice -> next)
350: i++;
351:
352: if (i > 10) {
353: printf ("%d imprecise matches for '", i);
354: print_qb (arg -> string);
355: printf ("', select fron them [y/n] ? ");
356: if (yesno () != OK)
357: goto send_rsp;
358: }
359: else {
360: printf ("Please select from the following %d match%s for '",
361: i, i != 1 ? "es" : "");
362: print_qb (arg -> string);
363: printf ("':\n");
364: }
365:
366: j = 1;
367: for (choice = arg -> choices; choice; choice = choice -> next) {
368: register struct type_DASE_Callback__RSP *yes;
369:
370: printf (" ");
371: print_qb (choice -> Pair -> friendly);
372: printf (" [y/n] ? ");
373:
374: switch (yesno ()) {
375: case DONE:
376: goto send_rsp;
377:
378: case NOTOK:
379: default:
380: break;
381:
382: case OK:
383: if ((yes = (struct type_DASE_Callback__RSP *)
384: calloc (1, sizeof *yes)) == NULL) {
385: PY_advise (NULLCP, "dase_callback: out of memory");
386: result = NOTOK;
387: goto out;
388: }
389: *rp = yes, rp = &yes -> next;
390:
391: yes -> IA5String = choice -> Pair -> complete;
392: choice -> Pair -> complete = NULL;
393: break;
394: }
395:
396: if ((j++ % 10) == 0 && choice -> next) {
397: printf ("Continue (%d more) [y/n] ? ", i - j + 1);
398: if (yesno () != OK)
399: break;
400: }
401: }
402:
403: send_rsp: ;
404: if ((result = encode_DASE_Callback__RSP (&pe, 1, NULL, NULLCP, rsp))
405: == NOTOK)
406: goto out;
407: if ((result = pe2ps (ps, pe)) == NOTOK)
408: PY_advise (NULLCP, "unable to write callback [%s]",
409: ps_error (ps -> ps_errno));
410: else {
411: PLOGP (addr_log,DASE_Message, pe, "message", 0);
412:
413: result = OK;
414: }
415:
416: out: ;
417: if (rsp)
418: free_DASE_Callback__RSP (rsp);
419: if (pe)
420: pe_free (pe);
421:
422: return result;
423: }
424:
425: /* */
426:
427: static int yesno () {
428: int x,
429: y,
430: result;
431: char buffer[BUFSIZ];
432:
433: if (interrupted) {
434: interrupted = 0;
435: return DONE;
436: }
437:
438: switch (setjmp (intrenv)) {
439: case OK:
440: armed++;
441: break;
442:
443: case NOTOK:
444: default:
445: printf ("\n");
446: armed = 0;
447: return DONE;
448: }
449:
450: again: ;
451: x = y = getc (stdin);
452: while (y != '\n' && y != EOF)
453: y = getc (stdin);
454:
455: switch (x) {
456: case 'y':
457: case '\n':
458: result = OK;
459: break;
460:
461: case 'n':
462: result = NOTOK;
463: break;
464:
465: case EOF:
466: result = DONE;
467: clearerr (stdin);
468: break;
469:
470: default:
471: printf ("Please type 'y' or 'n': ");
472: goto again;
473: }
474:
475: armed = 0;
476:
477: return result;
478: }
479:
480:
481: static print_qb (q)
482: struct qbuf *q;
483: {
484: register struct qbuf *p;
485:
486: for (p = q -> qb_forw; p != q; p = p -> qb_forw)
487: printf ("%*.*s", p -> qb_len, p -> qb_len, p -> qb_data);
488: }
489:
490: /* */
491:
492: static struct element_DASE_1 *read_el () {
493: register int i;
494: register char *bp,
495: *cp;
496: char buffer[BUFSIZ],
497: ufnrc[BUFSIZ];
498: FILE *fp;
499: struct element_DASE_1 *top;
500: register struct element_DASE_1 **etail;
501: register struct element_DASE_2 **dtail;
502:
503: if (bp = getenv ("UFNRC"))
504: (void) strcpy (ufnrc, bp);
505: else {
506: if ((bp = getenv ("HOME")) == NULL)
507: bp = ".";
508:
509: (void) sprintf (ufnrc, "%s/.ufnrc", bp);
510: }
511:
512: if ((fp = fopen (ufnrc, "r")) == NULL) {
513: (void) strcpy (ufnrc, isodefile ("ufnrc", 0));
514:
515: if ((fp = fopen (ufnrc, "r")) == NULL) {
516: PY_advise (ufnrc, "unable to read");
517: return NULL;
518: }
519: }
520:
521: top = NULL, etail = &top, dtail = NULL;
522:
523: for (i = 0; fgets (bp = buffer, sizeof buffer, fp); i++) {
524: register struct element_DASE_2 *dl;
525:
526: if (*buffer == '#')
527: continue;
528: if (bp = index (buffer, '\n'))
529: *bp = NULL;
530:
531: bp = buffer;
532: if (*bp == NULL) {
533: dtail = NULL;
534: continue;
535: }
536:
537: if (!isspace (*bp)) {
538: register char *dp;
539: register struct element_DASE_1 *el;
540: register struct type_DASE_Environment *fl;
541:
542: if ((el = (struct element_DASE_1 *) calloc (1, sizeof *el))
543: == NULL) {
544: no_mem: ;
545: PY_advise (NULLCP, "real_el: out of memory");
546:
547: out: ;
548: for (; top; top = el) {
549: el = top -> next;
550:
551: free_DASE_Environment (top -> Environment);
552: free ((char *) top);
553: }
554: SLOG (addr_log, LLOG_EXCEPTIONS, NULLCP, ("%s", PY_pepy));
555: (void) fclose (fp);
556: return NULL;
557: }
558: *etail = el;
559: etail = &el -> next;
560:
561: if ((fl = (struct type_DASE_Environment *) calloc (1, sizeof *fl))
562: == NULL)
563: goto no_mem;
564: el -> Environment = fl;
565: dtail = &fl -> path;
566:
567: if ((cp = index (bp, ':')) == NULL) {
568: PY_advise (NULLCP, "%s: missing ':' at line %d", ufnrc, i);
569: goto out;
570: }
571: *cp++ = NULL;
572:
573: if (dp = index (bp, ',')) {
574: *dp++ = NULL;
575:
576: while (isspace (*dp))
577: dp++;
578: fl -> upper = *dp == '+' ? 32767 : atoi (dp);
579: }
580: else
581: fl -> upper = 0;
582:
583: fl -> lower = atoi (bp);
584: if (fl -> upper == 0)
585: fl -> upper = fl -> lower;
586:
587: bp = cp;
588: }
589: else
590: if (!dtail) {
591: PY_advise (NULLCP, "%s: unexpected blank at start of line %d",
592: ufnrc, i);
593: goto out;
594: }
595:
596: if ((dl = (struct element_DASE_2 *) calloc (1, sizeof *dl)) == NULL)
597: goto no_mem;
598: *dtail = dl;
599: dtail = &dl -> next;
600:
601: while (isspace (*bp))
602: bp++;
603: if ((dl -> IA5String = str2qb (bp, strlen (bp), 1)) == NULL)
604: goto no_mem;
605: }
606:
607: (void) fclose (fp);
608:
609: return top;
610: }
611:
612: /* */
613:
614: /* ARGSUSED */
615:
616: static SFD intrser (sig)
617: int sig;
618: {
619: #ifndef BSDSIGS
620: (void) signal (SIGINT, intrser);
621: #endif
622:
623: if (armed)
624: longjmp (intrenv, NOTOK);
625:
626: interrupted++;
627: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.