![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to file_io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / unzip|
Return to file_io.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / unzip |
1.1 ! root 1: /*--------------------------------------------------------------------------- ! 2: ! 3: file_io.c ! 4: ! 5: This file contains routines for doing direct input/output, file-related ! 6: sorts of things. Most of the system-specific code for unzip is contained ! 7: here, including the non-echoing password code for decryption (bottom). ! 8: ! 9: ---------------------------------------------------------------------------*/ ! 10: ! 11: ! 12: #if (!defined(__GO32__) && !defined(NeXT)) ! 13: # define const ! 14: #endif ! 15: ! 16: #define FILE_IO_C ! 17: #include "unzip.h" ! 18: ! 19: #ifdef MSWIN ! 20: # include "wizunzip.h" ! 21: #endif ! 22: ! 23: ! 24: /************************************/ ! 25: /* File_IO Local Prototypes, etc. */ ! 26: /************************************/ ! 27: ! 28: #if (!defined(DOS_OS2) || defined(MSWIN)) ! 29: static int dos2unix __((unsigned char *buf, int len)); ! 30: int CR_flag = 0; /* when last char of buffer == CR (for dos2unix()) */ ! 31: #endif ! 32: ! 33: #ifdef OS2 ! 34: extern int longname; /* set in mapname.c */ ! 35: extern char longfilename[]; ! 36: #endif ! 37: ! 38: #ifdef CRYPT ! 39: # if (defined(DOS_OS2) || defined(VMS)) ! 40: # define MSVMS ! 41: # ifdef DOS_OS2 ! 42: # ifdef __EMX__ ! 43: # define getch() _read_kbd(0, 1, 0) ! 44: # else ! 45: # ifdef __GO32__ ! 46: # include <pc.h> ! 47: # define getch() getkey() ! 48: # else /* !__GO32__ */ ! 49: # include <conio.h> ! 50: # endif /* ?__GO32__ */ ! 51: # endif ! 52: # else /* !DOS_OS2 */ ! 53: # define getch() getc(stderr) ! 54: # define OFF 0 /* for echo control */ ! 55: # define ON 1 ! 56: # define echoff(f) echo(OFF) ! 57: # define echon() echo(ON) ! 58: # include <descrip.h> ! 59: # include <iodef.h> ! 60: # include <ttdef.h> ! 61: # if !defined(SS$_NORMAL) ! 62: # define SS$_NORMAL 1 /* only thing we need from <ssdef.h> */ ! 63: # endif ! 64: # endif /* ?DOS_OS2 */ ! 65: # else /* !(DOS_OS2 || VMS) */ ! 66: # ifdef TERMIO /* Amdahl, Cray, all SysV? */ ! 67: # ifdef CONVEX ! 68: # include <sys/termios.h> ! 69: # include <sgtty.h> ! 70: # else /* !CONVEX */ ! 71: # ifdef LINUX ! 72: # include <termios.h> ! 73: # else /* !LINUX */ ! 74: # include <termio.h> ! 75: # endif /* ?LINUX */ ! 76: # define sgttyb termio ! 77: # define sg_flags c_lflag ! 78: # endif /* ?CONVEX */ ! 79: int ioctl OF((int, int, voidp *)); ! 80: # define GTTY(f,s) ioctl(f,TCGETA,(voidp *)s) ! 81: # define STTY(f,s) ioctl(f,TCSETAW,(voidp *)s) ! 82: # else /* !TERMIO */ ! 83: # if (!defined(MINIX) && !defined(__386BSD__)) ! 84: # include <sys/ioctl.h> ! 85: # endif /* !MINIX && !__386BSD__ */ ! 86: # include <sgtty.h> ! 87: # ifdef __386BSD__ ! 88: # define GTTY(f, s) ioctl(f, TIOCGETP, (voidp *) s) ! 89: # define STTY(f, s) ioctl(f, TIOCSETP, (voidp *) s) ! 90: # else /* !__386BSD__ */ ! 91: # define GTTY gtty ! 92: # define STTY stty ! 93: int gtty OF((int, struct sgttyb *)); ! 94: int stty OF((int, struct sgttyb *)); ! 95: # endif /* ?__386BSD__ */ ! 96: # endif /* ?TERMIO */ ! 97: int isatty OF((int)); ! 98: char *ttyname OF((int)); ! 99: # if (defined(PROTO) && !defined(__GNUC__) && !defined(_AIX)) ! 100: int open (char *, int, ...); ! 101: # endif ! 102: int close OF((int)); ! 103: int read OF((int, voidp *, int)); ! 104: # endif /* ?(DOS_OS2 || VMS) */ ! 105: #endif /* CRYPT */ ! 106: ! 107: ! 108: ! 109: ! 110: ! 111: /******************************/ ! 112: /* Function open_input_file() */ ! 113: /******************************/ ! 114: ! 115: int open_input_file() /* return non-zero if open failed */ ! 116: { ! 117: /* ! 118: * open the zipfile for reading and in BINARY mode to prevent cr/lf ! 119: * translation, which would corrupt the bitstreams ! 120: */ ! 121: ! 122: #ifdef VMS ! 123: zipfd = open(zipfn, O_RDONLY, 0, "ctx=stm"); ! 124: #else /* !VMS */ ! 125: #ifdef UNIX ! 126: zipfd = open(zipfn, O_RDONLY); ! 127: #else /* !UNIX */ ! 128: #ifdef MACOS ! 129: zipfd = open(zipfn, 0); ! 130: #else /* !MACOS */ ! 131: zipfd = open(zipfn, O_RDONLY | O_BINARY); ! 132: #endif /* ?MACOS */ ! 133: #endif /* ?UNIX */ ! 134: #endif /* ?VMS */ ! 135: if (zipfd < 1) { ! 136: fprintf(stderr, "error: can't open zipfile [ %s ]\n", zipfn); ! 137: return (1); ! 138: } ! 139: return 0; ! 140: } ! 141: ! 142: ! 143: ! 144: ! 145: ! 146: /**********************/ ! 147: /* Function readbuf() */ ! 148: /**********************/ ! 149: ! 150: int readbuf(buf, size) ! 151: char *buf; ! 152: register unsigned size; ! 153: { /* return number of bytes read into buf */ ! 154: register int count; ! 155: int n; ! 156: ! 157: n = size; ! 158: while (size) { ! 159: if (incnt == 0) { ! 160: if ((incnt = read(zipfd, (char *)inbuf, INBUFSIZ)) <= 0) ! 161: return (n-size); ! 162: /* buffer ALWAYS starts on a block boundary: */ ! 163: cur_zipfile_bufstart += INBUFSIZ; ! 164: inptr = inbuf; ! 165: } ! 166: count = MIN(size, (unsigned)incnt); ! 167: memcpy(buf, inptr, count); ! 168: buf += count; ! 169: inptr += count; ! 170: incnt -= count; ! 171: size -= count; ! 172: } ! 173: return (n); ! 174: } ! 175: ! 176: ! 177: ! 178: ! 179: ! 180: #ifndef VMS /* for VMS use code in vms.c (old VMS code below is retained ! 181: * in case of problems...will be removed in a later release) */ ! 182: ! 183: /*********************************/ ! 184: /* Function create_output_file() */ ! 185: /*********************************/ ! 186: ! 187: int create_output_file() /* return non-0 if creat failed */ ! 188: { ! 189: /*--------------------------------------------------------------------------- ! 190: Create the output file with appropriate permissions. If we've gotten to ! 191: this point and the file still exists, we have permission to blow it away. ! 192: ---------------------------------------------------------------------------*/ ! 193: ! 194: #if (!defined(DOS_OS2) || defined(MSWIN)) ! 195: CR_flag = 0; /* hack to get CR at end of buffer working */ ! 196: #endif ! 197: ! 198: #if (defined(UNIX) && !defined(AMIGA)) ! 199: { ! 200: int mask; ! 201: ! 202: #ifndef VMS ! 203: if (!stat(filename, &statbuf) && (unlink(filename) < 0)) { ! 204: fprintf(stderr, "\n%s: cannot delete old copy\n", filename); ! 205: return 1; ! 206: } ! 207: # define EXTRA_ARGS ! 208: #else /* VMS */ ! 209: # define EXTRA_ARGS ,"rfm=stmlf","rat=cr" ! 210: #endif /* ?VMS */ ! 211: ! 212: mask = umask(0); /* now know that we own it */ ! 213: outfd = creat(filename, 0xffff & pInfo->unix_attr EXTRA_ARGS); ! 214: umask(mask); /* VMS, Unix */ ! 215: } ! 216: #else /* !UNIX || AMIGA */ /* file permissions set after file closed */ ! 217: #ifndef MACOS ! 218: outfd = creat(filename, S_IWRITE | S_IREAD); /* DOS, OS2, Mac, Amiga */ ! 219: #else /* MACOS */ ! 220: { ! 221: short fDataFork=TRUE; ! 222: MACINFO mi; ! 223: OSErr err; ! 224: ! 225: fMacZipped = FALSE; ! 226: CtoPstr(filename); ! 227: if (extra_field && ! 228: (lrec.extra_field_length > sizeof(MACINFOMIN)) && ! 229: (lrec.extra_field_length <= sizeof(MACINFO))) { ! 230: BlockMove(extra_field, &mi, lrec.extra_field_length); ! 231: if ((makeword((byte *)&mi.header) == 1992) && ! 232: (makeword((byte *)&mi.data) == ! 233: lrec.extra_field_length-sizeof(ZIP_EXTRA_HEADER)) && ! 234: (mi.signature == 'JLEE')) { ! 235: gostCreator = mi.finfo.fdCreator; ! 236: gostType = mi.finfo.fdType; ! 237: fDataFork = (mi.flags & 1) ? TRUE : FALSE; ! 238: fMacZipped = true; ! 239: /* If it was Zipped w/Mac version, the filename has either */ ! 240: /* a 'd' or 'r' appended. Remove the d/r when unzipping */ ! 241: filename[0]-=1; ! 242: } ! 243: } ! 244: if (!fMacZipped) { ! 245: if (!aflag) ! 246: gostType = gostCreator = '\?\?\?\?'; ! 247: else { ! 248: #ifdef THINK_C ! 249: gostCreator = 'KAHL'; ! 250: #else ! 251: #ifdef MCH_MACINTOSH ! 252: gostCreator = 'Manx'; ! 253: #else ! 254: gostCreator = 'MPS '; ! 255: #endif ! 256: #endif ! 257: gostType = 'TEXT'; ! 258: } ! 259: } ! 260: PtoCstr(filename); ! 261: ! 262: outfd = creat(filename, 0); ! 263: if (fMacZipped) { ! 264: CtoPstr(filename); ! 265: if (hfsflag) { ! 266: HParamBlockRec hpbr; ! 267: ! 268: hpbr.fileParam.ioNamePtr = (StringPtr)filename; ! 269: hpbr.fileParam.ioVRefNum = gnVRefNum; ! 270: hpbr.fileParam.ioDirID = glDirID; ! 271: hpbr.fileParam.ioFlFndrInfo = mi.finfo; ! 272: hpbr.fileParam.ioFlCrDat = mi.lCrDat; ! 273: hpbr.fileParam.ioFlMdDat = mi.lMdDat; ! 274: err = PBHSetFInfo(&hpbr, 0); ! 275: } else { ! 276: err = SetFInfo((StringPtr)filename , 0, &mi.finfo); ! 277: } ! 278: PtoCstr(filename); ! 279: } ! 280: if (outfd != -1) ! 281: outfd = open(filename, (fDataFork)? 1 : 2); ! 282: } ! 283: #endif /* ?MACOS */ ! 284: #endif /* ?(UNIX && !AMIGA) */ ! 285: ! 286: if (outfd < 1) { ! 287: fprintf(stderr, "\n%s: cannot create\n", filename); ! 288: return 1; ! 289: } ! 290: ! 291: /*--------------------------------------------------------------------------- ! 292: If newly created file is in text mode and should be binary (to disable ! 293: automatic CR/LF translations), either close it and reopen as binary or ! 294: else change the mode to binary (DOS, OS/2). ! 295: ---------------------------------------------------------------------------*/ ! 296: ! 297: #if (!defined(UNIX) && !defined(MACOS)) ! 298: if (!aflag) { ! 299: #ifdef DOS_OS2 ! 300: if (setmode(outfd, O_BINARY) == -1) { ! 301: #else /* !DOS_OS2 */ ! 302: close(outfd); ! 303: if ((outfd = open(filename, O_RDWR | O_BINARY)) < 1) { ! 304: #endif /* ?DOS_OS2 */ ! 305: fprintf(stderr, "Can't make output file binary: %s\n", filename); ! 306: return 1; ! 307: } ! 308: } ! 309: #endif /* !UNIX && !MACOS */ ! 310: ! 311: return 0; ! 312: } ! 313: ! 314: #endif /* !VMS */ ! 315: ! 316: ! 317: ! 318: ! 319: ! 320: /****************************/ ! 321: /* Function FillBitBuffer() */ ! 322: /****************************/ ! 323: ! 324: int FillBitBuffer() ! 325: { ! 326: /* ! 327: * Fill bitbuf, which is 32 bits. This function is only used by the ! 328: * READBIT and PEEKBIT macros (which are used by all of the uncompression ! 329: * routines). ! 330: */ ! 331: UWORD temp; ! 332: ! 333: zipeof = 1; ! 334: while (bits_left < 25 && ReadByte(&temp) == 8) ! 335: { ! 336: bitbuf |= (ULONG)temp << bits_left; ! 337: bits_left += 8; ! 338: zipeof = 0; ! 339: } ! 340: return 0; ! 341: } ! 342: ! 343: ! 344: ! 345: ! 346: ! 347: /***********************/ ! 348: /* Function ReadByte() */ ! 349: /***********************/ ! 350: ! 351: int ReadByte(x) ! 352: UWORD *x; ! 353: { ! 354: /* ! 355: * read a byte; return 8 if byte available, 0 if not ! 356: */ ! 357: ! 358: if (mem_mode) ! 359: return ReadMemoryByte(x); ! 360: ! 361: if (csize-- <= 0) ! 362: return 0; ! 363: ! 364: if (incnt == 0) { ! 365: if ((incnt = read(zipfd, (char *)inbuf, INBUFSIZ)) <= 0) ! 366: return 0; ! 367: /* buffer ALWAYS starts on a block boundary: */ ! 368: cur_zipfile_bufstart += INBUFSIZ; ! 369: inptr = inbuf; ! 370: #ifdef CRYPT ! 371: if (pInfo->encrypted) { ! 372: byte *p; ! 373: int n, t; ! 374: ! 375: for (n = (longint)incnt > csize + 1 ? (int)csize + 1 : incnt, ! 376: p = inptr; n--; p++) ! 377: *p = (byte) DECRYPT(*p); ! 378: } ! 379: #endif /* CRYPT */ ! 380: } ! 381: *x = *inptr++; ! 382: --incnt; ! 383: return 8; ! 384: } ! 385: ! 386: ! 387: ! 388: ! 389: ! 390: #ifndef VMS /* for VMS use code in vms.c */ ! 391: ! 392: /**************************/ ! 393: /* Function FlushOutput() */ ! 394: /**************************/ ! 395: ! 396: int FlushOutput() ! 397: { ! 398: /* ! 399: * flush contents of output buffer; return PK-type error code ! 400: */ ! 401: #if (!defined(DOS_OS2) || defined(MSWIN)) ! 402: int saved_ctrlZ = FALSE; ! 403: #endif ! 404: int len; ! 405: ! 406: ! 407: if (mem_mode) { ! 408: int rc = FlushMemory(); ! 409: outpos += outcnt; ! 410: outcnt = 0; ! 411: outptr = outbuf; ! 412: return rc; ! 413: } ! 414: ! 415: if (disk_full) { ! 416: outpos += outcnt; /* fake emptied buffer */ ! 417: outcnt = 0; ! 418: outptr = outbuf; ! 419: return 50; /* ignore rest of this file */ ! 420: } ! 421: ! 422: if (outcnt) { ! 423: UpdateCRC(outbuf, outcnt); ! 424: ! 425: if (!tflag) { ! 426: #if (!defined(DOS_OS2) || defined(MSWIN)) ! 427: if (aflag) { ! 428: if (outbuf[outcnt-1] == CTRLZ) { ! 429: --outcnt; ! 430: saved_ctrlZ = TRUE; ! 431: } ! 432: len = dos2unix(outbuf, outcnt); ! 433: } else ! 434: #endif /* !DOS_OS2 || MSWIN */ ! 435: len = outcnt; ! 436: #ifdef MACOS ! 437: if ((giCursor+1) >> 2 != (giCursor>>2)) ! 438: SetCursor( *rghCursor[((giCursor+1)>>2)&0x03] ); ! 439: giCursor = (giCursor+1) & 15; ! 440: #endif /* MACOS */ ! 441: #ifdef MSWIN ! 442: /* if writing to console vs. actual file, write to Msg Window */ ! 443: if (cflag) ! 444: WriteBufferToMsgWin(outout, len, FALSE); ! 445: else if (_lwrite(outfd, outout, len) != (UINT)len) ! 446: #else /* !MSWIN */ ! 447: if (write(outfd, (char *)outout, len) != len) ! 448: #endif /* ?MSWIN */ ! 449: #ifdef DOS_OS2 ! 450: if (!cflag) /* ^Z treated as EOF, removed with -c */ ! 451: #else /* !DOS_OS2 */ ! 452: #ifdef MINIX ! 453: if (errno == EFBIG) ! 454: if (write(fd, outout, len/2) != len/2 || ! 455: write(fd, outout+len/2, len/2) != len/2) ! 456: #endif /* MINIX */ ! 457: #endif /* ?DOS_OS2 */ ! 458: { ! 459: /* GRR: add test for force_flag when has its own switch */ ! 460: fprintf(stderr, ! 461: "\n%s: write error (disk full?). Continue? (y/n/^C) ", ! 462: filename); ! 463: FFLUSH /* for Amiga and Mac MPW */ ! 464: #ifdef MSWIN ! 465: disk_full = 2; ! 466: #else /* !MSWIN */ ! 467: fgets(answerbuf, 9, stdin); ! 468: if (*answerbuf == 'y') /* stop writing to this file */ ! 469: disk_full = 1; /* (outfd bad?), but new OK */ ! 470: else ! 471: disk_full = 2; /* no: exit program */ ! 472: #endif /* ?MSWIN */ ! 473: return 50; /* 50: disk full */ ! 474: } ! 475: } ! 476: outpos += outcnt; ! 477: outcnt = 0; ! 478: outptr = outbuf; ! 479: #if (!defined(DOS_OS2) || defined(MSWIN)) ! 480: if (saved_ctrlZ) { ! 481: *outptr++ = CTRLZ; ! 482: ++outcnt; ! 483: } ! 484: #endif /* !DOS_OS2 || MSWIN */ ! 485: } ! 486: return 0; /* 0: no error */ ! 487: } ! 488: ! 489: #endif /* !VMS */ ! 490: ! 491: ! 492: ! 493: ! 494: ! 495: #if (!defined(DOS_OS2) || defined(MSWIN)) ! 496: ! 497: /***********************/ ! 498: /* Function dos2unix() */ ! 499: /***********************/ ! 500: ! 501: static int dos2unix(buf, len) /* GRR: rewrite for generic text conversions */ ! 502: unsigned char *buf; ! 503: int len; ! 504: { ! 505: int new_len; ! 506: int i; ! 507: #ifdef MSWIN ! 508: unsigned char __far *walker; ! 509: #else /* !MSWIN */ ! 510: unsigned char *walker; ! 511: #endif /* ?MSWIN */ ! 512: ! 513: new_len = len; ! 514: walker = outout; ! 515: #ifdef MACOS ! 516: /* ! 517: * Mac wants to strip LFs instead CRs from CRLF pairs ! 518: */ ! 519: if (CR_flag && *buf == LF) { ! 520: buf++; ! 521: new_len--; ! 522: len--; ! 523: CR_flag = buf[len] == CR; ! 524: } ! 525: else ! 526: CR_flag = buf[len - 1] == CR; ! 527: for (i = 0; i < len; i += 1) { ! 528: *walker++ = ascii_to_native(*buf); ! 529: if (*buf == LF) walker[-1] = CR; ! 530: if (*buf++ == CR && *buf == LF) { ! 531: new_len--; ! 532: buf++; ! 533: i++; ! 534: } ! 535: } ! 536: #else /* !MACOS */ ! 537: if (CR_flag && *buf != LF) ! 538: *walker++ = ascii_to_native(CR); ! 539: CR_flag = buf[len - 1] == CR; ! 540: for (i = 0; i < len; i += 1) { ! 541: *walker++ = ascii_to_native(*buf); ! 542: if (*buf++ == CR && *buf == LF) { ! 543: new_len--; ! 544: walker[-1] = ascii_to_native(*buf++); ! 545: i++; ! 546: } ! 547: } ! 548: /* ! 549: * If the last character is a CR, then "ignore it" for now... ! 550: */ ! 551: if (walker[-1] == ascii_to_native(CR)) ! 552: new_len--; ! 553: #endif /* ?MACOS */ ! 554: return new_len; ! 555: } ! 556: ! 557: #endif /* !DOS_OS2 || MSWIN */ ! 558: ! 559: ! 560: ! 561: ! 562: ! 563: #ifdef __GO32__ ! 564: ! 565: void _dos_setftime(int fd, UWORD dosdate, UWORD dostime) ! 566: { ! 567: asm("pushl %ebx"); ! 568: asm("movl %0, %%ebx": : "g" (fd)); ! 569: asm("movl %0, %%ecx": : "g" (dostime)); ! 570: asm("movl %0, %%edx": : "g" (dosdate)); ! 571: asm("movl $0x5701, %eax"); ! 572: asm("int $0x21"); ! 573: asm("popl %ebx"); ! 574: } ! 575: ! 576: void _dos_setfileattr(char *name, int attr) ! 577: { ! 578: asm("movl %0, %%edx": : "g" (name)); ! 579: asm("movl %0, %%ecx": : "g" (attr)); ! 580: asm("movl $0x4301, %eax"); ! 581: asm("int $0x21"); ! 582: } ! 583: ! 584: #endif /* __GO32__ */ ! 585: ! 586: ! 587: ! 588: ! 589: ! 590: #ifdef DOS_OS2 ! 591: ! 592: /**************************************/ ! 593: /* Function set_file_time_and_close() */ ! 594: /**************************************/ ! 595: ! 596: void set_file_time_and_close() ! 597: /* ! 598: * MS-DOS AND OS/2 VERSION (Mac, Unix/VMS versions are below) ! 599: * ! 600: * Set the output file date/time stamp according to information from the ! 601: * zipfile directory record for this member, then close the file and set ! 602: * its permissions (archive, hidden, read-only, system). Aside from closing ! 603: * the file, this routine is optional (but most compilers support it). ! 604: */ ! 605: { ! 606: /*--------------------------------------------------------------------------- ! 607: Allocate local variables needed by OS/2 and Turbo C. ! 608: ---------------------------------------------------------------------------*/ ! 609: ! 610: #ifdef __TURBOC__ ! 611: ! 612: union { ! 613: struct ftime ft; /* system file time record */ ! 614: struct { ! 615: UWORD ztime; /* date and time words */ ! 616: UWORD zdate; /* .. same format as in .ZIP file */ ! 617: } zt; ! 618: } td; ! 619: ! 620: #endif /* __TURBOC__ */ ! 621: ! 622: /*--------------------------------------------------------------------------- ! 623: Do not attempt to set the time stamp on standard output. ! 624: ---------------------------------------------------------------------------*/ ! 625: ! 626: if (cflag) { ! 627: close(outfd); ! 628: return; ! 629: } ! 630: ! 631: /*--------------------------------------------------------------------------- ! 632: Copy and/or convert time and date variables, if necessary; then set the ! 633: file time/date. ! 634: ---------------------------------------------------------------------------*/ ! 635: ! 636: #ifndef OS2 ! 637: #ifdef __TURBOC__ ! 638: td.zt.ztime = lrec.last_mod_file_time; ! 639: td.zt.zdate = lrec.last_mod_file_date; ! 640: setftime(outfd, &td.ft); ! 641: #else /* !__TURBOC__ */ ! 642: #ifdef WIN32 ! 643: { ! 644: FILETIME ft; /* 64-bit value made up of two 32 bit [low & high] */ ! 645: WORD wDOSDate; /* for vconvertin from DOS date to Windows NT */ ! 646: WORD wDOSTime; ! 647: HANDLE hFile; /* file handle (defined in Windows NT) */ ! 648: ! 649: wDOSTime = (WORD) lrec.last_mod_file_time; ! 650: wDOSDate = (WORD) lrec.last_mod_file_date; ! 651: ! 652: /* The DosDateTimeToFileTime() function converts a DOS date/time ! 653: * into a 64 bit Windows NT file time */ ! 654: DosDateTimeToFileTime(wDOSDate, wDOSTime, &ft); ! 655: ! 656: /* Close the file and then re-open it using the Win32 ! 657: * CreateFile call, so that the file can be created ! 658: * with GENERIC_WRITE access, otherwise the SetFileTime ! 659: * call will fail. */ ! 660: close(outfd); ! 661: ! 662: hFile = CreateFile(filename, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, ! 663: FILE_ATTRIBUTE_NORMAL, NULL); ! 664: ! 665: if (!SetFileTime(hFile, NULL, NULL, &ft)) ! 666: printf("\nSetFileTime failed: %d\n", GetLastError()); ! 667: CloseHandle(hFile); ! 668: return; ! 669: } ! 670: #else /* !WIN32 */ ! 671: _dos_setftime(outfd, lrec.last_mod_file_date, lrec.last_mod_file_time); ! 672: #endif /* ?WIN32 */ ! 673: #endif /* ?__TURBOC__ */ ! 674: #endif /* ?OS2 */ ! 675: ! 676: /*--------------------------------------------------------------------------- ! 677: And finally we can close the file...at least everybody agrees on how to ! 678: do *this*. I think... Oh yeah, also change the mode according to the ! 679: stored file attributes, since we didn't do that when we opened the dude. ! 680: ---------------------------------------------------------------------------*/ ! 681: ! 682: close(outfd); ! 683: ! 684: #ifdef OS2 ! 685: SetPathInfo(filename, lrec.last_mod_file_date, ! 686: lrec.last_mod_file_time, pInfo->dos_attr); ! 687: if (extra_field) ! 688: SetEAs(filename, extra_field); ! 689: if (longname) ! 690: SetLongNameEA(filename, longfilename); ! 691: #else /* !OS2 */ ! 692: #ifdef __TURBOC__ ! 693: if (_chmod(filename, 1, pInfo->dos_attr) != pInfo->dos_attr) ! 694: fprintf(stderr, "\nwarning: file attributes may not be correct\n"); ! 695: #else /* !__TURBOC__ */ ! 696: #ifdef WIN32 ! 697: /* Attempt to set the file attributes. SetFileAttributes returns ! 698: * FALSE (0) if unsucessful, in which case print an error message, ! 699: * with error value returned from GetLastError call. */ ! 700: pInfo->dos_attr = pInfo->dos_attr & 0x7F; ! 701: ! 702: if (!(SetFileAttributes(filename, pInfo->dos_attr))) ! 703: fprintf(stderr, "\nwarning (%d): could not set file attributes\n", ! 704: GetLastError()); ! 705: #else /* !WIN32 */ ! 706: _dos_setfileattr(filename, pInfo->dos_attr); ! 707: #endif /* ?WIN32 */ ! 708: #endif /* ?__TURBOC__ */ ! 709: #endif /* ?OS2 */ ! 710: ! 711: } /* end function set_file_time_and_close() (DOS, OS/2) */ ! 712: ! 713: ! 714: ! 715: ! 716: ! 717: #else /* !DOS_OS2 */ ! 718: #ifdef MACOS /* Mac */ ! 719: ! 720: /**************************************/ ! 721: /* Function set_file_time_and_close() */ ! 722: /**************************************/ ! 723: ! 724: void set_file_time_and_close() ! 725: /* ! 726: * MAC VERSION ! 727: */ ! 728: { ! 729: long m_time; ! 730: DateTimeRec dtr; ! 731: ParamBlockRec pbr; ! 732: HParamBlockRec hpbr; ! 733: OSErr err; ! 734: ! 735: if (outfd != 1) { ! 736: close(outfd); ! 737: ! 738: /* ! 739: * Macintosh bases all file modification times on the number of seconds ! 740: * elapsed since Jan 1, 1904, 00:00:00. Therefore, to maintain ! 741: * compatibility with MS-DOS archives, which date from Jan 1, 1980, ! 742: * with NO relation to GMT, the following conversions must be made: ! 743: * the Year (yr) must be incremented by 1980; ! 744: * and converted to seconds using the Mac routine Date2Secs(), ! 745: * almost similar in complexity to the Unix version :-) ! 746: * J. Lee ! 747: */ ! 748: ! 749: dtr.year = (((lrec.last_mod_file_date >> 9) & 0x7f) + 1980); ! 750: dtr.month = ((lrec.last_mod_file_date >> 5) & 0x0f); ! 751: dtr.day = (lrec.last_mod_file_date & 0x1f); ! 752: ! 753: dtr.hour = ((lrec.last_mod_file_time >> 11) & 0x1f); ! 754: dtr.minute = ((lrec.last_mod_file_time >> 5) & 0x3f); ! 755: dtr.second = ((lrec.last_mod_file_time & 0x1f) * 2); ! 756: ! 757: Date2Secs(&dtr, (unsigned long *)&m_time); ! 758: CtoPstr(filename); ! 759: if (hfsflag) { ! 760: hpbr.fileParam.ioNamePtr = (StringPtr)filename; ! 761: hpbr.fileParam.ioVRefNum = gnVRefNum; ! 762: hpbr.fileParam.ioDirID = glDirID; ! 763: hpbr.fileParam.ioFDirIndex = 0; ! 764: err = PBHGetFInfo(&hpbr, 0L); ! 765: hpbr.fileParam.ioFlMdDat = m_time; ! 766: if ( !fMacZipped ) ! 767: hpbr.fileParam.ioFlCrDat = m_time; ! 768: hpbr.fileParam.ioDirID = glDirID; ! 769: if (err == noErr) ! 770: err = PBHSetFInfo(&hpbr, 0L); ! 771: if (err != noErr) ! 772: printf("error: can't set the time for %s\n", filename); ! 773: } else { ! 774: pbr.fileParam.ioNamePtr = (StringPtr)filename; ! 775: pbr.fileParam.ioVRefNum = pbr.fileParam.ioFVersNum = ! 776: pbr.fileParam.ioFDirIndex = 0; ! 777: err = PBGetFInfo(&pbr, 0L); ! 778: pbr.fileParam.ioFlMdDat = pbr.fileParam.ioFlCrDat = m_time; ! 779: if (err == noErr) ! 780: err = PBSetFInfo(&pbr, 0L); ! 781: if (err != noErr) ! 782: printf("error: can't set the time for %s\n", filename); ! 783: } ! 784: ! 785: /* set read-only perms if needed */ ! 786: if ((err == noErr) && !(pInfo->unix_attr & S_IWRITE)) { ! 787: if (hfsflag) { ! 788: hpbr.fileParam.ioNamePtr = (StringPtr)filename; ! 789: hpbr.fileParam.ioVRefNum = gnVRefNum; ! 790: hpbr.fileParam.ioDirID = glDirID; ! 791: err = PBHSetFLock(&hpbr, 0); ! 792: } else ! 793: err = SetFLock((ConstStr255Param)filename, 0); ! 794: } ! 795: PtoCstr(filename); ! 796: } ! 797: } ! 798: ! 799: ! 800: ! 801: ! 802: ! 803: #else /* !MACOS... */ ! 804: #if (!defined(MTS) && !defined(VMS)) /* && !MTS (can't do) && !VMS: only one ! 805: * left is UNIX (for VMS use code in vms.c) */ ! 806: ! 807: /**************************************/ ! 808: /* Function set_file_time_and_close() */ ! 809: /**************************************/ ! 810: ! 811: void set_file_time_and_close() ! 812: /* ! 813: * UNIX VERSION (MS-DOS & OS/2, Mac versions are above) ! 814: */ ! 815: { ! 816: static short yday[]={0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}; ! 817: long m_time; ! 818: int yr, mo, dy, hh, mm, ss, leap, days=0; ! 819: struct utimbuf { ! 820: time_t actime; /* new access time */ ! 821: time_t modtime; /* new modification time */ ! 822: } tp; ! 823: #ifdef AMIGA ! 824: # define YRBASE 1978 /* in AmigaDos, counting begins 01-Jan-1978 */ ! 825: struct DateStamp myadate; ! 826: /* extern char *_TZ; no longer used? */ ! 827: #else /* !AMIGA */ ! 828: # define YRBASE 1970 ! 829: #ifdef BSD ! 830: #ifndef __386BSD__ ! 831: static struct timeb tbp; ! 832: #endif /* !__386BSD__ */ ! 833: #else /* !BSD */ ! 834: extern long timezone; ! 835: #endif /* ?BSD */ ! 836: #endif /* ?AMIGA */ ! 837: ! 838: ! 839: /* ! 840: * Close the file *before* setting its time under Unix and AmigaDos. ! 841: */ ! 842: #ifdef AMIGA ! 843: if (cflag) /* can't set time on stdout */ ! 844: return; ! 845: close(outfd); ! 846: #else /* !AMIGA */ ! 847: close(outfd); ! 848: if (cflag) /* can't set time on stdout */ ! 849: return; ! 850: #endif /* ?AMIGA */ ! 851: ! 852: /* ! 853: * These date conversions look a little weird, so I'll explain. ! 854: * UNIX bases all file modification times on the number of seconds ! 855: * elapsed since Jan 1, 1970, 00:00:00 GMT. Therefore, to maintain ! 856: * compatibility with MS-DOS archives, which date from Jan 1, 1980, ! 857: * with NO relation to GMT, the following conversions must be made: ! 858: * the Year (yr) must be incremented by 10; ! 859: * the Date (dy) must be decremented by 1; ! 860: * and the whole mess must be adjusted by TWO factors: ! 861: * relationship to GMT (ie.,Pacific Time adds 8 hrs.), ! 862: * and whether or not it is Daylight Savings Time. ! 863: * Also, the usual conversions must take place to account for leap years, ! 864: * etc. ! 865: * C. Seaman ! 866: */ ! 867: ! 868: /* dissect date */ ! 869: yr = ((lrec.last_mod_file_date >> 9) & 0x7f) + (1980 - YRBASE); ! 870: mo = ((lrec.last_mod_file_date >> 5) & 0x0f) - 1; ! 871: dy = (lrec.last_mod_file_date & 0x1f) - 1; ! 872: ! 873: /* dissect time */ ! 874: hh = (lrec.last_mod_file_time >> 11) & 0x1f; ! 875: mm = (lrec.last_mod_file_time >> 5) & 0x3f; ! 876: ss = (lrec.last_mod_file_time & 0x1f) * 2; ! 877: ! 878: /* leap = # of leap years from BASE up to but not including current year */ ! 879: leap = ((yr + YRBASE - 1) / 4); /* leap year base factor */ ! 880: ! 881: /* How many days from BASE to this year? (& add expired days this year) */ ! 882: days = (yr * 365) + (leap - 492) + yday[mo]; ! 883: ! 884: /* if year is a leap year and month is after February, add another day */ ! 885: if ((mo > 1) && ((yr+YRBASE)%4 == 0) && ((yr+YRBASE) != 2100)) ! 886: ++days; /* OK through 2199 */ ! 887: ! 888: #ifdef AMIGA ! 889: /* _TZ = getenv("TZ"); does Amiga not have TZ and tzset() after all? */ ! 890: myadate.ds_Days = days+dy-2; /* off by one? */ ! 891: myadate.ds_Minute = hh*60+mm; ! 892: myadate.ds_Tick = ss*TICKS_PER_SECOND; ! 893: ! 894: if (!(SetFileDate(filename, &myadate))) ! 895: fprintf(stderr, "error: can't set the time for %s\n", filename); ! 896: ! 897: #else /* !AMIGA */ ! 898: /* convert date & time to seconds relative to 00:00:00, 01/01/YRBASE */ ! 899: m_time = ((days + dy) * 86400) + (hh * 3600) + (mm * 60) + ss; ! 900: ! 901: #ifdef BSD ! 902: #ifndef __386BSD__ ! 903: ftime(&tbp); ! 904: m_time += tbp.timezone * 60L; ! 905: #endif ! 906: /* #elif WIN32 ! 907: * don't do anything right now (esp. since "elif" is not legal for old cc's */ ! 908: #else /* !BSD */ ! 909: tzset(); /* set `timezone' */ ! 910: m_time += timezone; /* account for timezone differences */ ! 911: #endif /* ?BSD */ ! 912: ! 913: #ifdef __386BSD__ ! 914: m_time += localtime(&m_time)->tm_gmtoff; ! 915: #else ! 916: if (localtime(&m_time)->tm_isdst) ! 917: m_time -= 60L * 60L; /* adjust for daylight savings time */ ! 918: #endif ! 919: ! 920: tp.actime = m_time; /* set access time */ ! 921: tp.modtime = m_time; /* set modification time */ ! 922: ! 923: /* set the time stamp on the file */ ! 924: if (utime(filename, &tp)) ! 925: fprintf(stderr, "error: can't set the time for %s\n", filename); ! 926: #endif /* ?AMIGA */ ! 927: } ! 928: ! 929: #endif /* !MTS && !VMS */ ! 930: #endif /* ?MACOS */ ! 931: #endif /* ?DOS_OS2 */ ! 932: ! 933: ! 934: ! 935: ! 936: ! 937: /************************/ ! 938: /* Function handler() */ ! 939: /************************/ ! 940: ! 941: void handler(signal) /* upon interrupt, turn on echo and exit cleanly */ ! 942: int signal; ! 943: { ! 944: #if (defined(SIGBUS) || defined(SIGSEGV)) ! 945: static char *corrupt = "error: zipfile probably corrupt\n"; ! 946: #endif ! 947: ! 948: #ifndef DOS_OS2 ! 949: #ifdef CRYPT ! 950: echon(); ! 951: #endif /* CRYPT */ ! 952: putc('\n', stderr); ! 953: #endif /* !DOS_OS2 */ ! 954: #ifdef SIGBUS ! 955: if (signal == SIGBUS) { ! 956: fprintf(stderr, corrupt); ! 957: exit(3); ! 958: } ! 959: #endif /* SIGBUS */ ! 960: #ifdef SIGSEGV ! 961: if (signal == SIGSEGV) { ! 962: fprintf(stderr, corrupt); ! 963: exit(3); ! 964: } ! 965: #endif /* SIGSEGV */ ! 966: exit(0); ! 967: } ! 968: ! 969: ! 970: ! 971: ! 972: ! 973: /*******************************/ ! 974: /* Non-echoing password code */ ! 975: /*******************************/ ! 976: ! 977: #ifdef CRYPT ! 978: #ifndef DOS_OS2 ! 979: #ifdef VMS ! 980: ! 981: int echo(opt) ! 982: int opt; ! 983: { ! 984: /*--------------------------------------------------------------------------- ! 985: Based on VMSmunch.c, which in turn was based on Joe Meadows' file.c code. ! 986: --------------------------------------------------------------------------- ! 987: * For VMS v5.x: ! 988: * IO$_SENSEMODE/SETMODE info: Programming, Vol. 7A, System Programming, ! 989: * I/O User's: Part I, sec. 8.4.1.1, 8.4.3, 8.4.5, 8.6 ! 990: * sys$assign(), sys$qio() info: Programming, Vol. 4B, System Services, ! 991: * System Services Reference Manual, pp. sys-23, sys-379 ! 992: * fixed-length descriptor info: Programming, Vol. 3, System Services, ! 993: * Intro to System Routines, sec. 2.9.2 ! 994: * GRR, 15 Aug 91 ! 995: ---------------------------------------------------------------------------*/ ! 996: static struct dsc$descriptor_s DevDesc = ! 997: {9, DSC$K_DTYPE_T, DSC$K_CLASS_S, "SYS$INPUT"}; ! 998: /* {dsc$w_length, dsc$b_dtype, dsc$b_class, dsc$a_pointer}; */ ! 999: static short DevChan, iosb[4]; ! 1000: static long i, status; ! 1001: static unsigned long oldmode[2], newmode[2]; /* each = 8 bytes */ ! 1002: ! 1003: ! 1004: /*--------------------------------------------------------------------------- ! 1005: Assign a channel to standard input. ! 1006: ---------------------------------------------------------------------------*/ ! 1007: ! 1008: status = sys$assign(&DevDesc, &DevChan, 0, 0); ! 1009: if (!(status & 1)) ! 1010: return status; ! 1011: ! 1012: /*--------------------------------------------------------------------------- ! 1013: Use sys$qio and the IO$_SENSEMODE function to determine the current tty ! 1014: status (for password reading, could use IO$_READVBLK function instead, ! 1015: but echo on/off will be more general). ! 1016: ---------------------------------------------------------------------------*/ ! 1017: ! 1018: status = sys$qio(0, DevChan, IO$_SENSEMODE, &iosb, 0, 0, ! 1019: oldmode, 8, 0, 0, 0, 0); ! 1020: if (!(status & 1)) ! 1021: return status; ! 1022: status = iosb[0]; ! 1023: if (!(status & 1)) ! 1024: return status; ! 1025: ! 1026: /*--------------------------------------------------------------------------- ! 1027: Copy old mode into new-mode buffer, then modify to be either NOECHO or ! 1028: ECHO (depending on function argument opt). ! 1029: ---------------------------------------------------------------------------*/ ! 1030: ! 1031: newmode[0] = oldmode[0]; ! 1032: newmode[1] = oldmode[1]; ! 1033: if (opt == OFF) ! 1034: newmode[1] |= TT$M_NOECHO; /* set NOECHO bit */ ! 1035: else ! 1036: newmode[1] &= ~((unsigned long) TT$M_NOECHO); /* clear NOECHO bit */ ! 1037: ! 1038: /*--------------------------------------------------------------------------- ! 1039: Use the IO$_SETMODE function to change the tty status. ! 1040: ---------------------------------------------------------------------------*/ ! 1041: ! 1042: status = sys$qio(0, DevChan, IO$_SETMODE, &iosb, 0, 0, ! 1043: newmode, 8, 0, 0, 0, 0); ! 1044: if (!(status & 1)) ! 1045: return status; ! 1046: status = iosb[0]; ! 1047: if (!(status & 1)) ! 1048: return status; ! 1049: ! 1050: /*--------------------------------------------------------------------------- ! 1051: Deassign the sys$input channel by way of clean-up, then exit happily. ! 1052: ---------------------------------------------------------------------------*/ ! 1053: ! 1054: status = sys$dassgn(DevChan); ! 1055: if (!(status & 1)) ! 1056: return status; ! 1057: ! 1058: return SS$_NORMAL; /* we be happy */ ! 1059: ! 1060: } /* end function echo() */ ! 1061: ! 1062: ! 1063: ! 1064: ! 1065: ! 1066: #else /* !VMS */ ! 1067: ! 1068: static int echofd=(-1); /* file descriptor whose echo is off */ ! 1069: ! 1070: void echoff(f) ! 1071: int f; /* file descriptor for which to turn echo off */ ! 1072: /* Turn echo off for file descriptor f. Assumes that f is a tty device. */ ! 1073: { ! 1074: struct sgttyb sg; /* tty device structure */ ! 1075: ! 1076: echofd = f; ! 1077: GTTY(f, &sg); /* get settings */ ! 1078: sg.sg_flags &= ~ECHO; /* turn echo off */ ! 1079: STTY(f, &sg); ! 1080: } ! 1081: ! 1082: ! 1083: ! 1084: void echon() ! 1085: /* Turn echo back on for file descriptor echofd. */ ! 1086: { ! 1087: struct sgttyb sg; /* tty device structure */ ! 1088: ! 1089: if (echofd != -1) { ! 1090: GTTY(echofd, &sg); /* get settings */ ! 1091: sg.sg_flags |= ECHO; /* turn echo on */ ! 1092: STTY(echofd, &sg); ! 1093: echofd = -1; ! 1094: } ! 1095: } ! 1096: ! 1097: #endif /* ?VMS */ ! 1098: #endif /* !DOS_OS2 */ ! 1099: ! 1100: ! 1101: ! 1102: ! 1103: ! 1104: char *getp(m, p, n) ! 1105: char *m; /* prompt for password */ ! 1106: char *p; /* return value: line input */ ! 1107: int n; /* bytes available in p[] */ ! 1108: /* Get a password of length n-1 or less into *p using the prompt *m. ! 1109: The entered password is not echoed. Return p on success, NULL on ! 1110: failure (can't get controlling tty). */ ! 1111: { ! 1112: char c; /* one-byte buffer for read() to use */ ! 1113: int i; /* number of characters input */ ! 1114: char *w; /* warning on retry */ ! 1115: ! 1116: #ifndef DOS_OS2 ! 1117: #ifndef VMS ! 1118: int f; /* file decsriptor for tty device */ ! 1119: ! 1120: /* turn off echo on tty */ ! 1121: if (!isatty(2)) ! 1122: return NULL; /* error if not tty */ ! 1123: if ((f = open(ttyname(2), 0, 0)) == -1) ! 1124: return NULL; ! 1125: #endif /* !VMS */ ! 1126: echoff(f); /* turn echo off */ ! 1127: #endif /* !DOS_OS2 */ ! 1128: ! 1129: /* get password */ ! 1130: w = ""; ! 1131: do { ! 1132: #ifdef VMS /* bug: VMS adds '\n' to NULL fputs (apparently) */ ! 1133: if (*w) ! 1134: #endif /* VMS */ ! 1135: fputs(w, stderr); /* warning if back again */ ! 1136: fputs(m, stderr); /* prompt */ ! 1137: fflush(stderr); ! 1138: i = 0; ! 1139: do { /* read line, keeping n */ ! 1140: #ifdef MSVMS ! 1141: if ((c = (char)getch()) == '\r') ! 1142: c = '\n'; ! 1143: #else /* !MSVMS */ ! 1144: read(f, &c, 1); ! 1145: #endif /* ?MSVMS */ ! 1146: if (i < n) ! 1147: p[i++] = c; ! 1148: } while (c != '\n'); ! 1149: putc('\n', stderr); fflush(stderr); ! 1150: w = "(line too long--try again)\n"; ! 1151: } while (p[i-1] != '\n'); ! 1152: p[i-1] = 0; /* terminate at newline */ ! 1153: ! 1154: #ifndef DOS_OS2 ! 1155: echon(); /* turn echo back on */ ! 1156: #ifndef VMS ! 1157: close(f); ! 1158: #endif /* !VMS */ ! 1159: #endif /* !DOS_OS2 */ ! 1160: ! 1161: /* return pointer to password */ ! 1162: return p; ! 1163: } ! 1164: ! 1165: #endif /* CRYPT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.