home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / OldConfig.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  19.6 KB  |  890 lines
  1. /*
  2. **    OldConfig.c
  3. **
  4. **    Old configuration processing routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14. struct OldSerialSettings
  15. {
  16.     ULONG    BaudRate;
  17.     ULONG    BreakLength;
  18.     ULONG    SerialBufferSize;
  19.  
  20.     UBYTE    SerialDevice[256];
  21.     LONG    UnitNumber;
  22.  
  23.     BOOLEAN    BitsPerChar;
  24.     BOOLEAN    Parity;
  25.     BOOLEAN    StopBits;
  26.     BOOLEAN    HandshakingProtocol;
  27.     BOOLEAN    Duplex;
  28.  
  29.     BOOLEAN    xONxOFF;
  30.     BOOLEAN    HighSpeed;
  31.     BOOLEAN    Shared;
  32.     BOOLEAN    StripBit8;
  33.     BOOLEAN    CheckCarrier;
  34.     BOOLEAN    PassThrough;
  35. };
  36.  
  37. struct OldModemSettings
  38. {
  39.     UBYTE    ModemInit[80];
  40.     UBYTE     ModemExit[80];
  41.     UBYTE     ModemHangup[80];
  42.     UBYTE    DialPrefix[80];
  43.     UBYTE    DialSuffix[80];
  44.  
  45.     UBYTE    NoCarrier[16];
  46.     UBYTE    NoDialTone[16];
  47.     UBYTE    Connect[16];
  48.     UBYTE    Voice[16];
  49.     UBYTE    Ring[16];
  50.     UBYTE    Busy[16];
  51.  
  52.     LONG    RedialDelay;
  53.     LONG    DialRetries;
  54.     LONG    DialTimeout;
  55.     BOOLEAN    ConnectAutoBaud;
  56.     BOOLEAN    DropDTR;
  57. };
  58.  
  59. struct OldCommandSettings
  60. {
  61.     UBYTE    StartupMacro[256];
  62.     UBYTE    LogoffMacro[256];
  63.     UBYTE    UploadMacro[256];
  64.     UBYTE    DownloadMacro[256];
  65. };
  66.  
  67. struct OldScreenSettings
  68. {
  69.     ULONG    DisplayMode;
  70.     WORD    ColourMode;
  71.     UWORD    Colours[16];
  72.     UBYTE    FontName[256];
  73.     WORD    FontHeight;
  74.  
  75.     BOOLEAN    MakeScreenPublic;
  76.     BOOLEAN    ShanghaiWindows;
  77.  
  78.     BOOLEAN    Blinking;
  79.     BOOLEAN    FasterLayout;
  80.     BOOLEAN    TitleBar;
  81.     BOOLEAN    StatusLine;
  82. };
  83.  
  84. struct OldTerminalSettings
  85. {
  86.     BOOLEAN    BellMode;
  87.     BOOLEAN    AlertMode;
  88.     BOOLEAN    EmulationMode;
  89.     BOOLEAN    FontMode;
  90.  
  91.     BOOLEAN    SendCR;
  92.     BOOLEAN    SendLF;
  93.     BOOLEAN    ReceiveCR;
  94.     BOOLEAN    ReceiveLF;
  95.  
  96.     UWORD    NumColumns,
  97.         NumLines;
  98.  
  99.     UBYTE    KeyMapFileName[256];
  100.     UBYTE    EmulationFileName[256];
  101.     UBYTE    BeepFileName[256];
  102.  
  103.     UBYTE    TextFontName[256];
  104.     WORD    TextFontHeight;
  105. };
  106.  
  107. struct OldPathSettings
  108. {
  109.     UBYTE    ASCIIUploadPath[256];
  110.     UBYTE    ASCIIDownloadPath[256];
  111.  
  112.     UBYTE    TextUploadPath[256];
  113.     UBYTE    TextDownloadPath[256];
  114.  
  115.     UBYTE    BinaryUploadPath[256];
  116.     UBYTE    BinaryDownloadPath[256];
  117.  
  118.     UBYTE    DefaultStorage[256];
  119.  
  120.     UBYTE    Editor[256];
  121. };
  122.  
  123. struct OldMiscSettings
  124. {
  125.     BOOLEAN    Priority;
  126.     BOOLEAN    BackupConfig;
  127.  
  128.     BOOLEAN    OpenFastMacroPanel;
  129.     BOOLEAN    ReleaseDevice;
  130.  
  131.     BOOLEAN    TransferServer;
  132.     BOOLEAN    EmulationServer;
  133.  
  134.     BOOLEAN    OverridePath;
  135.     BOOLEAN    AutoUpload;
  136.     BOOLEAN    SetArchivedBit;
  137.     BOOLEAN    IdentifyFiles;
  138. };
  139.  
  140. struct OldClipSettings
  141. {
  142.     WORD    ClipboardUnit;
  143.  
  144.     WORD    LineDelay,
  145.         CharDelay;
  146.  
  147.     UBYTE    InsertPrefix[80];
  148.     UBYTE    InsertSuffix[80];
  149. };
  150.  
  151. struct OldCaptureSettings
  152. {
  153.     BOOLEAN    LogActions;
  154.     BOOLEAN    LogCall;
  155.     UBYTE    LogFileName[256];
  156.  
  157.     LONG    MaxBufferSize;
  158.     BOOLEAN    BufferEnabled;
  159.  
  160.     BOOLEAN    ConnectAutoCapture;
  161.     BOOLEAN    CaptureFilterMode;
  162.     UBYTE    CapturePath[256];
  163. };
  164.  
  165. struct OldFileSettings
  166. {
  167.     UBYTE    ProtocolFileName[256];
  168.     UBYTE    TranslationFileName[256];
  169.     UBYTE    MacroFileName[256];
  170.     UBYTE    CursorFileName[256];
  171.     UBYTE    FastMacroFileName[256];
  172. };
  173.  
  174. struct OldEmulationSettings
  175. {
  176.     BOOLEAN    CursorMode;
  177.     BOOLEAN    NumericMode;
  178.  
  179.     BOOLEAN    CursorWrap;
  180.     BOOLEAN    LineWrap;
  181.  
  182.     BOOLEAN    InsertMode;
  183.     BOOLEAN    NewLineMode;
  184.  
  185.     BOOLEAN    FontScale;
  186.     BOOLEAN    ScrollMode;
  187.     BOOLEAN    DestructiveBackspace;
  188.     BOOLEAN    SwapBSDelete;
  189.     BOOLEAN    PrinterEnabled;
  190.     BOOLEAN    Pad;
  191.  
  192.     UBYTE    AnswerBack[80];
  193. };
  194.  
  195. struct OldConfiguration
  196. {
  197.     struct OldSerialSettings    SerialConfig;
  198.     struct OldModemSettings        ModemConfig;
  199.     struct OldScreenSettings    ScreenConfig;
  200.     struct OldTerminalSettings    TerminalConfig;
  201.     struct OldEmulationSettings    EmulationConfig;
  202.     struct OldClipSettings        ClipConfig;
  203.     struct OldCaptureSettings    CaptureConfig;
  204.     struct OldCommandSettings    CommandConfig;
  205.     struct OldMiscSettings        MiscConfig;
  206.     struct OldPathSettings        PathConfig;
  207.     struct OldFileSettings        FileConfig;
  208. };
  209.  
  210. struct OldPhoneHeader
  211. {
  212.     UBYTE    Name[40],        /* BBS name. */
  213.         Number[60],        /* Phone number. */
  214.         Comment[40];        /* Comment. */
  215.  
  216.     UBYTE    UserName[30],        /* User name for this BSS. */
  217.         Password[30];        /* Password for user name. */
  218. };
  219.  
  220.     /* ConvertHeader():
  221.      *
  222.      *    Convert old style phone book header to new style
  223.      *    phone book header.
  224.      */
  225.  
  226. STATIC VOID
  227. ConvertHeader(struct OldPhoneHeader *OldHeader,struct PhoneHeader *NewHeader)
  228. {
  229.     strcpy(NewHeader -> Name,    OldHeader -> Name);
  230.     strcpy(NewHeader -> Number,    OldHeader -> Number);
  231.     strcpy(NewHeader -> Comment,    OldHeader -> Comment);
  232.  
  233.     strcpy(NewHeader -> UserName,    OldHeader -> UserName);
  234.     strcpy(NewHeader -> Password,    OldHeader -> Password);
  235. }
  236.  
  237.     /* ConvertConfig():
  238.      *
  239.      *    Convert old style configuration to new style configuration.
  240.      */
  241.  
  242. STATIC BOOL
  243. ConvertConfig(struct OldConfiguration *OldConfig,struct Configuration *NewConfig,BOOL IsPhonebook)
  244. {
  245.     if(CreateConfigEntry(NewConfig,PREF_SERIAL))
  246.     {
  247.         ResetConfigEntry(NewConfig,PREF_SERIAL,FALSE);
  248.  
  249.         CopyMem(&OldConfig -> SerialConfig,NewConfig -> SerialConfig,MIN(sizeof(struct SerialSettings),sizeof(struct OldSerialSettings)));
  250.  
  251.         FixOldConfig(NewConfig,PREF_SERIAL,IsPhonebook,2,4);
  252.     }
  253.     else
  254.         return(FALSE);
  255.  
  256.     if(CreateConfigEntry(NewConfig,PREF_MODEM))
  257.     {
  258.         ResetConfigEntry(NewConfig,PREF_MODEM,FALSE);
  259.  
  260.         CopyMem(&OldConfig -> ModemConfig,NewConfig -> ModemConfig,MIN(sizeof(struct ModemSettings),sizeof(struct OldModemSettings)));
  261.  
  262.         FixOldConfig(NewConfig,PREF_MODEM,IsPhonebook,2,4);
  263.     }
  264.     else
  265.         return(FALSE);
  266.  
  267.     if(CreateConfigEntry(NewConfig,PREF_COMMAND))
  268.     {
  269.         ResetConfigEntry(NewConfig,PREF_COMMAND,FALSE);
  270.  
  271.         CopyMem(&OldConfig -> CommandConfig,NewConfig -> CommandConfig,MIN(sizeof(struct CommandSettings),sizeof(struct OldCommandSettings)));
  272.  
  273.         FixOldConfig(NewConfig,PREF_COMMAND,IsPhonebook,2,4);
  274.     }
  275.     else
  276.         return(FALSE);
  277.  
  278.     if(CreateConfigEntry(NewConfig,PREF_SCREEN))
  279.     {
  280.         ResetConfigEntry(NewConfig,PREF_SCREEN,FALSE);
  281.  
  282.         CopyMem(&OldConfig -> ScreenConfig,NewConfig -> ScreenConfig,MIN(sizeof(struct ScreenSettings),sizeof(struct OldScreenSettings)));
  283.  
  284.         FixOldConfig(NewConfig,PREF_SCREEN,IsPhonebook,2,4);
  285.     }
  286.     else
  287.         return(FALSE);
  288.  
  289.     if(CreateConfigEntry(NewConfig,PREF_TERMINAL))
  290.     {
  291.         ResetConfigEntry(NewConfig,PREF_TERMINAL,FALSE);
  292.  
  293.         CopyMem(&OldConfig -> TerminalConfig,NewConfig -> TerminalConfig,MIN(sizeof(struct TerminalSettings),sizeof(struct OldTerminalSettings)));
  294.  
  295.         FixOldConfig(NewConfig,PREF_TERMINAL,IsPhonebook,2,4);
  296.     }
  297.     else
  298.         return(FALSE);
  299.  
  300.     if(CreateConfigEntry(NewConfig,PREF_PATH))
  301.     {
  302.         ResetConfigEntry(NewConfig,PREF_PATH,FALSE);
  303.  
  304.         CopyMem(&OldConfig -> PathConfig,NewConfig -> PathConfig,MIN(sizeof(struct PathSettings),sizeof(struct OldPathSettings)));
  305.  
  306.         FixOldConfig(NewConfig,PREF_PATH,IsPhonebook,2,4);
  307.     }
  308.     else
  309.         return(FALSE);
  310.  
  311.     if(CreateConfigEntry(NewConfig,PREF_MISC))
  312.     {
  313.         ResetConfigEntry(NewConfig,PREF_MISC,FALSE);
  314.  
  315.         CopyMem(&OldConfig -> MiscConfig,NewConfig -> MiscConfig,MIN(sizeof(struct MiscSettings),sizeof(struct OldMiscSettings)));
  316.  
  317.         FixOldConfig(NewConfig,PREF_MISC,IsPhonebook,2,4);
  318.     }
  319.     else
  320.         return(FALSE);
  321.  
  322.     if(CreateConfigEntry(NewConfig,PREF_CLIP))
  323.     {
  324.         ResetConfigEntry(NewConfig,PREF_CLIP,FALSE);
  325.  
  326.         CopyMem(&OldConfig -> ClipConfig,NewConfig -> ClipConfig,MIN(sizeof(struct ClipSettings),sizeof(struct OldClipSettings)));
  327.  
  328.         FixOldConfig(NewConfig,PREF_CLIP,IsPhonebook,2,4);
  329.     }
  330.     else
  331.         return(FALSE);
  332.  
  333.     if(CreateConfigEntry(NewConfig,PREF_CAPTURE))
  334.     {
  335.         ResetConfigEntry(NewConfig,PREF_CAPTURE,FALSE);
  336.  
  337.         CopyMem(&OldConfig -> CaptureConfig,NewConfig -> CaptureConfig,MIN(sizeof(struct CaptureSettings),sizeof(struct OldCaptureSettings)));
  338.  
  339.         strcpy(NewConfig -> CaptureConfig -> CallLogFileName,NewConfig -> CaptureConfig -> LogFileName);
  340.  
  341.         AddPart(NewConfig -> CaptureConfig -> CallLogFileName,"term-call.log",MAX_FILENAME_LENGTH);
  342.  
  343.         FixOldConfig(NewConfig,PREF_CAPTURE,IsPhonebook,2,4);
  344.     }
  345.     else
  346.         return(FALSE);
  347.  
  348.     if(CreateConfigEntry(NewConfig,PREF_FILE))
  349.     {
  350.         LONG i,Error = 0;
  351.  
  352.         ResetConfigEntry(NewConfig,PREF_FILE,FALSE);
  353.  
  354.         CopyMem(&OldConfig -> FileConfig,NewConfig -> FileConfig,MIN(sizeof(struct FileSettings),sizeof(struct OldFileSettings)));
  355.  
  356.         FixOldConfig(NewConfig,PREF_FILE,IsPhonebook,2,4);
  357.  
  358.         for(i = PREF_TRANSLATIONFILENAME ; i <= PREF_FASTMACROFILENAME ; i++)
  359.         {
  360.             if(!CreateConfigEntry(NewConfig,i))
  361.             {
  362.                 Error = ERROR_NO_FREE_STORE;
  363.                 break;
  364.             }
  365.         }
  366.  
  367.         if(!Error)
  368.         {
  369.             strcpy(NewConfig -> TranslationFileName,    NewConfig -> FileConfig -> TranslationFileName);
  370.             strcpy(NewConfig -> MacroFileName,        NewConfig -> FileConfig -> MacroFileName);
  371.             strcpy(NewConfig -> CursorFileName,        NewConfig -> FileConfig -> CursorFileName);
  372.             strcpy(NewConfig -> FastMacroFileName,        NewConfig -> FileConfig -> FastMacroFileName);
  373.  
  374.             DeleteConfigEntry(NewConfig,PREF_FILE);
  375.         }
  376.         else
  377.         {
  378.             SetIoErr(Error);
  379.             return(FALSE);
  380.         }
  381.     }
  382.     else
  383.         return(FALSE);
  384.  
  385.     if(CreateConfigEntry(NewConfig,PREF_EMULATION))
  386.     {
  387.         ResetConfigEntry(NewConfig,PREF_EMULATION,FALSE);
  388.  
  389.         CopyMem(&OldConfig -> EmulationConfig,NewConfig -> EmulationConfig,MIN(sizeof(struct EmulationSettings),sizeof(struct OldEmulationSettings)));
  390.  
  391.         FixOldConfig(NewConfig,PREF_EMULATION,IsPhonebook,2,4);
  392.     }
  393.     else
  394.         return(FALSE);
  395.  
  396.     FinalFix(NewConfig,IsPhonebook,2,4);
  397.  
  398.     return(TRUE);
  399. }
  400.  
  401.     /* LoadOldPhonebook(STRPTR Name):
  402.      *
  403.      *    Restore a phone book from a disk file.
  404.      */
  405.  
  406. BOOL
  407. LoadOldPhonebook(STRPTR Name,PhonebookHandle *BookHandle)
  408. {
  409.     STATIC ULONG Stops[6 * 2] =
  410.     {
  411.         ID_TERM,ID_VERS,
  412.         ID_TERM,ID_DIAL,
  413.         ID_TERM,ID_PREF,
  414.         ID_TERM,ID_DATE,
  415.         ID_TERM,ID_PHON,
  416.         ID_TERM,ID_PSWD
  417.     };
  418.  
  419.     struct PhoneEntry    **PrivatePhonebook;
  420.     LONG             PrivatePhoneSize = 0;
  421.     LONG             Size = 0,Count = 0,Last = -1;
  422.     struct IFFHandle    *Handle;
  423.     BOOL             Success = FALSE;
  424.     struct ContextNode    *Chunk;
  425.     BOOL             LastHadTime    = TRUE,
  426.                  HadPassword    = FALSE;
  427.     struct TimeDateNode    *TimeDateNode;
  428.     struct OldConfiguration    *OldConfig;
  429.     struct OldPhoneHeader    *OldHeader;
  430.     LONG             Error;
  431.  
  432.     if(OldConfig = (struct OldConfiguration *)AllocVecPooled(sizeof(struct OldConfiguration) + sizeof(struct OldPhoneHeader),MEMF_ANY))
  433.     {
  434.         OldHeader = (struct OldPhoneHeader *)(OldConfig + 1);
  435.  
  436.         if(Handle = AllocIFF())
  437.         {
  438.             if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  439.             {
  440.                 InitIFFasDOS(Handle);
  441.  
  442.                 if(!(Error = OpenIFF(Handle,IFFF_READ)))
  443.                 {
  444.                     if(!(Error = StopChunks(Handle,(LONG *)Stops,6)))
  445.                     {
  446.                         while(!ParseIFF(Handle,IFFPARSE_SCAN))
  447.                         {
  448.                             Chunk = CurrentChunk(Handle);
  449.  
  450.                             if(Chunk -> cn_ID == ID_VERS)
  451.                             {
  452.                                 struct TermInfo TermInfo;
  453.  
  454.                                 if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  455.                                 {
  456.                                     if(TermInfo . Version != 2 || TermInfo . Revision != 4)
  457.                                     {
  458.                                         Error = ERR_OUTDATED;
  459.  
  460.                                         break;
  461.                                     }
  462.                                 }
  463.                                 else
  464.                                 {
  465.                                     Error = IoErr();
  466.  
  467.                                     break;
  468.                                 }
  469.                             }
  470.  
  471.                             if(Chunk -> cn_ID == ID_PSWD)
  472.                             {
  473.                                 UBYTE DummyBuffer[20];
  474.  
  475.                                 HadPassword = TRUE;
  476.  
  477.                                 if(ReadChunkBytes(Handle,DummyBuffer,20) == 20)
  478.                                 {
  479.                                     if(BookHandle)
  480.                                     {
  481.                                         if(BookHandle -> PhonePasswordUsed)
  482.                                         {
  483.                                             if(!memcmp(BookHandle -> PhonePassword,DummyBuffer,20))
  484.                                                 continue;
  485.                                         }
  486.                                     }
  487.                                     else
  488.                                     {
  489.                                         if(PhonePasswordUsed)
  490.                                         {
  491.                                             if(!memcmp(PhonePassword,DummyBuffer,20))
  492.                                                 continue;
  493.                                         }
  494.                                     }
  495.  
  496.                                     memset(SharedBuffer,0,21);
  497.  
  498.                                     if(GetString(FALSE,TRUE,21,LocaleString(MSG_PHONEPANEL_PLEASE_ENTER_PASSWORD_TXT),SharedBuffer))
  499.                                     {
  500.                                         UBYTE AnotherBuffer[20];
  501.  
  502.                                         Encrypt(SharedBuffer,20,AnotherBuffer,SharedBuffer,strlen(SharedBuffer));
  503.  
  504.                                         if(!memcmp(DummyBuffer,AnotherBuffer,20))
  505.                                         {
  506.                                             if(BookHandle)
  507.                                             {
  508.                                                 CopyMem(DummyBuffer,BookHandle -> PhonePassword,20);
  509.  
  510.                                                 BookHandle -> PhonePasswordUsed = TRUE;
  511.                                             }
  512.                                             else
  513.                                             {
  514.                                                 CopyMem(DummyBuffer,PhonePassword,20);
  515.  
  516.                                                 PhonePasswordUsed = TRUE;
  517.                                             }
  518.  
  519.                                             continue;
  520.                                         }
  521.                                         else
  522.                                         {
  523.                                             ShowRequest(Window,LocaleString(MSG_TERMPHONE_WRONG_PASSWORD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT),Name);
  524.  
  525.                                             break;
  526.                                         }
  527.                                     }
  528.                                     else
  529.                                         break;
  530.                                 }
  531.                                 else
  532.                                 {
  533.                                     Error = IoErr();
  534.  
  535.                                     break;
  536.                                 }
  537.                             }
  538.  
  539.                             if(Chunk -> cn_ID == ID_DIAL)
  540.                             {
  541.                                 if(ReadChunkBytes(Handle,&Size,sizeof(LONG)) == sizeof(LONG))
  542.                                 {
  543.                                     if(!(PrivatePhonebook = CreatePhonebook(Size,&PrivatePhoneSize,TRUE)))
  544.                                         break;
  545.                                 }
  546.                                 else
  547.                                 {
  548.                                     Error = IoErr();
  549.  
  550.                                     break;
  551.                                 }
  552.                             }
  553.  
  554.                             if(Chunk -> cn_ID == ID_PHON)
  555.                             {
  556.                                 LONG Size = MIN(sizeof(struct OldPhoneHeader),Chunk -> cn_Size);
  557.  
  558.                                 if(ReadChunkBytes(Handle,OldHeader,Size) == Size)
  559.                                 {
  560.                                     if(BookHandle)
  561.                                     {
  562.                                         if(BookHandle -> PhonePasswordUsed)
  563.                                             Decrypt((UBYTE *)OldHeader,Size,(UBYTE *)OldHeader,BookHandle -> PhonePassword,20);
  564.                                     }
  565.                                     else
  566.                                     {
  567.                                         if(PhonePasswordUsed)
  568.                                             Decrypt((UBYTE *)OldHeader,Size,(UBYTE *)OldHeader,PhonePassword,20);
  569.                                     }
  570.                                 }
  571.                                 else
  572.                                 {
  573.                                     Error = IoErr();
  574.  
  575.                                     break;
  576.                                 }
  577.                             }
  578.  
  579.                             if(Chunk -> cn_ID == ID_PREF)
  580.                             {
  581.                                 if(Last != -1)
  582.                                 {
  583.                                     if(!LastHadTime)
  584.                                     {
  585.                                         if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
  586.                                             AddTail((struct List *)&PrivatePhonebook[Last] -> TimeDateList,&TimeDateNode -> VanillaNode);
  587.                                     }
  588.                                 }
  589.  
  590.                                 if(Size && Count < Size)
  591.                                 {
  592.                                     LONG LastSize = MIN(Chunk -> cn_Size,sizeof(struct OldConfiguration));
  593.  
  594.                                     if(BookHandle)
  595.                                         BookHandle -> PhonePasswordUsed = HadPassword;
  596.                                     else
  597.                                         PhonePasswordUsed = HadPassword;
  598.  
  599.                                     if(ReadChunkBytes(Handle,OldConfig,LastSize) == LastSize)
  600.                                     {
  601.                                         if(BookHandle)
  602.                                         {
  603.                                             if(BookHandle -> PhonePasswordUsed)
  604.                                                 Decrypt((UBYTE *)OldConfig,LastSize,(UBYTE *)OldConfig,BookHandle -> PhonePassword,20);
  605.                                         }
  606.                                         else
  607.                                         {
  608.                                             if(PhonePasswordUsed)
  609.                                                 Decrypt((UBYTE *)OldConfig,LastSize,(UBYTE *)OldConfig,PhonePassword,20);
  610.                                         }
  611.  
  612.                                         if(ConvertConfig(OldConfig,PrivatePhonebook[Count] -> Config,TRUE))
  613.                                         {
  614.                                             memset(PrivatePhonebook[Count] -> Header,0,sizeof(struct PhoneHeader));
  615.  
  616.                                             ConvertHeader(OldHeader,PrivatePhonebook[Count] -> Header);
  617.  
  618.                                             Last = Count;
  619.  
  620.                                             PrivatePhonebook[Count] -> Count = -1;
  621.  
  622.                                             Count++;
  623.  
  624.                                             LastHadTime = FALSE;
  625.                                         }
  626.                                         else
  627.                                         {
  628.                                             if(Count)
  629.                                                 Size = Count - 1;
  630.                                             else
  631.                                                 Size = 0;
  632.  
  633.                                             break;
  634.                                         }
  635.                                     }
  636.                                     else
  637.                                     {
  638.                                         Error = IoErr();
  639.  
  640.                                         if(Count)
  641.                                             Size = Count - 1;
  642.                                         else
  643.                                             Size = 0;
  644.  
  645.                                         break;
  646.                                     }
  647.                                 }
  648.                             }
  649.  
  650.                             if(Chunk -> cn_ID == ID_DATE)
  651.                             {
  652.                                 if(Last != -1)
  653.                                 {
  654.                                     LONG Count = (Chunk -> cn_Size - sizeof(struct TimeDateHeader)) / sizeof(struct TimeDateOld);
  655.  
  656.                                     if(TimeDateNode = CreateTimeDateNode(-1,-1,"",Count))
  657.                                     {
  658.                                         struct TimeDateOld *Old;
  659.  
  660.                                         if(Old = (struct TimeDateOld *)AllocVecPooled(sizeof(struct TimeDateOld) * Count,MEMF_ANY))
  661.                                         {
  662.                                             if(ReadChunkBytes(Handle,&TimeDateNode -> Header,sizeof(struct TimeDateHeader)) == sizeof(struct TimeDateHeader))
  663.                                             {
  664.                                                 if(ReadChunkBytes(Handle,Old,sizeof(struct TimeDateOld) * Count) == sizeof(struct TimeDateOld) * Count)
  665.                                                 {
  666.                                                     LONG i;
  667.  
  668.                                                     for(i = 0 ; i < Count ; i++)
  669.                                                         ConvertTimeDate(&Old[i],&TimeDateNode->Table[i]);
  670.  
  671.                                                     AdaptTimeDateNode(TimeDateNode);
  672.  
  673.                                                     AddTail((struct List *)&PrivatePhonebook[Last] -> TimeDateList,&TimeDateNode -> VanillaNode);
  674.  
  675.                                                     LastHadTime = TRUE;
  676.  
  677.                                                     FreeVecPooled(Old);
  678.                                                 }
  679.                                                 else
  680.                                                 {
  681.                                                     FreeVecPooled(Old);
  682.  
  683.                                                     Error = IoErr();
  684.  
  685.                                                     FreeTimeDateNode(TimeDateNode);
  686.                                                 }
  687.                                             }
  688.                                             else
  689.                                             {
  690.                                                 FreeVecPooled(Old);
  691.  
  692.                                                 Error = IoErr();
  693.  
  694.                                                 FreeTimeDateNode(TimeDateNode);
  695.                                             }
  696.                                         }
  697.                                         else
  698.                                         {
  699.                                             Error = ERROR_NO_FREE_STORE;
  700.  
  701.                                             FreeTimeDateNode(TimeDateNode);
  702.                                         }
  703.                                     }
  704.                                 }
  705.                             }
  706.                         }
  707.  
  708.                         if(Size)
  709.                         {
  710.                             if(!LastHadTime && Last != -1)
  711.                             {
  712.                                 if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
  713.                                     AddTail((struct List *)&PrivatePhonebook[Last] -> TimeDateList,&TimeDateNode -> VanillaNode);
  714.                             }
  715.  
  716.                             if(!BookHandle)
  717.                             {
  718.                                 struct timeval Now;
  719.                                 LONG i;
  720.  
  721.                                 GetSysTime(&Now);
  722.  
  723.                                 PhonebookID = Now . tv_secs;
  724.  
  725.                                 NewList((struct List *)&PhoneGroupList);
  726.  
  727.                                 if(Phonebook)
  728.                                     DeletePhonebook(Phonebook,PhoneSize,TRUE);
  729.  
  730.                                 Phonebook = PrivatePhonebook;
  731.                                 PhoneSize = PrivatePhoneSize;
  732.                                 PhonebookAutoDial = FALSE;
  733.                                 PhonebookAutoExit = FALSE;
  734.                                 PhonebookDefaultGroup = 0;
  735.  
  736.                                 NumPhoneEntries = Size;
  737.  
  738.                                 for(i = 0 ; i < NumPhoneEntries ; i++)
  739.                                 {
  740.                                     Phonebook[i] -> Header -> ID = PhonebookID++;
  741.                                     StripGlobals(Phonebook[i] -> Config);
  742.                                 }
  743.                             }
  744.                             else
  745.                             {
  746.                                 struct timeval Now;
  747.                                 LONG i;
  748.  
  749.                                 GetSysTime(&Now);
  750.  
  751.                                 BookHandle -> PhonebookID = Now . tv_secs;
  752.  
  753.                                 if(BookHandle -> PhoneGroupList)
  754.                                     NewList((struct List *)BookHandle -> PhoneGroupList);
  755.  
  756.                                 if(BookHandle -> Phonebook)
  757.                                     DeletePhonebook(BookHandle -> Phonebook,BookHandle -> PhoneSize,TRUE);
  758.  
  759.                                 BookHandle -> Phonebook = PrivatePhonebook;
  760.                                 BookHandle -> PhoneSize = PrivatePhoneSize;
  761.                                 BookHandle -> DefaultGroup = 0;
  762.  
  763.                                 BookHandle -> NumPhoneEntries = Size;
  764.                                 BookHandle -> AutoDial = FALSE;
  765.                                 BookHandle -> AutoExit = FALSE;
  766.  
  767.                                 for(i = 0 ; i < BookHandle -> NumPhoneEntries ; i++)
  768.                                 {
  769.                                     BookHandle -> Phonebook[i] -> Header -> ID = BookHandle -> PhonebookID++;
  770.                                     StripGlobals(BookHandle -> Phonebook[i] -> Config);
  771.                                 }
  772.                             }
  773.  
  774.                             Success = TRUE;
  775.                         }
  776.                         else
  777.                         {
  778.                             if(PrivatePhoneSize)
  779.                             {
  780.                                 DeletePhonebook(PrivatePhonebook,PrivatePhoneSize,TRUE);
  781.  
  782.                                 Success = FALSE;
  783.                             }
  784.                         }
  785.  
  786.                         FreeDialList(TRUE);
  787.                     }
  788.  
  789.                     CloseIFF(Handle);
  790.                 }
  791.  
  792.                 Close(Handle -> iff_Stream);
  793.             }
  794.             else
  795.                 Error = IoErr();
  796.  
  797.             FreeIFF(Handle);
  798.         }
  799.         else
  800.             Error = ERR_NO_MEM;
  801.  
  802.         FreeVecPooled(OldConfig);
  803.     }
  804.     else
  805.         Error = ERR_NO_MEM;
  806.  
  807.     if(Error)
  808.         SetIoErr(Error);
  809.  
  810.     return(Success);
  811. }
  812.  
  813.     /* ReadConfig(STRPTR Name,struct Configuration *Config):
  814.      *
  815.      *    Read the configuration file, very much the same as ReadIFFData().
  816.      */
  817.  
  818. BOOL
  819. ReadOldConfig(STRPTR Name,struct Configuration *Config)
  820. {
  821.     struct IFFHandle    *Handle;
  822.     BOOL             Success = FALSE;
  823.     struct StoredProperty    *Prop;
  824.     struct TermInfo        *TermInfo;
  825.     struct OldConfiguration    *OldConfig;
  826.     LONG             Error;
  827.  
  828.     if(OldConfig = (struct OldConfiguration *)AllocVecPooled(sizeof(struct OldConfiguration),MEMF_ANY))
  829.     {
  830.         if(Handle = AllocIFF())
  831.         {
  832.             if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  833.             {
  834.                 InitIFFasDOS(Handle);
  835.  
  836.                 if(!(Error = OpenIFF(Handle,IFFF_READ)))
  837.                 {
  838.                     if(!(Error = PropChunks(Handle,(LONG *)VersionProps,1)))
  839.                     {
  840.                         if(!(Error = StopChunk(Handle,ID_TERM,ID_PREF)))
  841.                         {
  842.                             if(!ParseIFF(Handle,IFFPARSE_SCAN))
  843.                             {
  844.                                 if(Prop = FindProp(Handle,ID_TERM,ID_VERS))
  845.                                 {
  846.                                     TermInfo = (struct TermInfo *)Prop -> sp_Data;
  847.  
  848.                                     if(TermInfo -> Version == 2 && TermInfo -> Revision == 4)
  849.                                     {
  850.                                         struct ContextNode *Chunk = CurrentChunk(Handle);
  851.  
  852.                                         if(ReadChunkRecords(Handle,OldConfig,MIN(Chunk -> cn_Size,sizeof(struct OldConfiguration)),1) == 1)
  853.                                         {
  854.                                             if(ConvertConfig(OldConfig,Config,FALSE))
  855.                                                 Success = TRUE;
  856.                                         }
  857.                                         else
  858.                                             Error = IoErr();
  859.                                     }
  860.                                     else
  861.                                         Error = ERR_OUTDATED;
  862.                                 }
  863.                             }
  864.                         }
  865.                     }
  866.  
  867.                     CloseIFF(Handle);
  868.                 }
  869.  
  870.                 Close(Handle -> iff_Stream);
  871.             }
  872.             else
  873.                 Error = IoErr();
  874.  
  875.             FreeIFF(Handle);
  876.         }
  877.         else
  878.             Error = ERR_NO_MEM;
  879.  
  880.         FreeVecPooled(OldConfig);
  881.     }
  882.     else
  883.         Error = ERR_NO_MEM;
  884.  
  885.     if(Error)
  886.         SetIoErr(Error);
  887.  
  888.     return(Success);
  889. }
  890.