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