![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to system_interface.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 system_interface.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: system_interface.c,v 1.6 87/05/14 11:35:19 ed Exp $"; ! 3: #endif lint ! 4: ! 5: /* ! 6: * Copyright (c) 1986, 1987 Xerox Corporation. ! 7: */ ! 8: ! 9: /* $Log: system_interface.c,v $ ! 10: * Revision 1.6 87/05/14 11:35:19 ed ! 11: * Enhanced fileID to be 32 bit inode (previous oversight). ! 12: * Also get_name_from_fileID now uses -a on ls to look at all files. ! 13: * ! 14: * Revision 1.5 87/04/16 15:26:17 ed ! 15: * Fixed bug if count was Filing4_unlimitedCount. (from jqj) ! 16: * Resolved lingering Subset pathname bugs. ! 17: * ! 18: * Revision 1.4 87/04/01 10:10:42 ed ! 19: * Added recognition of 'file drawers' (directories in root) ! 20: * in make_attribute_sequence. ! 21: * ! 22: * Revision 1.3 87/03/31 14:17:54 ed ! 23: * Fixed bug in access_file (per JQ Johnson) passed dir_handle, ! 24: * expected pathname, check for -1 failure, not success. ! 25: * ! 26: * Revision 1.2 87/03/31 09:46:46 ed ! 27: * New procedures: Create, ChangeAttributes(name only), Copy, Move, ! 28: * Replace, Serialize, Deserialize. ! 29: * Added conditional disabling of root logins. ! 30: * Support for GetAttributes (allAttributeTypes). ! 31: * Support for filter of type all. ! 32: * ! 33: * Revision 1.1 87/01/14 11:26:12 ed ! 34: * Initial revision ! 35: * ! 36: */ ! 37: ! 38: #include <stdio.h> ! 39: #include <pwd.h> ! 40: #include <signal.h> ! 41: #include <errno.h> ! 42: #include <ctype.h> ! 43: #include <sys/file.h> ! 44: #include <sys/time.h> ! 45: #include <sys/types.h> ! 46: #include <sys/stat.h> ! 47: #include <netns/ns.h> ! 48: #include <netns/sp.h> ! 49: #ifdef FILING4 ! 50: #include "filingV4.h" ! 51: #include "authenticationV2.h" ! 52: #endif FILING4 ! 53: #ifdef FILING5 ! 54: #include "filingV5.h" ! 55: #include "authenticationV2.h" ! 56: #endif FILING5 ! 57: #ifdef FILING6 ! 58: #include "filingV6.h" ! 59: #include "authenticationV3.h" ! 60: #endif FILING5 ! 61: #ifdef FILINGSUBSET1 ! 62: #include "filingsubsetV1.h" ! 63: #include "authenticationV3.h" ! 64: #endif FILINGSUBSET1 ! 65: #include <xnscourier/filing_server.h> ! 66: #include <xnscourier/filetypes.h> ! 67: ! 68: #define XNS_TIME_DIFFERENCE 2177452800 /* [(1970-1901) years * 365 days/year + 17 leap days */ ! 69: /* * 24 hours/day * 60 min/hour * 60 sec/min */ ! 70: ! 71: #define SERVICE_ROOT "/" /* root directory for service */ ! 72: #ifdef DEBUG ! 73: FILE *msgs; ! 74: #endif DEBUG ! 75: ! 76: extern int errno; ! 77: ! 78: Cardinal continuance; /* continuance value, in seconds */ ! 79: extern continuance_expiration(); /* expiration routine */ ! 80: ! 81: /* ! 82: * routine: ! 83: * verifyandposition_user ! 84: * input: ! 85: * user_name - derived from secondary credentials ! 86: * user_password - derived form secondary credentials ! 87: * returns: ! 88: * -1 - success ! 89: * else Filing Error, Problem ! 90: */ ! 91: ! 92: verifyandposition_user(user_name,user_password) ! 93: char *user_name; ! 94: char *user_password; ! 95: { ! 96: struct passwd *pwd_entry; ! 97: struct passwd *getpwnam(); ! 98: char *crypt(); ! 99: ! 100: #ifdef DEBUG ! 101: fprintf(msgs, "user= '%s'\n", user_name); ! 102: #endif DEBUG ! 103: ! 104: ! 105: /* determine if user is valid */ ! 106: if ( (pwd_entry= getpwnam(user_name)) == (struct passwd *)0 ) { ! 107: char *lowercase(); ! 108: #ifdef DEBUG ! 109: fprintf(msgs, "name= '%s'\n",lowercase(user_name)); ! 110: #endif DEBUG ! 111: if ( (pwd_entry= getpwnam(lowercase(user_name))) == (struct passwd *)0 ) { ! 112: #if FILING4 | FILING5 ! 113: ReturnAuthenticationError(AUTHENTICATION_credentialsInvalid); ! 114: #else FILING4 | FILING5 ! 115: ReturnAuthenticationError(FILING_secondaryCredentialsValueInvalid); ! 116: #endif FILING4 | FILING5 ! 117: /* NOT REACHED */ ! 118: } ! 119: } ! 120: ! 121: #if !(FILING4 | FILING5) ! 122: if ( strcmp(pwd_entry->pw_passwd, crypt(user_password,pwd_entry->pw_passwd)) ) { ! 123: ReturnAuthenticationError(FILING_secondaryCredentialsValueInvalid); ! 124: /* NOT REACHED */ ! 125: } ! 126: #endif !(FILING4 | FILING5) ! 127: /* set process group ID */ ! 128: if ( setgid(pwd_entry->pw_gid) == -1 ) { ! 129: #if FILING4 | FILING5 ! 130: ReturnAuthenticationError(AUTHENTICATION_credentialsInvalid); ! 131: #else FILING4 | FILING5 ! 132: ReturnAuthenticationError(FILING_secondaryCredentialsValueInvalid); ! 133: #endif FILING4 | FILING5 ! 134: /* NOT REACHED */ ! 135: } ! 136: /* set process user ID */ ! 137: if ( setuid(pwd_entry->pw_uid) == -1 ) { ! 138: #if FILING4 | FILING5 ! 139: ReturnAuthenticationError(AUTHENTICATION_credentialsInvalid); ! 140: #else FILING4 | FILING5 ! 141: ReturnAuthenticationError(FILING_secondaryCredentialsValueInvalid); ! 142: #endif FILING4 | FILING5 ! 143: /* NOT REACHED */ ! 144: } ! 145: /* position in service root */ ! 146: if ( chdir(SERVICE_ROOT) == -1 ) { ! 147: ReturnServiceError(FILING_serviceUnavailable); ! 148: /* NOT REACHED */ ! 149: } ! 150: ! 151: return(-1); ! 152: } ! 153: ! 154: ! 155: /* ! 156: * routine: ! 157: * set_continuance_timer ! 158: */ ! 159: ! 160: set_continuance_timer() ! 161: { ! 162: alarm(0); /* cancel any previous alarm */ ! 163: signal(SIGALRM, continuance_expiration); /* set routine to catch alarm */ ! 164: alarm(continuance); /* set alarm */ ! 165: } ! 166: ! 167: /* ! 168: * routine: ! 169: * reset_continuance_timer ! 170: */ ! 171: ! 172: reset_continuance_timer() ! 173: { ! 174: alarm(0); /* cancel previous alarm */ ! 175: alarm(continuance); /* then, reset alarm */ ! 176: } ! 177: ! 178: /* ! 179: * routine: ! 180: * cancel_continuance_timer ! 181: */ ! 182: ! 183: cancel_continuance_timer() ! 184: { ! 185: alarm(0); /* cancel any previous alarm */ ! 186: signal(SIGALRM,SIG_IGN); /* set routine to ignore alarm */ ! 187: } ! 188: ! 189: /* ! 190: * routine: ! 191: * open_file ! 192: * input: ! 193: * pointer to file handle ! 194: * returns: ! 195: * -1 - success ! 196: * else FILING_ error, problem ! 197: */ ! 198: ! 199: open_file(file_context_block) ! 200: file_handle *file_context_block; ! 201: { ! 202: #ifdef DEBUG ! 203: fprintf(msgs, "open_file\n"); ! 204: #endif DEBUG ! 205: ! 206: if ( (file_context_block->file_desc= ! 207: fopen(file_context_block->pathname, "r")) == NULL ) { ! 208: switch (errno) { ! 209: case EACCES : /* user has no access */ ! 210: ReturnAccessError(FILING_accessRightsInsufficient); ! 211: /* NOT REACHED */ ! 212: case ENOENT : /* no such file */ ! 213: case ENOTDIR : /* no such directory */ ! 214: ReturnHandleError(FILING_fileNotFound); ! 215: /* NOT REACHED */ ! 216: ! 217: default : /* all other errors */ ! 218: ReturnAccessError(FILING_accessRightsIndeterminate); ! 219: /* NOT REACHED */ ! 220: } ! 221: ! 222: } ! 223: ! 224: return(-1); ! 225: } ! 226: ! 227: /* ! 228: * routine: ! 229: * close_file ! 230: * input: ! 231: * pointer to file handle ! 232: * returns: ! 233: * -1 - success ! 234: */ ! 235: ! 236: close_file(file_context_block) ! 237: file_handle *file_context_block; ! 238: { ! 239: #ifdef DEBUG ! 240: fprintf(msgs, "closing...\n"); ! 241: #endif DEBUG ! 242: if ( file_context_block->file_desc != NULL ) { ! 243: fclose(file_context_block->file_desc); ! 244: file_context_block->file_desc= 0; ! 245: } ! 246: ! 247: return(-1); ! 248: } ! 249: ! 250: /* ! 251: * routine: ! 252: * stat_file ! 253: * input: ! 254: * pointer to file handle ! 255: * returns: ! 256: * -1 - success ! 257: * else Filing Error, Problem ! 258: * ! 259: * file_context_block entries filled in ! 260: */ ! 261: ! 262: stat_file(file_context_block) ! 263: file_handle *file_context_block; ! 264: { ! 265: struct stat file_stat; ! 266: LongCardinal get_type(); ! 267: ! 268: #ifdef DEBUG ! 269: fprintf(msgs, "stating '%s'\n",file_context_block->pathname); ! 270: #endif DEBUG ! 271: ! 272: if ( stat(file_context_block->pathname,&file_stat) == -1 ) { ! 273: switch (errno) { ! 274: case EACCES : /* user has no access */ ! 275: ReturnAccessError(FILING_accessRightsInsufficient); ! 276: /* NOT REACHED */ ! 277: case ENOTDIR : /* directory doesn't exist */ ! 278: case ENOENT : /* file doesn't exist */ ! 279: ReturnAccessError(FILING_fileNotFound); ! 280: ! 281: default : /* all other errors */ ! 282: ReturnAccessError(FILING_accessRightsIndeterminate); ! 283: } ! 284: } ! 285: ! 286: file_context_block->datasize= file_stat.st_size; /* dataSize */ ! 287: ! 288: /* file type */ ! 289: if ( (file_stat.st_mode & S_IFDIR) != 0 ) { /* directory */ ! 290: file_context_block->isdirectory= TRUE; ! 291: file_context_block->truetype= FILING_tDirectory; ! 292: } else { ! 293: file_context_block->isdirectory= FALSE; /* non-directory */ ! 294: file_context_block->truetype= get_type(file_context_block->pathname); ! 295: } ! 296: ! 297: return(-1); ! 298: } ! 299: ! 300: /* ! 301: * routine: ! 302: * create_file ! 303: * input: ! 304: * pointer to file handle ! 305: * returns: ! 306: * -1 - success ! 307: * else FILING_ Error, Problem ! 308: * ! 309: * file_context_block->file_desc filled in ! 310: */ ! 311: ! 312: create_file(file_context_block) ! 313: file_handle *file_context_block; ! 314: ! 315: { ! 316: ! 317: if ( access(file_context_block->pathname, F_OK) == 0 ) { ! 318: ReturnInsertionError(FILING_fileNotUnique); ! 319: /* NOT REACHED */ ! 320: } ! 321: ! 322: if ( (file_context_block->file_desc= ! 323: fopen(file_context_block->pathname, "w")) ) { ! 324: switch (errno) { ! 325: case EACCES : /* user has no access */ ! 326: ReturnAccessError(FILING_accessRightsInsufficient); ! 327: /* NOT REACHED */ ! 328: ! 329: case EEXIST : /* file exists */ ! 330: ReturnInsertionError(FILING_fileNotUnique); ! 331: /* NOT REACHED */ ! 332: ! 333: case ENOENT : /* no such file, OK */ ! 334: break; ! 335: ! 336: case ENOTDIR : /* no such directory */ ! 337: ReturnAccessError(FILING_fileNotFound); ! 338: /* NOT REACHED */ ! 339: ! 340: case EMFILE : /* process file table full */ ! 341: case ENFILE : /* system file table full */ ! 342: ReturnSpaceError(FILING_allocationExceeded); ! 343: /* NOT REACHED */ ! 344: ! 345: default : /* all other errors */ ! 346: ReturnAccessError(FILING_accessRightsIndeterminate); ! 347: /* NOT REACHED */ ! 348: } ! 349: } ! 350: ! 351: return(1); ! 352: } ! 353: /* ! 354: * routine: ! 355: * create_directory ! 356: * input: ! 357: * pointer to file handle ! 358: * returns: ! 359: * -1 - success ! 360: * else FILING_ Error, Problem ! 361: * ! 362: */ ! 363: ! 364: create_directory(file_context_block) ! 365: file_handle *file_context_block; ! 366: ! 367: { ! 368: int status; ! 369: ! 370: #ifdef DEBUG ! 371: fprintf(msgs, "createdir '%s'\n",file_context_block->pathname); ! 372: #endif DEBUG ! 373: status= 0; ! 374: if ( fork() == 0 ) { /* execute command */ ! 375: execl("/bin/mkdir", "mkdir", file_context_block->pathname, 0); ! 376: ReturnAccessError(FILING_accessRightsInsufficient); ! 377: /* NOT REACHED */ ! 378: } ! 379: ! 380: wait(&status); ! 381: if ( status ) { /* error reports accessRightsInsufficient */ ! 382: ReturnAccessError(FILING_accessRightsInsufficient); ! 383: /* NOT REACHED */ ! 384: } ! 385: ! 386: return(-1); ! 387: } ! 388: ! 389: /* ! 390: * routine: ! 391: * rename_file ! 392: * input: ! 393: * pointer to old name ! 394: * pointer to file handle (containing new name) ! 395: * returns: ! 396: * -1 - success ! 397: * else Filing Error, Problem ! 398: * ! 399: */ ! 400: ! 401: rename_file(oldname, file_context_block) ! 402: char *oldname; ! 403: file_handle *file_context_block; ! 404: { ! 405: ! 406: if ( access(file_context_block->pathname, F_OK) == 0 ) { ! 407: ReturnInsertionError(FILING_fileNotUnique); ! 408: /* NOT REACHED */ ! 409: } ! 410: ! 411: #ifdef DEBUG ! 412: fprintf(msgs, "renaming '%s' to '%s'\n",oldname, file_context_block->pathname); ! 413: #endif DEBUG ! 414: ! 415: if ( rename(oldname, file_context_block->pathname) == -1 ) { ! 416: switch (errno) { ! 417: case EACCES : /* user has no access */ ! 418: ReturnAccessError(FILING_accessRightsInsufficient); ! 419: /* NOT REACHED */ ! 420: case ENOTDIR : /* directory doesn't exist */ ! 421: case ENOENT : /* file doesn't exist */ ! 422: case EXDEV : /* no cross file system move */ ! 423: ReturnAccessError(FILING_fileChanged); ! 424: /* NOT REACHED */ ! 425: ! 426: case EINVAL : /* old is parent of new */ ! 427: ReturnInsertionError(FILING_loopInHierarchy); ! 428: /* NOT REACHED */ ! 429: ! 430: default : /* all other errors */ ! 431: ReturnAccessError(FILING_accessRightsIndeterminate); ! 432: /* NOT REACHED */ ! 433: } ! 434: } ! 435: ! 436: return(-1); ! 437: } ! 438: ! 439: /* ! 440: * routine: ! 441: * copy_file ! 442: * input: ! 443: * pointer to old file handle ! 444: * pointer to new file handle ! 445: * returns: ! 446: * -1 - success ! 447: * else Filing Error, Problem ! 448: * ! 449: */ ! 450: ! 451: copy_file(old_file_context_block, new_file_context_block) ! 452: file_handle *old_file_context_block; ! 453: file_handle *new_file_context_block; ! 454: { ! 455: int pid, s; ! 456: ! 457: if ( strncmp(old_file_context_block->pathname, new_file_context_block->pathname, strlen(old_file_context_block->pathname)) == 0 ) { ! 458: ReturnInsertionError(FILING_loopInHierarchy); ! 459: /* NOT REACHED */ ! 460: } ! 461: ! 462: if ( access(new_file_context_block->pathname, F_OK) == 0 ) { ! 463: ReturnInsertionError(FILING_fileNotUnique); ! 464: /* NOT REACHED */ ! 465: } ! 466: ! 467: #ifdef DEBUG ! 468: fprintf(msgs, "copying '%s' to '%s'\n",old_file_context_block->pathname, new_file_context_block->pathname); ! 469: #endif DEBUG ! 470: ! 471: if ( copy(old_file_context_block->pathname, new_file_context_block->pathname) != -1 ) { ! 472: ReturnAccessError(FILING_fileChanged); ! 473: /* NOT REACHED */ ! 474: } ! 475: ! 476: return(-1); ! 477: } ! 478: ! 479: copy(from, to) ! 480: char *from; ! 481: char *to; ! 482: { ! 483: int pid, s; ! 484: ! 485: if ( (pid= fork()) == 0 ) { ! 486: /* child */ ! 487: ! 488: execl("/bin/cp", "cp", "-r", from, to, 0); ! 489: exit(1); ! 490: } ! 491: ! 492: if ( pid == -1 ) { ! 493: ReturnUndefinedError(0); ! 494: /* NOT REACHED */ ! 495: } ! 496: ! 497: while ( wait(&s) != pid ) ; ! 498: ! 499: /* ! 500: * would be nice if cp returned useful errors, but ... ! 501: */ ! 502: ! 503: if ( s != 0 ) { ! 504: ReturnAccessError(FILING_fileChanged); ! 505: /* NOT REACHED */ ! 506: } ! 507: ! 508: return(-1); ! 509: } ! 510: ! 511: list_directory(conn, directory, attr, file_spec, count) ! 512: CourierConnection *conn; ! 513: file_handle *directory; ! 514: FILING_AttributeTypeSequence attr; ! 515: char *file_spec; ! 516: Cardinal count; ! 517: { ! 518: FILING_StreamOfAttributeSequence stream_of_attrseq; ! 519: FILING_AttributeSequence attribute_sequence; ! 520: FILE *pipe_desc; ! 521: FILE *popen(); ! 522: Boolean first= TRUE; ! 523: char command[256]; ! 524: char filename[MAX_FILE_NAME_LENGTH]; ! 525: ! 526: stream_of_attrseq.nextSegment_case.segment.length= 1; ! 527: stream_of_attrseq.nextSegment_case.segment.sequence= &attribute_sequence; ! 528: ! 529: strcpy(command, "/bin/ls -1d "); /* form appropriate command */ ! 530: ! 531: strcat(command, directory->pathname); ! 532: if ( strcmp(directory->pathname, "/") != 0 ) { ! 533: strcat(command, "/"); ! 534: } ! 535: ! 536: strcat(command, file_spec); ! 537: ! 538: if ( get_types(attr, &attribute_sequence) != -1 ) { ! 539: /* NOT REACHED */ ! 540: } ! 541: ! 542: #ifdef DEBUG ! 543: fprintf(msgs, "listing '%s'\n",command); ! 544: #endif DEBUG ! 545: ! 546: if ( (pipe_desc= popen(command, "r")) == NULL ) { /* issue command */ ! 547: ReturnAccessError(FILING_accessRightsInsufficient); ! 548: /* NOT REACHED */ ! 549: } ! 550: ! 551: while ( fgets(filename, MAX_FILE_NAME_LENGTH, pipe_desc) != NULL ) { ! 552: first= FALSE; ! 553: filename[strlen(filename)-1]= '\0'; ! 554: ! 555: #ifdef DEBUG ! 556: fprintf(msgs,"got '%s' ",filename); ! 557: fprintf(msgs, "count= %d\n",count); ! 558: #endif DEBUG ! 559: ! 560: if ( (count != FILING_unlimitedCount) && (--count < 0) ) { ! 561: break; ! 562: } ! 563: ! 564: make_attribute_sequence(filename,&attribute_sequence); ! 565: ! 566: put_next_attribute_sequence(conn, &stream_of_attrseq); ! 567: } ! 568: ! 569: if ( first == TRUE ) { ! 570: pclose(pipe_desc); ! 571: /* ReturnAccessError(FILING_fileNotFound); ??? */ ! 572: /* NOT REACHED */ ! 573: } ! 574: ! 575: put_last_attribute_sequence(conn); ! 576: ! 577: BDTclosewrite(conn); ! 578: pclose(pipe_desc); ! 579: ! 580: return(-1); ! 581: } ! 582: ! 583: /* ! 584: * routine: ! 585: * delete_file ! 586: * input: ! 587: * pointer to file handle ! 588: * returns: ! 589: * -1 - success ! 590: * else Filing Error, Problem ! 591: */ ! 592: ! 593: delete_file(file_context_block) ! 594: file_handle *file_context_block; ! 595: { ! 596: int status; ! 597: ! 598: #ifdef DEBUG ! 599: fprintf(msgs," deleting '%s'",file_context_block->pathname); ! 600: #endif DEBUG ! 601: if ( file_context_block->isdirectory ) { ! 602: if ( fork() == 0 ) { /* use rm -rf for directories */ ! 603: execl("/bin/rm", "rm", "-rf", file_context_block->pathname, 0); ! 604: ReturnAccessError(FILING_accessRightsInsufficient); ! 605: /* NOT REACHED */ ! 606: } ! 607: wait(&status); ! 608: if ( status ) { ! 609: ReturnAccessError(FILING_accessRightsInsufficient); ! 610: /* NOT REACHED */ ! 611: } ! 612: } else { /* use unlink for non-directories */ ! 613: if ( unlink(file_context_block->pathname) == -1 ) { ! 614: switch (errno) { ! 615: case EACCES : /* user has no access */ ! 616: ReturnAccessError(FILING_accessRightsInsufficient); ! 617: /* NOT REACHED */ ! 618: ! 619: case ENOENT : /* no such file */ ! 620: case ENOTDIR : /* no such directory */ ! 621: ReturnAccessError(FILING_fileNotFound); ! 622: /* NOT REACHED */ ! 623: ! 624: default : /* all other errors */ ! 625: ReturnAccessError(FILING_accessRightsIndeterminate); ! 626: /* NOT REACHED */ ! 627: } ! 628: } ! 629: } ! 630: } ! 631: ! 632: /* ! 633: * routine: ! 634: * delete_partial_file ! 635: * input: ! 636: * pointer to file handle ! 637: * returns: ! 638: * -1 - success ! 639: */ ! 640: ! 641: delete_partial_file(file_context_block) ! 642: file_handle *file_context_block; ! 643: { ! 644: unlink(file_context_block->pathname); ! 645: return(-1); ! 646: } ! 647: ! 648: /* ! 649: * routine: ! 650: * access_file ! 651: * input: ! 652: * pointer to file handle ! 653: * returns: ! 654: * -1 - success ! 655: */ ! 656: ! 657: access_file(file_context_block) ! 658: file_handle *file_context_block; ! 659: { ! 660: #ifdef DEBUG ! 661: fprintf(msgs, "access_file\n"); ! 662: #endif DEBUG ! 663: ! 664: if ( access(file_context_block->pathname,R_OK | F_OK) == -1 ) { ! 665: switch (errno) { ! 666: case EACCES : /* user has no access */ ! 667: ReturnAccessError(FILING_fileChanged); ! 668: /* NOT REACHED */ ! 669: case ENOENT : /* no such file */ ! 670: case ENOTDIR : /* no such directory */ ! 671: ReturnHandleError(FILING_invalid); ! 672: /* NOT REACHED */ ! 673: ! 674: default : /* all other errors */ ! 675: ReturnAccessError(FILING_accessRightsIndeterminate); ! 676: /* NOT REACHED */ ! 677: } ! 678: ! 679: } ! 680: ! 681: return(-1); ! 682: } ! 683: ! 684: /* ! 685: * routine: ! 686: * set_create_time ! 687: * input: ! 688: * pointer to file context block ! 689: * where ! 690: * if no createdOn value was specified on Store, createdon = 0 ! 691: * if createdOn value was specified on Store, createdOn != 0, ! 692: * value is in XNS time format ! 693: * returns: ! 694: * none ! 695: */ ! 696: ! 697: set_create_time(file_context_block) ! 698: file_handle *file_context_block; ! 699: ! 700: { ! 701: time_t time_buffer[2]; ! 702: time_t time(); ! 703: ! 704: ! 705: if ( file_context_block->createdon ) /* save createdOn if specified */ ! 706: time_buffer[1]= file_context_block->createdon - XNS_TIME_DIFFERENCE; ! 707: else /* else, set to current date/time */ ! 708: time_buffer[1]= time(0); ! 709: ! 710: time_buffer[0]= time(0); /* set modifiedOn to current date/time */ ! 711: ! 712: utime(file_context_block->pathname,time_buffer); ! 713: } ! 714: ! 715: /* ! 716: * routine: ! 717: * make_attribute_sequence ! 718: * inputs: ! 719: * pointer to file name ! 720: * pointer to sequence of attributes to fill in ! 721: * returns: ! 722: * -1 - success ! 723: */ ! 724: ! 725: make_attribute_sequence(pathname, attrseq) ! 726: char *pathname; ! 727: FILING_AttributeSequence *attrseq; ! 728: { ! 729: int i; ! 730: struct stat file_stat; ! 731: FILING_AttributeType t; ! 732: ! 733: LongCardinal createdon, modifiedon; ! 734: LongCardinal type, get_type(); ! 735: LongCardinal datasize; ! 736: Boolean isdirectory; ! 737: Boolean all_attributes= FALSE; ! 738: Cardinal unix_version= 1; ! 739: Boolean istemporary= FALSE; ! 740: #ifdef FILETOOLCOMPATIBILITY ! 741: Cardinal fileid[6]; ! 742: AUTHENTICATION_Clearinghouse_Name user; ! 743: AUTHENTICATION_Clearinghouse_Name CH_StringToName(); ! 744: char *name, *pwname; ! 745: char *rindex(); ! 746: struct passwd *getpwuid(), *pwd; ! 747: #endif FILETOOLCOMPATIBILITY ! 748: #ifdef EXTENSIONS ! 749: Boolean inroot= FALSE; ! 750: FILE *fd; ! 751: #endif EXTENSIONS ! 752: ! 753: #ifdef DEBUG ! 754: fprintf(msgs, "make_attrseq '%s'\n", pathname); ! 755: #endif DEBUG ! 756: ! 757: #ifndef FILINGSUBSET1 ! 758: if ( (name= rindex(pathname, '/')) == 0 ) ! 759: name= pathname; ! 760: else { ! 761: #ifdef EXTENSIONS ! 762: if ( name == pathname ) inroot= TRUE; ! 763: #endif EXTENSIONS ! 764: name++; ! 765: } ! 766: #endif FILINGSUBSET1 ! 767: ! 768: if ( stat(pathname, &file_stat) == -1 ) { ! 769: ReturnAccessError(FILING_accessRightsInsufficient); ! 770: /* NOT REACHED */ ! 771: } ! 772: ! 773: createdon= file_stat.st_mtime + XNS_TIME_DIFFERENCE; /* createdOn */ ! 774: modifiedon= file_stat.st_atime + XNS_TIME_DIFFERENCE; /* modifiedOn */ ! 775: ! 776: datasize= file_stat.st_size; /* dataSize */ ! 777: ! 778: /* type and isDirectory */ ! 779: if ( (file_stat.st_mode & S_IFDIR) != 0 ) { ! 780: isdirectory= TRUE; ! 781: #ifdef EXTENSIONS ! 782: if ( inroot ) /* if root & directory, assume file drawer */ ! 783: type= TYPE_VPDrawer; ! 784: else ! 785: type= FILING_tDirectory; ! 786: #else EXTENSIONS ! 787: type= FILING_tDirectory; ! 788: #endif EXTENSIONS ! 789: } else { ! 790: type= get_type(pathname); ! 791: #ifdef EXTENSIONS ! 792: if ( (type > LAST_FILING_TYPE) && (type != TYPE_Interpress) && ! 793: (type != TYPE_VPCanvas) ) { ! 794: if ( (fd= fopen(pathname, "r")) == NULL ) { ! 795: ReturnAccessError(FILING_fileChanged); ! 796: /* NOT REACHED */ ! 797: } ! 798: isdirectory= GetDirectoryAttribute(fd); ! 799: fclose(fd); ! 800: } else { ! 801: isdirectory= FALSE; ! 802: } ! 803: #else EXTENSIONS ! 804: isdirectory= FALSE; ! 805: #endif EXTENSIONS ! 806: } ! 807: ! 808: #ifdef EXTENSIONS ! 809: if ( attrseq->length == -1 ) { ! 810: all_attributes= TRUE; ! 811: if ( (type > LAST_FILING_TYPE) && (type != TYPE_Interpress) && ! 812: (type != TYPE_VPCanvas) ) ! 813: make_required_attributes(attrseq); ! 814: else ! 815: make_supported_attributes(attrseq); ! 816: } ! 817: #endif EXTENSIONS ! 818: ! 819: for ( i= 0 ; i < attrseq->length ; i++ ) { ! 820: t= attrseq->sequence[i].type; ! 821: #ifdef DEBUG ! 822: fprintf(msgs,"#%d type= %d \n", i, t); ! 823: #endif DEBUG ! 824: ! 825: if ( t == FILING_pathname ) { ! 826: StringToAttr(pathname, &attrseq->sequence[i]); ! 827: } else if ( t == FILING_type ) { ! 828: LongCardinalToAttr(type, &attrseq->sequence[i]); ! 829: } else if ( t == FILING_dataSize ) { ! 830: LongCardinalToAttr(datasize, &attrseq->sequence[i]); ! 831: } else if ( t == FILING_isDirectory ) { ! 832: BooleanToAttr(isdirectory, &attrseq->sequence[i]); ! 833: } else if ( t == FILING_createdOn ) { ! 834: LongCardinalToAttr(createdon, &attrseq->sequence[i]); ! 835: } else if ( t == FILING_modifiedOn ) { ! 836: LongCardinalToAttr(modifiedon, &attrseq->sequence[i]); ! 837: } else if ( t == FILING_version ) { ! 838: CardinalToAttr(unix_version, &attrseq->sequence[i]); ! 839: } else if ( t == FILING_isTemporary ) { ! 840: BooleanToAttr(istemporary, &attrseq->sequence[i]); ! 841: #ifdef FILETOOLCOMPATIBILITY ! 842: } else if ( t == FILING_name ) { ! 843: StringToAttr(name, &attrseq->sequence[i]); ! 844: } else if ( t == FILING_fileID ) { ! 845: fileid[0]= (file_stat.st_ino >> 16) & 0xffff; ! 846: fileid[1]= file_stat.st_ino & 0xffff; ! 847: fileid[2]= fileid[3]= fileid[4]= 0; ! 848: FileIDToAttr(fileid, &attrseq->sequence[i]); ! 849: } else if ( t == FILING_readOn ) { ! 850: LongCardinalToAttr(modifiedon, &attrseq->sequence[i]); ! 851: } else if ( t == FILING_createdBy ) { ! 852: if ( (pwd= getpwuid(file_stat.st_uid)) == 0 ) ! 853: pwname= "Unkown"; ! 854: else ! 855: pwname= pwd->pw_name; ! 856: user= CH_StringToName(pwname,NULL); ! 857: UserToAttr(user,&attrseq->sequence[i]); ! 858: #endif FILETOOLCOMPATIBILITY ! 859: } else { ! 860: attrseq->sequence[i].value.length= 0; ! 861: attrseq->sequence[i].value.sequence= (Unspecified *)0; ! 862: } ! 863: } ! 864: ! 865: #ifdef EXTENSIONS ! 866: if ( all_attributes ) { ! 867: if ( (type > LAST_FILING_TYPE) && (type != TYPE_Interpress) && ! 868: (type != TYPE_VPCanvas) ) { ! 869: if ( (fd= fopen(pathname, "r")) == NULL ) { ! 870: ReturnAccessError(FILING_fileChanged); ! 871: /* NOT REACHED */ ! 872: } ! 873: if ( AddAllExtendedAttributes(fd, attrseq) != -1 ) { ! 874: fclose(fd); ! 875: ReturnAccessError(FILING_fileChanged); ! 876: /* NOT REACHED */ ! 877: } ! 878: fclose(fd); ! 879: } ! 880: } ! 881: #endif EXTENSIONS ! 882: } ! 883: ! 884: int ! 885: getBDTch(conn,bpp) ! 886: CourierConnection *conn; ! 887: u_char **bpp; ! 888: { ! 889: static u_char buffer[SPPMAXDATA]; ! 890: static int count; ! 891: ! 892: if (*bpp == NULL) {*bpp = buffer; count = 0;} ! 893: if (*bpp >= buffer+count) { ! 894: count=BDTread(conn,buffer,sizeof(buffer)); ! 895: *bpp = buffer; ! 896: } ! 897: if (count <= 0) return(EOF); ! 898: else return(*((*bpp)++)); ! 899: ! 900: } ! 901: ! 902: storeproc(conn,handle) ! 903: CourierConnection *conn; ! 904: file_handle *handle; ! 905: { ! 906: int count, ocount, ch, hashbytes; ! 907: char buffer[SPPMAXDATA]; ! 908: int charset, charset16; ! 909: char *bp; ! 910: register FILE *fout; ! 911: register int fd; ! 912: ! 913: fout= handle->file_desc; ! 914: fd= fileno(fout); ! 915: ! 916: #ifdef FILETOOLCOMPATIBILITY ! 917: if ( handle->type == FILING_tText ) { ! 918: charset = 0; charset16 = 0; bp = NULL; ! 919: while ((ch = getBDTch(conn,&bp)) != EOF) { ! 920: if (ch == '\377') { ! 921: ch = getBDTch(conn,&bp); ! 922: if (ch == '\377') charset16 = 1; ! 923: else charset = ch; ! 924: continue; ! 925: } ! 926: if (charset16) { ! 927: charset = ch; ! 928: ch = getBDTch(conn,&bp); ! 929: } ! 930: switch (charset) { ! 931: case 0: /* normal character set -- minimal xlation */ ! 932: if (ch == '\r') { ! 933: int nextch; ! 934: ! 935: putc('\n',fout); ! 936: if ( (nextch = getBDTch(conn,&bp)) != '\n'){ ! 937: if (nextch == '\r') ! 938: putc('\n',fout); ! 939: else if (nextch == ','+0200) ! 940: putc('_',fout); ! 941: else if (nextch != EOF) ! 942: putc(nextch,fout); ! 943: else ! 944: continue; ! 945: } ! 946: ! 947: break; ! 948: } ! 949: else if (ch == ','+0200) ch = '_'; ! 950: /* more mapping here */ ! 951: putc(ch,fout); ! 952: break; ! 953: default: ! 954: break; /* ignore */ ! 955: } ! 956: } ! 957: /* if (count < 0) perror("netin"); */ ! 958: } else { ! 959: #else FILETOOLCOMPATIBILITY ! 960: { ! 961: #endif FILETOOLCOMPATIBILITY ! 962: errno = ocount = 0; ! 963: fflush(fout); ! 964: while ((count = BDTread(conn, buffer, sizeof(buffer))) > 0) { ! 965: if ((ocount = write(fd,buffer,count)) < 0) { ! 966: perror("write"); ! 967: BDTabort(conn); ! 968: return(0); ! 969: } ! 970: } ! 971: if (count < 0) { ! 972: perror("netin"); ! 973: return(0); ! 974: } ! 975: } ! 976: ! 977: return(-1); ! 978: } ! 979: ! 980: retrieveproc(conn, handle) ! 981: CourierConnection *conn; ! 982: file_handle *handle; ! 983: { ! 984: int count, ocount; ! 985: u_char buffer[SPPMAXDATA]; ! 986: u_char *bp; ! 987: ! 988: errno = ocount = 0; ! 989: clearerr(handle->file_desc); ! 990: ! 991: if ( handle->type == -1 ) ! 992: handle->type= handle->truetype; ! 993: ! 994: #ifdef DEBUG ! 995: fprintf(msgs, "transferring data type= %d\n", handle->type); ! 996: #endif DEBUG ! 997: ! 998: #ifdef FILETOOLCOMPATIBILITY ! 999: if (handle->type == FILING_tText) { ! 1000: while ((count = fread(buffer, sizeof(char), SPPMAXDATA, handle->file_desc)) > 0) { ! 1001: ocount = count; ! 1002: for (bp = buffer; count > 0; count--, bp++) { ! 1003: if (*bp == '\n') *bp = '\r'; ! 1004: else if (*bp == '_') *bp = ','+0200; ! 1005: /* more translations here */ ! 1006: } ! 1007: if ((ocount = BDTwrite(conn, buffer, ocount)) <= 0) ! 1008: break; ! 1009: } ! 1010: } else { ! 1011: #else FILETOOLCOMPATIBILITY ! 1012: { ! 1013: #endif FILETOOLCOMPATIBILITY ! 1014: while ((count = fread(buffer, sizeof(char), SPPMAXDATA, handle->file_desc)) > 0 ! 1015: && (ocount = BDTwrite(conn, buffer, count)) > 0) { ! 1016: } ! 1017: } ! 1018: ! 1019: if (ocount < 0) { ! 1020: BDTabort(conn); ! 1021: perror("netout"); ! 1022: return(0); ! 1023: } ! 1024: else if (ferror(handle->file_desc)) { ! 1025: BDTabort(conn); ! 1026: perror("read"); ! 1027: return(0); ! 1028: } ! 1029: else ! 1030: BDTclosewrite(conn); ! 1031: ! 1032: return(-1); ! 1033: } ! 1034: ! 1035: #ifdef FILETOOLCOMPATIBILITY ! 1036: get_name_from_fileID(handle, fileid) ! 1037: file_handle *handle; ! 1038: Unspecified *fileid; ! 1039: { ! 1040: char cmd[256]; ! 1041: char pathname[256]; ! 1042: char buffer[256]; ! 1043: int inode; ! 1044: FILE *fd, *popen(); ! 1045: Boolean first= TRUE; ! 1046: ! 1047: if ( *(handle->pathname) == '\0' ) { ! 1048: ReturnAttributeTypeError(FILING_unreasonable, FILING_fileID); ! 1049: /* NOT REACHED */ ! 1050: } ! 1051: ! 1052: #ifdef DEBUG ! 1053: fprintf(msgs, "looking for fileid %x %x\n", fileid[0], fileid[1]); ! 1054: #endif DEBUG ! 1055: ! 1056: strcpy(cmd, "/bin/ls -1ai "); ! 1057: strcat(cmd, handle->pathname); ! 1058: ! 1059: if ( (fd= popen(cmd, "r")) == NULL ) { ! 1060: ReturnAccessError(FILING_accessRightsInsufficient); ! 1061: /* NOT REACHED */ ! 1062: } ! 1063: ! 1064: while ( fgets(buffer, sizeof(buffer), fd) != NULL ) { ! 1065: buffer[strlen(buffer)-1]= '\0'; ! 1066: ! 1067: sscanf(buffer, "%d %s", &inode, pathname); ! 1068: #ifdef DEBUG ! 1069: fprintf(msgs, "inode= %d '%s'\n",inode, pathname); ! 1070: #endif DEBUG ! 1071: ! 1072: if ( (fileid[0] == ((inode>>16)&0xffff)) && ! 1073: (fileid[1] == (inode&0xffff)) ) { ! 1074: if ( strcmp(handle->pathname, "/") != 0 ) ! 1075: strcat(handle->pathname, "/"); ! 1076: strcat(handle->pathname, pathname); ! 1077: pclose(fd); ! 1078: return(-1); ! 1079: } ! 1080: } ! 1081: ! 1082: pclose(fd); ! 1083: ReturnAccessError(FILING_fileNotFound); ! 1084: /* NOT REACHED */ ! 1085: } ! 1086: #endif FILETOOLCOMPATIBILITY ! 1087: ! 1088: check_pathname(pathname) ! 1089: char *pathname; ! 1090: { ! 1091: char *ptr; ! 1092: ! 1093: for ( ptr= pathname; *ptr != '\0' ; ptr++ ) { ! 1094: if ( isspace(*ptr) || iscntrl(*ptr) ) { ! 1095: ReturnAttributeValueError(FILING_illegal, FILING_pathname); ! 1096: /* NOT REACHED */ ! 1097: } ! 1098: } ! 1099: ! 1100: return(-1); ! 1101: } ! 1102: ! 1103: #ifdef EXTENSIONS ! 1104: /* ! 1105: * make_backup ! 1106: * ! 1107: */ ! 1108: ! 1109: make_backup(handle) ! 1110: file_handle *handle; ! 1111: ! 1112: { ! 1113: char buffer[2048]; ! 1114: char backup_name[MAX_FILE_NAME_LENGTH]; ! 1115: int fin, fout, count; ! 1116: ! 1117: strcpy(backup_name, handle->pathname); ! 1118: strcat(backup_name, ".REP"); ! 1119: ! 1120: if ( (fin= open(handle->pathname, O_RDONLY, 0)) < 0 ) { ! 1121: return(0); ! 1122: /* NOT REACHED */ ! 1123: } ! 1124: ! 1125: if ( (fout= open(backup_name, O_WRONLY|O_CREAT, 0600)) < 0 ) { ! 1126: return(0); ! 1127: /* NOT REACHED */ ! 1128: } ! 1129: ! 1130: while ( (count= read(fin, buffer, sizeof(buffer))) > 0 ) { ! 1131: if ( write(fout, buffer, count) < 0 ) { ! 1132: close(fin); ! 1133: close(fout); ! 1134: unlink(backup_name); ! 1135: return(0); ! 1136: /* NOT REACHED */ ! 1137: } ! 1138: } ! 1139: ! 1140: close(fin); ! 1141: close(fout); ! 1142: return(-1); ! 1143: } ! 1144: ! 1145: /* ! 1146: * recall_backup ! 1147: * ! 1148: */ ! 1149: ! 1150: recall_backup(handle) ! 1151: file_handle *handle; ! 1152: ! 1153: { ! 1154: char backup_name[MAX_FILE_NAME_LENGTH]; ! 1155: ! 1156: strcpy(backup_name, handle->pathname); ! 1157: strcat(backup_name, ".REP"); ! 1158: ! 1159: /* ! 1160: * we better not see an error here, since we have already ! 1161: * munged the original file ! 1162: */ ! 1163: ! 1164: if ( rename(backup_name, handle->pathname) == -1 ) { ! 1165: return(0); ! 1166: } ! 1167: ! 1168: return(-1); ! 1169: } ! 1170: ! 1171: unlink_backup(handle) ! 1172: file_handle *handle; ! 1173: ! 1174: { ! 1175: char backup_name[MAX_FILE_NAME_LENGTH]; ! 1176: ! 1177: strcpy(backup_name, handle->pathname); ! 1178: strcat(backup_name, ".REP"); ! 1179: ! 1180: if ( unlink(backup_name) == -1 ) { ! 1181: return(0); ! 1182: } ! 1183: ! 1184: return(-1); ! 1185: } ! 1186: #endif EXTENSIONS
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.