home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d5xx / d534 / term.lha / Term / Source.LZH / UpdatePhone.c < prev    next >
C/C++ Source or Header  |  1991-07-06  |  12KB  |  582 lines
  1. /* $Revision Header * Header built automatically - do not edit! *************
  2.  *
  3.  *    (C) Copyright 1990 by Olaf 'Olsen' Barthel & MXM
  4.  *
  5.  *    Name .....: UpdatePhone.c
  6.  *    Created ..: Saturday 23-Mar-91 22:07
  7.  *    Revision .: 0
  8.  *
  9.  *    Date            Author          Comment
  10.  *    =========       ========        ====================
  11.  *    23-Mar-91       Olsen           Created this file!
  12.  *
  13.  * $Revision Header ********************************************************/
  14.  
  15. struct TermInfo
  16. {
  17.     UWORD    Version;
  18.     UWORD    Revision;
  19. };
  20.  
  21. extern LONG TermVersion,TermRevision;
  22. extern UBYTE TermName[],TermDate[],TermString[];
  23.  
  24. struct Configuration
  25. {
  26.     /* Serial Preferences. */
  27.  
  28.     ULONG    BaudRate;
  29.     BYTE    BitsPerChar;
  30.     BYTE    Parity;
  31.     BYTE    StopBits;
  32.     BYTE    Handshaking;
  33.     BYTE    Duplex;
  34.     BYTE    HighSpeed;
  35.     ULONG    BreakLength;
  36.     UBYTE    SerialDevice[40];
  37.     LONG    UnitNumber;
  38.  
  39.     /* Modem Preferences. */
  40.  
  41.     UBYTE    ModemInit[80];
  42.     UBYTE     ModemExit[80];
  43.     UBYTE    DialPrefix[80];
  44.     LONG    RedialDelay;
  45.     LONG    DialRetries;
  46.     LONG    DialTimeout;
  47.     BYTE    ConnectAutoBaud;
  48.     UBYTE    NoCarrier[16];
  49.     UBYTE    Connect[16];
  50.     UBYTE    Error[16];
  51.     UBYTE    Voice[16];
  52.     UBYTE    Ring[16];
  53.     UBYTE    Busy[16];
  54.     UBYTE    Okay[16];
  55.  
  56.     /* Transfer Preferences. */
  57.  
  58.     UBYTE    Protocol[40];
  59.  
  60.     /* Startup macro. */
  61.  
  62.     UBYTE    StartupMacro[256];
  63.  
  64.     /* Macro Preferences. */
  65.  
  66.     UBYTE    MacroFile[256];
  67.  
  68.     /* Screen Preferences. */
  69.  
  70.     ULONG    DisplayMode;
  71.     UWORD    Colours[16];
  72.     BYTE    MakeScreenPublic;
  73.     BYTE    ShanghaiWindows;
  74.  
  75.     /* Terminal Preferences. */
  76.  
  77.     BYTE    CaptureFilter;
  78.     BYTE    DestructiveBackspace;
  79.     BYTE    AudibleBell;
  80.     BYTE    VisibleBell;
  81.     BYTE    EightyColumns;
  82.     BYTE    SendCR;
  83.     BYTE    SendLF;
  84.     BYTE    ColourMode;
  85.     BYTE    Emulation;
  86.     BYTE    Font;
  87. };
  88.  
  89.     /* A phone book entry. */
  90.  
  91. struct PhoneEntry
  92. {
  93.     UBYTE            Name[40];
  94.     UBYTE            Number[40];
  95.     UBYTE            Password[40];
  96.  
  97.     LONG            PayPerUnit;
  98.     LONG            MinPerUnit;
  99.  
  100.     struct Configuration    Config;
  101. };
  102.  
  103. struct NewConfiguration
  104. {
  105.     /* Serial Preferences. */
  106.  
  107.     ULONG    BaudRate;
  108.     BYTE    BitsPerChar;
  109.     BYTE    Parity;
  110.     BYTE    StopBits;
  111.     BYTE    Handshaking;
  112.     BYTE    Duplex;
  113.     BYTE    HighSpeed;
  114.     ULONG    BreakLength;
  115.     UBYTE    SerialDevice[40];
  116.     LONG    UnitNumber;
  117.  
  118.     /* Modem Preferences. */
  119.  
  120.     UBYTE    ModemInit[80];
  121.     UBYTE     ModemExit[80];
  122.     UBYTE     ModemHangup[80];
  123.     UBYTE    DialPrefix[80];
  124.     LONG    RedialDelay;
  125.     LONG    DialRetries;
  126.     LONG    DialTimeout;
  127.     BYTE    ConnectAutoCapture;
  128.     BYTE    ConnectAutoBaud;
  129.     BYTE    LogActions;
  130.     UBYTE    NoCarrier[16];
  131.     UBYTE    Connect[16];
  132.     UBYTE    Voice[16];
  133.     UBYTE    Ring[16];
  134.     UBYTE    Busy[16];
  135.  
  136.     /* Transfer Preferences. */
  137.  
  138.     UBYTE    Protocol[40];
  139.  
  140.     /* Startup macro. */
  141.  
  142.     UBYTE    StartupMacro[256];
  143.  
  144.     /* Macro Preferences. */
  145.  
  146.     UBYTE    MacroFile[256];
  147.  
  148.     /* Screen Preferences. */
  149.  
  150.     ULONG    DisplayMode;
  151.     UWORD    Colours[16];
  152.     BYTE    MakeScreenPublic;
  153.     BYTE    ShanghaiWindows;
  154.  
  155.     /* Terminal Preferences. */
  156.  
  157.     BYTE    CaptureFilter;
  158.     BYTE    DestructiveBackspace;
  159.     BYTE    AudibleBell;
  160.     BYTE    VisibleBell;
  161.     BYTE    EightyColumns;
  162.     BYTE    DisableBlinking;
  163.     BYTE    SendCR;
  164.     BYTE    SendLF;
  165.     BYTE    ColourMode;
  166.     BYTE    Emulation;
  167.     BYTE    Font;
  168.  
  169.     /* Emulation control. */
  170.  
  171.     BYTE    CursorApp;
  172.     BYTE    FontScale;
  173.     BYTE    JumpScroll;
  174.     BYTE    AutoWrap;
  175.     BYTE    CursorWrap;
  176.     BYTE    NewLine;
  177.     BYTE    InsertChar;
  178.     BYTE    NumApp;
  179.  
  180.     /* Path Preferences. */
  181.  
  182.     UBYTE    DefaultStorage[256];
  183.  
  184.     UBYTE    TextUploadPath[256];
  185.     UBYTE    TextDownloadPath[256];
  186.  
  187.     UBYTE    ASCIIUploadPath[256];
  188.     UBYTE    ASCIIDownloadPath[256];
  189.  
  190.     UBYTE    BinaryUploadPath[256];
  191.     UBYTE    BinaryDownloadPath[256];
  192.  
  193.     UBYTE    CapturePath[256];
  194.     UBYTE    LogFile[256];
  195.     UBYTE    Editor[256];
  196.     UBYTE    BeepSound[256];
  197. };
  198.  
  199. struct NewPhoneEntry
  200. {
  201.     UBYTE            Name[30];
  202.     UBYTE            Number[40];
  203.     UBYTE            Password[40];
  204.  
  205.     LONG            PayPerUnit[2];
  206.     LONG            SecPerUnit[2];
  207.     LONG            TimeOfDay[2];
  208.  
  209.     struct NewConfiguration    Config;
  210. };
  211.  
  212. LONG __saveds        Main(VOID);
  213. struct PhoneEntry **    CreatePhonebook(LONG Size,LONG *AllocSize,BYTE CreateEntries);
  214. VOID            DeletePhonebook(struct PhoneEntry **PhoneBook,LONG Size,BYTE FreeEntries);
  215. BYTE            SavePhonebook(UBYTE *Name);
  216. BYTE            LoadPhonebook(UBYTE *Name);
  217.  
  218. struct PhoneEntry    **Phonebook;
  219. LONG             PhoneSize;
  220.  
  221. LONG             NumPhoneEntries;
  222.  
  223. struct ExecBase        *SysBase;
  224. struct DosLibrary    *DOSBase;
  225. struct Library        *IFFParseBase;
  226.  
  227. LONG __saveds
  228. Main()
  229. {
  230.     SysBase = *(struct ExecBase **)4;
  231.  
  232.     if(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library",36))
  233.     {
  234.         if(IFFParseBase = (struct Library *)OpenLibrary("iffparse.library",0))
  235.         {
  236.             UBYTE **ArgArray;
  237.  
  238.             if(ArgArray = (UBYTE **)AllocVec(sizeof(UBYTE *),MEMF_PUBLIC | MEMF_CLEAR))
  239.             {
  240.                 struct RDArgs *ArgsPtr;
  241.  
  242.                 if(ArgsPtr = (struct RDArgs *)ReadArgs("File",(LONG *)ArgArray,NULL))
  243.                 {
  244.                     if(ArgArray[0])
  245.                     {
  246.                         if(LoadPhonebook(ArgArray[0]))
  247.                         {
  248.                             if(!SavePhonebook(ArgArray[0]))
  249.                                 Printf("\33[1mUpdatePhone:\33[0m Couldn't save file \"%s\"!\a\n",ArgArray[0]);
  250.                         }
  251.                         else
  252.                             Printf("\33[1mUpdatePhone:\33[0m Couldn't load file \"%s\"!\a\n",ArgArray[0]);
  253.  
  254.                         if(Phonebook && PhoneSize)
  255.                             DeletePhonebook(Phonebook,PhoneSize,TRUE);
  256.                     }
  257.  
  258.                     FreeArgs(ArgsPtr);
  259.                 }
  260.  
  261.                 FreeVec(ArgArray);
  262.             }
  263.  
  264.             CloseLibrary(IFFParseBase);
  265.         }
  266.  
  267.         CloseLibrary(DOSBase);
  268.     }
  269.  
  270.     return(RETURN_OK);
  271. }
  272.  
  273.     /* Convert(struct PhoneEntry *Src):
  274.      *
  275.      *    Convert a phonebook entry.
  276.      */
  277.  
  278. struct NewPhoneEntry *
  279. Convert(struct PhoneEntry *Src)
  280. {
  281.     STATIC struct NewPhoneEntry Dst;
  282.  
  283.     CopyMem(Src -> Name,Dst . Name,30);
  284.  
  285.     Dst . Name[29] = 0;
  286.  
  287.     strcpy(Dst . Number,Src -> Number);
  288.  
  289.     strcpy(Dst . Password,Src -> Password);
  290.  
  291.     Dst . PayPerUnit[0] = Src -> PayPerUnit;
  292.     Dst . SecPerUnit[0] = Src -> MinPerUnit * 60;
  293.  
  294.     Dst . Config . BaudRate            = Src -> Config . BaudRate;
  295.     Dst . Config . BitsPerChar        = Src -> Config . BitsPerChar;
  296.     Dst . Config . Parity            = Src -> Config . Parity;
  297.     Dst . Config . StopBits            = Src -> Config . StopBits;
  298.     Dst . Config . Handshaking        = Src -> Config . Handshaking;
  299.     Dst . Config . Duplex            = Src -> Config . Duplex;
  300.     Dst . Config . HighSpeed        = Src -> Config . HighSpeed;
  301.     Dst . Config . BreakLength        = Src -> Config . BreakLength;
  302.  
  303.     strcpy(Dst . Config . SerialDevice,Src -> Config . SerialDevice);
  304.  
  305.     Dst . Config . UnitNumber        = Src -> Config . UnitNumber;
  306.  
  307.     strcpy(Dst . Config . ModemInit,Src -> Config . ModemInit);
  308.     strcpy(Dst . Config . ModemExit,Src -> Config . ModemExit);
  309.     strcpy(Dst . Config . ModemHangup,"~~~~~~+++~~ATH0\\r");
  310.     strcpy(Dst . Config . DialPrefix,Src -> Config . DialPrefix);
  311.  
  312.     Dst . Config . RedialDelay        = Src -> Config . RedialDelay;
  313.     Dst . Config . DialRetries        = Src -> Config . DialRetries;
  314.     Dst . Config . DialTimeout        = Src -> Config . DialTimeout;
  315.     Dst . Config . ConnectAutoBaud        = Src -> Config . ConnectAutoBaud;
  316.  
  317.     strcpy(Dst . Config . NoCarrier,Src -> Config . NoCarrier);
  318.     strcpy(Dst . Config . Connect,Src -> Config . Connect);
  319.     strcpy(Dst . Config . Voice,Src -> Config . Voice);
  320.     strcpy(Dst . Config . Ring,Src -> Config . Ring);
  321.     strcpy(Dst . Config . Busy,Src -> Config . Busy);
  322.  
  323.     strcpy(Dst . Config . Protocol,Src -> Config . Protocol);
  324.  
  325.     strcpy(Dst . Config . StartupMacro,Src -> Config . StartupMacro);
  326.  
  327.     strcpy(Dst . Config . MacroFile,Src -> Config . MacroFile);
  328.  
  329.     Dst . Config . DisplayMode        = Src -> Config . DisplayMode;
  330.  
  331.     CopyMem(Src -> Config . Colours,Dst . Config . Colours,sizeof(UWORD) * 16);
  332.  
  333.     Dst . Config . MakeScreenPublic        = Src -> Config . MakeScreenPublic;
  334.     Dst . Config . ShanghaiWindows        = Src -> Config . ShanghaiWindows;
  335.  
  336.     Dst . Config . CaptureFilter        = Src -> Config . CaptureFilter;
  337.     Dst . Config . DestructiveBackspace    = Src -> Config . DestructiveBackspace;
  338.     Dst . Config . AudibleBell        = Src -> Config . AudibleBell;
  339.     Dst . Config . VisibleBell        = Src -> Config . VisibleBell;
  340.     Dst . Config . EightyColumns        = Src -> Config . EightyColumns;
  341.     Dst . Config . SendCR            = Src -> Config . SendCR;
  342.     Dst . Config . SendLF            = Src -> Config . SendLF;
  343.     Dst . Config . ColourMode        = Src -> Config . ColourMode;
  344.     Dst . Config . Emulation        = Src -> Config . Emulation;
  345.     Dst . Config . Font            = Src -> Config . Font;
  346.  
  347.     strcpy(Dst . Config . DefaultStorage,"ENVARC:sys");
  348.  
  349.     return(&Dst);
  350. }
  351.  
  352.     /* CreatePhonebook(LONG Size,LONG *AllocSize,BYTE CreateEntries):
  353.      *
  354.      *    Create a new phone entry array (so-called phone book).
  355.      */
  356.  
  357. struct PhoneEntry **
  358. CreatePhonebook(LONG Size,LONG *AllocSize,BYTE CreateEntries)
  359. {
  360.     struct PhoneEntry **PhoneEntry = NULL;
  361.  
  362.     if(Size)
  363.     {
  364.             /* Round the number of phone entries to a
  365.              * multiple of eight.
  366.              */
  367.  
  368.         *AllocSize = (((Size + 7) >> 3) << 3);
  369.  
  370.             /* Create the list of pointers. */
  371.  
  372.         if(PhoneEntry = (struct PhoneEntry **)AllocMem(*AllocSize * sizeof(struct PhoneEntry *),MEMF_PUBLIC|MEMF_CLEAR))
  373.         {
  374.                 /* And create some entries if necessary. */
  375.  
  376.             if(CreateEntries)
  377.             {
  378.                 LONG i;
  379.  
  380.                 for(i = 0 ; i < Size ; i++)
  381.                 {
  382.                     if(!(PhoneEntry[i] = (struct PhoneEntry *)AllocMem(sizeof(struct PhoneEntry),MEMF_PUBLIC|MEMF_CLEAR)))
  383.                     {
  384.                         LONG j;
  385.  
  386.                         for(j = 0 ; j < i ; j++)
  387.                             FreeMem(PhoneEntry[j],sizeof(struct PhoneEntry));
  388.  
  389.                         FreeMem(PhoneEntry,*AllocSize * sizeof(struct PhoneEntry *));
  390.  
  391.                         return(NULL);
  392.                     }
  393.                 }
  394.             }
  395.         }
  396.     }
  397.  
  398.     return(PhoneEntry);
  399. }
  400.  
  401.     /* DeletePhonebook(struct PhoneEntry **PhoneBook,LONG Size,BYTE FreeEntries):
  402.      *
  403.      *    Deallocates a given phone book and its entries if necessary.
  404.      */
  405.  
  406. VOID
  407. DeletePhonebook(struct PhoneEntry **PhoneBook,LONG Size,BYTE FreeEntries)
  408. {
  409.     if(FreeEntries)
  410.     {
  411.         LONG i;
  412.  
  413.         for(i = 0 ; i < Size ; i++)
  414.         {
  415.             if(PhoneBook[i])
  416.                 FreeMem(PhoneBook[i],sizeof(struct PhoneEntry));
  417.         }
  418.     }
  419.  
  420.     FreeMem(PhoneBook,Size * sizeof(struct PhoneEntry *));
  421. }
  422.  
  423.     /* SavePhonebook(UBYTE *Name):
  424.      *
  425.      *    Save the current phone book to a disk file.
  426.      */
  427.  
  428. BYTE
  429. SavePhonebook(UBYTE *Name)
  430. {
  431.     struct IFFHandle    *Handle;
  432.     BYTE             Success = FALSE;
  433.     LONG             i;
  434.  
  435.     if(Phonebook && NumPhoneEntries)
  436.     {
  437.         if(Handle = AllocIFF())
  438.         {
  439.             if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  440.             {
  441.                 InitIFFasDOS(Handle);
  442.  
  443.                 if(!OpenIFF(Handle,IFFF_WRITE))
  444.                 {
  445.                     if(!PushChunk(Handle,'TERM','FORM',IFFSIZE_UNKNOWN))
  446.                     {
  447.                         if(!PushChunk(Handle,0,'VERS',IFFSIZE_UNKNOWN))
  448.                         {
  449.                             struct TermInfo TermInfo;
  450.  
  451.                             TermInfo . Version    = TermVersion;
  452.                             TermInfo . Revision    = TermRevision;
  453.  
  454.                             if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  455.                             {
  456.                                 if(PopChunk(Handle))
  457.                                     Success = FALSE;
  458.                                 else
  459.                                 {
  460.                                     if(!PushChunk(Handle,0,'DIAL',IFFSIZE_UNKNOWN))
  461.                                     {
  462.                                         if(WriteChunkBytes(Handle,&NumPhoneEntries,sizeof(LONG)) == sizeof(LONG))
  463.                                         {
  464.                                             Success = TRUE;
  465.  
  466.                                             for(i = 0 ; i < NumPhoneEntries ; i++)
  467.                                             {
  468.                                                 if(WriteChunkBytes(Handle,Convert(Phonebook[i]),sizeof(struct NewPhoneEntry)) != sizeof(struct NewPhoneEntry))
  469.                                                 {
  470.                                                     Success = FALSE;
  471.                                                     break;
  472.                                                 }
  473.                                             }
  474.                                         }
  475.  
  476.                                         if(PopChunk(Handle))
  477.                                             Success = FALSE;
  478.                                     }
  479.                                 }
  480.                             }
  481.                         }
  482.  
  483.                         if(PopChunk(Handle))
  484.                             Success = FALSE;
  485.                     }
  486.  
  487.                     CloseIFF(Handle);
  488.                 }
  489.  
  490.                 Close(Handle -> iff_Stream);
  491.             }
  492.  
  493.             FreeIFF(Handle);
  494.         }
  495.     }
  496.  
  497.     if(Success)
  498.         SetProtection(Name,FIBF_EXECUTE);
  499.  
  500.     return(Success);
  501. }
  502.  
  503.     /* LoadPhonebook(UBYTE *Name):
  504.      *
  505.      *    Restore a phone book from a disk file.
  506.      */
  507.  
  508. BYTE
  509. LoadPhonebook(UBYTE *Name)
  510. {
  511.     struct PhoneEntry    **PrivatePhonebook;
  512.     LONG             PrivatePhoneSize;
  513.     LONG             Size,i;
  514.     struct IFFHandle    *Handle;
  515.     BYTE             Success = FALSE;
  516.  
  517.     if(Handle = AllocIFF())
  518.     {
  519.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  520.         {
  521.             InitIFFasDOS(Handle);
  522.  
  523.             if(!OpenIFF(Handle,IFFF_READ))
  524.             {
  525.                 if(!StopChunk(Handle,'TERM','DIAL'))
  526.                 {
  527.                     if(!ParseIFF(Handle,IFFPARSE_SCAN))
  528.                     {
  529.                         if(ReadChunkRecords(Handle,&Size,sizeof(LONG),1))
  530.                         {
  531.                             if(Size)
  532.                             {
  533.                                 if(PrivatePhonebook = CreatePhonebook(Size,&PrivatePhoneSize,TRUE))
  534.                                 {
  535.                                     for(i = 0 ; i < Size ; i++)
  536.                                     {
  537.                                         if(!ReadChunkRecords(Handle,PrivatePhonebook[i],sizeof(struct PhoneEntry),1))
  538.                                         {
  539.                                             if(i)
  540.                                                 Size = i - 1;
  541.                                             else
  542.                                                 Size = 0;
  543.  
  544.                                             break;
  545.                                         }
  546.                                     }
  547.  
  548.                                     if(Size)
  549.                                     {
  550.                                         if(Phonebook)
  551.                                             DeletePhonebook(Phonebook,PhoneSize,TRUE);
  552.  
  553.                                         Phonebook = PrivatePhonebook;
  554.                                         PhoneSize = PrivatePhoneSize;
  555.  
  556.                                         NumPhoneEntries = Size;
  557.  
  558.                                         Success = TRUE;
  559.                                     }
  560.                                     else
  561.                                     {
  562.                                         DeletePhonebook(PrivatePhonebook,PrivatePhoneSize,TRUE);
  563.                                         Success = FALSE;
  564.                                     }
  565.                                 }
  566.                             }
  567.                         }
  568.                     }
  569.                 }
  570.  
  571.                 CloseIFF(Handle);
  572.             }
  573.  
  574.             Close(Handle -> iff_Stream);
  575.         }
  576.  
  577.         FreeIFF(Handle);
  578.     }
  579.  
  580.     return(Success);
  581. }
  582.