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-2013 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 #define __NOLIBBASE__
  28 #include <proto/openurl.h>
  29
  30 /**************************************************************************/
  31
  32 #define ID_BRWS MAKE_ID('B','R','W','S')
  33 #define ID_MLRS MAKE_ID('M','L','R','S')
  34 #define ID_FTPS MAKE_ID('F','T','P','S')
  35 #define ID_FLGS MAKE_ID('F','L','G','S')
  36 #define ID_DEFS MAKE_ID('D','E','F','S')
  37
  38 #define BRWS_SIZE (sizeof(struct URL_BrowserNode)-sizeof(struct MinNode))
  39 #define MLRS_SIZE (sizeof(struct URL_MailerNode)-sizeof(struct MinNode))
  40 #define FTPS_SIZE (sizeof(struct URL_FTPNode)-sizeof(struct MinNode))
  41 #define FLGS_SIZE (sizeof(ULONG))
  42 #define DEFS_SIZE (4 * sizeof(ULONG))
  43
  44 /**************************************************************************/
  45
  46 struct URL_Prefs *copyPrefs(struct URL_Prefs *old)
  47 {
  48   struct URL_Prefs *new = NULL;
  49
  50   ENTER();
  51
  52   if(old->up_Version == PREFS_VERSION)
  53   {
  54     if((new = allocArbitrateVecPooled(sizeof(struct URL_Prefs))) != NULL)
  55     {
  56       ULONG res;
  57
  58       new->up_Version = PREFS_VERSION;
  59       new->up_Flags   = old->up_Flags;
  60
  61       NewList((struct List *)&new->up_BrowserList);
  62       NewList((struct List *)&new->up_MailerList);
  63       NewList((struct List *)&new->up_FTPList);
  64
  65       if((res = copyList((struct List *)&new->up_BrowserList,(struct List *)&old->up_BrowserList,sizeof(struct URL_BrowserNode))))
  66       {
  67         new->up_DefShow         = old->up_DefShow;
  68         new->up_DefBringToFront = old->up_DefBringToFront;
  69         new->up_DefNewWindow    = old->up_DefNewWindow;
  70         new->up_DefLaunch       = old->up_DefLaunch;
  71
  72         if((res = copyList((struct List *)&new->up_MailerList,(struct List *)&old->up_MailerList,sizeof(struct URL_MailerNode))))
  73           res = copyList((struct List *)&new->up_FTPList,(struct List *)&old->up_FTPList,sizeof(struct URL_FTPNode));
  74       }
  75
  76       if(res == FALSE)
  77       {
  78         URL_FreePrefsA(new, NULL);
  79         new = NULL;
  80       }
  81     }
  82   }
  83
  84   return(new);
  85   return new;
  86 }
  87
  88 /**************************************************************************/
  89
  90 void initPrefs(struct URL_Prefs *p)
  91 {
  92   ENTER();
  93
  94   memset(p,0,sizeof(*p));
  95
  96   p->up_Version = PREFS_VERSION;
  97
  98   NewList((struct List *)&p->up_BrowserList);
  99   NewList((struct List *)&p->up_MailerList);
 100   NewList((struct List *)&p->up_FTPList);
 101
 102   LEAVE();
 103 }
 104
 105 /**************************************************************************/
 106
 107 static void addBrowser(struct URL_Prefs *p, const char *name, const char *path, const char *port, const char *show, const char *toFront, const char *open, const char *openWin)
 108 {
 109   struct URL_BrowserNode *bn;
 110
 111   if((bn = allocArbitrateVecPooled(sizeof(*bn))) != NULL)
 112   {
 113     bn->ubn_Flags = UNF_DISABLED;
 114     strlcpy(bn->ubn_Name, name, sizeof(bn->ubn_Name));
 115     strlcpy(bn->ubn_Path, path, sizeof(bn->ubn_Path));
 116     strlcpy(bn->ubn_Port, port, sizeof(bn->ubn_Port));
 117     strlcpy(bn->ubn_ShowCmd, show, sizeof(bn->ubn_ShowCmd));
 118     strlcpy(bn->ubn_ToFrontCmd, toFront, sizeof(bn->ubn_ToFrontCmd));
 119     strlcpy(bn->ubn_OpenURLCmd, open, sizeof(bn->ubn_OpenURLCmd));
 120     strlcpy(bn->ubn_OpenURLWCmd, openWin, sizeof(bn->ubn_OpenURLWCmd));
 121     AddTail((struct List *)&p->up_BrowserList, (struct Node *)bn);
 122   }
 123 }
 124
 125 static void addMailer(struct URL_Prefs *p, const char *name, const char *path, const char *port, const char *show, const char *toFront, const char *write)
 126 {
 127   struct URL_MailerNode *mn;
 128
 129   if((mn = allocArbitrateVecPooled(sizeof(*mn))) != NULL)
 130   {
 131     mn->umn_Flags = UNF_DISABLED;
 132     strlcpy(mn->umn_Name, name, sizeof(mn->umn_Name));
 133     strlcpy(mn->umn_Path, path, sizeof(mn->umn_Path));
 134     strlcpy(mn->umn_Port, port, sizeof(mn->umn_Port));
 135     strlcpy(mn->umn_ShowCmd, show, sizeof(mn->umn_ShowCmd));
 136     strlcpy(mn->umn_ToFrontCmd, toFront, sizeof(mn->umn_ToFrontCmd));
 137     strlcpy(mn->umn_WriteMailCmd, write, sizeof(mn->umn_WriteMailCmd));
 138     AddTail((struct List *)&p->up_MailerList, (struct Node *)mn);
 139   }
 140 }
 141
 142 static void addFTP(struct URL_Prefs *p, const char *name, const char *path, const char *port, const char *show, const char *toFront, const char *open, const char *openWin)
 143 {
 144   struct URL_FTPNode *fn;
 145
 146   if((fn = allocArbitrateVecPooled(sizeof(*fn))) != NULL)
 147   {
 148     fn->ufn_Flags = UNF_DISABLED;
 149     strlcpy(fn->ufn_Name, name, sizeof(fn->ufn_Name));
 150     strlcpy(fn->ufn_Path, path, sizeof(fn->ufn_Path));
 151     strlcpy(fn->ufn_Port, port, sizeof(fn->ufn_Port));
 152     strlcpy(fn->ufn_ShowCmd, show, sizeof(fn->ufn_ShowCmd));
 153     strlcpy(fn->ufn_ToFrontCmd, toFront, sizeof(fn->ufn_ToFrontCmd));
 154     strlcpy(fn->ufn_OpenURLCmd, open, sizeof(fn->ufn_OpenURLCmd));
 155     strlcpy(fn->ufn_OpenURLWCmd, openWin, sizeof(fn->ufn_OpenURLWCmd));
 156     AddTail((struct List *)&p->up_FTPList, (struct Node *)fn);
 157   }
 158 }
 159
 160 void setDefaultPrefs(struct URL_Prefs *p)
 161 {
 162   ENTER();
 163
 164   initPrefs(p);
 165
 166   p->up_Flags = DEF_FLAGS;
 167
 168   p->up_DefShow         = DEF_DefShow;
 169   p->up_DefBringToFront = DEF_DefBringToFront;
 170   p->up_DefNewWindow    = DEF_DefNewWindow;
 171   p->up_DefLaunch       = DEF_DefLaunch;
 172
 173   // Browsers: OWB
 174   addBrowser(p, "OWB", "OWB \"%u\"", "OWB", "", "SCREENTOFRONT", "OPENURL \"%u\"", "OPENURL \"%u\"");
 175
 176   // Browsers: MUIOWB
 177   addBrowser(p, "MUIOWB", "MUIOWB \"%u\"", "MUIOWB", "SHOW", "SCREENTOFRONT", "OPEN NAME=\"%u\"", "OPEN NAME=\"%u\" NEWPAGE");
 178
 179   // Browsers: NetSurf
 180   addBrowser(p, "NetSurf", "NetSurf \"%u\"", "NETSURF", "", "TOFRONT", "OPEN \"%u\"", "OPEN \"%u\" NEW");
 181
 182   // Browsers: IBrowse
 183   addBrowser(p, "IBrowse", "IBrowse \"%u\"", "IBROWSE", "SHOW", "SCREENTOFRONT", "GOTOURL \"%u\"", "NEWWINDOW \"%u\"");
 184
 185   // Browsers: AWeb
 186   addBrowser(p, "AWeb", "AWeb \"%u\"", "AWEB", "ICONIFY SHOW", "SCREENTOFRONT", "OPEN \"%u\"", "NEW \"%u\"");
 187
 188   // Browsers: Voyager
 189   addBrowser(p, "Voyager", "V \"%u\"", "VOYAGER", "SHOW", "SCREENTOFRONT", "OPENURL \"%u\"", "OPENURL \"%u\" NEWWIN");
 190
 191   // Mailers: YAM
 192   addMailer(p, "YAM", "YAM MAILTO=\"%a\" SUBJECT=\"%s\" LETTER=\"%f\"", "YAM", "SHOW", "SCREENTOFRONT", "MAILWRITE;WRITETO \"%a\";WRITESUBJECT \"%s\";WRITEEDITOR \"CLEAR\";WRITEEDITOR \"TEXT %b\"");
 193
 194   // Mailers: SimpleMail
 195   addMailer(p, "SimpleMail", "SimpleMail MAILTO=\"%a\" SUBJECT=\"%s\"", "SIMPLEMAIL", "SHOW", "SCREENTOFRONT", "MAILWRITE MAILTO=\"%a\" SUBJECT=\"%s\"");
 196
 197   // Mailers: MicroDot II
 198   addMailer(p, "MicroDot II", "MicroDot TO=\"%a\" SUBJECT=\"%s\" CONTENTS=\"%f\"", "MD", "SHOW", "SCREENTOFRONT", "NEWMSGWINDOW TO=\"%a\" SUBJECT=\"%s\" CONTENTS=\"%f\"");
 199
 200   // Mailers: lola
 201   addMailer(p, "lola", "lola TO=\"%a\" SUBJECT=\"%s\" TEXT=\"%b\" CX_POPUP CX_POPKEY=\"control alt l\"", "LOLA", "SHOW", "", "FILL TO=\"%a\" SUBJECT=\"%s\" TEXT=\"%b\"");
 202
 203   // FTP: AmiFTP
 204   addFTP(p, "AmiFTP", "AmiFTP \"%a\"", "AMIFTP", "", "", "", "");
 205
 206   // FTP: Pete's FTP
 207   addFTP(p, "Pete's FTP", "pftp \"%a\"", "", "", "", "", "");
 208
 209   // FTP: AmiTradeCenter
 210   addFTP(p, "AmiTradeCenter", "AmiTradeCenter \"%a\"", "ATC_MAIN", "", "", "", "");
 211
 212   LEAVE();
 213 }
 214
 215 /**************************************************************************/
 216
 217 BOOL savePrefs(CONST_STRPTR filename, struct URL_Prefs *p)
 218 {
 219   struct IFFHandle *iffh;
 220   BOOL res = FALSE;
 221
 222   ENTER();
 223
 224   if((iffh = AllocIFF()) != NULL)
 225   {
 226     if((iffh->iff_Stream = (IPTR)Open(filename, MODE_NEWFILE)) != 0)
 227     {
 228       InitIFFasDOS(iffh);
 229
 230       if(OpenIFF(iffh, IFFF_WRITE) == 0)
 231       {
 232         struct PrefHeader prhd;
 233         struct URL_BrowserNode *bn;
 234         struct URL_MailerNode *mn;
 235         struct URL_FTPNode *fn;
 236
 237         D(DBF_ALWAYS, "saving prefs to '%s'", filename);
 238
 239         if(PushChunk(iffh, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN) != 0)
 240           goto fail;
 241         if(PushChunk(iffh, ID_PREF, ID_PRHD, sizeof(struct PrefHeader)) != 0)
 242           goto fail;
 243
 244         prhd.ph_Version = p->up_Version;
 245         prhd.ph_Type    = 0;
 246         prhd.ph_Flags   = 0;
 247
 248         if(WriteChunkBytes(iffh, &prhd, sizeof(struct PrefHeader)) != sizeof(struct PrefHeader))
 249           goto fail;
 250
 251         if(PopChunk(iffh) != 0)
 252           goto fail;
 253
 254         /* write browser nodes */
 255         D(DBF_ALWAYS, "saving browsers");
 256         for(bn = (struct URL_BrowserNode *)p->up_BrowserList.mlh_Head;
 257             bn->ubn_Node.mln_Succ;
 258             bn = (struct URL_BrowserNode *)bn->ubn_Node.mln_Succ)
 259         {
 260             // mask out possibly invalid flags
 261             bn->ubn_Flags &= UNF_VALID_MASK;
 262
 263             if(PushChunk(iffh, ID_PREF, ID_BRWS, BRWS_SIZE) != 0)
 264               goto fail;
 265             if(WriteChunkBytes(iffh, &bn->ubn_Flags, BRWS_SIZE) != BRWS_SIZE)
 266               goto fail;
 267             if(PopChunk(iffh) != 0)
 268               goto fail;
 269         }
 270
 271         /* write mailer nodes */
 272         D(DBF_ALWAYS, "saving mailers");
 273         for(mn = (struct URL_MailerNode *)p->up_MailerList.mlh_Head;
 274             mn->umn_Node.mln_Succ;
 275             mn = (struct URL_MailerNode *)mn->umn_Node.mln_Succ)
 276         {
 277             // mask out possibly invalid flags
 278             mn->umn_Flags &= UNF_VALID_MASK;
 279
 280             if(PushChunk(iffh, ID_PREF, ID_MLRS, MLRS_SIZE) != 0)
 281               goto fail;
 282             if(WriteChunkBytes(iffh, &mn->umn_Flags, MLRS_SIZE) != MLRS_SIZE)
 283               goto fail;
 284             if(PopChunk(iffh) != 0)
 285               goto fail;
 286         }
 287
 288         /* write ftp nodes */
 289         D(DBF_ALWAYS, "saving ftps");
 290         for(fn = (struct URL_FTPNode *)p->up_FTPList.mlh_Head;
 291             fn->ufn_Node.mln_Succ;
 292             fn = (struct URL_FTPNode *)fn->ufn_Node.mln_Succ)
 293         {
 294             // mask out possibly invalid flags
 295             fn->ufn_Flags &= UNF_VALID_MASK;
 296
 297             if(PushChunk(iffh, ID_PREF, ID_FTPS, FTPS_SIZE) != 0)
 298               goto fail;
 299             if(WriteChunkBytes(iffh, &fn->ufn_Flags, FTPS_SIZE) != FTPS_SIZE)
 300               goto fail;
 301             if(PopChunk(iffh) != 0)
 302               goto fail;
 303         }
 304
 305         /* write flags */
 306         D(DBF_ALWAYS, "saving flags");
 307         // mask out possibly invalid flags
 308         p->up_Flags &= UPF_VALID_MASK;
 309
 310         if(PushChunk(iffh, ID_PREF, ID_FLGS, FLGS_SIZE) != 0)
 311           goto fail;
 312         if(WriteChunkBytes(iffh, &p->up_Flags, FLGS_SIZE) != FLGS_SIZE)
 313           goto fail;
 314         if(PopChunk(iffh) != 0)
 315           goto fail;
 316
 317         /* write defaults */
 318         D(DBF_ALWAYS, "saving defaults");
 319         if(PushChunk(iffh, ID_PREF, ID_DEFS, DEFS_SIZE) != 0)
 320           goto fail;
 321         if(WriteChunkBytes(iffh, &p->up_DefShow, DEFS_SIZE) != DEFS_SIZE)
 322           goto fail;
 323         if(PopChunk(iffh) != 0)
 324           goto fail;
 325
 326         /* pop the IFF PREF FORM chunk */
 327         if(PopChunk(iffh) != 0)
 328           goto fail;
 329
 330         res = TRUE;
 331
 332       fail:
 333         CloseIFF(iffh);
 334       }
 335
 336       Close((BPTR)iffh->iff_Stream);
 337     }
 338
 339     FreeIFF(iffh);
 340   }
 341
 342   if(res == FALSE)
 343     DeleteFile(filename);
 344
 345   RETURN(res);
 346   return res;
 347 }
 348
 349 /**************************************************************************/
 350
 351 BOOL loadPrefs(struct URL_Prefs *p,ULONG mode)
 352 {
 353     struct IFFHandle *iffh;
 354     BOOL res = FALSE;
 355
 356     ENTER();
 357
 358     initPrefs(p);
 359
 360     if((iffh = AllocIFF()) != NULL)
 361     {
 362         CONST_STRPTR fileName;
 363         BPTR  file;
 364
 365         fileName = (mode==LOADPREFS_ENV) ? DEF_ENV : DEF_ENVARC;
 366
 367         if (!(file = Open(fileName,MODE_OLDFILE)))
 368             if (mode==LOADPREFS_ENV) file = Open(DEF_ENVARC,MODE_OLDFILE);
 369
 370         if((iffh->iff_Stream = (IPTR)file) != 0)
 371         {
 372             InitIFFasDOS(iffh);
 373
 374             if (!OpenIFF(iffh,IFFF_READ))
 375             {
 376                 struct PrefHeader  prhd;
 377                 struct ContextNode *cn;
 378
 379                 if (StopChunk(iffh,ID_PREF,ID_PRHD)) goto fail;
 380                 if (StopChunk(iffh,ID_PREF,ID_DEFS)) goto fail;
 381                 if (StopChunk(iffh,ID_PREF,ID_FLGS)) goto fail;
 382                 if (StopChunk(iffh,ID_PREF,ID_FTPS)) goto fail;
 383                 if (StopChunk(iffh,ID_PREF,ID_MLRS)) goto fail;
 384                 if (StopChunk(iffh,ID_PREF,ID_BRWS)) goto fail;
 385
 386                 if (ParseIFF(iffh,IFFPARSE_SCAN)) goto fail;
 387
 388                 if (!(cn = CurrentChunk(iffh))) goto fail;
 389
 390                 if ((cn->cn_Type!=ID_PREF) || (cn->cn_ID!=ID_PRHD) ||
 391                     (cn->cn_Size!=sizeof(struct PrefHeader))) goto fail;
 392
 393                 if (ReadChunkBytes(iffh,&prhd,cn->cn_Size)!=cn->cn_Size) goto fail;
 394                 if (prhd.ph_Version>PREFS_VERSION) goto fail;
 395
 396                 for (;;)
 397                 {
 398                     LONG error;
 399
 400                     error = ParseIFF(iffh,IFFPARSE_SCAN);
 401                     if (error==IFFERR_EOF) break;
 402                     else if (error) goto fail;
 403
 404                     if (!(cn = CurrentChunk(iffh))) goto fail;
 405
 406                     if (cn->cn_Type!=ID_PREF) continue;
 407
 408                     if ((cn->cn_ID==ID_BRWS) && (cn->cn_Size==BRWS_SIZE))
 409                     {
 410                         struct URL_BrowserNode *bn;
 411
 412                         if(!(bn = allocArbitrateVecPooled(sizeof(struct URL_BrowserNode))))
 413                           goto fail;
 414
 415                         if (ReadChunkBytes(iffh,&bn->ubn_Flags,cn->cn_Size)!=cn->cn_Size)
 416                         {
 417                           freeArbitrateVecPooled(bn);
 418                           goto fail;
 419                         }
 420
 421                         // mask out possibly invalid flags
 422                         bn->ubn_Flags &= UNF_VALID_MASK;
 423
 424                         AddTail((struct List *)(&p->up_BrowserList),(struct Node *)(bn));
 425
 426                         continue;
 427                     }
 428
 429                     if ((cn->cn_ID==ID_MLRS) && (cn->cn_Size==MLRS_SIZE))
 430                     {
 431                         struct URL_MailerNode *mn;
 432
 433                         if(!(mn = allocArbitrateVecPooled(sizeof(struct URL_MailerNode))))
 434                           goto fail;
 435
 436                         if (ReadChunkBytes(iffh,&mn->umn_Flags,cn->cn_Size)!=cn->cn_Size)
 437                         {
 438                           freeArbitrateVecPooled(mn);
 439                           goto fail;
 440                         }
 441
 442                         // mask out possibly invalid flags
 443                         mn->umn_Flags &= UNF_VALID_MASK;
 444
 445                         AddTail((struct List *)(&p->up_MailerList),(struct Node *)(mn));
 446
 447                         continue;
 448                     }
 449
 450                     if ((cn->cn_ID==ID_FTPS) && (cn->cn_Size==FTPS_SIZE))
 451                     {
 452                         struct URL_FTPNode *fn;
 453
 454                         if(!(fn = allocArbitrateVecPooled(sizeof(struct URL_FTPNode))))
 455                           goto fail;
 456
 457                         if (ReadChunkBytes(iffh,&fn->ufn_Flags,cn->cn_Size)!=cn->cn_Size)
 458                         {
 459                           freeArbitrateVecPooled(fn);
 460                           goto fail;
 461                         }
 462
 463                         // mask out possibly invalid flags
 464                         fn->ufn_Flags &= UNF_VALID_MASK;
 465
 466                         AddTail((struct List *)(&p->up_FTPList),(struct Node *)(fn));
 467
 468                         continue;
 469                     }
 470
 471                     if ((cn->cn_ID==ID_FLGS) && (cn->cn_Size==FLGS_SIZE))
 472                     {
 473                         if (ReadChunkBytes(iffh,&p->up_Flags,cn->cn_Size)!=cn->cn_Size)
 474                             goto fail;
 475
 476                         continue;
 477                     }
 478
 479                     if ((cn->cn_ID==ID_DEFS) && (cn->cn_Size==DEFS_SIZE))
 480                     {
 481                         if (ReadChunkBytes(iffh,&p->up_DefShow,cn->cn_Size)!=cn->cn_Size)
 482                             goto fail;
 483
 484                         continue;
 485                     }
 486                 }
 487
 488                 // the loaded prefs are not the default ones
 489                 CLEAR_FLAG(p->up_Flags, UPF_ISDEFAULTS);
 490
 491                 // mask out possibly invalid flags
 492                 p->up_Flags &= UPF_VALID_MASK;
 493
 494                 res = TRUE;
 495
 496             fail:
 497                 CloseIFF(iffh);
 498             }
 499
 500             Close(file);
 501         }
 502
 503         FreeIFF(iffh);
 504     }
 505
 506     RETURN(res);
 507     return res;
 508 }
 509
 510 /**************************************************************************/
 511
 512 struct URL_Prefs *loadPrefsNotFail(void)
 513 {
 514   struct URL_Prefs *p;
 515
 516   ENTER();
 517
 518   if((p = allocArbitrateVecPooled(sizeof(*p))) != NULL)
 519   {
 520     if(loadPrefs(p, LOADPREFS_ENV) == FALSE)
 521       setDefaultPrefs(p);
 522   }
 523
 524   RETURN(p);
 525   return p;
 526 }
 527
 528 /**************************************************************************/
 529