![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftam-mgmt.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-mgmt.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam2 |
1.1 root 1: /* ftam-mgmt.c - interactive initiator FTAM -- file management */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftam-mgmt.c,v 7.0 89/11/23 21:54:23 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam2/RCS/ftam-mgmt.c,v 7.0 89/11/23 21:54:23 mrose Rel $
9: *
10: *
11: * $Log: ftam-mgmt.c,v $
12: * Revision 7.0 89/11/23 21:54:23 mrose
13: * Release 6.0
14: *
15: */
16:
17: /*
18: * NOTICE
19: *
20: * Acquisition, use, and distribution of this module and related
21: * materials are subject to the restrictions of a license agreement.
22: * Consult the Preface in the User's Manual for the full terms of
23: * this agreement.
24: *
25: */
26:
27:
28: #include <stdio.h>
29: #include "ftamuser.h"
30:
31: /* */
32:
33: int f_mv (vec)
34: char **vec;
35: {
36: #ifdef BRIDGE
37: register char *src;
38: #else
39: int sglobbed;
40: register char *bp,
41: **gp,
42: **src;
43: char *freedst = NULL,
44: buffer[BUFSIZ];
45: #endif
46: register char *dst;
47:
48: if (*++vec == NULL) {
49: #ifdef BRIDGE
50: return NOTOK;
51: #else
52: if (getline ("source: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
53: return OK;
54: dst = NULL;
55: #endif
56: }
57: #ifdef BRIDGE
58: src = *vec;
59: if (*++vec == NULL)
60: return NOTOK;
61: dst = *vec;
62: #else
63: else {
64: register char **ap;
65:
66: for (ap = vec; *ap; ap++)
67: continue;
68: if (--ap != vec)
69: dst = *ap, *ap = NULL;
70: else
71: dst = NULL;
72: }
73: #endif
74: #ifndef BRIDGE
75: if (!(src = xglob (vec, 1)))
76: return OK;
77: sglobbed = xglobbed;
78:
79: if (dst == NULL) {
80: if (getline ("destination: ", buffer) == NOTOK) {
81: blkfree (src);
82: return OK;
83: }
84: switch (str2vec (buffer, vec)) {
85: case 0:
86: switch (realstore) {
87: case RFS_UNIX:
88: dst = ".";
89: break;
90:
91: default:
92: advise (NULLCP, "need a destination");
93: goto out;
94: }
95: break;
96:
97: case 1:
98: dst = *vec;
99: break;
100:
101: default:
102: advise (NULLCP, "too many destinations");
103: goto out;
104: }
105: }
106: if (!(dst = freedst = xglob1val (dst, 1)))
107: goto out;
108:
109: if (src[1] == NULL) {
110: if (interrupted)
111: goto out;
112:
113: switch (realstore) {
114: case RFS_UNIX:
115: if (isdir (dst, NULLCP, 1) == NOTOK)
116: break;
117: #ifdef apollo
118: if (*dst == '/')
119: (void) sprintf (bp = buffer, "%s", dst);
120: else
121: #endif
122: (void) sprintf (bp = buffer, "%s/", dst);
123: bp += strlen (bp);
124: if (dst = rindex (*src, '/'))
125: dst++;
126: if (dst == NULL || *dst == NULL)
127: dst = *src;
128: (void) strcpy (bp, dst);
129: dst = buffer;
130:
131: switch (ask ("mv %s %s", *src, dst)) {
132: case NOTOK:
133: goto out;
134:
135: case OK:
136: default:
137: break;
138:
139: case DONE:
140: goto out;
141: }
142: break;
143:
144: default:
145: break;
146: }
147:
148: (void) mv (*src, dst, 0);
149: goto out;
150: }
151:
152: switch (realstore) {
153: case RFS_UNKNOWN:
154: advise (NULLCP, "%s", rs_unknown);
155: goto out;
156:
157: case RFS_UNIX:
158: #ifdef apollo
159: if (*dst == '/')
160: (void) sprintf (bp = buffer, "%s", dst);
161: else
162: #endif
163: (void) sprintf (bp = buffer, "%s/", dst);
164: bp += strlen (bp);
165: break;
166:
167: default:
168: advise (NULLCP, "%s", rs_support);
169: goto out;
170: }
171:
172: if (isdir (dst, NULLCP, 0) == NOTOK)
173: goto out;
174:
175: for (gp = src; *gp; gp++) {
176: switch (realstore) {
177: case RFS_UNIX:
178: if (dst = rindex (*gp, '/'))
179: dst++;
180: if (dst == NULL || *dst == NULL)
181: dst = *gp;
182: break;
183:
184: default:
185: dst = *gp;
186: }
187: (void) strcpy (bp, dst);
188: dst = str2file (buffer);
189:
190: if (sglobbed) {
191: if (query)
192: switch (ask ("mv %s %s", *gp, dst)) {
193: case NOTOK:
194: continue;
195:
196: case OK:
197: default:
198: break;
199:
200: case DONE:
201: goto out;
202: }
203: else
204: advise (NULLCP, "mv %s %s", *gp, dst);
205: }
206:
207: (void) mv (*gp, dst, 1);
208:
209: if (ftamfd == NOTOK)
210: break;
211: }
212: #else
213: return mv (src, dst, 0);
214: #endif
215:
216: #ifndef BRIDGE
217: out: ;
218: blkfree (src);
219: if (freedst)
220: free (freedst);
221:
222: return OK;
223: #endif
224: }
225:
226: /* */
227:
228: static int mv (src, dst, multi)
229: char *src,
230: *dst;
231: int multi;
232: {
233: struct FTAMgroup ftgs;
234: register struct FTAMgroup *ftg = &ftgs;
235: struct FTAMindication ftis;
236: register struct FTAMindication *fti = &ftis;
237:
238: bzero ((char *) ftg, sizeof *ftg);
239: ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
240: ftg -> ftg_threshold = 0;
241:
242: ftg -> ftg_flags |= FTG_SELECT;
243: {
244: register struct FTAMselect *ftse = &ftg -> ftg_select;
245: register struct FTAMattributes *fa = &ftse -> ftse_attrs;
246:
247: fa -> fa_present = FA_FILENAME;
248: fa -> fa_nfile = 0;
249: fa -> fa_files[fa -> fa_nfile++] = src;
250:
251: ftse -> ftse_access = FA_PERM_CHNGATTR;
252: FCINIT (&ftse -> ftse_conctl);
253: }
254: ftg -> ftg_threshold++;
255:
256: ftg -> ftg_flags |= FTG_CHATTR;
257: {
258: register struct FTAMchngattr *ftca = &ftg -> ftg_chngattr;
259: register struct FTAMattributes *fa = &ftca -> ftca_attrs;
260:
261: fa -> fa_present = FA_FILENAME;
262: fa -> fa_nfile = 0;
263: fa -> fa_files[fa -> fa_nfile++] = dst;
264: }
265: ftg -> ftg_threshold++;
266:
267: ftg -> ftg_flags |= FTG_DESELECT;
268: ftg -> ftg_threshold++;
269:
270: if (FManageRequest (ftamfd, ftg, fti) == NOTOK) {
271: ftam_advise (&fti -> fti_abort, "F-MANAGE.REQUEST");
272: return NOTOK;
273: }
274:
275: ftg = &fti -> fti_group;
276:
277: if (ftg -> ftg_flags & FTG_SELECT) {
278: register struct FTAMselect *ftse = &ftg -> ftg_select;
279:
280: if (multi && ftse -> ftse_state != FSTATE_SUCCESS)
281: printf ("%s\n", src);
282: ftam_diag (ftse -> ftse_diags, ftse -> ftse_ndiag, 1,
283: ftse -> ftse_action);
284: if (ftse -> ftse_state != FSTATE_SUCCESS)
285: goto you_lose;
286: }
287:
288: if (ftg -> ftg_flags & FTG_CHATTR) {
289: register struct FTAMchngattr *ftca = &ftg -> ftg_chngattr;
290:
291: ftam_diag (ftca -> ftca_diags, ftca -> ftca_ndiag, 1,
292: ftca -> ftca_action);
293: }
294:
295: if (ftg -> ftg_flags & FTG_DESELECT) {
296: register struct FTAMdeselect *ftde = &ftg -> ftg_deselect;
297:
298: ftam_diag (ftde -> ftde_diags, ftde -> ftde_ndiag, 1,
299: ftde -> ftde_action);
300: ftam_chrg (&ftde -> ftde_charges);
301: }
302:
303: FTGFREE (ftg);
304: return OK;
305:
306: you_lose: ;
307: FTGFREE (ftg);
308: return NOTOK;
309: }
310:
311: /* */
312:
313: int f_rm (vec)
314: char **vec;
315: {
316: #ifndef BRIDGE
317: int multi;
318: char buffer[BUFSIZ];
319: #endif
320:
321: if (*++vec == NULL) {
322: #ifdef BRIDGE
323: return NOTOK;
324: #else
325: if (getline ("file: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
326: return OK;
327: #endif
328: }
329:
330: #ifdef BRIDGE
331: return rm (*vec, 0);
332: #else
333: if (vec = xglob (vec, 1)) {
334: register char **gp;
335:
336: multi = vec[1] ? 1 : 0;
337:
338: for (gp = vec; *gp && !interrupted; gp++) {
339: if (xglobbed && query)
340: switch (ask ("rm %s", *gp)) {
341: case NOTOK:
342: continue;
343:
344: case OK:
345: default:
346: break;
347:
348: case DONE:
349: goto out;
350: }
351:
352: (void) rm (*gp, multi);
353:
354: if (ftamfd == NOTOK)
355: break;
356: }
357:
358: out: ;
359: blkfree (vec);
360: }
361:
362: return OK;
363: #endif
364: }
365:
366: /* */
367:
368: static int rm (file, multi)
369: char *file;
370: int multi;
371: {
372: struct FTAMgroup ftgs;
373: register struct FTAMgroup *ftg = &ftgs;
374: struct FTAMindication ftis;
375: register struct FTAMindication *fti = &ftis;
376:
377: bzero ((char *) ftg, sizeof *ftg);
378: ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
379: ftg -> ftg_threshold = 0;
380:
381: ftg -> ftg_flags |= FTG_SELECT;
382: {
383: register struct FTAMselect *ftse = &ftg -> ftg_select;
384: register struct FTAMattributes *fa = &ftse -> ftse_attrs;
385:
386: fa -> fa_present = FA_FILENAME;
387: fa -> fa_nfile = 0;
388: fa -> fa_files[fa -> fa_nfile++] = file;
389:
390: ftse -> ftse_access = FA_PERM_DELETE;
391: FCINIT (&ftse -> ftse_conctl);
392: }
393: ftg -> ftg_threshold++;
394:
395: ftg -> ftg_flags |= FTG_DELETE;
396: ftg -> ftg_threshold++;
397:
398: if (FManageRequest (ftamfd, ftg, fti) == NOTOK) {
399: ftam_advise (&fti -> fti_abort, "F-MANAGE.REQUEST");
400: return NOTOK;
401: }
402:
403: ftg = &fti -> fti_group;
404:
405: if (ftg -> ftg_flags & FTG_SELECT) {
406: register struct FTAMselect *ftse = &ftg -> ftg_select;
407:
408: if (multi && ftse -> ftse_state != FSTATE_SUCCESS)
409: printf ("%s\n", file);
410: ftam_diag (ftse -> ftse_diags, ftse -> ftse_ndiag, 1,
411: ftse -> ftse_action);
412: if (ftse -> ftse_state != FSTATE_SUCCESS)
413: goto you_lose;
414: }
415:
416: if (ftg -> ftg_flags & FTG_DELETE) {
417: register struct FTAMdelete *ftxe = &ftg -> ftg_delete;
418:
419: ftam_diag (ftxe -> ftxe_diags, ftxe -> ftxe_ndiag, 1,
420: ftxe -> ftxe_action);
421: ftam_chrg (&ftxe -> ftxe_charges);
422: }
423:
424: FTGFREE (ftg);
425: return OK;
426:
427: you_lose: ;
428: FTGFREE (ftg);
429: return NOTOK;
430: }
431:
432: /* */
433:
434: #ifndef BRIDGE
435: int f_chgrp (vec)
436: char **vec;
437: {
438: int multi;
439: char group[8 + 1];
440: char buffer[BUFSIZ];
441:
442: if (!(attrs & FATTR_STORAGE)) {
443: advise (NULLCP, "no support for storage attributes");
444: return OK;
445: }
446:
447: if (*++vec == NULL) {
448: if (getline ("group: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
449: return OK;
450: }
451:
452: (void) strcpy (group, vec[0]);
453:
454: if (*++vec == NULL) {
455: if (getline ("file: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
456: return OK;
457: }
458:
459: if (vec = xglob (vec, 1)) {
460: register char **gp;
461:
462: multi = vec[1] ? 1 : 0;
463:
464: for (gp = vec; *gp && !interrupted; gp++) {
465: if (xglobbed && query)
466: switch (ask ("chgrp %s %s", group, *gp)) {
467: case NOTOK:
468: continue;
469:
470: case OK:
471: default:
472: break;
473:
474: case DONE:
475: goto out;
476: }
477:
478: (void) chgrp (group, *gp, multi);
479:
480: if (ftamfd == NOTOK)
481: break;
482: }
483:
484: out: ;
485: blkfree (vec);
486: }
487:
488: return OK;
489: }
490:
491: /* */
492:
493: static int chgrp (group, file, multi)
494: char *group,
495: *file;
496: int multi;
497: {
498: struct FTAMgroup ftgs;
499: register struct FTAMgroup *ftg = &ftgs;
500: struct FTAMindication ftis;
501: register struct FTAMindication *fti = &ftis;
502:
503: bzero ((char *) ftg, sizeof *ftg);
504: ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
505: ftg -> ftg_threshold = 0;
506:
507: ftg -> ftg_flags |= FTG_SELECT;
508: {
509: register struct FTAMselect *ftse = &ftg -> ftg_select;
510: register struct FTAMattributes *fa = &ftse -> ftse_attrs;
511:
512: fa -> fa_present = FA_FILENAME;
513: fa -> fa_nfile = 0;
514: fa -> fa_files[fa -> fa_nfile++] = file;
515:
516: ftse -> ftse_access = FA_PERM_CHNGATTR;
517: FCINIT (&ftse -> ftse_conctl);
518: }
519: ftg -> ftg_threshold++;
520:
521: ftg -> ftg_flags |= FTG_CHATTR;
522: {
523: register struct FTAMchngattr *ftca = &ftg -> ftg_chngattr;
524: register struct FTAMattributes *fa = &ftca -> ftca_attrs;
525:
526: fa -> fa_present = FA_ACCOUNT;
527: fa -> fa_account = group;
528: }
529: ftg -> ftg_threshold++;
530:
531: ftg -> ftg_flags |= FTG_DESELECT;
532: ftg -> ftg_threshold++;
533:
534: if (FManageRequest (ftamfd, ftg, fti) == NOTOK) {
535: ftam_advise (&fti -> fti_abort, "F-MANAGE.REQUEST");
536: return NOTOK;
537: }
538:
539: ftg = &fti -> fti_group;
540:
541: if (ftg -> ftg_flags & FTG_SELECT) {
542: register struct FTAMselect *ftse = &ftg -> ftg_select;
543:
544: if (multi && ftse -> ftse_state != FSTATE_SUCCESS)
545: printf ("%s\n", file);
546: ftam_diag (ftse -> ftse_diags, ftse -> ftse_ndiag, 1,
547: ftse -> ftse_action);
548: if (ftse -> ftse_state != FSTATE_SUCCESS)
549: goto you_lose;
550: }
551:
552: if (ftg -> ftg_flags & FTG_CHATTR) {
553: register struct FTAMchngattr *ftca = &ftg -> ftg_chngattr;
554:
555: ftam_diag (ftca -> ftca_diags, ftca -> ftca_ndiag, 1,
556: ftca -> ftca_action);
557: }
558:
559: if (ftg -> ftg_flags & FTG_DESELECT) {
560: register struct FTAMdeselect *ftde = &ftg -> ftg_deselect;
561:
562: ftam_diag (ftde -> ftde_diags, ftde -> ftde_ndiag, 1,
563: ftde -> ftde_action);
564: ftam_chrg (&ftde -> ftde_charges);
565: }
566:
567: FTGFREE (ftg);
568: return OK;
569:
570: you_lose: ;
571: FTGFREE (ftg);
572: return NOTOK;
573: }
574: #endif
575:
576: /* */
577:
578: int f_mkdir (vec)
579: char **vec;
580: {
581: #ifndef BRIDGE
582: int multi;
583: register char *dir;
584: char buffer[BUFSIZ];
585: #endif
586:
587: if (*++vec == NULL) {
588: #ifdef BRIDGE
589: return NOTOK;
590: #else
591: if (getline ("directory: ", buffer) == NOTOK
592: || str2vec (buffer, vec) < 1)
593: return OK;
594:
595: (void) makedir (str2file (*vec), 0);
596: #endif
597: }
598: #ifdef BRIDGE
599: return makedir (str2file (*vec));
600: #else
601: else {
602: multi = vec[1] ? 1 : 0;
603:
604: while (dir = *vec++)
605: (void) makedir (str2file (dir), multi);
606: }
607:
608: return OK;
609: #endif
610: }
611:
612: /* */
613:
614: static int makedir (dir, multi)
615: char *dir;
616: int multi;
617: {
618: struct FTAMgroup ftgs;
619: register struct FTAMgroup *ftg = &ftgs;
620: struct FTAMindication ftis;
621: register struct FTAMindication *fti = &ftis;
622: struct vfsmap *vf = &vfs[VFS_FDF];
623:
624: if (vf -> vf_oid == NULLOID) {
625: advise (NULLCP, "no support for %ss", vf -> vf_text);
626: return NOTOK;
627: }
628:
629: bzero ((char *) ftg, sizeof *ftg);
630: ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
631: ftg -> ftg_threshold = 0;
632:
633: ftg -> ftg_flags |= FTG_CREATE;
634: {
635: register struct FTAMcreate *ftce = &ftg -> ftg_create;
636: register struct FTAMattributes *fa = &ftce -> ftce_attrs;
637:
638: ftce -> ftce_override = FOVER_FAIL;
639:
640: fa -> fa_present = FA_FILENAME;
641: fa -> fa_nfile = 0;
642: fa -> fa_files[fa -> fa_nfile++] = dir;
643:
644: fa -> fa_present |= FA_ACTIONS;
645: fa -> fa_permitted = FA_PERM_READ | FA_PERM_READATTR | FA_PERM_CHNGATTR
646: | FA_PERM_DELETE | FA_PERM_TRAV;
647:
648: fa -> fa_present |= FA_CONTENTS;
649: fa -> fa_contents = vf -> vf_oid;
650:
651: ftce -> ftce_access = 0;
652: FCINIT (&ftce -> ftce_conctl);
653: }
654: ftg -> ftg_threshold++;
655:
656: ftg -> ftg_flags |= FTG_DESELECT;
657: ftg -> ftg_threshold++;
658:
659: if (FManageRequest (ftamfd, ftg, fti) == NOTOK) {
660: ftam_advise (&fti -> fti_abort, "F-MANAGE.REQUEST");
661: return NOTOK;
662: }
663:
664: ftg = &fti -> fti_group;
665:
666: if (ftg -> ftg_flags & FTG_CREATE) {
667: register struct FTAMcreate *ftce = &ftg -> ftg_create;
668:
669: if (multi && ftce -> ftce_state != FSTATE_SUCCESS)
670: printf ("%s\n", dir);
671: ftam_diag (ftce -> ftce_diags, ftce -> ftce_ndiag, 1,
672: ftce -> ftce_action);
673: if (ftce -> ftce_state != FSTATE_SUCCESS)
674: goto you_lose;
675: }
676:
677: if (ftg -> ftg_flags & FTG_DESELECT) {
678: register struct FTAMdeselect *ftde = &ftg -> ftg_deselect;
679:
680: ftam_diag (ftde -> ftde_diags, ftde -> ftde_ndiag, 1,
681: ftde -> ftde_action);
682: ftam_chrg (&ftde -> ftde_charges);
683: }
684:
685: FTGFREE (ftg);
686: return OK;
687:
688: you_lose: ;
689: FTGFREE (ftg);
690: return NOTOK;
691: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.