![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftam.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 / ftam2|
Return to ftam.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam2 |
1.1 root 1: /* ftam.c - interactive FTAM initiator */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftam.c,v 7.1 90/07/09 14:37:18 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam2/RCS/ftam.c,v 7.1 90/07/09 14:37:18 mrose Exp $
9: *
10: *
11: * $Log: ftam.c,v $
12: * Revision 7.1 90/07/09 14:37:18 mrose
13: * sync
14: *
15: * Revision 7.0 89/11/23 21:54:27 mrose
16: * Release 6.0
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: #include <ctype.h>
32: #include <setjmp.h>
33: #include <signal.h>
34: #include <stdio.h>
35: #include <varargs.h>
36: #include "ftamuser.h"
37: #include "tailor.h"
38:
39: /* DATA */
40:
41: #ifndef BRIDGE
42: static char *myname = "ftam";
43:
44: static char **op = NULL;
45:
46: static char *aflag = NULL;
47: static char *oflag = NULL;
48: static int fflag = 0;
49: static char *hflag = NULL;
50: static char *uflag = NULL;
51:
52:
53: static char ringring = 0x07;
54:
55: int ontty;
56:
57: static int armed;
58: static jmp_buf intrenv;
59: #endif
60: int interrupted;
61:
62:
63: void adios (), advise ();
64: #ifndef BRIDGE
65: SFD intrser ();
66: #endif
67:
68: /* MAIN */
69:
70: /* ARGSUSED */
71:
72: #ifndef BRIDGE
73: main (argc, argv, envp)
74: int argc;
75: char **argv,
76: **envp;
77: {
78: int eof,
79: status,
80: vecp;
81: SFP istat;
82: char *bp,
83: buffer[BUFSIZ],
84: *vec[NVEC + 1];
85: FILE *fp;
86:
87: arginit (argv);
88:
89: runcom = 1;
90:
91: rcinit ();
92: (void) sprintf (buffer, "%s/.ftamrc", myhome);
93:
94: if (!fflag && (fp = fopen (buffer, "r"))) {
95: while (fgets (buffer, sizeof buffer, fp)) {
96: if (bp = index (buffer, '\n'))
97: *bp = NULL;
98:
99: bzero ((char *) vec, sizeof vec);
100: if ((vecp = str2vec (buffer, vec)) < 1)
101: continue;
102:
103: if (ftamloop (vec, NOTOK) != OK && op)
104: exit (1);
105: }
106:
107: (void) fclose (fp);
108: }
109:
110: if (hflag) {
111: vecp = 0;
112: vec[vecp++] = "open";
113: vec[vecp++] = hflag;
114: if (uflag)
115: vec[vecp++] = uflag;
116: if (aflag)
117: vec[vecp++] = aflag;
118: vec[vecp] = NULL;
119:
120: if (ftamloop (vec, NOTOK) != OK && op)
121: exit (1);
122: }
123: else {
124: if (uflag)
125: user = strdup (uflag);
126: if (aflag)
127: account = strdup (aflag);
128: }
129:
130: if (oflag) {
131: vecp = 0;
132: vec[vecp++] = "set";
133: vec[vecp++] = "override";
134: vec[vecp++] = oflag;
135: vec[vecp] = NULL;
136:
137: if (ftamloop (vec, NOTOK) != OK && op)
138: exit (1);
139: }
140:
141: runcom = 0;
142:
143: if (op) {
144: for (vecp = 0; *op; op++)
145: vec[vecp++] = *op;
146: vec[vecp] = NULL;
147:
148: status = ftamfd != NOTOK ? 1 : 0;
149: switch (ftamloop (vec, NOTOK)) {
150: case NOTOK:
151: status = 1;
152: break;
153:
154: case OK:
155: case DONE:
156: default:
157: if (ftamfd != NOTOK)
158: status = 0;
159: break;
160: }
161: }
162: else {
163: istat = signal (SIGINT, intrser);
164:
165: eof = 0;
166: for (interrupted = 0;; interrupted = 0) {
167: if (hash && marks >= BUFSIZ) {
168: marks = 0;
169: printf ("\n");
170: }
171:
172: if (getline ("%s> ", buffer) == NOTOK) {
173: if (eof)
174: break;
175:
176: eof = 1;
177: continue;
178: }
179: eof = 0;
180:
181: bzero ((char *) vec, sizeof vec);
182: if ((vecp = str2vec (buffer, vec)) < 1)
183: continue;
184:
185: switch (ftamloop (vec, OK)) {
186: case NOTOK:
187: status = 1;
188: break;
189:
190: case OK:
191: default:
192: if (bell)
193: (void) putchar (ringring);
194: continue;
195:
196: case DONE:
197: status = 0;
198: break;
199: }
200: break;
201: }
202:
203: (void) signal (SIGINT, istat);
204: }
205:
206: if (ftamfd != NOTOK) {
207: vecp = 0;
208: vec[vecp++] = "close";
209: vec[vecp] = NULL;
210:
211: (void) ftamloop (vec, NOTOK);
212: }
213:
214: exit (status); /* NOTREACHED */
215: }
216: #endif
217:
218: /* */
219:
220: #ifndef BRIDGE
221: static ftamloop (vec, error)
222: char **vec;
223: int error;
224: {
225: register struct dispatch *ds;
226:
227: if ((ds = getds (strcmp (*vec, "?") ? *vec : "help")) == NULL)
228: return error;
229:
230: if (ftamfd == NOTOK) {
231: if (ds -> ds_flags & DS_OPEN) {
232: advise (NULLCP, "not associated with virtual filestore");
233: return error;
234: }
235: }
236: else
237: if (ds -> ds_flags & DS_CLOSE) {
238: advise (NULLCP, "already associated with virtual filestore");
239: return error;
240: }
241:
242: if (ds -> ds_flags & DS_MODES) {
243: switch (ds -> ds_class) {
244: case FCLASS_TRANSFER:
245: if (class != FCLASS_TRANSFER && class != FCLASS_TM) {
246: advise (NULLCP, "need transfer service class");
247: return error;
248: }
249: break;
250:
251: case FCLASS_MANAGE:
252: if (class != FCLASS_MANAGE && class != FCLASS_TM) {
253: advise (NULLCP, "need management service class");
254: return error;
255: }
256: break;
257:
258: default:
259: break;
260: }
261:
262: if ((ds -> ds_units & units) != ds -> ds_units) {
263: advise (NULLCP, "need %s functional units",
264: sprintb (ds -> ds_units & ~units, UMASK));
265: return error;
266: }
267: }
268:
269: switch ((*ds -> ds_fnx) (vec)) {
270: case NOTOK:
271: return error;
272:
273: case OK:
274: default:
275: return OK;
276:
277: case DONE:
278: return DONE;
279: }
280: }
281: #endif
282:
283: /* ARGINIT */
284:
285: #ifndef BRIDGE
286: static arginit (vec)
287: char **vec;
288: {
289: register char *ap,
290: *pp;
291:
292: if (myname = rindex (*vec, '/'))
293: myname++;
294: if (myname == NULL || *myname == NULL)
295: myname = *vec;
296:
297: isodetailor (myname, 1);
298: ftam_log -> ll_file = strdup ("./ftam.log");
299: ll_hdinit (ftam_log, myname);
300:
301: storename = strdup ("filestore");
302: if (ontty = isatty (fileno (stdin)))
303: verbose++;
304:
305: for (vec++; ap = *vec; vec++) {
306: if (*ap == '-') {
307: while (*++ap)
308: switch (*ap) {
309: case 'a':
310: if ((pp = *++vec) == NULL || *pp == NULL)
311: adios (NULLCP, "usage: %s -a acct", myname);
312: aflag = pp;
313: break;
314:
315: case 'd':
316: debug++;
317: break;
318:
319: case 'f':
320: fflag++;
321: break;
322:
323: case 'h':
324: hash++;
325: break;
326:
327: case 'o':
328: if ((pp = *++vec) == NULL || *pp == NULL)
329: adios (NULLCP, "usage: %s -o mode", myname);
330: oflag = pp;
331: break;
332:
333: case 't':
334: trace++;
335: break;
336:
337: case 'u':
338: if ((pp = *++vec) == NULL || *pp == NULL)
339: adios (NULLCP, "usage: %s -u user", myname);
340: uflag = pp;
341: break;
342:
343: case 'v':
344: verbose = 1;
345: break;
346:
347: case 'w':
348: watch++;
349: break;
350:
351: default:
352: adios (NULLCP, "unknown switch -%c", *ap);
353: }
354: continue;
355: }
356:
357: if (hflag == NULL)
358: hflag = ap;
359: else
360: if (op == NULL) {
361: op = vec;
362: break;
363: }
364: }
365: }
366: #endif
367:
368: /* INTERACTIVE */
369:
370: #ifndef BRIDGE
371: int getline (prompt, buffer)
372: char *prompt,
373: *buffer;
374: {
375: register int i;
376: register char *cp,
377: *ep;
378: static int sticky = 0;
379:
380: if (interrupted) {
381: interrupted = 0;
382: return NOTOK;
383: }
384:
385: if (sticky) {
386: sticky = 0;
387: return NOTOK;
388: }
389:
390: switch (setjmp (intrenv)) {
391: case OK:
392: armed++;
393: break;
394:
395: case NOTOK:
396: if (ontty)
397: printf ("\n"); /* and fall */
398: default:
399: armed = 0;
400: return NOTOK;
401: }
402:
403: if (ontty) {
404: printf (prompt, ftamfd != NOTOK ? host : myname);
405: (void) fflush (stdout);
406: }
407:
408: for (ep = (cp = buffer) + BUFSIZ - 1; (i = getchar ()) != '\n';) {
409: if (i == EOF) {
410: if (ontty)
411: printf ("\n");
412: clearerr (stdin);
413: if (cp == buffer)
414: longjmp (intrenv, DONE);
415:
416: sticky++;
417: break;
418: }
419:
420: if (cp < ep)
421: *cp++ = i;
422: }
423: *cp = NULL;
424:
425: armed = 0;
426:
427: return OK;
428: }
429: #endif
430:
431: /* */
432:
433: #ifndef BRIDGE
434:
435: /* ARGSUSED */
436:
437: static SFD intrser (sig)
438: int sig;
439: {
440: #ifndef BSDSIGS
441: (void) signal (SIGINT, intrser);
442: #endif
443:
444: if (armed)
445: longjmp (intrenv, NOTOK);
446:
447: interrupted++;
448: }
449: #endif
450:
451: /* */
452:
453: #ifndef BRIDGE
454: #ifndef lint
455: int ask (va_alist)
456: va_dcl
457: {
458: int x,
459: y,
460: result;
461: char buffer[BUFSIZ];
462: va_list ap;
463:
464: if (interrupted) {
465: interrupted = 0;
466: return NOTOK;
467: }
468:
469: if (!ontty)
470: return OK;
471:
472: switch (setjmp (intrenv)) {
473: case OK:
474: armed++;
475: break;
476:
477: case NOTOK:
478: default:
479: printf ("\n");
480: armed = 0;
481: return DONE;
482: }
483: if (bell)
484: (void) putchar (ringring);
485:
486: va_start (ap);
487:
488: _asprintf (buffer, NULLCP, ap);
489:
490: va_end (ap);
491:
492: again: ;
493: printf ("%s? (y)es, (n)o: ", buffer);
494:
495: x = y = getchar ();
496: while (y != '\n' && y != EOF)
497: y = getchar ();
498:
499: switch (x) {
500: case 'y':
501: case '\n':
502: result = OK;
503: break;
504:
505: case 'n':
506: result = NOTOK;
507: break;
508:
509: case EOF:
510: result = DONE;
511: break;
512:
513: default:
514: goto again;
515: }
516:
517: armed = 0;
518:
519: return result;
520: }
521: #else
522: /* VARARGS */
523:
524: int ask (fmt)
525: char *fmt;
526: {
527: return ask (fmt);
528: }
529: #endif
530: #endif
531:
532: /* ERRORS */
533:
534: #ifndef lint
535: void _advise ();
536:
537:
538: void adios (va_alist)
539: va_dcl
540: {
541: struct FTAMindication ftis;
542: va_list ap;
543:
544: va_start (ap);
545:
546: _advise (ap);
547:
548: va_end (ap);
549:
550: if (ftamfd != NOTOK)
551: (void) FUAbortRequest (ftamfd, FACTION_PERM,
552: (struct FTAMdiagnostic *) 0, 0, &ftis);
553:
554: #ifdef BRIDGE
555: reply (550, ftam_error);
556: exit (1);
557: #else
558: _exit (1);
559: #endif
560: }
561: #else
562: /* VARARGS */
563:
564: void adios (what, fmt)
565: char *what,
566: *fmt;
567: {
568: adios (what, fmt);
569: }
570: #endif
571:
572:
573: #ifndef lint
574: void advise (va_alist)
575: va_dcl
576: {
577: va_list ap;
578:
579: va_start (ap);
580:
581: _advise (ap);
582:
583: va_end (ap);
584: }
585:
586:
587: static void _advise (ap)
588: va_list ap;
589: {
590: char buffer[BUFSIZ];
591:
592: asprintf (buffer, ap);
593:
594: #ifndef BRIDGE
595: if (hash && marks >= BUFSIZ) {
596: marks = 0;
597: printf ("\n");
598: }
599:
600: (void) fflush (stdout);
601:
602: fprintf (stderr, "%s: ", myname);
603: (void) fputs (buffer, stderr);
604: (void) fputc ('\n', stderr);
605:
606: (void) fflush (stderr);
607: #else
608: (void) ll_log (ftam_log, LLOG_NOTICE, NULLCP, "%s", buffer);
609: (void) strcpy (ftam_error, buffer);
610: #endif
611: }
612: #else
613: /* VARARGS */
614:
615: void advise (what, fmt)
616: char *what,
617: *fmt;
618: {
619: advise (what, fmt);
620: }
621: #endif
622:
623: /* MISCELLANY */
624:
625: #ifndef lint
626: char *strdup (s)
627: char *s;
628: {
629: char *p;
630:
631: if ((p = malloc((unsigned) (strlen (s) + 1))) == NULL)
632: adios (NULLCP, "out of memory");
633:
634: (void) strcpy (p, s);
635:
636: return p;
637: }
638: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.