home *** CD-ROM | disk | FTP | other *** search
/ The California Collection / TheCaliforniaCollection.cdr / his008 / unarj220.exe / ENVIRON.C < prev    next >
C/C++ Source or Header  |  1991-07-08  |  11KB  |  646 lines
  1. /* ENVIRON.C, UNARJ, R JUNG, 07/07/91
  2.  * Implementation dependent routines
  3.  * Copyright (c) 1991 by Robert K Jung.  All rights reserved.
  4.  *
  5.  *   This code may be freely used in programs that are NOT ARJ archivers
  6.  *   (both compress and extract ARJ archives).
  7.  *
  8.  *   If you wish to distribute a modified version of this program, you
  9.  *   MUST indicate that it is a modified version both in the program and
  10.  *   source code.
  11.  *
  12.  *   If you modify this program, I would appreciate a copy of the new
  13.  *   source code.  I am holding the copyright on the source code, so
  14.  *   please do not delete my name from the program files or from the
  15.  *   documentation.
  16.  *
  17.  *   The vanilla section of this file was tested with UNIX in mind.
  18.  *
  19.  * Modification history:
  20.  * Date      Programmer  Description of modification.
  21.  * 04/09/91  R. Jung     Rewrote code.
  22.  * 04/23/91  M. Adler     Portabilized.
  23.  * 04/29/91  R. Jung     Added get_mode_str().
  24.  * 05/08/91  R. Jung     Combined set_ftime() and set_fmode().
  25.  * 06/03/91  R. Jung     Changed arguments in get_mode_str() and
  26.  *                       set_ftime_mode().
  27.  * 07/07/91  R. Jung     Added default_case_path() and UNIX section.
  28.  *
  29.  */
  30.  
  31. #include "unarj.h"
  32.  
  33. #ifdef __TURBOC__
  34.  
  35. #define SUBS_DEFINED
  36.  
  37. #include <string.h>
  38. #include <dos.h>
  39. #include <io.h>
  40. #include <fcntl.h>
  41. #include <alloc.h>
  42.  
  43. FILE *
  44. file_open(name, mode)
  45. char *name;
  46. char *mode;
  47. {
  48.     return fopen(name, mode);
  49. }
  50.  
  51. int
  52. file_read(buf, size, nitems, stream)
  53. char *buf;
  54. int  size;
  55. int  nitems;
  56. FILE *stream;
  57. {
  58.     return fread(buf, (size_t) size, (size_t) nitems, stream);
  59. }
  60.  
  61. int
  62. file_seek(stream, offset, mode)
  63. FILE *stream;
  64. long offset;
  65. int  mode;
  66. {
  67.     return fseek(stream, offset, mode);
  68. }
  69.  
  70. long
  71. file_tell(stream)
  72. FILE *stream;
  73. {
  74.     return ftell(stream);
  75. }
  76.  
  77. int
  78. file_write(buf, size, nitems, stream)
  79. char *buf;
  80. int  size;
  81. int  nitems;
  82. FILE *stream;
  83. {
  84.     return fwrite(buf, (size_t) size, (size_t) nitems, stream);
  85. }
  86.  
  87. voidp *
  88. xmalloc(size)
  89. int size;
  90. {
  91.     return (voidp *)malloc((size_t) size);
  92. }
  93.  
  94. void
  95. case_path(name)
  96. char *name;
  97. {
  98.     strupper(name);
  99. }
  100.  
  101. void
  102. default_case_path(name)
  103. char *name;
  104. {
  105.     strupper(name);
  106. }
  107.  
  108. int
  109. file_exists(name)
  110. char *name;
  111. {
  112.     return (access(name, 0) == 0);
  113. }
  114.  
  115. void
  116. get_mode_str(str, mode)
  117. char *str;
  118. uint mode;
  119. {
  120.     strcpy(str, "---W");
  121.     if (mode & FA_ARCH)
  122.     str[0] = 'A';
  123.     if (mode & FA_SYSTEM)
  124.     str[1] = 'S';
  125.     if (mode & FA_HIDDEN)
  126.     str[2] = 'H';
  127.     if (mode & FA_RDONLY)
  128.     str[3] = 'R';
  129. }
  130.  
  131. int
  132. set_ftime_mode(name, tstamp, attribute, host)
  133. char  *name;
  134. ulong tstamp;
  135. uint  attribute;
  136. uint  host;
  137. {
  138.     FILE *fd;
  139.     int code;
  140.  
  141.     if ((fd = fopen(name, "r+b")) == NULL)
  142.     return -1;
  143.     code = setftime(fileno(fd), (struct ftime *) &tstamp);
  144.     fclose(fd);
  145.     if (host == OS)
  146.     {
  147.     if (_chmod(name, 1, attribute) == -1)
  148.         return -1;
  149.     }
  150.     return code;
  151. }
  152.  
  153. #endif
  154.  
  155. #ifdef _QC
  156.  
  157. #define SUBS_DEFINED
  158.  
  159. #include <string.h>
  160. #include <dos.h>
  161. #include <io.h>
  162. #include <fcntl.h>
  163. #include <malloc.h>
  164.  
  165. FILE *
  166. file_open(name, mode)
  167. char *name;
  168. char *mode;
  169. {
  170.     return fopen(name, mode);
  171. }
  172.  
  173. int
  174. file_read(buf, size, nitems, stream)
  175. char *buf;
  176. int  size;
  177. int  nitems;
  178. FILE *stream;
  179. {
  180.     return fread(buf, (size_t) size, (size_t) nitems, stream);
  181. }
  182.  
  183. int
  184. file_seek(stream, offset, mode)
  185. FILE *stream;
  186. long offset;
  187. int  mode;
  188. {
  189.     return fseek(stream, offset, mode);
  190. }
  191.  
  192. long
  193. file_tell(stream)
  194. FILE *stream;
  195. {
  196.     return ftell(stream);
  197. }
  198.  
  199. int
  200. file_write(buf, size, nitems, stream)
  201. char *buf;
  202. int  size;
  203. int  nitems;
  204. FILE *stream;
  205. {
  206.     return fwrite(buf, (size_t) size, (size_t) nitems, stream);
  207. }
  208.  
  209. voidp *
  210. xmalloc(size)
  211. int size;
  212. {
  213.     return (voidp *)malloc((size_t) size);
  214. }
  215.  
  216. void
  217. case_path(name)
  218. char *name;
  219. {
  220.     strupper(name);
  221. }
  222.  
  223. void
  224. default_case_path(name)
  225. char *name;
  226. {
  227.     strupper(name);
  228. }
  229.  
  230. int
  231. file_exists(name)
  232. char *name;
  233. {
  234.     return (access(name, 0) == 0);
  235. }
  236.  
  237. void
  238. get_mode_str(str, mode)
  239. char *str;
  240. uint mode;
  241. {
  242.     strcpy(str, "---W");
  243.     if (mode & FA_ARCH)
  244.     str[0] = 'A';
  245.     if (mode & FA_SYSTEM)
  246.     str[1] = 'S';
  247.     if (mode & FA_HIDDEN)
  248.     str[2] = 'H';
  249.     if (mode & FA_RDONLY)
  250.     str[3] = 'R';
  251. }
  252.  
  253. int
  254. set_ftime_mode(name, tstamp, attribute, host)
  255. char  *name;
  256. ulong tstamp;
  257. uint  attribute;
  258. uint  host;
  259. {
  260.     FILE *fd;
  261.     int code;
  262.     uint date_stamp, time_stamp;
  263.  
  264.     date_stamp = (uint)(tstamp >> 16);
  265.     time_stamp = (uint)(tstamp & 0xFFFF);
  266.     if ((fd = fopen(name, "r+b")) == NULL)
  267.     return -1;
  268.     code = _dos_setftime(fileno(fd), date_stamp, time_stamp);
  269.     fclose(fd);
  270.     if (host == OS)
  271.     {
  272.     if (_dos_setfileattr(name, attribute))
  273.         return -1;
  274.     }
  275.     return code;
  276. }
  277.  
  278. #endif
  279.  
  280. #ifdef _OS2
  281.  
  282. #define SUBS_DEFINED
  283.  
  284. #include <string.h>
  285. #define INCL_DOSFILEMGR
  286. #include <os2.h>
  287. #include <io.h>
  288. #include <fcntl.h>
  289.  
  290. FILE *
  291. file_open(name, mode)
  292. char *name;
  293. char *mode;
  294. {
  295.     return fopen(name, mode);
  296. }
  297.  
  298. int
  299. file_read(buf, size, nitems, stream)
  300. char *buf;
  301. int  size;
  302. int  nitems;
  303. FILE *stream;
  304. {
  305.     return fread(buf, (size_t) size, (size_t) nitems, stream);
  306. }
  307.  
  308. int
  309. file_seek(stream, offset, mode)
  310. FILE *stream;
  311. long offset;
  312. int  mode;
  313. {
  314.     return fseek(stream, offset, mode);
  315. }
  316.  
  317. long
  318. file_tell(stream)
  319. FILE *stream;
  320. {
  321.     return ftell(stream);
  322. }
  323.  
  324. int
  325. file_write(buf, size, nitems, stream)
  326. char *buf;
  327. int  size;
  328. int  nitems;
  329. FILE *stream;
  330. {
  331.     return fwrite(buf, (size_t) size, (size_t) nitems, stream);
  332. }
  333.  
  334. voidp *
  335. xmalloc(size)
  336. int size;
  337. {
  338.     return (voidp *)malloc((size_t) size);
  339. }
  340.  
  341. void
  342. case_path(name)
  343. char *name;
  344. {
  345.     strupper(name);
  346. }
  347.  
  348. void
  349. default_case_path(name)
  350. char *name;
  351. {
  352.     strupper(name);
  353. }
  354.  
  355. int
  356. file_exists(name)
  357. char *name;
  358. {
  359.     return (access(name, 0) == 0);
  360. }
  361.  
  362. void
  363. get_mode_str(str, mode)
  364. char *str;
  365. uint mode;
  366. {
  367.     strcpy(str, "---W");
  368.     if (mode & FA_ARCH)
  369.         str[0] = 'A';
  370.     if (mode & FA_SYSTEM)
  371.         str[1] = 'S';
  372.     if (mode & FA_HIDDEN)
  373.         str[2] = 'H';
  374.     if (mode & FA_RDONLY)
  375.         str[3] = 'R';
  376. }
  377.  
  378. int
  379. set_ftime_mode(name, tstamp, attribute, host)
  380. char  *name;
  381. ulong tstamp;
  382. uint  attribute;
  383. uint  host;
  384. {
  385.     int code;
  386.     FDATE date_stamp;
  387.     FTIME time_stamp;
  388.     HFILE handle;
  389.     FILESTATUS info;
  390.     USHORT action;
  391.  
  392.     date_stamp.day = ts_day (tstamp);
  393.     date_stamp.month = ts_month (tstamp);
  394.     date_stamp.year = ts_year (tstamp) - 1980;
  395.     time_stamp.twosecs = ts_sec (tstamp) / 2;
  396.     time_stamp.minutes = ts_min (tstamp);
  397.     time_stamp.hours = ts_hour (tstamp);
  398.     if (DosOpen (name, &handle, &action, 0L, 0, FILE_OPEN,
  399.          OPEN_ACCESS_READWRITE|OPEN_SHARE_DENYREADWRITE, 0L) != 0)
  400.     return -1;
  401.     info.fdateCreation = date_stamp;
  402.     info.ftimeCreation = time_stamp;
  403.     info.fdateLastAccess = date_stamp;
  404.     info.ftimeLastAccess = time_stamp;
  405.     info.fdateLastWrite = date_stamp;
  406.     info.ftimeLastWrite = time_stamp;
  407.     info.cbFile = 0;
  408.     info.cbFileAlloc = 0;
  409.     info.attrFile = 0;
  410.     code = (int)DosSetFileInfo (handle, 1, (PBYTE)&info, sizeof (info));
  411.     (void)DosClose (handle);
  412.     if (host == OS)
  413.     {
  414.     if (DosSetFileMode (name, attribute, 0L))
  415.         return -1;
  416.     }
  417.     return code;
  418. }
  419.  
  420. #endif
  421.  
  422. #ifdef UNIX
  423.                /* specifically tested under SUN UNIX */
  424. #define SUBS_DEFINED
  425.  
  426. extern char *strcpy();
  427. extern voidp *malloc();
  428.  
  429. FILE *
  430. file_open(name, mode)
  431. char *name;
  432. char *mode;
  433. {
  434.     return fopen(name, mode);
  435. }
  436.  
  437. int
  438. file_read(buf, size, nitems, stream)
  439. char *buf;
  440. int  size;
  441. int  nitems;
  442. FILE *stream;
  443. {
  444.     return fread(buf, (int) size, (int) nitems, stream);
  445. }
  446.  
  447. int
  448. file_seek(stream, offset, mode)
  449. FILE *stream;
  450. long offset;
  451. int  mode;
  452. {
  453.     return fseek(stream, offset, mode);
  454. }
  455.  
  456. long
  457. file_tell(stream)
  458. FILE *stream;
  459. {
  460.     return ftell(stream);
  461. }
  462.  
  463. int
  464. file_write(buf, size, nitems, stream)
  465. char *buf;
  466. int  size;
  467. int  nitems;
  468. FILE *stream;
  469. {
  470.     return fwrite(buf, (int) size, (int) nitems, stream);
  471. }
  472.  
  473. voidp *
  474. xmalloc(size)
  475. int size;
  476. {
  477.     return (voidp *)malloc((uint) size);
  478. }
  479.  
  480. void
  481. case_path(name)
  482. char *name;
  483. {
  484. }
  485.  
  486. void
  487. default_case_path(name)
  488. char *name;
  489. {
  490.     strlower(name);
  491. }
  492.  
  493. int
  494. file_exists(name)
  495. char *name;
  496. {
  497.     FILE *fd;
  498.  
  499.     if ((fd = fopen(name, "rb")) == NULL)
  500.     return 0;
  501.     fclose(fd);
  502.     return 1;
  503. }
  504.  
  505. void
  506. get_mode_str(str, mode)
  507. char *str;
  508. uint mode;
  509. {
  510.     strcpy(str, "---W");
  511.     if (mode & FA_ARCH)
  512.     str[0] = 'A';
  513.     if (mode & FA_SYSTEM)
  514.     str[1] = 'S';
  515.     if (mode & FA_HIDDEN)
  516.     str[2] = 'H';
  517.     if (mode & FA_RDONLY)
  518.     str[3] = 'R';
  519. }
  520.  
  521. int
  522. set_ftime_mode(name, tstamp, attribute, host)
  523. char  *name;
  524. ulong tstamp;
  525. uint  attribute;
  526. uint  host;
  527. {
  528.     return 0;
  529. }
  530.  
  531. #endif  /* end of UNIX section */
  532.  
  533. #ifndef SUBS_DEFINED       /* vanilla version for other compilers */
  534.                /* specifically tested under SUN UNIX */
  535. #ifdef MODERN
  536. #include <string.h>
  537. #else /* !MODERN */
  538. extern char *strcpy();
  539. extern voidp *malloc();
  540. #endif /* ?MODERN */
  541.  
  542. FILE *
  543. file_open(name, mode)
  544. char *name;
  545. char *mode;
  546. {
  547.     return fopen(name, mode);
  548. }
  549.  
  550. int
  551. file_read(buf, size, nitems, stream)
  552. char *buf;
  553. int  size;
  554. int  nitems;
  555. FILE *stream;
  556. {
  557.     return fread(buf, (int) size, (int) nitems, stream);
  558. }
  559.  
  560. int
  561. file_seek(stream, offset, mode)
  562. FILE *stream;
  563. long offset;
  564. int  mode;
  565. {
  566.     return fseek(stream, offset, mode);
  567. }
  568.  
  569. long
  570. file_tell(stream)
  571. FILE *stream;
  572. {
  573.     return ftell(stream);
  574. }
  575.  
  576. int
  577. file_write(buf, size, nitems, stream)
  578. char *buf;
  579. int  size;
  580. int  nitems;
  581. FILE *stream;
  582. {
  583.     return fwrite(buf, (int) size, (int) nitems, stream);
  584. }
  585.  
  586. voidp *
  587. xmalloc(size)
  588. int size;
  589. {
  590.     return (voidp *)malloc((uint) size);
  591. }
  592.  
  593. void
  594. case_path(name)
  595. char *name;
  596. {
  597. }
  598.  
  599. void
  600. default_case_path(name)
  601. char *name;
  602. {
  603. }
  604.  
  605. int
  606. file_exists(name)
  607. char *name;
  608. {
  609.     FILE *fd;
  610.  
  611.     if ((fd = fopen(name, "rb")) == NULL)
  612.     return 0;
  613.     fclose(fd);
  614.     return 1;
  615. }
  616.  
  617. void
  618. get_mode_str(str, mode)
  619. char *str;
  620. uint mode;
  621. {
  622.     strcpy(str, "---W");
  623.     if (mode & FA_ARCH)
  624.     str[0] = 'A';
  625.     if (mode & FA_SYSTEM)
  626.     str[1] = 'S';
  627.     if (mode & FA_HIDDEN)
  628.     str[2] = 'H';
  629.     if (mode & FA_RDONLY)
  630.     str[3] = 'R';
  631. }
  632.  
  633. int
  634. set_ftime_mode(name, tstamp, attribute, host)
  635. char  *name;
  636. ulong tstamp;
  637. uint  attribute;
  638. uint  host;
  639. {
  640.     return 0;
  641. }
  642.  
  643. #endif    /* end of vanilla section */
  644.  
  645. /* end ENVIRON.C */
  646.