![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftam-get.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-get.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam2 |
1.1 root 1: /* ftam-get.c - interactive initiator FTAM -- "get" */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftam-get.c,v 7.2 90/07/01 21:03:08 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam2/RCS/ftam-get.c,v 7.2 90/07/01 21:03:08 mrose Exp $
9: *
10: *
11: * $Log: ftam-get.c,v $
12: * Revision 7.2 90/07/01 21:03:08 mrose
13: * pepsy
14: *
15: * Revision 7.1 90/01/11 23:48:39 mrose
16: * lint
17: *
18: * Revision 7.0 89/11/23 21:54:17 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 <errno.h>
35: #include <stdio.h>
36: #include "ftamuser.h"
37:
38: /* */
39:
40: static int effector;
41:
42: int ubffnx ();
43: struct vfsmap *findvf ();
44:
45: /* */
46:
47: int f_get (vec)
48: char **vec;
49: {
50: #ifndef BRIDGE
51: int sglobbed;
52: register char *bp;
53: register char *dst,
54: **gp,
55: **src;
56: char *freedst = NULL,
57: buffer[BUFSIZ];
58: struct stat st;
59: #endif
60: struct FADUidentity faduids;
61: register struct FADUidentity *faduid = &faduids;
62: struct vfsmap *vf = &vfs[tmode];
63:
64: if (vf == &vfs[VFS_DEF]
65: && (!(units & FUNIT_LIMITED)
66: || (class != FCLASS_MANAGE && class != FCLASS_TM))) {
67: advise (NULLCP,
68: "unable to use \"default\" document type on this association");
69: return OK;
70: }
71:
72: #ifdef BRIDGE
73: if (*++vec == NULL)
74: return NOTOK;
75: #else
76: if (*++vec == NULL) {
77: if (getline ("source: ", buffer) == NOTOK || str2vec (buffer, vec) < 1)
78: return OK;
79: dst = NULL;
80: }
81: else {
82: register char **ap;
83:
84: for (ap = vec; *ap; ap++)
85: continue;
86: if (--ap != vec)
87: dst = *ap, *ap = NULL;
88: else
89: dst = NULL;
90: }
91: if (!(src = xglob (vec, 1)))
92: return OK;
93: sglobbed = xglobbed;
94:
95: if (dst == NULL) {
96: if (getline ("destination: ", buffer) == NOTOK) {
97: blkfree (src);
98: return OK;
99: }
100: switch (str2vec (buffer, vec)) {
101: case 0:
102: break;
103:
104: case 1:
105: dst = *vec;
106: break;
107:
108: default:
109: advise (NULLCP, "too many destinations");
110: goto out;
111: }
112: }
113: if (dst && !(dst = freedst = xglob1val (dst, 0)))
114: goto out;
115: #endif
116:
117: faduid -> fa_type = FA_FIRSTLAST;
118: faduid -> fa_firstlast = FA_FIRST;
119:
120: #ifdef BRIDGE
121: return getvf (*vec, *vec, faduid, vf, ubffnx);
122: #else
123: if (src[1] == NULL) {
124: if (interrupted)
125: goto out;
126:
127: if (dst == NULL) {
128: switch (realstore) {
129: case RFS_UNIX:
130: if (dst = rindex (*src, '/'))
131: dst++;
132: if (dst == NULL || *dst == NULL)
133: dst = *src;
134: break;
135:
136: default:
137: dst = *src;
138: break;
139: }
140:
141: ask_it: ;
142: if (query)
143: switch (ask ("get %s %s", *src, dst)) {
144: case NOTOK:
145: goto out;
146:
147: case OK:
148: default:
149: break;
150:
151: case DONE:
152: goto out;
153: }
154: }
155: else
156: if (stat (dst, &st) != NOTOK
157: && (st.st_mode & S_IFMT) == S_IFDIR) {
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: switch (realstore) {
166: case RFS_UNIX:
167: if (dst = rindex (*src, '/'))
168: dst++;
169: if (dst == NULL || *dst == NULL)
170: dst = *src;
171: break;
172:
173: default:
174: break;
175: }
176: (void) strcpy (bp, dst);
177: dst = buffer;
178: goto ask_it;
179: }
180:
181: if (check_get (dst) != NOTOK)
182: (void) getvf (*src, dst, faduid, vf, ubffnx);
183: goto out;
184: }
185:
186: switch (realstore) {
187: case RFS_UNKNOWN:
188: advise (NULLCP, "%s", rs_unknown);
189: goto out;
190:
191: case RFS_UNIX:
192: #ifdef apollo
193: if (dst && dst[strlen (dst) - 1] == '/')
194: (void) sprintf (bp = buffer, "%s", dst);
195: else
196: #endif
197: (void) sprintf (bp = buffer, "%s/", dst ? dst : ".");
198: bp += strlen (bp);
199: break;
200:
201: default:
202: advise (NULLCP, "%s", rs_support);
203: goto out;
204: }
205:
206: if (stat (buffer, &st) == NOTOK) {
207: advise (dst, "unable to stat");
208: goto out;
209: }
210: if ((st.st_mode & S_IFMT) != S_IFDIR) {
211: advise (NULLCP, "%s: not a directory");
212: goto out;
213: }
214:
215: for (gp = src; *gp && !interrupted; gp++) {
216: switch (realstore) {
217: case RFS_UNIX:
218: if (dst = rindex (*gp, '/'))
219: dst++;
220: if (dst == NULL || *dst == NULL)
221: dst = *gp;
222: break;
223:
224: default:
225: dst = *gp;
226: break;
227: }
228: (void) strcpy (bp, dst);
229: dst = buffer;
230:
231: if (sglobbed) {
232: if (query)
233: switch (ask ("get %s %s", *gp, dst)) {
234: case NOTOK:
235: continue;
236:
237: case OK:
238: default:
239: break;
240:
241: case DONE:
242: goto out;
243: }
244: else
245: advise (NULLCP, "get %s %s", *gp, dst);
246: }
247:
248: if (check_get (dst) == NOTOK)
249: break;
250: (void) getvf (*gp, dst, faduid, vf, ubffnx);
251:
252: if (ftamfd == NOTOK)
253: break;
254: }
255:
256: out: ;
257: blkfree (src);
258: if (freedst)
259: free (freedst);
260:
261: return OK;
262: #endif
263: }
264:
265: /* */
266:
267: #ifndef BRIDGE
268: static int check_get (dst)
269: char *dst;
270: {
271: int result;
272: register char *cp;
273:
274: if ((result = access (dst, W_OK)) == NOTOK && errno == ENOENT)
275: if (cp = rindex (dst, '/')) {
276: *cp = NULL;
277: result = access (*dst ? dst : "/", W_OK);
278: *cp = '/';
279: }
280: else
281: result = access (".", W_OK);
282: if (result == OK)
283: return result;
284:
285: advise (dst, "unable to write");
286:
287: return result;
288: }
289: #endif
290:
291: /* */
292:
293: int getvf (src, dst, faduid, vf, wfnx)
294: char *src,
295: *dst;
296: register struct FADUidentity *faduid;
297: register struct vfsmap *vf;
298: IFP wfnx;
299: {
300: int fd,
301: result;
302: #ifdef BRIDGE
303: int ftp_result;
304: #endif
305: PE param;
306: struct FTAMgroup ftgs;
307: register struct FTAMgroup *ftg = &ftgs;
308: struct FTAMindication ftis;
309: register struct FTAMindication *fti = &ftis;
310: register struct FTAMabort *fta = &fti -> fti_abort;
311:
312: if (vf == &vfs[VFS_DEF]) {
313: if (!(vf = findvf (src))) {
314: vf = &vfs[VFS_UBF];
315: advise (NULLCP,
316: "unable to determine document type associated with %s", src);
317: /* most likely reason: the file isn't there... */
318:
319: if (vf -> vf_oid == NULLOID || !(vf -> vf_flags & VF_OK))
320: return NOTOK;
321: advise (NULLCP, "proposing %s transfer", vf -> vf_text);
322: }
323: else
324: if (vf == &vfs[VFS_FDF]) {
325: advise (NULLCP, "%s is a %s", src, vf -> vf_text);
326: return NOTOK;
327: }
328: }
329: else
330: if (vf -> vf_oid == NULLOID || !(vf -> vf_flags & VF_OK)) {
331: advise (NULLCP, "no support for %ss", vf -> vf_text);
332: return NOTOK;
333: }
334:
335: bzero ((char *) ftg, sizeof *ftg);
336: ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
337: ftg -> ftg_threshold = 0;
338:
339: ftg -> ftg_flags |= FTG_SELECT;
340: {
341: register struct FTAMselect *ftse = &ftg -> ftg_select;
342: register struct FTAMattributes *fa = &ftse -> ftse_attrs;
343:
344: fa -> fa_present = FA_FILENAME;
345: fa -> fa_nfile = 0;
346: fa -> fa_files[fa -> fa_nfile++] = src;
347:
348: ftse -> ftse_access = FA_PERM_READ;
349: FCINIT (&ftse -> ftse_conctl);
350: }
351: ftg -> ftg_threshold++;
352:
353: param = NULLPE;
354:
355: ftg -> ftg_flags |= FTG_OPEN;
356: {
357: register struct FTAMopen *ftop = &ftg -> ftg_open;
358:
359: ftop -> ftop_mode = FA_PERM_READ;
360: ftop -> ftop_contents = vf -> vf_oid;
361: if (vf -> vf_parameter) {
362: if (enc_f (vf -> vf_number, &_ZDOCS_mod, ¶m, 1, 0, NULLCP,
363: vf -> vf_parameter) == NOTOK) {
364: advise (NULLCP, "unable to build document type parameter: %s",
365: PY_pepy);
366: return NOTOK;
367: }
368: ftop -> ftop_parameter = param;
369: }
370: FCINIT (&ftop -> ftop_conctl);
371: ftop -> ftop_conctl.fc_readlock = FLOCK_SHARED;
372: }
373: ftg -> ftg_threshold++;
374:
375: result = FBulkBeginRequest (ftamfd, ftg, fti);
376:
377: if (param)
378: pe_free (param);
379:
380: if (result == NOTOK) {
381: ftam_advise (&fti -> fti_abort, "F-BULK-BEGIN.REQUEST");
382: return NOTOK;
383: }
384:
385: ftg = &fti -> fti_group;
386:
387: if (ftg -> ftg_flags & FTG_SELECT) {
388: register struct FTAMselect *ftse = &ftg -> ftg_select;
389:
390: ftam_diag (ftse -> ftse_diags, ftse -> ftse_ndiag, 1,
391: ftse -> ftse_action);
392: if (ftse -> ftse_state != FSTATE_SUCCESS)
393: goto you_lose;
394: }
395:
396: if (ftg -> ftg_flags & FTG_OPEN) {
397: register struct FTAMopen *ftop = &ftg -> ftg_open;
398:
399: ftam_diag (ftop -> ftop_diags, ftop -> ftop_ndiag, 1,
400: ftop -> ftop_action);
401: if (ftop -> ftop_state != FSTATE_SUCCESS)
402: goto you_lose;
403:
404: for (myvf = vfs; myvf -> vf_entry; myvf++)
405: if (oid_cmp (myvf -> vf_oid, ftop -> ftop_contents) == 0)
406: break;
407: switch (myvf - vfs) {
408: case VFS_UBF:
409: case VFS_UTF:
410: effector = 1;
411: if (ftop -> ftop_parameter && myvf -> vf_number >= 0) {
412: caddr_t parm = NULL;
413:
414: if (dec_f (myvf -> vf_number, &_ZDOCS_mod,
415: ftop -> ftop_parameter, 1, NULLIP, NULLVP,
416: (char **) &parm) == NOTOK)
417: advise (NULLCP,
418: "unable to parse document type parameter: %s",
419: PY_pepy);
420: else
421: switch (myvf - vfs) {
422: case VFS_UTF:
423: {
424: PElementID id;
425: register struct type_DOCS_FTAM__1__Parameters *p1 =
426: (struct type_DOCS_FTAM__1__Parameters *)
427: parm;
428:
429: if (p1 -> optionals
430: & opt_DOCS_FTAM__1__Parameters_universal__class__number)
431: id = (PElementID)
432: p1 -> universal__class__number;
433: else
434: id = PE_DEFN_GFXS;
435: switch (id) {
436: case PE_DEFN_GFXS:
437: if (getenv ("HP-FTAM")) {
438: effector = 1;
439: break;
440: } /* else fall... */
441: case PE_DEFN_PRTS:
442: case PE_DEFN_VISS:
443: effector = 0;
444: break;
445:
446: case PE_DEFN_T61S:
447: case PE_DEFN_VTXS:
448: case PE_DEFN_IA5S:
449: case PE_DEFN_GENS:
450: effector = 1;
451: break;
452:
453: default:
454: break;
455: }
456: }
457: break;
458:
459: case VFS_UBF:
460: default:
461: break;
462: }
463: if (parm)
464: fre_obj (parm, _ZDOCS_mod.md_dtab[myvf -> vf_number],
465: &_ZDOCS_mod);
466: }
467: if (debug)
468: advise (NULLCP, "effector=%d", effector);
469: /* and fall... */
470: case VFS_FDF:
471: if (myvf != vf || watch) {
472: advise (NULLCP, "%s transfer", myvf -> vf_text);
473: vf = myvf;
474: }
475: break;
476:
477: default:
478: vf = &vfs[VFS_UBF];
479: advise (NULLCP, "document type mismatch; assuming %s (%s)",
480: vf -> vf_text, vf -> vf_entry);
481: break;
482: }
483: }
484: myvf = vf;
485:
486: FTGFREE (ftg);
487:
488: if (FReadWriteRequest (ftamfd, FA_OPS_READ, faduid, myvf -> vf_context,
489: NOTOK, 0, fti) == NOTOK) {
490: ftam_advise (fta, "F-READWRITE.REQUEST");
491: return NOTOK;
492: }
493:
494: if (dst) {
495: #ifdef BRIDGE
496: if ((fd = dataconn(dst)) == NOTOK) {
497: #else
498: if ((fd = open (dst, O_WRONLY | O_CREAT | O_TRUNC, 0666)) == NOTOK) {
499: #endif
500: struct FTAMdiagnostic diags[NFDIAG];
501: register struct FTAMdiagnostic *dp = diags;
502:
503: advise (dst, "unable to write");
504: #ifdef BRIDGE
505: ftp_result = DONE;
506: #endif
507:
508: dp -> ftd_type = DIAG_PERM;
509: dp -> ftd_identifier = FS_ACC_LCL;
510: dp -> ftd_observer = dp -> ftd_source = EREF_IFSU;
511: dp -> ftd_delay = DIAG_NODELAY;
512: (void) sprintf (dp -> ftd_data, "unable to write %s: %s",
513: dst, sys_errname (errno));
514: dp -> ftd_cc = strlen (dp -> ftd_data);
515: dp++;
516:
517: if (FCancelRequest (ftamfd, FACTION_PERM, NULLPE, diags,
518: dp - diags, fti) == NOTOK) {
519: ftam_advise (fta, "F-CANCEL.REQUEST");
520: if (fd != NOTOK)
521: (void) close (fd);
522: return NOTOK;
523: }
524:
525: if (fti -> fti_type == FTI_CANCEL) {
526: register struct FTAMcancel *ftcn = &fti -> fti_cancel;
527:
528: ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag, 1,
529: ftcn -> ftcn_action);
530: FTCNFREE (ftcn);
531: }
532:
533: goto done_transfer;
534: }
535: }
536: else
537: fd = NOTOK;
538:
539: if (fd != NOTOK)
540: (*wfnx) (fd, (struct PSAPdata *) 0, OK);
541:
542: result = getloop (fd, dst, wfnx);
543:
544: if (fd != NOTOK) {
545: (*wfnx) (fd, (struct PSAPdata *) 0, DONE);
546: (void) close (fd);
547: }
548:
549: switch (result) {
550: case NOTOK:
551: return NOTOK;
552:
553: case OK:
554: default:
555: break;
556:
557: case DONE:
558: goto done_transfer;
559: }
560:
561: if (FTransEndRequest (ftamfd, NULLPE, fti) == NOTOK) {
562: ftam_advise (fta, "F-TRANSFER-END.REQUEST");
563: return NOTOK;
564: }
565:
566: switch (fti -> fti_type) {
567: case FTI_TRANSEND:
568: {
569: register struct FTAMtransend *ftre = &fti -> fti_transend;
570:
571: ftam_diag (ftre -> ftre_diags, ftre -> ftre_ndiag, 1,
572: ftre -> ftre_action);
573: FTREFREE (ftre);
574: }
575: break;
576:
577: case FTI_CANCEL:
578: {
579: register struct FTAMcancel *ftcn = &fti -> fti_cancel;
580:
581: advise (NULLCP, "data transfer cancelled!");
582: ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag, 1,
583: ftcn -> ftcn_action);
584: FTCNFREE (ftcn);
585:
586: if (FCancelResponse (ftamfd, FACTION_SUCCESS, NULLPE,
587: (struct FTAMdiagnostic *) 0, 0, fti)
588: == NOTOK) {
589: ftam_advise (fta, "F-CANCEL.RESPONSE");
590: return NOTOK;
591: }
592: }
593: break;
594:
595: default:
596: adios (NULLCP, "unexpected indication type=%d", fti -> fti_type);
597: }
598: #ifdef BRIDGE
599: ftp_result = OK;
600: #endif
601:
602: done_transfer: ;
603: ftg = &ftgs;
604: bzero ((char *) ftg, sizeof *ftg);
605: ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
606: ftg -> ftg_threshold = 0;
607:
608: ftg -> ftg_flags |= FTG_CLOSE;
609: ftg -> ftg_threshold++;
610:
611: ftg -> ftg_flags |= FTG_DESELECT;
612: ftg -> ftg_threshold++;
613:
614: if (FBulkEndRequest (ftamfd, ftg, fti) == NOTOK) {
615: ftam_advise (fta, "F-BULK-END.REQUEST");
616: return NOTOK;
617: }
618:
619: ftg = &fti -> fti_group;
620:
621: if (ftg -> ftg_flags & FTG_CLOSE) {
622: register struct FTAMclose *ftcl = &ftg -> ftg_close;
623:
624: ftam_diag (ftcl -> ftcl_diags, ftcl -> ftcl_ndiag, 1,
625: ftcl -> ftcl_action);
626: }
627:
628: if (ftg -> ftg_flags & FTG_DESELECT) {
629: register struct FTAMdeselect *ftde = &ftg -> ftg_deselect;
630:
631: ftam_diag (ftde -> ftde_diags, ftde -> ftde_ndiag, 1,
632: ftde -> ftde_action);
633: ftam_chrg (&ftde -> ftde_charges);
634: }
635:
636: FTGFREE (ftg);
637: #ifdef BRIDGE
638: return ftp_result;
639: #else
640: return OK;
641: #endif
642:
643: you_lose: ;
644: FTGFREE (ftg);
645: return NOTOK;
646: }
647:
648: /* */
649:
650: static struct vfsmap *findvf (file)
651: char *file;
652: {
653: struct FTAMgroup ftgs;
654: register struct FTAMgroup *ftg = &ftgs;
655: struct FTAMindication ftis;
656: register struct FTAMindication *fti = &ftis;
657: struct vfsmap *vf;
658:
659: bzero ((char *) ftg, sizeof *ftg);
660: ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
661: ftg -> ftg_threshold = 0;
662:
663: ftg -> ftg_flags |= FTG_SELECT;
664: {
665: register struct FTAMselect *ftse = &ftg -> ftg_select;
666: register struct FTAMattributes *fa = &ftse -> ftse_attrs;
667:
668: fa -> fa_present = FA_FILENAME;
669: fa -> fa_nfile = 0;
670: fa -> fa_files[fa -> fa_nfile++] = file;
671:
672: ftse -> ftse_access = FA_PERM_READATTR;
673: FCINIT (&ftse -> ftse_conctl);
674: }
675: ftg -> ftg_threshold++;
676:
677: ftg -> ftg_flags |= FTG_RDATTR;
678: {
679: register struct FTAMreadattr *ftra = &ftg -> ftg_readattr;
680:
681: ftra -> ftra_attrnames = FA_FILENAME | FA_CONTENTS;
682: }
683: ftg -> ftg_threshold++;
684:
685: ftg -> ftg_flags |= FTG_DESELECT;
686: ftg -> ftg_threshold++;
687:
688: if (FManageRequest (ftamfd, ftg, fti) == NOTOK) {
689: ftam_advise (&fti -> fti_abort, "F-MANAGE.REQUEST");
690: return NULL;
691: }
692:
693: ftg = &fti -> fti_group;
694:
695: if (ftg -> ftg_flags & FTG_SELECT) {
696: register struct FTAMselect *ftse = &ftg -> ftg_select;
697:
698: if (debug)
699: ftam_diag (ftse -> ftse_diags, ftse -> ftse_ndiag, 1,
700: ftse -> ftse_action);
701: if (ftse -> ftse_state != FSTATE_SUCCESS)
702: goto you_lose;
703: }
704:
705: vf = NULL;
706: if (ftg -> ftg_flags & FTG_RDATTR) {
707: register struct FTAMreadattr *ftra = &ftg -> ftg_readattr;
708: register struct FTAMattributes *fa = &ftra -> ftra_attrs;
709:
710: if (debug)
711: ftam_diag (ftra -> ftra_diags, ftra -> ftra_ndiag, 1,
712: ftra -> ftra_action);
713: if (ftra -> ftra_action != FACTION_SUCCESS)
714: fa -> fa_present = 0;
715:
716: if (fa -> fa_present & FA_CONTENTS) {
717: for (vf = vfs; vf -> vf_entry; vf++)
718: if (vf -> vf_oid
719: && (vf -> vf_flags & VF_OK)
720: && oid_cmp (vf -> vf_oid, fa -> fa_contents) == 0) {
721: if (fa -> fa_parameter && vf -> vf_number >= 0) {
722: if (vf -> vf_parameter && (vf -> vf_flags & VF_PARM))
723: fre_obj (vf -> vf_parameter,
724: _ZDOCS_mod.md_dtab[vf -> vf_number],
725: &_ZDOCS_mod);
726: vf -> vf_parameter = NULL, vf -> vf_flags &= ~VF_PARM;
727: if (dec_f (vf -> vf_number, &_ZDOCS_mod,
728: fa -> fa_parameter, 1, NULLIP, NULLVP,
729: &vf -> vf_parameter) == NOTOK) {
730: advise (NULLCP,
731: "unable to parse document type parameter: %s",
732: PY_pepy);
733: vf = NULL;
734: }
735: else
736: if (vf -> vf_check
737: && (*vf -> vf_check) (vf -> vf_parameter,
738: PY_pepy) == NOTOK) {
739: advise (NULLCP, "%s", PY_pepy);
740: vf = NULL;
741: }
742: }
743: break;
744: }
745: if (!vf -> vf_entry) {
746: advise (NULLCP,
747: "unknown document type %s associated with %s",
748: sprintoid (fa -> fa_contents), file);
749: vf = NULL;
750: }
751: }
752: }
753:
754: if (ftg -> ftg_flags & FTG_DESELECT) {
755: register struct FTAMdeselect *ftde = &ftg -> ftg_deselect;
756:
757: if (debug) {
758: ftam_diag (ftde -> ftde_diags, ftde -> ftde_ndiag, 1,
759: ftde -> ftde_action);
760: ftam_chrg (&ftde -> ftde_charges);
761: }
762: }
763:
764: FTGFREE (ftg);
765: return vf;
766:
767: you_lose: ;
768: FTGFREE (ftg);
769: return NULL;
770: }
771:
772: /* */
773:
774: static int getloop (fd, dst, wfnx)
775: int fd;
776: char *dst;
777: IFP wfnx;
778: {
779: int reason,
780: result;
781: struct FTAMindication ftis;
782: register struct FTAMindication *fti = &ftis;
783: register struct FTAMabort *fta = &fti -> fti_abort;
784:
785: for (;;) {
786: if (!interrupted) {
787: int nfds;
788: fd_set rfds;
789:
790: nfds = 0;
791: FD_ZERO (&rfds);
792: /* interrupt causes EINTR */
793: if (FSelectMask (ftamfd, &rfds, &nfds, fti) == OK)
794: (void) xselect (nfds, &rfds, NULLFD, NULLFD, NOTOK);
795: }
796:
797: if (interrupted) {
798: advise (NULLCP, "cancelling transfer");
799: reason = FS_GEN_INITIATOR;
800: errno = EINTR;
801: goto do_cancel;
802: }
803:
804: switch (result = FWaitRequest (ftamfd, NOTOK, fti)) {
805: case NOTOK:
806: ftam_advise (&fti -> fti_abort, "F-WAIT.REQUEST");
807: return NOTOK;
808:
809: case OK:
810: case DONE:
811: break;
812:
813: default:
814: adios (NULLCP, "unknown return from FWaitRequest=%d",
815: result);
816: }
817:
818: switch (fti -> fti_type) {
819: case FTI_DATA:
820: if ((*wfnx) (fd, &fti -> fti_data, OK) == NOTOK) {
821: struct FTAMdiagnostic diags[NFDIAG];
822: register struct FTAMdiagnostic *dp;
823:
824: advise (dst, "error writing");
825: reason = FS_ACC_WRITE;
826:
827: do_cancel: ;
828: dp = diags;
829:
830: dp -> ftd_type = DIAG_PERM;
831: dp -> ftd_identifier = reason;
832: dp -> ftd_observer = dp -> ftd_source = EREF_IFSU;
833: dp -> ftd_delay = DIAG_NODELAY;
834: (void) strcpy (dp -> ftd_data, sys_errname (errno));
835: dp -> ftd_cc = strlen (dp -> ftd_data);
836: dp++;
837:
838: if (FCancelRequest (ftamfd, FACTION_PERM, NULLPE, diags,
839: dp - diags, fti) == NOTOK) {
840: ftam_advise (fta, "F-CANCEL.REQUEST");
841: return NOTOK;
842: }
843:
844: if (fti -> fti_type == FTI_CANCEL) {
845: register struct FTAMcancel *ftcn = &fti -> fti_cancel;
846:
847: ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag, 1,
848: ftcn -> ftcn_action);
849: FTCNFREE (ftcn);
850: }
851:
852: return DONE;
853: }
854: break;
855:
856: case FTI_DATAEND:
857: return OK;
858:
859: case FTI_CANCEL:
860: {
861: register struct FTAMcancel *ftcn = &fti -> fti_cancel;
862:
863: advise (NULLCP, "data transfer cancelled!");
864: ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag, 1,
865: ftcn -> ftcn_action);
866: FTCNFREE (ftcn);
867:
868: if (FCancelResponse (ftamfd, FACTION_SUCCESS, NULLPE,
869: (struct FTAMdiagnostic *) 0, 0, fti)
870: == NOTOK) {
871: ftam_advise (fta, "F-CANCEL.RESPONSE");
872: return NOTOK;
873: }
874: }
875: return DONE;
876:
877: default:
878: adios (NULLCP, "unexpected indication type=%d",
879: fti -> fti_type);
880: }
881: }
882: }
883:
884: /* */
885:
886: static int ubffnx (fd, px, status)
887: int fd;
888: register struct PSAPdata *px;
889: int status;
890: {
891: register int i,
892: n;
893: register PE pe,
894: *pep;
895: static int cc;
896:
897: if (px == NULL) {
898: switch (status) {
899: case OK:
900: default:
901: cc = 0;
902: if (verbose)
903: timer (cc, NULLCP);
904: if (hash)
905: marks = BUFSIZ - 1;
906: break;
907:
908: case DONE:
909: if (verbose)
910: timer (cc, "received");
911: break;
912: }
913:
914: return OK;
915: }
916:
917: for (pep = px -> px_info, i = px -> px_ninfo - 1; i >= 0; pep++, i--) {
918: if ((pe = *pep) == NULLPE)
919: continue;
920:
921: switch (myvf - vfs) {
922: case VFS_UBF:
923: default:
924: if (debug)
925: WATCHP (DOCS_FTAM__3__Datatype1, pe, 1);
926: n = de2fd (fd, pe, 0, 0);
927: break;
928:
929: case VFS_UTF:
930: if (debug)
931: WATCHP (DOCS_FTAM__1__Datatype1, pe, 1);
932: n = de2fd (fd, pe, 1, effector);
933: break;
934: }
935: if (n == NOTOK)
936: break;
937:
938: if (verbose || hash)
939: cc += n;
940: if (hash) {
941: if (hash > 1)
942: printf ("%d\r", cc);
943: else
944: for (; marks < cc; marks += BUFSIZ)
945: (void) putchar ('#');
946: (void) fflush (stdout);
947: }
948: }
949:
950: PXFREE (px);
951:
952: return n;
953: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.