![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to filingd.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_common|
Return to filingd.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / examples / filing_common |
1.1 root 1: #ifndef lint
2: static char *rcsid = "$Header: filingd.c,v 1.6 87/05/14 11:33:26 ed Exp $";
3: #endif lint
4:
5: /*
6: * Copyright (c) 1986, 1987 Xerox Corporation.
7: */
8:
9: /* $Log: filingd.c,v $
10: * Revision 1.6 87/05/14 11:33:26 ed
11: * Open: don't set cur_dir_handle unless directory is opened.
12: *
13: * Revision 1.5 87/05/05 14:46:31 ed
14: * Don't close connection in continuance_expiration if BDT in progress.
15: *
16: * Revision 1.4 87/04/16 15:30:29 ed
17: * Fixed lingering Subset bugs.
18: *
19: * Revision 1.3 87/03/31 14:22:53 ed
20: * Initialize got_matches in get_filter.
21: *
22: * Revision 1.2 87/03/31 09:05:15 ed
23: * New procedures: Create, ChangeAttributes(name only), Copy, Move,
24: * Replace, Serialize, Deserialize.
25: * Added conditional disabling of root logins.
26: * Support for GetAttributes (allAttributeTypes).
27: * Support for filter of type all.
28: *
29: * Revision 1.1 87/01/14 11:25:59 ed
30: * Initial revision
31: *
32: */
33:
34: #include <stdio.h>
35: #include <sys/types.h>
36: #include <netns/ns.h>
37: #include <netns/sp.h>
38: #ifdef FILING4
39: #include "filingV4.h"
40: #include "clearinghouseV2.h"
41: #include "authenticationV2.h"
42: #endif FILING4
43: #ifdef FILING5
44: #include "filingV5.h"
45: #include "clearinghouseV2.h"
46: #include "authenticationV2.h"
47: #endif FILING5
48: #ifdef FILING6
49: #include "filingV6.h"
50: #include "clearinghouseV3.h"
51: #include "authenticationV3.h"
52: #endif FILING6
53: #ifdef FILINGSUBSET1
54: #include "filingsubsetV1.h"
55: #include "clearinghouseV3.h"
56: #include "authenticationV3.h"
57: #endif FILINGSUBSET1
58: #include <xnscourier/filing_server.h>
59: #include <xnscourier/CH.h>
60: #include <xnscourier/filetypes.h>
61:
62: #define SERVICE_ROOT "/" /* root directory for service */
63:
64: #ifdef DEBUG
65: FILE *msgs= 0;
66: #endif DEBUG
67:
68: session_handle SessionHandle= 0;
69: file_handle RootHandle= { FILE_OPEN, SERVICE_ROOT, 0, 0, 0, TRUE, 0, 0, NULL };
70: extern CourierConnection *_serverConnection; /* current connection */
71:
72: /*
73: * The continuance value is slightly lower than the 90 second
74: * value in lookahead.c. This should insure that the client will
75: * send a Continue before this service stops looking for the next
76: * procedure call.
77: */
78: Cardinal continuance= 80; /* continuance value in seconds */
79:
80: Boolean BDTabort_expected= FALSE; /* should BDT attn be sent */
81:
82: #ifdef FILETOOLCOMPATIBILITY
83: file_handle *cur_dir_handle= &RootHandle;
84: #endif FILETOOLCOMPATIBILITY
85:
86:
87: FILING_LogonResults
88: FILING_Logon(ServerConnection, BDTProc, service_name, user_credentials, user_verifier)
89: CourierConnection *ServerConnection;
90: int (*BDTProc)();
91: CLEARINGHOUSE_ObjectName service_name;
92: FILING_Credentials user_credentials;
93: FILING_Verifier user_verifier;
94: {
95: FILING_LogonResults result;
96: AUTHENTICATION_ThreePartName chs_name;
97: session_handle *session_ptr;
98: Unspecified *bp, buffer[SPPMAXDATA];
99: char user[40];
100: char pass[40];
101: Cardinal credentials_type;
102: Cardinal len;
103: char *lowercase();
104: #if FILING4 | FILING5
105: char *rindex();
106: char *ptr;
107: #endif FILING4 | FILING5
108:
109: BDTabort_expected= FALSE;
110:
111: #ifdef DEBUG
112: if (msgs == 0) {
113: char logfile[50];
114: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
115: msgs= fopen(logfile,"w");
116: }
117: fprintf(msgs,"Logon\n");
118: #endif DEBUG
119:
120: #if FILING4 | FILING5
121: if (user_credentials.type != AUTHENTICATION_simpleCredentials) {
122: ReturnAuthenticationError(AUTHENTICATION_inappropriateCredentials);
123: /* NOT REACHED */
124: } else {
125: CLEARINGHOUSE_externalize_Item(&user_credentials.value, buffer);
126: bp= buffer;
127: bp += internalize_Cardinal(&len, bp);
128: AUTHENTICATION_internalize_SimpleCredentials(&chs_name, bp);
129: #ifdef DEBUG
130: fprintf(msgs,"chs_name= %s:%s:%s\n",chs_name.object,chs_name.domain,chs_name.organization);
131: #endif DEBUG
132: }
133:
134: #ifdef ROOTNOTALLOWED
135: /*
136: * We don't allow root access from the file server
137: */
138:
139: if ( strcmp(lowercase(chs_name.object), "root") == 0 ) {
140: ReturnAuthenticationError(AUTHENTICATION_credentialsInvalid);
141: /* NOT REACHED */
142: }
143: #endif ROOTNOTALLOWED
144:
145: /*
146: * Assumption (for Filing4/Filing5 implementation):
147: * may receive fully specified Clearinghouse name, so we should try
148: * to strip off last name (look for last space) assuming there is a
149: * similary named account on this service. If the user credentials
150: * pass network authentiction, then we will not check passwords on
151: * this service (in fact, we can't since the verifier is hashed).
152: * It is assumed that the name will be found in /etc/passwd and
153: * everything will work regardless of password checking.
154: */
155:
156: if ( (ptr= rindex(chs_name.object, ' ')) == 0 ) {
157: strcpy(user, chs_name.object);
158: } else {
159: ptr++;
160: strcpy(user, ptr);
161: }
162:
163: if ( !Auth_CredCheck(user_credentials, user_verifier) ) {
164: ReturnAuthenticationError(AUTHENTICATION_credentialsInvalid);
165: /* NOT REACHED */
166: }
167: #else FILING4 | FILING5
168: /*
169: * assumption (for FILING6 and FILINGSUBSET1):
170: * no primary credentials are ok
171: * simple primary credentials will be validated with Authentication
172: * strong credentials will be ignored
173: *
174: * secondary credentials must contain userName and userPassword
175: * which are assumed to be Unix name and password
176: */
177:
178: if (user_credentials.primary.type == AUTHENTICATION_simpleCredentials) {
179: if ( !Auth_CredCheck(user_credentials.primary, user_verifier) ) {
180: ReturnAuthenticationError(FILING_primaryCredentialsInvalid);
181: /* NOT REACHED */
182: }
183: }
184:
185: if ( get_name_and_pwd(&user_credentials.secondary, user, pass) != -1 ) {
186: ReturnAuthenticationError(FILING_secondaryCredentialsRequired);
187: /* NOT REACHED */
188: }
189:
190: #ifdef ROOTNOTALLOWED
191: /*
192: * We don't allow root access from the file server
193: */
194:
195: if ( strcmp(lowercase(user), "root") == 0 ) {
196: ReturnAuthenticationError(AUTHENTICATION_credentialsInvalid);
197: /* NOT REACHED */
198: }
199: #endif ROOTNOTALLOWED
200:
201: #endif FILING4 | FILING5
202:
203: #ifdef DEBUG
204: fprintf(msgs, "user= %s\n", user);
205: #endif DEBUG
206:
207: if ( verifyandposition_user(user, pass) != -1 ) {
208: /* NOT REACHED */
209: }
210:
211: session_ptr= &SessionHandle;
212: SessionHandle.state= SESSION_OPEN;
213: SessionHandle.verifier= user_verifier.sequence[0];
214:
215: #ifdef DEBUG
216: /* fprintf(msgs,"handle= %x, ver= %x\n",session_ptr,session_ptr->verifier);
217: */
218: #endif DEBUG
219:
220: copyhandle(result.session.token, &session_ptr);
221: result.session.verifier.length= sizeof(AUTHENTICATION_SimpleVerifier) / sizeof(Cardinal);
222: result.session.verifier.sequence= Allocate(sizeof(AUTHENTICATION_SimpleVerifier));
223: result.session.verifier.sequence[0]= user_verifier.sequence[0];
224:
225: set_continuance_timer();
226: #ifdef DEBUG
227: fprintf(msgs, "out of logon\n");
228: #endif DEBUG
229: return(result);
230:
231: }
232:
233: copyhandle(dest, src)
234: Unspecified *dest, *src;
235: {
236: if ( dest == (Unspecified *)0 ) {
237: #ifdef DEBUG
238: fprintf(msgs, "Oops, dest is null in copyhandle\n");
239: #else DEBUG
240: fprintf(stderr, "Oops, dest is null in copyhandle\n");
241: #endif DEBUG
242: exit(1);
243: }
244:
245: dest[0]= src[0];
246: dest[1]= src[1];
247: }
248:
249:
250: void FILING_Logoff(ServerConnection, BDTProc, session)
251: CourierConnection *ServerConnection;
252: int (*BDTProc)();
253: FILING_Session session;
254: {
255: session_handle *session_ptr;
256:
257: BDTabort_expected= FALSE;
258:
259: if ( verify_session(session) != -1 ) {
260: /* NOT REACHED */
261: }
262:
263: copyhandle(&session_ptr,session.token);
264:
265: #ifdef SOMEDAY
266: if ( session_ptr->state == SESSION_IN_USE ) {
267: ReturnServiceError(FILING_sessionInUse);
268: }
269: #endif SOMEDAY
270:
271: session_ptr->state= SESSION_CLOSED;
272: reset_continuance_timer();
273:
274: return;
275: }
276:
277:
278: FILING_OpenResults FILING_Open(ServerConnection, BDTProc, attributes, directory, controls, session)
279: CourierConnection *ServerConnection;
280: int ( *BDTProc)();
281: FILING_AttributeSequence attributes;
282: FILING_Handle directory;
283: FILING_ControlSequence controls;
284: FILING_Session session;
285: {
286: FILING_OpenResults results;
287: file_handle *handle;
288:
289: #ifdef FILETOOLCOMPATIBILITY
290: file_handle *dir_handle;
291: #endif FILETOOLCOMPATIBILITY
292:
293: BDTabort_expected= FALSE;
294:
295: #ifdef DEBUG
296: if (msgs == 0) {
297: char logfile[50];
298: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
299: msgs= fopen(logfile,"w");
300: }
301: fprintf(msgs,"Open\n");
302: fflush(msgs);
303: #endif DEBUG
304:
305: if ( verify_session(session) != -1 ) {
306: /* NOT REACHED */
307: }
308:
309: #ifndef FILETOOLCOMPATIBILITY
310: if ( is_nullControls(controls) != -1 ) {
311: ReturnControlTypeError(FILING_disallowed,0);
312: /* NOT REACHED */
313: }
314:
315: if ( is_nullHandle(directory) != -1 ) {
316: ReturnHandleError(FILING_invalid);
317: /* NOT REACHED */
318: }
319: #endif FILETOOLCOMPATIBILITY
320:
321: if ( (handle= (file_handle *)malloc(sizeof(file_handle))) == NULL ) {
322: ReturnUndefinedError(0);
323: /* NOT REACHED */
324: }
325:
326: #ifdef DEBUG
327: fprintf(msgs,"Open-- file handle= %x\n",handle);
328: fflush(msgs);
329: #endif DEBUG
330:
331: if ( (handle->pathname= (char *)malloc(MAX_FILE_NAME_LENGTH)) == NULL ) {
332: ReturnUndefinedError(0);
333: /* NOT REACHED */
334: }
335:
336: #ifdef FILETOOLCOMPATIBILITY
337: copyhandle(&dir_handle,directory);
338:
339: if ( dir_handle != 0 ) {
340: if ( dir_handle->state != FILE_OPEN ) {
341: ReturnHandleError(FILING_invalid);
342: /* NOT REACHED */
343: }
344:
345: if ( dir_handle->isdirectory != TRUE ) {
346: ReturnHandleError(FILING_directoryRequired);
347: /* NOT REACHED */
348: }
349:
350: if ( access_file(dir_handle) != -1 ) {
351: /* NOT REACHED */
352: }
353:
354: strcpy(handle->pathname,dir_handle->pathname);
355: if ( strcmp(handle->pathname, "/") != 0 )
356: strcat(handle->pathname,"/");
357: } else {
358: strcpy(handle->pathname, SERVICE_ROOT);
359: }
360: #else FILETOOLCOMPATIBILITY
361: strcpy(handle->pathname, SERVICE_ROOT);
362: #endif FILETOOLCOMPATIBILITY
363:
364: if ( verify_open_attributes(attributes, handle) != -1 ) {
365: /* NOT REACHED */
366: }
367:
368: if ( stat_file(handle) != -1 ) {
369: /* NOT REACHED */
370: }
371:
372: handle->state= FILE_OPEN;
373: handle->file_desc= NULL;
374: handle->createdon= handle->modifiedon= 0;
375:
376: copyhandle(results.file,&handle);
377:
378: #ifdef FILETOOLCOMPATIBILITY
379: if ( handle->isdirectory == TRUE )
380: cur_dir_handle= handle;
381: #endif FILETOOLCOMPATIBILITY
382:
383: reset_continuance_timer();
384:
385: return(results);
386: }
387:
388: verify_session(session)
389: FILING_Session session;
390: {
391: session_handle *session_ptr;
392:
393: copyhandle(&session_ptr, session.token);
394:
395: if ( session_ptr == 0 ||
396: (session_ptr->state != SESSION_OPEN) ) {
397: ReturnSessionError(FILING_tokenInvalid);
398: /* NOT REACHED */
399: }
400:
401: if ( session_ptr->verifier != *(session.verifier.sequence) ) {
402: ReturnAuthenticationError(AUTHENTICATION_verifierInvalid);
403: /* NOT REACHED */
404: }
405:
406: return(-1);
407:
408: }
409:
410: is_nullControls(controls)
411: FILING_ControlSequence controls;
412: {
413:
414: if ( controls.length != 0 && controls.sequence != 0 ) {
415: return(0);
416: }
417:
418: return(-1);
419: }
420:
421: is_nullHandle(handle)
422: FILING_Handle handle;
423: {
424: if ( handle[0] != 0 && handle[1] != 0 ) {
425: return(0);
426: }
427:
428: return(-1);
429: }
430:
431: verify_open_attributes(attr, handle)
432: FILING_AttributeSequence attr;
433: file_handle *handle;
434: {
435: int i;
436: FILING_AttributeType t;
437: int got_parentID, got_pathname, got_type, got_version;
438: char *pathname;
439: Unspecified *parentid;
440: FILING_Version version;
441: char *AttrToString();
442: Unspecified *AttrToFileID();
443: LongCardinal AttrToLongCardinal();
444:
445: #ifdef FILETOOLCOMPATIBILITY
446: int got_name, got_fileID;
447: char *name;
448: Unspecified *fileid;
449: #endif FILETOOLCOMPATIBILITY
450:
451: #ifdef DEBUG
452: fprintf(msgs,"verify_open_attribute %d attributes ",attr.length);
453: #endif DEBUG
454:
455: got_parentID= got_pathname= got_type= got_version= 0;
456:
457: #ifdef FILETOOLCOMPATIBILITY
458: got_name= got_fileID= 0;
459: #endif FILETOOLCOMPATIBILITY
460:
461: #ifdef FILETOOLCOMPATIBILITY
462: if ( attr.length == 0 ) {
463: return;
464: }
465: #endif FILETOOLCOMPATIBILITY
466:
467: for ( i= 0 ; i < attr.length ; i++ ) {
468: t= attr.sequence[i].type;
469:
470: if ( t == FILING_parentID ) {
471: #ifdef DEBUG
472: fprintf(msgs,"parentID ");
473: #endif DEBUG
474: if ( got_parentID ) {
475: ReturnAttributeTypeError(FILING_duplicated, t);
476: /* NOT REACHED */
477: }
478: got_parentID++;
479:
480: parentid= AttrToFileID(&attr.sequence[i]);
481: if ( !is_nullID(parentid) ) {
482: ReturnAttributeValueError(FILING_unimplemented, t);
483: /* NOT REACHED */
484: }
485: continue;
486: }
487: if ( t == FILING_pathname ) {
488: #ifdef DEBUG
489: fprintf(msgs,"pathname ");
490: #endif DEBUG
491: if ( got_pathname ) {
492: ReturnAttributeTypeError(FILING_duplicated, t);
493: /* NOT REACHED */
494: }
495: got_pathname++;
496:
497: pathname= AttrToString(&attr.sequence[i]);
498: if ( check_pathname(pathname) != -1 ) {
499: /* NOT REACHED */
500: }
501: continue;
502: }
503: if ( t == FILING_type ) {
504: #ifdef DEBUG
505: fprintf(msgs,"type ");
506: #endif DEBUG
507: if ( got_type ) {
508: ReturnAttributeTypeError(FILING_duplicated, t);
509: /* NOT REACHED */
510: }
511: got_type++;
512:
513: handle->type= AttrToLongCardinal(&attr.sequence[i]);
514: #ifndef EXTENSIONS
515: if ( (handle->type != FILING_tText) &&
516: (handle->type != FILING_tUnspecified) ) {
517: ReturnAttributeValueError(FILING_unimplemented, t);
518: /* NOT REACHED */
519: }
520: #endif EXTENSIONS
521: continue;
522: }
523: if ( t == FILING_version ) {
524: #ifdef DEBUG
525: fprintf(msgs,"version ");
526: #endif DEBUG
527: if ( got_version ) {
528: ReturnAttributeTypeError(FILING_duplicated, t);
529: /* NOT REACHED */
530: }
531: got_version++;
532:
533: version= AttrToCardinal(&attr.sequence[i]);
534: if ( version != FILING_highestVersion && version != FILING_lowestVersion ) {
535: ReturnAttributeValueError(FILING_unimplemented, t);
536: /* NOT REACHED */
537:
538: }
539: continue;
540: }
541:
542: #ifdef FILETOOLCOMPATIBILITY
543: if ( t == FILING_name ) {
544: #ifdef DEBUG
545: fprintf(msgs, "name ");
546: #endif DEBUG
547: if ( got_name ) {
548: ReturnAttributeTypeError(FILING_duplicated, t);
549: /* NOT REACHED */
550: }
551: got_name++;
552:
553: name= AttrToString(&attr.sequence[i]);
554: continue;
555: }
556:
557: if ( t == FILING_fileID ) {
558: #ifdef DEBUG
559: fprintf(msgs, "fileID ");
560: #endif DEBUG
561: if ( got_fileID ) {
562: ReturnAttributeTypeError(FILING_duplicated, t);
563: /* NOT REACHED */
564: }
565: got_fileID++;
566:
567: fileid= AttrToFileID(&attr.sequence[i]);
568: if ( is_nullID(fileid) == -1 ) {
569: ReturnAttributeValueError(FILING_disallowed, t);
570: /* NOT REACHED */
571: }
572: strcpy(handle->pathname, cur_dir_handle->pathname);
573: if ( get_name_from_fileID(handle, fileid) != -1 ) {
574: /* NOT REACHED */
575: }
576: continue;
577: }
578: #else FILETOOLCOMPATIBILITY
579: if ( t == FILING_fileID ) {
580: ReturnAttributeTypeError(FILING_unimplemented, t);
581: /* NOT REACHED */
582: }
583:
584: if ( t == FILING_name ) {
585: ReturnAttributeTypeError(FILING_unimplemented, t);
586: /* NOT REACHED */
587: }
588: #endif FILETOOLCOMPATIBILITY
589:
590: if ( ( t < 0 ) || (t > FILING_subtreeSizeLimit) ) {
591: ReturnAttributeTypeError(FILING_illegal, t);
592: /* NOT REACHED */
593: }
594:
595: ReturnAttributeTypeError(FILING_disallowed, t);
596: }
597:
598: #ifdef FILETOOLCOMPATIBILITY
599: if ( !got_pathname && !got_name) {
600: if ( !got_fileID ) {
601: handle->pathname= SERVICE_ROOT;
602: }
603: } else if ( !got_pathname ) {
604: strcat(handle->pathname,name);
605: } else {
606: if ( *pathname == '/' )
607: strcat(handle->pathname, pathname+1);
608: else
609: strcat(handle->pathname,pathname);
610: Deallocate(&pathname);
611: }
612:
613: #else FILETOOLCOMPATIBILITY
614: if ( !got_pathname ) {
615: handle->pathname= SERVICE_ROOT;
616: } else {
617: if ( *pathname == '/' )
618: strcat(handle->pathname, pathname+1);
619: else
620: strcat(handle->pathname, pathname);
621: Deallocate(&pathname);
622: }
623: #endif FILETOOLCOMPATIBILITY
624:
625: if ( !got_type )
626: handle->type= -1;
627:
628: return(-1);
629: }
630:
631: is_nullID(fileid)
632: Unspecified *fileid;
633: {
634: int i;
635:
636: for ( i= 0 ; i < 6 ; i++ ) {
637: if ( fileid[i] != 0 )
638: return(0);
639: }
640:
641: return(-1);
642: }
643:
644:
645: void FILING_Close(ServerConnection, BDTProc, file, session)
646: CourierConnection *ServerConnection;
647: int ( *BDTProc)();
648: FILING_Handle file;
649: FILING_Session session;
650: {
651: file_handle *handle;
652:
653: BDTabort_expected= FALSE;
654:
655: #ifdef DEBUG
656: if (msgs == 0) {
657: char logfile[50];
658: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
659: msgs= fopen(logfile,"w");
660: }
661: fprintf(msgs, "Close\n");
662: #endif DEBUG
663:
664: if ( verify_session(session) != -1 ) {
665: /* NOT REACHED */
666: }
667:
668: if ( is_nullHandle(file) == -1 ) {
669: ReturnHandleError(FILING_nullDisallowed);
670: /* NOT REACHED */
671: }
672:
673: copyhandle(&handle,file);
674: #ifdef DEBUG
675: fprintf(msgs, "closing %x\n",handle);
676: #endif DEBUG
677:
678: if ( handle->state != FILE_OPEN ) {
679: ReturnHandleError(FILING_invalid);
680: /* NOT REACHED */
681: }
682:
683: if ( access_file(handle) != -1 ) {
684: /* NOT REACHED */
685: }
686:
687: close_file(handle); /* do it now */
688:
689: if ( handle->createdon != 0 ) /* set date if needed */
690: set_create_time(handle);
691:
692: handle->state= FILE_CLOSED;
693: handle->pathname= (char *)0;
694:
695: #ifdef FILETOOLCOMPATIBILITY
696: if ( handle == cur_dir_handle )
697: cur_dir_handle= &RootHandle;
698: #endif FILETOOLCOMPATIBILITY
699:
700: free(handle);
701: reset_continuance_timer();
702:
703: return;
704: }
705:
706:
707: FILING_CreateResults FILING_Create(ServerConnection, BDTProc, directory, attributes, controls, session)
708: CourierConnection *ServerConnection;
709: int ( *BDTProc)();
710: FILING_Handle directory;
711: FILING_AttributeSequence attributes;
712: FILING_ControlSequence controls;
713: FILING_Session session;
714: {
715: #ifdef EXTENSIONS
716: FILING_CreateResults results;
717: file_handle *handle, *dir_handle;
718:
719: #ifdef DEBUG
720: if (msgs == 0) {
721: char logfile[50];
722: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
723: msgs= fopen(logfile,"w");
724: }
725: fprintf(msgs, "Create ");
726: #endif DEBUG
727:
728: BDTabort_expected= TRUE;
729:
730: if ( verify_session(session) != -1 ) {
731: /* NOT REACHED */
732: }
733:
734: #ifndef FILETOOLCOMPATIBILITY
735: if ( is_nullControls(controls) != -1) {
736: ReturnControlTypeError(FILING_disallowed, 0);
737: /* NOT REACHED */
738: }
739: #endif FILETOOLCOMPATIBILITY
740:
741: if ( (handle= (file_handle *)malloc(sizeof(file_handle))) == NULL ) {
742: ReturnUndefinedError(0);
743: /* NOT REACHED */
744: }
745:
746: if ( (handle->pathname= (char *)malloc(MAX_FILE_NAME_LENGTH)) == NULL ) {
747: ReturnUndefinedError(0);
748: /* NOT REACHED */
749: }
750:
751: #ifdef DEBUG
752: fprintf(msgs, "create handle= %x\n",handle);
753: #endif DEBUG
754:
755: #ifdef FILETOOLCOMPATIBILITY
756: copyhandle(&dir_handle,directory);
757:
758: if ( dir_handle == 0 ) {
759: dir_handle= &RootHandle;
760: strcpy(handle->pathname, SERVICE_ROOT);
761: } else {
762: if ( dir_handle->state != FILE_OPEN ) {
763: ReturnHandleError(FILING_invalid);
764: /* NOT REACHED */
765: }
766:
767: if ( access_file(dir_handle) != -1 ) {
768: /* NOT REACHED */
769: }
770:
771: if ( dir_handle->isdirectory != TRUE ) {
772: ReturnHandleError(FILING_directoryRequired);
773: /* NOT REACHED */
774: }
775:
776: strcpy(handle->pathname,dir_handle->pathname);
777: if ( strcmp(handle->pathname, "/") != 0 )
778: strcat(handle->pathname,"/");
779: }
780: #else FILETOOLCOMPATIBILITY
781: strcpy(handle->pathname, SERVICE_ROOT);
782: #endif FILETOOLCOMPATIBILITY
783:
784: if ( verify_create_attributes(attributes, handle) != -1 ) {
785: /* NOT REACHED */
786: }
787:
788: #ifdef DEBUG
789: fprintf(msgs, "creating '%s'\n", handle->pathname);
790: #endif DEBUG
791:
792: if ( handle->isdirectory == TRUE ) {
793: if ( create_directory(handle) != -1 ) {
794: /* NOT REACHED */
795: }
796: } else {
797: if ( create_file(handle) != -1 ) {
798: /* NOT REACHED */
799: }
800: }
801:
802: close_file(handle);
803:
804: handle->state= FILE_OPEN;
805: handle->file_desc= NULL;
806:
807: copyhandle(results.file, &handle);
808: reset_continuance_timer();
809:
810: return(results);
811: #else EXTENSIONS
812: NoSuchProcedureValue("Filing", 4);
813: #endif EXTENSIONS
814: }
815:
816: #ifdef EXTENSIONS
817: verify_create_attributes(attr, handle)
818: FILING_AttributeSequence attr;
819: file_handle *handle;
820: {
821: int i;
822: FILING_AttributeType t;
823: int got_accesslist, got_childrenuniquelynamed, got_createdon, got_datasize;
824: int got_defaultaccesslist, got_isdirectory, got_istemporary, got_ordering;
825: int got_pathname, got_subtreesizelimit, got_type, got_version;
826: char *pathname;
827: FILING_Version version;
828: Boolean childrenuniquelynamed, istemporary;
829: Cardinal ordering;
830: Cardinal subtreesizelimit;
831: char *AttrToString();
832: Unspecified *AttrToFileID();
833: LongCardinal AttrToLongCardinal();
834:
835: #ifdef FILETOOLCOMPATIBILITY
836: int got_name;
837: char *name;
838: #endif FILETOOLCOMPATIBILITY
839:
840: #ifdef DEBUG
841: fprintf(msgs,"%d create attributes ",attr.length);
842: #endif DEBUG
843:
844: if ( attr.length <= 0 ) {
845: ReturnAttributeTypeError(FILING_illegal, 0);
846: /* NOT REACHED */
847: }
848:
849: got_accesslist= got_childrenuniquelynamed= got_createdon= 0;
850: got_datasize= got_defaultaccesslist= got_isdirectory= 0;
851: got_istemporary= got_ordering= got_pathname= 0;
852: got_subtreesizelimit= got_type= got_version= 0;
853:
854: #ifdef FILETOOLCOMPATIBILITY
855: got_name= 0;
856: #endif FILETOOLCOMPATIBILITY
857:
858:
859: for ( i= 0 ; i < attr.length ; i++ ) {
860: t= attr.sequence[i].type;
861: #ifdef DEBUG
862: fprintf(msgs, "%d ",t);
863: #endif DEBUG
864: if ( t == FILING_createdOn ) {
865: #ifdef DEBUG
866: fprintf(msgs,"createdOn ");
867: #endif DEBUG
868: if ( got_createdon ) {
869: ReturnAttributeTypeError(FILING_duplicated, t);
870: /* NOT REACHED */
871: }
872: got_createdon++;
873:
874: handle->createdon= AttrToLongCardinal(&attr.sequence[i]);
875: continue;
876: }
877:
878: if ( t == FILING_dataSize ) {
879: #ifdef DEBUG
880: fprintf(msgs,"dataSize ");
881: #endif DEBUG
882: if ( got_datasize ) {
883: ReturnAttributeTypeError(FILING_duplicated, t);
884: /* NOT REACHED */
885: }
886: got_datasize++;
887:
888: handle->datasize= AttrToLongCardinal(&attr.sequence[i]);
889: continue;
890: }
891:
892: if ( t == FILING_isDirectory ) {
893: #ifdef DEBUG
894: fprintf(msgs,"isDirectory ");
895: #endif DEBUG
896: if ( got_isdirectory ) {
897: ReturnAttributeTypeError(FILING_duplicated, t);
898: /* NOT REACHED */
899: }
900:
901: got_isdirectory++;
902:
903: handle->isdirectory= AttrToBoolean(&attr.sequence[i]);
904: continue;
905: }
906:
907: if ( t == FILING_pathname ) {
908: #ifdef DEBUG
909: fprintf(msgs,"pathname ");
910: #endif DEBUG
911: if ( got_pathname ) {
912: ReturnAttributeTypeError(FILING_duplicated, t);
913: /* NOT REACHED */
914: }
915: got_pathname++;
916:
917: pathname= AttrToString(&attr.sequence[i]);
918: if ( check_pathname(pathname) != -1 ) {
919: /* NOT REACHED */
920: }
921: continue;
922: }
923: if ( t == FILING_type ) {
924: #ifdef DEBUG
925: fprintf(msgs,"type ");
926: #endif DEBUG
927: if ( got_type ) {
928: ReturnAttributeTypeError(FILING_duplicated, t);
929: /* NOT REACHED */
930: }
931: got_type++;
932:
933: handle->type= AttrToLongCardinal(&attr.sequence[i]);
934: continue;
935: }
936: if ( t == FILING_version ) {
937: #ifdef DEBUG
938: fprintf(msgs,"version ");
939: #endif DEBUG
940: if ( got_version ) {
941: ReturnAttributeTypeError(FILING_duplicated, t);
942: /* NOT REACHED */
943: }
944: got_version++;
945:
946: version= AttrToCardinal(&attr.sequence[i]);
947: if ( version != FILING_highestVersion ) {
948: ReturnAttributeValueError(FILING_unimplemented, t);
949: /* NOT REACHED */
950:
951: }
952: continue;
953: }
954:
955: #ifdef FILETOOLCOMPATIBILITY
956: if ( t == FILING_name ) {
957: #ifdef DEBUG
958: fprintf(msgs, "name ");
959: #endif DEBUG
960: if ( got_name ) {
961: ReturnAttributeTypeError(FILING_duplicated, t);
962: /* NOT REACHED */
963: }
964: got_name++;
965:
966: name= AttrToString(&attr.sequence[i]);
967: continue;
968: }
969: #endif FILETOOLCOMPATIBILITY
970:
971: #ifdef SOMEDAY
972: if ( t == FILING_accessList ) {
973: if ( got_accesslist ) {
974: ReturnAttributeTypeError(FILING_duplicated, t);
975: /* NOT REACHED */
976: }
977:
978: got_accesslist++;
979:
980: if ( FALSE ) {
981: ReturnAttributeValueError(FILING_unimplemented, t);
982: /* NOT REACHED */
983: }
984:
985: continue;
986: }
987: #endif SOMEDAY
988:
989: if ( t == FILING_childrenUniquelyNamed ) {
990: if ( got_childrenuniquelynamed ) {
991: ReturnAttributeTypeError(FILING_duplicated, t);
992: /* NOT REACHED */
993: }
994:
995: got_childrenuniquelynamed++;
996:
997: childrenuniquelynamed= AttrToBoolean(&attr.sequence[i]);
998: if ( childrenuniquelynamed != TRUE ) {
999: ReturnAttributeValueError(FILING_unimplemented, t);
1000: /* NOT REACHED */
1001: }
1002:
1003: continue;
1004: }
1005:
1006:
1007: #ifdef SOMEDAY
1008: if ( t == FILING_defaultAccessList ) {
1009: if ( got_defaultaccesslist ) {
1010: ReturnAttributeTypeError(FILING_duplicated, t);
1011: /* NOT REACHED */
1012: }
1013:
1014: got_defaultaccesslist++;
1015:
1016: if ( FALSE ) {
1017: ReturnAttributeValueError(FILING_unimplemented, t);
1018: /* NOT REACHED */
1019: }
1020:
1021: continue;
1022: }
1023: #endif SOMEDAY
1024:
1025: if ( t == FILING_isTemporary ) {
1026: if ( got_istemporary ) {
1027: ReturnAttributeTypeError(FILING_duplicated, t);
1028: /* NOT REACHED */
1029: }
1030:
1031: got_istemporary++;
1032:
1033: istemporary= AttrToBoolean(&attr.sequence[i]);
1034: if ( istemporary != FALSE ) {
1035: ReturnAttributeValueError(FILING_unimplemented, t);
1036: /* NOT REACHED */
1037: }
1038:
1039: continue;
1040: }
1041:
1042: if ( t == FILING_ordering ) {
1043: if ( got_ordering ) {
1044: ReturnAttributeTypeError(FILING_duplicated, t);
1045: /* NOT REACHED */
1046: }
1047:
1048: got_ordering++;
1049:
1050: if ( FALSE ) {
1051: ReturnAttributeValueError(FILING_unimplemented, t);
1052: /* NOT REACHED */
1053: }
1054:
1055: continue;
1056: }
1057:
1058: if ( t == FILING_subtreeSizeLimit ) {
1059: if ( got_subtreesizelimit ) {
1060: ReturnAttributeTypeError(FILING_duplicated, t);
1061: /* NOT REACHED */
1062: }
1063:
1064: got_subtreesizelimit++;
1065:
1066: subtreesizelimit= AttrToCardinal(&attr.sequence[i]);
1067: if ( subtreesizelimit != FILING_nullSubtreeSizeLimit ) {
1068: ReturnAttributeValueError(FILING_unimplemented, t);
1069: /* NOT REACHED */
1070: }
1071:
1072: continue;
1073: }
1074:
1075: if ( (t == FILING_fileID) || (t == FILING_modifiedBy) ||
1076: (t == FILING_modifiedOn) ||
1077: (t == FILING_numberOfChildren) || (t == FILING_parentID) ||
1078: (t == FILING_readBy) || (t == FILING_readOn) ||
1079: (t == FILING_storedSize) || (t == FILING_subtreeSize) ) {
1080: ReturnAttributeTypeError(FILING_disallowed, t);
1081: }
1082:
1083: if ( t < 0 ) {
1084: ReturnAttributeTypeError(FILING_illegal, t);
1085: /* NOT REACHED */
1086: }
1087:
1088: if ( handle->type != TYPE_VP ) {
1089: if ( (t == FILING_checksum) || (t == FILING_createdBy) ||
1090: (t == FILING_position) )
1091: ReturnAttributeTypeError(FILING_unimplemented, t);
1092: else
1093: ReturnAttributeTypeError(FILING_disallowed, t);
1094: }
1095: }
1096:
1097: #ifdef DEBUG
1098: fprintf(msgs, "\n");
1099: #endif DEBUG
1100:
1101: #ifdef FILETOOLCOMPATIBILITY
1102: if ( !got_pathname && !got_name) {
1103: handle->pathname= SERVICE_ROOT;
1104: } else if ( !got_pathname ) {
1105: strcat(handle->pathname,name);
1106: } else {
1107: if ( *pathname == '/' )
1108: strcat(handle->pathname, pathname+1);
1109: else
1110: strcat(handle->pathname,pathname);
1111: Deallocate(&pathname);
1112: }
1113:
1114: #else FILETOOLCOMPATIBILITY
1115: if ( !got_pathname ) {
1116: ReturnAttributeTypeError(FILING_missing, t);
1117: /* NOT REACHED */
1118: } else {
1119: if ( *pathname == '/' )
1120: strcat(handle->pathname, pathname+1);
1121: else
1122: strcat(handle->pathname, pathname);
1123: Deallocate(&pathname);
1124: }
1125: #endif FILETOOLCOMPATIBILITY
1126:
1127: if ( !got_type )
1128: handle->type= FILING_tUnspecified;
1129:
1130: if ( !got_createdon )
1131: handle->createdon= 0;
1132:
1133: if ( !got_isdirectory ) {
1134: if ( handle->type == FILING_tDirectory )
1135: handle->isdirectory= TRUE;
1136: else
1137: handle->isdirectory= FALSE;
1138: } else {
1139: if ( ((handle->isdirectory == TRUE) && (handle->type != FILING_tDirectory)) ||
1140: ((handle->isdirectory == FALSE) && (handle->type == FILING_tDirectory)) ) {
1141: ReturnAttributeTypeError(FILING_unreasonable, FILING_isDirectory);
1142: /* NOT REACHED */
1143: }
1144: }
1145:
1146: return(-1);
1147: }
1148: #endif EXTENSIONS
1149:
1150:
1151: void FILING_Delete(ServerConnection, BDTProc, file, session)
1152: CourierConnection *ServerConnection;
1153: int ( *BDTProc)();
1154: FILING_Handle file;
1155: FILING_Session session;
1156: {
1157: file_handle *handle;
1158:
1159: BDTabort_expected= FALSE;
1160: #ifdef DEBUG
1161: if (msgs == 0) {
1162: char logfile[50];
1163: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
1164: msgs= fopen(logfile,"w");
1165: }
1166: fprintf(msgs, "Delete\n");
1167: #endif DEBUG
1168:
1169: if ( verify_session(session) != -1 ) {
1170: /* NOT REACHED */
1171: }
1172:
1173: if ( is_nullHandle(file) == -1 ) {
1174: ReturnHandleError(FILING_nullDisallowed);
1175: /* NOT REACHED */
1176: }
1177:
1178: copyhandle(&handle,file);
1179:
1180: if ( handle->state != FILE_OPEN ) {
1181: ReturnHandleError(FILING_invalid);
1182: /* NOT REACHED */
1183: }
1184:
1185: if ( access_file(handle) != -1 ) {
1186: /* NOT REACHED */
1187: }
1188:
1189: close_file(handle); /* do it now */
1190:
1191: if ( delete_file(handle) != -1 ) {
1192: /* NOT REACHED */
1193: }
1194:
1195: handle->state= FILE_CLOSED;
1196: handle->pathname= (char *)0;
1197:
1198: free(handle);
1199: reset_continuance_timer();
1200:
1201: return;
1202: }
1203:
1204:
1205: FILING_GetControlsResults FILING_GetControls(ServerConnection, BDTProc, file, types, session)
1206: CourierConnection *ServerConnection;
1207: int ( *BDTProc)();
1208: FILING_Handle file;
1209: FILING_ControlTypeSequence types;
1210: FILING_Session session;
1211: {
1212: NoSuchProcedureValue("Filing", 6);
1213: }
1214:
1215:
1216: void FILING_ChangeControls(ServerConnection, BDTProc, file, controls, session)
1217: CourierConnection *ServerConnection;
1218: int ( *BDTProc)();
1219: FILING_Handle file;
1220: FILING_ControlSequence controls;
1221: FILING_Session session;
1222: {
1223: NoSuchProcedureValue("Filing", 7);
1224: }
1225:
1226:
1227: FILING_GetAttributesResults FILING_GetAttributes(ServerConnection, BDTProc, file, types, session)
1228: CourierConnection *ServerConnection;
1229: int ( *BDTProc)();
1230: FILING_Handle file;
1231: FILING_AttributeTypeSequence types;
1232: FILING_Session session;
1233: {
1234: #ifdef EXTENSIONS
1235: file_handle *handle;
1236: FILING_GetAttributesResults results;
1237:
1238: #ifdef DEBUG
1239: if (msgs == 0) {
1240: char logfile[50];
1241: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
1242: msgs= fopen(logfile,"w");
1243: }
1244: fprintf(msgs, "Getattributes\n");
1245: #endif DEBUG
1246:
1247: BDTabort_expected= FALSE;
1248:
1249: if ( verify_session(session) != -1 ) {
1250: /* NOT REACHED */
1251: }
1252:
1253: if ( is_nullHandle(file) == -1 ) {
1254: ReturnHandleError(FILING_nullDisallowed);
1255: /* NOT REACHED */
1256: }
1257:
1258: copyhandle(&handle,file);
1259:
1260: if ( handle->state != FILE_OPEN ) {
1261: ReturnHandleError(FILING_invalid);
1262: /* NOT REACHED */
1263: }
1264:
1265: if ( access_file(handle) != -1 ) {
1266: /* NOT REACHED */
1267: }
1268:
1269: close_file(handle); /* do it now */
1270:
1271: if ( get_types(types,&results.attributes) != -1 ) {
1272: /* NOT REACHED */
1273: }
1274:
1275: make_attribute_sequence(handle->pathname,&results.attributes);
1276:
1277: return(results);
1278: #else EXTENSIONS
1279: NoSuchProcedureValue("Filing", 8);
1280: #endif EXTENSIONS
1281: }
1282:
1283: get_types(types, attrseq)
1284: FILING_AttributeTypeSequence types;
1285: FILING_AttributeSequence *attrseq;
1286: {
1287: int i;
1288: LongCardinal t;
1289:
1290: if ( types.length <= 0 ) {
1291: ReturnAttributeTypeError(FILING_illegal, 0);
1292: /* NOT REACHED */
1293: }
1294:
1295: #ifdef EXTENSIONS
1296: if ( *(types.sequence) == 037777777777 ) {
1297: #ifdef DEBUG
1298: fprintf(msgs, "get_types: asking for all\n");
1299: #endif DEBUG
1300: attrseq->length= -1;
1301: attrseq->sequence= (FILING_Attribute *)
1302: Allocate((SUPPORTEDATTRIBUTES + OPTIONALATTRIBUTES) * sizeof(FILING_Attribute)/sizeof(Unspecified));
1303: } else {
1304: #endif EXTENSIONS
1305: attrseq->length= types.length;
1306: attrseq->sequence= (FILING_Attribute *)
1307: Allocate(types.length * sizeof(FILING_Attribute)/sizeof(Unspecified));
1308:
1309: #ifdef DEBUG
1310: fprintf(msgs, "get_types: asking for ");
1311: #endif DEBUG
1312:
1313: for ( i = 0; i < types.length ; i ++ ) {
1314: t= types.sequence[i];
1315:
1316: #ifdef DEBUG
1317: fprintf(msgs, "%d ",t);
1318: #endif DEBUG
1319:
1320:
1321: if ( (t < 0) || ( t > FILING_subtreeSizeLimit) ) {
1322: #ifdef FILETOOLCOMPATIBILITY
1323: if ( t != 4938 ) {
1324: ReturnAttributeTypeError(FILING_illegal, t);
1325: /* NOT REACHED */
1326: }
1327: #else FILETOOLCOMPATIBILITY
1328: ReturnAttributeTypeError(FILING_illegal, t);
1329: /* NOT REACHED */
1330: #endif FILETOOLCOMPATIBILITY
1331: }
1332:
1333: if ( (t != FILING_createdOn) && (t != FILING_modifiedOn) &&
1334: (t != FILING_isDirectory) && (t != FILING_isTemporary) &&
1335: (t != FILING_name) && (t != FILING_pathname) &&
1336: #ifndef FILETOOLCOMPATIBILITY
1337: (t != FILING_dataSize) && (t != FILING_type) &&
1338: (t != FILING_version) ) {
1339: #else FILETOOLCOMPATIBILITY
1340: (t != FILING_dataSize) && (t != FILING_type) &&
1341: (t != FILING_createdBy) && (t != FILING_readOn) &&
1342: (t != FILING_version) && (t != FILING_fileID) &&
1343: (t != 4938) ) {
1344: #endif FILETOOLCOMPATIBILITY
1345: ReturnAttributeTypeError(FILING_disallowed, t);
1346: /* NOT REACHED */
1347: }
1348: attrseq->sequence[i].type= t;
1349: }
1350: #ifdef EXTENSIONS
1351: }
1352: #endif EXTENSIONS
1353: #ifdef DEBUG
1354: fprintf(msgs, "\n");
1355: #endif DEBUG
1356: }
1357:
1358: #ifdef EXTENSIONS
1359: make_supported_attributes(attrseq)
1360: FILING_AttributeSequence *attrseq;
1361:
1362: {
1363: attrseq->length= SUPPORTEDATTRIBUTES;
1364: attrseq->sequence[0].type= FILING_createdOn;
1365: attrseq->sequence[1].type= FILING_isDirectory;
1366: attrseq->sequence[2].type= FILING_modifiedOn;
1367: attrseq->sequence[3].type= FILING_name;
1368: attrseq->sequence[4].type= FILING_dataSize;
1369: attrseq->sequence[5].type= FILING_type;
1370: attrseq->sequence[6].type= FILING_version;
1371: attrseq->sequence[7].type= FILING_pathname;
1372: }
1373:
1374: make_required_attributes(attrseq)
1375: FILING_AttributeSequence *attrseq;
1376:
1377: {
1378: attrseq->length= REQUIREDATTRIBUTES;
1379: attrseq->sequence[0].type= FILING_createdOn;
1380: attrseq->sequence[1].type= FILING_modifiedOn;
1381: attrseq->sequence[2].type= FILING_name;
1382: attrseq->sequence[3].type= FILING_dataSize;
1383: attrseq->sequence[4].type= FILING_version;
1384: attrseq->sequence[5].type= FILING_pathname;
1385: }
1386: #endif EXTENSIONS
1387:
1388: void FILING_ChangeAttributes(ServerConnection, BDTProc, file, attributes, session)
1389: CourierConnection *ServerConnection;
1390: int ( *BDTProc)();
1391: FILING_Handle file;
1392: FILING_AttributeSequence attributes;
1393: FILING_Session session;
1394: {
1395: #ifdef EXTENSIONS
1396: file_handle *handle;
1397: char oldname[MAX_FILE_NAME_LENGTH];
1398:
1399: #ifdef DEBUG
1400: if (msgs == 0) {
1401: char logfile[50];
1402: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
1403: msgs= fopen(logfile,"w");
1404: }
1405: fprintf(msgs, "ChangeAttributes\n");
1406: #endif DEBUG
1407:
1408: if ( verify_session(session) != -1 ) {
1409: /* NOT REACHED */
1410: }
1411:
1412: if ( is_nullHandle(file) == -1 ) {
1413: ReturnHandleError(FILING_nullDisallowed);
1414: /* NOT REACHED */
1415: }
1416:
1417: copyhandle(&handle,file);
1418:
1419: if ( handle->state != FILE_OPEN ) {
1420: ReturnHandleError(FILING_invalid);
1421: /* NOT REACHED */
1422: }
1423:
1424: if ( access_file(handle) != -1 ) {
1425: /* NOT REACHED */
1426: }
1427:
1428: close_file(handle); /* do it now */
1429:
1430: strcpy(oldname, handle->pathname);
1431:
1432: if ( verify_change_attributes(attributes, handle) != -1 ) {
1433: /* NOT REACHED */
1434: }
1435:
1436: if ( strcmp(oldname, handle->pathname) != 0 ) {
1437: rename_file(oldname, handle);
1438: }
1439:
1440: set_create_time(handle);
1441:
1442: return;
1443: #else EXTENSIONS
1444: NoSuchProcedureValue("Filing", 9);
1445: #endif EXTENSIONS
1446: }
1447: #ifdef EXTENSIONS
1448: verify_change_attributes(attr, handle)
1449: FILING_AttributeSequence attr;
1450: file_handle *handle;
1451: {
1452: int i;
1453: FILING_AttributeType t;
1454: int got_accesslist, got_childrenuniquelynamed, got_createdon, got_datasize;
1455: int got_defaultaccesslist, got_ordering;
1456: int got_subtreesizelimit, got_type, got_version;
1457: FILING_Version version;
1458: Boolean childrenuniquelynamed;
1459: Cardinal ordering;
1460: Cardinal subtreesizelimit;
1461: char *AttrToString();
1462: LongCardinal AttrToLongCardinal();
1463:
1464: int got_name;
1465: char *name;
1466:
1467: #ifdef DEBUG
1468: fprintf(msgs,"%d change attributes ",attr.length);
1469: #endif DEBUG
1470:
1471: if ( attr.length < 0 ) {
1472: ReturnAttributeTypeError(FILING_illegal, 0);
1473: /* NOT REACHED */
1474: }
1475:
1476: got_accesslist= got_childrenuniquelynamed= got_createdon= 0;
1477: got_datasize= got_defaultaccesslist= 0;
1478: got_ordering= got_subtreesizelimit= got_type= got_version= 0;
1479: got_name= 0;
1480:
1481: for ( i= 0 ; i < attr.length ; i++ ) {
1482: t= attr.sequence[i].type;
1483: #ifdef DEBUG
1484: fprintf(msgs, "%d ",t);
1485: #endif DEBUG
1486: if ( t == FILING_createdOn ) {
1487: #ifdef DEBUG
1488: fprintf(msgs,"createdOn ");
1489: #endif DEBUG
1490: if ( got_createdon ) {
1491: ReturnAttributeTypeError(FILING_duplicated, t);
1492: /* NOT REACHED */
1493: }
1494: got_createdon++;
1495:
1496: handle->createdon= AttrToLongCardinal(&attr.sequence[i]);
1497: continue;
1498: }
1499:
1500: if ( t == FILING_dataSize ) {
1501: #ifdef DEBUG
1502: fprintf(msgs,"dataSize ");
1503: #endif DEBUG
1504: if ( got_datasize ) {
1505: ReturnAttributeTypeError(FILING_duplicated, t);
1506: /* NOT REACHED */
1507: }
1508: got_datasize++;
1509:
1510: handle->datasize= AttrToLongCardinal(&attr.sequence[i]);
1511: continue;
1512: }
1513:
1514: if ( t == FILING_type ) {
1515: #ifdef DEBUG
1516: fprintf(msgs,"type ");
1517: #endif DEBUG
1518: if ( got_type ) {
1519: ReturnAttributeTypeError(FILING_duplicated, t);
1520: /* NOT REACHED */
1521: }
1522: got_type++;
1523:
1524: handle->type= AttrToLongCardinal(&attr.sequence[i]);
1525: continue;
1526: }
1527: if ( t == FILING_version ) {
1528: #ifdef DEBUG
1529: fprintf(msgs,"version ");
1530: #endif DEBUG
1531: if ( got_version ) {
1532: ReturnAttributeTypeError(FILING_duplicated, t);
1533: /* NOT REACHED */
1534: }
1535: got_version++;
1536:
1537: version= AttrToCardinal(&attr.sequence[i]);
1538: if ( version != FILING_highestVersion ) {
1539: ReturnAttributeValueError(FILING_unimplemented, t);
1540: /* NOT REACHED */
1541:
1542: }
1543: continue;
1544: }
1545:
1546: if ( t == FILING_name ) {
1547: #ifdef DEBUG
1548: fprintf(msgs, "name ");
1549: #endif DEBUG
1550: if ( got_name ) {
1551: ReturnAttributeTypeError(FILING_duplicated, t);
1552: /* NOT REACHED */
1553: }
1554: got_name++;
1555:
1556: name= AttrToString(&attr.sequence[i]);
1557: continue;
1558: }
1559:
1560: #ifdef SOMEDAY
1561: if ( t == FILING_accessList ) {
1562: if ( got_accesslist ) {
1563: ReturnAttributeTypeError(FILING_duplicated, t);
1564: /* NOT REACHED */
1565: }
1566:
1567: got_accesslist++;
1568:
1569: if ( FALSE ) {
1570: ReturnAttributeValueError(FILING_unimplemented, t);
1571: /* NOT REACHED */
1572: }
1573:
1574: continue;
1575: }
1576: #endif SOMEDAY
1577:
1578: if ( t == FILING_childrenUniquelyNamed ) {
1579: if ( got_childrenuniquelynamed ) {
1580: ReturnAttributeTypeError(FILING_duplicated, t);
1581: /* NOT REACHED */
1582: }
1583:
1584: got_childrenuniquelynamed++;
1585:
1586: childrenuniquelynamed= AttrToBoolean(&attr.sequence[i]);
1587: if ( childrenuniquelynamed != TRUE ) {
1588: ReturnAttributeValueError(FILING_unimplemented, t);
1589: /* NOT REACHED */
1590: }
1591:
1592: continue;
1593: }
1594:
1595:
1596: #ifdef SOMEDAY
1597: if ( t == FILING_defaultAccessList ) {
1598: if ( got_defaultaccesslist ) {
1599: ReturnAttributeTypeError(FILING_duplicated, t);
1600: /* NOT REACHED */
1601: }
1602:
1603: got_defaultaccesslist++;
1604:
1605: if ( FALSE ) {
1606: ReturnAttributeValueError(FILING_unimplemented, t);
1607: /* NOT REACHED */
1608: }
1609:
1610: continue;
1611: }
1612: #endif SOMEDAY
1613:
1614: if ( t == FILING_ordering ) {
1615: if ( got_ordering ) {
1616: ReturnAttributeTypeError(FILING_duplicated, t);
1617: /* NOT REACHED */
1618: }
1619:
1620: got_ordering++;
1621:
1622: if ( FALSE ) {
1623: ReturnAttributeValueError(FILING_unimplemented, t);
1624: /* NOT REACHED */
1625: }
1626:
1627: continue;
1628: }
1629:
1630: if ( t == FILING_subtreeSizeLimit ) {
1631: if ( got_subtreesizelimit ) {
1632: ReturnAttributeTypeError(FILING_duplicated, t);
1633: /* NOT REACHED */
1634: }
1635:
1636: got_subtreesizelimit++;
1637:
1638: subtreesizelimit= AttrToCardinal(&attr.sequence[i]);
1639: if ( subtreesizelimit != FILING_nullSubtreeSizeLimit ) {
1640: ReturnAttributeValueError(FILING_unimplemented, t);
1641: /* NOT REACHED */
1642: }
1643:
1644: continue;
1645: }
1646:
1647: if ( (t == FILING_fileID) || (t == FILING_isDirectory) ||
1648: (t == FILING_isTemporary) || (t == FILING_modifiedBy) ||
1649: (t == FILING_modifiedOn) || (t == FILING_numberOfChildren) ||
1650: (t == FILING_parentID) || (t == FILING_pathname) ||
1651: (t == FILING_readBy) || (t == FILING_readOn) ||
1652: (t == FILING_storedSize) || (t == FILING_subtreeSize) ) {
1653: ReturnAttributeTypeError(FILING_disallowed, t);
1654: }
1655:
1656: if ( t < 0 ) {
1657: ReturnAttributeTypeError(FILING_illegal, t);
1658: /* NOT REACHED */
1659: }
1660:
1661: if ( (t == FILING_checksum) || (t == FILING_createdBy) ||
1662: (t == FILING_position) )
1663: ReturnAttributeTypeError(FILING_unimplemented, t);
1664: else
1665: ReturnAttributeTypeError(FILING_disallowed, t);
1666:
1667: }
1668:
1669: #ifdef DEBUG
1670: fprintf(msgs, "\n");
1671: #endif DEBUG
1672:
1673: if ( got_name ) {
1674: char *ptr, *rindex();
1675: if ( (ptr= rindex(handle->pathname, '/')) == 0 ) {
1676: ptr= handle->pathname;
1677: } else {
1678: ptr++;
1679: *ptr= '\0';
1680: }
1681: strcat(handle->pathname, name);
1682: }
1683:
1684: return(-1);
1685: }
1686: #endif EXTENSIONS
1687:
1688:
1689: FILING_CopyResults FILING_Copy(ServerConnection, BDTProc, file, destdir, attributes, controls, session)
1690: CourierConnection *ServerConnection;
1691: int ( *BDTProc)();
1692: FILING_Handle file;
1693: FILING_Handle destdir;
1694: FILING_AttributeSequence attributes;
1695: FILING_ControlSequence controls;
1696: FILING_Session session;
1697: {
1698: #ifdef EXTENSIONS
1699: FILING_CopyResults results;
1700: file_handle *handle;
1701: file_handle *dir_handle;
1702: file_handle *new_handle;
1703:
1704: #ifdef DEBUG
1705: if (msgs == 0) {
1706: char logfile[50];
1707: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
1708: msgs= fopen(logfile,"w");
1709: }
1710: fprintf(msgs, "Copy\n");
1711: #endif DEBUG
1712:
1713: BDTabort_expected= FALSE;
1714:
1715: if ( verify_session(session) != -1 ) {
1716: /* NOT REACHED */
1717: }
1718:
1719: copyhandle(&handle, file);
1720:
1721: if ( handle->state != FILE_OPEN ) {
1722: ReturnHandleError(FILING_invalid);
1723: /* NOT REACHED */
1724: }
1725:
1726: if ( access_file(handle) != -1 ) {
1727: /* NOT REACHED */
1728: }
1729:
1730: if ( (new_handle= (file_handle *)malloc(sizeof(file_handle))) == NULL ) {
1731: ReturnUndefinedError(0);
1732: /* NOT REACHED */
1733: }
1734:
1735: if ( (new_handle->pathname= (char *)malloc(MAX_FILE_NAME_LENGTH)) == NULL ) {
1736: ReturnUndefinedError(0);
1737: /* NOT REACHED */
1738: }
1739:
1740: #ifdef DEBUG
1741: fprintf(msgs, "copy handle= %x\n",new_handle);
1742: #endif DEBUG
1743:
1744: copyhandle(&dir_handle,destdir);
1745:
1746: if ( dir_handle == 0 ) {
1747: dir_handle= &RootHandle;
1748: strcpy(new_handle->pathname, SERVICE_ROOT);
1749: } else {
1750: if ( dir_handle->state != FILE_OPEN ) {
1751: ReturnHandleError(FILING_invalid);
1752: /* NOT REACHED */
1753: }
1754:
1755: if ( access_file(dir_handle) != -1 ) {
1756: /* NOT REACHED */
1757: }
1758:
1759: if ( dir_handle->isdirectory != TRUE ) {
1760: ReturnHandleError(FILING_directoryRequired);
1761: /* NOT REACHED */
1762: }
1763:
1764: strcpy(new_handle->pathname,dir_handle->pathname);
1765: if ( strcmp(new_handle->pathname, "/") != 0 )
1766: strcat(new_handle->pathname,"/");
1767: }
1768:
1769: if ( verify_copy_attributes(attributes,new_handle,handle) != -1 ) {
1770: /* NOT REACHED */
1771: }
1772:
1773: close_file(handle);
1774:
1775: #ifdef DEBUG
1776: fprintf(msgs, "copying %s to %s\n", handle->pathname, new_handle->pathname);
1777: fflush(msgs);
1778: #endif DEBUG
1779:
1780: if ( copy_file(handle, new_handle) != -1 ) {
1781: /* NOT REACHED */
1782: }
1783:
1784: new_handle->state= FILE_OPEN;
1785: new_handle->file_desc= NULL;
1786:
1787: copyhandle(results.newFile, &new_handle);
1788: reset_continuance_timer();
1789: return(results);
1790:
1791: #else EXTENSIONS
1792: NoSuchProcedureValue("Filing", 10);
1793: #endif EXTENSIONS
1794: }
1795: #ifdef EXTENSIONS
1796: verify_copy_attributes(attr, tohandle, fromhandle)
1797: FILING_AttributeSequence attr;
1798: file_handle *tohandle;
1799: file_handle *fromhandle;
1800: {
1801: int i;
1802: FILING_AttributeType t;
1803: int got_accesslist, got_defaultaccesslist, got_istemporary;
1804: int got_name, got_pathname, got_subtreesizelimit, got_version;
1805: char *pathname;
1806: char *name;
1807: FILING_Version version;
1808: Boolean istemporary;
1809: Cardinal subtreesizelimit;
1810: char *AttrToString();
1811: LongCardinal AttrToLongCardinal();
1812:
1813: #ifdef DEBUG
1814: fprintf(msgs,"%d copy attributes ",attr.length);
1815: #endif DEBUG
1816:
1817: if ( attr.length < 0 ) {
1818: ReturnAttributeTypeError(FILING_illegal, 0);
1819: /* NOT REACHED */
1820: }
1821:
1822: got_accesslist= got_defaultaccesslist= got_istemporary= 0;
1823: got_name= got_pathname= got_subtreesizelimit= got_version= 0;
1824:
1825: for ( i= 0 ; i < attr.length ; i++ ) {
1826: t= attr.sequence[i].type;
1827: #ifdef DEBUG
1828: fprintf(msgs, "%d ",t);
1829: #endif DEBUG
1830:
1831: if ( t == FILING_pathname ) {
1832: #ifdef DEBUG
1833: fprintf(msgs,"pathname ");
1834: #endif DEBUG
1835: if ( got_pathname ) {
1836: ReturnAttributeTypeError(FILING_duplicated, t);
1837: /* NOT REACHED */
1838: }
1839: got_pathname++;
1840:
1841: pathname= AttrToString(&attr.sequence[i]);
1842: if ( check_pathname(pathname) != -1 ) {
1843: /* NOT REACHED */
1844: }
1845: continue;
1846: }
1847:
1848: if ( t == FILING_version ) {
1849: #ifdef DEBUG
1850: fprintf(msgs,"version ");
1851: #endif DEBUG
1852: if ( got_version ) {
1853: ReturnAttributeTypeError(FILING_duplicated, t);
1854: /* NOT REACHED */
1855: }
1856: got_version++;
1857:
1858: version= AttrToCardinal(&attr.sequence[i]);
1859: if ( version != FILING_highestVersion ) {
1860: ReturnAttributeValueError(FILING_unimplemented, t);
1861: /* NOT REACHED */
1862:
1863: }
1864: continue;
1865: }
1866:
1867:
1868: if ( t == FILING_name ) {
1869: #ifdef DEBUG
1870: fprintf(msgs, "name ");
1871: #endif DEBUG
1872: if ( got_name ) {
1873: ReturnAttributeTypeError(FILING_duplicated, t);
1874: /* NOT REACHED */
1875: }
1876: got_name++;
1877:
1878: name= AttrToString(&attr.sequence[i]);
1879: continue;
1880: }
1881:
1882: #ifdef SOMEDAY
1883: if ( t == FILING_accessList ) {
1884: if ( got_accesslist ) {
1885: ReturnAttributeTypeError(FILING_duplicated, t);
1886: /* NOT REACHED */
1887: }
1888:
1889: got_accesslist++;
1890:
1891: if ( FALSE ) {
1892: ReturnAttributeValueError(FILING_unimplemented, t);
1893: /* NOT REACHED */
1894: }
1895:
1896: continue;
1897: }
1898:
1899: if ( t == FILING_defaultAccessList ) {
1900: if ( got_defaultaccesslist ) {
1901: ReturnAttributeTypeError(FILING_duplicated, t);
1902: /* NOT REACHED */
1903: }
1904:
1905: got_defaultaccesslist++;
1906:
1907: if ( FALSE ) {
1908: ReturnAttributeValueError(FILING_unimplemented, t);
1909: /* NOT REACHED */
1910: }
1911:
1912: continue;
1913: }
1914: #endif SOMEDAY
1915:
1916: if ( t == FILING_isTemporary ) {
1917: if ( got_istemporary ) {
1918: ReturnAttributeTypeError(FILING_duplicated, t);
1919: /* NOT REACHED */
1920: }
1921:
1922: got_istemporary++;
1923:
1924: istemporary= AttrToBoolean(&attr.sequence[i]);
1925: if ( istemporary != FALSE ) {
1926: ReturnAttributeValueError(FILING_unimplemented, t);
1927: /* NOT REACHED */
1928: }
1929:
1930: continue;
1931: }
1932:
1933: if ( t == FILING_subtreeSizeLimit ) {
1934: if ( got_subtreesizelimit ) {
1935: ReturnAttributeTypeError(FILING_duplicated, t);
1936: /* NOT REACHED */
1937: }
1938:
1939: got_subtreesizelimit++;
1940:
1941: subtreesizelimit= AttrToCardinal(&attr.sequence[i]);
1942: if ( subtreesizelimit != FILING_nullSubtreeSizeLimit ) {
1943: ReturnAttributeValueError(FILING_unimplemented, t);
1944: /* NOT REACHED */
1945: }
1946:
1947: continue;
1948: }
1949:
1950: if ( t == FILING_position ) {
1951: ReturnAttributeTypeError(FILING_unimplemented, t);
1952: /* NOT REACHED */
1953: }
1954:
1955: if ( ( t < 0 ) || (t > FILING_subtreeSizeLimit) ) {
1956: ReturnAttributeTypeError(FILING_illegal, t);
1957: /* NOT REACHED */
1958: }
1959:
1960: ReturnAttributeTypeError(FILING_disallowed, t);
1961: }
1962:
1963: #ifdef DEBUG
1964: fprintf(msgs, "\n");
1965: #endif DEBUG
1966:
1967: #ifdef FILETOOLCOMPATIBILITY
1968: if ( !got_pathname && !got_name) {
1969: char *ptr, *rindex();
1970: if ( (ptr= rindex(fromhandle->pathname,'/')) == 0 )
1971: ptr= fromhandle->pathname;
1972: else
1973: ptr++;
1974: strcat(tohandle->pathname, ptr);
1975: } else if ( !got_pathname ) {
1976: strcat(tohandle->pathname,name);
1977: } else {
1978: if ( *pathname == '/' )
1979: strcat(tohandle->pathname, pathname+1);
1980: else
1981: strcat(tohandle->pathname,pathname);
1982: Deallocate(&pathname);
1983: }
1984:
1985: #else FILETOOLCOMPATIBILITY
1986: if ( !got_pathname ) {
1987: ReturnAttributeTypeError(FILING_missing, t);
1988: /* NOT REACHED */
1989: } else {
1990: if ( *pathname == '/' )
1991: strcat(tohandle->pathname, pathname+1);
1992: else
1993: strcat(tohandle->pathname, pathname);
1994: Deallocate(&pathname);
1995: }
1996: #endif FILETOOLCOMPATIBILITY
1997:
1998: return(-1);
1999: }
2000: #endif EXTENSIONS
2001:
2002:
2003: void FILING_Move(ServerConnection, BDTProc, file, destdir, attributes, session)
2004: CourierConnection *ServerConnection;
2005: int ( *BDTProc)();
2006: FILING_Handle file;
2007: FILING_Handle destdir;
2008: FILING_AttributeSequence attributes;
2009: FILING_Session session;
2010: {
2011: #ifdef EXTENSIONS
2012: file_handle *handle;
2013: file_handle *dir_handle;
2014: char oldname[MAX_FILE_NAME_LENGTH];
2015:
2016: #ifdef DEBUG
2017: if (msgs == 0) {
2018: char logfile[50];
2019: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
2020: msgs= fopen(logfile,"w");
2021: }
2022: fprintf(msgs, "Move\n");
2023: #endif DEBUG
2024:
2025: BDTabort_expected= FALSE;
2026:
2027: if ( verify_session(session) != -1 ) {
2028: /* NOT REACHED */
2029: }
2030:
2031: copyhandle(&handle, file);
2032:
2033: if ( handle->state != FILE_OPEN ) {
2034: ReturnHandleError(FILING_invalid);
2035: /* NOT REACHED */
2036: }
2037:
2038: if ( access_file(handle) != -1 ) {
2039: /* NOT REACHED */
2040: }
2041:
2042: strcpy(oldname, handle->pathname);
2043:
2044: copyhandle(&dir_handle,destdir);
2045:
2046: if ( dir_handle == 0 ) {
2047: dir_handle= &RootHandle;
2048: strcpy(handle->pathname, SERVICE_ROOT);
2049: } else {
2050: if ( dir_handle->state != FILE_OPEN ) {
2051: ReturnHandleError(FILING_invalid);
2052: /* NOT REACHED */
2053: }
2054:
2055: if ( access_file(dir_handle) != -1 ) {
2056: /* NOT REACHED */
2057: }
2058:
2059: if ( dir_handle->isdirectory != TRUE ) {
2060: ReturnHandleError(FILING_directoryRequired);
2061: /* NOT REACHED */
2062: }
2063:
2064: strcpy(handle->pathname,dir_handle->pathname);
2065: if ( strcmp(handle->pathname, "/") != 0 )
2066: strcat(handle->pathname,"/");
2067: }
2068:
2069:
2070: if ( verify_move_attributes(attributes,handle,oldname) != -1 ) {
2071: /* NOT REACHED */
2072: }
2073:
2074: close_file(handle);
2075:
2076: #ifdef DEBUG
2077: fprintf(msgs, "moving %s to %s\n", oldname, handle->pathname);
2078: #endif DEBUG
2079:
2080: if ( rename_file(oldname, handle) != -1 ) {
2081: /* NOT REACHED */
2082: }
2083:
2084: reset_continuance_timer();
2085: return;
2086:
2087: #else EXTENSIONS
2088: NoSuchProcedureValue("Filing", 11);
2089: #endif EXTENSIONS
2090: }
2091: #ifdef EXTENSIONS
2092: verify_move_attributes(attr, tohandle, fromname)
2093: FILING_AttributeSequence attr;
2094: file_handle *tohandle;
2095: char *fromname;
2096: {
2097: int i;
2098: FILING_AttributeType t;
2099: int got_accesslist, got_defaultaccesslist, got_istemporary;
2100: int got_name, got_subtreesizelimit, got_version;
2101: char *name;
2102: FILING_Version version;
2103: Boolean istemporary;
2104: Cardinal subtreesizelimit;
2105: char *AttrToString();
2106: LongCardinal AttrToLongCardinal();
2107:
2108: #ifdef DEBUG
2109: fprintf(msgs,"%d move attributes ",attr.length);
2110: #endif DEBUG
2111:
2112: if ( attr.length < 0 ) {
2113: ReturnAttributeTypeError(FILING_illegal, 0);
2114: /* NOT REACHED */
2115: }
2116:
2117: got_accesslist= got_defaultaccesslist= got_istemporary= 0;
2118: got_name= got_subtreesizelimit= got_version= 0;
2119:
2120: for ( i= 0 ; i < attr.length ; i++ ) {
2121: t= attr.sequence[i].type;
2122: #ifdef DEBUG
2123: fprintf(msgs, "%d ",t);
2124: #endif DEBUG
2125:
2126: if ( t == FILING_version ) {
2127: #ifdef DEBUG
2128: fprintf(msgs,"version ");
2129: #endif DEBUG
2130: if ( got_version ) {
2131: ReturnAttributeTypeError(FILING_duplicated, t);
2132: /* NOT REACHED */
2133: }
2134: got_version++;
2135:
2136: version= AttrToCardinal(&attr.sequence[i]);
2137: if ( version != FILING_highestVersion ) {
2138: ReturnAttributeValueError(FILING_unimplemented, t);
2139: /* NOT REACHED */
2140:
2141: }
2142: continue;
2143: }
2144:
2145:
2146: if ( t == FILING_name ) {
2147: #ifdef DEBUG
2148: fprintf(msgs, "name ");
2149: #endif DEBUG
2150: if ( got_name ) {
2151: ReturnAttributeTypeError(FILING_duplicated, t);
2152: /* NOT REACHED */
2153: }
2154: got_name++;
2155:
2156: name= AttrToString(&attr.sequence[i]);
2157: continue;
2158: }
2159:
2160: #ifdef SOMEDAY
2161: if ( t == FILING_accessList ) {
2162: if ( got_accesslist ) {
2163: ReturnAttributeTypeError(FILING_duplicated, t);
2164: /* NOT REACHED */
2165: }
2166:
2167: got_accesslist++;
2168:
2169: if ( FALSE ) {
2170: ReturnAttributeValueError(FILING_unimplemented, t);
2171: /* NOT REACHED */
2172: }
2173:
2174: continue;
2175: }
2176:
2177: if ( t == FILING_defaultAccessList ) {
2178: if ( got_defaultaccesslist ) {
2179: ReturnAttributeTypeError(FILING_duplicated, t);
2180: /* NOT REACHED */
2181: }
2182:
2183: got_defaultaccesslist++;
2184:
2185: if ( FALSE ) {
2186: ReturnAttributeValueError(FILING_unimplemented, t);
2187: /* NOT REACHED */
2188: }
2189:
2190: continue;
2191: }
2192: #endif SOMEDAY
2193:
2194: if ( t == FILING_isTemporary ) {
2195: if ( got_istemporary ) {
2196: ReturnAttributeTypeError(FILING_duplicated, t);
2197: /* NOT REACHED */
2198: }
2199:
2200: got_istemporary++;
2201:
2202: istemporary= AttrToBoolean(&attr.sequence[i]);
2203: if ( istemporary != FALSE ) {
2204: ReturnAttributeValueError(FILING_unimplemented, t);
2205: /* NOT REACHED */
2206: }
2207:
2208: continue;
2209: }
2210:
2211: if ( t == FILING_subtreeSizeLimit ) {
2212: if ( got_subtreesizelimit ) {
2213: ReturnAttributeTypeError(FILING_duplicated, t);
2214: /* NOT REACHED */
2215: }
2216:
2217: got_subtreesizelimit++;
2218:
2219: subtreesizelimit= AttrToCardinal(&attr.sequence[i]);
2220: if ( subtreesizelimit != FILING_nullSubtreeSizeLimit ) {
2221: ReturnAttributeValueError(FILING_unimplemented, t);
2222: /* NOT REACHED */
2223: }
2224:
2225: continue;
2226: }
2227:
2228: if ( t == FILING_position ) {
2229: ReturnAttributeTypeError(FILING_unimplemented, t);
2230: /* NOT REACHED */
2231: }
2232:
2233: if ( ( t < 0 ) || (t > FILING_subtreeSizeLimit) ) {
2234: ReturnAttributeTypeError(FILING_illegal, t);
2235: /* NOT REACHED */
2236: }
2237:
2238: ReturnAttributeTypeError(FILING_disallowed, t);
2239: }
2240:
2241: #ifdef DEBUG
2242: fprintf(msgs, "\n");
2243: #endif DEBUG
2244:
2245: if ( !got_name) {
2246: char *ptr, *rindex();
2247: if ( (ptr= rindex(fromname,'/')) == 0 )
2248: ptr= fromname;
2249: else
2250: ptr++;
2251: strcat(tohandle->pathname, ptr);
2252: } else {
2253: strcat(tohandle->pathname,name);
2254: }
2255:
2256: return(-1);
2257: }
2258: #endif EXTENSIONS
2259:
2260:
2261: FILING_StoreResults FILING_Store(ServerConnection, BDTProc, directory, attributes, controls, content, session)
2262: CourierConnection *ServerConnection;
2263: int ( *BDTProc)();
2264: FILING_Handle directory;
2265: FILING_AttributeSequence attributes;
2266: FILING_ControlSequence controls;
2267: BulkData1_Descriptor content;
2268: FILING_Session session;
2269: {
2270: FILING_StoreResults results;
2271: file_handle *handle, *dir_handle;
2272:
2273: #ifdef DEBUG
2274: if (msgs == 0) {
2275: char logfile[50];
2276: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
2277: msgs= fopen(logfile,"w");
2278: }
2279: fprintf(msgs, "Store ");
2280: #endif DEBUG
2281:
2282: BDTabort_expected= TRUE;
2283:
2284: if ( verify_session(session) != -1 ) {
2285: /* NOT REACHED */
2286: }
2287:
2288: #ifndef FILETOOLCOMPATIBILITY
2289: if ( is_nullControls(controls) != -1) {
2290: ReturnControlTypeError(FILING_disallowed, 0);
2291: /* NOT REACHED */
2292: }
2293:
2294: if ( is_nullHandle(directory) != -1 ) {
2295: ReturnHandleError(FILING_invalid);
2296: /* NOT REACHED */
2297: }
2298: #endif FILETOOLCOMPATIBILITY
2299:
2300: if ( content.designator == BulkData1_null ) {
2301: return;
2302: } else if ( content.designator != BulkData1_immediate ) {
2303: ReturnTransferError(FILING_aborted);
2304: /* NOT REACHED */
2305: }
2306:
2307: if ( (handle= (file_handle *)malloc(sizeof(file_handle))) == NULL ) {
2308: ReturnUndefinedError(0);
2309: /* NOT REACHED */
2310: }
2311:
2312: if ( (handle->pathname= (char *)malloc(MAX_FILE_NAME_LENGTH)) == NULL ) {
2313: ReturnUndefinedError(0);
2314: /* NOT REACHED */
2315: }
2316:
2317: #ifdef DEBUG
2318: fprintf(msgs, "store handle= %x\n",handle);
2319: #endif DEBUG
2320:
2321: #ifdef FILETOOLCOMPATIBILITY
2322: copyhandle(&dir_handle,directory);
2323:
2324: if ( dir_handle == 0 ) {
2325: dir_handle= &RootHandle;
2326: strcpy(handle->pathname, SERVICE_ROOT);
2327: } else {
2328: if ( dir_handle->state != FILE_OPEN ) {
2329: ReturnHandleError(FILING_invalid);
2330: /* NOT REACHED */
2331: }
2332:
2333: if ( access_file(dir_handle) != -1 ) {
2334: /* NOT REACHED */
2335: }
2336:
2337: if ( dir_handle->isdirectory != TRUE ) {
2338: ReturnHandleError(FILING_directoryRequired);
2339: /* NOT REACHED */
2340: }
2341:
2342: strcpy(handle->pathname,dir_handle->pathname);
2343: if ( strcmp(handle->pathname, "/") != 0 )
2344: strcat(handle->pathname,"/");
2345: }
2346: #else FILETOOLCOMPATIBILITY
2347: strcpy(handle->pathname, SERVICE_ROOT);
2348: #endif FILETOOLCOMPATIBILITY
2349:
2350: if ( verify_store_attributes(attributes, handle) != -1 ) {
2351: /* NOT REACHED */
2352: }
2353:
2354: #ifdef DEBUG
2355: fprintf(msgs, "creating '%s'\n", handle->pathname);
2356: #endif DEBUG
2357:
2358: if ( handle->isdirectory == TRUE ) {
2359: if ( dir_storeproc(ServerConnection,handle,content) != -1 ) {
2360: /* NOT REACHED */
2361: }
2362: } else {
2363: if ( create_file(handle) != -1 ) {
2364: /* NOT REACHED */
2365: }
2366:
2367: #ifdef EXTENSIONS
2368: if ( (handle->type > LAST_FILING_TYPE) && (handle->type != TYPE_Interpress) &&
2369: (handle->type != TYPE_VPCanvas) ) {
2370: SaveExtendedAttributes(handle->file_desc, attributes);
2371: }
2372: #endif EXTENSIONS
2373: if ( storeproc(ServerConnection,handle) != -1 ) {
2374: close_file(handle);
2375: delete_partial_file(handle);
2376: ReturnTransferError(FILING_aborted);
2377: /* NOT REACHED */
2378: }
2379:
2380: close_file(handle);
2381: }
2382:
2383: handle->state= FILE_OPEN;
2384: handle->file_desc= NULL;
2385:
2386: copyhandle(results.file, &handle);
2387: reset_continuance_timer();
2388:
2389: return(results);
2390: }
2391:
2392: verify_store_attributes(attr, handle)
2393: FILING_AttributeSequence attr;
2394: file_handle *handle;
2395: {
2396: int i;
2397: FILING_AttributeType t;
2398: int got_accesslist, got_childrenuniquelynamed, got_createdon, got_datasize;
2399: int got_defaultaccesslist, got_isdirectory, got_istemporary, got_ordering;
2400: int got_parentID, got_pathname, got_subtreesizelimit, got_type, got_version;
2401: char *pathname;
2402: FILING_Version version;
2403: Boolean childrenuniquelynamed, istemporary;
2404: Cardinal ordering;
2405: Cardinal subtreesizelimit;
2406: char *AttrToString();
2407: Unspecified *AttrToFileID();
2408: LongCardinal AttrToLongCardinal();
2409:
2410: #ifdef FILETOOLCOMPATIBILITY
2411: int got_name, got_4938;
2412: char *name;
2413: #endif FILETOOLCOMPATIBILITY
2414:
2415: #ifdef DEBUG
2416: fprintf(msgs,"%d store attributes ",attr.length);
2417: #endif DEBUG
2418:
2419: if ( attr.length <= 0 ) {
2420: ReturnAttributeTypeError(FILING_illegal, 0);
2421: /* NOT REACHED */
2422: }
2423:
2424: got_accesslist= got_childrenuniquelynamed= got_createdon= 0;
2425: got_datasize= got_defaultaccesslist= got_isdirectory= 0;
2426: got_istemporary= got_ordering= got_parentID= got_pathname= 0;
2427: got_subtreesizelimit= got_type= got_version= 0;
2428:
2429: #ifdef FILETOOLCOMPATIBILITY
2430: got_name= got_4938= 0;
2431: #endif FILETOOLCOMPATIBILITY
2432:
2433:
2434: for ( i= 0 ; i < attr.length ; i++ ) {
2435: t= attr.sequence[i].type;
2436: #ifdef DEBUG
2437: fprintf(msgs, "%d ",t);
2438: #endif DEBUG
2439: if ( t == FILING_createdOn ) {
2440: #ifdef DEBUG
2441: fprintf(msgs,"createdOn ");
2442: #endif DEBUG
2443: if ( got_createdon ) {
2444: ReturnAttributeTypeError(FILING_duplicated, t);
2445: /* NOT REACHED */
2446: }
2447: got_createdon++;
2448:
2449: handle->createdon= AttrToLongCardinal(&attr.sequence[i]);
2450: continue;
2451: }
2452:
2453: if ( t == FILING_dataSize ) {
2454: #ifdef DEBUG
2455: fprintf(msgs,"dataSize ");
2456: #endif DEBUG
2457: if ( got_datasize ) {
2458: ReturnAttributeTypeError(FILING_duplicated, t);
2459: /* NOT REACHED */
2460: }
2461: got_datasize++;
2462:
2463: handle->datasize= AttrToLongCardinal(&attr.sequence[i]);
2464: continue;
2465: }
2466:
2467: if ( t == FILING_isDirectory ) {
2468: #ifdef DEBUG
2469: fprintf(msgs,"isDirectory ");
2470: #endif DEBUG
2471: if ( got_isdirectory ) {
2472: ReturnAttributeTypeError(FILING_duplicated, t);
2473: /* NOT REACHED */
2474: }
2475:
2476: got_isdirectory++;
2477:
2478: handle->isdirectory= AttrToBoolean(&attr.sequence[i]);
2479: continue;
2480: }
2481:
2482: if ( t == FILING_pathname ) {
2483: #ifdef DEBUG
2484: fprintf(msgs,"pathname ");
2485: #endif DEBUG
2486: if ( got_pathname ) {
2487: ReturnAttributeTypeError(FILING_duplicated, t);
2488: /* NOT REACHED */
2489: }
2490: got_pathname++;
2491:
2492: pathname= AttrToString(&attr.sequence[i]);
2493: if ( check_pathname(pathname) != -1 ) {
2494: /* NOT REACHED */
2495: }
2496: continue;
2497: }
2498: if ( t == FILING_type ) {
2499: #ifdef DEBUG
2500: fprintf(msgs,"type ");
2501: #endif DEBUG
2502: if ( got_type ) {
2503: ReturnAttributeTypeError(FILING_duplicated, t);
2504: /* NOT REACHED */
2505: }
2506: got_type++;
2507:
2508: handle->type= AttrToLongCardinal(&attr.sequence[i]);
2509: #ifndef EXTENSIONS
2510: if ( (handle->type != FILING_tText) &&
2511: (handle->type != FILING_tUnspecified) &&
2512: (handle->type != FILING_tDirectory) ) {
2513: ReturnAttributeValueError(FILING_unimplemented, t);
2514: /* NOT REACHED */
2515: }
2516: #endif EXTENSIONS
2517: continue;
2518: }
2519: if ( t == FILING_version ) {
2520: #ifdef DEBUG
2521: fprintf(msgs,"version ");
2522: #endif DEBUG
2523: if ( got_version ) {
2524: ReturnAttributeTypeError(FILING_duplicated, t);
2525: /* NOT REACHED */
2526: }
2527: got_version++;
2528:
2529: version= AttrToCardinal(&attr.sequence[i]);
2530: if ( version != FILING_highestVersion ) {
2531: ReturnAttributeValueError(FILING_unimplemented, t);
2532: /* NOT REACHED */
2533:
2534: }
2535: continue;
2536: }
2537:
2538: #ifdef FILETOOLCOMPATIBILITY
2539: if ( t == FILING_name ) {
2540: #ifdef DEBUG
2541: fprintf(msgs, "name ");
2542: #endif DEBUG
2543: if ( got_name ) {
2544: ReturnAttributeTypeError(FILING_duplicated, t);
2545: /* NOT REACHED */
2546: }
2547: got_name++;
2548:
2549: name= AttrToString(&attr.sequence[i]);
2550: continue;
2551: }
2552:
2553: if ( t == 4938 ) {
2554: if ( got_4938 ) {
2555: ReturnAttributeTypeError(FILING_duplicated, t);
2556: /* NOT REACHED */
2557: }
2558:
2559: got_4938++;
2560: continue;
2561: }
2562: #endif FILETOOLCOMPATIBILITY
2563:
2564: #ifdef SOMEDAY
2565: if ( t == FILING_accessList ) {
2566: if ( got_accesslist ) {
2567: ReturnAttributeTypeError(FILING_duplicated, t);
2568: /* NOT REACHED */
2569: }
2570:
2571: got_accesslist++;
2572:
2573: if ( FALSE ) {
2574: ReturnAttributeValueError(FILING_unimplemented, t);
2575: /* NOT REACHED */
2576: }
2577:
2578: continue;
2579: }
2580: #endif SOMEDAY
2581:
2582: if ( t == FILING_childrenUniquelyNamed ) {
2583: if ( got_childrenuniquelynamed ) {
2584: ReturnAttributeTypeError(FILING_duplicated, t);
2585: /* NOT REACHED */
2586: }
2587:
2588: got_childrenuniquelynamed++;
2589:
2590: childrenuniquelynamed= AttrToBoolean(&attr.sequence[i]);
2591: if ( childrenuniquelynamed != TRUE ) {
2592: ReturnAttributeValueError(FILING_unimplemented, t);
2593: /* NOT REACHED */
2594: }
2595:
2596: continue;
2597: }
2598:
2599:
2600: #ifdef SOMEDAY
2601: if ( t == FILING_defaultAccessList ) {
2602: if ( got_defaultaccesslist ) {
2603: ReturnAttributeTypeError(FILING_duplicated, t);
2604: /* NOT REACHED */
2605: }
2606:
2607: got_defaultaccesslist++;
2608:
2609: if ( FALSE ) {
2610: ReturnAttributeValueError(FILING_unimplemented, t);
2611: /* NOT REACHED */
2612: }
2613:
2614: continue;
2615: }
2616: #endif SOMEDAY
2617:
2618: if ( t == FILING_isTemporary ) {
2619: if ( got_istemporary ) {
2620: ReturnAttributeTypeError(FILING_duplicated, t);
2621: /* NOT REACHED */
2622: }
2623:
2624: got_istemporary++;
2625:
2626: istemporary= AttrToBoolean(&attr.sequence[i]);
2627: if ( istemporary != FALSE ) {
2628: ReturnAttributeValueError(FILING_unimplemented, t);
2629: /* NOT REACHED */
2630: }
2631:
2632: continue;
2633: }
2634:
2635: if ( t == FILING_ordering ) {
2636: if ( got_ordering ) {
2637: ReturnAttributeTypeError(FILING_duplicated, t);
2638: /* NOT REACHED */
2639: }
2640:
2641: got_ordering++;
2642:
2643: if ( FALSE ) {
2644: ReturnAttributeValueError(FILING_unimplemented, t);
2645: /* NOT REACHED */
2646: }
2647:
2648: continue;
2649: }
2650:
2651: if ( t == FILING_subtreeSizeLimit ) {
2652: if ( got_subtreesizelimit ) {
2653: ReturnAttributeTypeError(FILING_duplicated, t);
2654: /* NOT REACHED */
2655: }
2656:
2657: got_subtreesizelimit++;
2658:
2659: subtreesizelimit= AttrToCardinal(&attr.sequence[i]);
2660: if ( subtreesizelimit != FILING_nullSubtreeSizeLimit ) {
2661: ReturnAttributeValueError(FILING_unimplemented, t);
2662: /* NOT REACHED */
2663: }
2664:
2665: continue;
2666: }
2667:
2668: if ( (t == FILING_fileID) || (t == FILING_modifiedBy) ||
2669: (t == FILING_modifiedOn) || (t == FILING_name) ||
2670: (t == FILING_numberOfChildren) || (t == FILING_parentID) ||
2671: (t == FILING_readBy) || (t == FILING_readOn) ||
2672: (t == FILING_storedSize) || (t == FILING_subtreeSize) ) {
2673: ReturnAttributeTypeError(FILING_disallowed, t);
2674: }
2675:
2676: #ifndef EXTENSIONS
2677: if ( ( t < 0 ) || (t > FILING_subtreeSizeLimit) ) {
2678: ReturnAttributeTypeError(FILING_illegal, t);
2679: /* NOT REACHED */
2680: }
2681:
2682: if ( (t == FILING_checksum) || (t == FILING_createdBy) ||
2683: (t == FILING_position) )
2684: ReturnAttributeTypeError(FILING_unimplemented, t);
2685: else
2686: ReturnAttributeTypeError(FILING_disallowed, t);
2687:
2688: #else EXTENSIONS
2689: if ( t < 0 ) {
2690: ReturnAttributeTypeError(FILING_illegal, t);
2691: /* NOT REACHED */
2692: }
2693: if ( handle->type != TYPE_VP ) {
2694: if ( (t == FILING_checksum) || (t == FILING_createdBy) ||
2695: (t == FILING_position) )
2696: ReturnAttributeTypeError(FILING_unimplemented, t);
2697: else
2698: ReturnAttributeTypeError(FILING_disallowed, t);
2699: }
2700: #endif EXTENSIONS
2701: }
2702:
2703: #ifdef DEBUG
2704: fprintf(msgs, "\n");
2705: #endif DEBUG
2706:
2707: #ifdef FILETOOLCOMPATIBILITY
2708: if ( !got_pathname && !got_name) {
2709: handle->pathname= SERVICE_ROOT;
2710: } else if ( !got_pathname ) {
2711: strcat(handle->pathname,name);
2712: } else {
2713: if ( *pathname == '/' )
2714: strcat(handle->pathname, pathname+1);
2715: else
2716: strcat(handle->pathname,pathname);
2717: Deallocate(&pathname);
2718: }
2719:
2720: #else FILETOOLCOMPATIBILITY
2721: if ( !got_pathname ) {
2722: ReturnAttributeTypeError(FILING_missing, t);
2723: /* NOT REACHED */
2724: } else {
2725: if ( *pathname == '/' )
2726: strcat(handle->pathname, pathname+1);
2727: else
2728: strcat(handle->pathname, pathname);
2729: Deallocate(&pathname);
2730: }
2731: #endif FILETOOLCOMPATIBILITY
2732:
2733: if ( !got_type )
2734: handle->type= FILING_tUnspecified;
2735:
2736: if ( !got_createdon )
2737: handle->createdon= 0;
2738:
2739: if ( !got_isdirectory ) {
2740: if ( handle->type == FILING_tDirectory )
2741: handle->isdirectory= TRUE;
2742: else
2743: handle->isdirectory= FALSE;
2744: } else {
2745: if ( ((handle->isdirectory == TRUE) && (handle->type != FILING_tDirectory)) ||
2746: ((handle->isdirectory == FALSE) && (handle->type == FILING_tDirectory)) ) {
2747: ReturnAttributeTypeError(FILING_unreasonable, FILING_isDirectory);
2748: /* NOT REACHED */
2749: }
2750: }
2751:
2752: return(-1);
2753: }
2754:
2755:
2756: void FILING_Retrieve(ServerConnection, BDTProc, file, content, session)
2757: CourierConnection *ServerConnection;
2758: int ( *BDTProc)();
2759: FILING_Handle file;
2760: BulkData1_Descriptor content;
2761: FILING_Session session;
2762: {
2763: file_handle *handle;
2764:
2765: #ifdef DEBUG
2766: if (msgs == 0) {
2767: char logfile[50];
2768: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
2769: msgs= fopen(logfile,"w");
2770: }
2771: fprintf(msgs, "Retrieve\n");
2772: #endif DEBUG
2773:
2774: BDTabort_expected= TRUE;
2775:
2776: if ( verify_session(session) != -1 ) {
2777: /* NOT REACHED */
2778: }
2779:
2780: if ( is_nullHandle(file) == -1 ) {
2781: ReturnHandleError(FILING_nullDisallowed);
2782: /* NOT REACHED */
2783: }
2784:
2785: copyhandle(&handle,file);
2786:
2787: if ( handle->state != FILE_OPEN ) {
2788: ReturnHandleError(FILING_invalid);
2789: /* NOT REACHED */
2790: }
2791:
2792: if ( access_file(handle) != -1 ) {
2793: /* NOT REACHED */
2794: }
2795:
2796: if ( content.designator == BulkData1_null ) {
2797: return;
2798: } else if ( content.designator != BulkData1_immediate ) {
2799: ReturnTransferError(FILING_aborted);
2800: /* NOT REACHED */
2801: }
2802:
2803: if ( open_file(handle) != -1 ) {
2804: /* NOT REACHED */
2805: }
2806:
2807: #ifdef DEBUG
2808: fprintf(msgs, "retrieving '%s'\n", handle->pathname);
2809: #endif DEBUG
2810:
2811: if ( retrieveproc(ServerConnection,handle) != -1 ) {
2812: close_file(handle);
2813: ReturnTransferError(FILING_aborted);
2814: /* NOT REACHED */
2815: }
2816:
2817: close_file(handle);
2818: handle->file_desc= NULL;
2819: reset_continuance_timer();
2820:
2821: return;
2822: }
2823:
2824:
2825: void FILING_Replace(ServerConnection, BDTProc, file, attributes, content, session)
2826: CourierConnection *ServerConnection;
2827: int ( *BDTProc)();
2828: FILING_Handle file;
2829: FILING_AttributeSequence attributes;
2830: BulkData1_Descriptor content;
2831: FILING_Session session;
2832: {
2833: #ifdef EXTENSIONS
2834: file_handle *handle;
2835:
2836: #ifdef DEBUG
2837: if (msgs == 0) {
2838: char logfile[50];
2839: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
2840: msgs= fopen(logfile,"w");
2841: }
2842: fprintf(msgs, "Replace\n");
2843: #endif DEBUG
2844:
2845: BDTabort_expected= TRUE;
2846:
2847: if ( verify_session(session) != -1 ) {
2848: /* NOT REACHED */
2849: }
2850:
2851: if ( is_nullHandle(file) == -1 ) {
2852: ReturnHandleError(FILING_nullDisallowed);
2853: /* NOT REACHED */
2854: }
2855:
2856: copyhandle(&handle,file);
2857:
2858: if ( handle->state != FILE_OPEN ) {
2859: ReturnHandleError(FILING_invalid);
2860: /* NOT REACHED */
2861: }
2862:
2863: if ( access_file(handle) != -1 ) {
2864: /* NOT REACHED */
2865: }
2866:
2867: if ( content.designator == BulkData1_null ) {
2868: return;
2869: } else if ( content.designator != BulkData1_immediate ) {
2870: ReturnTransferError(FILING_aborted);
2871: /* NOT REACHED */
2872: }
2873:
2874: if ( verify_replace_attributes(attributes, handle) != -1 ) {
2875: /* NOT REACHED */
2876: }
2877:
2878: #ifdef DEBUG
2879: fprintf(msgs, "replacing '%s'\n", handle->pathname);
2880: #endif DEBUG
2881:
2882: if ( make_backup(handle) != -1 ) {
2883: /* NOT REACHED */
2884: }
2885:
2886: if ( open_file(handle) != -1 ) {
2887: /* NOT REACHED */
2888: }
2889:
2890: if ( storeproc(ServerConnection,handle) != -1 ) {
2891: close_file(handle);
2892: recall_backup(handle);
2893: ReturnTransferError(FILING_aborted);
2894: /* NOT REACHED */
2895: }
2896:
2897: close_file(handle);
2898: unlink_backup(handle);
2899:
2900: handle->file_desc= NULL;
2901: reset_continuance_timer();
2902:
2903: return;
2904:
2905: #else EXTENSIONS
2906: NoSuchProcedureValue("Filing", 14);
2907: #endif EXTENSIONS
2908: }
2909:
2910: #ifdef EXTENSIONS
2911: verify_replace_attributes(attr, handle)
2912: FILING_AttributeSequence attr;
2913: file_handle *handle;
2914: {
2915: int i;
2916: FILING_AttributeType t;
2917: LongCardinal datasize;
2918: int got_createdon, got_datasize;
2919: LongCardinal AttrToLongCardinal();
2920:
2921: #ifdef DEBUG
2922: fprintf(msgs,"%d replace attributes ",attr.length);
2923: #endif DEBUG
2924:
2925: if ( attr.length < 0 ) {
2926: ReturnAttributeTypeError(FILING_illegal, 0);
2927: /* NOT REACHED */
2928: }
2929:
2930: got_createdon= 0;
2931:
2932: for ( i= 0 ; i < attr.length ; i++ ) {
2933: t= attr.sequence[i].type;
2934: #ifdef DEBUG
2935: fprintf(msgs, "%d ",t);
2936: #endif DEBUG
2937: if ( t == FILING_createdOn ) {
2938: #ifdef DEBUG
2939: fprintf(msgs,"createdOn ");
2940: #endif DEBUG
2941: if ( got_createdon ) {
2942: ReturnAttributeTypeError(FILING_duplicated, t);
2943: /* NOT REACHED */
2944: }
2945: got_createdon++;
2946:
2947: handle->createdon= AttrToLongCardinal(&attr.sequence[i]);
2948: continue;
2949: }
2950:
2951: if ( t == FILING_dataSize ) {
2952: #ifdef DEBUG
2953: fprintf(msgs,"dataSize ");
2954: #endif DEBUG
2955: if ( got_datasize ) {
2956: ReturnAttributeTypeError(FILING_duplicated, t);
2957: /* NOT REACHED */
2958: }
2959: got_datasize++;
2960:
2961: datasize= AttrToLongCardinal(&attr.sequence[i]);
2962: continue;
2963: }
2964:
2965: if ( t < 0 ) {
2966: ReturnAttributeTypeError(FILING_illegal, t);
2967: /* NOT REACHED */
2968: }
2969:
2970: if ( (t == FILING_checksum) || (t == FILING_createdBy) ||
2971: (t == FILING_position) )
2972: ReturnAttributeTypeError(FILING_unimplemented, t);
2973: else
2974: ReturnAttributeTypeError(FILING_disallowed, t);
2975:
2976: }
2977:
2978: #ifdef DEBUG
2979: fprintf(msgs, "\n");
2980: #endif DEBUG
2981:
2982: return(-1);
2983: }
2984: #endif EXTENSIONS
2985:
2986:
2987: void FILING_Serialize(ServerConnection, BDTProc, file, serializedFile, session)
2988: CourierConnection *ServerConnection;
2989: int ( *BDTProc)();
2990: FILING_Handle file;
2991: BulkData1_Descriptor serializedFile;
2992: FILING_Session session;
2993: {
2994: #ifdef EXTENSIONS
2995: file_handle *handle;
2996: LongCardinal type;
2997:
2998: #ifdef DEBUG
2999: if (msgs == 0) {
3000: char logfile[50];
3001: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
3002: msgs= fopen(logfile,"w");
3003: }
3004: fprintf(msgs, "Serialize\n");
3005: #endif DEBUG
3006:
3007: BDTabort_expected= TRUE;
3008:
3009: if ( verify_session(session) != -1 ) {
3010: /* NOT REACHED */
3011: }
3012:
3013: if ( is_nullHandle(file) == -1 ) {
3014: ReturnHandleError(FILING_nullDisallowed);
3015: /* NOT REACHED */
3016: }
3017:
3018: copyhandle(&handle,file);
3019:
3020: if ( handle->state != FILE_OPEN ) {
3021: ReturnHandleError(FILING_invalid);
3022: /* NOT REACHED */
3023: }
3024:
3025: if ( access_file(handle) != -1 ) {
3026: /* NOT REACHED */
3027: }
3028:
3029: if ( serializedFile.designator == BulkData1_null ) {
3030: return;
3031: } else if ( serializedFile.designator != BulkData1_immediate ) {
3032: ReturnTransferError(FILING_aborted);
3033: /* NOT REACHED */
3034: }
3035:
3036: /*
3037: * for now, can only serialize files which are already in 'serialized'
3038: * form. This can be assumed if the file is of a Viewpoint file type
3039: * and the stored isDirectory attribute is TRUE.
3040: * NOTE: like all other cases, this is no guarantee...
3041: */
3042:
3043: type= get_type(handle->pathname);
3044:
3045: if ( (type < LAST_FILING_TYPE) || (type == TYPE_Interpress) || (type == TYPE_VPCanvas) ) {
3046: ReturnAccessError(FILING_fileChanged);
3047: /* NOT REACHED */
3048: }
3049:
3050: if ( open_file(handle) != -1 ) {
3051: /* NOT REACHED */
3052: }
3053:
3054: if ( GetDirectoryAttribute(handle->file_desc) != TRUE ) {
3055: close_file(handle);
3056: ReturnAccessError(FILING_fileChanged);
3057: /* NOT REACHED */
3058: }
3059:
3060: #ifdef DEBUG
3061: fprintf(msgs, "serializing '%s'\n", handle->pathname);
3062: #endif DEBUG
3063:
3064: if ( retrieveproc(ServerConnection,handle) != -1 ) {
3065: close_file(handle);
3066: ReturnTransferError(FILING_aborted);
3067: /* NOT REACHED */
3068: }
3069:
3070: close_file(handle);
3071: handle->file_desc= NULL;
3072: reset_continuance_timer();
3073: #else EXTENSIONS
3074: NoSuchProcedureValue("Filing", 15);
3075: #endif EXTENSIONS
3076: }
3077:
3078:
3079: FILING_DeserializeResults FILING_Deserialize(ServerConnection, BDTProc,
3080: directory, attributes, controls, serializedFile, session)
3081: CourierConnection *ServerConnection;
3082: int ( *BDTProc)();
3083: FILING_Handle directory;
3084: FILING_AttributeSequence attributes;
3085: FILING_ControlSequence controls;
3086: BulkData1_Descriptor serializedFile;
3087: FILING_Session session;
3088: {
3089: #ifdef EXTENSIONS
3090: FILING_DeserializeResults results;
3091: file_handle *handle, *dir_handle;
3092:
3093: #ifdef DEBUG
3094: if (msgs == 0) {
3095: char logfile[50];
3096: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
3097: msgs= fopen(logfile,"w");
3098: }
3099: fprintf(msgs, "Deserialize ");
3100: #endif DEBUG
3101:
3102: BDTabort_expected= TRUE;
3103:
3104: if ( verify_session(session) != -1 ) {
3105: /* NOT REACHED */
3106: }
3107:
3108: #ifndef FILETOOLCOMPATIBILITY
3109: if ( is_nullControls(controls) != -1) {
3110: ReturnControlTypeError(FILING_disallowed, 0);
3111: /* NOT REACHED */
3112: }
3113:
3114: if ( is_nullHandle(directory) != -1 ) {
3115: ReturnHandleError(FILING_invalid);
3116: /* NOT REACHED */
3117: }
3118: #endif FILETOOLCOMPATIBILITY
3119:
3120: if ( serializedFile.designator == BulkData1_null ) {
3121: return;
3122: } else if ( serializedFile.designator != BulkData1_immediate ) {
3123: ReturnTransferError(FILING_aborted);
3124: /* NOT REACHED */
3125: }
3126:
3127: if ( (handle= (file_handle *)malloc(sizeof(file_handle))) == NULL ) {
3128: ReturnUndefinedError(0);
3129: /* NOT REACHED */
3130: }
3131:
3132: if ( (handle->pathname= (char *)malloc(MAX_FILE_NAME_LENGTH)) == NULL ) {
3133: ReturnUndefinedError(0);
3134: /* NOT REACHED */
3135: }
3136:
3137: #ifdef DEBUG
3138: fprintf(msgs, "deserialize handle= %x\n",handle);
3139: #endif DEBUG
3140:
3141: #ifdef FILETOOLCOMPATIBILITY
3142: copyhandle(&dir_handle,directory);
3143:
3144: if ( dir_handle == 0 ) {
3145: dir_handle= &RootHandle;
3146: strcpy(handle->pathname, SERVICE_ROOT);
3147: } else {
3148: if ( dir_handle->state != FILE_OPEN ) {
3149: ReturnHandleError(FILING_invalid);
3150: /* NOT REACHED */
3151: }
3152:
3153: if ( access_file(dir_handle) != -1 ) {
3154: /* NOT REACHED */
3155: }
3156:
3157: if ( dir_handle->isdirectory != TRUE ) {
3158: ReturnHandleError(FILING_directoryRequired);
3159: /* NOT REACHED */
3160: }
3161:
3162: strcpy(handle->pathname,dir_handle->pathname);
3163: if ( strcmp(handle->pathname, "/") != 0 )
3164: strcat(handle->pathname,"/");
3165: }
3166: #else FILETOOLCOMPATIBILITY
3167: strcpy(handle->pathname, SERVICE_ROOT);
3168: #endif FILETOOLCOMPATIBILITY
3169:
3170: if ( verify_deserialize_attributes(attributes, handle) != -1 ) {
3171: /* NOT REACHED */
3172: }
3173:
3174: #ifdef DEBUG
3175: fprintf(msgs, "creating '%s'\n", handle->pathname);
3176: #endif DEBUG
3177:
3178: if ( create_file(handle) != -1 ) {
3179: /* NOT REACHED */
3180: }
3181:
3182: if ( storeproc(ServerConnection,handle) != -1 ) {
3183: close_file(handle);
3184: delete_partial_file(handle);
3185: ReturnTransferError(FILING_aborted);
3186: /* NOT REACHED */
3187: }
3188:
3189: close_file(handle);
3190:
3191: handle->state= FILE_OPEN;
3192: handle->file_desc= NULL;
3193:
3194: copyhandle(results.file, &handle);
3195: reset_continuance_timer();
3196:
3197: return(results);
3198: #else EXTENSIONS
3199: NoSuchProcedureValue("Filing", 16);
3200: #endif EXTENSIONS
3201: }
3202:
3203: #ifdef EXTENSIONS
3204: verify_deserialize_attributes(attr, handle)
3205: FILING_AttributeSequence attr;
3206: file_handle *handle;
3207: {
3208: int i;
3209: FILING_AttributeType t;
3210: int got_accesslist, got_defaultaccesslist, got_istemporary;
3211: int got_name, got_pathname, got_subtreesizelimit, got_version;
3212: FILING_Version version;
3213: Boolean istemporary;
3214: char *pathname;
3215: char *name;
3216: char *AttrToString();
3217:
3218: #ifdef DEBUG
3219: fprintf(msgs, "%d deserialize attributes ", attr.length);
3220: #endif DEBUG
3221:
3222: if ( attr.length <= 0 ) {
3223: ReturnAttributeTypeError(FILING_illegal, 0);
3224: /* NOT REACHED */
3225: }
3226:
3227: got_accesslist= got_defaultaccesslist= got_istemporary= 0;
3228: got_name= got_pathname= got_subtreesizelimit= got_version= 0;
3229:
3230: for ( i= 0; i < attr.length ; i++ ) {
3231: t= attr.sequence[i].type;
3232:
3233: if ( t == FILING_accessList ) {
3234: #ifdef DEBUG
3235: fprintf(msgs, "accessList ");
3236: #endif DEBUG
3237: if ( got_accesslist ) {
3238: ReturnAttributeTypeError(FILING_duplicated, t);
3239: /* NOT REACHED */
3240: }
3241: got_accesslist++;
3242:
3243: continue;
3244: }
3245:
3246: #ifdef SOMEDAY
3247: if ( t == FILING_defaultAccessList ) {
3248: #ifdef DEBUG
3249: fprintf(msgs, "defaultAccessList ");
3250: #endif DEBUG
3251: if ( got_defaultaccesslist ) {
3252: ReturnAttributeTypeError(FILING_duplicated, t);
3253: /* NOT REACHED */
3254: }
3255: got_defaultaccesslist++;
3256:
3257: continue;
3258: }
3259: #endif SOMEDAY
3260:
3261: if ( t == FILING_isTemporary ) {
3262: #ifdef DEBUG
3263: fprintf(msgs, "isTemporary ");
3264: #endif DEBUG
3265: if ( got_istemporary ) {
3266: ReturnAttributeTypeError(FILING_duplicated, t);
3267: /* NOT REACHED */
3268: }
3269: got_istemporary++;
3270:
3271: istemporary= AttrToBoolean(&attr.sequence[i]);
3272: if ( istemporary != FALSE ) {
3273: ReturnAttributeValueError(FILING_unimplemented, t);
3274: /* NOT REACHED */
3275: }
3276: continue;
3277: }
3278:
3279: if ( t == FILING_name ) {
3280: #ifdef DEBUG
3281: fprintf(msgs, "name ");
3282: #endif DEBUG
3283: if ( got_name ) {
3284: ReturnAttributeTypeError(FILING_duplicated, t);
3285: /* NOT REACHED */
3286: }
3287: got_name++;
3288:
3289: name= AttrToString(&attr.sequence[i]);
3290: continue;
3291: }
3292:
3293: if ( t == FILING_pathname ) {
3294: #ifdef DEBUG
3295: fprintf(msgs, "pathname ");
3296: #endif DEBUG
3297: if ( got_pathname ) {
3298: ReturnAttributeTypeError(FILING_duplicated, t);
3299: /* NOT REACHED */
3300: }
3301: got_pathname++;
3302:
3303: pathname= AttrToString(&attr.sequence[i]);
3304: if ( check_pathname(pathname) != 1 ) {
3305: /* NOT REACHED */
3306: }
3307: continue;
3308: }
3309:
3310: if ( t == FILING_subtreeSizeLimit ) {
3311: #ifdef DEBUG
3312: fprintf(msgs, "subtreeSizeLimit ");
3313: #endif DEBUG
3314: if ( got_subtreesizelimit ) {
3315: ReturnAttributeTypeError(FILING_duplicated, t);
3316: /* NOT REACHED */
3317: }
3318: got_subtreesizelimit++;
3319:
3320: continue;
3321: }
3322:
3323: if ( t == FILING_version ) {
3324: #ifdef DEBUG
3325: fprintf(msgs, "version ");
3326: #endif DEBUG
3327: if ( got_version ) {
3328: ReturnAttributeTypeError(FILING_duplicated, t);
3329: /* NOT REACHED */
3330: }
3331: got_version++;
3332:
3333: version= AttrToCardinal(&attr.sequence[i]);
3334: if ( version != FILING_highestVersion ) {
3335: ReturnAttributeValueError(FILING_unimplemented, t);
3336: /* NOT REACHED */
3337: }
3338: continue;
3339: }
3340: }
3341:
3342: #ifdef DEBUG
3343: fprintf(msgs, "\n");
3344: #endif DEBUG
3345:
3346: if ( !got_pathname && !got_name ) {
3347: handle->pathname= SERVICE_ROOT;
3348: } else if ( !got_pathname ) {
3349: strcat(handle->pathname, name);
3350: Deallocate(&name);
3351: } else {
3352: if ( *pathname == '/' )
3353: strcat(handle->pathname, pathname+1);
3354: else
3355: strcat(handle->pathname, pathname);
3356: Deallocate(&pathname);
3357: }
3358:
3359: handle->type= FILING_tSerialized;
3360: handle->createdon= 0;
3361:
3362: return(-1);
3363: }
3364: #endif EXTENSIONS
3365:
3366: FILING_FindResults FILING_Find(ServerConnection, BDTProc, directory, types, scope, controls, session)
3367: CourierConnection *ServerConnection;
3368: int ( *BDTProc)();
3369: FILING_Handle directory;
3370: FILING_AttributeTypeSequence types;
3371: FILING_ScopeSequence scope;
3372: FILING_ControlSequence controls;
3373: FILING_Session session;
3374: {
3375: NoSuchProcedureValue("Filing", 17);
3376: }
3377:
3378:
3379: void FILING_List(ServerConnection, BDTProc, directory, types, scope, listing, session)
3380: CourierConnection *ServerConnection;
3381: int ( *BDTProc)();
3382: FILING_Handle directory;
3383: FILING_AttributeTypeSequence types;
3384: FILING_ScopeSequence scope;
3385: BulkData1_Descriptor listing;
3386: FILING_Session session;
3387: {
3388: char *match_name;
3389: Cardinal count;
3390: file_handle *dir_handle;
3391:
3392: BDTabort_expected= TRUE;
3393:
3394: #ifdef DEBUG
3395: if (msgs == 0) {
3396: char logfile[50];
3397: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
3398: msgs= fopen(logfile,"w");
3399: }
3400: fprintf(msgs, "List\n");
3401: #endif DEBUG
3402:
3403: if ( verify_session(session) != -1 ) {
3404: /* NOT REACHED */
3405: }
3406:
3407: #ifndef FILETOOLCOMPATIBILITY
3408: if ( is_nullHandle(directory) != -1 ) {
3409: ReturnHandleError(FILING_invalid);
3410: /* NOT REACHED */
3411: }
3412: #endif FILETOOLCOMPATIBILITY
3413:
3414: if ( listing.designator == BulkData1_null )
3415: return;
3416: else if ( listing.designator != BulkData1_immediate ) {
3417: ReturnTransferError(FILING_aborted);
3418: /* NOT REACHED */
3419: }
3420:
3421: copyhandle(&dir_handle, directory);
3422:
3423: #ifdef FILETOOLCOMPATIBILITY
3424: if ( dir_handle == 0 ) {
3425: dir_handle= &RootHandle;
3426: } else {
3427: if ( dir_handle->state != FILE_OPEN ) {
3428: ReturnHandleError(FILING_invalid);
3429: /* NOT REACHED */
3430: }
3431:
3432: if ( dir_handle->isdirectory != TRUE ) {
3433: ReturnHandleError(FILING_directoryRequired);
3434: /* NOT REACHED */
3435: }
3436:
3437: if ( access_file(dir_handle) != -1 ) {
3438: /* NOT REACHED */
3439: }
3440:
3441: }
3442: #else FILETOOLCOMPATIBILITY
3443: dir_handle= &RootHandle;
3444: #endif FILETOOLCOMPATIBILITY
3445:
3446: if ( get_scopes(scope, &count, &match_name) != -1 ) {
3447: /* NOT REACHED */
3448: }
3449:
3450: if ( list_directory(ServerConnection, dir_handle, types, match_name, count) != -1 ) {
3451: /* NOT REACHED */
3452: }
3453:
3454: reset_continuance_timer();
3455:
3456: return;
3457: }
3458:
3459: get_scopes(scope, count, matches_name)
3460: FILING_ScopeSequence scope;
3461: Cardinal *count;
3462: char **matches_name;
3463: {
3464: int got_count, got_filter, got_matches;
3465: int i, scopetype;
3466: FILING_ScopeType t;
3467: #ifdef FILETOOLCOMPATIBILITY
3468: int got_equal;
3469: static char *wildcard_all= "*";
3470:
3471: *matches_name= wildcard_all;
3472: *count= FILING_unlimitedCount;
3473: if ( scope.length < 0 ) {
3474: ReturnScopeTypeError(FILING_illegal, 0);
3475: /* NOT REACHED */
3476: } else if ( scope.length == 0 ) {
3477: return(-1);
3478: }
3479: #else FILETOOLCOMPATIBILITY
3480: if ( scope.length <= 0 ) {
3481: ReturnScopeTypeError(FILING_illegal, 0);
3482: /* NOT REACHED */
3483: }
3484: #endif FILETOOLCOMPATIBILITY
3485:
3486: #ifdef DEBUG
3487: fprintf(msgs, "get_scope %d scopes ",scope.length);
3488: #endif DEBUG
3489:
3490: got_count= got_filter= got_matches= 0;
3491:
3492: for ( i= 0 ; i < scope.length ; i++ ) {
3493: t= scope.sequence[i].designator;
3494:
3495: if ( t == FILING_filter ) {
3496: #ifdef DEBUG
3497: fprintf(msgs, "filter ");
3498: #endif DEBUG
3499: if ( got_filter ) {
3500: ReturnScopeTypeError(FILING_duplicated, t);
3501: /* NOT REACHED */
3502: }
3503: got_filter++;
3504:
3505: if ( get_filter(scope.sequence[i].FILING_filter_case,matches_name) != -1 ) {
3506: /* NOT REACHED */
3507: }
3508: continue;
3509: }
3510:
3511: if ( t == FILING_count ) {
3512: #ifdef DEBUG
3513: fprintf(msgs, "count ");
3514: #endif DEBUG
3515: if ( got_count ) {
3516: ReturnScopeTypeError(FILING_duplicated, t);
3517: /* NOT REACHED */
3518: }
3519: got_count++;
3520:
3521: *count= AttrToCardinal(&scope.sequence[i].FILING_count_case);
3522: #ifdef DEBUG
3523: fprintf(msgs, "count = %d ",*count);
3524: #endif DEBUG
3525: continue;
3526: }
3527:
3528: scopetype= (Cardinal) t;
3529: if ( (scopetype < 0) || (scopetype > (Cardinal) FILING_depth) ) {
3530: ReturnScopeTypeError(FILING_illegal, t);
3531: /* NOT REACHED */
3532: }
3533:
3534: ReturnScopeTypeError(FILING_unimplemented, t);
3535: /* NOT REACHED */
3536: }
3537:
3538: if ( !got_count ) {
3539: *count= FILING_unlimitedCount;
3540: }
3541:
3542: #ifdef DEBUG
3543: fprintf(msgs, "\n");
3544: #endif DEBUG
3545: }
3546:
3547: get_filter(filter,matches_name)
3548: FILING_Filter filter;
3549: char **matches_name;
3550: {
3551:
3552: int got_matches= 0;
3553: #ifdef FILETOOLCOMPATIBILITY
3554: int got_equal= 0;
3555: int got_all= 0;
3556: #endif FILETOOLCOMPATIBILITY
3557:
3558: if ( filter.designator == FILING_matches ) {
3559: if ( got_matches ) {
3560: ReturnScopeValueError(FILING_duplicated, (Cardinal) FILING_filter);
3561: /* NOT REACHED */
3562: }
3563:
3564: got_matches++;
3565:
3566: #ifdef DEBUG
3567: fprintf(msgs, "matches on %d attribute\n",filter.FILING_matches_case.attribute.type);
3568: #endif DEBUG
3569:
3570: #ifdef FILETOOLCOMPATIBILITY
3571: if ( (filter.FILING_matches_case.attribute.type != FILING_pathname) &&
3572: (filter.FILING_matches_case.attribute.type != FILING_name) ) {
3573: ReturnScopeValueError(FILING_unimplemented, (Cardinal) FILING_filter);
3574: /* NOT REACHED */
3575: }
3576: #else FILETOOLCOMPATIBILITY
3577: if ( filter.FILING_matches_case.attribute.type != FILING_pathname ) {
3578: ReturnScopeValueError(FILING_unimplemented, (Cardinal) FILING_filter);
3579: /* NOT REACHED */
3580: }
3581: #endif FILETOOLCOMPATIBILITY
3582:
3583: *matches_name= AttrToString(&filter.FILING_matches_case.attribute);
3584:
3585: #ifdef DEBUG
3586: fprintf(msgs, "matches name= '%s'\n",*matches_name);
3587: #endif DEBUG
3588:
3589: #ifdef FILETOOLCOMPATIBILITY
3590: } else if ( filter.designator == FILING_equal ) {
3591: if ( got_equal ) {
3592: ReturnScopeValueError(FILING_duplicated, (Cardinal) FILING_filter);
3593: /* NOT REACHED */
3594: }
3595:
3596: got_equal++;
3597:
3598: #ifdef DEBUG
3599: fprintf(msgs, "equal on %d attribute\n",filter.FILING_matches_case.attribute.type);
3600: #endif DEBUG
3601:
3602: if ( (filter.FILING_matches_case.attribute.type != FILING_pathname) &&
3603: (filter.FILING_matches_case.attribute.type != FILING_name) ) {
3604: ReturnScopeValueError(FILING_unimplemented, (Cardinal) FILING_filter);
3605: /* NOT REACHED */
3606: }
3607:
3608: *matches_name= AttrToString(&filter.FILING_matches_case.attribute);
3609:
3610: #ifdef DEBUG
3611: fprintf(msgs, "matches name= '%s'\n",*matches_name);
3612: #endif DEBUG
3613:
3614: } else if ( filter.designator == FILING_all ) {
3615: if ( got_all ) {
3616: ReturnScopeValueError(FILING_duplicated, (Cardinal) FILING_filter);
3617: /* NOT REACHED */
3618: }
3619: got_all++;
3620:
3621: #ifdef DEBUG
3622: fprintf(msgs, "all");
3623: #endif DEBUG
3624: #endif FILETOOLCOMPATIBILITY
3625: } else {
3626: ReturnScopeValueError(FILING_unimplemented, (Cardinal) FILING_filter);
3627: /* NOT REACHED */
3628: }
3629: return(-1);
3630: }
3631:
3632:
3633: FILING_ContinueResults FILING_Continue(ServerConnection, BDTProc, session)
3634: CourierConnection *ServerConnection;
3635: int ( *BDTProc)();
3636: FILING_Session session;
3637: {
3638: FILING_ContinueResults results;
3639:
3640: BDTabort_expected= FALSE;
3641:
3642: #ifdef DEBUG
3643: if (msgs == 0) {
3644: char logfile[50];
3645: sprintf(logfile, "/tmp/filing%ld.msgs", getpid());
3646: msgs= fopen(logfile,"w");
3647: }
3648: fprintf(msgs, "Continue\n");
3649: #endif DEBUG
3650:
3651: if ( verify_session(session) != -1 ) {
3652: /* NOT REACHED */
3653: }
3654:
3655: results.continuance= continuance;
3656: reset_continuance_timer();
3657:
3658: return(results);
3659: }
3660:
3661: continuance_expiration()
3662: {
3663: /*
3664: * if BDT in progress, don't close connection
3665: */
3666:
3667: if ( !BDTabort_expected ) {
3668: #ifdef DEBUG
3669: fprintf(msgs, "continuance_expiration, closing connection\n");
3670: fflush(msgs);
3671: #endif DEBUG
3672: CourierClose(_serverConnection);
3673: exit(1);
3674: } else {
3675: reset_continuance_timer();
3676: }
3677:
3678: }
3679:
3680:
3681: void FILING_UnifyAccessLists(ServerConnection, BDTProc, directory, session)
3682: CourierConnection *ServerConnection;
3683: int ( *BDTProc)();
3684: FILING_Handle directory;
3685: FILING_Session session;
3686: {
3687: NoSuchProcedureValue("Filing", 20);
3688: }
3689:
3690:
3691: void FILING_RetrieveBytes(ServerConnection, BDTProc, file, range, sink, session)
3692: CourierConnection *ServerConnection;
3693: int ( *BDTProc)();
3694: FILING_Handle file;
3695: FILING_ByteRange range;
3696: BulkData1_Descriptor sink;
3697: FILING_Session session;
3698: {
3699: NoSuchProcedureValue("Filing", 22);
3700: }
3701:
3702:
3703: void FILING_ReplaceBytes(ServerConnection, BDTProc, file, range, source, session)
3704: CourierConnection *ServerConnection;
3705: int ( *BDTProc)();
3706: FILING_Handle file;
3707: FILING_ByteRange range;
3708: BulkData1_Descriptor source;
3709: FILING_Session session;
3710: {
3711: NoSuchProcedureValue("Filing", 23);
3712: }
3713:
3714:
3715: dir_storeproc(conn,handle,content)
3716: CourierConnection *conn;
3717: file_handle *handle;
3718: BulkData1_Descriptor content;
3719: {
3720: int count;
3721: char buffer[10];
3722:
3723: if ( content.designator == BulkData1_immediate ) {
3724: if ( (count= BDTread(conn,buffer,sizeof(buffer))) > 0 ) {
3725: BDTabort(conn);
3726: ReturnAttributeTypeError(FILING_unreasonable, FILING_isDirectory);
3727: /* NOT REACHED */
3728: }
3729: }
3730:
3731: if ( create_directory(handle) != -1 ) {
3732: /* NOT REACHED */
3733: }
3734:
3735: return(-1);
3736: }
3737:
3738:
3739: static Unspecified list_buffer[SPPMAXDATA];
3740: static Unspecified *list_end= list_buffer + SPPMAXDATA -1;
3741: static Unspecified *list_ptr= list_buffer;
3742:
3743: put_next_attribute_sequence(conn,stream_of_attrseq)
3744: CourierConnection *conn;
3745: FILING_StreamOfAttributeSequence *stream_of_attrseq;
3746: {
3747: int ocount;
3748:
3749: stream_of_attrseq->designator= nextSegment;
3750:
3751: if ( (list_ptr + FILING_sizeof_StreamOfAttributeSequence(stream_of_attrseq)) > list_end ) {
3752: #ifdef DEBUG
3753: fprintf(msgs,"put_next writing %d bulk data\n",list_ptr-list_buffer);
3754: #endif DEBUG
3755: if ( (ocount= BDTwrite(conn, list_buffer, (list_ptr-list_buffer)*sizeof(Cardinal))) <= 0 ) {
3756: list_ptr= list_buffer;
3757: BDTabort(conn);
3758: ReturnTransferError(FILING_aborted);
3759: /* NOT REACHED */
3760: }
3761:
3762: list_ptr= list_buffer;
3763: }
3764:
3765: list_ptr += FILING_externalize_StreamOfAttributeSequence(stream_of_attrseq, list_ptr);
3766:
3767: #ifdef DEBUG
3768: fprintf(msgs, "put_next_attr_seq (out) buf= %x, ptr= %x\n",list_buffer, list_ptr);
3769: #endif DEBUG
3770:
3771: return(-1);
3772: }
3773:
3774: put_last_attribute_sequence(conn)
3775: CourierConnection *conn;
3776: {
3777:
3778: int ocount;
3779: Cardinal zero= 0, lastseg= (Cardinal) lastSegment;
3780:
3781: if ( (list_ptr + (sizeof_Cardinal(0) * 3)) > list_end ) {
3782: #ifdef DEBUG
3783: fprintf(msgs,"put_last writing %d bulk data\n",list_ptr-list_buffer);
3784: #endif DEBUG
3785: if ( (ocount= BDTwrite(conn, list_buffer, (list_ptr-list_buffer)*sizeof(Cardinal))) <= 0 ) {
3786: list_ptr= list_buffer;
3787: BDTabort(conn);
3788: ReturnTransferError(FILING_aborted);
3789: /* NOT REACHED */
3790: }
3791: list_ptr= list_buffer;
3792: }
3793:
3794: list_ptr+= externalize_Cardinal(&lastseg, list_ptr);
3795: list_ptr+= externalize_Cardinal(&zero, list_ptr);
3796:
3797: #ifdef DEBUG
3798: fprintf(msgs,"put_last writing %d bulk data\n",list_ptr-list_buffer);
3799: #endif DEBUG
3800: if ( (ocount= BDTwrite(conn, list_buffer, (list_ptr-list_buffer)*sizeof(Cardinal))) <= 0 ) {
3801: list_ptr= list_buffer;
3802: BDTabort(conn);
3803: ReturnTransferError(FILING_aborted);
3804: /* NOT REACHED */
3805: }
3806:
3807: list_ptr= list_buffer;
3808: return(-1);
3809: }
3810:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.