![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xnftp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / xns / examples / filing|
Return to xnftp.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / xns / examples / filing |
1.1 ! root 1: #ifndef lint ! 2: static char *rcsid = "$Header: xnftp.c,v 2.0 85/11/21 07:22:51 jqj Exp $"; ! 3: #endif lint ! 4: ! 5: /* $Log: xnftp.c,v $ ! 6: * Revision 2.0 85/11/21 07:22:51 jqj ! 7: * 4.3BSD standard release ! 8: * ! 9: * Revision 1.5 85/09/24 14:45:10 jqj ! 10: * fix bug in alarm() handling that caused aborts during large file transfers. ! 11: * ! 12: * Revision 1.4 85/09/17 07:49:47 jqj ! 13: * 4.3 changes. Use more routines from CHlookup ! 14: * ! 15: * Revision 1.1 85/05/27 06:31:07 jqj ! 16: * Initial revision ! 17: * ! 18: */ ! 19: ! 20: #include <stdio.h> ! 21: #include <sys/time.h> ! 22: #include <sys/param.h> ! 23: #include <sys/stat.h> ! 24: #include <netns/ns.h> ! 25: #include <netns/sp.h> ! 26: #include "ftp_var.h" ! 27: #include <xnscourier/CH.h> ! 28: ! 29: CourierConnection *connected; ! 30: Clearinghouse2_ObjectName hostobjname; ! 31: Authentication1_Verifier verifier; ! 32: ! 33: /* the following 3 items make up the current session */ ! 34: Filing4_Session session; /* the current session */ ! 35: Clearinghouse2_ObjectName username; ! 36: int continuetime; ! 37: int remoteprocpending; ! 38: Filing4_Handle wdHandle; /* the current remote working dir */ ! 39: ! 40: static Filing4_ControlSequence nullControls = {0,0}; ! 41: static Filing4_ScopeSequence nullScope = {0,0}; ! 42: ! 43: /* global data used to communicate with BDT procedures ! 44: */ ! 45: extern GetAttributeSequences(), ! 46: listproc(), nlistproc(), ! 47: storeproc(), retrieveproc(); ! 48: static (*ProcEachSeq)(); ! 49: static long bytessent; ! 50: static FILE *fout, *fin; ! 51: ! 52: copyhandle(dest,src) ! 53: Filing4_Handle dest,src; ! 54: { ! 55: if (dest == (Unspecified *) 0) { ! 56: fprintf(stderr,"Oops. dest is null in copyhandle\n"); ! 57: exit(1); ! 58: } ! 59: dest[0] = src[0]; ! 60: dest[1] = src[1]; ! 61: } ! 62: ! 63: StringToAttr(str, attr) ! 64: char *str; ! 65: Filing4_Attribute *attr; ! 66: { ! 67: Unspecified buf[2049], *bp; ! 68: Cardinal len; ! 69: ! 70: bp = buf + sizeof_Cardinal(len); ! 71: len = externalize_String(&str, bp); ! 72: (void) externalize_Cardinal(&len, buf); ! 73: internalize_Clearinghouse2_Item(&(attr->value), buf); ! 74: return; ! 75: } ! 76: ! 77: char * ! 78: AttrToString(attr) ! 79: Filing4_Attribute *attr; ! 80: { ! 81: Unspecified buf[2049], *bp; ! 82: Cardinal len; ! 83: char *strval; ! 84: ! 85: externalize_Clearinghouse2_Item(&(attr->value), buf); ! 86: bp = buf; ! 87: bp += internalize_Cardinal(&len, bp); ! 88: bp += internalize_String(&strval, bp); ! 89: return(strval); ! 90: } ! 91: ! 92: UserToAttr(id, attr) ! 93: Clearinghouse2_Name id; ! 94: Filing4_Attribute *attr; ! 95: { ! 96: Unspecified buf[2049], *bp; ! 97: Cardinal len; ! 98: ! 99: bp = buf + sizeof_Cardinal(len); ! 100: len = externalize_Clearinghouse2_Name(&id, bp); ! 101: (void) externalize_Cardinal(&len, buf); ! 102: internalize_Clearinghouse2_Item(&(attr->value), buf); ! 103: return; ! 104: } ! 105: ! 106: LongCardinalToAttr(val, attr) ! 107: LongCardinal val; ! 108: Filing4_Attribute *attr; ! 109: { ! 110: Unspecified buf[3], *bp; ! 111: Cardinal len; ! 112: ! 113: bp = buf + sizeof_Cardinal(len); ! 114: len = externalize_LongCardinal(&val, bp); ! 115: (void) externalize_Cardinal(&len, buf); ! 116: internalize_Clearinghouse2_Item(&(attr->value), buf); ! 117: return; ! 118: } ! 119: ! 120: BooleanToAttr(val, attr) ! 121: int val; ! 122: Filing4_Attribute *attr; ! 123: { ! 124: Boolean boolval; ! 125: Unspecified buf[3], *bp; ! 126: Cardinal len; ! 127: ! 128: boolval = (Boolean) val; ! 129: bp = buf + sizeof_Cardinal(len); ! 130: len = externalize_Boolean(&boolval, bp); ! 131: (void) externalize_Cardinal(&len, buf); ! 132: internalize_Clearinghouse2_Item(&(attr->value), buf); ! 133: return; ! 134: } ! 135: ! 136: int ! 137: AttrToBoolean(attr) ! 138: Filing4_Attribute *attr; ! 139: { ! 140: Unspecified buf[1]; ! 141: Boolean result; ! 142: ! 143: (void) externalize_Unspecified(attr->value.sequence, buf); ! 144: (void) internalize_Boolean(&result, buf); ! 145: return(result); ! 146: } ! 147: ! 148: LongCardinal ! 149: AttrToLongCardinal(attr) ! 150: Filing4_Attribute *attr; ! 151: { ! 152: Unspecified buf[2]; ! 153: LongCardinal result; ! 154: ! 155: (void) externalize_Unspecified(attr->value.sequence, buf); ! 156: (void) externalize_Unspecified((attr->value.sequence)+1, buf+1); ! 157: (void) internalize_LongCardinal(&result, buf); ! 158: return(result); ! 159: } ! 160: ! 161: ! 162: getfilehandle(filename, handle) ! 163: char *filename; ! 164: Filing4_Handle handle; ! 165: { ! 166: Filing4_Attribute pathattr[1]; ! 167: Filing4_AttributeSequence attrseq; ! 168: Filing4_OpenResults openresult; ! 169: ! 170: if (filename == (char *)0 || *filename == '\000') { ! 171: copyhandle(handle,wdHandle); ! 172: return; ! 173: } ! 174: attrseq.length = 1; ! 175: attrseq.sequence = pathattr; ! 176: pathattr[0].type = Filing4_pathname; ! 177: copyhandle(handle, Filing4_nullHandle); ! 178: if (*filename != '/') { /* relative pathname specified */ ! 179: StringToAttr(filename, &pathattr[0]); ! 180: copyhandle(handle, wdHandle); ! 181: } else if (filename[1] == '\000') { ! 182: /* root specified */ ! 183: attrseq.length = 0; ! 184: } else { /* absolute pathname specified */ ! 185: StringToAttr(filename+1, &pathattr[0]); ! 186: } ! 187: alarm(0); ! 188: openresult = Filing4_Open(connected, NULL, attrseq, ! 189: handle, nullControls, ! 190: session); ! 191: alarm(continuetime); ! 192: copyhandle(handle, openresult.file); ! 193: } ! 194: ! 195: freefilehandle(handle) ! 196: Filing4_Handle handle; ! 197: { ! 198: if (handle[0] == Filing4_nullHandle[0] && ! 199: handle[1] == Filing4_nullHandle[1]) ! 200: return; /* don't free nullHandle */ ! 201: if (handle[0] == wdHandle[0] && ! 202: handle[1] == wdHandle[1]) ! 203: return; /* don't free working directory */ ! 204: alarm(0); ! 205: Filing4_Close(connected, NULL, handle, session); ! 206: alarm(continuetime); ! 207: } ! 208: ! 209: /* ! 210: * do a continue to make sure that the session doesn't time out. ! 211: * Note that this is usually called by an ALARM interrupt ! 212: */ ! 213: probe() ! 214: { ! 215: Filing4_ContinueResults cresult; ! 216: ! 217: alarm(0); /* cancel previous alarms */ ! 218: cresult = Filing4_Continue(connected, NULL, session); ! 219: continuetime = cresult.continuance / 5; /* seconds */ ! 220: alarm(continuetime); /* reset for another 2 min. or so */ ! 221: } ! 222: ! 223: CourierConnection * ! 224: hookup(name) ! 225: char *name; ! 226: { ! 227: register struct ns_addr *hostaddr; ! 228: extern struct ns_addr *getXNSaddr(); ! 229: Clearinghouse2_ObjectName defaultobjname; ! 230: static char hnamebuf[128]; ! 231: CourierConnection *cconn; ! 232: ! 233: CH_NameDefault(&defaultobjname); ! 234: hostobjname = CH_StringToName(name, &defaultobjname); ! 235: if ((hostaddr = CH_LookupAddrDN( hostobjname, 0, hnamebuf, 128))) { ! 236: /* should check here to be sure host is a file service */ ! 237: hostaddr->x_port = htons(IDPPORT_COURIER); /* ?? */ ! 238: cconn = CourierOpen(hostaddr); ! 239: /* reset objname to flush wildcards */ ! 240: /* clear_Clearinghouse2_ThreePartName(&hostobjname); */ ! 241: hostobjname = CH_StringToName(hnamebuf, &defaultobjname); ! 242: hostname = hnamebuf; ! 243: if (verbose) ! 244: printf("Connected to %s\n", hnamebuf); ! 245: } else { ! 246: printf("%s: unknown host\n", name); ! 247: cconn = (CourierConnection*)0; ! 248: } ! 249: return(cconn); ! 250: } ! 251: ! 252: ! 253: login(name,pwd) ! 254: char *pwd; ! 255: char *name; ! 256: { ! 257: Authentication1_Credentials credentials; ! 258: Filing4_LogonResults logonresult; ! 259: ! 260: username = CH_StringToName(name,&hostobjname); ! 261: MakeSimpleCredsAndVerifier(&username,pwd, ! 262: &credentials, &verifier); ! 263: logonresult = Filing4_Logon(connected, NULL, hostobjname, ! 264: credentials, verifier); ! 265: session = logonresult.session; ! 266: copyhandle(wdHandle, Filing4_nullHandle); ! 267: if (verbose) ! 268: printf("User %s:%s:%s logged on\n", username.object, ! 269: username.domain, username.organization); ! 270: alarm(0); ! 271: signal(SIGALRM, probe); ! 272: probe(); ! 273: } ! 274: ! 275: logout() ! 276: { ! 277: signal(SIGALRM, SIG_IGN); ! 278: Filing4_Logoff(connected, NULL, session); ! 279: clear_Filing4_Session(&session); ! 280: copyhandle(wdHandle, Filing4_nullHandle); ! 281: } ! 282: ! 283: domakedir(dest) ! 284: char *dest; ! 285: { ! 286: sendrequest("MKDIR", "-", dest); ! 287: } ! 288: ! 289: doremovedir(src) ! 290: char *src; ! 291: { ! 292: dodelete(src); ! 293: } ! 294: ! 295: dostore(src, dest) ! 296: char *src, *dest; ! 297: { ! 298: sendrequest("STOR", src, dest); ! 299: } ! 300: ! 301: doappend(src, dest) ! 302: char *src, *dest; ! 303: { ! 304: NYI(); ! 305: } ! 306: ! 307: dorename(src, dest) ! 308: char *src, *dest; ! 309: { ! 310: NYI(); ! 311: } ! 312: ! 313: recvrequest(cmd, local, remote, mode) ! 314: char *cmd, *local, *remote, *mode; ! 315: { ! 316: FILE *popen(); ! 317: int (*closefunc)(), pclose(), fclose(); ! 318: struct timeval start, stop; ! 319: Filing4_Handle remotehandle; /* note: an array */ ! 320: Filing4_AttributeTypeSequence typeseq; ! 321: Filing4_AttributeType tsvals[10]; ! 322: ! 323: closefunc = NULL; ! 324: fout = stdout; ! 325: typeseq.length = 0; typeseq.sequence = tsvals; ! 326: if (strcmp(local, "-") && *local != '|') ! 327: if (access(local, 2) < 0) { ! 328: char *dir = rindex(local, '/'); ! 329: /* get a good error message */ ! 330: if (dir != NULL) *dir = '\0'; ! 331: if (access(dir ? local : ".", 2) < 0) { ! 332: perror(local); ! 333: goto bad; ! 334: } ! 335: if (dir != NULL) *dir = '/'; ! 336: } ! 337: if (strcmp(local, "-") == 0) ! 338: fout = stdout; ! 339: else if (*local == '|') { ! 340: fout = popen(local + 1, "w"); ! 341: if (fout == NULL) { ! 342: perror(local + 1); ! 343: goto bad; ! 344: } ! 345: closefunc = pclose; ! 346: } else { ! 347: fout = fopen(local, mode); ! 348: if (fout == NULL) { ! 349: perror(local); ! 350: goto bad; ! 351: } ! 352: closefunc = fclose; ! 353: } ! 354: bytessent = 0; ! 355: gettimeofday(&start, (struct timezone *)0); ! 356: getfilehandle(remote, remotehandle); ! 357: alarm(0); ! 358: if (strcmp(cmd,"NLST") == 0) { ! 359: typeseq.length = 1; ! 360: typeseq.sequence[0] = Filing4_pathname; ! 361: ProcEachSeq = nlistproc; ! 362: Filing4_List(connected, GetAttributeSequences, remotehandle, ! 363: typeseq, nullScope, ! 364: BulkData1_immediateSink, session); ! 365: } ! 366: else if (strcmp(cmd,"LIST") == 0) { ! 367: typeseq.length = 5; ! 368: typeseq.sequence[0] = Filing4_name; ! 369: typeseq.sequence[1] = Filing4_dataSize; ! 370: typeseq.sequence[2] = Filing4_isDirectory; ! 371: typeseq.sequence[3] = Filing4_isTemporary; ! 372: typeseq.sequence[4] = Filing4_type; ! 373: ProcEachSeq = listproc; ! 374: Filing4_List(connected, GetAttributeSequences, remotehandle, ! 375: typeseq, nullScope, ! 376: BulkData1_immediateSink, session); ! 377: } ! 378: else if (strcmp(cmd,"RETR") == 0) { ! 379: Filing4_Retrieve(connected, retrieveproc, remotehandle, ! 380: BulkData1_immediateSink, session); ! 381: } ! 382: else printf("unrecognized command %s\n",cmd); ! 383: alarm(continuetime); ! 384: gettimeofday(&stop, (struct timezone *)0); ! 385: freefilehandle(remotehandle); ! 386: if (bytessent > 0 && verbose) ! 387: ptransfer("received", bytessent, &start, &stop); ! 388: bad: ! 389: if (closefunc != NULL && fout != NULL) ! 390: (*closefunc)(fout); ! 391: fout = NULL; ! 392: } ! 393: ! 394: ! 395: sendrequest(cmd, local, remote) ! 396: char *cmd, *local, *remote; ! 397: { ! 398: FILE *popen(); ! 399: int (*closefunc)(), pclose(), fclose(); ! 400: struct stat st; ! 401: struct timeval start, stop; ! 402: Filing4_StoreResults storeresults; ! 403: Filing4_CreateResults createresults; ! 404: Filing4_Handle remotehandle; ! 405: Filing4_AttributeSequence attrseq; ! 406: Filing4_Attribute attrvals[5]; ! 407: ! 408: closefunc = NULL; ! 409: if (strcmp(local, "-") == 0) { ! 410: fin = stdin; ! 411: closefunc = NULL; ! 412: } else if (*local == '|') { ! 413: fin = popen(local + 1, "r"); ! 414: if (fin == NULL) { ! 415: perror(local + 1); ! 416: goto bad; ! 417: } ! 418: closefunc = pclose; ! 419: } else { ! 420: fin = fopen(local, "r"); ! 421: if (fin == NULL) { ! 422: perror(local); ! 423: goto bad; ! 424: } ! 425: closefunc = fclose; ! 426: if (fstat(fileno(fin), &st) < 0 || ! 427: (st.st_mode&S_IFMT) != S_IFREG) { ! 428: fprintf(stderr, "%s: not a plain file.", local); ! 429: goto bad; ! 430: } ! 431: } ! 432: if (remote) { ! 433: char *dir = rindex(remote,'/'); ! 434: if (dir != NULL) { ! 435: *dir = '\000'; ! 436: getfilehandle(remote, remotehandle); ! 437: *dir = '/'; ! 438: remote = dir+1; ! 439: } else { ! 440: getfilehandle("", remotehandle); ! 441: } ! 442: } else { ! 443: printf("No remote name specified\n"); ! 444: return; ! 445: } ! 446: bytessent = 0; ! 447: gettimeofday(&start, (struct timezone *)0); ! 448: alarm(0); ! 449: if (strcmp(cmd,"STOR") == 0) { ! 450: attrseq.length = 2; ! 451: attrseq.sequence = attrvals; ! 452: attrvals[0].type = Filing4_name; ! 453: StringToAttr(remote, &attrvals[0]); ! 454: attrvals[1].type = Filing4_type; ! 455: if (typevalue == TYPE_A) ! 456: LongCardinalToAttr(Filing4_tText, &attrvals[1]); ! 457: else ! 458: LongCardinalToAttr(Filing4_tUnspecified, &attrvals[1]); ! 459: storeresults = Filing4_Store(connected, storeproc, ! 460: remotehandle, attrseq, ! 461: nullControls, ! 462: BulkData1_immediateSource, ! 463: session); ! 464: alarm(continuetime); ! 465: freefilehandle(storeresults.file); ! 466: } ! 467: else if (strcmp(cmd,"MKDIR") == 0) { ! 468: attrseq.length = 3; ! 469: attrseq.sequence = attrvals; ! 470: attrvals[0].type = Filing4_name; ! 471: StringToAttr(remote, &attrvals[0]); ! 472: attrvals[1].type = Filing4_isDirectory; ! 473: BooleanToAttr(1, &attrvals[1]); ! 474: attrvals[2].type = Filing4_type; ! 475: LongCardinalToAttr(Filing4_tDirectory, &attrvals[2]); ! 476: createresults = Filing4_Create(connected, NULL, ! 477: remotehandle, attrseq, ! 478: nullControls, session); ! 479: alarm(continuetime); ! 480: freefilehandle(createresults.file); ! 481: } ! 482: else { ! 483: printf("unrecognized command %s\n",cmd); ! 484: alarm(continuetime); ! 485: } ! 486: gettimeofday(&stop, (struct timezone *)0); ! 487: freefilehandle(remotehandle); ! 488: if (bytessent > 0 && verbose) ! 489: ptransfer("sent", bytessent, &start, &stop); ! 490: bad: ! 491: if (closefunc != NULL && fin != NULL) ! 492: (*closefunc)(fin); ! 493: fin = NULL; ! 494: } ! 495: ! 496: ! 497: ! 498: docd(dest) ! 499: char *dest; ! 500: { ! 501: Filing4_AttributeSequence attrseq; ! 502: Filing4_AttributeTypeSequence typeseq; ! 503: Filing4_AttributeType cdattrs[1]; ! 504: Filing4_GetAttributesResults garesult; ! 505: Filing4_Handle remotehandle, temphandle; ! 506: char trydest[100]; ! 507: int i; ! 508: ! 509: if (dest == (char*)NULL || *dest == '\0') { ! 510: trydest[0] = '/'; /* assume absolute pathname */ ! 511: strcpy(trydest+1,username.object); ! 512: getfilehandle(trydest, remotehandle); ! 513: } ! 514: else ! 515: getfilehandle(dest, remotehandle); ! 516: typeseq.length = 1; typeseq.sequence = cdattrs; ! 517: cdattrs[0] = Filing4_isDirectory; ! 518: alarm(0); ! 519: garesult = Filing4_GetAttributes(connected, NULL, remotehandle, ! 520: typeseq, session); ! 521: alarm(continuetime); ! 522: for (i = 0; i < garesult.attributes.length; i++) { ! 523: if (garesult.attributes.sequence[i].type == Filing4_isDirectory ! 524: && AttrToBoolean(&(garesult.attributes.sequence[i]))) { ! 525: copyhandle(temphandle, wdHandle); ! 526: copyhandle(wdHandle, remotehandle); /* change dir */ ! 527: if (verbose) dopwd(); ! 528: freefilehandle(temphandle); /* free old wdHandle */ ! 529: return; ! 530: } ! 531: } ! 532: printf("%s is not a directory\n", dest); ! 533: freefilehandle(remotehandle); ! 534: } ! 535: ! 536: dopwd() ! 537: { ! 538: Filing4_AttributeSequence attrseq; ! 539: Filing4_AttributeTypeSequence typeseq; ! 540: Filing4_AttributeType pwdattrs[1]; ! 541: Filing4_GetAttributesResults garesult; ! 542: ! 543: if (wdHandle[0] == 0 && wdHandle[1] == 0) { ! 544: printf("Remote working directory: /\n"); ! 545: return; ! 546: } ! 547: typeseq.length = 1; typeseq.sequence = pwdattrs; ! 548: pwdattrs[0] = Filing4_pathname; ! 549: alarm(0); ! 550: garesult = Filing4_GetAttributes(connected, NULL, wdHandle, typeseq, ! 551: session); ! 552: alarm(continuetime); ! 553: if (garesult.attributes.length > 0 && ! 554: garesult.attributes.sequence[0].type == Filing4_pathname) ! 555: printf("Remote working directory: /%s\n", ! 556: AttrToString(&(garesult.attributes.sequence[0]))); ! 557: else printf("Remote working directory not set\n"); ! 558: clear_Filing4_GetAttributesResults(&garesult); ! 559: } ! 560: ! 561: dodelete(src) ! 562: char *src; ! 563: { ! 564: Filing4_Handle remotehandle; ! 565: Filing4_AttributeSequence attrseq; ! 566: Filing4_AttributeTypeSequence typeseq; ! 567: Filing4_AttributeType delattrs[1]; ! 568: Filing4_GetAttributesResults garesult; ! 569: ! 570: typeseq.length = 1; typeseq.sequence = delattrs; ! 571: delattrs[0] = Filing4_isDirectory; ! 572: getfilehandle(src, remotehandle); ! 573: garesult = Filing4_GetAttributes(connected, NULL, remotehandle, ! 574: typeseq, session); ! 575: if (garesult.attributes.length > 0 && ! 576: garesult.attributes.sequence[0].type == Filing4_isDirectory && ! 577: AttrToBoolean(&(garesult.attributes.sequence[0]))) { ! 578: if (!confirm("Delete directory", src)) return; ! 579: } ! 580: ! 581: clear_Filing4_GetAttributesResults(&garesult); ! 582: alarm(0); ! 583: Filing4_Delete(connected, NULL, remotehandle, session); ! 584: alarm(continuetime); ! 585: } ! 586: ! 587: NYI() ! 588: { ! 589: printf("Not yet implemented\n"); ! 590: } ! 591: ! 592: ! 593: ptransfer(direction, bytes, t0, t1) ! 594: char *direction; ! 595: long bytes; ! 596: struct timeval *t0, *t1; ! 597: { ! 598: struct timeval td; ! 599: long ms; ! 600: float bs; ! 601: ! 602: tvsub(&td, t1, t0); ! 603: ms = (td.tv_sec * 1000) + (td.tv_usec / 1000); ! 604: #define nz(x) ((x) == 0 ? 1 : (x)) ! 605: bs = ((1000. * (float) bytes) / (float) nz(ms)); ! 606: printf("\n%ld bytes %s in %d.%02d seconds (%.2g Kbytes/s)\n", ! 607: bytes, direction, td.tv_sec, td.tv_usec / 10000, bs / 1024.); ! 608: } ! 609: ! 610: tvadd(tsum, t0) ! 611: struct timeval *tsum, *t0; ! 612: { ! 613: ! 614: tsum->tv_sec += t0->tv_sec; ! 615: tsum->tv_usec += t0->tv_usec; ! 616: if (tsum->tv_usec > 1000000) ! 617: tsum->tv_sec++, tsum->tv_usec -= 1000000; ! 618: } ! 619: ! 620: tvsub(tdiff, t1, t0) ! 621: struct timeval *tdiff, *t1, *t0; ! 622: { ! 623: ! 624: tdiff->tv_sec = t1->tv_sec - t0->tv_sec; ! 625: tdiff->tv_usec = t1->tv_usec - t0->tv_usec; ! 626: if (tdiff->tv_usec < 0) ! 627: tdiff->tv_sec--, tdiff->tv_usec += 1000000; ! 628: } ! 629: ! 630: nlistproc(attr) ! 631: Filing4_AttributeSequence attr; ! 632: { ! 633: int i; ! 634: char *thisname; ! 635: Filing4_AttributeType t; ! 636: ! 637: for (i = 0; i < attr.length; i++) { ! 638: t = attr.sequence[i].type; ! 639: if (t == Filing4_pathname) fputc('/', fout); ! 640: if (t == Filing4_name || ! 641: t == Filing4_pathname) { ! 642: thisname = AttrToString(&attr.sequence[i]); ! 643: fputs(thisname, fout); ! 644: fputc('\n', fout); ! 645: clear_String(&thisname); ! 646: return; ! 647: } ! 648: } ! 649: } ! 650: ! 651: ! 652: listproc(attr) ! 653: Filing4_AttributeSequence attr; ! 654: { ! 655: int i; ! 656: char *thisname = ""; ! 657: Boolean istemp = 0; ! 658: Boolean isdir = 0; ! 659: LongCardinal thistype = 0; ! 660: LongCardinal thissize = 0; ! 661: Filing4_AttributeType t; ! 662: char *filetypestr; ! 663: char filetypebuf[20]; ! 664: ! 665: for (i = 0; i < attr.length; i++) { ! 666: t = attr.sequence[i].type; ! 667: if (t == Filing4_name || ! 668: t == Filing4_pathname) ! 669: thisname = AttrToString(&attr.sequence[i]); ! 670: else if (t == Filing4_isDirectory) ! 671: isdir = AttrToBoolean(&attr.sequence[i]); ! 672: else if (t == Filing4_isTemporary) ! 673: istemp = AttrToBoolean(&attr.sequence[i]); ! 674: else if (t == Filing4_type) ! 675: thistype = AttrToLongCardinal(&attr.sequence[i]); ! 676: else if (t == Filing4_dataSize) ! 677: thissize = AttrToLongCardinal(&attr.sequence[i]); ! 678: } ! 679: ! 680: if (thistype == Filing4_tDirectory) ! 681: filetypestr = "(dir.)"; ! 682: else if (thistype == Filing4_tText) ! 683: filetypestr = "(text)"; ! 684: else if (thistype == Filing4_tSerialized) ! 685: filetypestr = "(ser.)"; ! 686: else if (thistype == 4353) ! 687: filetypestr = "(Star)"; ! 688: else if (thistype != Filing4_tUnspecified) { ! 689: sprintf(filetypebuf, "(%ld)", thistype); ! 690: filetypestr = filetypebuf; ! 691: } ! 692: else filetypestr = ""; ! 693: fprintf(fout, "%c%c%-6s%7ld %s\n", ! 694: isdir?'D':' ', istemp?'T':' ', ! 695: filetypestr, thissize, thisname); ! 696: clear_String(&thisname); ! 697: } ! 698: ! 699: #define MAXPACKS 20 ! 700: static ! 701: GetAttributeSequences(conn) ! 702: CourierConnection *conn; ! 703: { ! 704: int count, i; ! 705: Unspecified buffer[MAXWORDS*MAXPACKS], *bp, *bufend; ! 706: Filing4_StreamOfAttributeSequence attrs; ! 707: ! 708: bufend = buffer; ! 709: bp = buffer+((MAXWORDS-1)*MAXPACKS); /* end of available space */ ! 710: while ((count = BDTread(conn, (char*)bufend, ! 711: MAXWORDS*sizeof(Unspecified))) > 0) { ! 712: bufend += count/sizeof(Unspecified); ! 713: bytessent += count; ! 714: if (bufend > bp) { ! 715: fprintf(stderr,"BDT read too big to fit\n"); ! 716: BDTabort(conn); ! 717: /* should clear out stuff here if we knew how much */ ! 718: } ! 719: } ! 720: bp = buffer; ! 721: while (bp < bufend) { ! 722: bp += internalize_Filing4_StreamOfAttributeSequence(&attrs,bp); ! 723: if (0 == (int) attrs.designator) { ! 724: for (i=0; i < attrs.nextSegment_case.segment.length; i++) { ! 725: (*ProcEachSeq)( ! 726: attrs.nextSegment_case.segment.sequence[i]); ! 727: } ! 728: free(attrs.nextSegment_case.segment.sequence); ! 729: } else { ! 730: for (i = 0; i < attrs.lastSegment_case.length; i++) { ! 731: (*ProcEachSeq)( ! 732: attrs.lastSegment_case.sequence[i]); ! 733: } ! 734: free(attrs.lastSegment_case.sequence); ! 735: return; ! 736: } ! 737: } ! 738: } ! 739: ! 740: int ! 741: getBDTch(conn,bpp) ! 742: CourierConnection *conn; ! 743: u_char **bpp; ! 744: { ! 745: static u_char buffer[SPPMAXDATA]; ! 746: static int count; ! 747: ! 748: if (*bpp == NULL) {*bpp = buffer; count = 0;} ! 749: if (*bpp >= buffer+count) { ! 750: count=BDTread(conn,buffer,sizeof(buffer)); ! 751: *bpp = buffer; ! 752: } ! 753: if (count <= 0) return(EOF); ! 754: else return(*((*bpp)++)); ! 755: ! 756: } ! 757: ! 758: retrieveproc(conn) ! 759: CourierConnection *conn; ! 760: { ! 761: int count, ocount, ch, hashbytes; ! 762: char buffer[SPPMAXDATA]; ! 763: int charset, charset16; ! 764: char *bp; ! 765: ! 766: switch (typevalue) { ! 767: default: ! 768: fprintf(stderr,"We don't support type %s. Using binary\n", ! 769: typename); ! 770: case TYPE_I: ! 771: case TYPE_L: ! 772: errno = ocount = 0; ! 773: fflush(fout); ! 774: while ((count = BDTread(conn, buffer, sizeof(buffer))) > 0) { ! 775: if ((ocount = write(fileno(fout),buffer,count)) < 0) { ! 776: perror("write"); ! 777: BDTabort(conn); ! 778: break; ! 779: } ! 780: bytessent += count; ! 781: if (hash) { ! 782: putchar('#'); ! 783: fflush(stdout); ! 784: } ! 785: } ! 786: if (count < 0) perror("netin"); ! 787: break; ! 788: ! 789: case TYPE_A: ! 790: charset = 0; charset16 = 0; bp = NULL; ! 791: hashbytes = 0; ! 792: while ((ch = getBDTch(conn,&bp)) != EOF) { ! 793: if (ch == '\377') { ! 794: ch = getBDTch(conn,&bp); ! 795: if (ch == '\377') charset16 = 1; ! 796: else charset = ch; ! 797: continue; ! 798: } ! 799: if (charset16) { ! 800: charset = ch; ! 801: ch = getBDTch(conn,&bp); ! 802: } ! 803: switch (charset) { ! 804: case 0: /* normal character set -- minimal xlation */ ! 805: if (ch == '\r') { ! 806: ch = '\n'; ! 807: while (hash && bytessent >= hashbytes){ ! 808: putchar('#'); ! 809: fflush(stdout); ! 810: hashbytes += sizeof(buffer); ! 811: } ! 812: } ! 813: else if (ch == ','+0200) ch = '_'; ! 814: /* more mapping here */ ! 815: putc(ch,fout); ! 816: bytessent++; ! 817: break; ! 818: default: ! 819: break; /* ignore */ ! 820: } ! 821: } ! 822: if (hash) { ! 823: while (bytessent < hashbytes) { ! 824: putchar('#'); ! 825: hashbytes += sizeof(buffer); ! 826: } ! 827: putchar('\n'); ! 828: fflush(stdout); ! 829: } ! 830: /* if (count < 0) perror("netin"); */ ! 831: break; ! 832: } ! 833: } ! 834: ! 835: storeproc(conn) ! 836: CourierConnection *conn; ! 837: { ! 838: int count, ocount; ! 839: u_char buffer[SPPMAXDATA]; ! 840: u_char *bp; ! 841: ! 842: errno = ocount = 0; ! 843: clearerr(fin); ! 844: switch (typevalue) { ! 845: default: ! 846: fprintf(stderr,"We don't support type %s. Using binary\n", ! 847: typename); ! 848: case TYPE_I: ! 849: case TYPE_L: ! 850: while ((count = fread(buffer,sizeof(char),SPPMAXDATA,fin)) > 0 ! 851: && (ocount = BDTwrite(conn, buffer, count)) > 0) { ! 852: bytessent += count; ! 853: if (hash) { ! 854: putchar('#'); ! 855: fflush(stdout); ! 856: } ! 857: } ! 858: break; ! 859: case TYPE_A: ! 860: while ((count = fread(buffer,sizeof(char),SPPMAXDATA,fin)) ! 861: > 0) { ! 862: ocount = count; ! 863: for (bp = buffer; count > 0; count--, bp++) { ! 864: if (*bp == '\n') *bp = '\r'; ! 865: else if (*bp == '_') *bp = ','+0200; ! 866: /* more translations here */ ! 867: } ! 868: if ((ocount = BDTwrite(conn, buffer, ocount)) <= 0) ! 869: break; ! 870: bytessent += ocount; ! 871: if (hash) { ! 872: putchar('#'); ! 873: fflush(stdout); ! 874: } ! 875: } ! 876: break; ! 877: } ! 878: if (ocount < 0) { ! 879: BDTabort(conn); ! 880: perror("netout"); ! 881: } ! 882: else if (ferror(fin)) { ! 883: BDTabort(conn); ! 884: perror("fread"); ! 885: } ! 886: else ! 887: BDTclosewrite(conn); ! 888: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.