![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftamd-trans.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 ftamd-trans.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / ftam2 |
1.1 root 1: /* ftamd-trans.c - FTAM responder -- transfer */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/ftam2/RCS/ftamd-trans.c,v 7.2 90/07/01 21:03:28 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/ftam2/RCS/ftamd-trans.c,v 7.2 90/07/01 21:03:28 mrose Exp $
9: *
10: *
11: * $Log: ftamd-trans.c,v $
12: * Revision 7.2 90/07/01 21:03:28 mrose
13: * pepsy
14: *
15: * Revision 7.1 90/01/16 20:43:01 mrose
16: * last check-out
17: *
18: * Revision 7.0 89/11/23 21:54:33 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: #include <stdio.h>
34: #include "FTAM-types.h"
35: #include "ftamsystem.h"
36: #if defined(SYS5) && !defined(HPUX)
37: #include <sys/times.h>
38: #define TMS
39: #endif
40:
41: /* DATA */
42:
43: static int nbytes;
44:
45: long lseek ();
46:
47:
48: /* TRANSFER */
49:
50: int ftam_bulkbeginindication (ftg)
51: struct FTAMgroup *ftg;
52: {
53: int state;
54: struct FTAMgroup ftms;
55: struct FTAMgroup *ftm = &ftms;
56: struct FTAMindication ftis;
57: register struct FTAMindication *fti = &ftis;
58:
59: ftam_selection (ftg, ftm);
60:
61: if (ftm -> ftg_flags & FTG_SELECT)
62: state = ftm -> ftg_select.ftse_state;
63: else
64: state = ftm -> ftg_create.ftce_state;
65: if ((state != FSTATE_SUCCESS
66: || ((ftm -> ftg_flags & FTG_OPEN)
67: && ftm -> ftg_open.ftop_state != FSTATE_SUCCESS))
68: && myfd != NOTOK) {
69: #ifndef BRIDGE
70: unlock ();
71: #endif
72: (void) close (myfd);
73: myfd = NOTOK;
74: }
75:
76: if (FBulkBeginResponse (ftamfd, ftm, fti) == NOTOK)
77: ftam_adios (&fti -> fti_abort, "F-BULK-BEGIN.RESPONSE");
78:
79: FTGFREE (ftg);
80: }
81:
82: /* */
83:
84: /* we really pay the price here for not keeping more constraint set
85: information in the vfs structure...
86:
87: regular files have the unstructured constraint set
88: access context US
89:
90: directory files have the sequential flat constraint set
91: access context UA (is forced)
92:
93: Hence, when FADUs are transmitted, only data elements of type
94:
95: File-Contents-Data-Element
96:
97: are sent.
98: */
99:
100:
101: int ftam_readwriteindication (ftrw)
102: struct FTAMreadwrite *ftrw;
103: {
104: int result;
105: register struct FADUidentity *fa = &ftrw -> ftrw_identity;
106: struct FTAMdiagnostic diags[NFDIAG];
107: struct FTAMdiagnostic *dp = diags;
108: struct FTAMindication ftis;
109: register struct FTAMindication *fti = &ftis;
110:
111: mylocation = *fa; /* struct copy */
112: mylevel = ftrw -> ftrw_level;
113:
114: #ifdef BRIDGE
115: myoperation = ftrw -> ftrw_operation;
116: if (ftp_type (myvf - vfs) == NOTOK
117: && myoperation == FA_OPS_READ
118: && (mycontext = ftrw -> ftrw_context) != myvf -> vf_context) {
119: #else
120: if ((myoperation = ftrw -> ftrw_operation) == FA_OPS_READ
121: && (mycontext = ftrw -> ftrw_context) != myvf -> vf_context) {
122: #endif
123: dp -> ftd_type = DIAG_PERM;
124: dp -> ftd_identifier = FS_ACC_CTXSUPRT;
125: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
126: dp -> ftd_delay = DIAG_NODELAY;
127: dp -> ftd_cc = 0;
128: dp++;
129:
130: goto do_cancel;
131: }
132:
133: switch (myvf - vfs) {
134: case VFS_UBF:
135: case VFS_UTF:
136: default:
137: if (fa -> fa_type != FA_FIRSTLAST
138: || fa -> fa_firstlast != FA_FIRST) {
139: dp -> ftd_type = DIAG_PERM;
140: dp -> ftd_identifier = FS_ACC_FADULOC;
141: dp -> ftd_observer = EREF_RFSU, dp -> ftd_source = EREF_IFSU;
142: dp -> ftd_delay = DIAG_NODELAY;
143: dp -> ftd_cc = 0;
144: dp++;
145:
146: goto do_cancel;
147: }
148: break;
149: }
150:
151: switch (myoperation) {
152: case FA_OPS_READ:
153: default:
154: advise (LLOG_NOTICE, NULLCP, "read %s", myfile);
155: break;
156:
157: case FA_OPS_INSERT: /* not valid on an FDF */
158: dp -> ftd_type = DIAG_PERM;
159: dp -> ftd_identifier = FS_ACC_INSERT;
160: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
161: dp -> ftd_delay = DIAG_NODELAY;
162: dp -> ftd_cc = 0;
163: dp++;
164: goto do_cancel;
165:
166: case FA_OPS_REPLACE:
167: #ifdef BRIDGE
168: if ((myfd = ftp_write (myfile)) == NOTOK) {
169: #else
170: if (statok && myst.st_size == 0)
171: goto replace;
172: #ifdef SUNOS4
173: if (ftruncate (myfd, (off_t) 0) == NOTOK) {
174: #else
175: if (ftruncate (myfd, 0) == NOTOK) {
176: #endif
177: #endif
178: bad_operation: ;
179: dp -> ftd_type = DIAG_PERM;
180: dp -> ftd_identifier = myoperation == FA_OPS_REPLACE
181: ? FS_ACC_REPLACE : FS_ACC_INSERT;
182: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
183: dp -> ftd_delay = DIAG_NODELAY;
184: #ifdef BRIDGE
185: (void) strcpy (dp -> ftd_data, ftp_error);
186: #else
187: (void) strcpy (dp -> ftd_data, sys_errname (errno));
188: #endif
189: dp -> ftd_cc = strlen (dp -> ftd_data);
190: dp++;
191: goto do_cancel;
192: }
193: #ifndef BRIDGE
194: replace: ;
195: #endif
196: advise (LLOG_NOTICE, NULLCP, "replace %s", myfile);
197: break;
198:
199: case FA_OPS_EXTEND:
200: #ifdef BRIDGE
201: if ((myfd = ftp_append (myfile)) == NOTOK)
202: #else
203: if (lseek (myfd, 0L, L_XTND) == (long) NOTOK)
204: #endif
205: goto bad_operation;
206: advise (LLOG_NOTICE, NULLCP, "extend %s", myfile);
207: break;
208: }
209:
210: FTRWFREE (ftrw);
211:
212: timer (nbytes = 0, NULLCP);
213: if (myoperation != FA_OPS_READ)
214: return;
215:
216: switch (myvf - vfs) {
217: case VFS_UTF:
218: case VFS_UBF:
219: default:
220: result = uxfget (&dp);
221: break;
222:
223: case VFS_FDF:
224: result = fdfget (&dp);
225: break;
226: }
227:
228: if (result != NOTOK)
229: return;
230:
231: do_cancel: ;
232: FTRWFREE (ftrw);
233:
234: if (FCancelRequest (ftamfd, FACTION_PERM, NULLPE, diags, dp - diags, fti)
235: == NOTOK)
236: ftam_adios (&fti -> fti_abort, "F-CANCEL-REQUEST");
237:
238: if (fti -> fti_type == FTI_CANCEL) {
239: register struct FTAMcancel *ftcn = &fti -> fti_cancel;
240:
241: advise (LLOG_NOTICE, NULLCP, "F-CANCEL.RESPONSE: %d",
242: ftcn -> ftcn_action);
243: ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag);
244: FTCNFREE (ftcn);
245: }
246: }
247:
248: /* */
249:
250: static uxfget (diags)
251: register struct FTAMdiagnostic **diags;
252: {
253: register int n;
254: int bsize,
255: effector,
256: gd,
257: magic,
258: nc,
259: size;
260: PE pe,
261: de;
262: register struct FTAMdiagnostic *dp = *diags;
263: struct FTAMindication ftis;
264: register struct FTAMindication *fti = &ftis;
265: register struct FTAMabort *fta = &fti -> fti_abort;
266: register struct type_DOCS_FTAM__1__Parameters *p1;
267: register struct type_DOCS_FTAM__3__Parameters *p3;
268: FILE *fp;
269: #ifdef BRIDGE
270: char line[BUFSIZ];
271: #endif
272:
273: #ifdef BRIDGE
274: /* try opening file for ftp read */
275: if ((myfd = ftp_read (myfile)) == NOTOK){
276: dp -> ftd_type = DIAG_PERM;
277: dp -> ftd_identifier = FS_ACC_LCL;
278: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
279: dp -> ftd_delay = DIAG_NODELAY;
280: (void) strcpy (dp -> ftd_data, "failed file access on remote host");
281: dp -> ftd_cc = strlen (dp -> ftd_data);
282: dp++;
283:
284: *diags = dp;
285: return NOTOK;
286: }
287: #endif
288:
289: effector = 1;
290: switch (myvf - vfs) {
291: case VFS_UTF:
292: p1 = (struct type_DOCS_FTAM__1__Parameters *) myparam;
293: if ((gd = dup (myfd)) == NOTOK
294: || (fp = fdopen (gd, "r")) == NULL) {
295: if (gd != NOTOK)
296: (void) close (gd);
297: if (myfd != NOTOK){
298: #ifdef BRIDGE
299: (void) close (myfd);
300: myfd = NOTOK;
301: (void) ftp_reply ();
302: #endif
303: }
304: goto no_mem;
305: }
306:
307: {
308: PElementID id;
309:
310: if (p1 -> optionals
311: & opt_DOCS_FTAM__1__Parameters_universal__class__number)
312: id = (PElementID) p1 -> universal__class__number;
313: else
314: id = PE_DEFN_GFXS;
315:
316: pe = pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, id);
317:
318: switch (pe -> pe_id) {
319: case PE_DEFN_GFXS:
320: if (getenv ("HP-FTAM")) {
321: effector = 1;
322: break;
323: } /* else fall... */
324: case PE_DEFN_PRTS:
325: case PE_DEFN_VISS:
326: effector = 0;
327: break;
328:
329: case PE_DEFN_T61S:
330: case PE_DEFN_VTXS:
331: case PE_DEFN_IA5S:
332: case PE_DEFN_GENS:
333: effector = 1;
334: break;
335:
336: default:
337: break;
338: }
339: }
340: if ((magic = fadusize - MAGIC_OCTET1) < 0)
341: magic = 0;
342: break;
343:
344: case VFS_UBF:
345: p3 = (struct type_DOCS_FTAM__3__Parameters *) myparam;
346: /* and fall */
347: default:
348: fp = NULL;
349:
350: pe = pe_alloc (PE_CLASS_UNIV, PE_FORM_PRIM, PE_PRIM_OCTS);
351: if ((magic = fadusize - MAGIC_SINGLE) < 0)
352: magic = 0;
353: break;
354: }
355: if (pe == NULLPE)
356: goto no_mem;
357: pe -> pe_context = myvf -> vf_id;
358:
359: #ifdef BRIDGE
360: bsize = BUFSIZ << 2;
361: size = magic >= bsize ? magic : bsize;
362: if (size > bsize)
363: size -= size % bsize;
364: #else
365: #ifndef MAXBSIZE
366: bsize = BUFSIZ;
367: #else
368: bsize = myst.st_blksize > 0 ? myst.st_blksize : BUFSIZ;
369: #endif
370: size = (1024 <= magic && magic < bsize) ? magic : bsize;
371: #endif
372: switch (myvf - vfs) {
373: case VFS_UTF:
374: if ((p1 -> optionals
375: & opt_DOCS_FTAM__1__Parameters_maximum__string__length)
376: && p1 -> maximum__string__length > 0)
377: size = p1 -> maximum__string__length;
378: break;
379:
380: case VFS_UBF:
381: if ((p3 -> optionals
382: & opt_DOCS_FTAM__3__Parameters_maximum__string__length)
383: && p3 -> maximum__string__length > 0)
384: size = p3 -> maximum__string__length;
385: /* and fall */
386: default:
387: break;
388: }
389:
390: if (debug)
391: advise (LLOG_DEBUG, NULLCP, "effector=%d id=0x%x size=%d",
392: effector, pe -> pe_id, size);
393:
394: if ((pe -> pe_prim = PEDalloc (pe -> pe_len = size)) == NULLPED) {
395: no_mem: ;
396: dp -> ftd_type = DIAG_PERM;
397: dp -> ftd_identifier = FS_ACC_LCL;
398: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
399: dp -> ftd_delay = DIAG_NODELAY;
400: (void) strcpy (dp -> ftd_data, "out of memory");
401: dp -> ftd_cc = strlen (dp -> ftd_data);
402: dp++;
403:
404: error_return: ;
405: (void) de2fadu (NULLPE, 0);
406: if (pe)
407: pe_free (pe);
408: if (fp)
409: (void) fclose (fp);
410: *diags = dp;
411: return NOTOK;
412: }
413:
414: for (;;) {
415: register char *bp,
416: *ep;
417:
418: for (ep = (bp = (char *) pe -> pe_prim) + size - (fp ? 2 : 0), nc = 0;
419: bp < ep; ) {
420: if (fp) {
421: register char *cp;
422:
423: #ifdef BRIDGE
424: if (strlen (line) || fgets (line, BUFSIZ, fp)) {
425: if ((strlen (line) + 1) < (ep - bp + 1)) {
426: (void) strcpy (bp, line);
427: line[0] = NULL;
428: }
429: else
430: break;
431: }
432: else {
433: n = (ferror (fp) && !feof (fp)) ? NOTOK : OK;
434: break;
435: }
436: #else
437: if (fgets (bp, ep - bp + 1, fp) == NULL) {
438: n = (ferror (fp) && !feof (fp)) ? NOTOK : OK;
439: break;
440: }
441: #endif
442: cp = bp + strlen (bp) - 1;
443: if (!effector) {
444: if (*cp == '\n') {
445: #ifndef BRIDGE
446: *cp = NULL;
447: #else
448: if (cp > bp) {
449: if (*--cp == '\r')
450: *cp = NULL;
451: else
452: *++cp = NULL;
453: }
454: else
455: *cp = NULL;
456: #endif
457: n = cp - bp;
458: bp = cp;
459: }
460: else { /* XXX: losing! */
461: n = cp - bp + 1;
462: bp = cp + 1;
463: }
464: }
465: else {
466: if (*cp == '\n') {
467: #ifndef BRIDGE
468: *cp++ = '\r';
469: #endif
470: *cp++ = '\n';
471: n = cp - bp;
472: bp = cp;
473: nc++;
474: continue;
475: }
476:
477: n = cp - bp + 1;
478: bp = cp + 1;
479: }
480: }
481: else {
482: switch (n = read (myfd, bp, ep - bp)) {
483: case NOTOK:
484: case OK:
485: break;
486:
487: default:
488: bp += n;
489: continue;
490: }
491: }
492: break;
493: }
494: if (n == NOTOK || (n = bp - (char *) pe -> pe_prim) == 0)
495: break;
496: pe -> pe_len = n;
497:
498: if (fp && !effector) {
499: if ((de = pe_cpy (pe)) == NULLPE)
500: goto no_mem;
501: }
502: else
503: de = pe;
504:
505: if (debug)
506: if (fp) {
507: WATCHP (DOCS_FTAM__1__Datatype1, de, 0);
508: }
509: else
510: WATCHP (DOCS_FTAM__3__Datatype1, de, 0);
511:
512:
513: switch (de2fadu (de, pe != de ? 1 : 0)) {
514: case NOTOK:
515: dp -> ftd_type = DIAG_PERM;
516: dp -> ftd_identifier = FS_ACC_LCL;
517: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
518: dp -> ftd_delay = DIAG_NODELAY;
519: dp -> ftd_cc = 0;
520: dp++;
521: goto error_return;
522:
523: case OK:
524: default:
525: nbytes += (n - nc), nc = 0;
526: continue;
527:
528: case DONE:
529: break;
530: }
531: break;
532: }
533:
534: pe_free (pe);
535:
536: if (fp)
537: (void) fclose (fp);
538:
539: if (n == DONE)
540: return DONE;
541:
542: if (n == NOTOK) {
543: dp -> ftd_type = DIAG_PERM;
544: dp -> ftd_identifier = FS_ACC_LCLDEV;
545: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
546: dp -> ftd_delay = DIAG_NODELAY;
547: (void) strcpy (dp -> ftd_data, sys_errname (errno));
548: dp -> ftd_cc = strlen (dp -> ftd_data);
549: dp++;
550:
551: *diags = dp;
552:
553: (void) de2fadu (NULLPE, 0);
554: return NOTOK;
555: }
556:
557: n = de2fadu (NULLPE, 1);
558:
559: if (n != DONE) {
560: timer (nbytes, "sent");
561:
562: if (FDataEndRequest (ftamfd, FACTION_SUCCESS,
563: (struct FTAMdiagnostic *) 0, 0, fti) == NOTOK)
564: ftam_adios (fta, "F-DATA-END.REQUEST");
565: }
566:
567: return n;
568: }
569:
570: /* */
571:
572: static fdfget (diags)
573: register struct FTAMdiagnostic **diags;
574: {
575: int names,
576: len,
577: n;
578: char *pp,
579: path[MAXPATHLEN];
580: PE pe;
581: #ifdef BRIDGE
582: int dd;
583: FILE *df;
584: char *ptr,
585: line[BUFSIZ];
586: #else
587: register struct dirent *d;
588: register DIR *dd;
589: #endif
590: struct stat st;
591: register struct FTAMdiagnostic *dp = *diags;
592: struct FTAMindication ftis;
593: register struct FTAMindication *fti = &ftis;
594: register struct FTAMabort *fta = &fti -> fti_abort;
595: register struct type_DOCS_NBS__9__Parameters *p9;
596: struct type_DOCS_NBS__9__Datatype1 *d9;
597:
598: if (strcmp (myfile, ".") == 0) {
599: pp = path;
600: *pp = NULL;
601: len = 0;
602: }
603: else
604: #ifdef apollo
605: if (strcmp (myfile, "/") == 0 || strcmp (myfile, "//") == 0) {
606: (void) sprintf (pp = path, "%s", myfile);
607: pp += (len = strlen (pp));
608: }
609: else
610: #endif
611: {
612: (void) sprintf (pp = path, "%s/", myfile);
613: pp += (len = strlen (pp));
614: }
615:
616: pe = NULLPE;
617:
618: #ifdef BRIDGE
619: if ((dd = ftp_ls (myfile)) == NOTOK || (df = fdopen (dd,"r")) == NULL) {
620: #else
621: if ((dd = opendir (myfile)) == NULL) {
622: #endif
623: no_mem: ;
624: dp -> ftd_type = DIAG_PERM;
625: dp -> ftd_identifier = FS_ACC_LCL;
626: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
627: dp -> ftd_delay = DIAG_NODELAY;
628: (void) strcpy (dp -> ftd_data, "out of memory");
629: dp -> ftd_cc = strlen (dp -> ftd_data);
630: dp++;
631:
632: error_return: ;
633: (void) de2fadu (NULLPE, 0);
634: if (pe)
635: pe_free (pe);
636: #ifdef BRIDGE
637: if (dd) {
638: (void) close (dd);
639: (void) ftp_reply ();
640: }
641: #else
642: if (dd)
643: (void) closedir (dd);
644: #endif
645: *diags = dp;
646: return NOTOK;
647: }
648:
649:
650: p9 = (struct type_DOCS_NBS__9__Parameters *) myparam;
651: if (fdf_p2names (ftamfd, p9, &names, fti) == NOTOK) {
652: register struct FTAMdiagnostic *d2 = fti -> fti_abort.fta_diags;
653:
654: dp = d2; /* struct copy */
655: dp++;
656: goto error_return;
657: }
658:
659: n = OK;
660: #ifdef BRIDGE
661: while (fgets(line, BUFSIZ, df)) {
662: #else
663: for (errno = 0; d = readdir (dd); errno = 0) {
664: #endif
665: struct FTAMattributes fas;
666: register struct FTAMattributes *fa = &fas;
667: #ifndef BRIDGE
668: register struct vfsmap *vf;
669: #endif
670:
671: #ifdef BRIDGE
672: if (ptr = rindex(line,'\r'))
673: *ptr = '\0';
674: #endif
675:
676: if (debug)
677: #ifdef BRIDGE
678: advise (LLOG_DEBUG, NULLCP, "len=%d name=\"%s\"",
679: strlen(line), line);
680: #else
681: advise (LLOG_DEBUG, NULLCP, "ino=%ld len=%d name=\"%s\"",
682: d -> d_ino, strlen (d -> d_name), d -> d_name);
683: #endif
684:
685: #ifndef BRIDGE
686: if (!d -> d_ino)
687: continue;
688: #endif
689:
690: #ifdef BRIDGE
691: if (len + strlen (line) >= MAXPATHLEN)
692: #else
693: if (len + strlen (d -> d_name) >= MAXPATHLEN)
694: #endif
695: continue;
696:
697: #ifdef BRIDGE
698: (void) strcpy (pp, line);
699: #else
700: (void) strcpy (pp, d -> d_name);
701: #endif
702:
703: #ifndef BRIDGE
704: if (stat (path, &st) == NOTOK
705: || (vf = st2vfs (NOTOK, path, &st, NULLOID, ftamfd)) == NULL)
706: continue;
707: #endif
708:
709: bzero ((char *) fa, sizeof *fa);
710: *diags = dp;
711: #ifdef BRIDGE
712: (void) readattrs (names, fa, vfs[VFS_UTF].vf_oid, NULLPE, path, &st,
713: diags);
714: #else
715: (void) readattrs (names, fa, vf -> vf_oid, NULLPE, path, &st, diags);
716: #endif
717: dp = *diags;
718:
719: if (fdf_attrs2d (ftamfd, fa, &d9, fti) == NOTOK) {
720: register struct FTAMdiagnostic *d2 = fti -> fti_abort.fta_diags;
721:
722: dp = d2; /* struct copy */
723: dp++;
724: goto error_return;
725: }
726:
727: if (encode_DOCS_NBS__9__Datatype1 (&pe, 1, 0, NULLCP, d9) == NOTOK) {
728: dp -> ftd_type = DIAG_PERM;
729: dp -> ftd_identifier = FS_ACC_LCL;
730: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
731: dp -> ftd_delay = DIAG_NODELAY;
732: (void) sprintf (dp -> ftd_data, "error encoding Datatype1: %s",
733: PY_pepy);
734: dp -> ftd_cc = strlen (dp -> ftd_data);
735: dp++;
736:
737: free_DOCS_NBS__9__Datatype1 (d9);
738: goto error_return;
739: }
740: pe -> pe_context = myvf -> vf_id;
741:
742: if (debug)
743: WATCHP (DOCS_NBS__9__Datatype1, pe, 0);
744:
745: n = de2fadu (pe, 1), pe = NULLPE;
746: switch (n) {
747: case NOTOK:
748: goto no_mem;
749:
750: case OK:
751: default:
752: continue;
753:
754: case DONE:
755: break;
756: }
757: break;
758: }
759:
760: #ifdef BRIDGE
761: (void) fclose (df);
762: (void) close (dd);
763: (void) ftp_reply ();
764: #else
765: if (errno != 0) {
766: dp -> ftd_type = DIAG_PERM;
767: dp -> ftd_identifier = FS_ACC_LCL;
768: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
769: dp -> ftd_delay = DIAG_NODELAY;
770: (void) sprintf (dp -> ftd_data, "%s: %s", myfile, sys_errname (errno));
771: dp -> ftd_cc = strlen (dp -> ftd_data);
772: dp++;
773:
774: goto error_return;
775:
776: }
777: (void) closedir (dd);
778: #endif
779:
780: if (n == OK)
781: n = de2fadu (NULLPE, 1);
782:
783: switch (n) {
784: case DONE:
785: return DONE;
786:
787: case OK:
788: default:
789: if (FDataEndRequest (ftamfd, FACTION_SUCCESS,
790: (struct FTAMdiagnostic *) 0, 0, fti) == NOTOK)
791: ftam_adios (fta, "F-DATA-END.REQUEST");
792: return OK;
793: }
794: }
795:
796: /* */
797:
798: static int de2fadu (pe, concat)
799: PE pe;
800: int concat;
801: {
802: struct FTAMindication ftis;
803: register struct FTAMindication *fti = &ftis;
804: register struct FTAMabort *fta = &fti -> fti_abort;
805: static int ninfo = 0;
806: static int size = 0;
807: static PE info[NPDATA];
808:
809: if (pe == NULLPE) {
810: if (concat
811: && ninfo > 0
812: && FDataRequest (ftamfd, info, ninfo, fti) == NOTOK)
813: ftam_adios (fta, "F-DATA.REQUEST");
814:
815: while (ninfo > 0)
816: pe_free (info[--ninfo]);
817: size = 0;
818:
819: return OK;
820: }
821:
822: if (concat) {
823: int flush,
824: n;
825:
826: if (size + (n = ps_get_abs (pe) + MAGIC_OCTET2) >= fadusize
827: && ninfo > 0) {
828: if (debug)
829: advise (LLOG_DEBUG, NULLCP,
830: "de2fadu flushing on %d FADUs, estimated size %d/%d",
831: ninfo, size, fadusize);
832:
833: (void) de2fadu (NULLPE, 1);
834: flush = 1;
835: }
836: else
837: flush = 0;
838:
839: info[ninfo++] = pe;
840: size += n;
841:
842: if (ninfo < NPDATA && size < fadusize) {
843: if (!flush)
844: return OK;
845: }
846: else {
847: if (FDataRequest (ftamfd, info, ninfo, fti) == NOTOK)
848: ftam_adios (fta, "F-DATA.REQUEST");
849:
850: while (ninfo > 0)
851: pe_free (info[--ninfo]);
852: size = 0;
853: }
854: }
855: else
856: if (FDataRequest (ftamfd, &pe, 1, fti) == NOTOK)
857: ftam_adios (fta, "F-DATA.REQUEST");
858:
859: if (FWaitRequest (ftamfd, OK, fti) == NOTOK) {
860: if (fta -> fta_peer
861: || fta -> fta_action != FACTION_TRANS
862: || fta -> fta_ndiag < 1
863: || fta -> fta_diags[0].ftd_type != DIAG_TRANS
864: || fta -> fta_diags[0].ftd_identifier != FS_PRO_TIMEOUT)
865: ftam_adios (fta, "F-WAIT.REQUEST");
866:
867: return OK;
868: }
869:
870: if (fti -> fti_type == FTI_CANCEL) {
871: register struct FTAMcancel *ftcn = &fti -> fti_cancel;
872:
873: advise (LLOG_NOTICE, NULLCP, "F-CANCEL.INDICATION: %d",
874: ftcn -> ftcn_action);
875: ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag);
876: FTCNFREE (ftcn);
877:
878: if (FCancelResponse (ftamfd, FACTION_SUCCESS, NULLPE,
879: (struct FTAMdiagnostic *) 0, 0, fti) == NOTOK)
880: ftam_adios (fta, "F-CANCEL.RESPONSE");
881: }
882:
883: return DONE;
884: }
885:
886: /* */
887:
888: int ftam_dataindication (px)
889: register struct PSAPdata *px;
890: {
891: register int i;
892: int effector,
893: n;
894: register PE pe,
895: *pep;
896: struct FTAMdiagnostic diags[NFDIAG];
897: register struct FTAMdiagnostic *dp = diags;
898: struct FTAMindication ftis;
899: register struct FTAMindication *fti = &ftis;
900:
901: effector = 1;
902: switch (myvf - vfs) {
903: case VFS_UBF:
904: default:
905: break;
906:
907: case VFS_UTF:
908: {
909: PElementID id;
910: register struct type_DOCS_FTAM__1__Parameters *p1 =
911: (struct type_DOCS_FTAM__1__Parameters *) myparam;
912:
913: if (p1 -> optionals
914: & opt_DOCS_FTAM__1__Parameters_universal__class__number)
915: id = (PElementID) p1 -> universal__class__number;
916: else
917: id = PE_DEFN_GFXS;
918: switch (id) {
919: case PE_DEFN_GFXS:
920: if (getenv ("HP-FTAM")) {
921: effector = 1;
922: break;
923: } /* else fall... */
924: case PE_DEFN_PRTS:
925: case PE_DEFN_VISS:
926: effector = 0;
927: break;
928:
929: case PE_DEFN_T61S:
930: case PE_DEFN_VTXS:
931: case PE_DEFN_IA5S:
932: case PE_DEFN_GENS:
933: effector = 1;
934: break;
935:
936: default:
937: break;
938: }
939: }
940: break;
941: }
942:
943: for (pep = px -> px_info, i = px -> px_ninfo - 1; i >= 0; pep++, i--) {
944: if ((pe = *pep) == NULLPE)
945: continue;
946:
947: switch (myvf - vfs) {
948: case VFS_UBF:
949: default:
950: if (debug)
951: WATCHP (DOCS_FTAM__3__Datatype1, pe, 1);
952: n = de2fd (myfd, pe, 0, 0);
953: break;
954:
955: case VFS_UTF:
956: if (debug)
957: WATCHP (DOCS_FTAM__1__Datatype1, pe, 1);
958: n = de2fd (myfd, pe, 1, effector);
959: break;
960: }
961:
962: if (n != NOTOK) {
963: nbytes += n;
964: continue;
965: }
966:
967: dp -> ftd_type = DIAG_PERM;
968: switch (errno) {
969: case ENOSPC:
970: dp -> ftd_identifier = FS_ACC_LCLSPACE;
971: dp -> ftd_cc = 0;
972: break;
973:
974: case EIO:
975: case ENXIO:
976: dp -> ftd_identifier = FS_ACC_LCLDEV;
977: dp -> ftd_cc = 0;
978: break;
979:
980: default:
981: dp -> ftd_identifier = FS_ACC_WRITE;
982: (void) strcpy (dp -> ftd_data, sys_errname (errno));
983: dp -> ftd_cc = strlen (dp -> ftd_data);
984: break;
985: }
986: dp -> ftd_observer = dp -> ftd_source = EREF_RFSU;
987: dp -> ftd_delay = DIAG_NODELAY;
988: dp++;
989:
990: if (FCancelRequest (ftamfd, FACTION_PERM, NULLPE, diags, dp - diags,
991: fti) == NOTOK)
992: ftam_adios (&fti -> fti_abort, "F-CANCEL-REQUEST");
993:
994: if (fti -> fti_type == FTI_CANCEL) {
995: register struct FTAMcancel *ftcn = &fti -> fti_cancel;
996:
997: advise (LLOG_NOTICE, NULLCP, "F-CANCEL.RESPONSE: %d",
998: ftcn -> ftcn_action);
999: ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag);
1000: FTCNFREE (ftcn);
1001: }
1002: break;
1003: }
1004:
1005: PXFREE (px);
1006: }
1007:
1008: /* */
1009:
1010: /* ARGSUSED */
1011:
1012: int ftam_dataendindication (ftda)
1013: struct FTAMdataend *ftda;
1014: {
1015: timer (nbytes, "received");
1016:
1017: #ifndef SYS5
1018: if (ftda -> ftda_action == FACTION_SUCCESS)
1019: (void) fsync (myfd);
1020: #endif
1021: }
1022:
1023: /* */
1024:
1025: int ftam_cancelindication (ftcn)
1026: register struct FTAMcancel *ftcn;
1027: {
1028: struct FTAMindication ftis;
1029: register struct FTAMindication *fti = &ftis;
1030:
1031: advise (LLOG_NOTICE, NULLCP, "F-CANCEL.INDICATION: %d",
1032: ftcn -> ftcn_action);
1033: ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag);
1034: FTCNFREE (ftcn);
1035:
1036: if (FCancelResponse (ftamfd, FACTION_SUCCESS, NULLPE,
1037: (struct FTAMdiagnostic *) 0, 0, fti) == NOTOK)
1038: ftam_adios (&fti -> fti_abort, "F-CANCEL.RESPONSE");
1039: }
1040:
1041: /* */
1042:
1043: /* ARGSUSED */
1044:
1045: int ftam_transendindication (ftre)
1046: struct FTAMtransend *ftre;
1047: {
1048: struct FTAMindication ftis;
1049: register struct FTAMindication *fti = &ftis;
1050:
1051: if (FTransEndResponse (ftamfd, FACTION_SUCCESS, NULLPE,
1052: (struct FTAMdiagnostic *) 0, 0, fti) == NOTOK)
1053: ftam_adios (&fti -> fti_abort, "F-TRANSFER-END.RESPONSE");
1054: }
1055:
1056: /* */
1057:
1058: int ftam_bulkendindication (ftg)
1059: struct FTAMgroup *ftg;
1060: {
1061: struct FTAMgroup ftms;
1062: struct FTAMgroup *ftm = &ftms;
1063: struct FTAMindication ftis;
1064: register struct FTAMindication *fti = &ftis;
1065:
1066: ftam_selection (ftg, ftm);
1067:
1068: if (myfd != NOTOK) {
1069: #ifdef BRIDGE
1070: (void) close (myfd);
1071: (void) ftp_reply ();
1072: #else
1073: unlock ();
1074: (void) close (myfd);
1075: #endif
1076: myfd = NOTOK;
1077: }
1078:
1079: if (FBulkEndResponse (ftamfd, ftm, fti) == NOTOK)
1080: ftam_adios (&fti -> fti_abort, "F-BULK-END.RESPONSE");
1081:
1082: FTGFREE (ftg);
1083: }
1084:
1085: /* */
1086:
1087: #ifndef NBBY
1088: #define NBBY 8
1089: #endif
1090:
1091:
1092: #ifndef TMS
1093: timer (cc, action)
1094: int cc;
1095: char *action;
1096: {
1097: long ms;
1098: float bs;
1099: struct timeval stop,
1100: td;
1101: static struct timeval start;
1102:
1103: if (cc == 0) {
1104: (void) gettimeofday (&start, (struct timezone *) 0);
1105: return;
1106: }
1107: else
1108: (void) gettimeofday (&stop, (struct timezone *) 0);
1109:
1110: tvsub (&td, &stop, &start);
1111: ms = (td.tv_sec * 1000) + (td.tv_usec / 1000);
1112: bs = (((float) cc * NBBY * 1000) / (float) (ms ? ms : 1)) / NBBY;
1113:
1114: advise (LLOG_NOTICE, NULLCP,
1115: "%d bytes %s in %d.%02d seconds (%.2f Kbytes/s)",
1116: cc, action, td.tv_sec, td.tv_usec / 10000, bs / 1024);
1117: }
1118:
1119:
1120: static tvsub (tdiff, t1, t0)
1121: register struct timeval *tdiff,
1122: *t1,
1123: *t0;
1124: {
1125:
1126: tdiff -> tv_sec = t1 -> tv_sec - t0 -> tv_sec;
1127: tdiff -> tv_usec = t1 -> tv_usec - t0 -> tv_usec;
1128: if (tdiff -> tv_usec < 0)
1129: tdiff -> tv_sec--, tdiff -> tv_usec += 1000000;
1130: }
1131:
1132: #else
1133: #ifndef HZ
1134: #define HZ 60
1135: #endif
1136:
1137:
1138: long times ();
1139:
1140:
1141: static timer (cc, action)
1142: int cc;
1143: char *action;
1144: {
1145: long ms;
1146: float bs;
1147: long stop,
1148: td,
1149: secs,
1150: msecs;
1151: struct tms tm;
1152: static long start;
1153:
1154: if (cc == 0) {
1155: start = times (&tm);
1156: return;
1157: }
1158: else
1159: stop = times (&tm);
1160:
1161: td = stop - start;
1162: secs = td / HZ, msecs = (td % HZ) * 1000 / HZ;
1163: ms = (secs * 1000) + msecs;
1164: bs = (((float) cc * NBBY * 1000) / (float) (ms ? ms : 1)) / NBBY;
1165:
1166: advise (LLOG_NOTICE, NULLCP,
1167: "%d bytes %s in %d.%02d seconds (%.2f Kbytes/s)",
1168: cc, action, secs, msecs / 10, bs / 1024);
1169: }
1170: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.