![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftam-assoc.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-assoc.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam2 |
1.1 root 1: /* ftam-assoc.c - interactive initiator FTAM -- association management */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftam-assoc.c,v 7.3 90/07/09 14:37:10 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam2/RCS/ftam-assoc.c,v 7.3 90/07/09 14:37:10 mrose Exp $
9: *
10: *
11: * $Log: ftam-assoc.c,v $
12: * Revision 7.3 90/07/09 14:37:10 mrose
13: * sync
14: *
15: * Revision 7.2 89/12/01 13:56:06 mrose
16: * touch-up
17: *
18: * Revision 7.1 89/11/30 23:51:50 mrose
19: * pa2str
20: *
21: * Revision 7.0 89/11/23 21:54:15 mrose
22: * Release 6.0
23: *
24: */
25:
26: /*
27: * NOTICE
28: *
29: * Acquisition, use, and distribution of this module and related
30: * materials are subject to the restrictions of a license agreement.
31: * Consult the Preface in the User's Manual for the full terms of
32: * this agreement.
33: *
34: */
35:
36:
37: #include <stdio.h>
38: #include "ftamuser.h"
39:
40: /* */
41:
42: static struct PSAPaddr vfs_bound;
43:
44: /* */
45:
46: int f_open (vec)
47: char **vec;
48: {
49: register int i;
50: int manage;
51: char *p;
52: #ifndef BRIDGE
53: char buffer[BUFSIZ],
54: prompt[BUFSIZ];
55: #endif
56: AEI aei;
57: register struct vfsmap *vf;
58: register struct PSAPaddr *pa;
59: struct FTAMcontentlist fcs;
60: register struct FTAMcontentlist *fc = &fcs;
61: register struct FTAMcontent *fx;
62: struct FTAMconnect ftcs;
63: register struct FTAMconnect *ftc = &ftcs;
64: struct FTAMindication ftis;
65: register struct FTAMindication *fti = &ftis;
66:
67: if (*++vec == NULL) {
68: #ifdef BRIDGE
69: return NOTOK;
70: #else
71: if (getline ("host: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
72: return OK;
73: #endif
74: }
75:
76: if (host)
77: free (host);
78: host = strdup (*vec);
79:
80: if (*++vec == NULL) {
81: #ifdef BRIDGE
82: return NOTOK;
83: #else
84: if (user == NULL)
85: user = strdup (myuser ? myuser : "");
86: (void) sprintf (prompt, "user (%s:%s): ", host, user);
87: if (getline (prompt, buffer) == NOTOK)
88: return OK;
89: if (str2vec (buffer, vec) < 1)
90: *vec = user, user = NULL;
91: #endif
92: }
93:
94: if (user)
95: free (user);
96: user = strdup (*vec);
97:
98: if (*++vec) {
99: if (account)
100: free (account);
101: #ifdef BRIDGE
102: account = (**vec) ? strdup (*vec) : "";
103: #else
104: account = strdup (*vec);
105: #endif
106: }
107:
108: #ifdef BRIDGE
109: if (!strcmp (user, "anonymous") || !strcmp (user, "ANONYMOUS") ){
110: free (user);
111: user = strdup ("ANON");
112: }
113: #endif
114:
115: if (strcmp (user, "anon") == 0) {
116: free (user);
117: user = strdup ("ANON");
118: }
119:
120: #ifdef BRIDGE
121: if (strcmp (user, "ANON") && !*++vec)
122: return NOTOK;
123: else
124: p = *vec ? strdup(*vec) : "";
125: #else
126: if (strcmp (user, "ANON")) {
127: (void) sprintf (prompt, "password (%s:%s): ", host, user);
128: p = getpassword (prompt);
129: }
130: else
131: p = myuser ? myuser : "";
132: #endif
133:
134: #ifdef BRIDGE
135: if ((aei = _str2aei (host, "filestore", "iso ftam", 0)) == NULLAEI) {
136: advise (NULLCP, "unable to resolve service: %s", PY_pepy);
137: #else
138: if ((aei = _str2aei (host, storename, "iso ftam", ontty)) == NULLAEI) {
139: advise (NULLCP, "unable to resolve service: %s", PY_pepy);
140: #endif
141: return NOTOK;
142: }
143: if ((pa = aei2addr (aei)) == NULLPA) {
144: advise (NULLCP, "address translation failed");
145: return NOTOK;
146: }
147:
148: manage = 0;
149: fqos = FQOS_NORECOVERY;
150: class = FCLASS_TM | FCLASS_TRANSFER | FCLASS_MANAGE;
151: units |= FUNIT_READ | FUNIT_WRITE | FUNIT_LIMITED | FUNIT_ENHANCED
152: | FUNIT_GROUPING;
153: attrs = FATTR_STORAGE;
154: fc -> fc_ncontent = 0;
155: for (vf = vfs; vf -> vf_entry; vf++)
156: if (vf -> vf_oid)
157: fc -> fc_contents[fc -> fc_ncontent++].fc_dtn = vf -> vf_oid;
158:
159: #ifndef BRIDGE
160: if (verbose) {
161: fprintf (stderr, "%s... ", host);
162: (void) fflush (stderr);
163: }
164: #endif
165: if (FInitializeRequest (NULLOID, NULLAEI, aei, NULLPA, pa, manage, class,
166: units, attrs, NULLPE, fqos, fc,
167: *user ? user : NULL, account, *p ? p : NULL,
168: strlen (p), &myqos, trace ? FTraceHook : NULLIFP,
169: ftc, fti)
170: == NOTOK) {
171: #ifndef BRIDGE
172: if (verbose)
173: fprintf (stderr, "loses big\n");
174: #endif
175: ftam_advise (&fti -> fti_abort, "F-INITIALIZE.REQUEST");
176:
177: return NOTOK;
178: }
179:
180: switch (ftc -> ftc_state) {
181: case FSTATE_SUCCESS:
182: #ifndef BRIDGE
183: if (verbose)
184: fprintf (stderr, "connected\n");
185: #endif
186: #ifdef DEBUG
187: if (debug)
188: advise (NULLCP,
189: "responding AE title: %s, responding PSAP address: %s",
190: sprintaei (&ftc -> ftc_respondtitle),
191: paddr2str (&ftc -> ftc_respondaddr, NULLNA));
192: #endif
193: vfs_bound = ftc -> ftc_respondaddr; /* struct copy */
194:
195: ftamfd = ftc -> ftc_sd;
196: context = ftc -> ftc_context, ftc -> ftc_context = NULLOID;
197: fqos = ftc -> ftc_fqos;
198: class = ftc -> ftc_class;
199: units = ftc -> ftc_units;
200: attrs = ftc -> ftc_attrs;
201:
202: for (fx = ftc -> ftc_contents.fc_contents,
203: i = ftc -> ftc_contents.fc_ncontent - 1;
204: i >= 0;
205: fx++, i--) {
206: if (fx -> fc_result != PC_ACCEPT)
207: continue;
208:
209: for (vf = vfs; vf -> vf_entry; vf++)
210: if (oid_cmp (vf -> vf_oid, fx -> fc_dtn) == 0) {
211: vf -> vf_flags |= VF_OK;
212: vf -> vf_id = fx -> fc_id;
213: break;
214: }
215: }
216: for (vf = vfs; vf -> vf_entry; vf++)
217: if (vf -> vf_oid
218: && !(vf -> vf_flags & VF_OK)
219: && (vf -> vf_flags & VF_WARN))
220: advise (NULLCP,
221: "warning: virtual filestore has no support for %ss",
222: vf -> vf_text);
223:
224: vf = &vfs[VFS_UBF];
225: if (vf -> vf_oid == NULLOID || !(vf -> vf_flags & VF_OK))
226: advise (NULLCP,
227: "%s files not negotiated, suggest you quit now!",
228: vf -> vf_entry);
229:
230: if ((vf = &vfs[tmode]) != &vfs[VFS_DEF]
231: && (vf -> vf_oid == NULLOID
232: || !(vf -> vf_flags & VF_OK))) {
233: advise (NULLCP, "negotiation prevents transfer of %ss",
234: vf -> vf_text);
235:
236: tmode = VFS_DEF;
237: }
238:
239: for (vf = vfs; vf -> vf_entry; vf++) /* prime the pump */
240: if (vf -> vf_peek)
241: (void) (*vf -> vf_peek) (vf, NOTOK, NULLCP,
242: (struct stat *) 0, ftamfd);
243:
244: if ((fadusize = ftc -> ftc_ssdusize) < 0)
245: fadusize = 0;
246: break;
247:
248: default:
249: #ifndef BRIDGE
250: if (verbose)
251: fprintf (stderr, "failed\n");
252: #endif
253: break;
254: }
255: ftam_diag (ftc -> ftc_diags, ftc -> ftc_ndiag,
256: ftamfd != NOTOK || fti -> fti_abort.fta_peer,
257: ftc -> ftc_action);
258:
259: FTCFREE (ftc);
260:
261: if (ftamfd != NOTOK) {
262: vec[0] = "sd";
263: vec[1] = NULLCP;
264:
265: (void) f_cd (vec);
266: }
267:
268: return (ftamfd != NOTOK ? OK : NOTOK);
269: }
270:
271: /* */
272:
273: /* ARGSUSED */
274:
275: int f_close (vec)
276: char **vec;
277: {
278: struct FTAMrelease ftrs;
279: register struct FTAMrelease *ftr = &ftrs;
280: struct FTAMindication ftis;
281: register struct FTAMindication *fti = &ftis;
282:
283: #ifdef BRIDGE
284: if (ftamfd == NOTOK)
285: return OK;
286: #endif
287:
288: if (FTerminateRequest (ftamfd, NULLPE, ftr, fti) == NOTOK) {
289: ftam_advise (&fti -> fti_abort, "F-TERMINATE.REQUEST");
290:
291: (void) FUAbortRequest (ftamfd, FACTION_PERM,
292: (struct FTAMdiagnostic *) 0, 0, &ftis);
293: ftamfd = NOTOK;
294:
295: return NOTOK;
296: }
297:
298: ftam_chrg (&ftr -> ftr_charges);
299:
300: FTRFREE (ftr);
301:
302: ftamfd = NOTOK;
303: if (rcwd) {
304: free (rcwd);
305: rcwd = NULL;
306: }
307:
308: return OK;
309: }
310:
311: /* */
312:
313: int f_quit (vec)
314: char **vec;
315: {
316: if (ftamfd != NOTOK)
317: (void) f_close (vec);
318:
319: return DONE;
320: }
321:
322: /* */
323:
324: #define AMASK "\020\01STORAGE\02SECURITY\03PRIVATE"
325:
326:
327: /* ARGSUSED */
328:
329: #ifndef BRIDGE
330: int f_status (vec)
331: char **vec;
332: {
333: int hit;
334: register struct vfsmap *vf;
335:
336: printf ("associated with virtual filestore on \"%s\"\n at %s\n",
337: host, pa2str (&vfs_bound));
338: printf (" as user \"%s\"", user);
339: if (account)
340: printf (" using account \"%s\"", account);
341: printf ("\n");
342:
343: printf ("application-context: %s\nservice class: ", oid2ode (context));
344: switch (class) {
345: case FCLASS_TRANSFER:
346: printf ("transfer");
347: break;
348:
349: case FCLASS_ACCESS:
350: printf ("access");
351: break;
352:
353: case FCLASS_MANAGE:
354: printf ("management");
355: break;
356:
357: case FCLASS_TM:
358: printf ("transfer-and-management");
359: break;
360:
361: case FCLASS_UNCONS:
362: printf ("unconstrained");
363: break;
364:
365: default:
366: printf ("%d", class);
367: }
368: printf (", ftam-QoS: ");
369: switch (fqos) {
370: case FQOS_NORECOVERY:
371: printf ("no-recovery");
372: break;
373:
374: default:
375: printf ("class-%d-recovery", fqos);
376: break;
377: }
378:
379: printf ("\nfunctional units: %s\n", sprintb (units, UMASK));
380:
381: printf ("attribute groups: %s\n", sprintb (attrs, AMASK));
382:
383: printf ("document types:");
384: hit = 0;
385: for (vf = vfs; vf -> vf_entry; vf++)
386: if (vf -> vf_oid && (vf -> vf_flags & VF_OK)) {
387: printf ("\n %-16.16s %s (%s)", sprintoid (vf -> vf_oid),
388: vf -> vf_text, vf -> vf_entry);
389: hit = 1;
390: }
391: if (!hit)
392: printf (" none negotiated!");
393:
394: printf ("\nestimated integral FADU size: %d\n", fadusize);
395:
396: return OK;
397: }
398: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.