home *** CD-ROM | disk | FTP | other *** search
/ Internet Publisher's Toolbox 1.0 / Image.iso / toolbox / ntserver / wtsource / futil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-15  |  18.6 KB  |  786 lines
  1. /* Wide AREA INFORMATION SERVER SOFTWARE    
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.  
  4.   
  5.    3/90 Brewster
  6. */
  7.  
  8. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  9.  
  10.  
  11. /* Change log:
  12.  * $Log:    futil.c,v $
  13.  * Revision 1.2  93/07/01  19:18:02  warnock
  14.  * gethostname -> mygethostname
  15.  * 
  16.  * Revision 1.1  1993/02/16  15:05:35  freewais
  17.  * Initial revision
  18.  *
  19.  * Revision 1.21  92/03/24  10:30:41  jonathan
  20.  * Added fix to pathname_directory if no directory part, it puts "./" in the
  21.  * destination.
  22.  * 
  23.  * Revision 1.20  92/02/21  11:05:48  jonathan
  24.  * added RCSIdent
  25.  * 
  26.  * Revision 1.19  92/02/20  14:51:19  jonathan
  27.  * changed include for access() to sys/file.h, since that seems more portable.
  28.  * 
  29.  * Revision 1.18  92/02/18  11:52:43  jonathan
  30.  * conditionalized inclusion of unistd.h for NeXT (use fcntl instead).  This
  31.  * may be a BSD thing.
  32.  * 
  33.  * Revision 1.17  92/02/12  13:19:27  jonathan
  34.  * Added "$Log" so RCS will put the log message in the header
  35.  * 
  36.  
  37. */
  38.  
  39. #ifndef lint
  40. static char *RCSid = "$Header: /archives/stelar/src/freeWAIS/freeWAIS-0.2/ir/RCS/futil.c,v 1.2 93/07/01 19:18:02 warnock Exp $";
  41. #endif
  42.  
  43. /* ======================== */
  44. /* ===  File Utilities  === */
  45. /* ======================== */
  46.  
  47. #include <string.h>
  48.  
  49. #ifdef THINK_C
  50.   /* file type info */
  51. #include <pascal.h>     /* for CtoPstr */
  52. #include <FileMgr.h>
  53. #define CREATOR         'WIS1'
  54. #define WAIS_INDEX_FILE_TYPE    'INDX'
  55.  
  56. #else
  57.  
  58. #include <sys/types.h> /* for stat and getuid */
  59. #include <sys/stat.h> /* for stat */
  60. #ifdef WIN32
  61. #include <io.h> /* for _access() */
  62. #else
  63. #include <sys/param.h> /* for getwd */
  64. #include <sys/file.h> /* for access() */
  65. #endif /* WIN32 */
  66.  
  67. #endif /* THINK_C */
  68.  
  69. #ifdef LINUX
  70. #include <unistd.h>   /* to get R_OK IO flag */
  71. #endif
  72.  
  73. #include "futil.h"
  74. #include "panic.h"
  75.  
  76. #ifndef WIN32
  77. #ifndef R_OK
  78. #include <unistd.h>
  79. #endif
  80. #endif /* WIN32 */
  81. /*----------------------------------------------------------------------*/
  82.  
  83. static long numFilesCurrentlyOpen = 0;
  84. static long maxNumFilesOpenAtOneTime = 0;
  85.  
  86. FILE*
  87. fs_fopen(fileName,mode)
  88. char* fileName;
  89. char* mode;
  90. {
  91.   FILE* file = NULL;
  92.   
  93. #ifdef BSD
  94. #define implicitBinary
  95. #endif /* def BSD */
  96. #ifdef ultrix
  97. #define implicitBinary
  98. #endif /* def ultrix */
  99. #ifndef ANSI_LIKE
  100. #define implicitBinary
  101. #endif /* def ANSI_LIKE */
  102.  
  103.  
  104.  
  105. #ifdef implicitBinary
  106.    /* these old os's don't handle the binary mode.  Just remove it */
  107.    char realMode[100];
  108.    long i,j;
  109.    for (i = 0L,j = 0; mode[i] != '\0';i++)
  110.     { if (mode[i] != 'b')
  111.     realMode[j++] = mode[i];
  112.     }
  113.    realMode[j] = '\0';
  114.   file = fopen(fileName,realMode);
  115. #else
  116.   file = fopen(fileName,mode);
  117. #endif /* def implicitBinary */
  118.   
  119.   if (file != NULL)
  120.     { numFilesCurrentlyOpen++;
  121.       if (numFilesCurrentlyOpen > maxNumFilesOpenAtOneTime)
  122.     maxNumFilesOpenAtOneTime = numFilesCurrentlyOpen;
  123.     }
  124.   
  125.   return(file);
  126. }
  127.  
  128. /*----------------------------------------------------------------------*/
  129.  
  130. long
  131. fs_fclose(file)
  132. FILE* file;
  133.  
  134. {
  135.   if (file != NULL)
  136.     { numFilesCurrentlyOpen--;
  137.       return(fclose(file));
  138.     }
  139.   else
  140.     return(0L);
  141. }
  142.  
  143. /*----------------------------------------------------------------------*/
  144.  
  145. long fs_fseek(file,offset,wherefrom)
  146. FILE* file;
  147. long offset;
  148. long wherefrom;
  149. {
  150.   long result;
  151.   
  152.   if(NULL == file)
  153.     return -1;
  154.   
  155.   result = fseek(file, offset, wherefrom);
  156.  
  157.   /*
  158.   if(0 != result) 
  159.     panic("A seek failed:  offset %ld, wherefrom %d.\n",offset, wherefrom);
  160.     */
  161.   return result;
  162. }
  163.  
  164. /*----------------------------------------------------------------------*/
  165.  
  166. long fs_ftell(file)
  167. FILE* file;
  168. {
  169.   long result;
  170.   
  171.   if (file == NULL)
  172.     return(0);
  173.     
  174.   result = ftell(file);
  175.   
  176.   if(EOF == result)
  177.     panic("A seek on an index file failed.\n");
  178.  
  179.   return(result);
  180. }
  181.  
  182. /*----------------------------------------------------------------------*/
  183.  
  184. void grow_file(file,length)
  185. FILE* file;
  186. long length;
  187. {
  188.   long current_length;
  189.   s_fseek(file, 0L, SEEK_END);
  190.   current_length = s_ftell(file);
  191.   s_fseek(file, length - current_length, SEEK_END);
  192. }
  193.  
  194. /*----------------------------------------------------------------------*/
  195.  
  196. /* writes the high byte first, this makes reading faster */
  197. long write_bytes(value,size,stream)
  198. long value;
  199. long size;
  200. FILE* stream;
  201. {
  202.   long i;
  203.   long answer;
  204.   if((size < sizeof(long)) && (0 != (value >> (size * 8))))
  205.     panic("In a call to write_bytes, the value %ld can not be represented in %ld bytes", value, size);
  206.   for(i = size - 1; i >= 0; i--){
  207.     answer = putc((value >> (i * 8)) & 0xFF, stream);
  208.   }
  209.   if(ferror(stream) != 0) {
  210.     panic("Write failed");
  211.   }
  212.   return(answer);
  213. }
  214.  
  215. /*----------------------------------------------------------------------*/
  216.  
  217. /* returns EOF if it gets an error */
  218. long read_bytes(n_bytes,stream)
  219. long n_bytes;
  220. FILE *stream;
  221. {
  222.   long answer = 0;
  223.   unsigned long ch;
  224.   long i;
  225.   for(i = 0; i < n_bytes; i++){
  226.     ch = fgetc(stream);
  227.     if(EOF == ch){
  228.       return(EOF);
  229.     }
  230.     answer = (answer << 8) + (unsigned char)ch;
  231.   }
  232.   return(answer);
  233. }
  234.  
  235. /*----------------------------------------------------------------------*/
  236.  
  237. long read_bytes_from_memory(n_bytes,block)
  238. long n_bytes;
  239. unsigned char *block;
  240. {
  241.   long answer = 0;
  242.   unsigned char ch;
  243.   long i;
  244.   for(i = 0; i < n_bytes; i++){
  245.     ch = *(block++);
  246.     answer = (answer << 8) + ch;
  247.   }
  248.   return(answer);
  249. }
  250.  
  251. /*----------------------------------------------------------------------*/
  252.  
  253. time_t file_write_date(filename)
  254. char* filename;
  255. { /* os dependent */
  256. #ifdef THINK_C
  257.     return((time_t)0);  /* not implemented yet */
  258. #else
  259.   struct stat *buf = (struct stat*)s_malloc((size_t)sizeof(struct stat));
  260.   time_t mtime;
  261.  
  262.  
  263.  
  264.    if(0 != stat(filename, buf)) {
  265.      /* might be the compressed one. */
  266.      char buffer[MAX_FILENAME_LEN+2];
  267.      sprintf(buffer, "%s.Z", filename);
  268.      if (0 != stat(buffer, buf)) {
  269.        panic("could not stat %s", filename);
  270.      }
  271.   }
  272.  
  273.  
  274.   mtime =  buf->st_mtime;
  275.   s_free(buf);
  276.   return(mtime);
  277. #endif /* THINK_C */
  278. }
  279.  
  280. /*----------------------------------------------------------------------*/
  281.  
  282. long file_length(stream)
  283. FILE* stream;
  284. /* return the length (in bytes) of a stream - leave the current
  285.    position where it was
  286.  */ 
  287. {
  288.   long position = ftell(stream);
  289.   long end = -1;
  290.   s_fseek(stream, 0L, SEEK_END);
  291.   end = ftell(stream);  
  292.   s_fseek(stream,position,SEEK_SET);
  293.   return(end);
  294. }
  295.  
  296. /*----------------------------------------------------------------------*/
  297.  
  298. static char *clean_path _AP((char* filename));
  299.  
  300. static char *clean_path(filename)
  301. char *filename;
  302. /* this takes out the '/../' and the '/./' from the path by modifying 
  303.    the argument and returning it. The pathname passed to it must be a 
  304.    full path. This is not optimized. */
  305. {
  306. #ifndef THINK_C
  307. #ifndef WIN32
  308.   char *beginning_ptr = strstr(filename, "/../");
  309.   if(NULL != beginning_ptr){
  310.     /* then we have something to process.
  311.        reverse search for the beginning of the last directory,
  312.        in order to snuff it */
  313.     char *ptr;
  314.     for(ptr = beginning_ptr - 1; ptr >= filename; ptr--){
  315.       if(*ptr == '/'){
  316.     /* then we found the beginning of the path */
  317.     strcpy(ptr, beginning_ptr + strlen("/../") -1);
  318.     clean_path(filename);   /* get the other occurances of /../ */
  319.     break;
  320.       } 
  321.     }
  322.   }
  323.   /* now look for /./ */
  324.   beginning_ptr = strstr(filename, "/./");
  325.   if(NULL != beginning_ptr){
  326.     strcpy(beginning_ptr, beginning_ptr + strlen("/./") -1);
  327.     clean_path(filename);   /* get the other occurances of /./ */
  328.   }
  329. #endif /* ndef WIN32 */
  330. #endif              /* ndef THINK_C */
  331.  
  332.   return(filename);
  333.  
  334. }
  335.  
  336. /*----------------------------------------------------------------------*/
  337.     
  338. char *truename(filename,full_path)
  339. char *filename;
  340. char *full_path;
  341. {
  342.   /* this puts into full_path the full pathname including directory.
  343.    */
  344. #if defined(THINK_C) || defined(WIN32)
  345.   strcpy(full_path, filename);
  346.   return(full_path); /* do nothing */
  347. #else
  348.   if('/' == filename[0]){
  349.     /* then it is complete already */
  350.     strcpy(full_path, filename);
  351.     clean_path(full_path);
  352.     return(full_path);
  353.   }
  354.   else{
  355.     getcwd(full_path,1024);
  356.     s_strncat(full_path,"/",MAX_FILENAME_LEN,MAX_FILENAME_LEN);
  357.     s_strncat(full_path,filename,MAX_FILENAME_LEN,MAX_FILENAME_LEN);
  358.     clean_path(full_path);
  359.     return(full_path);
  360.   }
  361. #endif /* THINK_C */
  362. }
  363.  
  364. /*----------------------------------------------------------------------*/
  365.  
  366. char *pathname_name(pathname)
  367. char *pathname;
  368. /* returns a pointer to the leaf name part of full pathname.
  369.    equivalent to common lisp pathname-name. */
  370. {
  371. #ifdef WIN32
  372.   char *answer = strrchr(pathname, '\\');
  373. #else
  374. #ifdef THINK_C
  375.   char *answer = strrchr(pathname, ':');
  376. #else
  377.   char *answer = strrchr(pathname, '/');
  378. #endif  /* THINK_C */
  379. #endif  /* WIN32 */
  380.  
  381.   if(NULL == answer)
  382.     return(pathname);
  383.   return(answer + 1);
  384. }
  385.  
  386. /*----------------------------------------------------------------------*/
  387.  
  388. char *pathname_directory(pathname,destination)
  389. char *pathname;
  390. char *destination;
  391. /* returns a pointer to a string of the directory part of
  392.    the pathname and modifies its destination argument.
  393.    This is the equivalent to the common lisp pathname-directory function. */
  394. {
  395. #ifdef WIN32
  396.   char *dirptr = strrchr(pathname, '\\');
  397. #else
  398. #ifdef THINK_C
  399.   char *dirptr = strrchr(pathname, ':');
  400. #else
  401.   char *dirptr = strrchr(pathname, '/');
  402. #endif /* THINK_C */
  403. #endif /* WIN32 */
  404.  
  405.   if(NULL == dirptr)
  406. #ifdef WIN32
  407.     strncpy(destination, ".\\", MAX_FILENAME_LEN);
  408. #else
  409. #ifdef THINK_C
  410.     strncpy(destination, pathname, MAX_FILE_NAME_LEN);
  411. #else
  412.     strncpy(destination, "./", MAX_FILENAME_LEN);
  413. #endif /* THINK_C */
  414. #endif /* WIN32 */
  415.   else
  416.     { strncpy(destination, pathname, MAX_FILE_NAME_LEN);
  417.       destination[dirptr - pathname + 1] = '\0';
  418.     }
  419.  
  420.   return(destination);
  421. }
  422.   
  423. /*----------------------------------------------------------------------*/
  424.  
  425. /* Setting the Macintosh File type (requires the MacTraps library) */
  426. /* from Util.c by Harry Morris */
  427.  
  428. #ifdef THINK_C
  429.  
  430. void 
  431. setFileType(fileName,type,creator)
  432. char* fileName;
  433. FType type;
  434. FType creator;
  435. { 
  436.   FInfo info;
  437.   OSErr error;
  438.   
  439.   CtoPstr(fileName);
  440.   error = GetFInfo((StringPtr)fileName,0L,&info);
  441.   if (error != noErr)
  442.     panic("error - Can't get file type of file %s, code %ld\n",
  443.           PtoCstr((char*)fileName),noErr);
  444.   info.fdType = type;
  445.   info.fdCreator = creator;
  446.   error = SetFInfo((StringPtr)fileName,0L,&info);
  447.   if (error != noErr)
  448.     panic("error - Can't change file type of file %s, code %ld\n",
  449.           PtoCstr((char*)fileName),noErr);
  450.   PtoCstr((char*)fileName);
  451. }
  452.  
  453. #endif /* THINK_C */
  454.  
  455. /*----------------------------------------------------------------------*/
  456.  
  457. char *current_user_name()
  458. /* returns the current_user_name as a mail address */
  459. {
  460.   static char answer[200];
  461. #ifndef WIN32  
  462.   char hostname[120];
  463. #endif
  464.   
  465. #ifdef THINK_C
  466.   strcpy(answer,"MAC"); /* could look up the name in the chooser */
  467. #endif /* def THINK_C */
  468.  
  469. #ifdef M_XENIX
  470.   strcpy(answer,"unknown"); /* could look up the name in the chooser */
  471. #endif /* def M_XENIX */
  472.  
  473. #ifdef WIN32
  474.   strcpy(answer,"unknown"); /* Could get it from the GetUserName function */
  475. #endif /* WIN32 */
  476.  
  477. #ifndef THINK_C
  478. #ifndef M_XENIX
  479. #ifndef WIN32
  480.  
  481. #include <pwd.h>  /* for getpwent */
  482.  
  483.   struct passwd *pwent = getpwuid(getuid());
  484.   strncpy(answer, pwent->pw_name, 200);
  485.   strncat(answer, "@", 200);
  486.   mygethostname(hostname, 120);
  487.   strncat(answer, hostname, 200);
  488.  
  489. #endif /* ndef WIN32 */
  490. #endif /* ndef M_XENIX */
  491. #endif /* ndef THINK_C */
  492.  
  493.   return(answer);
  494. }
  495.  
  496. /*----------------------------------------------------------------------*/
  497.  
  498. boolean probe_file(filename)
  499. char *filename;
  500. /* return true if it is there, false otherwise.
  501.    Can this be done faster? 
  502. */
  503. {
  504.   if (filename == NULL)
  505.     return(false);
  506. #ifdef WIN32
  507.   else if (_access(filename,4) == 0)
  508.     return(true);
  509. #else
  510.   else if (access(filename,R_OK) == 0)
  511.     return(true);
  512. #endif
  513.   else
  514.     return(false);
  515. }
  516.  
  517. /*----------------------------------------------------------------------*/
  518.  
  519. boolean probe_file_possibly_compressed(filename)
  520. char *filename;
  521. /* return true if it is there, false otherwise.
  522.    Can this be done faster? */
  523. {
  524.   if (filename == NULL)
  525.     return(false);
  526.   else if (!probe_file(filename))
  527.     { /* try the compression */
  528.       char buffer[ MAX_FILENAME_LEN * 2 ];
  529.       strcpy(buffer, filename);
  530.       strcat(buffer, ".Z");
  531.       return(probe_file(buffer));
  532.     }
  533.   else
  534.     return(true);
  535. }
  536.  
  537. /*----------------------------------------------------------------------*/
  538.  
  539. /* this opens the file for writing (append)p and then closes it again */
  540. boolean touch_file(filename)
  541. char *filename;
  542. /* return false if error, true otherwise. */
  543. {
  544.   FILE *stream = NULL;
  545.   if (filename == NULL)
  546.     return(false);
  547.   stream = s_fopen(filename, "a");
  548.   if (NULL == stream)
  549.     return(false);
  550.   else
  551.     { s_fclose(stream);
  552.       return(true);
  553.     }
  554. }
  555.  
  556. /*----------------------------------------------------------------------*/
  557.  
  558. char *merge_pathnames(pathname, directory)
  559. char *pathname;
  560. char *directory;
  561. {
  562.   /* if the pathname is not complete, then it puts on the directory
  563.      component and returns it in a static variable.  This is Unix specific */
  564.   static char answer[MAX_FILENAME_LEN + 1];
  565.   if((pathname[0] == '/') || (NULL == directory) || directory[0] == '\0')
  566.     return(pathname);
  567.   else{
  568.     answer[0] = '\0';
  569.     strncat(answer, directory, MAX_FILENAME_LEN);
  570. #ifdef WIN32
  571.     if(directory[strlen(directory) - 1] != '\\')
  572.       strncat(answer, "\\", MAX_FILENAME_LEN);
  573. #else
  574. #ifdef THINK_C
  575.     if(directory[strlen(directory) - 1] != ':')
  576.       strncat(answer, ":", MAX_FILENAME_LEN);
  577. #else
  578.     if(directory[strlen(directory) - 1] != '/')
  579.       strncat(answer, "/", MAX_FILENAME_LEN);
  580. #endif /* THINK_C */
  581. #endif /* WIN32 */
  582.     strncat(answer, pathname, MAX_FILENAME_LEN);
  583.   }
  584.   /* should this call truename? */
  585.   return(answer);
  586. }
  587.  
  588. /*----------------------------------------------------------------------*/
  589.  
  590.  
  591. boolean 
  592. read_string_from_file(stream,array,array_length)
  593. FILE *stream;
  594. char *array;
  595. long array_length;
  596. /* returns true if it wins. */
  597. {
  598.   long ch;
  599.   long char_count = 0;
  600.  
  601.   array[0] = '\0';
  602.   while(true){
  603.     ch = fgetc(stream);
  604.     if(EOF == ch){
  605.       array[char_count] = '\0';
  606.       return(false);
  607.     }
  608.     else if(char_count == array_length){        
  609.       array[char_count] = '\0';
  610.       return(false);
  611.     }
  612.     else if('\0' == ch){
  613.       array[char_count] = '\0';
  614.       return(true);
  615.     }
  616.     else
  617. #ifdef WIN32
  618.       array[char_count++] = (char)ch;
  619. #else          
  620.       array[char_count++] = ch;
  621. #endif
  622.   }
  623. }
  624.  
  625. /*----------------------------------------------------------------------*/
  626.  
  627. /* counts the lines in a file */
  628. long count_lines(stream)
  629. FILE *stream;
  630. {
  631.   long answer = 1;
  632.   char line[100];
  633.   fseek(stream, 0L, SEEK_SET);  
  634.   while(NULL != fgets(line,100L,stream))
  635.     answer++;
  636.   return(answer);
  637. }
  638.  
  639. #ifdef WIN32
  640. /*
  641.  *  Windows NT (and DOS and ...) won't allow open files to be renamed.
  642.  *  So this function closes the file, rename it, and reopens it.
  643.  */
  644. int CloseRenameOpen(FILE **ppf,char *oldname,char *newname,char *openmode) {
  645. int Result;
  646. long Position;
  647. char *cp, tmp_filename[MAX_FILENAME_LEN];
  648. int ch = '.';
  649.  
  650.   if (ppf!=NULL) {
  651.     /* Save file poiner position and close the file */
  652.     Position = ftell(*ppf);
  653.     s_fclose(*ppf);
  654.   }
  655.  
  656.   /* rename in NT has a different meaning from UNIX's */
  657.   /* the new name should not be exist */
  658.   tmp_filename[0] = 0;
  659.   if (access(newname, 0) == 0) {
  660.     /* change the new file name to a unique one */
  661.     strcpy(tmp_filename, newname);
  662.     if ((strlen(tmp_filename) + 6) >= MAX_FILENAME_LEN)
  663.       tmp_filename[MAX_FILENAME_LEN - 7] = 0;
  664.     cp = strchr(tmp_filename, ch);
  665.     if (cp)
  666.       strcpy(++cp, "XXXXXX");
  667.     else
  668.       strcat(tmp_filename, "XXXXXX");
  669.     _mktemp(tmp_filename);
  670.     Result = rename(newname,tmp_filename);
  671.     if (Result!=0)
  672.       return Result;
  673.   }
  674.     
  675.   /* Rename the file */
  676.   Result = rename(oldname, newname);
  677.   if (Result!=0) {
  678.     /* If failed, the newname file comes back */
  679.     if (tmp_filename[0] != 0)
  680.       rename(tmp_filename, newname);
  681.   } else {
  682.     /* If OK, delete the tmp_file */
  683.     if (tmp_filename[0] != 0)
  684.       unlink(tmp_filename);
  685.   }
  686.   /* Reopen it */
  687.   if (ppf!=NULL) {
  688.     if (Result!=0) {
  689.       /* Reopen oldname */
  690.       *ppf = s_fopen(oldname,openmode);
  691.     } else {
  692.       /* Reopen newname */
  693.       *ppf = s_fopen(newname,openmode);
  694.     }  
  695.     if (*ppf!=NULL) {
  696.       /* Reposition file pointer */
  697.       fseek(*ppf,Position,SEEK_SET);
  698.     }
  699.   }
  700.   return Result;
  701. }
  702.  
  703.  
  704. /*
  705.  *  Check whether this filename is OK to create.  Return non-0
  706.  *  if it is OK.
  707.  */
  708. int CanCreateLongFileNames(char *IndexFileName) {
  709. char TestFileName[MAX_FILENAME_LEN];
  710. FILE *pFile;
  711.  
  712.     strncpy(TestFileName,IndexFileName,MAX_FILENAME_LEN);
  713.     TestFileName[MAX_FILENAME_LEN-1] = '\0';
  714.     strncat(TestFileName,".longextension.0.1.test",MAX_FILENAME_LEN);
  715.     TestFileName[MAX_FILENAME_LEN-1] = '\0';
  716.     pFile = fs_fopen(TestFileName,"w");
  717.     if (pFile==NULL) return 0;
  718.     fs_fclose(pFile);
  719.     remove(TestFileName);
  720.     return 1;
  721. }
  722.  
  723. #endif
  724.  
  725. /*----------------------------------------------------------------------*/
  726.  
  727. #define UNCOMPRESSOR "zcat"
  728.  
  729.  
  730. char*
  731. fs_fzcat(fileName)
  732. char *fileName;
  733. /* uncompress the file fileName
  734.    returns a pointer to the name of the uncompressed file if succeeds
  735.    returns NULL if failed
  736. */
  737. {
  738.  
  739.  
  740.   char buffer[ 2 * MAX_FILENAME_LEN + 10 ];
  741.   long err = 0L;
  742.   
  743.  
  744. #if (defined(NeXT) || defined(Mach) || defined(BSD43))
  745.   char tmpFileName[MAX_FILENAME_LEN+1];
  746. #else
  747.   char *tmpFileName = NULL;
  748. #endif              /* NeXT or Mach */
  749.   char *retptr;
  750.  
  751.   if (fileName == NULL)
  752.     return(NULL);
  753.  
  754. #if defined(NeXT) || defined(Mach) || defined(BSD43)
  755.   tmpnam(tmpFileName);
  756.   retptr = s_strdup(tmpFileName);
  757. #else
  758.   tmpFileName = tempnam("/tmp/", 0);
  759.   retptr = tmpFileName;
  760.   if (! retptr) {
  761.     return(NULL);
  762.   }
  763. #endif
  764.  
  765.  
  766.     sprintf(buffer, "%s %s.Z > %s", UNCOMPRESSOR, fileName, retptr);
  767.  
  768.     system(buffer);
  769.     return(retptr); 
  770.  
  771.  
  772.  
  773. /*   
  774.     if( system(buffer) != 0 ) {
  775.         waislog(WLOG_HIGH, WLOG_ERROR, "Error excuting system command: %s %ld",buffer, err );
  776.     unlink(retptr);
  777.         s_free(retptr);
  778.         return(NULL);
  779.     }
  780.     else {    
  781.        return(retptr);
  782.     }
  783. */
  784.  
  785. }
  786.