![[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.