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