workbench/prefs/serial/prefs.c

   1 /*
   2     Copyright © 1995-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 /*********************************************************************************************/
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <stdlib.h>
  14
  15 #include <aros/macros.h>
  16
  17 /* #define DEBUG 1 */
  18 #include <aros/debug.h>
  19
  20 #include <proto/iffparse.h>
  21 #include <proto/dos.h>
  22
  23 #include <prefs/prefhdr.h>
  24
  25 #include "global.h"
  26
  27
  28 /*********************************************************************************************/
  29
  30 struct FilePrefHeader
  31 {
  32     UBYTE ph_Version;
  33     UBYTE ph_Type;
  34     UBYTE ph_Flags[4];
  35 };
  36
  37 /*********************************************************************************************/
  38
  39 static struct SerialPrefs   restore_prefs;
  40 struct SerialPrefs          serialprefs;
  41 static APTR                 mempool;
  42
  43 /*********************************************************************************************/
  44
  45 #define SER_DEFAULT_BAUDRATE       19200
  46 #define SER_DEFAULT_IBUFFER        512
  47 #define SER_DEFAULT_OBUFFER        512
  48
  49 #define SER_DEFAULT_IHANDSHAKE     HSHAKE_NONE
  50 #define SER_DEFAULT_OHANDSHAKE     HSHAKE_NONE
  51
  52 #define SER_DEFAULT_PARITY         PARITY_NONE
  53 #define SER_DEFAULT_BITS_PER_CHAR  8
  54 #define SER_DEFAULT_STOP_BITS      1
  55
  56 /*********************************************************************************************/
  57
  58 VOID CleanupPrefs(void)
  59 {
  60     D(bug("[serial prefs] CleanupPrefs\n"));
  61     if (mempool) DeletePool(mempool);
  62 }
  63
  64 /*********************************************************************************************/
  65
  66 VOID CopyPrefs(struct SerialPrefs *s, struct SerialPrefs *d)
  67 {
  68     CopyMem(s, d, sizeof(struct SerialPrefs));
  69 }
  70
  71 VOID BackupPrefs(void)
  72 {
  73     CopyPrefs(&serialprefs, &restore_prefs);
  74 }
  75
  76 VOID RestorePrefs(void)
  77 {
  78     CopyPrefs(&restore_prefs, &serialprefs);
  79 }
  80
  81 /*********************************************************************************************/
  82
  83 /* 1 is success */
  84
  85 ULONG InitPrefs(STRPTR filename, BOOL use, BOOL save)
  86 {
  87     D(bug("[serial prefs] InitPrefs\n"));
  88     mempool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR, 2048, 2048);
  89     if (!mempool)
  90     {
  91         ShowMsg("Out of memory!");
  92         return 0;
  93     }
  94
  95     if (!LoadPrefs(filename))
  96     {
  97         if (!DefaultPrefs())
  98         {
  99             CleanupPrefs();
 100             ShowMsg("Panic! Cannot setup default prefs!");
 101             return 0;
 102         }
 103     }
 104
 105     restore_prefs = serialprefs;
 106
 107     if (use || save)
 108     {
 109         SavePrefs((CONST STRPTR) CONFIGNAME_ENV);
 110     }
 111
 112     if (save)
 113     {
 114         SavePrefs((CONST STRPTR) CONFIGNAME_ENVARC);
 115     }
 116
 117     if (use || save) CleanupPrefs();
 118
 119     return 1;
 120 }
 121
 122 /*********************************************************************************************/
 123
 124 BOOL LoadPrefsFH(BPTR fh)
 125 {
 126     static struct SerialPrefs loadprefs;
 127     struct IFFHandle            *iff;
 128     BOOL                        retval = FALSE;
 129
 130
 131     if ((iff = AllocIFF()))
 132     {
 133         iff->iff_Stream = (IPTR)fh;
 134
 135         InitIFFasDOS(iff);
 136
 137         if (!OpenIFF(iff, IFFF_READ))
 138         {
 139             D(bug("LoadPrefs: OpenIFF okay.\n"));
 140
 141             if (!StopChunk(iff, ID_PREF, ID_SERL))
 142             {
 143                 D(bug("LoadPrefs: StopChunk okay.\n"));
 144
 145                 if (!ParseIFF(iff, IFFPARSE_SCAN))
 146                 {
 147                     struct ContextNode *cn;
 148
 149                     D(bug("LoadPrefs: ParseIFF okay.\n"));
 150
 151                     cn = CurrentChunk(iff);
 152
 153                     if (cn->cn_Size == sizeof(struct SerialPrefs))
 154                     {
 155                         D(bug("LoadPrefs: ID_SERL chunk size okay.\n"));
 156
 157                         if (ReadChunkBytes(iff, &loadprefs, sizeof(struct SerialPrefs)) == sizeof(struct SerialPrefs))
 158                         {
 159                             D(bug("LoadPrefs: Reading chunk successful.\n"));
 160
 161                             serialprefs = loadprefs;
 162
 163                             D(bug("LoadPrefs: Everything okay :-)\n"));
 164
 165                             retval = TRUE;
 166                         }
 167                     }
 168
 169                 } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */
 170
 171             } /* if (!StopChunk(iff, ID_PREF, ID_SERL)) */
 172
 173             CloseIFF(iff);
 174
 175         } /* if (!OpenIFF(iff, IFFF_READ)) */
 176
 177
 178         FreeIFF(iff);
 179
 180     } /* if ((iff = AllocIFF())) */
 181
 182     return retval;
 183 }
 184
 185 BOOL LoadPrefs(STRPTR filename)
 186 {
 187     BPTR fh;
 188     BOOL ret;
 189
 190     D(bug("[serial prefs] LoadPrefsFH: Trying to open \"%s\"\n", filename));
 191
 192     fh=Open(filename, MODE_OLDFILE);
 193
 194     if(!fh) return FALSE;
 195
 196     ret=LoadPrefsFH(fh);
 197
 198     Close(fh);
 199     return ret;
 200 }
 201 /*********************************************************************************************/
 202
 203 BOOL SavePrefsFH(BPTR fh)
 204 {
 205     static struct SerialPrefs   saveprefs;
 206     struct IFFHandle            *iff;
 207     BOOL                        retval = FALSE, delete_if_error = FALSE;
 208
 209     saveprefs = serialprefs;
 210
 211
 212     D(bug("SavePrefsFH: fh: %lx\n", fh));
 213     //if ((iff->iff_Stream = (IPTR)Open(filename, MODE_NEWFILE)))
 214
 215     if ((iff = AllocIFF()))
 216     {
 217         iff->iff_Stream = (IPTR) fh;
 218         D(bug("SavePrefsFH: stream opened.\n"));
 219
 220             delete_if_error = TRUE;
 221
 222             InitIFFasDOS(iff);
 223
 224             if (!OpenIFF(iff, IFFF_WRITE))
 225             {
 226                 D(bug("SavePrefsFH: OpenIFF okay.\n"));
 227
 228                 if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN))
 229                 {
 230                     D(bug("SavePrefsFH: PushChunk(FORM) okay.\n"));
 231
 232                     if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct FilePrefHeader)))
 233                     {
 234                         struct FilePrefHeader head;
 235
 236                         D(bug("SavePrefsFH: PushChunk(PRHD) okay.\n"));
 237
 238                         head.ph_Version  = PHV_CURRENT;
 239                         head.ph_Type     = 0;
 240                         head.ph_Flags[0] =
 241                         head.ph_Flags[1] =
 242                         head.ph_Flags[2] =
 243                         head.ph_Flags[3] = 0;
 244
 245                         if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head))
 246                         {
 247                             D(bug("SavePrefsFH: WriteChunkBytes(PRHD) okay.\n"));
 248
 249                             PopChunk(iff);
 250
 251                             if (!PushChunk(iff, ID_PREF, ID_SERL, sizeof(struct SerialPrefs)))
 252                             {
 253                                 D(bug("SavePrefsFH: PushChunk(LCLE) okay.\n"));
 254
 255                                 if (WriteChunkBytes(iff, &saveprefs, sizeof(saveprefs)) == sizeof(saveprefs))
 256                                 {
 257                                     D(bug("SavePrefsFH: WriteChunkBytes(SERL) okay.\n"));
 258                                     D(bug("SavePrefsFH: Everything okay :-)\n"));
 259
 260                                     retval = TRUE;
 261                                 }
 262
 263                                 PopChunk(iff);
 264
 265                             } /* if (!PushChunk(iff, ID_PREF, ID_SERL, sizeof(struct LocalePrefs))) */
 266
 267                         } /* if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head)) */
 268                         else
 269                         {
 270                             PopChunk(iff);
 271                         }
 272
 273                     } /* if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct PrefHeader))) */
 274
 275                     PopChunk(iff);
 276
 277                 } /* if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN)) */
 278
 279                 CloseIFF(iff);
 280
 281             } /* if (!OpenIFF(iff, IFFFWRITE)) */
 282
 283
 284         FreeIFF(iff);
 285
 286     } /* if ((iff = AllocIFF())) */
 287
 288     #if 0
 289     if (!retval && delete_if_error)
 290     {
 291         DeleteFile(filename);
 292     }
 293     #endif
 294
 295
 296     return retval;
 297 }
 298
 299 BOOL SavePrefs(CONST STRPTR filename)
 300 {
 301     BPTR fh;
 302     BOOL ret;
 303
 304     D(bug("[serial prefs] SavePrefs: Trying to open \"%s\"\n", filename));
 305
 306     fh=Open(filename, MODE_NEWFILE);
 307
 308     if(fh == NULL)
 309     {
 310         D(bug("[serial prefs] open \"%s\" failed!\n", filename));
 311         return FALSE;
 312     }
 313
 314     ret=SavePrefsFH(fh);
 315
 316     Close(fh);
 317     return ret;
 318 }
 319
 320 /*********************************************************************************************/
 321
 322 BOOL SaveEnv() {
 323     BPTR fh;
 324     BOOL result;
 325
 326     D(bug("[serial prefs] SaveEnv: Trying to open \"%s\"\n", CONFIGNAME_ENV));
 327
 328     fh=Open((CONST_STRPTR) CONFIGNAME_ENV, MODE_NEWFILE);
 329
 330     if(fh == NULL)
 331     {
 332         D(bug("[serial prefs] open \"%s\" failed!\n", CONFIGNAME_ENV));
 333         return FALSE;
 334     }
 335
 336     result=SavePrefsFH(fh);
 337
 338     Close(fh);
 339
 340     return result;
 341 }
 342
 343 /*********************************************************************************************/
 344
 345 BOOL DefaultPrefs(void)
 346 {
 347     serialprefs.sp_Reserved[0]     = 0;
 348     serialprefs.sp_Reserved[1]     = 0;
 349     serialprefs.sp_Reserved[2]     = 0;
 350     serialprefs.sp_Unit0Map        = 0;
 351     serialprefs.sp_BaudRate        = SER_DEFAULT_BAUDRATE;
 352     serialprefs.sp_InputBuffer     = SER_DEFAULT_IBUFFER;
 353     serialprefs.sp_OutputBuffer    = SER_DEFAULT_OBUFFER;
 354     serialprefs.sp_InputHandshake  = SER_DEFAULT_IHANDSHAKE;
 355     serialprefs.sp_OutputHandshake = SER_DEFAULT_OHANDSHAKE;
 356     serialprefs.sp_Parity          = SER_DEFAULT_PARITY;
 357     serialprefs.sp_BitsPerChar     = SER_DEFAULT_BITS_PER_CHAR;
 358     serialprefs.sp_StopBits        = SER_DEFAULT_STOP_BITS;
 359
 360     return TRUE;
 361 }
 362