home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / MISC / MNLDOS.ZIP / src / fileutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  2004-07-18  |  7.7 KB  |  334 lines
  1. /* $Id: fileutil.c,v 1.6 2004/07/17 03:41:43 ozzmosis Exp $ */
  2.  
  3. #include <sys/types.h>
  4. #include <stdlib.h>
  5. #include <fcntl.h>
  6. #include <string.h>
  7. #include <stdio.h>
  8. #include <ctype.h>
  9.  
  10. #include "makenl.h"
  11. #include "config.h"
  12. #include "fileutil.h"
  13.  
  14. #ifdef MALLOC_DEBUG
  15. #include "rmalloc.h"
  16. #endif
  17.  
  18. #ifdef DMALLOC
  19. #include "dmalloc.h"
  20. #endif
  21.  
  22. char OldExtensions[4][MYMAXEXT];
  23. int do_clean;
  24.  
  25. char MakeSourceFile[MYMAXFILE + MYMAXEXT];
  26. char OutFile[MYMAXFILE + MYMAXEXT];
  27. char OutDiff[MYMAXFILE + MYMAXEXT];
  28. char CopyrightFile[MYMAXFILE + MYMAXEXT] = "cpyright.txt";
  29. char PrologFile[MYMAXFILE + MYMAXEXT] = "prolog.txt";
  30. char EpilogFile[MYMAXFILE + MYMAXEXT] = "epilog.txt";
  31. char MergeFilename[MYMAXPATH];
  32. char CommentsFile[MYMAXPATH];
  33.  
  34. char CurDir[MYMAXDIR];
  35. char OutDir[MYMAXDIR];
  36. char MasterDir[MYMAXDIR];
  37. char UpdateDir[MYMAXDIR];
  38. char MessageDir[MYMAXDIR];
  39. char MailfileDir[MYMAXDIR];
  40. char UploadDir[MYMAXDIR];
  41. char BadDir[MYMAXDIR];
  42.  
  43. char BatchFile[MYMAXPATH];
  44. char CalledBatchFile[MYMAXFILE];
  45.  
  46. int GetPath(char *arg, int switchno)
  47. {
  48.     char *destptr;
  49.  
  50.     switch (switchno)
  51.     {
  52.     default:
  53.         return 0;
  54.     case CFG_BADFILES:
  55.         destptr = BadDir;
  56.         break;
  57.     case CFG_MAILFILES:
  58.         destptr = MailfileDir;
  59.         break;
  60.     case CFG_MASTER:
  61.         destptr = MasterDir;
  62.         break;
  63.     case CFG_MESSAGES:
  64.         destptr = MessageDir;
  65.         break;
  66.     case CFG_OUTPATH:
  67.         destptr = OutDir;
  68.         break;
  69.     case CFG_UPDATE:
  70.         destptr = UpdateDir;
  71.         break;
  72.     case CFG_UPLOADS:
  73.         destptr = UploadDir;
  74.         break;
  75.     }
  76.     return (os_fulldir(destptr, arg, MYMAXDIR) == 0);
  77. }
  78.  
  79. int getext(char *ext, char *filename) /* returns length of extension 0..3 */
  80. {
  81.     char extbuf[MYMAXEXT], *extptr;
  82.  
  83.     if (ext)
  84.         extptr = ext;
  85.     else
  86.         extptr = extbuf;
  87.     myfnsplit(filename, NULL, NULL, NULL, extptr);
  88.     return strlen(extptr);
  89. }
  90.  
  91. void swapext(char *newname, const char *origname, const char *newext)
  92. {
  93.     char drive[MYMAXDRIVE];
  94.     char name[MYMAXFILE];
  95.     char path[MYMAXDIR];
  96.  
  97.     myfnsplit(origname, drive, path, name, NULL);
  98.     myfnmerge(newname, drive, path, name, newext);
  99. }
  100.  
  101. void
  102. myfnmerge(char *output, const char *drive, const char *dir,
  103.           const char *name, const char *ext)
  104. {
  105.     int lenleft;
  106.  
  107.     lenleft = MYMAXDIR - 1;
  108.     if (drive && *drive != 0)
  109.     {
  110.         *(output++) = *drive;
  111.         *(output++) = ':';
  112.         lenleft = MYMAXDIR - 3;
  113.     }
  114.     if (dir && *dir)
  115.     {
  116.         while (lenleft && *dir)
  117.         {
  118.             *(output++) = *(dir++);
  119.             lenleft--;
  120.         }
  121.         if (lenleft && (*(output - 1) != '\\' && *(output - 1) != '/'))
  122.         {
  123.             *(output++) = CHAR_DIRSEPARATOR;
  124.             lenleft--;
  125.         }
  126.     }
  127.     if (name && *name)
  128.     {
  129.         while (lenleft && *name)
  130.         {
  131.             *(output++) = *(name++);
  132.             lenleft--;
  133.         }
  134.     }
  135.     if (ext && *ext)
  136.     {
  137.         if (lenleft && *(output - 1) != '.')
  138.         {
  139.             *(output++) = '.';
  140.             lenleft--;
  141.         }
  142.         if (*ext == '.')
  143.             ext++;
  144.         while (lenleft && *ext)
  145.         {
  146.             *(output++) = *(ext++);
  147.             lenleft--;
  148.         }
  149.     }
  150.     *output = 0;
  151. }
  152.  
  153. void
  154. myfnsplit(const char *input, char *drive, char *dir, char *name, char *ext)
  155. {
  156.     const char *splitptr;
  157.     const char *splitptr2;
  158.     int lenleft;
  159.  
  160.     if (input[1] == ':')
  161.     {
  162.         if (drive)
  163.         {
  164.             drive[0] = input[0];
  165.             drive[1] = 0;
  166.         }
  167.         input += 2;
  168.     }
  169.     else if (drive)
  170.         *drive = 0;
  171.     splitptr = strrchr(input, '\\');
  172.     splitptr2 = strrchr(input, '/');
  173.     if (splitptr2 > splitptr)
  174.         splitptr = splitptr2;
  175.     if (!splitptr)
  176.         splitptr = input - 1;
  177.     if (dir)
  178.     {
  179.         for (lenleft = MYMAXDIR - 1; input <= splitptr && lenleft;
  180.              lenleft--)
  181.             *(dir++) = *(input++);
  182.  
  183.         if (lenleft < MYMAXDIR - 2) /* the single '\' may *not* be deleted 
  184.                                      */
  185.             dir--;              /* delete trailing '\' */
  186.  
  187.         *dir = 0;
  188.     }
  189.     else
  190.         input = splitptr + 1;
  191.     splitptr = strchr(input, '.');
  192.     if (!splitptr)
  193.         splitptr = strchr(input, 0);
  194.     if (name)
  195.     {
  196.         for (lenleft = MYMAXFILE - 1; input < splitptr && lenleft;
  197.              lenleft--)
  198.             *(name++) = *(input++);
  199.         *name = 0;
  200.     }
  201.     else
  202.         input = splitptr;
  203.     if (ext)
  204.     {
  205.         if (*splitptr)
  206.             splitptr++;         /* Skip the dot */
  207.         for (lenleft = 3; *splitptr && lenleft; lenleft--)
  208.             *(ext++) = *(splitptr++);
  209.         *ext = 0;
  210.     }
  211. }
  212.  
  213. long filesize(const char *filename)
  214. {
  215.     long size;
  216.     int handle;
  217.  
  218.     handle = open(filename, O_RDONLY);
  219.     if (handle == -1)
  220.         return -1;
  221.     size = lseek(handle, 0, SEEK_END);
  222.     close(handle);
  223.     if (size < 0)
  224.         return -1;
  225.     else
  226.         return size;
  227. }
  228.  
  229. void cleanold(char *path, char *filename, char *ext)
  230. {
  231.     char *nameptr;
  232.     struct _filefind f;
  233.     char fnamebuf[MYMAXDIR];
  234.  
  235.     if (path[0] == 0)
  236.         return;
  237.     if (getext(NULL, filename))
  238.     {
  239.         /* extension in filename given: delete exactly that file */
  240.         myfnmerge(fnamebuf, NULL, path, filename, NULL);
  241.         unlink(fnamebuf);
  242.     }
  243.     else if (ext && ext[0] != 0)
  244.     {
  245.         /* no extension in filename but extension in ext: delete
  246.            filename+ext */
  247.         myfnmerge(fnamebuf, NULL, path, filename, ext);
  248.         unlink(fnamebuf);
  249.     }
  250.     else
  251.     {
  252.         /* no extension in filename or ext: delete filename.* */
  253.         myfnmerge(fnamebuf, NULL, NULL, filename, "*");
  254.  
  255.         for (nameptr = os_findfirst(&f, path, fnamebuf);
  256.              nameptr != NULL; nameptr = os_findnext(&f))
  257.         {
  258.             myfnmerge(fnamebuf, NULL, path, nameptr, NULL);
  259.             unlink(fnamebuf);
  260.         }
  261.         os_findclose(&f);
  262.     }
  263. }
  264.  
  265. void cleanit(void)
  266. {
  267.     char (*extptr)[MYMAXEXT];
  268.     char ext[MYMAXEXT];
  269.     char delname[MYMAXDIR];
  270.  
  271.     if (!do_clean)
  272.         return;
  273.     if (getext(NULL, OutFile) != 0)
  274.         return;
  275.     extptr = OldExtensions + 1;
  276.     do
  277.     {
  278.         strcpy(ext, *extptr);
  279.         if (OutDiff[0] != 0)
  280.         {
  281.             myfnmerge(delname, NULL, OutDir, OutDiff, ext);
  282.             unlink(delname);
  283.             ext[0] = 'A';
  284.             myfnmerge(delname, NULL, OutDir, OutDiff, ext);
  285.             unlink(delname);
  286.         }
  287.         ext[0] = 'D';
  288.         myfnmerge(delname, NULL, OutDir, OutFile, ext);
  289.         unlink(delname);
  290.         ext[0] = 'A';
  291.         myfnmerge(delname, NULL, OutDir, OutFile, ext);
  292.         unlink(delname);
  293.         ext[1] = 'D';
  294.         myfnmerge(delname, NULL, OutDir, OutFile, ext);
  295.         unlink(delname);
  296.         extptr++;
  297.     }
  298.     while (extptr < OldExtensions + 4);
  299. }
  300.  
  301. void CopyOrMove(int copy, char *source, char *destdir, char *destname)
  302. {
  303.     char dest[MYMAXDIR];
  304.     int copychar;               /* Yes *int* and *char* are intentionally! 
  305.                                  */
  306.     FILE *destFILE;             /* 0x04 */
  307.     FILE *sourceFILE;           /* 0x06 */
  308.  
  309.     if (destname[0] == 0)
  310.         return;
  311.  
  312.     myfnmerge(dest, NULL, destdir, destname,
  313.               getext(NULL, destname) ? NULL : OldExtensions[0]);
  314.     if (!filecmp(dest, source))
  315.         return;
  316.     fprintf(stdout, "%sing \"%s\" to \"%s\"\n", copy ? "Copy" : "Mov",
  317.             source, dest);
  318.     unlink(dest);
  319.     if (!copy && rename(source, dest) == 0)
  320.         return;
  321.     destFILE = fopen(dest, "w");
  322.     if (!destFILE)
  323.         die(254, 1, "Unable to open %s for output", dest);
  324.     sourceFILE = fopen(source, "r");
  325.     if (!sourceFILE)
  326.         die(254, 1, "Unable to open %s for input", source);
  327.     while ((copychar = getc(sourceFILE)) != EOF)
  328.         putc(copychar, destFILE);
  329.     fclose(sourceFILE);
  330.     fclose(destFILE);
  331.     if (!copy)
  332.         unlink(source);
  333. }
  334.