![[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] / 43BSDTahoe / new / xns / examples / filing_client|
Return to xnftp.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / examples / filing_client |
1.1 root 1: #ifndef lint
2: static char *rcsid = "$Header: xnftp.c,v 2.13 87/05/28 14:17:14 ed Exp $";
3: #endif lint
4:
5: /* $Log: xnftp.c,v $
6: * Revision 2.13 87/05/28 14:17:14 ed
7: * I botched the compiler bug fix...
8: *
9: * Revision 2.12 87/05/14 11:37:34 ed
10: * Raise error from hookup if connection not established.
11: * Better handling of truncated bulk data stream when it overflows buffer.
12: *
13: * Revision 2.11 87/05/11 14:40:12 ed
14: * Incorporated changes from JQ's 4.3e version.
15: *
16: * Revision 2.11 87/03/08 07:09:53 jqj
17: * work around "schain botch" 4.3BSD VAX compiler bug (from Scooter Morris).
18: *
19: * Revision 2.10 87/05/05 14:49:00 ed
20: * Move alarm setting/resetting closer to actual procedure calls.
21: *
22: * Revision 2.9 87/04/16 15:23:47 ed
23: * Fixed lingering bugs in Subset pathname usage.
24: *
25: * Revision 2.8 87/04/01 09:33:36 ed
26: * Changed for new MakeSecondaryCreds call.
27: * Reset connection on login failure.
28: *
29: * Revision 2.7 87/03/27 15:19:19 ed
30: * Don't assume secondary username is primary name.
31: * Additional check for underscore translation on text files.
32: *
33: * Revision 2.6 87/03/23 12:32:12 ed
34: * allow round-trip transfer of Viewpoint files, retain/specify uninterpreted
35: * attributes.
36: * Serialization/Deserialization of directories from server.
37: * Wildcard deletion.
38: * Compatibility with XDE MFileServer.
39: * New commands: Archive, Restore, Unify.
40: *
41: * Revision 2.5 87/01/14 15:59:29 ed
42: * Use FilingSubset, if rejected attempt Filing
43: * Allows user override with -F switch
44: * Maintain FilingSubset mandatory attributes
45: * User niceties: echo file name/type on transfer commands
46: * prompt on delete
47: * guess type which will determine file type implied by content
48: * New commands: (type related) Guess, Whatis
49: * (file transfer) Copy, Move, Rename
50: *
51: * Revision 2.4 86/12/15 11:41:16 jqj
52: * Added support for more ViewPoint file types (no other attributes, though)
53: *
54: * Revision 2.3 86/12/11 06:12:22 jqj
55: * Eliminated form, mode, and struct commands. Started adding support for
56: * more file types.
57: *
58: * Revision 2.2 86/09/07 07:43:40 jqj
59: * Cope with failure return from CourierOpen.
60: *
61: * Revision 2.1 86/06/30 12:19:39 jqj
62: * convert to Authentication v. 2 for compatibility with official spec.
63: *
64: * Revision 2.0 85/11/21 07:22:51 jqj
65: * 4.3BSD standard release
66: *
67: * Revision 1.5 85/09/24 14:45:10 jqj
68: * fix bug in alarm() handling that caused aborts during large file transfers.
69: *
70: * Revision 1.4 85/09/17 07:49:47 jqj
71: * 4.3 changes. Use more routines from CHlookup
72: *
73: * Revision 1.1 85/05/27 06:31:07 jqj
74: * Initial revision
75: *
76: */
77:
78: #include <stdio.h>
79: #include <ctype.h>
80: #include <sys/time.h>
81: #include <sys/param.h>
82: #include <sys/stat.h>
83: #include <netns/ns.h>
84: #include <netns/sp.h>
85: #include "ftp_var.h"
86: #include <xnscourier/Filing4.h>
87: #include <xnscourier/except.h>
88: #undef __Clearinghouse2 /* Filing4.h defs this */
89: #include <xnscourier/CH.h>
90:
91: #define XNS_TIME_DIFFERENCE 2177452800 /* [(1970-1901) years * 365 days/year + 17 leap days */
92: /* * 24 hours/day * 60 minutes/hour * 60 seconds/minute */
93: #define ROOT_DIRECTORY "/"
94: #define MAXNAMES 10
95:
96: CourierConnection *connected;
97: Clearinghouse3_ObjectName hostobjname;
98: Authentication3_Verifier verifier;
99:
100: /* the following 3 items make up the current session */
101: FilingSubset1_Session session; /* the current session */
102: Clearinghouse3_ObjectName username;
103: int continuetime;
104: int remoteprocpending;
105: FilingSubset1_Handle rootHandle;
106: char cur_dir[512]= 0;
107: char cur_pathname[512]= 0;
108: char cur_name[512]= 0;
109:
110: struct name_entry {
111: char *pathname;
112: LongCardinal type;
113: } ;
114:
115: static struct name_entry *name_list= 0;
116: static int name_count= 0;
117: static int name_size= 0;
118:
119: static FilingSubset1_ControlSequence nullControls = {0,0};
120: static FilingSubset1_ScopeSequence nullScope = {0,0};
121:
122: /* global data used to communicate with BDT procedures
123: */
124: extern GetAttributeSequences(),
125: GetAllAttributes(),
126: listproc(), nlistproc(),
127: storeproc(), retrieveproc(),
128: rlistproc(), mkdirproc(),
129: cdproc(), isdirproc(), deleteproc();
130:
131: char *malloc();
132: char *AttrToString();
133: Boolean AttrToBoolean();
134: LongCardinal AttrToLongCardinal();
135: Cardinal AttrToCardinal();
136: char *typetostring();
137:
138: static (*ProcEachSeq)();
139: static long bytessent;
140: static FILE *fout, *fin;
141:
142: LongCardinal filetypevalue; /* real transfer type */
143:
144: struct timeval timbuf[2];
145: Boolean is_a_directory= FALSE;
146: Boolean files_found= FALSE;
147: Boolean filing_subset= TRUE;
148: Boolean isdir= FALSE;
149:
150: copyhandle(dest,src)
151: FilingSubset1_Handle dest,src;
152: {
153: if (dest == (Unspecified *) 0) {
154: fprintf(stderr,"Oops. dest is null in copyhandle\n");
155: exit(1);
156: }
157: dest[0] = src[0];
158: dest[1] = src[1];
159: }
160:
161: getfilehandle(filename, handle)
162: char *filename;
163: FilingSubset1_Handle handle;
164: {
165: FilingSubset1_Attribute pathattr[1];
166: FilingSubset1_AttributeSequence attrseq;
167: FilingSubset1_OpenResults openresult;
168: Filing4_OpenResults openresult2;
169:
170: if (filename == (char *)0 || *filename == '\000' || (strcmp(filename, "/") == 0) ) {
171: if ( filing_subset )
172: copyhandle(handle,FilingSubset1_nullHandle);
173: else
174: copyhandle(handle,rootHandle);
175: return;
176: }
177:
178: attrseq.length = 1;
179: attrseq.sequence = pathattr;
180: pathattr[0].type = FilingSubset1_pathname;
181: copyhandle(handle, FilingSubset1_nullHandle);
182: #ifdef XEROXFSCOMPATIBILITY
183: if ( filename[0] == '/')
184: StringToAttr(filename+1, &pathattr[0]);
185: else
186: StringToAttr(filename, &pathattr[0]);
187: #else XEROXFSCOMPATIBILITY
188: StringToAttr(filename, &pathattr[0]);
189: #endif XEROXFSCOMPATIBILITY
190: alarm(0);
191: if ( filing_subset ) {
192: openresult = FilingSubset1_Open(connected, NULL, attrseq,
193: handle, nullControls,
194: session);
195: copyhandle(handle, openresult.file);
196: } else {
197: openresult2 = Filing4_Open(connected, NULL, attrseq,
198: handle, nullControls,
199: session);
200: copyhandle(handle, openresult2.file);
201: }
202: alarm(continuetime);
203: }
204:
205: getdirhandle(filename, handle)
206: char *filename;
207: FilingSubset1_Handle handle;
208: {
209: FilingSubset1_Attribute pathattr[1];
210: FilingSubset1_AttributeSequence attrseq;
211: FilingSubset1_OpenResults openresult;
212: Filing4_OpenResults openresult2;
213: char *rindex();
214: char *slash, *bang;
215:
216: if (filename == (char *)0 || *filename == '\000' || (strcmp(filename, "/") == 0) ) {
217: strcpy(cur_pathname, "/");
218: strcpy(cur_name, "/");
219: if ( filing_subset )
220: copyhandle(handle,FilingSubset1_nullHandle);
221: else
222: copyhandle(handle,rootHandle);
223: return;
224: } else if ( filename[0] == '/' ) {
225: strcpy(cur_pathname, filename);
226: } else {
227: strcpy(cur_pathname, cur_dir);
228: if ( strcmp(cur_pathname, "/") != 0 )
229: strcat(cur_pathname, "/");
230: strcat(cur_pathname, filename);
231: }
232:
233: if ( (slash= rindex(cur_pathname,'/')) == NULL )
234: strcpy(cur_name, cur_pathname);
235: else
236: strcpy(cur_name, slash+1);
237:
238: if ( (bang= rindex(cur_name, '!')) != NULL )
239: *bang= '\0';
240:
241: if ( filing_subset ) {
242: copyhandle(handle, FilingSubset1_nullHandle);
243: } else {
244: if ( slash == cur_pathname) {
245: copyhandle(handle, rootHandle);
246: return;
247: }
248:
249: attrseq.length = 1;
250: attrseq.sequence = pathattr;
251: pathattr[0].type = FilingSubset1_pathname;
252: copyhandle(handle, FilingSubset1_nullHandle);
253: *slash= '\0'; /* separate pathname from name */
254: #ifdef XEROXFSCOMPATIBILITY
255: if ( cur_pathname[0] == '/' )
256: StringToAttr(cur_pathname+1, &pathattr[0]);
257: else
258: StringToAttr(cur_pathname, &pathattr[0]);
259: #else XEROXFSCOMPATIBILITY
260: StringToAttr(cur_pathname, &pathattr[0]);
261: #endif XEROXFSCOMPATIBILITY
262: *slash= '/'; /* and put back */
263: alarm(0);
264: if ( filing_subset ) {
265: openresult = FilingSubset1_Open(connected, NULL, attrseq,
266: handle, nullControls,
267: session);
268: copyhandle(handle, openresult.file);
269: } else {
270: openresult2 = Filing4_Open(connected, NULL, attrseq,
271: handle, nullControls,
272: session);
273: copyhandle(handle, openresult2.file);
274: }
275: alarm(continuetime);
276: }
277: }
278:
279: freefilehandle(handle)
280: FilingSubset1_Handle handle;
281: {
282: if (handle[0] == FilingSubset1_nullHandle[0] &&
283: handle[1] == FilingSubset1_nullHandle[1])
284: return; /* don't free nullHandle */
285: if (handle[0] == rootHandle[0] &&
286: handle[1] == rootHandle[1])
287: return; /* don't free root directory */
288: alarm(0);
289: if ( filing_subset )
290: FilingSubset1_Close(connected, NULL, handle, session);
291: else
292: Filing4_Close(connected, NULL, handle, session);
293: alarm(continuetime);
294: }
295:
296: /*
297: * do a continue to make sure that the session doesn't time out.
298: * Note that this is usually called by an ALARM interrupt
299: */
300: probe()
301: {
302: FilingSubset1_ContinueResults cresult;
303: Filing4_ContinueResults cresult2;
304: alarm(0); /* cancel previous alarms */
305: if ( filing_subset ) {
306: cresult = FilingSubset1_Continue(connected, NULL, session);
307: continuetime = cresult.continuance / 5; /* seconds */
308: } else {
309: cresult2 = Filing4_Continue(connected, NULL, session);
310: continuetime = cresult2.continuance / 5; /* seconds */
311: }
312: alarm(continuetime); /* reset for another 2 min. or so */
313: }
314:
315: CourierConnection *
316: hookup(name)
317: char *name;
318: {
319: register struct ns_addr *hostaddr;
320: extern struct ns_addr *getXNSaddr();
321: Clearinghouse3_ObjectName defaultobjname;
322: static char hnamebuf[128];
323: CourierConnection *cconn;
324:
325: CH_NameDefault(&defaultobjname);
326: hostobjname = CH_StringToName(name, &defaultobjname);
327: if ((hostaddr = CH_LookupAddrDN( hostobjname, 0, hnamebuf, 128))) {
328: /* should check here to be sure host is a file service */
329: hostaddr->x_port = htons(5); /* ?? */
330: cconn = CourierOpen(hostaddr);
331: if ( cconn == (CourierConnection *) 0 ) {
332: Cardinal problem;
333: problem= FilingSubset1_noResponse;
334: raise(FilingSubset1_ConnectionError, &problem);
335: }
336: /* reset objname to flush wildcards */
337: /* clear_Clearinghouse3_ThreePartName(&hostobjname); */
338: hostobjname = CH_StringToName(hnamebuf, &defaultobjname);
339: hostname = hnamebuf;
340: if (verbose)
341: printf("Connected to %s\n", hnamebuf);
342: } else {
343: printf("%s: unknown host\n", name);
344: usefiling= 0;
345: cconn = (CourierConnection*)0;
346: }
347: return(cconn);
348: }
349:
350:
351: login(name,pwd)
352: char *pwd;
353: char *name;
354: {
355: FilingSubset1_Credentials credentials;
356: FilingSubset1_LogonResults logonresult;
357: FilingSubset1_LogonResults *resultptr= &logonresult;
358: Filing4_LogonResults logonresult2;
359: FilingSubset1_AttributeSequence attrseq;
360: FilingSubset1_OpenResults openresult;
361: Filing4_OpenResults openresult2;
362:
363:
364: if ( name != 0 )
365: username = CH_StringToName(name,&hostobjname);
366:
367: if ( usefiling ) {
368: usefiling= 0;
369: filing_subset= FALSE;
370: if ( name == 0 && pwd == 0 ) {
371: GetSimpleCredsAndVerifier(&username, 0,
372: &credentials.primary, &verifier);
373: } else {
374: MakeSimpleCredsAndVerifier(&username,pwd,
375: &credentials.primary, &verifier);
376: }
377: logonresult2= Filing4_Logon(connected, NULL, hostobjname,
378: credentials.primary, verifier);
379: resultptr= (FilingSubset1_LogonResults *) &logonresult2;
380:
381: } else {
382: usefiling= 0;
383: if ( name == 0 && pwd == 0 ) {
384: GetSimpleCredsAndVerifier(&username, 0, &credentials.primary, &verifier);
385: MakeSecondaryCreds(hostobjname.object, 0, 0, &credentials.secondary);
386: } else {
387: MakeSimpleCredsAndVerifier(0, pwd, &credentials.primary, &verifier);
388: MakeSecondaryCreds(hostobjname.object, name, pwd, &credentials.secondary);
389: }
390: filing_subset= TRUE;
391: DURING
392: logonresult = FilingSubset1_Logon(connected, NULL, hostobjname,
393: credentials, verifier);
394: HANDLER {
395: switch (Exception.Code) {
396: case REJECT_ERROR:
397: filing_subset= FALSE;
398: logonresult2= Filing4_Logon(connected, NULL, hostobjname,
399: credentials.primary, verifier);
400: resultptr= (FilingSubset1_LogonResults *) &logonresult2;
401: break;
402: default:
403: connected= (CourierConnection *)0; /* reset */
404: RERAISE;
405: }
406: } END_HANDLER;
407: }
408:
409: if ( filing_subset )
410: session = resultptr->session;
411: else
412: session = resultptr->session;
413: if (verbose)
414: printf("User %s:%s:%s logged on\n", username.object,
415: username.domain, username.organization);
416:
417: attrseq.length= 0;
418: attrseq.sequence= 0;
419: if ( filing_subset ) {
420: openresult= FilingSubset1_Open(connected, NULL, attrseq,
421: FilingSubset1_nullHandle, nullControls,
422: session);
423: copyhandle(rootHandle, openresult.file);
424: } else {
425: openresult2= Filing4_Open(connected, NULL, attrseq,
426: FilingSubset1_nullHandle, nullControls,
427: session);
428: copyhandle(rootHandle, openresult2.file);
429: }
430: strcpy(cur_dir, ROOT_DIRECTORY);
431: alarm(0);
432: signal(SIGALRM, probe);
433: probe();
434: }
435:
436: logout()
437: {
438: signal(SIGALRM, SIG_IGN);
439: if ( filing_subset )
440: FilingSubset1_Logoff(connected, NULL, session);
441: else
442: Filing4_Logoff(connected, NULL, session);
443: clear_FilingSubset1_Session(&session);
444: }
445:
446: domakedir(dest)
447: char *dest;
448: {
449: struct timeval start, stop, time;
450: FilingSubset1_StoreResults storeresults;
451: Filing4_StoreResults storeresults2;
452: FilingSubset1_Handle dirhandle;
453: FilingSubset1_AttributeSequence attrseq;
454: FilingSubset1_Attribute attrvals[5];
455:
456: gettimeofday(&time, (struct timezone *) 0);
457:
458: if (dest) {
459: getdirhandle(dest, dirhandle);
460: } else {
461: printf("No remote name specified\n");
462: return;
463: }
464:
465: bytessent= 0;
466: alarm(0);
467:
468: attrseq.length= 3;
469: attrseq.sequence= attrvals;
470:
471: if ( filing_subset ) {
472: attrvals[0].type= FilingSubset1_pathname;
473: StringToAttr(cur_pathname, &attrvals[0]);
474: } else {
475: attrvals[0].type= FilingSubset1_name;
476: StringToAttr(cur_name, &attrvals[0]);
477: }
478: attrvals[1].type = FilingSubset1_isDirectory;
479: BooleanToAttr(TRUE, &attrvals[1]);
480: attrvals[2].type = FilingSubset1_type;
481: LongCardinalToAttr(FilingSubset1_tDirectory, &attrvals[2]);
482: gettimeofday(&start, (struct timezone *)0);
483: if ( filing_subset )
484: storeresults = FilingSubset1_Store(connected, BDTclosewrite,
485: dirhandle, attrseq,
486: nullControls,
487: BulkData1_immediateSource, session);
488: else
489: storeresults2 = Filing4_Store(connected, BDTclosewrite,
490: dirhandle, attrseq,
491: nullControls,
492: BulkData1_immediateSource, session);
493: alarm(continuetime);
494: gettimeofday(&stop, (struct timezone *)0);
495: if ( filing_subset )
496: freefilehandle(storeresults.file);
497: else
498: freefilehandle(storeresults2.file);
499:
500: freefilehandle(dirhandle);
501: }
502:
503: doremovedir(src)
504: char *src;
505: {
506: dodelete(src);
507: }
508:
509: dostore(src, dest)
510: char *src, *dest;
511: {
512: sendrequest("STOR", src, dest);
513: }
514:
515: doappend(src, dest)
516: char *src, *dest;
517: {
518: NYI();
519: }
520:
521: dorename(src, dest)
522: char *src, *dest;
523: {
524: Filing4_Handle srchandle, dirhandle;
525: Filing4_AttributeSequence attrseq;
526: Filing4_Attribute attrvals[1];
527:
528: if ( filing_subset ) {
529: NotAvailableUnderSubset("Rename function not available");
530: return;
531: }
532:
533: if ( index(dest, '/') != 0 ) { /* rename across directory */
534: docopy("MOVE", src, dest); /* use move */
535: return;
536: }
537:
538: getdirhandle(src, dirhandle);
539: getfilehandle(cur_pathname, srchandle);
540:
541: attrseq.length= 1;
542: attrseq.sequence= attrvals;
543:
544: attrvals[0].type= Filing4_name;
545: StringToAttr(dest, &attrvals[0]);
546:
547: if (verbose) {
548: printf("renaming %s to %s...\n", src, dest);
549: }
550:
551: alarm(0);
552: Filing4_ChangeAttributes(connected, NULL, srchandle, attrseq, session);
553: alarm(continuetime);
554:
555: freefilehandle(srchandle);
556: freefilehandle(dirhandle);
557: }
558:
559: docopy(cmd, src, dest)
560: char *cmd, *src, *dest;
561: {
562: Filing4_Handle srchandle, srcdirhandle, dirhandle, newhandle;
563: Filing4_AttributeSequence attrseq;
564: Filing4_Attribute attrvals[1];
565: Filing4_AttributeTypeSequence typeseq;
566: Filing4_AttributeType attrs[2];
567: Filing4_ScopeSequence scopeseq;
568: Filing4_Scope scope;
569: Filing4_CopyResults copyresults;
570: Boolean copy= FALSE;
571:
572: if ( filing_subset ) {
573: NotAvailableUnderSubset("Copy/Move function not available");
574: return;
575: }
576:
577: if ( strcmp(cmd, "COPY") == 0 )
578: copy= TRUE;
579:
580: getdirhandle(src, srcdirhandle);
581: getfilehandle(cur_pathname, srchandle);
582: freefilehandle(srcdirhandle);
583:
584: getdirhandle(dest, dirhandle);
585:
586: typeseq.length= 2; typeseq.sequence= attrs;
587: attrs[0]= Filing4_isDirectory;
588: attrs[1]= Filing4_pathname;
589:
590: scopeseq.length= 1; scopeseq.sequence= &scope;
591: scope.designator= Filing4_filter;
592: scope.Filing4_filter_case.designator= Filing4_matches;
593: scope.Filing4_filter_case.Filing4_matches_case.attribute.type= Filing4_name;
594: StringToAttr(cur_name, &scope.Filing4_filter_case.Filing4_matches_case.attribute);
595: ProcEachSeq= isdirproc;
596: isdir= FALSE;
597:
598: alarm(0);
599: Filing4_List(connected, GetAttributeSequences, dirhandle, typeseq,
600: scopeseq, BulkData1_immediateSink, session);
601: alarm(continuetime);
602:
603: if ( isdir ) {
604: getfilehandle(cur_pathname, dirhandle); /* open directory as file */
605:
606: attrseq.length= 0;
607: attrseq.sequence= attrvals;
608: } else {
609: attrseq.length= 1;
610: attrseq.sequence= attrvals;
611:
612: attrvals[0].type= Filing4_name;
613: StringToAttr(cur_name, &attrvals[0]);
614: }
615:
616: if (verbose) {
617: if ( copy )
618: printf("copying ");
619: else
620: printf("moving ");
621: printf("%s to %s%s%s...\n", src, dest, (isdir ? "/" : ""),
622: (isdir ? src : ""));
623: }
624:
625: alarm(0);
626: if ( copy ) {
627: copyresults= Filing4_Copy(connected, NULL, srchandle, dirhandle,
628: attrseq, nullControls, session);
629:
630: freefilehandle(copyresults.newFile);
631: } else {
632: Filing4_Move(connected, NULL, srchandle, dirhandle,
633: attrseq, session);
634: }
635: alarm(continuetime);
636:
637: freefilehandle(srchandle);
638: freefilehandle(dirhandle);
639: }
640:
641: dounify(remote)
642: char *remote;
643: {
644: Filing4_Handle dirhandle, remotehandle;
645:
646: if ( filing_subset ) {
647: NotAvailableUnderSubset("Unify AccessLists");
648: return;
649: }
650:
651: getdirhandle(remote, dirhandle);
652: getfilehandle(cur_pathname, remotehandle);
653: freefilehandle(dirhandle);
654:
655: if ( verbose ) {
656: printf("unify access lists for %s\n", remote);
657: }
658:
659: alarm(0);
660: Filing4_UnifyAccessLists(connected, NULL, remotehandle, session);
661: alarm(continuetime);
662:
663: freefilehandle(remotehandle);
664:
665: }
666: recvrequest(cmd, local, remote, mode)
667: char *cmd, *local, *remote, *mode;
668: {
669: FILE *popen();
670: int (*closefunc)(), pclose(), fclose();
671: int do_unlink= FALSE;
672: int pos, i;
673: struct timeval start, stop;
674: FilingSubset1_Handle remotehandle; /* note: an array */
675: FilingSubset1_Handle dirhandle; /* note: an array */
676: FilingSubset1_AttributeTypeSequence typeseq;
677: FilingSubset1_AttributeType tsvals[10];
678: char *dir;
679: FilingSubset1_ScopeSequence scopeseq;
680: FilingSubset1_Scope scope;
681:
682: closefunc = NULL;
683:
684: fout = stdout;
685: typeseq.length = 0; typeseq.sequence = tsvals;
686: scopeseq.length= 1; scopeseq.sequence= &scope;
687: scope.designator= FilingSubset1_filter;
688: scope.FilingSubset1_filter_case.designator= FilingSubset1_matches;
689: if ( filing_subset )
690: scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_pathname;
691: else
692: scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_name;
693: timbuf[0].tv_sec= 0;
694:
695: copyhandle(remotehandle, FilingSubset1_nullHandle);
696:
697: if (strcmp(local, "-") && *local != '|')
698: if (access(local, 2) < 0) {
699: dir = rindex(local, '/');
700: /* get a good error message */
701: if (dir != NULL) *dir = '\0';
702: if (access(dir ? local : ".", 2) < 0) {
703: perror(local);
704: goto bad;
705: }
706: if (dir != NULL) *dir = '/';
707: }
708: if (strcmp(local, "-") == 0)
709: fout = stdout;
710: else if (*local == '|') {
711: char *ptr;
712: ptr= local+1;
713: while (isspace(*ptr)) ptr++;
714: fout = popen(ptr, "w");
715: if (fout == NULL) {
716: perror(ptr);
717: goto bad;
718: }
719: closefunc = pclose;
720: } else {
721: fout = fopen(local, mode);
722: if (fout == NULL) {
723: perror(local);
724: goto bad;
725: }
726: closefunc = fclose;
727: }
728:
729: if (remote) {
730: getdirhandle(remote, dirhandle);
731: }
732: bytessent= 0;
733: filetypevalue= typevalue;
734:
735: if ( filing_subset )
736: StringToAttr(cur_pathname+1,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
737: else
738: StringToAttr(cur_name,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
739:
740: if (strcmp(cmd,"NLST") == 0) {
741: typeseq.length = 1;
742: typeseq.sequence[0] = FilingSubset1_pathname;
743: ProcEachSeq = nlistproc;
744: alarm(0);
745: gettimeofday(&start, (struct timezone *)0);
746: if ( filing_subset )
747: FilingSubset1_List(connected, GetAttributeSequences, dirhandle,
748: typeseq, scopeseq,
749: BulkData1_immediateSink, session);
750: else
751: Filing4_List(connected, GetAttributeSequences, dirhandle,
752: typeseq, scopeseq,
753: BulkData1_immediateSink, session);
754: alarm(continuetime);
755: }
756: else if (strcmp(cmd,"LIST") == 0) {
757: typeseq.length = 7;
758: if ( filing_subset )
759: typeseq.sequence[0] = FilingSubset1_pathname;
760: else
761: typeseq.sequence[0] = FilingSubset1_name;
762: typeseq.sequence[1] = FilingSubset1_dataSize;
763: typeseq.sequence[2] = FilingSubset1_isDirectory;
764: typeseq.sequence[3] = FilingSubset1_isTemporary;
765: typeseq.sequence[4] = FilingSubset1_type;
766: typeseq.sequence[5] = FilingSubset1_createdOn;
767: typeseq.sequence[6] = FilingSubset1_version;
768: ProcEachSeq = listproc;
769: alarm(0);
770: gettimeofday(&start, (struct timezone *)0);
771: if ( filing_subset )
772: FilingSubset1_List(connected, GetAttributeSequences, dirhandle,
773: typeseq, scopeseq,
774: BulkData1_immediateSink, session);
775: else
776: Filing4_List(connected, GetAttributeSequences, dirhandle,
777: typeseq, scopeseq,
778: BulkData1_immediateSink, session);
779: alarm(continuetime);
780: }
781: else if (strcmp(cmd,"RETR") == 0) {
782: typeseq.length= 4;
783: typeseq.sequence[0]= FilingSubset1_createdOn;
784: typeseq.sequence[1]= FilingSubset1_pathname;
785: typeseq.sequence[2]= FilingSubset1_type;
786: typeseq.sequence[3]= FilingSubset1_isDirectory;
787:
788: is_a_directory= FALSE;
789: ProcEachSeq= rlistproc;
790:
791: alarm(0);
792: if ( filing_subset )
793: FilingSubset1_List(connected, GetAttributeSequences, dirhandle,
794: typeseq, scopeseq,
795: BulkData1_immediateSink, session);
796: else
797: Filing4_List(connected, GetAttributeSequences, dirhandle,
798: typeseq, scopeseq,
799: BulkData1_immediateSink, session);
800:
801: alarm(continuetime);
802:
803: if ( files_found ) {
804: if ( is_a_directory && (filetypevalue == FilingSubset1_tDirectory) ) {
805: if ( filing_subset ) {
806: NotAvailableUnderSubset("Cannot retrieve directory files");
807: do_unlink= TRUE;
808: goto error;
809: }
810: }
811:
812: if (verbose) {
813: printf("%s...(%s)...", local, typetostring(filetypevalue));
814: fflush(stdout);
815: }
816:
817: if ( (filetypevalue == FilingSubset1_tDirectory) ||
818: ((filetypevalue > LAST_FILING_TYPE) &&
819: (filetypevalue != TYPE_Interpress) &&
820: (filetypevalue != TYPE_VPCanvas)) ) {
821: if ( filing_subset ) {
822: NotAvailableUnderSubset("Cannot retrieve Viewpoint files");
823: do_unlink= TRUE;
824: goto error;
825: }
826:
827: alarm(0);
828: ProcEachSeq= GetAllAttributes;
829: Filing4_List(connected, GetAttributeSequences, dirhandle,
830: Filing4_allAttributeTypes, scopeseq,
831: BulkData1_immediateSink, session);
832: alarm(continuetime);
833: }
834:
835: bytessent= 0;
836: getfilehandle(cur_pathname, remotehandle); /* get file handle */
837: alarm(0);
838: gettimeofday(&start, (struct timezone *)0);
839: if ( filing_subset ) {
840: FilingSubset1_Retrieve(connected, retrieveproc, remotehandle,
841: BulkData1_immediateSink, session);
842: } else {
843: if ( is_a_directory )
844: Filing4_Serialize(connected, retrieveproc, remotehandle,
845: BulkData1_immediateSink, session);
846: else
847: Filing4_Retrieve(connected, retrieveproc, remotehandle,
848: BulkData1_immediateSink, session);
849: }
850: alarm(continuetime);
851: }
852: } else if (strcmp(cmd,"SER") == 0) {
853: ProcEachSeq= GetAllAttributes;
854:
855: alarm(0);
856: if ( filing_subset ) {
857: NotAvailableUnderSubset("Cannot serialize files");
858: do_unlink= TRUE;
859: goto error;
860: } else {
861: Filing4_List(connected, GetAttributeSequences, dirhandle,
862: Filing4_allAttributeTypes, scopeseq,
863: BulkData1_immediateSink, session);
864: }
865: alarm(continuetime);
866:
867: if ( files_found ) {
868: if (verbose) {
869: printf("%s to %s...(%s)...",cur_pathname, local, typetostring(filetypevalue));
870: fflush(stdout);
871: }
872:
873: bytessent= 0;
874: getfilehandle(cur_pathname, remotehandle); /* get file handle */
875: alarm(0);
876: gettimeofday(&start, (struct timezone *)0);
877: Filing4_Serialize(connected, retrieveproc, remotehandle,
878: BulkData1_immediateSink, session);
879: alarm(continuetime);
880: }
881: }
882: else printf("unrecognized command %s\n",cmd);
883: gettimeofday(&stop, (struct timezone *)0);
884: freefilehandle(remotehandle);
885:
886: if ( files_found ) {
887: if (bytessent > 0 && verbose)
888: ptransfer("received", bytessent, &start, &stop);
889: } else {
890: printf("%s not found\n",cur_pathname);
891: do_unlink= TRUE;
892: }
893:
894: error:
895: freefilehandle(dirhandle);
896:
897: bad:
898: if (closefunc != NULL && fout != NULL) {
899: (*closefunc)(fout);
900: if ( closefunc == fclose ) {
901: if (timbuf[0].tv_sec != 0 )
902: utimes(local,&timbuf[0]);
903: }
904: }
905: if ( do_unlink )
906: unlink(local);
907:
908: fout = NULL;
909: }
910:
911:
912: sendrequest(cmd, local, remote)
913: char *cmd, *local, *remote;
914: {
915: FILE *popen();
916: int (*closefunc)(), pclose(), fclose();
917: struct stat st;
918: struct timeval start, stop;
919: FilingSubset1_StoreResults storeresults;
920: Filing4_DeserializeResults deserializeresults;
921: Filing4_StoreResults storeresults2;
922: FilingSubset1_Handle dirhandle;
923: FilingSubset1_AttributeSequence attrseq;
924: FilingSubset1_Attribute attrvals[50];
925: Boolean GetDirectoryAttribute();
926: struct timeval time;
927: long createdate;
928: long datasize;
929:
930: gettimeofday(&time,(struct timezone *) 0);
931: createdate= time.tv_sec + XNS_TIME_DIFFERENCE;
932: filetypevalue= typevalue;
933:
934: closefunc = NULL;
935: if (strcmp(local, "-") == 0) {
936: fin = stdin;
937: closefunc = NULL;
938: } else if (*local == '|') {
939: char *ptr;
940: ptr= local+1;
941: while (isspace(*ptr)) ptr++;
942: fin = popen(ptr, "r");
943: if (fin == NULL) {
944: perror(ptr);
945: return;
946: }
947: closefunc = pclose;
948: } else {
949: if (typevalue == TYPE_Guess) {
950: filetypevalue= get_type(local); /* guess file type */
951: }
952: fin = fopen(local, "r");
953: if (fin == NULL) {
954: perror(local);
955: return;
956: }
957: closefunc = fclose;
958: if (fstat(fileno(fin), &st) < 0 ||
959: (st.st_mode&S_IFMT) != S_IFREG) {
960: fprintf(stderr, "%s: not a plain file.", local);
961: fclose(fin);
962: fin= NULL;
963: return;
964: }
965: createdate= st.st_mtime + XNS_TIME_DIFFERENCE;
966: datasize= st.st_size;
967: }
968:
969: if (filetypevalue == TYPE_Guess) /* if input from file, TYPE_G should already be replaced */
970: filetypevalue= TYPE_A; /* assume ascii for pipes/stdin... */
971:
972: if (remote) {
973: getdirhandle(remote, dirhandle);
974: } else {
975: printf("No remote name specified\n");
976: return;
977: }
978: bytessent = 0;
979: if (strcmp(cmd,"STOR") == 0) {
980: if (verbose) {
981: printf("%s to %s...",local,remote);
982: fflush(stdout);
983: }
984: attrseq.length = 1;
985: attrseq.sequence = attrvals;
986: if ( filing_subset ) {
987: attrvals[0].type = FilingSubset1_pathname;
988: StringToAttr(cur_pathname, &attrvals[0]);
989: } else {
990: attrvals[0].type = FilingSubset1_name;
991: StringToAttr(cur_name, &attrvals[0]);
992: }
993:
994: if ( (filetypevalue == TYPE_Directory) ||
995: ((filetypevalue > LAST_FILING_TYPE) &&
996: (filetypevalue != TYPE_Interpress) &&
997: (filetypevalue != TYPE_VPCanvas)) ) {
998: isdir= GetDirectoryAttribute(fin);
999: } else {
1000: isdir= FALSE;
1001: }
1002:
1003: if ( !isdir ) {
1004: attrseq.length += 4;
1005: attrvals[1].type = FilingSubset1_type;
1006: LongCardinalToAttr(filetypevalue, &attrvals[1]);
1007: attrvals[2].type = FilingSubset1_createdOn;
1008: LongCardinalToAttr(createdate,&attrvals[2]);
1009: attrvals[3].type= FilingSubset1_isDirectory;
1010: BooleanToAttr(FALSE, &attrvals[3]);
1011: attrvals[4].type= FilingSubset1_dataSize;
1012: LongCardinalToAttr(datasize, &attrvals[4]);
1013: }
1014:
1015: if (verbose) {
1016: printf("(%s)...", typetostring(filetypevalue));
1017: fflush(stdout);
1018: }
1019:
1020: if ( (filetypevalue == TYPE_Directory) ||
1021: ((filetypevalue > LAST_FILING_TYPE) &&
1022: (filetypevalue != TYPE_Interpress) &&
1023: (filetypevalue != TYPE_VPCanvas)) ) {
1024: if ( filing_subset ) {
1025: NotAvailableUnderSubset("Cannot store Viewpoint files");
1026: goto error;
1027: }
1028: if ( isdir ) {
1029: if ( AddExtendedDeserializeAttributes(fin, &attrseq) == 0 ) {
1030: goto error;
1031: }
1032: } else {
1033: if ( AddExtendedStoreAttributes(fin, &attrseq) == 0 ) {
1034: goto error;
1035: }
1036: }
1037: }
1038:
1039: alarm(0);
1040: gettimeofday(&start, (struct timezone *)0);
1041: if ( filing_subset ) {
1042: storeresults = FilingSubset1_Store(connected, storeproc,
1043: dirhandle, attrseq,
1044: nullControls,
1045: BulkData1_immediateSource,
1046: session);
1047: } else {
1048: if ( isdir )
1049: deserializeresults = Filing4_Deserialize(connected, storeproc,
1050: dirhandle, attrseq,
1051: nullControls,
1052: BulkData1_immediateSource,
1053: session);
1054: else
1055: storeresults2 = Filing4_Store(connected, storeproc,
1056: dirhandle, attrseq,
1057: nullControls,
1058: BulkData1_immediateSource,
1059: session);
1060: }
1061: alarm(continuetime);
1062: gettimeofday(&stop, (struct timezone *)0);
1063: if ( filing_subset ) {
1064: freefilehandle(storeresults.file);
1065: } else {
1066: if ( isdir )
1067: freefilehandle(deserializeresults.file);
1068: else
1069: freefilehandle(storeresults2.file);
1070: }
1071: } else if (strcmp(cmd,"DSER") == 0) {
1072: if ( filing_subset ) {
1073: NotAvailableUnderSubset("Cannot Deserialize files");
1074: goto error;
1075: }
1076: if (verbose) {
1077: printf("%s to %s...",local,remote);
1078: fflush(stdout);
1079: }
1080: attrseq.length = 1;
1081: attrseq.sequence = attrvals;
1082: attrvals[0].type = FilingSubset1_name;
1083: StringToAttr(cur_name, &attrvals[0]);
1084:
1085: if (verbose) {
1086: printf("(%s)...", typetostring(filetypevalue));
1087: fflush(stdout);
1088: }
1089:
1090: if ( AddExtendedDeserializeAttributes(fin, &attrseq) == 0 ) {
1091: goto error;
1092: }
1093:
1094: alarm(0);
1095: gettimeofday(&start, (struct timezone *)0);
1096: deserializeresults = Filing4_Deserialize(connected, storeproc,
1097: dirhandle, attrseq, nullControls,
1098: BulkData1_immediateSource, session);
1099: alarm(continuetime);
1100: gettimeofday(&stop, (struct timezone *)0);
1101: freefilehandle(deserializeresults.file);
1102: }
1103: else {
1104: printf("unrecognized command %s\n",cmd);
1105: alarm(continuetime);
1106: }
1107: if (bytessent > 0 && verbose)
1108: ptransfer("sent", bytessent, &start, &stop);
1109: error:
1110: freefilehandle(dirhandle);
1111: if (closefunc != NULL && fin != NULL)
1112: (*closefunc)(fin);
1113: fin = NULL;
1114: }
1115:
1116:
1117:
1118: docd(dest)
1119: char *dest;
1120: {
1121: FilingSubset1_AttributeSequence attrseq;
1122: FilingSubset1_AttributeTypeSequence typeseq;
1123: Boolean current= FALSE;
1124: FilingSubset1_AttributeType cdattrs[2];
1125: FilingSubset1_ScopeSequence scopeseq;
1126: FilingSubset1_Scope scope;
1127: FilingSubset1_Handle remotehandle;
1128:
1129: if (dest == (char*)NULL || *dest == '\0' || (strcmp(dest, "/") == 0) ) {
1130: getdirhandle("/", remotehandle);
1131: strcpy(cur_dir, "/");
1132: dopwd();
1133: return;
1134: } else {
1135: getdirhandle(dest, remotehandle);
1136: }
1137:
1138: isdir= FALSE;
1139:
1140: if ( filing_subset ) {
1141: StringToAttr(cur_pathname+1,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
1142: scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_pathname;
1143: } else {
1144: StringToAttr(cur_name,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
1145: scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_name;
1146: }
1147: typeseq.length = 2; typeseq.sequence = cdattrs;
1148: cdattrs[0] = FilingSubset1_isDirectory;
1149: cdattrs[1] = FilingSubset1_pathname;
1150: scopeseq.length= 1; scopeseq.sequence= &scope;
1151: scope.designator= FilingSubset1_filter;
1152: scope.FilingSubset1_filter_case.designator= FilingSubset1_matches;
1153: ProcEachSeq= cdproc;
1154: alarm(0);
1155: if ( filing_subset )
1156: FilingSubset1_List(connected, GetAttributeSequences, remotehandle, typeseq,
1157: scopeseq, BulkData1_immediateSink, session);
1158: else
1159: Filing4_List(connected, GetAttributeSequences, remotehandle, typeseq,
1160: scopeseq, BulkData1_immediateSink, session);
1161:
1162: alarm(continuetime);
1163: freefilehandle(remotehandle);
1164:
1165: if ( files_found == FALSE ) {
1166: printf("%s not found\n", dest);
1167: } else if ( !isdir ) {
1168: printf("%s not a directory\n", dest);
1169: } else {
1170: if ( dest[0] != '/' ) {
1171: if ( strcmp(cur_dir, "/") != 0 )
1172: strcat(cur_dir, "/");
1173: strcat(cur_dir, dest);
1174: } else {
1175: strcpy(cur_dir, dest);
1176: }
1177: if (verbose) dopwd();
1178: }
1179:
1180: }
1181:
1182: dopwd()
1183: {
1184: printf("Remote working directory: %s\n",cur_dir);
1185: }
1186:
1187: dodelete(src)
1188: char *src;
1189: {
1190: int i;
1191: FilingSubset1_Handle remotehandle;
1192: FilingSubset1_Handle dirhandle;
1193: FilingSubset1_AttributeSequence attrseq;
1194: FilingSubset1_AttributeTypeSequence typeseq;
1195: FilingSubset1_AttributeType delattrs[2];
1196: FilingSubset1_ScopeSequence scopeseq;
1197: FilingSubset1_Scope scope;
1198:
1199: typeseq.length = 2; typeseq.sequence= delattrs;
1200: delattrs[0] = FilingSubset1_type;
1201: delattrs[1]= FilingSubset1_pathname;
1202:
1203: scopeseq.length= 1; scopeseq.sequence= &scope;
1204: scope.designator= FilingSubset1_filter;
1205: scope.FilingSubset1_filter_case.designator= FilingSubset1_matches;
1206:
1207: name_count= 0;
1208: name_size= MAXNAMES;
1209: if ( (name_list= (struct name_entry *)malloc(sizeof(struct name_entry) * name_size)) == 0 ) {
1210: perror("dodelete");
1211: return;
1212: }
1213:
1214: getdirhandle(src, dirhandle);
1215:
1216: if ( filing_subset ) {
1217: scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_pathname;
1218: StringToAttr(cur_pathname+1,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
1219: } else {
1220: scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_name;
1221: StringToAttr(cur_name,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
1222: }
1223:
1224: ProcEachSeq= deleteproc;
1225: alarm(0);
1226: if ( filing_subset )
1227: FilingSubset1_List(connected, GetAttributeSequences, dirhandle, typeseq,
1228: scopeseq, BulkData1_immediateSink, session);
1229: else
1230: Filing4_List(connected, GetAttributeSequences, dirhandle, typeseq,
1231: scopeseq, BulkData1_immediateSink, session);
1232:
1233: alarm(continuetime);
1234: freefilehandle(dirhandle);
1235:
1236: for ( i= 0 ; i < name_count ; i++ ) {
1237: struct name_entry *entry;
1238:
1239: entry= &name_list[i];
1240: if ( verbose ) {
1241: if ( entry->type == TYPE_Directory ) {
1242: if (!confirm("Delete directory", entry->pathname) ) {
1243: clear_String(&entry->pathname);
1244: continue;
1245: }
1246: } else if ( entry->type == TYPE_VPDrawer ) {
1247: if (!confirm("Delete file drawer", entry->pathname) ) {
1248: clear_String(&entry->pathname);
1249: continue;
1250: }
1251: } else {
1252: if (!confirm("Delete file",entry->pathname) ) {
1253: clear_String(&entry->pathname);
1254: continue;
1255: }
1256: }
1257: }
1258:
1259: getfilehandle(entry->pathname,remotehandle);
1260: alarm(0);
1261: if ( filing_subset )
1262: FilingSubset1_Delete(connected, NULL, remotehandle, session);
1263: else
1264: Filing4_Delete(connected, NULL, remotehandle, session);
1265: alarm(continuetime);
1266:
1267: clear_String(&entry->pathname);
1268: }
1269: }
1270:
1271: NYI()
1272: {
1273: printf("Not yet implemented\n");
1274: }
1275:
1276: NotAvailableUnderSubset(message)
1277: char *message;
1278: {
1279: printf("%s under Subset,\n Reopen connection with -F switch and retry\n", message);
1280: }
1281:
1282: ptransfer(direction, bytes, t0, t1)
1283: char *direction;
1284: long bytes;
1285: struct timeval *t0, *t1;
1286: {
1287: struct timeval td;
1288: long ms;
1289: float bs;
1290:
1291: tvsub(&td, t1, t0);
1292: ms = (td.tv_sec * 1000) + (td.tv_usec / 1000);
1293: #define nz(x) ((x) == 0 ? 1 : (x))
1294: bs = ((1000. * (float) bytes) / (float) nz(ms));
1295: printf("\n%ld bytes %s in %d.%02d seconds (%.2g Kbytes/s)\n",
1296: bytes, direction, td.tv_sec, td.tv_usec / 10000, bs / 1024.);
1297: }
1298:
1299: tvadd(tsum, t0)
1300: struct timeval *tsum, *t0;
1301: {
1302:
1303: tsum->tv_sec += t0->tv_sec;
1304: tsum->tv_usec += t0->tv_usec;
1305: if (tsum->tv_usec > 1000000)
1306: tsum->tv_sec++, tsum->tv_usec -= 1000000;
1307: }
1308:
1309: tvsub(tdiff, t1, t0)
1310: struct timeval *tdiff, *t1, *t0;
1311: {
1312:
1313: tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
1314: tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
1315: if (tdiff->tv_usec < 0)
1316: tdiff->tv_sec--, tdiff->tv_usec += 1000000;
1317: }
1318:
1319: nlistproc(attr)
1320: FilingSubset1_AttributeSequence attr;
1321: {
1322: int i;
1323: char *thisname;
1324: FilingSubset1_AttributeType t;
1325:
1326: files_found= TRUE;
1327:
1328: for (i = 0; i < attr.length; i++) {
1329: t = attr.sequence[i].type;
1330: if (t == FilingSubset1_pathname) {
1331: thisname = AttrToString(&attr.sequence[i]);
1332: #ifdef XEROXFSCOMPATIBILITY
1333: /*
1334: * Xerox File servers don't include beginning /
1335: */
1336: if ( *thisname != '/' )
1337: fputc('/', fout);
1338: #endif XEROXFSCOMPATIIBLITY
1339: fputs(thisname, fout);
1340: fputc('\n', fout);
1341: clear_String(&thisname);
1342: return;
1343: }
1344: }
1345: }
1346:
1347:
1348: listproc(attr)
1349: FilingSubset1_AttributeSequence attr;
1350: {
1351: int i;
1352: char *thisname;
1353: char *slash;
1354: Boolean istemp = 0;
1355: Boolean isdir = 0;
1356: LongCardinal thistype = 0;
1357: LongCardinal thissize = 0;
1358: LongCardinal thisdate = 0;
1359: FilingSubset1_AttributeType t;
1360: char filetypestr[25];
1361: char filetypebuf[20];
1362: Cardinal thisversion = 0;
1363: char *filedatestr;
1364: char *ctime();
1365: char *rindex();
1366:
1367: files_found= TRUE;
1368:
1369: for (i = 0; i < attr.length; i++) {
1370: t = attr.sequence[i].type;
1371: if (t == FilingSubset1_name || t == FilingSubset1_pathname)
1372: thisname = AttrToString(&attr.sequence[i]);
1373: else if (t == FilingSubset1_isDirectory)
1374: isdir = AttrToBoolean(&attr.sequence[i]);
1375: else if (t == FilingSubset1_isTemporary)
1376: istemp = AttrToBoolean(&attr.sequence[i]);
1377: else if (t == FilingSubset1_type)
1378: thistype = AttrToLongCardinal(&attr.sequence[i]);
1379: else if (t == FilingSubset1_dataSize)
1380: thissize = AttrToLongCardinal(&attr.sequence[i]);
1381: else if (t == FilingSubset1_version)
1382: thisversion = AttrToCardinal(&attr.sequence[i]);
1383: else if (t == FilingSubset1_createdOn) {
1384: thisdate = AttrToLongCardinal(&attr.sequence[i]);
1385: thisdate = thisdate - XNS_TIME_DIFFERENCE;
1386: filedatestr= ctime(&thisdate);
1387: filedatestr[24]= '\0';
1388: filedatestr += 4;
1389: }
1390: }
1391:
1392: strcpy(filetypestr, "(");
1393: strcat(filetypestr, typetostring(thistype));
1394: strcat(filetypestr, ")");
1395:
1396: if ( (slash= rindex(thisname, '/')) == NULL )
1397: slash= thisname;
1398: else
1399: slash++;
1400:
1401: fprintf(fout, "%c%c%-16s%7ld %s %s",
1402: isdir?'D':' ', istemp?'T':' ',
1403: filetypestr, thissize, filedatestr, slash);
1404: if ( thisversion != 0)
1405: fprintf(fout,"!%d",thisversion);
1406: fprintf(fout,"\n");
1407: clear_String(&thisname);
1408: }
1409:
1410: /*
1411: * process used by retrieve to get file type, createdOn and pathname
1412: */
1413: rlistproc(attr)
1414: FilingSubset1_AttributeSequence attr;
1415: {
1416: int i;
1417: char *thisname;
1418: FilingSubset1_AttributeType t;
1419: char *AttrToString();
1420:
1421: files_found= TRUE;
1422:
1423: /*
1424: * Xerox file servers will return all versions of the requested file in
1425: * ascending version order. We assume that the last version will be the
1426: * highest and remember that name so that the retrieve will pull the
1427: * highest version of the file. If we request just the file with no
1428: * version, the server will return the oldest version (not what I would
1429: * expect...)
1430: */
1431:
1432: for (i= 0; i < attr.length; i++) {
1433: t= attr.sequence[i].type;
1434: if (t == FilingSubset1_createdOn) {
1435: gettimeofday(&timbuf[0],(struct timezone *)0);
1436: timbuf[1].tv_sec= AttrToLongCardinal(&attr.sequence[i]) - XNS_TIME_DIFFERENCE;
1437: timbuf[1].tv_usec= 0;
1438: } else if (t == FilingSubset1_type) {
1439: if (typevalue == TYPE_Guess) {
1440: filetypevalue= AttrToLongCardinal(&attr.sequence[i]);
1441: }
1442: } else if (t == FilingSubset1_pathname) {
1443: thisname= AttrToString(&attr.sequence[i]);
1444: if (verbose) {
1445: printf("%s to ", thisname);
1446: fflush(stdout);
1447: }
1448: clear_String(&thisname);
1449: } else if (t == FilingSubset1_isDirectory) {
1450: is_a_directory= AttrToBoolean(&attr.sequence[i]);
1451: }
1452: }
1453:
1454: }
1455:
1456: cdproc(attr)
1457: FilingSubset1_AttributeSequence attr;
1458: {
1459: char *AttrtoString();
1460: char *dest;
1461: int i;
1462:
1463: files_found= TRUE;
1464:
1465: dest= 0;
1466: for (i= 0; i < attr.length; i++) {
1467: if (attr.sequence[i].type == FilingSubset1_isDirectory
1468: && AttrToBoolean(&attr.sequence[i])) {
1469: isdir= TRUE; /* if directory, change handles */
1470: }
1471: if (attr.sequence[i].type == FilingSubset1_pathname)
1472: dest= AttrToString(&attr.sequence[i]);
1473: }
1474:
1475: if (!isdir || dest == 0) { /* if no directory or pathname */
1476: isdir= FALSE; /* assume failure */
1477: }
1478: }
1479:
1480: #define MAXPACKS 20
1481: static
1482: GetAttributeSequences(conn)
1483: CourierConnection *conn;
1484: {
1485: int count, i;
1486: Unspecified buffer[MAXWORDS*MAXPACKS], *bp, *bufend;
1487: FilingSubset1_StreamOfAttributeSequence attrs;
1488: Boolean overflow= FALSE;
1489:
1490: files_found= FALSE;
1491:
1492: bufend = buffer;
1493: bp = buffer+((MAXWORDS-1)*MAXPACKS); /* end of available space */
1494: while ((count = BDTread(conn, (char*)bufend,
1495: MAXWORDS*sizeof(Unspecified))) > 0) {
1496: bufend += count/sizeof(Unspecified);
1497: bytessent += count;
1498: if (bufend > bp) {
1499: fprintf(stderr,"BDT read too big to fit\n");
1500: BDTabort(conn);
1501: /* should clear out stuff here if we knew how much
1502: * fall back to previous block on the assumption
1503: * we can give a truncated list
1504: */
1505: bufend -= count/sizeof(Unspecified);
1506: overflow=TRUE;
1507: }
1508: }
1509: bp = buffer;
1510: while (bp < bufend) {
1511: bp += internalize_FilingSubset1_StreamOfAttributeSequence(&attrs,bp);
1512: if (0 == (int) attrs.designator) {
1513: for (i=0; i < attrs.nextSegment_case.segment.length; i++) {
1514: (*ProcEachSeq)(
1515: attrs.nextSegment_case.segment.sequence[i]);
1516: }
1517: free(attrs.nextSegment_case.segment.sequence);
1518: } else {
1519: for (i = 0; i < attrs.lastSegment_case.length; i++) {
1520: (*ProcEachSeq)(
1521: attrs.lastSegment_case.sequence[i]);
1522: }
1523: free(attrs.lastSegment_case.sequence);
1524: return;
1525: }
1526: }
1527: if ( overflow ) {
1528: fprintf(stderr, "\nListing was truncated due to internal bulk data buffer size\n");
1529: overflow= FALSE;
1530: }
1531: }
1532:
1533: int
1534: getBDTch(conn,bpp)
1535: CourierConnection *conn;
1536: u_char **bpp;
1537: {
1538: static u_char buffer[SPPMAXDATA];
1539: static int count;
1540:
1541: if (*bpp == NULL) {*bpp = buffer; count = 0;}
1542: if (*bpp >= buffer+count) {
1543: count=BDTread(conn,buffer,sizeof(buffer));
1544: *bpp = buffer;
1545: }
1546: if (count <= 0) return(EOF);
1547: else return(*((*bpp)++));
1548:
1549: }
1550:
1551: retrieveproc(conn)
1552: CourierConnection *conn;
1553: {
1554: int count, ocount, ch, hashbytes;
1555: char buffer[SPPMAXDATA];
1556: int charset, charset16;
1557: char *bp;
1558:
1559: switch (filetypevalue) {
1560: default :
1561: errno = ocount = 0;
1562: fflush(fout);
1563: while ((count = BDTread(conn, buffer, sizeof(buffer))) > 0) {
1564: if ((ocount = write(fileno(fout),buffer,count)) < 0) {
1565: perror("write");
1566: BDTabort(conn);
1567: break;
1568: }
1569: bytessent += count;
1570: if (hash) {
1571: putchar('#');
1572: fflush(stdout);
1573: }
1574: }
1575: if (count < 0) perror("netin");
1576: break;
1577:
1578: case TYPE_VPMailNote :
1579: case TYPE_A :
1580: charset = 0; charset16 = 0; bp = NULL;
1581: hashbytes = 0;
1582: while ((ch = getBDTch(conn,&bp)) != EOF) {
1583: if (ch == '\377') {
1584: ch = getBDTch(conn,&bp);
1585: if (ch == '\377') charset16 = 1;
1586: else charset = ch;
1587: continue;
1588: }
1589: if (charset16) {
1590: charset = ch;
1591: ch = getBDTch(conn,&bp);
1592: }
1593: switch (charset) {
1594: case 0: /* normal character set -- minimal xlation */
1595: if (ch == '\r') {
1596: int nextch;
1597:
1598: putc('\n',fout);
1599: bytessent++;
1600: if ( (nextch = getBDTch(conn,&bp)) != '\n'){
1601: if (nextch == '\r')
1602: putc('\n',fout);
1603: else if ( nextch == ','+0200 )
1604: putc('_',fout);
1605: else if ( nextch != EOF )
1606: putc(nextch,fout);
1607: else
1608: continue;
1609: }
1610: bytessent= bytessent++;
1611:
1612: while (hash && bytessent >= hashbytes){
1613: putchar('#');
1614: fflush(stdout);
1615: hashbytes += sizeof(buffer);
1616: }
1617: break;
1618: }
1619: else if (ch == ','+0200) ch = '_';
1620: /* more mapping here */
1621: putc(ch,fout);
1622: bytessent++;
1623: break;
1624: default:
1625: break; /* ignore */
1626: }
1627: }
1628: if (hash) {
1629: while (bytessent >= hashbytes) {
1630: putchar('#');
1631: hashbytes += sizeof(buffer);
1632: }
1633: putchar('\n');
1634: fflush(stdout);
1635: }
1636: /* if (count < 0) perror("netin"); */
1637: break;
1638: }
1639: }
1640:
1641: storeproc(conn)
1642: CourierConnection *conn;
1643: {
1644: int count, ocount;
1645: u_char buffer[SPPMAXDATA];
1646: u_char *bp;
1647:
1648: errno = ocount = 0;
1649: clearerr(fin);
1650: switch (filetypevalue) {
1651:
1652: default :
1653: while ((count = fread(buffer, sizeof(char), SPPMAXDATA, fin)) > 0
1654: && (ocount = BDTwrite(conn, buffer, count)) > 0) {
1655: bytessent += count;
1656: if (hash) {
1657: putchar('#');
1658: fflush(stdout);
1659: }
1660: }
1661: break;
1662: case TYPE_VPMailNote :
1663: case TYPE_A :
1664: while ((count = fread(buffer, sizeof(char), SPPMAXDATA, fin))
1665: > 0) {
1666: ocount = count;
1667: for (bp = buffer; count > 0; count--, bp++) {
1668: if (*bp == '\n') *bp = '\r';
1669: else if (*bp == '_') *bp = ','+0200;
1670: /* more translations here */
1671: }
1672: if ((ocount = BDTwrite(conn, buffer, ocount)) <= 0)
1673: break;
1674: bytessent += ocount;
1675: if (hash) {
1676: putchar('#');
1677: fflush(stdout);
1678: }
1679: }
1680: break;
1681: }
1682: if (ocount < 0) {
1683: BDTabort(conn);
1684: perror("netout");
1685: }
1686: else if (ferror(fin)) {
1687: BDTabort(conn);
1688: perror("fread");
1689: }
1690: else
1691: BDTclosewrite(conn);
1692: }
1693:
1694: isdirproc(attr)
1695: FilingSubset1_AttributeSequence attr;
1696: {
1697: int i;
1698: char *name;
1699: FilingSubset1_AttributeType t;
1700:
1701: for ( i= 0; i < attr.length; i++ ) {
1702: t= attr.sequence[i].type;
1703: if ( t == FilingSubset1_isDirectory ) {
1704: isdir= AttrToBoolean(&attr.sequence[i]);
1705: } else if ( t == FilingSubset1_pathname ) {
1706: name= AttrToString(&attr.sequence[1]);
1707: strcpy(cur_pathname, name);
1708: clear_String(&name);
1709: }
1710: }
1711: }
1712:
1713: deleteproc(attr)
1714: FilingSubset1_AttributeSequence attr;
1715: {
1716: int i;
1717: char *name;
1718: struct name_entry *entry;
1719: FilingSubset1_AttributeType t;
1720:
1721: if ( name_count > name_size ) {
1722: name_size += MAXNAMES;
1723: name_list= (struct name_entry *) realloc(name_list,
1724: sizeof(struct name_entry) * name_size);
1725: }
1726:
1727: entry= &name_list[name_count];
1728: for ( i= 0; i < attr.length; i++ ) {
1729: t= attr.sequence[i].type;
1730: if ( t == FilingSubset1_type ) {
1731: entry->type= AttrToLongCardinal(&attr.sequence[i]);
1732: } else if ( t == FilingSubset1_pathname ) {
1733: entry->pathname= AttrToString(&attr.sequence[1]);
1734: }
1735: }
1736: name_count++;
1737: }
1738:
1739: GetAllAttributes(attr)
1740: FilingSubset1_AttributeSequence attr;
1741: {
1742: int i;
1743: char *thisname;
1744: FilingSubset1_AttributeType t;
1745: int got_createdon, got_type, got_pathname;
1746:
1747: files_found= TRUE;
1748: got_createdon= got_pathname= got_type= 0;
1749:
1750: /*
1751: * Xerox file servers will return all versions of the requested file in
1752: * ascending version order. We assume that the last version will be the
1753: * highest and remember that name so that the retrieve will pull the
1754: * highest version of the file. If we request just the file with no
1755: * version, the server will return the oldest version (not what I would
1756: * expect...)
1757: */
1758: for (i= 0; i < attr.length; i++) {
1759: t= attr.sequence[i].type;
1760: if (t == FilingSubset1_createdOn) {
1761: gettimeofday(&timbuf[0],(struct timezone *)0);
1762: timbuf[1].tv_sec= AttrToLongCardinal(&attr.sequence[i]) - XNS_TIME_DIFFERENCE;
1763: timbuf[1].tv_usec= 0;
1764: got_createdon++;
1765: } else if (t == FilingSubset1_type) {
1766: if (typevalue == TYPE_Guess) {
1767: filetypevalue= AttrToLongCardinal(&attr.sequence[i]);
1768: }
1769: got_type++;
1770: } else if (t == FilingSubset1_pathname) {
1771: thisname= AttrToString(&attr.sequence[i]);
1772: strcpy(cur_pathname, thisname);
1773: clear_String(&thisname);
1774: got_pathname++;
1775: }
1776:
1777: if ( got_createdon && got_type && got_pathname )
1778: break;
1779: }
1780:
1781: SaveExtendedAttributes(fout, attr);
1782:
1783: return;
1784: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.