home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / lora299s.zip / PACKER.CPP < prev    next >
C/C++ Source or Header  |  1998-05-12  |  12KB  |  459 lines
  1.  
  2. // LoraBBS Version 2.99 Free Edition
  3. // Copyright (C) 1987-98 Marco Maccaferri
  4. //
  5. // This program is free software; you can redistribute it and/or modify
  6. // it under the terms of the GNU General Public License as published by
  7. // the Free Software Foundation; either version 2 of the License, or
  8. // (at your option) any later version.
  9. //
  10. // This program is distributed in the hope that it will be useful,
  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. // GNU General Public License for more details.
  14. //
  15. // You should have received a copy of the GNU General Public License
  16. // along with this program; if not, write to the Free Software
  17. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19. #include "_ldefs.h"
  20. #include "lora_api.h"
  21. #include <errno.h>
  22.  
  23. TPacker::TPacker (void)
  24. {
  25.    fd = -1;
  26. #if defined(__LINUX__)
  27.    strcpy (DataPath, "./");
  28. #else
  29.    strcpy (DataPath, ".\\");
  30. #endif
  31. }
  32.  
  33. TPacker::TPacker (PSZ pszDataPath)
  34. {
  35.    fd = -1;
  36.    strcpy (DataPath, pszDataPath);
  37. #if defined(__LINUX__)
  38.    if (DataPath[0] && DataPath[strlen (DataPath) - 1] != '/')
  39.       strcat (DataPath, "/");
  40. #else
  41.    if (DataPath[0] && DataPath[strlen (DataPath) - 1] != '\\')
  42.       strcat (DataPath, "\\");
  43. #endif
  44. }
  45.  
  46. TPacker::~TPacker (void)
  47. {
  48.    if (fd != -1)
  49.       close (fd);
  50. }
  51.  
  52. USHORT TPacker::Add (VOID)
  53. {
  54.    USHORT RetVal = FALSE;
  55.    CHAR Temp[64];
  56.    PACKER Pack;
  57.  
  58.    if (fd == -1) {
  59.       sprintf (Temp, "%spacker.dat", DataPath);
  60.       fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE);
  61.    }
  62.  
  63.    if (fd != -1) {
  64.       memset (&Pack, 0, sizeof (Pack));
  65.       strcpy (Pack.Key, Key);
  66.       strcpy (Pack.Display, Display);
  67.       strcpy (Pack.PackCmd, PackCmd);
  68.       strcpy (Pack.UnpackCmd, UnpackCmd);
  69.       strcpy (Pack.Id, Id);
  70.       Pack.Position = Position;
  71.       if (Dos == TRUE)
  72.          Pack.OS |= OS_DOS;
  73.       if (OS2 == TRUE)
  74.          Pack.OS |= OS_OS2;
  75.       if (Windows == TRUE)
  76.          Pack.OS |= OS_WINDOWS;
  77.       if (Linux == TRUE)
  78.          Pack.OS |= OS_LINUX;
  79.  
  80.       if (lseek (fd, 0L, SEEK_END) != -1L) {
  81.          if (write (fd, &Pack, sizeof (Pack)) == sizeof (Pack))
  82.             RetVal = TRUE;
  83.       }
  84.  
  85.       RetVal = TRUE;
  86.    }
  87.  
  88.    return (RetVal);
  89. }
  90.  
  91. USHORT TPacker::CheckArc (PSZ pszArcName)
  92. {
  93.    int fdd;
  94.    USHORT RetVal = FALSE;
  95.    CHAR Temp[64];
  96.    UCHAR c, Buffer[16], c1, *a;
  97.    PSZ p;
  98.    PACKER Pack;
  99.  
  100.    if (fd == -1) {
  101.       sprintf (Temp, "%spacker.dat", DataPath);
  102.       fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE);
  103.    }
  104.  
  105.    if ((fdd = sopen (pszArcName, O_RDONLY|O_BINARY, SH_DENYNO, S_IREAD|S_IWRITE)) != -1) {
  106.       lseek (fd, 0L, SEEK_SET);
  107.       while (read (fd, &Pack, sizeof (Pack)) == sizeof (Pack)) {
  108. #if defined(__OS2__)
  109.          if (!(Pack.OS & OS_OS2))
  110.             continue;
  111. #elif defined(__NT__)
  112.          if (!(Pack.OS & OS_WINDOWS))
  113.             continue;
  114. #elif defined(__LINUX__)
  115.          if (!(Pack.OS & OS_LINUX))
  116.             continue;
  117. #else
  118.          if (!(Pack.OS & OS_DOS))
  119.             continue;
  120. #endif
  121.  
  122.          if (Pack.Position < 0)
  123.             lseek (fdd, filelength (fd) + Pack.Position, SEEK_SET);
  124.          else
  125.             lseek (fdd, Pack.Position, SEEK_SET);
  126.  
  127.          read (fdd, Buffer, sizeof (Buffer));
  128.  
  129.          p = Pack.Id;
  130.          a = Buffer;
  131.          RetVal = TRUE;
  132.  
  133.          while (*p != '\0' && RetVal == TRUE) {
  134.             c = (UCHAR)(toupper (*p++) - '0');
  135.             if (c > 9)
  136.                c -= 7;
  137.             if (*p != '\0') {
  138.                c1 = (UCHAR)(toupper (*p++) - '0');
  139.                if (c1 > 9)
  140.                   c1 -= 7;
  141.                c = (UCHAR)((c << 4) | c1);
  142.             }
  143.             if (*a++ != c)
  144.                RetVal = FALSE;
  145.          }
  146.  
  147.          if (RetVal == TRUE)
  148.             break;
  149.       }
  150.       close (fdd);
  151.    }
  152.  
  153.    if (RetVal == TRUE) {
  154.       strcpy (Key, Pack.Key);
  155.       strcpy (Display, Pack.Display);
  156.       strcpy (PackCmd, Pack.PackCmd);
  157.       strcpy (UnpackCmd, Pack.UnpackCmd);
  158.       strcpy (Id, Pack.Id);
  159.       Position = Pack.Position;
  160.       Dos = (UCHAR)((Pack.OS & OS_DOS) ? TRUE : FALSE);
  161.       OS2 = (UCHAR)((Pack.OS & OS_OS2) ? TRUE : FALSE);
  162.       Windows = (UCHAR)((Pack.OS & OS_WINDOWS) ? TRUE : FALSE);
  163.       Linux = (UCHAR)((Pack.OS & OS_LINUX) ? TRUE : FALSE);
  164.    }
  165.  
  166.    return (RetVal);
  167. }
  168.  
  169. USHORT TPacker::Delete (VOID)
  170. {
  171.    int fdn;
  172.    USHORT RetVal = FALSE;
  173.    CHAR Temp[64];
  174.    ULONG Position;
  175.    PACKER Pack;
  176.  
  177.    sprintf (Temp, "%spacker.new", DataPath);
  178.    fdn = sopen (Temp, O_RDWR|O_BINARY|O_CREAT|O_TRUNC, SH_DENYNO, S_IREAD|S_IWRITE);
  179.  
  180.    if (fd != -1 && fdn != -1) {
  181.       Position = tell (fd);
  182.       lseek (fd, 0L, SEEK_SET);
  183.  
  184.       while (read (fd, &Pack, sizeof (Pack)) == sizeof (Pack)) {
  185.          if (tell (fd) != Position)
  186.             write (fdn, &Pack, sizeof (Pack));
  187.       }
  188.  
  189.       lseek (fd, 0L, SEEK_SET);
  190.       lseek (fdn, 0L, SEEK_SET);
  191.  
  192.       while (read (fdn, &Pack, sizeof (Pack)) == sizeof (Pack))
  193.          write (fd, &Pack, sizeof (Pack));
  194.       chsize (fd, tell (fd));
  195.  
  196.       if (tell (fd) > Position)
  197.          lseek (fd, Position, SEEK_SET);
  198.       if (Next () == FALSE) {
  199.          if (Previous () == FALSE)
  200.             New ();
  201.       }
  202.  
  203.       RetVal = TRUE;
  204.    }
  205.  
  206.    if (fdn != -1) {
  207.       close (fdn);
  208.       sprintf (Temp, "%spacker.new", DataPath);
  209.       unlink (Temp);
  210.    }
  211.  
  212.    return (RetVal);
  213. }
  214.  
  215. USHORT TPacker::DoPack (PSZ pszArcName, PSZ pszFiles)
  216. {
  217.    USHORT RetVal = FALSE;
  218.  
  219.    strcpy (Command, PackCmd);
  220.    if (pszArcName != NULL) {
  221.       strsrep (Command, "%1", pszArcName);
  222.       strsrep (Command, "%a", pszArcName);
  223.    }
  224.    if (pszFiles != NULL) {
  225.       strsrep (Command, "%2", pszFiles);
  226.       strsrep (Command, "%f", pszFiles);
  227.    }
  228.  
  229.    RunExternal (Command);
  230.    RetVal = TRUE;
  231.  
  232.    return (RetVal);
  233. }
  234.  
  235. USHORT TPacker::DoUnpack (PSZ pszArcName, PSZ pszPath, PSZ pszFiles)
  236. {
  237.    USHORT RetVal = FALSE, AppendSlash = FALSE;
  238.    CHAR CurrentDir[128];
  239.  
  240.    strcpy (Command, UnpackCmd);
  241.    if (pszArcName != NULL) {
  242.       strsrep (Command, "%1", pszArcName);
  243.       strsrep (Command, "%a", pszArcName);
  244.    }
  245.    strsrep (Command, "%2", "");
  246.    if (pszFiles != NULL) {
  247.       strsrep (Command, "%3", pszFiles);
  248.       strsrep (Command, "%f", pszFiles);
  249.    }
  250.  
  251.    getcwd (CurrentDir, sizeof (CurrentDir) - 1);
  252.    if (pszPath[strlen (pszPath) - 1] == '\\') {
  253.       pszPath[strlen (pszPath) - 1] = '\0';
  254.       AppendSlash = TRUE;
  255.    }
  256.    chdir (pszPath);
  257.  
  258.    RunExternal (Command);
  259.    RetVal = TRUE;
  260.  
  261.    chdir (CurrentDir);
  262.    if (AppendSlash == TRUE)
  263.       strcat (pszPath, "\\");
  264.  
  265.    return (RetVal);
  266. }
  267.  
  268. USHORT TPacker::First (USHORT checkOS)
  269. {
  270.    CHAR Temp[64];
  271.  
  272.    if (fd == -1) {
  273.       sprintf (Temp, "%spacker.dat", DataPath);
  274.       fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE);
  275.    }
  276.  
  277.    if (fd != -1)
  278.       lseek (fd, 0L, SEEK_SET);
  279.  
  280.    return (Next (checkOS));
  281. }
  282.  
  283. VOID TPacker::New (VOID)
  284. {
  285.    memset (Key, 0, sizeof (Key));
  286.    memset (Display, 0, sizeof (Display));
  287.    memset (PackCmd, 0, sizeof (PackCmd));
  288.    memset (UnpackCmd, 0, sizeof (UnpackCmd));
  289.    memset (Id, 0, sizeof (Id));
  290.    Position = 0L;
  291.    Dos = OS2 = Windows = Linux = FALSE;
  292. }
  293.  
  294. USHORT TPacker::Next (USHORT checkOS)
  295. {
  296.    USHORT RetVal = FALSE;
  297.    PACKER Pack;
  298.  
  299.    if (fd != -1) {
  300.       while (read (fd, &Pack, sizeof (Pack)) == sizeof (Pack)) {
  301.          if (checkOS == TRUE) {
  302. #if defined(__OS2__)
  303.             if (!(Pack.OS & OS_OS2))
  304.                continue;
  305. #elif defined(__NT__)
  306.             if (!(Pack.OS & OS_WINDOWS))
  307.                continue;
  308. #elif defined(__LINUX__)
  309.             if (!(Pack.OS & OS_LINUX))
  310.                continue;
  311. #else
  312.             if (!(Pack.OS & OS_DOS))
  313.                continue;
  314. #endif
  315.          }
  316.          strcpy (Key, Pack.Key);
  317.          strcpy (Display, Pack.Display);
  318.          strcpy (PackCmd, Pack.PackCmd);
  319.          strcpy (UnpackCmd, Pack.UnpackCmd);
  320.          strcpy (Id, Pack.Id);
  321.          Position = Pack.Position;
  322.          Dos = (UCHAR)((Pack.OS & OS_DOS) ? TRUE : FALSE);
  323.          OS2 = (UCHAR)((Pack.OS & OS_OS2) ? TRUE : FALSE);
  324.          Windows = (UCHAR)((Pack.OS & OS_WINDOWS) ? TRUE : FALSE);
  325.          Linux = (UCHAR)((Pack.OS & OS_LINUX) ? TRUE : FALSE);
  326.          RetVal = TRUE;
  327.          break;
  328.       }
  329.    }
  330.  
  331.    return (RetVal);
  332. }
  333.  
  334. USHORT TPacker::Previous (USHORT checkOS)
  335. {
  336.    USHORT RetVal = FALSE;
  337.    PACKER Pack;
  338.  
  339.    if (fd != -1) {
  340.       while (tell (fd) >= sizeof (Pack) * 2) {
  341.          lseek (fd, tell (fd) - sizeof (Pack) * 2, SEEK_SET);
  342.          if (read (fd, &Pack, sizeof (Pack)) == sizeof (Pack)) {
  343.             if (checkOS == TRUE) {
  344. #if defined(__OS2__)
  345.                if (!(Pack.OS & OS_OS2))
  346.                   continue;
  347. #elif defined(__NT__)
  348.                if (!(Pack.OS & OS_WINDOWS))
  349.                   continue;
  350. #elif defined(__LINUX__)
  351.                if (!(Pack.OS & OS_LINUX))
  352.                   continue;
  353. #else
  354.                if (!(Pack.OS & OS_DOS))
  355.                   continue;
  356. #endif
  357.             }
  358.             strcpy (Key, Pack.Key);
  359.             strcpy (Display, Pack.Display);
  360.             strcpy (PackCmd, Pack.PackCmd);
  361.             strcpy (UnpackCmd, Pack.UnpackCmd);
  362.             strcpy (Id, Pack.Id);
  363.             Position = Pack.Position;
  364.             Dos = (UCHAR)((Pack.OS & OS_DOS) ? TRUE : FALSE);
  365.             OS2 = (UCHAR)((Pack.OS & OS_OS2) ? TRUE : FALSE);
  366.             Windows = (UCHAR)((Pack.OS & OS_WINDOWS) ? TRUE : FALSE);
  367.             Linux = (UCHAR)((Pack.OS & OS_LINUX) ? TRUE : FALSE);
  368.             RetVal = TRUE;
  369.             break;
  370.          }
  371.       }
  372.    }
  373.  
  374.    return (RetVal);
  375. }
  376.  
  377. USHORT TPacker::Read (PSZ pszKey, USHORT checkOS)
  378. {
  379.    USHORT RetVal = FALSE;
  380.    CHAR Temp[64];
  381.    PACKER Pack;
  382.  
  383.    if (fd == -1) {
  384.       sprintf (Temp, "%spacker.dat", DataPath);
  385.       fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE);
  386.    }
  387.  
  388.    if (fd != -1) {
  389.       lseek (fd, 0L, SEEK_SET);
  390.       while (read (fd, &Pack, sizeof (Pack)) == sizeof (Pack)) {
  391.          if (checkOS == TRUE) {
  392. #if defined(__OS2__)
  393.             if (!(Pack.OS & OS_OS2))
  394.                continue;
  395. #elif defined(__NT__)
  396.             if (!(Pack.OS & OS_WINDOWS))
  397.                continue;
  398. #elif defined(__LINUX__)
  399.             if (!(Pack.OS & OS_LINUX))
  400.                continue;
  401. #else
  402.             if (!(Pack.OS & OS_DOS))
  403.                continue;
  404. #endif
  405.          }
  406.          if (!stricmp (Pack.Key, pszKey)) {
  407.             strcpy (Key, Pack.Key);
  408.             strcpy (Display, Pack.Display);
  409.             strcpy (PackCmd, Pack.PackCmd);
  410.             strcpy (UnpackCmd, Pack.UnpackCmd);
  411.             strcpy (Id, Pack.Id);
  412.             Position = Pack.Position;
  413.             Dos = (UCHAR)((Pack.OS & OS_DOS) ? TRUE : FALSE);
  414.             OS2 = (UCHAR)((Pack.OS & OS_OS2) ? TRUE : FALSE);
  415.             Windows = (UCHAR)((Pack.OS & OS_WINDOWS) ? TRUE : FALSE);
  416.             Linux = (UCHAR)((Pack.OS & OS_LINUX) ? TRUE : FALSE);
  417.             RetVal = TRUE;
  418.             break;
  419.          }
  420.       }
  421.    }
  422.  
  423.    return (RetVal);
  424. }
  425.  
  426. USHORT TPacker::Update (VOID)
  427. {
  428.    USHORT RetVal = FALSE;
  429.    PACKER Pack;
  430.  
  431.    if (fd != -1 && tell (fd) >= sizeof (Pack)) {
  432.       memset (&Pack, 0, sizeof (Pack));
  433.       strcpy (Pack.Key, Key);
  434.       strcpy (Pack.Display, Display);
  435.       strcpy (Pack.PackCmd, PackCmd);
  436.       strcpy (Pack.UnpackCmd, UnpackCmd);
  437.       strcpy (Pack.Id, Id);
  438.       Pack.Position = Position;
  439.       if (Dos == TRUE)
  440.          Pack.OS |= OS_DOS;
  441.       if (OS2 == TRUE)
  442.          Pack.OS |= OS_OS2;
  443.       if (Windows == TRUE)
  444.          Pack.OS |= OS_WINDOWS;
  445.       if (Linux == TRUE)
  446.          Pack.OS |= OS_LINUX;
  447.  
  448.       if (lseek (fd, tell (fd) - sizeof (Pack), SEEK_SET) != -1L) {
  449.          if (write (fd, &Pack, sizeof (Pack)) == sizeof (Pack))
  450.             RetVal = TRUE;
  451.       }
  452.    }
  453.  
  454.    return (RetVal);
  455. }
  456.  
  457.  
  458.  
  459.