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