![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fileio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [PGP] / pgp / src|
Return to fileio.c CVS log | Up to [PGP] / pgp / src |
1.1 ! root 1: /* fileio.c - I/O routines for PGP. ! 2: PGP: Pretty Good(tm) Privacy - public key cryptography for the masses. ! 3: ! 4: (c) Copyright 1990-1992 by Philip Zimmermann. All rights reserved. ! 5: The author assumes no liability for damages resulting from the use ! 6: of this software, even if the damage results from defects in this ! 7: software. No warranty is expressed or implied. ! 8: ! 9: All the source code Philip Zimmermann wrote for PGP is available for ! 10: free under the "Copyleft" General Public License from the Free ! 11: Software Foundation. A copy of that license agreement is included in ! 12: the source release package of PGP. Code developed by others for PGP ! 13: is also freely available. Other code that has been incorporated into ! 14: PGP from other sources was either originally published in the public ! 15: domain or was used with permission from the various authors. See the ! 16: PGP User's Guide for more complete information about licensing, ! 17: patent restrictions on certain algorithms, trademarks, copyrights, ! 18: and export controls. ! 19: ! 20: Modified 16 Apr 92 - HAJK ! 21: Mods for support of VAX/VMS file system ! 22: */ ! 23: ! 24: #include <ctype.h> ! 25: #include <stdio.h> ! 26: #include <stdlib.h> ! 27: #include <string.h> ! 28: #if defined(UNIX) ! 29: #include <sys/stat.h> ! 30: #if !defined(NeXT) ! 31: #include <unistd.h> ! 32: #endif ! 33: #endif ! 34: #include "random.h" ! 35: #include "mpilib.h" ! 36: #include "mpiio.h" ! 37: #include "fileio.h" ! 38: #include "language.h" ! 39: #include "pgp.h" ! 40: #ifdef MSDOS ! 41: #include <io.h> ! 42: #include <fcntl.h> ! 43: #endif ! 44: ! 45: /* 1st character of temporary file extension */ ! 46: #define TMP_EXT '$' /* extensions are '.$##' */ ! 47: ! 48: /* The PGPPATH environment variable */ ! 49: ! 50: char PGPPATH[] = "PGPPATH"; ! 51: ! 52: /* Disk buffers, used here and in crypto.c */ ! 53: byte textbuf[DISKBUFSIZE]; ! 54: static byte textbuf2[2*DISKBUFSIZE]; ! 55: ! 56: boolean file_exists(char *filename) ! 57: /* Returns TRUE iff file exists. */ ! 58: { ! 59: #ifdef UNIX ! 60: #ifndef F_OK ! 61: #define F_OK 0 ! 62: #endif ! 63: return(access(filename, F_OK) == 0); ! 64: #else ! 65: FILE *f; ! 66: /* open file f for read, in binary (not text) mode...*/ ! 67: if ((f = fopen(filename,"rb")) == NULL) ! 68: return(FALSE); ! 69: fclose(f); ! 70: return(TRUE); ! 71: #endif ! 72: } /* file_exists */ ! 73: ! 74: ! 75: boolean file_ok_write(char *filename) ! 76: /* Returns TRUE iff file can be opened for writing. ! 77: Does not harm file! ! 78: */ ! 79: { FILE *f; ! 80: if (file_exists (filename)) ! 81: return(TRUE); ! 82: if ((f = fopen(filename,"wb")) == NULL) ! 83: return(FALSE); ! 84: fclose(f); ! 85: remove(filename); ! 86: return(TRUE); ! 87: } /* file_ok_write */ ! 88: ! 89: boolean is_regular_file(char *filename) ! 90: { ! 91: #ifdef S_ISREG ! 92: struct stat st; ! 93: return(stat(filename, &st) != -1 && S_ISREG(st.st_mode)); ! 94: #else ! 95: return TRUE; ! 96: #endif ! 97: } ! 98: ! 99: int wipeout(FILE *f) ! 100: { /* Completely overwrite and erase file, so that no sensitive ! 101: information is left on the disk. ! 102: NOTE: File MUST be open for read/write. ! 103: */ ! 104: ! 105: long flength; ! 106: int count = 0; ! 107: ! 108: fseek(f, 0L, SEEK_END); ! 109: flength = ftell(f); ! 110: rewind(f); ! 111: ! 112: fill0(textbuf, sizeof(textbuf)); ! 113: while (flength > 0L) ! 114: { /* write zeros to the whole file... */ ! 115: if (flength < (word32) DISKBUFSIZE) ! 116: count = (int)flength; ! 117: else ! 118: count = DISKBUFSIZE; ! 119: fwrite(textbuf,1,count,f); ! 120: flength -= count; ! 121: } ! 122: rewind(f); /* maybe this isn't necessary */ ! 123: return(0); /* normal return */ ! 124: } /* wipeout */ ! 125: ! 126: ! 127: int wipefile(char *filename) ! 128: { /* Completely overwrite and erase file, so that no sensitive ! 129: information is left on the disk. ! 130: */ ! 131: FILE *f; ! 132: /* open file f for read/write, in binary (not text) mode...*/ ! 133: #ifdef VMS ! 134: if ((f = fopen(filename,"rb+","ctx=stm")) == NULL) ! 135: #else ! 136: if ((f = fopen(filename,"rb+")) == NULL) ! 137: #endif ! 138: return(-1); /* error - file can't be opened */ ! 139: wipeout(f); ! 140: fclose(f); ! 141: return(0); /* normal return */ ! 142: } /* wipefile */ ! 143: ! 144: char *file_tail (char *filename) ! 145: /* Returns the after-slash part of filename. Also skips backslashes, ! 146: * colons, and right brackets. */ ! 147: { ! 148: char *bslashPos = strrchr(filename, '\\');/* Find last bslash in filename */ ! 149: char *slashPos = strrchr(filename, '/');/* Find last slash in filename */ ! 150: char *colonPos = strrchr(filename, ':'); ! 151: char *rbrakPos = strrchr(filename, ']'); ! 152: ! 153: if (!slashPos || bslashPos > slashPos) ! 154: slashPos = bslashPos; ! 155: if (!slashPos || colonPos > slashPos) ! 156: slashPos = colonPos; ! 157: if (!slashPos || rbrakPos > slashPos) ! 158: slashPos = rbrakPos; ! 159: return( slashPos?(slashPos+1):filename ); ! 160: } ! 161: /* Define BSLASH for machines that use backslash, FSLASH for machines ! 162: * that use forward slash as separators. ! 163: */ ! 164: ! 165: #ifdef MSDOS ! 166: #define BSLASH ! 167: #endif ! 168: #ifdef ATARI ! 169: #define BSLASH ! 170: #endif ! 171: #ifdef UNIX ! 172: #define FSLASH ! 173: #define MULTIPLE_DOTS ! 174: #endif ! 175: #ifdef AMIGA ! 176: #define FSLASH ! 177: #define MULTIPLE_DOTS ! 178: #endif ! 179: ! 180: boolean has_extension(char *filename, char *extension) ! 181: { /* return TRUE if extension matches the end of filename */ ! 182: int lf = strlen(filename); ! 183: int lx = strlen(extension); ! 184: ! 185: if (lf <= lx) ! 186: return(FALSE); ! 187: return(!strcmp(filename + lf - lx, extension)); ! 188: } ! 189: ! 190: boolean is_tempfile(char *path) ! 191: { /* return TRUE if path is a filename created by tempfile() */ ! 192: char *p; ! 193: ! 194: return((p = strrchr(path, '.')) != NULL && ! 195: p[1] == TMP_EXT && strlen(p) == 4); ! 196: } ! 197: ! 198: boolean no_extension(char *filename) ! 199: /* Returns TRUE if user left off file extension, allowing default. */ ! 200: { ! 201: #ifdef MULTIPLE_DOTS /* filename can have more than one dot */ ! 202: if (has_extension(filename, CTX_EXTENSION) || ! 203: has_extension(filename, ASC_EXTENSION) || ! 204: has_extension(filename, PGP_EXTENSION) || ! 205: has_extension(filename, SIG_EXTENSION) || ! 206: is_tempfile(filename)) ! 207: return(FALSE); ! 208: else ! 209: return(TRUE); ! 210: #else ! 211: #ifdef BSLASH ! 212: char *slashPos = strrchr(filename, '\\'); /* Find last slash in filename */ ! 213: ! 214: /* Look for the filename after the last slash if there is one */ ! 215: return(strchr((slashPos != NULL ) ? slashPos : filename, '.') == NULL); ! 216: #else ! 217: #ifdef FSLASH ! 218: char *slashPos = strrchr(filename, '/'); /* Find last slash in filename */ ! 219: ! 220: /* Look for the filename after the last slash if there is one */ ! 221: return(strchr((slashPos != NULL ) ? slashPos : filename, '.') == NULL); ! 222: #else ! 223: #ifdef VMS ! 224: char *slashPos = strrchr(filename,']'); /* Locate end of directory spec */ ! 225: ! 226: /* Look for last period in filename */ ! 227: return(strrchr((slashPos != NULL) ? slashPos : filename, '.') == NULL ); ! 228: #else ! 229: return( (strrchr(filename,'.')==NULL) ? TRUE : FALSE ); ! 230: #endif /* VMS */ ! 231: #endif /* FSLASH */ ! 232: #endif /* BSLASH */ ! 233: #endif /* MULTIPLE_DOTS */ ! 234: } /* no_extension */ ! 235: ! 236: ! 237: void drop_extension(char *filename) ! 238: { /* deletes trailing ".xxx" file extension after the period. */ ! 239: if (!no_extension(filename)) ! 240: *strrchr(filename,'.') = '\0'; ! 241: } /* drop_extension */ ! 242: ! 243: ! 244: void default_extension(char *filename, char *extension) ! 245: { /* append filename extension if there isn't one already. */ ! 246: if (no_extension(filename)) ! 247: strcat(filename,extension); ! 248: } /* default_extension */ ! 249: ! 250: #ifndef MAX_NAMELEN ! 251: #if defined(AMIGA) || defined(NeXT) ! 252: #define MAX_NAMELEN 255 ! 253: #endif ! 254: #endif ! 255: ! 256: void truncate_name(char *path, int ext_len) ! 257: { /* truncate the filename so that an extension can be tacked on. */ ! 258: #ifdef UNIX /* for other systems this is a no-op */ ! 259: char dir[MAX_PATH], *p; ! 260: int namemax; ! 261: ! 262: #ifdef MAX_NAMELEN /* overrides the use of pathconf() */ ! 263: namemax = MAX_NAMELEN ! 264: #else ! 265: #ifdef _PC_NAME_MAX ! 266: strcpy(dir, path); ! 267: if ((p = strrchr(dir, '/')) == NULL) ! 268: strcpy(dir, "."); ! 269: else ! 270: { if (p == dir) ! 271: ++p; ! 272: *p = '\0'; ! 273: } ! 274: if ((namemax = pathconf(dir, _PC_NAME_MAX)) <= ext_len) ! 275: return; ! 276: #else ! 277: namemax = 14; ! 278: #endif ! 279: #endif /* MAX_NAMELEN */ ! 280: ! 281: if ((p = strrchr(path, '/')) == NULL) ! 282: p = path; ! 283: else ! 284: ++p; ! 285: if (strlen(p) > namemax - ext_len) ! 286: { ! 287: if (verbose) ! 288: fprintf(pgpout, "Truncating filename '%s' ", path); ! 289: p[namemax - ext_len] = '\0'; ! 290: if (verbose) ! 291: fprintf(pgpout, "to '%s'\n", path); ! 292: } ! 293: #endif /* UNIX */ ! 294: } ! 295: ! 296: void force_extension(char *filename, char *extension) ! 297: { /* change the filename extension. */ ! 298: drop_extension(filename); /* out with the old */ ! 299: truncate_name(filename, strlen(extension)); ! 300: strcat(filename,extension); /* in with the new */ ! 301: } /* force_extension */ ! 302: ! 303: ! 304: boolean getyesno(char default_answer) ! 305: /* Get yes/no answer from user, returns TRUE for yes, FALSE for no. ! 306: First the translations are checked, if they don't match 'y' and 'n' ! 307: are tried. ! 308: */ ! 309: { char buf[8]; ! 310: static char yes[8], no[8]; ! 311: ! 312: if (yes[0] == '\0') ! 313: { strncpy(yes, PSTR("y"), 7); ! 314: strncpy(no, PSTR("n"), 7); ! 315: } ! 316: flush_input(); ! 317: getstring(buf,6,TRUE); /* echo keyboard input */ ! 318: strlwr(buf); ! 319: if (!strncmp(buf, no, strlen(no))) ! 320: return(FALSE); ! 321: if (!strncmp(buf, yes, strlen(yes))) ! 322: return(TRUE); ! 323: if (buf[0] == 'n') ! 324: return(FALSE); ! 325: if (buf[0] == 'y') ! 326: return(TRUE); ! 327: return(default_answer == 'y' ? TRUE : FALSE); ! 328: } /* getyesno */ ! 329: ! 330: ! 331: ! 332: void maybe_force_extension(char *filename, char *extension) ! 333: { /* if user consents to it, change the filename extension. */ ! 334: char newname[MAX_PATH]; ! 335: if (!has_extension(filename,extension)) ! 336: { strcpy(newname,filename); ! 337: force_extension(newname,extension); ! 338: if (!file_exists(newname)) ! 339: { fprintf(pgpout,PSTR("\nShould '%s' be renamed to '%s' [Y/n]? "), ! 340: filename,newname); ! 341: if (getyesno('y')) ! 342: rename(filename,newname); ! 343: } ! 344: } ! 345: } /* maybe_force_extension */ ! 346: ! 347: char *buildfilename(char *result, char *fname) ! 348: /* Builds a filename with a complete path specifier from the environmental ! 349: variable PGPPATH. ! 350: */ ! 351: { char *s = getenv(PGPPATH); ! 352: ! 353: if ( s==NULL || strlen(s) > 50) /* undefined, or too long to use */ ! 354: s=""; ! 355: strcpy(result,s); ! 356: if (strlen(result) != 0) ! 357: #ifdef BSLASH ! 358: if (result[strlen(result)-1] != '\\') ! 359: strcat(result,"\\"); ! 360: #else ! 361: #ifdef FSLASH ! 362: if (result[strlen(result)-1] != '/') ! 363: strcat(result,"/"); ! 364: #else ! 365: #ifdef VMS ! 366: if (result[strlen(result)-1] != ']') ! 367: strcat(result,"]"); ! 368: #endif ! 369: #endif ! 370: #endif /* Various OS-specific defines */ ! 371: strcat(result,fname); ! 372: return(result); ! 373: } /* buildfilename */ ! 374: ! 375: int build_path(char *path, char *fileName, char *origPath) ! 376: /* Build a path for fileName based on origPath */ ! 377: { int i, lastSlash = 0; ! 378: ! 379: #ifdef BSLASH ! 380: for (i=0; origPath[i]; i++) ! 381: if (origPath[i] == ':' || origPath[i] == '\\') ! 382: lastSlash = i + 1; ! 383: #else ! 384: #ifdef VMS ! 385: for (i=0; origPath[i]; i++) ! 386: if (origPath[i] == ']') ! 387: lastSlash = i + 1; ! 388: #else ! 389: for (i=0; origPath[i]; i++) ! 390: if (origPath[i] == '/') ! 391: lastSlash = i + 1; ! 392: #endif ! 393: #endif ! 394: ! 395: /* Sanity check: Make sure the path is of legal length */ ! 396: if (i>=MAX_PATH) ! 397: { fprintf(pgpout,PSTR("Path '%s' too long\n"), origPath); ! 398: return(-1); /* error return */ ! 399: } ! 400: ! 401: strncpy(path,origPath,lastSlash); /* Add path component */ ! 402: strcpy(path+lastSlash,fileName); /* Append filename */ ! 403: return(0); /* normal return */ ! 404: } /* build_path */ ! 405: ! 406: ! 407: void file_to_canon(char *filename) ! 408: { /* Convert filename to canonical form, with slashes as separators */ ! 409: #ifdef BSLASH ! 410: while (*filename) { ! 411: if (*filename == '\\') ! 412: *filename = '/'; ! 413: ++filename; ! 414: } ! 415: #endif ! 416: } ! 417: ! 418: ! 419: void file_from_canon(char *filename) ! 420: { /* Convert filename from canonical to local form */ ! 421: /* I think everyone can handle slashes */ ! 422: filename = filename; /* Suppress warning */ ! 423: } ! 424: ! 425: ! 426: FILE *fopenbin(char *name, char *mode) ! 427: { ! 428: #if !defined(UNIX) ! 429: char mode_b[8]; ! 430: ! 431: strcpy(mode_b, mode); ! 432: strcat(mode_b, "b"); ! 433: mode = mode_b; ! 434: #endif ! 435: ! 436: #ifdef VMS ! 437: if (*mode == 'r') ! 438: return(fopen(name, mode, "ctx=stm")); ! 439: else ! 440: return(fopen(name, mode)); ! 441: #else ! 442: return(fopen(name, mode)); ! 443: #endif ! 444: } ! 445: ! 446: FILE *fopentxt(char *name, char *mode) ! 447: { ! 448: #ifdef VMS ! 449: if (*mode == 'r') ! 450: return(fopen(name, mode, "ctx=stm")); ! 451: else ! 452: return(fopen(name, mode)); ! 453: #else ! 454: return(fopen(name, mode)); ! 455: #endif ! 456: } ! 457: ! 458: ! 459: int copyfile(FILE *f, FILE *g, word32 longcount) ! 460: { /* copy file f to file g, for longcount bytes */ ! 461: int count, status = 0; ! 462: do /* read and write the whole file... */ ! 463: { ! 464: if (longcount < (word32) DISKBUFSIZE) ! 465: count = (int)longcount; ! 466: else ! 467: count = DISKBUFSIZE; ! 468: count = fread(textbuf,1,count,f); ! 469: if (count>0) ! 470: { ! 471: if (CONVERSION != NO_CONV) ! 472: { int i; ! 473: for (i = 0; i < count; i++) ! 474: textbuf[i] = (CONVERSION == EXT_CONV) ? ! 475: EXT_C(textbuf[i]) : ! 476: INT_C(textbuf[i]); ! 477: } ! 478: if (fwrite(textbuf,1,count,g) != count ) ! 479: { /* Problem: return error value */ ! 480: status = -1; ! 481: break; ! 482: } ! 483: longcount -= count; ! 484: } ! 485: /* if text block was short, exit loop */ ! 486: } while (count==DISKBUFSIZE); ! 487: burn(textbuf); /* burn sensitive data on stack */ ! 488: return(status); ! 489: } /* copyfile */ ! 490: ! 491: int copyfilepos (FILE *f, FILE *g, word32 longcount, word32 fpos) ! 492: /* Like copyfile, but takes a position for file f. Returns with ! 493: * f and g pointing just past the copied data. ! 494: */ ! 495: { ! 496: fseek (f, fpos, SEEK_SET); ! 497: return copyfile (f, g, longcount); ! 498: } ! 499: ! 500: ! 501: #ifndef CANONICAL_TEXT ! 502: int copyfile_to_canon (FILE *f, FILE *g, word32 longcount) ! 503: { /* copy file f to file g, for longcount bytes. Convert to ! 504: canonical form as we go. f is open in text mode. Canonical ! 505: form uses crlf's as line separators. */ ! 506: int count, status = 0; ! 507: byte c, *tb1, *tb2; ! 508: int i, nbytes; ! 509: do /* read and write the whole file... */ ! 510: { ! 511: if (longcount < (word32) DISKBUFSIZE) ! 512: count = (int)longcount; ! 513: else ! 514: count = DISKBUFSIZE; ! 515: count = fread(textbuf,1,count,f); ! 516: if (count>0) ! 517: { /* Convert by adding CR before LF */ ! 518: tb1 = textbuf; ! 519: tb2 = textbuf2; ! 520: for (i=0; i<count; ++i) ! 521: { switch (CONVERSION) { ! 522: case EXT_CONV: ! 523: c = EXT_C(*tb1++); ! 524: break; ! 525: case INT_CONV: ! 526: c = INT_C(*tb1++); ! 527: break; ! 528: default: ! 529: c = *tb1++; ! 530: } ! 531: if (c == '\n') ! 532: *tb2++ = '\r'; ! 533: *tb2++ = c; ! 534: } ! 535: nbytes = tb2 - textbuf2; ! 536: if (fwrite(textbuf2,1,nbytes,g) != nbytes ) ! 537: { /* Problem: return error value */ ! 538: status = -1; ! 539: break; ! 540: } ! 541: longcount -= count; ! 542: } ! 543: /* if text block was short, exit loop */ ! 544: } while (count==DISKBUFSIZE); ! 545: burn(textbuf); /* burn sensitive data on stack */ ! 546: burn(textbuf2); ! 547: return(status); ! 548: } /* copyfile_to_canon */ ! 549: #endif ! 550: ! 551: ! 552: #ifndef CANONICAL_TEXT ! 553: int copyfile_from_canon (FILE *f, FILE *g, word32 longcount) ! 554: { /* copy file f to file g, for longcount bytes. Convert from ! 555: canonical to local form as we go. g is open in text mode. Canonical ! 556: form uses crlf's as line separators. */ ! 557: int count, status = 0; ! 558: byte c, *tb1, *tb2; ! 559: int i, nbytes; ! 560: do /* read and write the whole file... */ ! 561: { ! 562: if (longcount < (word32) DISKBUFSIZE) ! 563: count = (int)longcount; ! 564: else ! 565: count = DISKBUFSIZE; ! 566: count = fread(textbuf,1,count,f); ! 567: if (count>0) ! 568: { /* Convert by removing CR's */ ! 569: tb1 = textbuf; ! 570: tb2 = textbuf2; ! 571: for (i=0; i<count; ++i) ! 572: { switch (CONVERSION) { ! 573: case EXT_CONV: ! 574: c = EXT_C(*tb1++); ! 575: break; ! 576: case INT_CONV: ! 577: c = INT_C(*tb1++); ! 578: break; ! 579: default: ! 580: c = *tb1++; ! 581: } ! 582: if (c != '\r') ! 583: *tb2++ = c; ! 584: } ! 585: nbytes = tb2 - textbuf2; ! 586: if (fwrite(textbuf2,1,nbytes,g) != nbytes ) ! 587: { /* Problem: return error value */ ! 588: status = -1; ! 589: break; ! 590: } ! 591: longcount -= count; ! 592: } ! 593: /* if text block was short, exit loop */ ! 594: } while (count==DISKBUFSIZE); ! 595: burn(textbuf); /* burn sensitive data on stack */ ! 596: burn(textbuf2); ! 597: return(status); ! 598: } /* copyfile_from_canon */ ! 599: #endif ! 600: ! 601: ! 602: int copyfiles_by_name(char *srcFile, char *destFile) ! 603: /* Copy srcFile to destFile */ ! 604: { ! 605: FILE *f, *g; ! 606: int status = 0; ! 607: long fileLength; ! 608: ! 609: #ifdef VMS ! 610: if (((f=fopen(srcFile,"rb","ctx=stm")) == NULL) || ! 611: #else ! 612: if (((f=fopen(srcFile,"rb")) == NULL) || ! 613: #endif ! 614: ((g=fopen(destFile,"wb")) == NULL)) ! 615: /* Can't open files */ ! 616: return(-1); ! 617: ! 618: /* Get file length and copy it */ ! 619: fseek(f,0L,SEEK_END); ! 620: fileLength = ftell(f); ! 621: rewind(f); ! 622: status = copyfile(f,g,fileLength); ! 623: fclose(f); ! 624: fclose(g); ! 625: return(status); ! 626: } /* copyfiles_by_name */ ! 627: ! 628: ! 629: int make_canonical(char *srcFile, char *destFile) ! 630: /* Copy srcFile to destFile, converting to canonical text form */ ! 631: { ! 632: FILE *f, *g; ! 633: int status = 0; ! 634: long fileLength; ! 635: ! 636: #ifdef CANONICAL_TEXT ! 637: if (((f=fopen(srcFile,"rb")) == NULL) || ! 638: #else ! 639: if (((f=fopen(srcFile,"r")) == NULL) || ! 640: #endif ! 641: ((g=fopen(destFile,"wb")) == NULL)) ! 642: /* Can't open files */ ! 643: return(-1); ! 644: ! 645: /* Get file length and copy it */ ! 646: fseek(f,0L,SEEK_END); ! 647: fileLength = ftell(f); ! 648: rewind(f); ! 649: CONVERSION = INT_CONV; ! 650: #ifdef CANONICAL_TEXT ! 651: status = copyfile(f,g,fileLength); ! 652: #else ! 653: status = copyfile_to_canon(f,g,fileLength); ! 654: #endif ! 655: CONVERSION = NO_CONV; ! 656: fclose(f); ! 657: fclose(g); ! 658: return(status); ! 659: } /* make_canonical */ ! 660: ! 661: ! 662: int rename2(char *srcFile, char *destFile) ! 663: /* Like rename() but will try to copy the file if the rename fails. ! 664: This is because under OS's with multiple physical volumes if the ! 665: source and destination are on different volumes the rename will fail */ ! 666: { ! 667: FILE *f, *g; ! 668: int status = 0; ! 669: long fileLength; ! 670: ! 671: if (rename(srcFile,destFile) == -1) ! 672: { /* Rename failed, try a copy */ ! 673: #ifdef VMS ! 674: if (((f=fopen(srcFile,"rb","ctx=stm")) == NULL) || ! 675: #else ! 676: if (((f=fopen(srcFile,"rb")) == NULL) || ! 677: #endif ! 678: ((g=fopen(destFile,"wb")) == NULL)) ! 679: /* Can't open files */ ! 680: return(-1); ! 681: ! 682: /* Get file length and copy it */ ! 683: fseek(f,0L,SEEK_END); ! 684: fileLength = ftell(f); ! 685: rewind(f); ! 686: status = copyfile(f,g,fileLength); ! 687: ! 688: /* Zap source file if the copy went OK, otherwise zap the (possibly ! 689: incomplete) destination file */ ! 690: if (status >= 0) ! 691: { wipeout(f); /* Zap source file */ ! 692: fclose(f); ! 693: remove(srcFile); ! 694: fclose(g); ! 695: } ! 696: else ! 697: { if (is_regular_file(destFile)) ! 698: { wipeout(g); /* Zap destination file */ ! 699: fclose(g); ! 700: remove(destFile); ! 701: } else ! 702: fclose(g); ! 703: fclose(f); ! 704: } ! 705: } ! 706: return(status); ! 707: } ! 708: ! 709: ! 710: int readPhantomInput(char *filename) ! 711: /* read the data from stdin to the phantom input file */ ! 712: { FILE *outFilePtr; ! 713: byte buffer[ 512 ]; ! 714: int bytesRead; ! 715: ! 716: if ((outFilePtr = fopen(filename,"wb")) == NULL) ! 717: return(-1); ! 718: ! 719: #ifdef MSDOS ! 720: /* Under DOS must set input stream to binary mode to avoid data mangling */ ! 721: setmode(fileno(stdin), O_BINARY); ! 722: #endif /* MSDOS */ ! 723: while ((bytesRead = fread (buffer, 1, 512, stdin)) > 0) ! 724: fwrite (buffer, 1, bytesRead, outFilePtr); ! 725: fclose (outFilePtr); ! 726: #ifdef MSDOS ! 727: setmode(fileno(stdin), O_TEXT); /* Reset stream */ ! 728: #endif /* MSDOS */ ! 729: return(0); ! 730: } ! 731: ! 732: ! 733: void writePhantomOutput(char *filename) ! 734: /* write the data from the phantom output file to stdout */ ! 735: { FILE *outFilePtr; ! 736: byte buffer[ 512 ]; ! 737: int bytesRead; ! 738: ! 739: /* this can't fail since we just created the file */ ! 740: outFilePtr = fopen(filename,"rb"); ! 741: ! 742: #ifdef MSDOS ! 743: setmode(fileno(stdout), O_BINARY); ! 744: #endif ! 745: while ((bytesRead = fread (buffer, 1, 512, outFilePtr)) > 0) ! 746: fwrite (buffer, 1, bytesRead, stdout); ! 747: fclose (outFilePtr); ! 748: fflush(stdout); ! 749: #ifdef MSDOS ! 750: setmode(fileno(stdout), O_TEXT); ! 751: #endif ! 752: ! 753: /* finally, delete the phantom file */ ! 754: wipefile(filename); ! 755: remove(filename); ! 756: } ! 757: ! 758: /* Return the size from the current position of file f to the end */ ! 759: word32 fsize (FILE *f) ! 760: { ! 761: long fpos = ftell (f); ! 762: long fpos2; ! 763: ! 764: fseek (f, 0L, SEEK_END); ! 765: fpos2 = ftell (f); ! 766: fseek (f, fpos, SEEK_SET); ! 767: return (word32)(fpos2 - fpos); ! 768: } ! 769: ! 770: /* Return TRUE if file filename looks like a pure text file */ ! 771: int is_text_file (char *filename) ! 772: { ! 773: FILE *f = fopen(filename,"rb"); ! 774: int i, n, bit8 = 0; ! 775: unsigned char buf[512]; ! 776: unsigned char *bufptr = buf; ! 777: unsigned char c; ! 778: ! 779: if (!f) ! 780: return(FALSE); /* error opening it, so not a text file */ ! 781: i = n = fread (buf, 1, sizeof(buf), f); ! 782: fclose(f); ! 783: if (n <= 0) ! 784: return(FALSE); /* empty file or error, not a text file */ ! 785: if (compressSignature(buf) >= 0) ! 786: return(FALSE); ! 787: while (i--) ! 788: { c = *bufptr++; ! 789: if (c & 0x80) ! 790: ++bit8; ! 791: else /* allow BEL BS HT LF VT FF CR EOF control characters */ ! 792: if (c < '\007' || (c > '\r' && c < ' ' && c != '\032')) ! 793: return(FALSE); /* not a text file */ ! 794: } ! 795: if (strcmp(language, "ru")) ! 796: return(TRUE); ! 797: /* assume binary if more than 1/4 bytes have 8th bit set */ ! 798: return(bit8 < n / 4); ! 799: } /* is_text_file */ ! 800: ! 801: void *xmalloc(unsigned size) ! 802: { void *p; ! 803: if (size == 0) ! 804: ++size; ! 805: if ((p = malloc(size)) == NULL) ! 806: { fprintf(stderr, PSTR("\n\007Out of memory.\n")); ! 807: exitPGP(1); ! 808: } ! 809: return(p); ! 810: } ! 811: ! 812: /*---------------------------------------------------------------------- ! 813: * temporary file routines ! 814: */ ! 815: ! 816: ! 817: #define MAXTMPF 8 ! 818: ! 819: #define TMP_INUSE 2 ! 820: ! 821: static struct ! 822: { char path[MAX_PATH]; ! 823: int flags; ! 824: } tmpf[MAXTMPF]; ! 825: ! 826: extern char outdir[]; ! 827: extern char basename[]; ! 828: ! 829: /* ! 830: * return a unique temporary file name ! 831: */ ! 832: char *tempfile(int flags) ! 833: { ! 834: int i; ! 835: int num = 0; ! 836: ! 837: for (i = 0; i < MAXTMPF; ++i) ! 838: if (tmpf[i].flags == 0) ! 839: break; ! 840: ! 841: if (i == MAXTMPF) ! 842: { /* message only for debugging, no need for PSTR */ ! 843: fprintf(stderr, "\n\007Out of temporary files\n"); ! 844: return(NULL); ! 845: } ! 846: ! 847: do ! 848: sprintf(tmpf[i].path, "%s%s.%c%02d", ! 849: (flags & TMP_TMPDIR ? tmpdir : outdir), basename, TMP_EXT, num); ! 850: while (file_exists(tmpf[i].path) && ++num < 100); ! 851: ! 852: if (!file_ok_write(tmpf[i].path)) ! 853: { fprintf(pgpout, PSTR("\n\007Cannot create temporary file '%s'\n"), tmpf[i].path); ! 854: user_error(); ! 855: } ! 856: ! 857: if (num == 100) ! 858: { fprintf(stderr, "\n\007tempfile: cannot find unique name\n"); ! 859: return(NULL); ! 860: } ! 861: ! 862: tmpf[i].flags = flags | TMP_INUSE; ! 863: if (verbose) ! 864: fprintf(stderr, "tempfile: created '%s'\n", tmpf[i].path); ! 865: return(tmpf[i].path); ! 866: } /* tempfile */ ! 867: ! 868: /* ! 869: * remove temporary file, wipe if necessary. ! 870: */ ! 871: void rmtemp(char *name) ! 872: { ! 873: int i; ! 874: ! 875: for (i = 0; i < MAXTMPF; ++i) ! 876: if (tmpf[i].flags && strcmp(tmpf[i].path, name) == 0) ! 877: break; ! 878: ! 879: if (i < MAXTMPF) ! 880: { if (strlen(name) > 3 && name[strlen(name)-3] == TMP_EXT) ! 881: { /* only remove file if name hasn't changed */ ! 882: if (verbose) ! 883: fprintf(stderr, "rmtemp: removing '%s'\n", name); ! 884: if (tmpf[i].flags & TMP_WIPE) ! 885: wipefile(name); ! 886: remove(name); ! 887: tmpf[i].flags = 0; ! 888: } else if (verbose) ! 889: fprintf(stderr, "rmtemp: not removing '%s'\n", name); ! 890: } ! 891: } /* rmtemp */ ! 892: ! 893: /* ! 894: * make temporary file permanent, returns the new name. ! 895: */ ! 896: char *savetemp(char *name, char *newname) ! 897: { ! 898: int i, overwrite; ! 899: static char buf[MAX_PATH]; ! 900: ! 901: if (strcmp(name, newname) == 0) ! 902: return(name); ! 903: ! 904: for (i = 0; i < MAXTMPF; ++i) ! 905: if (tmpf[i].flags && strcmp(tmpf[i].path, name) == 0) ! 906: break; ! 907: ! 908: if (i < MAXTMPF) ! 909: { if (strlen(name) < 4 || name[strlen(name)-3] != TMP_EXT) ! 910: { if (verbose) ! 911: fprintf(stderr, "savetemp: not renaming '%s' to '%s'\n", ! 912: name, newname); ! 913: return(name); /* return original file name */ ! 914: } ! 915: } ! 916: ! 917: while (file_exists(newname)) ! 918: { ! 919: if (is_regular_file(newname)) ! 920: { fprintf(pgpout,PSTR("\n\007Output file '%s' already exists. Overwrite (y/N)? "),newname); ! 921: overwrite = getyesno('n'); ! 922: } ! 923: else ! 924: { fprintf(pgpout,PSTR("\n\007Output file '%s' already exists.\n"),newname); ! 925: overwrite = FALSE; ! 926: } ! 927: ! 928: if (!overwrite) ! 929: { fprintf(pgpout, PSTR("\nEnter new file name: ")); ! 930: getstring(buf, MAX_PATH - 1, TRUE); ! 931: if (buf[0] == '\0') ! 932: return(NULL); ! 933: newname = buf; ! 934: } ! 935: else ! 936: remove(newname); ! 937: } ! 938: if (verbose) ! 939: fprintf(stderr, "savetemp: renaming '%s' to '%s'\n", name, newname); ! 940: if (rename2(name, newname) < 0) ! 941: { /* errorLvl = UNKNOWN_FILE_ERROR; */ ! 942: return(NULL); ! 943: } ! 944: if (i < MAXTMPF) ! 945: tmpf[i].flags = 0; ! 946: return(newname); ! 947: } /* savetemp */ ! 948: ! 949: /* ! 950: * like savetemp(), only make backup of destname if it exists ! 951: */ ! 952: int savetempbak(char *tmpname, char *destname) ! 953: { ! 954: char bakpath[MAX_PATH]; ! 955: ! 956: if (strcmp(destname, SCRATCH_KEYRING_PATH) == 0 || ! 957: is_tempfile(destname)) ! 958: remove(destname); ! 959: else ! 960: { if (file_exists(destname)) ! 961: { ! 962: strcpy(bakpath, destname); ! 963: force_extension(bakpath, BAK_EXTENSION); ! 964: remove(bakpath); ! 965: if (rename(destname, bakpath) == -1) ! 966: return(-1); ! 967: } ! 968: } ! 969: if (savetemp(tmpname, destname) == NULL) ! 970: return(-1); ! 971: return(0); ! 972: } ! 973: ! 974: /* ! 975: * remove all temporary files and wipe them if necessary ! 976: */ ! 977: void cleanup_tmpf(void) ! 978: { ! 979: int i; ! 980: ! 981: for (i = 0; i < MAXTMPF; ++i) ! 982: if (tmpf[i].flags) ! 983: rmtemp(tmpf[i].path); ! 984: } /* cleanup_tmpf */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.