home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / lora299s.zip / NODES.CPP < prev    next >
C/C++ Source or Header  |  1998-05-12  |  25KB  |  906 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.  
  22. TNodes::TNodes (void)
  23. {
  24. #if defined(__LINUX__)
  25.    strcpy (DataFile, "./nodes");
  26. #else
  27.    strcpy (DataFile, ".\\nodes");
  28. #endif
  29.    fd = -1;
  30. }
  31.  
  32. TNodes::TNodes (PSZ pszDataPath)
  33. {
  34.    strcpy (DataFile, pszDataPath);
  35.    if (DataFile[0] != '\0') {
  36. #if defined(__LINUX__)
  37.       if (DataFile[strlen (DataFile) - 1] != '\\')
  38.          strcat (DataFile, "/");
  39. #else
  40.       if (DataFile[strlen (DataFile) - 1] != '\\')
  41.          strcat (DataFile, "\\");
  42. #endif
  43.    }
  44.    strcat (DataFile, "nodes");
  45.    fd = -1;
  46. }
  47.  
  48. TNodes::~TNodes (void)
  49. {
  50.    if (fd != -1)
  51.       close (fd);
  52. }
  53.  
  54. VOID TNodes::Class2Struct (NODES &Nodes)
  55. {
  56.    memset (&Nodes, 0, sizeof (Nodes));
  57.    strcpy (Nodes.Address, Address);
  58.    strcpy (Nodes.SystemName, SystemName);
  59.    strcpy (Nodes.SysopName, SysopName);
  60.    strcpy (Nodes.Location, Location);
  61.    Nodes.Speed = Speed;
  62.    Nodes.MinSpeed = MinSpeed;
  63.    strcpy (Nodes.Phone, Phone);
  64.    strcpy (Nodes.Flags, Flags);
  65.    strcpy (Nodes.DialCmd, DialCmd);
  66.    Nodes.RemapMail = RemapMail;
  67.    strcpy (Nodes.SessionPwd, SessionPwd);
  68.    strcpy (Nodes.AreaMgrPwd, AreaMgrPwd);
  69.    strcpy (Nodes.OutPktPwd, OutPktPwd);
  70.    strcpy (Nodes.InPktPwd, InPktPwd);
  71.    Nodes.UsePkt22 = UsePkt22;
  72.    Nodes.CreateNewAreas = CreateNewAreas;
  73.    strcpy (Nodes.NewAreasFilter, NewAreasFilter);
  74.    strcpy (Nodes.TicPwd, TicPwd);
  75.    strcpy (Nodes.Packer, Packer);
  76.    Nodes.ImportPOP3Mail = ImportPOP3Mail;
  77.    Nodes.UseInetAddress = UseInetAddress;
  78.    strcpy (Nodes.InetAddress, InetAddress);
  79.    strcpy (Nodes.Pop3Pwd, Pop3Pwd);
  80.    Nodes.Level = Level;
  81.    Nodes.AccessFlags = AccessFlags;
  82.    Nodes.DenyFlags = DenyFlags;
  83.    Nodes.TicLevel = TicLevel;
  84.    Nodes.TicAccessFlags = TicAccessFlags;
  85.    Nodes.TicDenyFlags = TicDenyFlags;
  86.    Nodes.LinkNewEcho = LinkNewEcho;
  87.    Nodes.EchoMaint = EchoMaint;
  88.    Nodes.ChangeEchoTag = ChangeEchoTag;
  89.    Nodes.NotifyAreafix = NotifyAreafix;
  90.    Nodes.CreateNewTic = CreateNewTic;
  91.    Nodes.LinkNewTic = LinkNewTic;
  92.    Nodes.TicMaint = TicMaint;
  93.    Nodes.ChangeTicTag = ChangeTicTag;
  94.    Nodes.NotifyRaid = NotifyRaid;
  95.    strcpy (Nodes.MailerAka, MailerAka);
  96.    strcpy (Nodes.EchoAka, EchoAka);
  97.    strcpy (Nodes.TicAka, TicAka);
  98.    strcpy (Nodes.NewTicFilter, NewTicFilter);
  99. }
  100.  
  101. VOID TNodes::Struct2Class (NODES &Nodes)
  102. {
  103.    class TAddress Addr;
  104.  
  105.    strcpy (Address, Nodes.Address);
  106.    Addr.Parse (Address);
  107.    Zone = Addr.Zone;
  108.    Net = Addr.Net;
  109.    Node = Addr.Node;
  110.    Point = Addr.Point;
  111.    strcpy (SystemName, Nodes.SystemName);
  112.    strcpy (SysopName, Nodes.SysopName);
  113.    strcpy (Location, Nodes.Location);
  114.    Speed = Nodes.Speed;
  115.    MinSpeed = Nodes.MinSpeed;
  116.    strcpy (Phone, Nodes.Phone);
  117.    strcpy (Flags, Nodes.Flags);
  118.    strcpy (DialCmd, Nodes.DialCmd);
  119.    RemapMail = Nodes.RemapMail;
  120.    strcpy (SessionPwd, Nodes.SessionPwd);
  121.    strcpy (AreaMgrPwd, Nodes.AreaMgrPwd);
  122.    strcpy (OutPktPwd, Nodes.OutPktPwd);
  123.    strcpy (InPktPwd, Nodes.InPktPwd);
  124.    UsePkt22 = Nodes.UsePkt22;
  125.    CreateNewAreas = Nodes.CreateNewAreas;
  126.    strcpy (NewAreasFilter, Nodes.NewAreasFilter);
  127.    strcpy (TicPwd, Nodes.TicPwd);
  128.    strcpy (Packer, Nodes.Packer);
  129.    ImportPOP3Mail = Nodes.ImportPOP3Mail;
  130.    UseInetAddress = Nodes.UseInetAddress;
  131.    strcpy (InetAddress, Nodes.InetAddress);
  132.    strcpy (Pop3Pwd, Nodes.Pop3Pwd);
  133.    Level = Nodes.Level;
  134.    AccessFlags = Nodes.AccessFlags;
  135.    DenyFlags = Nodes.DenyFlags;
  136.    TicLevel = Nodes.TicLevel;
  137.    TicAccessFlags = Nodes.TicAccessFlags;
  138.    TicDenyFlags = Nodes.TicDenyFlags;
  139.    LinkNewEcho = Nodes.LinkNewEcho;
  140.    EchoMaint = Nodes.EchoMaint;
  141.    ChangeEchoTag = Nodes.ChangeEchoTag;
  142.    NotifyAreafix = Nodes.NotifyAreafix;
  143.    CreateNewTic = Nodes.CreateNewTic;
  144.    LinkNewTic = Nodes.LinkNewTic;
  145.    TicMaint = Nodes.TicMaint;
  146.    ChangeTicTag = Nodes.ChangeTicTag;
  147.    NotifyRaid = Nodes.NotifyRaid;
  148.    strcpy (MailerAka, Nodes.MailerAka);
  149.    strcpy (EchoAka, Nodes.EchoAka);
  150.    strcpy (TicAka, Nodes.TicAka);
  151.    strcpy (NewTicFilter, Nodes.NewTicFilter);
  152. }
  153.  
  154. VOID TNodes::Add (VOID)
  155. {
  156.    int fdn;
  157.    USHORT DoClose = FALSE, Saved = FALSE;
  158.    CHAR Temp[64];
  159.    NODES Nodes;
  160.  
  161.    if (fd == -1) {
  162.       sprintf (Temp, "%s.dat", DataFile);
  163.       if ((fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE)) != -1)
  164.          DoClose = TRUE;
  165.    }
  166.  
  167.    sprintf (Temp, "%s.new", DataFile);
  168.    while ((fdn = sopen (Temp, O_RDWR|O_BINARY|O_CREAT|O_TRUNC, SH_DENYRW, S_IREAD|S_IWRITE)) == -1)
  169.       ;
  170.  
  171.    if (fd != -1 && fdn != -1) {
  172.       lseek (fd, 0L, SEEK_SET);
  173.       Addr1.Parse (Address);
  174.       strcpy (Address, Addr1.String);
  175.       while (read (fd, &Nodes, sizeof (Nodes)) == sizeof (Nodes)) {
  176.          if (Saved == FALSE) {
  177.             Addr2.Parse (Nodes.Address);
  178.             if (Addr2.Zone != Addr1.Zone) {
  179.                if (Addr2.Zone > Addr1.Zone)
  180.                   Saved = TRUE;
  181.             }
  182.             else if (Addr2.Net != Addr1.Net) {
  183.                if (Addr2.Net > Addr1.Net)
  184.                   Saved = TRUE;
  185.             }
  186.             else if (Addr2.Node != Addr1.Node) {
  187.                if (Addr2.Node > Addr1.Node)
  188.                   Saved = TRUE;
  189.             }
  190.             else if (Addr2.Point != Addr1.Point) {
  191.                if (Addr2.Point > Addr1.Point)
  192.                   Saved = TRUE;
  193.             }
  194.             else if (stricmp (Addr2.Domain, Addr1.Domain) > 0)
  195.                Saved = TRUE;
  196.  
  197.             if (Saved == TRUE) {
  198.                Class2Struct (Nodes);
  199.                write (fdn, &Nodes, sizeof (Nodes));
  200.  
  201.                lseek (fd, tell (fd) - sizeof (Nodes), SEEK_SET);
  202.                read (fd, &Nodes, sizeof (Nodes));
  203.             }
  204.          }
  205.  
  206.          write (fdn, &Nodes, sizeof (Nodes));
  207.       }
  208.  
  209.       if (Saved == FALSE) {
  210.          Class2Struct (Nodes);
  211.          write (fdn, &Nodes, sizeof (Nodes));
  212.       }
  213.  
  214.       lseek (fd, 0L, SEEK_SET);
  215.       lseek (fdn, 0L, SEEK_SET);
  216.       while (read (fdn, &Nodes, sizeof (Nodes)) == sizeof (Nodes))
  217.          write (fd, &Nodes, sizeof (Nodes));
  218.    }
  219.  
  220.    if (fdn != -1) {
  221.       close (fdn);
  222.       sprintf (Temp, "%s.new", DataFile);
  223.       unlink (Temp);
  224.    }
  225.    if (fd != -1 && DoClose == TRUE) {
  226.       close (fd);
  227.       fd = -1;
  228.    }
  229.  
  230.    if (Read (Addr1, FALSE) == FALSE) {
  231.       if (First () == FALSE)
  232.          New ();
  233.    }
  234. }
  235.  
  236. VOID TNodes::Delete (VOID)
  237. {
  238.    int fdn;
  239.    USHORT DoClose = FALSE;
  240.    CHAR Temp[64], NewName[64];
  241.    ULONG Position;
  242.    NODES Nodes;
  243.  
  244.    if (fd == -1) {
  245.       sprintf (Temp, "%s.dat", DataFile);
  246.       if ((fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE)) != -1)
  247.          DoClose = TRUE;
  248.    }
  249.    sprintf (NewName, "%s.new", DataFile);
  250.    fdn = sopen (NewName, O_RDWR|O_BINARY|O_CREAT|O_TRUNC, SH_DENYNO, S_IREAD|S_IWRITE);
  251.  
  252.    if (fd != -1 && fdn != -1) {
  253.       Position = 0L;
  254.       lseek (fd, 0L, SEEK_SET);
  255.       while (read (fd, &Nodes, sizeof (Nodes)) == sizeof (Nodes)) {
  256.          if (stricmp (Nodes.Address, Address))
  257.             write (fdn, &Nodes, sizeof (Nodes));
  258.          else
  259.             Position = tell (fd);
  260.       }
  261.  
  262.       lseek (fd, 0L, SEEK_SET);
  263.       lseek (fdn, 0L, SEEK_SET);
  264.  
  265.       while (read (fdn, &Nodes, sizeof (Nodes)) == sizeof (Nodes))
  266.          write (fd, &Nodes, sizeof (Nodes));
  267.       chsize (fd, tell (fd));
  268.  
  269.       if (Position > tell (fd))
  270.          Position = tell (fd);
  271.  
  272.       if (Position >= sizeof (Temp)) {
  273.          lseek (fd, Position - sizeof (Nodes), SEEK_SET);
  274.          read (fd, &Nodes, sizeof (Nodes));
  275.          Struct2Class (Nodes);
  276.       }
  277.       else
  278.          New ();
  279.    }
  280.  
  281.    if (DoClose == TRUE) {
  282.       close (fd);
  283.       fd = -1;
  284.    }
  285.  
  286.    if (fdn != -1)
  287.       close (fdn);
  288.    unlink (NewName);
  289. }
  290.  
  291. USHORT TNodes::First (VOID)
  292. {
  293.    USHORT RetVal = FALSE;
  294.    CHAR Temp[64];
  295.  
  296.    if (fd == -1) {
  297.       sprintf (Temp, "%s.dat", DataFile);
  298.       fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE);
  299.    }
  300.  
  301.    if (fd != -1) {
  302.       lseek (fd, 0L, SEEK_SET);
  303.       RetVal = Next ();
  304.    }
  305.  
  306.    return (RetVal);
  307. }
  308.  
  309. VOID TNodes::New (VOID)
  310. {
  311.    memset (Address, 0, sizeof (Address));
  312.    memset (SystemName, 0, sizeof (SystemName));
  313.    memset (SysopName, 0, sizeof (SysopName));
  314.    memset (Location, 0, sizeof (Location));
  315.    Speed = 0L;
  316.    MinSpeed = 0L;
  317.    memset (Phone, 0, sizeof (Phone));
  318.    memset (Flags, 0, sizeof (Flags));
  319.    memset (DialCmd, 0, sizeof (DialCmd));
  320.    RemapMail = FALSE;
  321.    memset (SessionPwd, 0, sizeof (SessionPwd));
  322.    memset (AreaMgrPwd, 0, sizeof (AreaMgrPwd));
  323.    memset (OutPktPwd, 0, sizeof (OutPktPwd));
  324.    memset (InPktPwd, 0, sizeof (InPktPwd));
  325.    memset (TicPwd, 0, sizeof (TicPwd));
  326.    memset (NewAreasFilter, 0, sizeof (NewAreasFilter));
  327.    UsePkt22 = FALSE;
  328.    CreateNewAreas = FALSE;
  329.    ImportPOP3Mail = UseInetAddress = FALSE;
  330.    memset (InetAddress, 0, sizeof (InetAddress));
  331.    memset (Pop3Pwd, 0, sizeof (Pop3Pwd));
  332.    memset (Packer, 0, sizeof (Packer));
  333.    Level = 0;
  334.    AccessFlags = 0L;
  335.    DenyFlags = 0L;
  336.    TicLevel = 0;
  337.    TicAccessFlags = 0L;
  338.    TicDenyFlags = 0L;
  339.    LinkNewEcho = FALSE;
  340.    EchoMaint = FALSE;
  341.    ChangeEchoTag = FALSE;
  342.    NotifyAreafix = FALSE;
  343.    CreateNewTic = FALSE;
  344.    LinkNewTic = FALSE;
  345.    TicMaint = FALSE;
  346.    ChangeTicTag = FALSE;
  347.    NotifyRaid = FALSE;
  348.    memset (MailerAka, 0, sizeof (MailerAka));
  349.    memset (EchoAka, 0, sizeof (EchoAka));
  350.    memset (TicAka, 0, sizeof (TicAka));
  351.    memset (NewTicFilter, 0, sizeof (NewTicFilter));
  352. }
  353.  
  354. USHORT TNodes::Next (VOID)
  355. {
  356.    USHORT RetVal = FALSE;
  357.    CHAR Temp[64];
  358.    NODES Nodes;
  359.  
  360.    if (fd == -1) {
  361.       sprintf (Temp, "%s.dat", DataFile);
  362.       fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE);
  363.    }
  364.  
  365.    if (fd != -1) {
  366.       if (read (fd, &Nodes, sizeof (Nodes)) == sizeof (Nodes)) {
  367.          Struct2Class (Nodes);
  368.          RetVal = TRUE;
  369.       }
  370.    }
  371.  
  372.    return (RetVal);
  373. }
  374.  
  375. USHORT TNodes::Previous (VOID)
  376. {
  377.    USHORT RetVal = FALSE;
  378.    CHAR Temp[64];
  379.    NODES Nodes;
  380.  
  381.    if (fd == -1) {
  382.       sprintf (Temp, "%s.dat", DataFile);
  383.       fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE);
  384.    }
  385.  
  386.    if (fd != -1) {
  387.       if (tell (fd) >= sizeof (Nodes) * 2) {
  388.          lseek (fd, tell (fd) - sizeof (Nodes) * 2, SEEK_SET);
  389.          read (fd, &Nodes, sizeof (Nodes));
  390.          Struct2Class (Nodes);
  391.          RetVal = TRUE;
  392.       }
  393.    }
  394.  
  395.    return (RetVal);
  396. }
  397.  
  398. USHORT TNodes::Read (USHORT usZone, USHORT usNet, USHORT usNode, USHORT usPoint, PSZ pszDomain)
  399. {
  400.    USHORT RetVal = FALSE, DoClose = FALSE;
  401.    CHAR Temp[64];
  402.    NODES Nodes;
  403.  
  404.    New ();
  405.  
  406.    if (fd == -1) {
  407.       sprintf (Temp, "%s.dat", DataFile);
  408.       if ((fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE)) != -1)
  409.          DoClose = TRUE;
  410.    }
  411.  
  412.    if (fd != -1) {
  413.       Addr1.Clear ();
  414.       Addr1.Add (usZone, usNet, usNode, usPoint, pszDomain);
  415.       Addr1.First ();
  416.  
  417.       lseek (fd, 0L, SEEK_SET);
  418.       while (read (fd, &Nodes, sizeof (Nodes)) == sizeof (Nodes)) {
  419.          if (!stricmp (Nodes.Address, Addr1.String)) {
  420.             RetVal = TRUE;
  421.             break;
  422.          }
  423.       }
  424.  
  425.       Addr1.Clear ();
  426.  
  427.       if (RetVal == TRUE)
  428.          Struct2Class (Nodes);
  429.    }
  430.  
  431.    if (fd != -1 && DoClose == TRUE) {
  432.       close (fd);
  433.       fd = -1;
  434.    }
  435.  
  436.    return (RetVal);
  437. }
  438.  
  439. USHORT TNodes::Read (class TAddress *lpAddress, USHORT flAddNodelist)
  440. {
  441.    USHORT RetVal = FALSE, DoClose = FALSE;
  442.    CHAR Temp[64];
  443.    NODES Nodes;
  444.  
  445.    New ();
  446.  
  447.    if (fd == -1) {
  448.       sprintf (Temp, "%s.Dat", DataFile);
  449.       if ((fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE)) != -1)
  450.          DoClose = TRUE;
  451.    }
  452.  
  453.    if (fd != -1 && lpAddress != NULL) {
  454.       lseek (fd, 0L, SEEK_SET);
  455.       while (read (fd, &Nodes, sizeof (Nodes)) == sizeof (Nodes)) {
  456.          if (!stricmp (Nodes.Address, lpAddress->String)) {
  457.             RetVal = TRUE;
  458.             break;
  459.          }
  460.       }
  461.  
  462.       if (RetVal == TRUE)
  463.          Struct2Class (Nodes);
  464.    }
  465.  
  466.    if (fd != -1 && DoClose == TRUE) {
  467.       close (fd);
  468.       fd = -1;
  469.    }
  470.  
  471.    if (flAddNodelist == TRUE) {
  472.       if (ReadNodelist (lpAddress) == TRUE) {
  473.          strcpy (Address, lpAddress->String);
  474.          RetVal = TRUE;
  475.       }
  476.    }
  477.  
  478.    return (RetVal);
  479. }
  480.  
  481. USHORT TNodes::Read (class TAddress &lpAddress, USHORT flAddNodelist)
  482. {
  483.    USHORT RetVal = FALSE, DoClose = FALSE;
  484.    CHAR Temp[64];
  485.    NODES Nodes;
  486.  
  487.    New ();
  488.  
  489.    if (fd == -1) {
  490.       sprintf (Temp, "%s.dat", DataFile);
  491.       if ((fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE)) != -1)
  492.          DoClose = TRUE;
  493.    }
  494.  
  495.    if (fd != -1) {
  496.       lseek (fd, 0L, SEEK_SET);
  497.       while (read (fd, &Nodes, sizeof (Nodes)) == sizeof (Nodes)) {
  498.          if (!stricmp (Nodes.Address, lpAddress.String)) {
  499.             RetVal = TRUE;
  500.             break;
  501.          }
  502.       }
  503.  
  504.       if (RetVal == TRUE)
  505.          Struct2Class (Nodes);
  506.    }
  507.  
  508.    if (fd != -1 && DoClose == TRUE) {
  509.       close (fd);
  510.       fd = -1;
  511.    }
  512.  
  513.    if (flAddNodelist == TRUE) {
  514.       if (ReadNodelist (lpAddress) == TRUE) {
  515.          strcpy (Address, lpAddress.String);
  516.          RetVal = TRUE;
  517.       }
  518.    }
  519.  
  520.    return (RetVal);
  521. }
  522.  
  523. USHORT TNodes::Read (PSZ pszAddress, USHORT flAddNodelist)
  524. {
  525.    class TAddress Addr;
  526.  
  527.    Addr.Parse (pszAddress);
  528.  
  529.    return (Read (Addr, flAddNodelist));
  530. }
  531.  
  532. USHORT TNodes::ReadNodelist (class TAddress &Address)
  533. {
  534.    return (ReadNodelist (&Address));
  535. }
  536.  
  537. USHORT TNodes::ReadNodelist (class TAddress *Address)
  538. {
  539.    FILE *fp, *fpText;
  540.    USHORT RetVal = FALSE, First;
  541.    ULONG Num;
  542.    CHAR Temp[128], *p;
  543.    IDXHEADER idxHead;
  544.    NODEIDX nodeIdx;
  545.  
  546.    sprintf (Temp, "%s.idx", DataFile);
  547.    if ((fp = _fsopen (Temp, "rb", SH_DENYNO)) != NULL) {
  548.       while (fread (&idxHead, sizeof (IDXHEADER), 1, fp) == 1 && RetVal == FALSE) {
  549.          for (Num = 0L; Num < idxHead.Entry && RetVal == FALSE; Num++) {
  550.             if (fread (&nodeIdx, sizeof (NODEIDX), 1, fp) != 1)
  551.                break;
  552.             if (nodeIdx.Zone == Address->Zone && nodeIdx.Net == Address->Net && (nodeIdx.Node == 0 || nodeIdx.Node == Address->Node)) {
  553.                strcpy (Temp, DataFile);
  554.                if ((p = strchr (Temp, '\0')) != NULL) {
  555.                   while (p > Temp && *p != '\\' && *p != '/')
  556.                      *p-- = '\0';
  557.                }
  558.                strcat (Temp, idxHead.Name);
  559.                if ((fpText = _fsopen (Temp, "rt", SH_DENYNO)) != NULL) {
  560.                   fseek (fpText, nodeIdx.Position, SEEK_SET);
  561.                   First = FALSE;
  562.                   while (fgets (Temp, sizeof (Temp) - 1, fpText) != NULL && RetVal == FALSE) {
  563.                      if (Temp[0] != ';') {
  564.                         if (Temp[0] != ',') {
  565.                            p = strtok (Temp, ",");
  566.                            if (!stricmp (p, "Zone") || !stricmp (p, "Region") || !stricmp (p, "Host")) {
  567.                               if (First == TRUE)
  568.                                  break;
  569.                               First = TRUE;
  570.                               p = strtok (NULL, ",");
  571.                               *p = '\0';
  572.                            }
  573.                            else
  574.                               p = strtok (NULL, ",");
  575.                         }
  576.                         else
  577.                            p = strtok (Temp, ",");
  578.  
  579.                         if (p != NULL) {
  580.                            if (Address->Node == (USHORT)atoi (p)) {
  581.                               RetVal = TRUE;
  582.                               if ((p = strtok (NULL, ",")) != NULL) {
  583.                                  if (strlen (p) > sizeof (SystemName))
  584.                                     p[sizeof (SystemName)] = '\0';
  585.                                  if (SystemName[0] == '\0') {
  586.                                     strcpy (SystemName, p);
  587.                                     while ((p = strchr (SystemName, '_')) != NULL)
  588.                                        *p = ' ';
  589.                                  }
  590.                               }
  591.                               if ((p = strtok (NULL, ",")) != NULL) {
  592.                                  if (strlen (p) > sizeof (Location))
  593.                                     p[sizeof (Location)] = '\0';
  594.                                  if (Location[0] == '\0') {
  595.                                     strcpy (Location, p);
  596.                                     while ((p = strchr (Location, '_')) != NULL)
  597.                                        *p = ' ';
  598.                                  }
  599.                               }
  600.                               if ((p = strtok (NULL, ",")) != NULL) {
  601.                                  if (strlen (p) > sizeof (SysopName))
  602.                                     p[sizeof (SysopName)] = '\0';
  603.                                  if (SysopName[0] == '\0') {
  604.                                     strcpy (SysopName, p);
  605.                                     while ((p = strchr (SysopName, '_')) != NULL)
  606.                                        *p = ' ';
  607.                                  }
  608.                               }
  609.                               if ((p = strtok (NULL, ",")) != NULL) {
  610.                                  if (strlen (p) > sizeof (Phone))
  611.                                     p[sizeof (Phone)] = '\0';
  612.                                  if (Phone[0] == '\0') {
  613.                                     strcpy (Phone, p);
  614.                                     while ((p = strchr (Phone, '_')) != NULL)
  615.                                        *p = ' ';
  616.                                  }
  617.                               }
  618.                               if ((p = strtok (NULL, ",")) != NULL) {
  619.                                  if (Speed == 0L)
  620.                                     Speed = atol (p);
  621.                               }
  622.                               if ((p = strtok (NULL, ",")) != NULL) {
  623.                                  if (strlen (p) > sizeof (Flags))
  624.                                     p[sizeof (Flags)] = '\0';
  625.                                  if (Flags[0] == '\0')
  626.                                     strcpy (Flags, p);
  627.                               }
  628.                            }
  629.                         }
  630.                      }
  631.                   }
  632.                   fclose (fpText);
  633.                }
  634.             }
  635.          }
  636.       }
  637.       fclose (fp);
  638.    }
  639.  
  640.    if (RetVal == TRUE) {
  641.       Zone = Address->Zone;
  642.       Net = Address->Net;
  643.       Node = Address->Node;
  644.       Point = Address->Point;
  645.    }
  646.  
  647.    return (RetVal);
  648. }
  649.  
  650. VOID TNodes::Update (VOID)
  651. {
  652.    USHORT DoClose = FALSE;
  653.    CHAR Temp[64];
  654.    NODES Nodes;
  655.  
  656.    if (fd == -1) {
  657.       sprintf (Temp, "%s.dat", DataFile);
  658.       if ((fd = sopen (Temp, O_RDWR|O_BINARY|O_CREAT, SH_DENYNO, S_IREAD|S_IWRITE)) != -1)
  659.          DoClose = TRUE;
  660.    }
  661.  
  662.    if (fd != -1) {
  663.       lseek (fd, 0L, SEEK_SET);
  664.       Addr1.Parse (Address);
  665.       strcpy (Address, Addr1.String);
  666.       while (read (fd, &Nodes, sizeof (Nodes)) == sizeof (Nodes)) {
  667.          if (!strcmp (Address, Nodes.Address)) {
  668.             Class2Struct (Nodes);
  669.             lseek (fd, tell (fd) - sizeof (Nodes), SEEK_SET);
  670.             write (fd, &Nodes, sizeof (Nodes));
  671.             break;
  672.          }
  673.       }
  674.    }
  675.  
  676.    if (fd != -1 && DoClose == TRUE) {
  677.       close (fd);
  678.       fd = -1;
  679.    }
  680. }
  681.  
  682. USHORT TNodes::FirstNodelist (VOID)
  683. {
  684.    USHORT RetVal = FALSE;
  685.    NODELIST *data;
  686.  
  687.    if ((data = (NODELIST *)ListData.First ()) != NULL) {
  688.       DefaultZone = data->Zone;
  689.       strcpy (Nodelist, data->Name);
  690.       strcpy (Nodediff, data->Diff);
  691.       RetVal = TRUE;
  692.    }
  693.  
  694.    return (RetVal);
  695. }
  696.  
  697. USHORT TNodes::NextNodelist (VOID)
  698. {
  699.    USHORT RetVal = FALSE;
  700.    NODELIST *data;
  701.  
  702.    if ((data = (NODELIST *)ListData.Next ()) != NULL) {
  703.       DefaultZone = data->Zone;
  704.       strcpy (Nodelist, data->Name);
  705.       strcpy (Nodediff, data->Diff);
  706.       RetVal = TRUE;
  707.    }
  708.  
  709.    return (RetVal);
  710. }
  711.  
  712. VOID TNodes::AddNodelist (PSZ name, PSZ diff, USHORT zone)
  713. {
  714.    NODELIST data;
  715.  
  716.    memset (&data, 0, sizeof (NODELIST));
  717.    data.Size = sizeof (NODELIST);
  718.    data.Zone = zone;
  719.    strcpy (data.Name, name);
  720.    strcpy (data.Diff, diff);
  721.    ListData.Add (&data, sizeof (NODELIST));
  722. }
  723.  
  724. VOID TNodes::LoadNodelist (VOID)
  725. {
  726.    int fd;
  727.    CHAR Temp[64];
  728.    NODELIST data;
  729.  
  730.    ListData.Clear ();
  731.  
  732.    strcpy (Temp, DataFile);
  733.    strcpy (&Temp[strlen (Temp) - 5], "nodelist.dat");
  734.    if ((fd = open (Temp, O_RDWR|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) != -1) {
  735.       while (read (fd, &data, sizeof (data)) == sizeof (data))
  736.          ListData.Add (&data, sizeof (data));
  737.       close (fd);
  738.    }
  739. }
  740.  
  741. VOID TNodes::SaveNodelist (VOID)
  742. {
  743.    int fd;
  744.    CHAR Temp[64];
  745.    NODELIST *data;
  746.  
  747.    strcpy (Temp, DataFile);
  748.    strcpy (&Temp[strlen (Temp) - 5], "nodelist.dat");
  749.    if ((fd = open (Temp, O_RDWR|O_BINARY|O_CREAT|O_TRUNC, S_IREAD|S_IWRITE)) != -1) {
  750.       if ((data = (NODELIST *)ListData.First ()) != NULL)
  751.          do {
  752.             data->Size = sizeof (NODELIST);
  753.             write (fd, data, sizeof (NODELIST));
  754.          } while ((data = (NODELIST *)ListData.Next ()) != NULL);
  755.       close (fd);
  756.    }
  757. }
  758.  
  759. VOID TNodes::DeleteNodelist (VOID)
  760. {
  761.    ListData.Remove ();
  762. }
  763.  
  764. // ----------------------------------------------------------------------
  765.  
  766. TNodeFlags::TNodeFlags (void)
  767. {
  768.    fdDat = -1;
  769.    strcpy (DataFile, "nodeflag.dat");
  770. }
  771.  
  772. TNodeFlags::TNodeFlags (PSZ pszDataPath)
  773. {
  774.    fdDat = -1;
  775.    strcpy (DataFile, pszDataPath);
  776.    strcat (DataFile, "nodeflag.dat");
  777.    AdjustPath (strlwr (DataFile));
  778.    List.Clear ();
  779.  
  780.    if ((fdDat = open (DataFile, O_RDWR|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) != -1) {
  781.       while (read (fdDat, &nf, sizeof (nf)) == sizeof (nf))
  782.          List.Add (&nf, sizeof (nf));
  783.       close (fdDat);
  784.    }
  785. }
  786.  
  787. TNodeFlags::~TNodeFlags (void)
  788. {
  789. }
  790.  
  791. VOID TNodeFlags::Add (VOID)
  792. {
  793.    memset (&nf, 0, sizeof (nf));
  794.    nf.Size = sizeof (nf);
  795.    strcpy (nf.Flags, Flags);
  796.    strcpy (nf.Cmd, Cmd);
  797.  
  798.    List.Add (&nf, sizeof (nf));
  799. }
  800.  
  801. VOID TNodeFlags::Delete (VOID)
  802. {
  803.    NODEFLAGS *pnf;
  804.  
  805.    List.Remove ();
  806.  
  807.    if ((pnf = (NODEFLAGS *)List.Value ()) != NULL) {
  808.       strcpy (Flags, pnf->Flags);
  809.       strcpy (Cmd, pnf->Cmd);
  810.    }
  811. }
  812.  
  813. VOID TNodeFlags::DeleteAll (VOID)
  814. {
  815.    while (List.First () != NULL)
  816.       List.Remove ();
  817. }
  818.  
  819. USHORT TNodeFlags::First (VOID)
  820. {
  821.    USHORT RetVal = FALSE;
  822.    NODEFLAGS *pnf;
  823.  
  824.    if ((pnf = (NODEFLAGS *)List.First ()) != NULL) {
  825.       strcpy (Flags, pnf->Flags);
  826.       strcpy (Cmd, pnf->Cmd);
  827.       RetVal = TRUE;
  828.    }
  829.  
  830.    return (RetVal);
  831. }
  832.  
  833. USHORT TNodeFlags::Next (VOID)
  834. {
  835.    USHORT RetVal = FALSE;
  836.    NODEFLAGS *pnf;
  837.  
  838.    if ((pnf = (NODEFLAGS *)List.Next ()) != NULL) {
  839.       strcpy (Flags, pnf->Flags);
  840.       strcpy (Cmd, pnf->Cmd);
  841.       RetVal = TRUE;
  842.    }
  843.  
  844.    return (RetVal);
  845. }
  846.  
  847. USHORT TNodeFlags::Read (PSZ pszFlag)
  848. {
  849.    USHORT RetVal = FALSE;
  850.    CHAR Temp1[64], Temp2[64], *p;
  851.    NODEFLAGS *pnf;
  852.  
  853.    if ((pnf = (NODEFLAGS *)List.First ()) != NULL) {
  854.       strcpy (Temp1, pszFlag);
  855.       strupr (Temp1);
  856.  
  857.       do {
  858.          strcpy (Temp2, pnf->Flags);
  859.          if ((p = strtok (strupr (Temp2), " ,")) != NULL)
  860.             do {
  861.                if (strstr (Temp1, p) != NULL) {
  862.                   strcpy (Flags, pnf->Flags);
  863.                   strcpy (Cmd, pnf->Cmd);
  864.                   RetVal = TRUE;
  865.                   break;
  866.                }
  867.             } while ((p = strtok (NULL, " ,")) != NULL);
  868.       } while (RetVal == FALSE && (pnf = (NODEFLAGS *)List.Next ()) != NULL);
  869.    }
  870.  
  871.    return (RetVal);
  872. }
  873.  
  874. USHORT TNodeFlags::Read (USHORT)
  875. {
  876.    USHORT RetVal = FALSE;
  877.  
  878.    return (RetVal);
  879. }
  880.  
  881. VOID TNodeFlags::Update (VOID)
  882. {
  883.    NODEFLAGS *pnf;
  884.  
  885.    if ((pnf = (NODEFLAGS *)List.Value ()) != NULL) {
  886.       memset (pnf, 0, sizeof (NODEFLAGS));
  887.       pnf->Size = sizeof (NODEFLAGS);
  888.       strcpy (pnf->Flags, Flags);
  889.       strcpy (pnf->Cmd, Cmd);
  890.    }
  891. }
  892.  
  893. VOID TNodeFlags::Save (VOID)
  894. {
  895.    NODEFLAGS *pnf;
  896.  
  897.    if ((fdDat = open (DataFile, O_RDWR|O_BINARY|O_CREAT|O_TRUNC, S_IREAD|S_IWRITE)) != -1) {
  898.       if ((pnf = (NODEFLAGS *)List.First ()) != NULL)
  899.          do {
  900.             write (fdDat, pnf, sizeof (NODEFLAGS));
  901.          } while ((pnf = (NODEFLAGS *)List.Next ()) != NULL);
  902.       close (fdDat);
  903.    }
  904. }
  905.  
  906.