![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ryinitiator.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 / lookup|
Return to ryinitiator.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / lookup |
1.1 root 1: /* ryinitiator.c - generic interactive initiator */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/others/lookup/RCS/ryinitiator.c,v 7.2 90/07/09 14:39:53 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/others/lookup/RCS/ryinitiator.c,v 7.2 90/07/09 14:39:53 mrose Exp $
9: *
10: *
11: * $Log: ryinitiator.c,v $
12: * Revision 7.2 90/07/09 14:39:53 mrose
13: * sync
14: *
15: * Revision 7.1 90/07/01 21:04:28 mrose
16: * pepsy
17: *
18: * Revision 7.0 89/11/23 22:56:41 mrose
19: * Release 6.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: #include <stdio.h>
35: #include <varargs.h>
36: #include "PasswordLookup-types.h"
37: #include "ryinitiator.h"
38:
39: /* DATA */
40:
41: static char *myname = "ryinitiator";
42:
43:
44: extern char *isodeversion;
45:
46: /* INITIATOR */
47:
48: ryinitiator (argc, argv, myservice, mycontext, mypci, ops, dispatches, quit)
49: int argc;
50: char **argv,
51: *myservice,
52: *mycontext,
53: *mypci;
54: struct RyOperation ops[];
55: struct dispatch *dispatches;
56: IFP quit;
57: {
58: int iloop,
59: sd;
60: char buffer[BUFSIZ],
61: *vec[NVEC + 1];
62: register struct dispatch *ds;
63: struct SSAPref sfs;
64: register struct SSAPref *sf;
65: register struct PSAPaddr *pa;
66: struct AcSAPconnect accs;
67: register struct AcSAPconnect *acc = &accs;
68: struct AcSAPindication acis;
69: register struct AcSAPindication *aci = &acis;
70: register struct AcSAPabort *aca = &aci -> aci_abort;
71: AEI aei;
72: OID ctx,
73: pci;
74: struct PSAPctxlist pcs;
75: register struct PSAPctxlist *pc = &pcs;
76: struct RoSAPindication rois;
77: register struct RoSAPindication *roi = &rois;
78: register struct RoSAPpreject *rop = &roi -> roi_preject;
79:
80: if (myname = rindex (argv[0], '/'))
81: myname++;
82: if (myname == NULL || *myname == NULL)
83: myname = argv[0];
84:
85: if (argc < 2)
86: adios (NULLCP, "usage: %s host [operation [ arguments ... ]]", myname);
87:
88: if ((aei = _str2aei (argv[1], myservice, mycontext, 0)) == NULLAEI)
89: adios (NULLCP, "unable to resolve service: %s", PY_pepy);
90: if ((pa = aei2addr (aei)) == NULLPA)
91: adios (NULLCP, "address translation failed");
92:
93: if ((ctx = ode2oid (mycontext)) == NULLOID)
94: adios (NULLCP, "%s: unknown object descriptor", mycontext);
95: if ((ctx = oid_cpy (ctx)) == NULLOID)
96: adios (NULLCP, "out of memory");
97: if ((pci = ode2oid (mypci)) == NULLOID)
98: adios (NULLCP, "%s: unknown object descriptor", mypci);
99: if ((pci = oid_cpy (pci)) == NULLOID)
100: adios (NULLCP, "out of memory");
101: pc -> pc_nctx = 1;
102: pc -> pc_ctx[0].pc_id = 1;
103: pc -> pc_ctx[0].pc_asn = pci;
104: pc -> pc_ctx[0].pc_atn = NULLOID;
105:
106: if ((sf = addr2ref (PLocalHostName ())) == NULL) {
107: sf = &sfs;
108: (void) bzero ((char *) sf, sizeof *sf);
109: }
110:
111: if (argc < 3) {
112: printf ("%s", myname);
113: if (sf -> sr_ulen > 2)
114: printf (" running on host %s", sf -> sr_udata + 2);
115: if (sf -> sr_clen > 2)
116: printf (" at %s", sf -> sr_cdata + 2);
117: printf (" [%s, ", oid2ode (ctx));
118: printf ("%s]\n", oid2ode (pci));
119: printf ("using %s\n", isodeversion);
120:
121: printf ("%s... ", argv[1]);
122: (void) fflush (stdout);
123:
124: iloop = 1;
125: }
126: else {
127: for (ds = dispatches; ds -> ds_name; ds++)
128: if (strcmp (ds -> ds_name, argv[2]) == 0)
129: break;
130: if (ds -> ds_name == NULL)
131: adios (NULLCP, "unknown operation \"%s\"", argv[2]);
132:
133: iloop = 0;
134: }
135:
136: if (AcAssocRequest (ctx, NULLAEI, aei, NULLPA, pa, pc, NULLOID,
137: 0, ROS_MYREQUIRE, SERIAL_NONE, 0, sf, NULLPEP, 0, NULLQOS,
138: acc, aci)
139: == NOTOK)
140: acs_adios (aca, "A-ASSOCIATE.REQUEST");
141:
142: if (acc -> acc_result != ACS_ACCEPT) {
143: if (iloop)
144: printf ("failed\n");
145:
146: adios (NULLCP, "association rejected: [%s]",
147: AcErrString (acc -> acc_result));
148: }
149: if (iloop) {
150: printf ("connected\n");
151: (void) fflush (stdout);
152: }
153:
154: sd = acc -> acc_sd;
155: ACCFREE (acc);
156:
157: if (RoSetService (sd, RoPService, roi) == NOTOK)
158: ros_adios (rop, "set RO/PS fails");
159:
160: if (iloop) {
161: for (;;) {
162: if (getline (buffer) == NOTOK)
163: break;
164:
165: if (str2vec (buffer, vec) < 1)
166: continue;
167:
168: for (ds = dispatches; ds -> ds_name; ds++)
169: if (strcmp (ds -> ds_name, vec[0]) == 0)
170: break;
171: if (ds -> ds_name == NULL) {
172: advise (NULLCP, "unknown operation \"%s\"", vec[0]);
173: continue;
174: }
175:
176: invoke (sd, ops, ds, vec + 1);
177: }
178: }
179: else
180: invoke (sd, ops, ds, argv + 3);
181:
182: (*quit) (sd, (struct dispatch *) NULL, (char **) NULL, (caddr_t *) NULL);
183: }
184:
185: /* */
186:
187: static invoke (sd, ops, ds, args)
188: int sd;
189: struct RyOperation ops[];
190: register struct dispatch *ds;
191: char **args;
192: {
193: int result;
194: caddr_t in;
195: struct RoSAPindication rois;
196: register struct RoSAPindication *roi = &rois;
197: register struct RoSAPpreject *rop = &roi -> roi_preject;
198:
199: in = NULL;
200: if (ds -> ds_argument && (*ds -> ds_argument) (sd, ds, args, &in) == NOTOK)
201: return;
202:
203: switch (result = RyStub (sd, ops, ds -> ds_operation, RyGenID (sd), NULLIP,
204: in, ds -> ds_result, ds -> ds_error, ROS_SYNC,
205: roi)) {
206: case NOTOK: /* failure */
207: if (ROS_FATAL (rop -> rop_reason))
208: ros_adios (rop, "STUB");
209: ros_advise (rop, "STUB");
210: break;
211:
212: case OK: /* got a result/error response */
213: break;
214:
215: case DONE: /* got RO-END? */
216: adios (NULLCP, "got RO-END.INDICATION");
217: /* NOTREACHED */
218:
219: default:
220: adios (NULLCP, "unknown return from RyStub=%d", result);
221: /* NOTREACHED */
222: }
223:
224: if (ds -> ds_mod && ds -> ds_ind >= 0 && in)
225: (void)fre_obj(in, ds->ds_mod->md_dtab[ds->ds_ind], ds->ds_mod);
226: }
227:
228: /* */
229:
230: static int getline (buffer)
231: char *buffer;
232: {
233: register int i;
234: register char *cp,
235: *ep;
236: static int sticky = 0;
237:
238: if (sticky) {
239: sticky = 0;
240: return NOTOK;
241: }
242:
243: printf ("%s> ", myname);
244: (void) fflush (stdout);
245:
246: for (ep = (cp = buffer) + BUFSIZ - 1; (i = getchar ()) != '\n';) {
247: if (i == EOF) {
248: printf ("\n");
249: clearerr (stdin);
250: if (cp != buffer) {
251: sticky++;
252: break;
253: }
254:
255: return NOTOK;
256: }
257:
258: if (cp < ep)
259: *cp++ = i;
260: }
261: *cp = NULL;
262:
263: return OK;
264: }
265:
266: /* */
267:
268: void ros_adios (rop, event)
269: register struct RoSAPpreject *rop;
270: char *event;
271: {
272: ros_advise (rop, event);
273:
274: _exit (1);
275: }
276:
277:
278: void ros_advise (rop, event)
279: register struct RoSAPpreject *rop;
280: char *event;
281: {
282: char buffer[BUFSIZ];
283:
284: if (rop -> rop_cc > 0)
285: (void) sprintf (buffer, "[%s] %*.*s", RoErrString (rop -> rop_reason),
286: rop -> rop_cc, rop -> rop_cc, rop -> rop_data);
287: else
288: (void) sprintf (buffer, "[%s]", RoErrString (rop -> rop_reason));
289:
290: advise (NULLCP, "%s: %s", event, buffer);
291: }
292:
293: /* */
294:
295: void acs_adios (aca, event)
296: register struct AcSAPabort *aca;
297: char *event;
298: {
299: acs_advise (aca, event);
300:
301: _exit (1);
302: }
303:
304:
305: void acs_advise (aca, event)
306: register struct AcSAPabort *aca;
307: char *event;
308: {
309: char buffer[BUFSIZ];
310:
311: if (aca -> aca_cc > 0)
312: (void) sprintf (buffer, "[%s] %*.*s",
313: AcErrString (aca -> aca_reason),
314: aca -> aca_cc, aca -> aca_cc, aca -> aca_data);
315: else
316: (void) sprintf (buffer, "[%s]", AcErrString (aca -> aca_reason));
317:
318: advise (NULLCP, "%s: %s (source %d)", event, buffer,
319: aca -> aca_source);
320: }
321:
322: /* */
323:
324: #ifndef lint
325: void _advise ();
326:
327:
328: void adios (va_alist)
329: va_dcl
330: {
331: va_list ap;
332:
333: va_start (ap);
334:
335: _advise (ap);
336:
337: va_end (ap);
338:
339: _exit (1);
340: }
341: #else
342: /* VARARGS */
343:
344: void adios (what, fmt)
345: char *what,
346: *fmt;
347: {
348: adios (what, fmt);
349: }
350: #endif
351:
352:
353: #ifndef lint
354: void advise (va_alist)
355: va_dcl
356: {
357: va_list ap;
358:
359: va_start (ap);
360:
361: _advise (ap);
362:
363: va_end (ap);
364: }
365:
366:
367: static void _advise (ap)
368: va_list ap;
369: {
370: char buffer[BUFSIZ];
371:
372: asprintf (buffer, ap);
373:
374: (void) fflush (stdout);
375:
376: fprintf (stderr, "%s: ", myname);
377: (void) fputs (buffer, stderr);
378: (void) fputc ('\n', stderr);
379:
380: (void) fflush (stderr);
381: }
382: #else
383: /* VARARGS */
384:
385: void advise (what, fmt)
386: char *what,
387: *fmt;
388: {
389: advise (what, fmt);
390: }
391: #endif
392:
393:
394: #ifndef lint
395: void ryr_advise (va_alist)
396: va_dcl
397: {
398: va_list ap;
399:
400: va_start (ap);
401:
402: _advise (ap);
403:
404: va_end (ap);
405: }
406: #else
407: /* VARARGS */
408:
409: void ryr_advise (what, fmt)
410: char *what,
411: *fmt;
412: {
413: ryr_advise (what, fmt);
414: }
415: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.