external/openurl/library/prefs.c

   1 /***************************************************************************
   2
   3  openurl.library - universal URL display and browser launcher library
   4  Copyright (C) 1998-2005 by Troels Walsted Hansen, et al.
   5  Copyright (C) 2005-2009 by openurl.library Open Source Team
   6
   7  This library is free software; it has been placed in the public domain
   8  and you can freely redistribute it and/or modify it. Please note, however,
   9  that some components may be under the LGPL or GPL license.
  10
  11  This library is distributed in the hope that it will be useful,
  12  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14
  15  openurl.library project: http://sourceforge.net/projects/openurllib/
  16
  17  $Id$
  18
  19 ***************************************************************************/
  20
  21 #include "lib.h"
  22
  23 #include <prefs/prefhdr.h>
  24
  25 #include "debug.h"
  26
  27 /**************************************************************************/
  28
  29 #define ID_BRWS MAKE_ID('B','R','W','S')
  30 #define ID_MLRS MAKE_ID('M','L','R','S')
  31 #define ID_FTPS MAKE_ID('F','T','P','S')
  32 #define ID_FLGS MAKE_ID('F','L','G','S')
  33 #define ID_DEFS MAKE_ID('D','E','F','S')
  34
  35 #define BRWS_SIZE (sizeof(struct URL_BrowserNode)-sizeof(struct MinNode))
  36 #define MLRS_SIZE (sizeof(struct URL_MailerNode)-sizeof(struct MinNode))
  37 #define FTPS_SIZE (sizeof(struct URL_FTPNode)-sizeof(struct MinNode))
  38 #define FLGS_SIZE (sizeof(ULONG))
  39 #define DEFS_SIZE (4 * sizeof(ULONG))
  40
  41 /**************************************************************************/
  42
  43 struct URL_Prefs *copyPrefs(struct URL_Prefs *old)
  44 {
  45   struct URL_Prefs *new = NULL;
  46
  47   ENTER();
  48
  49   if(old->up_Version == PREFS_VERSION)
  50   {
  51     if((new = allocArbitrateVecPooled(sizeof(struct URL_Prefs))) != NULL)
  52     {
  53       ULONG res;
  54
  55       new->up_Version = PREFS_VERSION;
  56       new->up_Flags   = old->up_Flags;
  57
  58       NewList((struct List *)&new->up_BrowserList);
  59       NewList((struct List *)&new->up_MailerList);
  60       NewList((struct List *)&new->up_FTPList);
  61
  62       if((res = copyList((struct List *)&new->up_BrowserList,(struct List *)&old->up_BrowserList,sizeof(struct URL_BrowserNode))))
  63       {
  64         new->up_DefShow         = old->up_DefShow;
  65         new->up_DefBringToFront = old->up_DefBringToFront;
  66         new->up_DefNewWindow    = old->up_DefNewWindow;
  67         new->up_DefLaunch       = old->up_DefLaunch;
  68
  69         if((res = copyList((struct List *)&new->up_MailerList,(struct List *)&old->up_MailerList,sizeof(struct URL_MailerNode))))
  70           res = copyList((struct List *)&new->up_FTPList,(struct List *)&old->up_FTPList,sizeof(struct URL_FTPNode));
  71       }
  72
  73       if(res == FALSE)
  74       {
  75         URL_FreePrefsA(new, NULL);
  76         new = NULL;
  77       }
  78     }
  79   }
  80
  81   return(new);
  82   return new;
  83 }
  84
  85 /**************************************************************************/
  86
  87 void initPrefs(struct URL_Prefs *p)
  88 {
  89   ENTER();
  90
  91   memset(p,0,sizeof(*p));
  92
  93   p->up_Version = PREFS_VERSION;
  94
  95   NewList((struct List *)&p->up_BrowserList);
  96   NewList((struct List *)&p->up_MailerList);
  97   NewList((struct List *)&p->up_FTPList);
  98
  99   LEAVE();
 100 }
 101
 102 /**************************************************************************/
 103
 104 void setDefaultPrefs(struct URL_Prefs *p)
 105 {
 106   struct URL_BrowserNode *bn;
 107   struct URL_MailerNode  *mn;
 108   struct URL_FTPNode     *fn;
 109
 110   ENTER();
 111
 112   initPrefs(p);
 113
 114   p->up_Flags = DEF_FLAGS;
 115
 116   p->up_DefShow         = DEF_DefShow;
 117   p->up_DefBringToFront = DEF_DefBringToFront;
 118   p->up_DefNewWindow    = DEF_DefNewWindow;
 119   p->up_DefLaunch       = DEF_DefLaunch;
 120
 121   /* Browsers: OWB */
 122   if(!(bn = allocArbitrateVecPooled(sizeof(struct URL_BrowserNode))))
 123   {
 124     LEAVE();
 125     return;
 126   }
 127
 128   bn->ubn_Flags = UNF_DISABLED;
 129   strlcpy(bn->ubn_Name,"OWB", sizeof(bn->ubn_Name));
 130   strlcpy(bn->ubn_Path,"OWB \"%u\"", sizeof(bn->ubn_Path));
 131   strlcpy(bn->ubn_Port,"OWB", sizeof(bn->ubn_Port));
 132   strlcpy(bn->ubn_ShowCmd,"", sizeof(bn->ubn_ShowCmd));
 133   strlcpy(bn->ubn_ToFrontCmd,"SCREENTOFRONT", sizeof(bn->ubn_ToFrontCmd));
 134   strlcpy(bn->ubn_OpenURLCmd,"OPENURL \"%u\"", sizeof(bn->ubn_OpenURLCmd));
 135   strlcpy(bn->ubn_OpenURLWCmd,"OPENURL \"%u\"", sizeof(bn->ubn_OpenURLWCmd));
 136   AddTail((struct List *)(&p->up_BrowserList), (struct Node *)(bn));
 137
 138   /* Browsers: NetSurf */
 139   if(!(bn = allocArbitrateVecPooled(sizeof(struct URL_BrowserNode))))
 140   {
 141     LEAVE();
 142     return;
 143   }
 144
 145   bn->ubn_Flags = UNF_DISABLED;
 146   strlcpy(bn->ubn_Name, "NetSurf", sizeof(bn->ubn_Name));
 147   strlcpy(bn->ubn_Path, "NetSurf \"%u\"", sizeof(bn->ubn_Path));
 148   strlcpy(bn->ubn_Port, "NETSURF", sizeof(bn->ubn_Port));
 149   strlcpy(bn->ubn_ShowCmd, "", sizeof(bn->ubn_ShowCmd));
 150   strlcpy(bn->ubn_ToFrontCmd, "TOFRONT", sizeof(bn->ubn_ToFrontCmd));
 151   strlcpy(bn->ubn_OpenURLCmd, "OPEN \"%u\"", sizeof(bn->ubn_OpenURLCmd));
 152   strlcpy(bn->ubn_OpenURLWCmd, "OPEN \"%u\" NEW", sizeof(bn->ubn_OpenURLWCmd));
 153   AddTail((struct List *)(&p->up_BrowserList), (struct Node *)(bn));
 154
 155   /* Browsers: IBrowse */
 156   if(!(bn = allocArbitrateVecPooled(sizeof(struct URL_BrowserNode))))
 157   {
 158     LEAVE();
 159     return;
 160   }
 161
 162   bn->ubn_Flags = UNF_DISABLED;
 163   strlcpy(bn->ubn_Name,"IBrowse", sizeof(bn->ubn_Name));
 164   strlcpy(bn->ubn_Path,"IBrowse \"%u\"", sizeof(bn->ubn_Path));
 165   strlcpy(bn->ubn_Port,"IBROWSE", sizeof(bn->ubn_Port));
 166   strlcpy(bn->ubn_ShowCmd,"SHOW", sizeof(bn->ubn_ShowCmd));
 167   strlcpy(bn->ubn_ToFrontCmd,"SCREENTOFRONT", sizeof(bn->ubn_ToFrontCmd));
 168   strlcpy(bn->ubn_OpenURLCmd,"GOTOURL \"%u\"", sizeof(bn->ubn_OpenURLCmd));
 169   strlcpy(bn->ubn_OpenURLWCmd,"NEWWINDOW \"%u\"", sizeof(bn->ubn_OpenURLWCmd));
 170   AddTail((struct List *)(&p->up_BrowserList), (struct Node *)(bn));
 171
 172   /* Browsers: AWeb */
 173   if(!(bn = allocArbitrateVecPooled(sizeof(struct URL_BrowserNode))))
 174   {
 175     LEAVE();
 176     return;
 177   }
 178
 179   bn->ubn_Flags = UNF_DISABLED;
 180   strlcpy(bn->ubn_Name,"AWeb", sizeof(bn->ubn_Name));
 181   strlcpy(bn->ubn_Path,"AWeb \"%u\"", sizeof(bn->ubn_Path));
 182   strlcpy(bn->ubn_Port,"AWEB", sizeof(bn->ubn_Port));
 183   strlcpy(bn->ubn_ShowCmd,"ICONIFY SHOW", sizeof(bn->ubn_ShowCmd));
 184   strlcpy(bn->ubn_ToFrontCmd,"SCREENTOFRONT", sizeof(bn->ubn_ToFrontCmd));
 185   strlcpy(bn->ubn_OpenURLCmd,"OPEN \"%u\"", sizeof(bn->ubn_OpenURLCmd));
 186   strlcpy(bn->ubn_OpenURLWCmd,"NEW \"%u\"", sizeof(bn->ubn_OpenURLWCmd));
 187   AddTail((struct List *)(&p->up_BrowserList),(struct Node *)(bn));
 188
 189   /* Browsers: Voyager */
 190   if(!(bn = allocArbitrateVecPooled(sizeof(struct URL_BrowserNode))))
 191   {
 192     LEAVE();
 193     return;
 194   }
 195
 196   bn->ubn_Flags = UNF_DISABLED;
 197   strcpy(bn->ubn_Name,"Voyager");
 198   if(GetVar("Vapor/Voyager_LASTUSEDDIR",bn->ubn_Path,sizeof(bn->ubn_Path),GVF_GLOBAL_ONLY)>0)
 199     AddPart(bn->ubn_Path,"V \"%u\"", sizeof(bn->ubn_Path));
 200   else
 201     strlcpy(bn->ubn_Path,"V \"%u\"", sizeof(bn->ubn_Path));
 202   strlcpy(bn->ubn_Port,"VOYAGER", sizeof(bn->ubn_Port));
 203   strlcpy(bn->ubn_ShowCmd,"SHOW", sizeof(bn->ubn_ShowCmd));
 204   strlcpy(bn->ubn_ToFrontCmd,"SCREENTOFRONT", sizeof(bn->ubn_ToFrontCmd));
 205   strlcpy(bn->ubn_OpenURLCmd,"OPENURL \"%u\"", sizeof(bn->ubn_OpenURLCmd));
 206   strlcpy(bn->ubn_OpenURLWCmd,"OPENURL \"%u\" NEWWIN", sizeof(bn->ubn_OpenURLWCmd));
 207   AddTail((struct List *)(&p->up_BrowserList),(struct Node *)(bn));
 208
 209   /* Mailers: YAM */
 210   if(!(mn = allocArbitrateVecPooled(sizeof(struct URL_MailerNode))))
 211   {
 212     LEAVE();
 213     return;
 214   }
 215
 216   mn->umn_Flags = UNF_DISABLED;
 217   strlcpy(mn->umn_Name,"YAM", sizeof(mn->umn_Name));
 218   strlcpy(mn->umn_Path,"YAM MAILTO=\"%a\" SUBJECT=\"%s\" LETTER=\"%f\"", sizeof(mn->umn_Path));
 219   strlcpy(mn->umn_Port,"YAM", sizeof(mn->umn_Port));
 220   strlcpy(mn->umn_ShowCmd,"SHOW", sizeof(mn->umn_ShowCmd));
 221   strlcpy(mn->umn_ToFrontCmd,"SCREENTOFRONT", sizeof(mn->umn_ToFrontCmd));
 222   strlcpy(mn->umn_WriteMailCmd,"MAILWRITE;WRITETO \"%a\";WRITESUBJECT \"%s\";WRITEEDITOR \"CLEAR\";WRITEEDITOR \"TEXT %b\"", sizeof(mn->umn_WriteMailCmd));
 223   AddTail((struct List *)(&p->up_MailerList),(struct Node *)(mn));
 224
 225   /* Mailers: SimpleMail */
 226   if(!(mn = allocArbitrateVecPooled(sizeof(struct URL_MailerNode))))
 227   {
 228     LEAVE();
 229     return;
 230   }
 231
 232   mn->umn_Flags = UNF_DISABLED;
 233   strlcpy(mn->umn_Name,"SimpleMail", sizeof(mn->umn_Name));
 234   strlcpy(mn->umn_Path,"SimpleMail MAILTO=\"%a\" SUBJECT=\"%s\"", sizeof(mn->umn_Path));
 235   strlcpy(mn->umn_Port,"SIMPLEMAIL", sizeof(mn->umn_Port));
 236   strlcpy(mn->umn_ShowCmd,"SHOW", sizeof(mn->umn_ShowCmd));
 237   strlcpy(mn->umn_ToFrontCmd,"SCREENTOFRONT", sizeof(mn->umn_ToFrontCmd));
 238   strlcpy(mn->umn_WriteMailCmd,"MAILWRITE MAILTO=\"%a\" SUBJECT=\"%s\"", sizeof(mn->umn_WriteMailCmd));
 239   AddTail((struct List *)(&p->up_MailerList),(struct Node *)(mn));
 240
 241   /* Mailers: MicroDot II */
 242   if(!(mn = allocArbitrateVecPooled(sizeof(struct URL_MailerNode))))
 243   {
 244     LEAVE();
 245     return;
 246   }
 247
 248   mn->umn_Flags = UNF_DISABLED;
 249   strlcpy(mn->umn_Name,"MicroDot II", sizeof(mn->umn_Name));
 250   if(GetVar("Vapor/MD2_LASTUSEDDIR",mn->umn_Path, sizeof(mn->umn_Path),GVF_GLOBAL_ONLY)<0)
 251     *mn->umn_Path = 0;
 252   AddPart(mn->umn_Path,"MicroDot TO=\"%a\" SUBJECT=\"%s\" CONTENTS=\"%f\"", sizeof(mn->umn_Path));
 253   strlcpy(mn->umn_Port,"MD", sizeof(mn->umn_Port));
 254   strlcpy(mn->umn_ShowCmd,"SHOW", sizeof(mn->umn_ShowCmd));
 255   strlcpy(mn->umn_WriteMailCmd,"NEWMSGWINDOW TO=\"%a\" SUBJECT=\"%s\" CONTENTS=\"%f\"", sizeof(mn->umn_WriteMailCmd));
 256   AddTail((struct List *)(&p->up_MailerList),(struct Node *)(mn));
 257
 258   /* Mailers: lola */
 259   if(!(mn = allocArbitrateVecPooled(sizeof(struct URL_MailerNode))))
 260   {
 261     LEAVE();
 262     return;
 263   }
 264
 265   mn->umn_Flags = UNF_DISABLED;
 266   strlcpy(mn->umn_Name,"lola", sizeof(mn->umn_Name));
 267   strlcpy(mn->umn_Path,"lola TO=\"%a\" SUBJECT=\"%s\" TEXT=\"%b\" CX_POPUP CX_POPKEY=\"control alt l\"", sizeof(mn->umn_Path));
 268   strlcpy(mn->umn_Port,"LOLA", sizeof(mn->umn_Port));
 269   strlcpy(mn->umn_ShowCmd,"SHOW", sizeof(mn->umn_ShowCmd));
 270   strlcpy(mn->umn_WriteMailCmd,"FILL TO=\"%a\" SUBJECT=\"%s\" TEXT=\"%b\"", sizeof(mn->umn_WriteMailCmd));
 271   AddTail((struct List *)(&p->up_MailerList),(struct Node *)(mn));
 272
 273   /* FTP: AmiFTP */
 274   if(!(fn = allocArbitrateVecPooled(sizeof(struct URL_FTPNode))))
 275   {
 276     LEAVE();
 277     return;
 278   }
 279
 280   fn->ufn_Flags = UNF_DISABLED;
 281   strlcpy(fn->ufn_Name,"AmiFTP", sizeof(fn->ufn_Name));
 282   strlcpy(fn->ufn_Path,"AmiFTP \"%a\"", sizeof(fn->ufn_Path));
 283   strlcpy(fn->ufn_Port,"AMIFTP", sizeof(fn->ufn_Port));
 284   strlcpy(fn->ufn_ShowCmd,"", sizeof(fn->ufn_ShowCmd));
 285   strlcpy(fn->ufn_ToFrontCmd,"", sizeof(fn->ufn_ToFrontCmd));
 286   strlcpy(fn->ufn_OpenURLCmd,"", sizeof(fn->ufn_OpenURLCmd));
 287   strlcpy(fn->ufn_OpenURLWCmd,"", sizeof(fn->ufn_OpenURLWCmd));
 288   AddTail((struct List *)(&p->up_FTPList),(struct Node *)(fn));
 289
 290   /* FTP: Pete's FTP */
 291   if(!(fn = allocArbitrateVecPooled(sizeof(struct URL_FTPNode))))
 292   {
 293     LEAVE();
 294     return;
 295   }
 296
 297   fn->ufn_Flags = UNF_DISABLED;
 298   strlcpy(fn->ufn_Name,"Pete's FTP", sizeof(fn->ufn_Name));
 299   strlcpy(fn->ufn_Path,"pftp \"%a\"", sizeof(fn->ufn_Path));
 300   strlcpy(fn->ufn_Port,"", sizeof(fn->ufn_Port));
 301   strlcpy(fn->ufn_ShowCmd,"", sizeof(fn->ufn_ShowCmd));
 302   strlcpy(fn->ufn_ToFrontCmd,"", sizeof(fn->ufn_ToFrontCmd));
 303   strlcpy(fn->ufn_OpenURLCmd,"", sizeof(fn->ufn_OpenURLCmd));
 304   strlcpy(fn->ufn_OpenURLWCmd,"", sizeof(fn->ufn_OpenURLWCmd));
 305   AddTail((struct List *)(&p->up_FTPList),(struct Node *)(fn));
 306
 307   /* FTP: AmiTradeCenter */
 308   if(!(fn = allocArbitrateVecPooled(sizeof(struct URL_FTPNode))))
 309   {
 310     LEAVE();
 311     return;
 312   }
 313
 314   fn->ufn_Flags = UNF_DISABLED;
 315   strlcpy(fn->ufn_Name,"AmiTradeCenter", sizeof(fn->ufn_Name));
 316   strlcpy(fn->ufn_Path,"AmiTradeCenter \"%a\"", sizeof(fn->ufn_Path));
 317   strlcpy(fn->ufn_Port,"ATC_MAIN", sizeof(fn->ufn_Port));
 318   strlcpy(fn->ufn_ShowCmd,"", sizeof(fn->ufn_ShowCmd));
 319   strlcpy(fn->ufn_ToFrontCmd,"", sizeof(fn->ufn_ToFrontCmd));
 320   strlcpy(fn->ufn_OpenURLCmd,"", sizeof(fn->ufn_OpenURLCmd));
 321   strlcpy(fn->ufn_OpenURLWCmd,"", sizeof(fn->ufn_OpenURLWCmd));
 322   AddTail((struct List *)(&p->up_FTPList),(struct Node *)(fn));
 323
 324   LEAVE();
 325 }
 326
 327 /**************************************************************************/
 328
 329 BOOL savePrefs(CONST_STRPTR filename, struct URL_Prefs *p)
 330 {
 331   struct IFFHandle *iffh;
 332   BOOL res = FALSE;
 333
 334   ENTER();
 335
 336   if((iffh = AllocIFF()) != NULL)
 337   {
 338     if((iffh->iff_Stream = (IPTR)Open(filename, MODE_NEWFILE)) != 0)
 339     {
 340       InitIFFasDOS(iffh);
 341
 342       if(OpenIFF(iffh, IFFF_WRITE) == 0)
 343       {
 344         struct PrefHeader prhd;
 345         struct URL_BrowserNode *bn;
 346         struct URL_MailerNode *mn;
 347         struct URL_FTPNode *fn;
 348
 349         D(DBF_ALWAYS, "saving prefs to '%s'", filename);
 350
 351         if(PushChunk(iffh, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN) != 0)
 352           goto fail;
 353         if(PushChunk(iffh, ID_PREF, ID_PRHD, sizeof(struct PrefHeader)) != 0)
 354           goto fail;
 355
 356         prhd.ph_Version = p->up_Version;
 357         prhd.ph_Type    = 0;
 358         prhd.ph_Flags   = 0;
 359
 360         if(WriteChunkBytes(iffh, &prhd, sizeof(struct PrefHeader)) != sizeof(struct PrefHeader))
 361           goto fail;
 362
 363         if(PopChunk(iffh) != 0)
 364           goto fail;
 365
 366         /* write browser nodes */
 367         D(DBF_ALWAYS, "saving browsers");
 368         for(bn = (struct URL_BrowserNode *)p->up_BrowserList.mlh_Head;
 369             bn->ubn_Node.mln_Succ;
 370             bn = (struct URL_BrowserNode *)bn->ubn_Node.mln_Succ)
 371         {
 372             // mask out possibly invalid flags
 373             bn->ubn_Flags &= UNF_VALID_MASK;
 374
 375             if(PushChunk(iffh, ID_PREF, ID_BRWS, BRWS_SIZE) != 0)
 376               goto fail;
 377             if(WriteChunkBytes(iffh, &bn->ubn_Flags, BRWS_SIZE) != BRWS_SIZE)
 378               goto fail;
 379             if(PopChunk(iffh) != 0)
 380               goto fail;
 381         }
 382
 383         /* write mailer nodes */
 384         D(DBF_ALWAYS, "saving mailers");
 385         for(mn = (struct URL_MailerNode *)p->up_MailerList.mlh_Head;
 386             mn->umn_Node.mln_Succ;
 387             mn = (struct URL_MailerNode *)mn->umn_Node.mln_Succ)
 388         {
 389             // mask out possibly invalid flags
 390             mn->umn_Flags &= UNF_VALID_MASK;
 391
 392             if(PushChunk(iffh, ID_PREF, ID_MLRS, MLRS_SIZE) != 0)
 393               goto fail;
 394             if(WriteChunkBytes(iffh, &mn->umn_Flags, MLRS_SIZE) != MLRS_SIZE)
 395               goto fail;
 396             if(PopChunk(iffh) != 0)
 397               goto fail;
 398         }
 399
 400         /* write ftp nodes */
 401         D(DBF_ALWAYS, "saving ftps");
 402         for(fn = (struct URL_FTPNode *)p->up_FTPList.mlh_Head;
 403             fn->ufn_Node.mln_Succ;
 404             fn = (struct URL_FTPNode *)fn->ufn_Node.mln_Succ)
 405         {
 406             // mask out possibly invalid flags
 407             fn->ufn_Flags &= UNF_VALID_MASK;
 408
 409             if(PushChunk(iffh, ID_PREF, ID_FTPS, FTPS_SIZE) != 0)
 410               goto fail;
 411             if(WriteChunkBytes(iffh, &fn->ufn_Flags, FTPS_SIZE) != FTPS_SIZE)
 412               goto fail;
 413             if(PopChunk(iffh) != 0)
 414               goto fail;
 415         }
 416
 417         /* write flags */
 418         D(DBF_ALWAYS, "saving flags");
 419         // mask out possibly invalid flags
 420         p->up_Flags &= UPF_VALID_MASK;
 421
 422         if(PushChunk(iffh, ID_PREF, ID_FLGS, FLGS_SIZE) != 0)
 423           goto fail;
 424         if(WriteChunkBytes(iffh, &p->up_Flags, FLGS_SIZE) != FLGS_SIZE)
 425           goto fail;
 426         if(PopChunk(iffh) != 0)
 427           goto fail;
 428
 429         /* write defaults */
 430         D(DBF_ALWAYS, "saving defaults");
 431         if(PushChunk(iffh, ID_PREF, ID_DEFS, DEFS_SIZE) != 0)
 432           goto fail;
 433         if(WriteChunkBytes(iffh, &p->up_DefShow, DEFS_SIZE) != DEFS_SIZE)
 434           goto fail;
 435         if(PopChunk(iffh) != 0)
 436           goto fail;
 437
 438         /* pop the IFF PREF FORM chunk */
 439         if(PopChunk(iffh) != 0)
 440           goto fail;
 441
 442         res = TRUE;
 443
 444       fail:
 445         CloseIFF(iffh);
 446       }
 447
 448       Close((BPTR)iffh->iff_Stream);
 449     }
 450
 451     FreeIFF(iffh);
 452   }
 453
 454   if(res == FALSE)
 455     DeleteFile(filename);
 456
 457   RETURN(res);
 458   return res;
 459 }
 460
 461 /**************************************************************************/
 462
 463 BOOL loadPrefs(struct URL_Prefs *p,ULONG mode)
 464 {
 465     struct IFFHandle *iffh;
 466     BOOL res = FALSE;
 467
 468     ENTER();
 469
 470     initPrefs(p);
 471
 472     if((iffh = AllocIFF()) != NULL)
 473     {
 474         CONST_STRPTR fileName;
 475         BPTR  file;
 476
 477         fileName = (mode==LOADPREFS_ENV) ? DEF_ENV : DEF_ENVARC;
 478
 479         if (!(file = Open(fileName,MODE_OLDFILE)))
 480             if (mode==LOADPREFS_ENV) file = Open(DEF_ENVARC,MODE_OLDFILE);
 481
 482         if((iffh->iff_Stream = (IPTR)file) != 0)
 483         {
 484             InitIFFasDOS(iffh);
 485
 486             if (!OpenIFF(iffh,IFFF_READ))
 487             {
 488                 struct PrefHeader  prhd;
 489                 struct ContextNode *cn;
 490
 491                 if (StopChunk(iffh,ID_PREF,ID_PRHD)) goto fail;
 492                 if (StopChunk(iffh,ID_PREF,ID_DEFS)) goto fail;
 493                 if (StopChunk(iffh,ID_PREF,ID_FLGS)) goto fail;
 494                 if (StopChunk(iffh,ID_PREF,ID_FTPS)) goto fail;
 495                 if (StopChunk(iffh,ID_PREF,ID_MLRS)) goto fail;
 496                 if (StopChunk(iffh,ID_PREF,ID_BRWS)) goto fail;
 497
 498                 if (ParseIFF(iffh,IFFPARSE_SCAN)) goto fail;
 499
 500                 if (!(cn = CurrentChunk(iffh))) goto fail;
 501
 502                 if ((cn->cn_Type!=ID_PREF) || (cn->cn_ID!=ID_PRHD) ||
 503                     (cn->cn_Size!=sizeof(struct PrefHeader))) goto fail;
 504
 505                 if (ReadChunkBytes(iffh,&prhd,cn->cn_Size)!=cn->cn_Size) goto fail;
 506                 if (prhd.ph_Version>PREFS_VERSION) goto fail;
 507
 508                 for (;;)
 509                 {
 510                     LONG error;
 511
 512                     error = ParseIFF(iffh,IFFPARSE_SCAN);
 513                     if (error==IFFERR_EOF) break;
 514                     else if (error) goto fail;
 515
 516                     if (!(cn = CurrentChunk(iffh))) goto fail;
 517
 518                     if (cn->cn_Type!=ID_PREF) continue;
 519
 520                     if ((cn->cn_ID==ID_BRWS) && (cn->cn_Size==BRWS_SIZE))
 521                     {
 522                         struct URL_BrowserNode *bn;
 523
 524                         if(!(bn = allocArbitrateVecPooled(sizeof(struct URL_BrowserNode))))
 525                           goto fail;
 526
 527                         if (ReadChunkBytes(iffh,&bn->ubn_Flags,cn->cn_Size)!=cn->cn_Size)
 528                         {
 529                           freeArbitrateVecPooled(bn);
 530                           goto fail;
 531                         }
 532
 533                         // mask out possibly invalid flags
 534                         bn->ubn_Flags &= UNF_VALID_MASK;
 535
 536                         AddTail((struct List *)(&p->up_BrowserList),(struct Node *)(bn));
 537
 538                         continue;
 539                     }
 540
 541                     if ((cn->cn_ID==ID_MLRS) && (cn->cn_Size==MLRS_SIZE))
 542                     {
 543                         struct URL_MailerNode *mn;
 544
 545                         if(!(mn = allocArbitrateVecPooled(sizeof(struct URL_MailerNode))))
 546                           goto fail;
 547
 548                         if (ReadChunkBytes(iffh,&mn->umn_Flags,cn->cn_Size)!=cn->cn_Size)
 549                         {
 550                           freeArbitrateVecPooled(mn);
 551                           goto fail;
 552                         }
 553
 554                         // mask out possibly invalid flags
 555                         mn->umn_Flags &= UNF_VALID_MASK;
 556
 557                         AddTail((struct List *)(&p->up_MailerList),(struct Node *)(mn));
 558
 559                         continue;
 560                     }
 561
 562                     if ((cn->cn_ID==ID_FTPS) && (cn->cn_Size==FTPS_SIZE))
 563                     {
 564                         struct URL_FTPNode *fn;
 565
 566                         if(!(fn = allocArbitrateVecPooled(sizeof(struct URL_FTPNode))))
 567                           goto fail;
 568
 569                         if (ReadChunkBytes(iffh,&fn->ufn_Flags,cn->cn_Size)!=cn->cn_Size)
 570                         {
 571                           freeArbitrateVecPooled(fn);
 572                           goto fail;
 573                         }
 574
 575                         // mask out possibly invalid flags
 576                         fn->ufn_Flags &= UNF_VALID_MASK;
 577
 578                         AddTail((struct List *)(&p->up_FTPList),(struct Node *)(fn));
 579
 580                         continue;
 581                     }
 582
 583                     if ((cn->cn_ID==ID_FLGS) && (cn->cn_Size==FLGS_SIZE))
 584                     {
 585                         if (ReadChunkBytes(iffh,&p->up_Flags,cn->cn_Size)!=cn->cn_Size)
 586                             goto fail;
 587
 588                         continue;
 589                     }
 590
 591                     if ((cn->cn_ID==ID_DEFS) && (cn->cn_Size==DEFS_SIZE))
 592                     {
 593                         if (ReadChunkBytes(iffh,&p->up_DefShow,cn->cn_Size)!=cn->cn_Size)
 594                             goto fail;
 595
 596                         continue;
 597                     }
 598                 }
 599
 600                 // the loaded prefs are not the default ones
 601                 CLEAR_FLAG(p->up_Flags, UPF_ISDEFAULTS);
 602
 603                 // mask out possibly invalid flags
 604                 p->up_Flags &= UPF_VALID_MASK;
 605
 606                 res = TRUE;
 607
 608             fail:
 609                 CloseIFF(iffh);
 610             }
 611
 612             Close(file);
 613         }
 614
 615         FreeIFF(iffh);
 616     }
 617
 618     RETURN(res);
 619     return res;
 620 }
 621
 622 /**************************************************************************/
 623
 624 struct URL_Prefs *loadPrefsNotFail(void)
 625 {
 626   struct URL_Prefs *p;
 627
 628   ENTER();
 629
 630   if((p = allocArbitrateVecPooled(sizeof(*p))) != NULL)
 631   {
 632     if(loadPrefs(p, LOADPREFS_ENV) == FALSE)
 633       setDefaultPrefs(p);
 634   }
 635
 636   RETURN(p);
 637   return p;
 638 }
 639
 640 /**************************************************************************/
 641