workbench/tools/HDToolBox/prefs.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <dos/dos.h>
   7 #include <dos/rdargs.h>
   8 #include <exec/lists.h>
   9 #include <exec/memory.h>
  10 #include <workbench/icon.h>
  11 #include <proto/dos.h>
  12 #include <proto/exec.h>
  13 #include <proto/icon.h>
  14 #include <proto/uuid.h>
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <strings.h>
  19
  20 #include "debug.h"
  21 #include "prefs.h"
  22 #include "devices.h"
  23 #include "hdtoolbox_support.h"
  24 #include "platform.h"
  25
  26 struct List tabletypelist;
  27
  28 struct TableTypeNode *findTableTypeNodeName(STRPTR name)
  29 {
  30     struct TableTypeNode *ttn;
  31
  32     D(bug("[HDToolBox] findTableTypeNodeName('%s')\n", name));
  33
  34     ttn = (struct TableTypeNode *)tabletypelist.lh_Head;
  35     while (ttn->ln.ln_Succ)
  36     {
  37         if (strcmp(ttn->pti->pti_Name, name) == 0)
  38             return ttn;
  39         ttn = (struct TableTypeNode *)ttn->ln.ln_Succ;
  40     }
  41     return NULL;
  42 }
  43
  44 struct TableTypeNode *findTableTypeNode(ULONG tabletype)
  45 {
  46     struct TableTypeNode *ttn;
  47
  48     D(bug("[HDToolBox] findTableTypeNode()\n"));
  49
  50     ttn = (struct TableTypeNode *)tabletypelist.lh_Head;
  51     while (ttn->ln.ln_Succ)
  52     {
  53         if (ttn->pti->pti_Type == tabletype)
  54             return ttn;
  55         ttn = (struct TableTypeNode *)ttn->ln.ln_Succ;
  56     }
  57     return NULL;
  58 }
  59
  60 struct TypeNode *findPartitionType(struct PartitionType *type, ULONG tabletype)
  61 {
  62     struct TableTypeNode *ttn;
  63     struct TypeNode *tn;
  64
  65     D(bug("[HDToolBox] findPartitionType()\n"));
  66
  67     ttn = findTableTypeNode(tabletype);
  68     if (ttn)
  69     {
  70         tn = (struct TypeNode *)ttn->typelist->lh_Head;
  71         while (tn->ln.ln_Succ)
  72         {
  73             if (tn->type.id_len == type->id_len)
  74             {
  75                 if (memcmp(tn->type.id, type->id, type->id_len) == 0)
  76                     return tn;
  77             }
  78             tn = (struct TypeNode *)tn->ln.ln_Succ;
  79         }
  80     }
  81     return NULL;
  82 }
  83
  84 void getTableTypeList(struct List *list)
  85 {
  86     struct TableTypeNode *ttn;
  87     int i;
  88
  89     D(bug("[HDToolBox] getTableTypeList()\n"));
  90
  91     NEWLIST(&tabletypelist);
  92     for (i=0;PartitionBase->tables[i];i++)
  93     {
  94         ttn = AllocMem(sizeof(struct TableTypeNode), MEMF_PUBLIC | MEMF_CLEAR);
  95         if (ttn)
  96         {
  97             ttn->typelist =
  98                 AllocMem(sizeof(struct List), MEMF_PUBLIC | MEMF_CLEAR);
  99             if (ttn->typelist != NULL)
 100             {
 101                 ttn->pti = PartitionBase->tables[i];
 102                 NEWLIST(ttn->typelist);
 103                 AddTail(list, &ttn->ln);
 104             }
 105             else
 106             {
 107                 FreeMem(ttn, sizeof(struct TableTypeNode));
 108                 ttn = NULL;
 109             }
 110         }
 111     }
 112 }
 113
 114 static LONG parseType(struct TableTypeNode *ttn, ULONG id_len, char *ident, struct CSource *csrc, WORD line)
 115 {
 116     if (ttn && id_len)
 117     {
 118         LONG res;
 119         struct TypeNode *tn = AllocMem(sizeof(struct TypeNode), MEMF_PUBLIC | MEMF_CLEAR);
 120
 121         if (tn == NULL)
 122             return ERROR_NO_FREE_STORE;
 123
 124         tn->type.id_len = id_len;
 125
 126         switch (ttn->pti->pti_Type)
 127         {
 128         case PHPTT_GPT:
 129             UUID_Parse(ident, (uuid_t *)&tn->type.id);
 130             break;
 131
 132         default:
 133             strcpyESC(tn->type.id, ident);
 134             break;
 135         }
 136
 137         res = ReadItem(ident, 256, csrc);
 138
 139         switch (res)
 140         {
 141         case ITEM_ERROR:
 142             return IoErr();
 143
 144         case ITEM_EQUAL:
 145             res = ReadItem(ident, 256, csrc);
 146
 147             switch (res)
 148             {
 149             case ITEM_ERROR:
 150                 return IoErr();
 151
 152             case ITEM_QUOTED:
 153                 res = strlen(ident) + 1;
 154
 155                 tn->ln.ln_Name = AllocVec(res, MEMF_PUBLIC | MEMF_CLEAR);
 156                 if (tn->ln.ln_Name == NULL)
 157                     return ERROR_NO_FREE_STORE;
 158
 159                 CopyMem(ident, tn->ln.ln_Name, res);
 160
 161                 break;
 162
 163             default:
 164                 printf("LINE %d: Quoted expression expected\n", line);
 165                 return 0;
 166             }
 167             break;
 168
 169        default:
 170             printf("LINE %d: Unexpected item after table id\n", line);
 171             return 0;
 172         }
 173
 174         AddTail(ttn->typelist, &tn->ln);
 175     }
 176     else
 177         printf("LINE %d: Missing partition table type or IDLen\n", line);
 178
 179     return 0;
 180 }
 181
 182 enum SectionNum
 183 {
 184     Section_Root,
 185     Section_Devices,
 186     Section_TableIDs
 187 };
 188
 189 LONG parsePrefs(char *buffer, LONG size)
 190 {
 191     struct TableTypeNode *ttn=NULL;
 192     struct CSource csrc = {buffer, size, 0};
 193     struct DiskObject *hdtbicon=NULL;
 194     char ident[256];
 195     LONG res;
 196     ULONG id_len = 0;
 197     WORD current = Section_Root;
 198     WORD line = 1;
 199
 200     D(bug("[HDToolBox] parsePrefs()\n"));
 201
 202     while (csrc.CS_CurChr < csrc.CS_Length)
 203     {
 204         DB2(bug("[parsePrefs] Cur %d, Length %d\n", csrc.CS_CurChr, csrc.CS_Length));
 205         res = ReadItem(ident, 256, &csrc);
 206
 207         DB2(bug("[parsePrefs] Got item %d (%s)\n", res, ident));
 208
 209         switch (res)
 210         {
 211         case ITEM_ERROR:
 212             return IoErr();
 213         case ITEM_UNQUOTED:
 214             if (strcasecmp(ident, "[Devices]") == 0)
 215                 current = Section_Devices;
 216             else if (strcasecmp(ident, "[TableIDs]") == 0)
 217             {
 218                 current = Section_TableIDs;
 219                 ttn = NULL;
 220                 id_len = 0;
 221             }
 222             else
 223             {
 224                 switch (current)
 225                 {
 226                 case Section_Devices:
 227                     addDeviceName(ident);
 228                     break;
 229
 230                 case Section_TableIDs:
 231                     if (strcasecmp(ident, "TableType") == 0)
 232                     {
 233                         res = ReadItem(ident, 256, &csrc);
 234
 235                         switch (res)
 236                         {
 237                         case ITEM_ERROR:
 238                             return IoErr();
 239
 240                         case ITEM_EQUAL:
 241                             res = ReadItem(ident, 256, &csrc);
 242
 243                             switch (res)
 244                             {
 245                             case ITEM_ERROR:
 246                                 return IoErr();
 247
 248                             case ITEM_QUOTED:
 249                                 ttn = findTableTypeNodeName(ident);
 250                                 break;
 251
 252                             case ITEM_UNQUOTED:
 253                                 ttn = findTableTypeNode(strtoul(ident, NULL, 0));
 254                                 break;
 255
 256                             default:
 257                                 printf("LINE %d: Unexpected item in TableType\n", line);
 258                                 return 0;
 259                             }
 260
 261                             if (ttn == 0)
 262                             {
 263                                 printf("LINE %d: Unknown Table %s\n", line, ident);
 264                                 return 0;
 265                             }
 266                             break;
 267
 268                         default:
 269                             printf("LINE %d: Unexpected item after TableType\n", line);
 270                             return 0;
 271                         }
 272                     }
 273                     else if (strcasecmp(ident, "IDLen") == 0)
 274                     {
 275                         res = ReadItem(ident, 256, &csrc);
 276
 277                         switch (res)
 278                         {
 279                         case ITEM_ERROR:
 280                             return IoErr();
 281
 282                         case ITEM_EQUAL:
 283                             res = ReadItem(ident, 256, &csrc);
 284
 285                             switch (res)
 286                             {
 287                             case ITEM_ERROR:
 288                                 return IoErr();
 289
 290                             case ITEM_UNQUOTED:
 291                                 id_len = strtoul(ident, NULL, 0);
 292                                 if (id_len == 0)
 293                                 {
 294                                     printf("LINE %d: Illegal value of IDLen\n", line);
 295                                     return 0;
 296                                 }
 297                                 break;
 298
 299                             default:
 300                                 printf("LINE %d: Value in IDLen expected\n", line);
 301                                 return 0;
 302                             }
 303                             break;
 304
 305                         default:
 306                             printf("LINE %d: Unexpected item after IDLen\n", line);
 307                             return 0;
 308                         }
 309                     }
 310                     else if (strcasecmp(ident, "Default") == 0)
 311                     {
 312                         if (ttn && id_len)
 313                         {
 314                             res = ReadItem(ident, 256, &csrc);
 315
 316                             switch (res)
 317                             {
 318                             case ITEM_ERROR:
 319                                 return IoErr();
 320                                 break;
 321
 322                             case ITEM_EQUAL:
 323                                 res = ReadItem(ident, 256, &csrc);
 324                                 switch (res)
 325                                 {
 326                                 case ITEM_ERROR:
 327                                     return IoErr();
 328
 329                                 case ITEM_QUOTED:
 330                                     ttn->defaulttype.id_len = id_len;
 331                                     strcpyESC(ttn->defaulttype.id, ident);
 332                                     break;
 333
 334                                 default:
 335                                     printf("LINE %d: Unexpected expression after Default\n", line);
 336                                     return 0;
 337                                 }
 338                                 break;
 339
 340                             default:
 341                                 printf("LINE %d: Unexpected item after IDLen\n", line);
 342                                 return 0;
 343                             }
 344                         }
 345                         else
 346                         {
 347                             printf("LINE %d: Unknown option '%s'\n", line, ident);
 348                             return 0;
 349                         }
 350                     }
 351                     else
 352                     {
 353                         res = parseType(ttn, id_len, ident, &csrc, line);
 354                         if (res)
 355                             return res;
 356                     }
 357
 358                     break;
 359
 360                 default:
 361                     printf("LINE %d: Unexpected item '%s' in prefs\n", line, ident);
 362                     return 0;
 363                 }
 364             }
 365             break;
 366
 367         case ITEM_QUOTED:
 368             res = parseType(ttn, id_len, ident, &csrc, line);
 369             if (res)
 370                 return res;
 371
 372             break;
 373
 374         case ITEM_NOTHING:
 375             line++;
 376             break;
 377         }
 378
 379         /*
 380          * Intentional ReadItem() bug workaround.
 381          * Ungets '\n' every time, causing an infinite loop without this adjustment.
 382          */
 383         if ((csrc.CS_CurChr < csrc.CS_Length) && (buffer[csrc.CS_CurChr] == '\n'))
 384             csrc.CS_CurChr++;
 385     }
 386
 387    hdtbicon = GetIconTags("HDToolBox",
 388             ICONGETA_FailIfUnavailable, TRUE,
 389             ICONGETA_IsDefaultIcon, FALSE,
 390             TAG_DONE);
 391
 392     if (hdtbicon != NULL)
 393     {
 394 D(bug("[HDToolBox] Got our Icon..\n"));
 395         if (hdtbicon->do_ToolTypes)
 396         {
 397             char *tt = NULL, *devicename;
 398             int   i  = 0;
 399 D(bug("[HDToolBox] Icon has tooltypes..\n"));
 400
 401             while ((tt = hdtbicon->do_ToolTypes[i]) != NULL)
 402             {
 403                 if (strncmp(hdtbicon->do_ToolTypes[i], "DEVICE=", 7) == 0)
 404                 {
 405                     devicename = hdtbicon->do_ToolTypes[i] + 7;
 406 D(bug("[HDToolBox] Adding Device '%s' from ToolType\n", devicename));
 407                     addDeviceName(devicename);
 408                 }
 409                 i++;
 410             }
 411         }
 412     }
 413
 414     // EBR uses same types as MBR
 415     findTableTypeNode(PHPTT_EBR)->typelist =
 416         findTableTypeNode(PHPTT_MBR)->typelist;
 417
 418     return 0;
 419 }
 420
 421 void LoadPrefs(STRPTR filename)
 422 {
 423     struct FileInfoBlock fib;
 424     char *buffer;
 425     LONG retval;
 426     LONG size;
 427     BPTR fh;
 428
 429     D(bug("[HDToolBox] LoadPrefs('%s')\n", filename));
 430
 431     getTableTypeList(&tabletypelist);
 432     fh = Open(filename, MODE_OLDFILE);
 433     if (fh)
 434     {
 435         if (ExamineFH(fh, &fib))
 436         {
 437             if (fib.fib_Size>0)
 438             {
 439                 buffer = AllocMem(fib.fib_Size, MEMF_PUBLIC | MEMF_CLEAR);
 440                 if (buffer)
 441                 {
 442                     size = Read(fh, buffer, fib.fib_Size);
 443                     if (size == fib.fib_Size)
 444                     {
 445                         retval = parsePrefs(buffer, size);
 446                         if (retval)
 447                             PrintFault(retval, filename);
 448                     }
 449                     FreeMem(buffer, fib.fib_Size);
 450                 }
 451                 else
 452                     PrintFault(ERROR_NO_FREE_STORE, filename);
 453             }
 454         }
 455         Close(fh);
 456     }
 457     else
 458         PrintFault(IoErr(), filename);
 459 }