programs/regapi/regapi.c

   1 /*
   2  * Command line Registry implementation
   3  *
   4  * Copyright 1999 Sylvain St-Germain
   5  *
   6  * Note: Please consult the README file for more information.
   7  *
   8  */
   9
  10 #include <stdio.h>
  11 #include <malloc.h>
  12 #include <windows.h>
  13 #include <winreg.h>
  14 #include <winerror.h>
  15 #include <winnt.h>
  16 #include <string.h>
  17 #include <shell.h>
  18
  19 /******************************************************************************
  20  * Defines and consts
  21  */
  22 #define IDENTICAL             0
  23 #define COMMAND_COUNT         5
  24
  25 #define KEY_MAX_LEN           1024
  26 #define STDIN_MAX_LEN         2048
  27
  28 /* Return values */
  29 #define COMMAND_NOT_FOUND     -1
  30 #define SUCCESS               0
  31 #define NOT_ENOUGH_MEMORY     1
  32 #define KEY_VALUE_ALREADY_SET 2
  33 #define COMMAND_NOT_SUPPORTED 3
  34
  35 /* Generic global */
  36 static BOOL bForce            = FALSE; /* Is set to TRUE when -force is
  37                                           passed on the command line */
  38
  39 /* Globals used by the api setValue, queryValue */
  40 static LPSTR currentKeyName   = NULL;
  41 static HKEY  currentKeyClass  = NULL;
  42 static HKEY  currentKeyHandle = NULL;
  43 static BOOL  bTheKeyIsOpen    = FALSE;
  44
  45 /* Delimitors used to parse the "value"="data" pair for setValue*/
  46 #define SET_VALUE_MAX_ARGS    2
  47 /* Delimitors used to parse the "value" to query queryValue*/
  48 #define QUERY_VALUE_MAX_ARGS  1
  49
  50 static const char *setValueDelim[SET_VALUE_MAX_ARGS]   = {"=", ""};
  51 static const char *queryValueDelim[QUERY_VALUE_MAX_ARGS]   = {""};
  52
  53 /* Array used to extract the data type from a string in getDataType. */
  54 typedef struct tagDataTypeMap
  55 {
  56   char  mask[15];
  57   DWORD dataType;
  58 } dataTypeMap;
  59
  60 static const dataTypeMap typeMap[] =
  61 {
  62   {"hex:",            REG_BINARY},/* could be REG_NONE (?) */
  63   {"dword:",          REG_DWORD},
  64   {"hex(0):",         REG_NONE},
  65   {"hex(1):",         REG_SZ},
  66   {"hex(2):",         REG_EXPAND_SZ},
  67   {"hex(3):",         REG_BINARY},
  68   {"hex(4):",         REG_DWORD},
  69   {"hex(5):",         REG_DWORD_BIG_ENDIAN},
  70   {"hex(6):",         REG_LINK},
  71   {"hex(7):",         REG_MULTI_SZ},
  72   {"hex(8):",         REG_RESOURCE_LIST},
  73   {"hex(9):",         REG_FULL_RESOURCE_DESCRIPTOR},
  74   {"hex(80000000):",  REG_NONE},
  75   {"hex(80000001):",  REG_SZ},
  76   {"hex(80000002):",  REG_EXPAND_SZ},
  77   {"hex(80000003):",  REG_BINARY},
  78   {"hex(80000004):",  REG_DWORD},
  79   {"hex(80000005):",  REG_DWORD_BIG_ENDIAN},
  80   {"hex(80000006):",  REG_LINK},
  81   {"hex(80000007):",  REG_MULTI_SZ},
  82   {"hex(80000008):",  REG_RESOURCE_LIST},
  83   {"hex(80000009):",  REG_FULL_RESOURCE_DESCRIPTOR},
  84   {"hex(8000000a):",  REG_BINARY}, /* REG_RESOURCE_REQUIREMENTS_LIST}, !Exist */
  85   {"hex(8000000A):",  REG_BINARY}, /* REG_RESOURCE_REQUIREMENTS_LIST}, !Exist */
  86 };
  87 const static int LAST_TYPE_MAP = sizeof(typeMap)/sizeof(dataTypeMap);
  88
  89
  90 /*
  91  * Forward declaration
  92  */
  93 typedef void (*commandAPI)(LPSTR lpsLine);
  94
  95 static void doSetValue(LPSTR lpsLine);
  96 static void doDeleteValue(LPSTR lpsLine);
  97 static void doCreateKey(LPSTR lpsLine);
  98 static void doDeleteKey(LPSTR lpsLine);
  99 static void doQueryValue(LPSTR lpsLine);
 100
 101 /*
 102  * current suuported api
 103  */
 104 static const char* commandNames[COMMAND_COUNT] = {
 105   "setValue",
 106   "deleteValue",
 107   "createKey",
 108   "deleteKey",
 109   "queryValue"
 110 };
 111
 112 /*
 113  * Pointers to processing entry points
 114  */
 115 static const commandAPI commandAPIs[COMMAND_COUNT] = {
 116   doSetValue,
 117   doDeleteValue,
 118   doCreateKey,
 119   doDeleteKey,
 120   doQueryValue
 121 };
 122
 123 /*
 124  * This array controls the registry saving needs at the end of the process
 125  */
 126 static const BOOL commandSaveRegistry[COMMAND_COUNT] = {
 127   TRUE,
 128   TRUE,
 129   TRUE,
 130   TRUE,
 131   FALSE
 132 };
 133
 134 /*
 135  * Generic prototyes
 136  */
 137 static HKEY    getDataType(LPSTR *lpValue);
 138 static LPSTR   getRegKeyName(LPSTR lpLine);
 139 static HKEY    getRegClass(LPSTR lpLine);
 140 static LPSTR   getArg(LPSTR arg);
 141 static INT     getCommand(LPSTR commandName);
 142 static DWORD   convertHexToDWord(char *str, BYTE *buf);
 143 static DWORD   convertHexCSVToHex(char *str, BYTE *buf, ULONG bufLen);
 144 static LPSTR   convertHexToHexCSV( BYTE *buf, ULONG len);
 145 static LPSTR   convertHexToDWORDStr( BYTE *buf, ULONG len);
 146 static HRESULT openKey(LPSTR stdInput);
 147 static void    closeKey();
 148
 149 /*
 150  * api setValue prototypes
 151  */
 152 static void    processSetValue(LPSTR cmdline);
 153 static HRESULT setValue(LPSTR *argv);
 154
 155 /*
 156  * api queryValue prototypes
 157  */
 158 static void    processQueryValue(LPSTR cmdline);
 159
 160 /*
 161  * Help Text displyed when invalid parameters are provided
 162  */
 163 static char helpText[] = "
 164 NAME
 165           regapi - provide a command line interface to the wine registry.
 166
 167 SYNOPSYS
 168           regapi commandName [-force] < file
 169
 170 DESCRIPTION
 171           regapi allows editing the wine resgistry.  It processes the given
 172           commandName for every line in the stdin data stream.  Input data
 173           format may vary depending on the commandName see INPUT FILE FORMAT.
 174
 175 OPTIONS
 176           commandName
 177               Instruct regapi about what action to perform on the data stream.
 178               Currently, only setValue and queryValue are supported and
 179               implemented.
 180
 181           -force
 182               When provided the action will be performed anyway.  This may
 183               have a different meaning depending on the context.  For example,
 184               when providing -force to setValue, the value is set even if it
 185               was previously set to another value.
 186
 187           < file
 188               STDIN chanel, provide a file name with line of the appropriate
 189               format.
 190
 191 INPUT FILE FORMAT
 192
 193           setValue
 194               The input file format required by the setValue command is similar
 195               to the one obtained from regedit.exe export option.  The only
 196               difference is that multi line values are not supported, the
 197               value data must be on a single line.
 198
 199               [KEY_CLASS\\Some\\Path\\For\\A\\Key]
 200               \"Value1\"=\"Data1\"
 201               \"Value2\"=\"Data2\"
 202               \"Valuen\"=\"Datan\"
 203               ...
 204
 205           queryValue
 206               The input file format required by the queryValue command is
 207               similar to the one required by setValue.  The only
 208               difference is that you only provide the value name.
 209
 210               [KEY_CLASS\\Some\\Path\\For\\A\\Key]
 211               \"Value1\"
 212               \"Value2\"
 213               \"Valuen\"
 214               ...
 215                                 February 1999.
 216 ";
 217
 218
 219 /******************************************************************************
 220  * This funtion returns the HKEY associated with the data type encoded in the
 221  * value.  It modify the input parameter (key value) in order to skip this
 222  * "now useless" data type information.
 223  */
 224 HKEY getDataType(LPSTR *lpValue)
 225 {
 226   INT   counter  = 0;
 227   DWORD dwReturn = REG_SZ;
 228
 229   for (; counter < LAST_TYPE_MAP; counter++)
 230   {
 231     LONG len = strlen(typeMap[counter].mask);
 232     if ( strncmp( *lpValue, typeMap[counter].mask, len) == IDENTICAL)
 233     {
 234       /*
 235        * We found it, modify the value's pointer in order to skip the data
 236        * type identifier, set the return value and exit the loop.
 237        */
 238       (*lpValue) += len;
 239       dwReturn    = typeMap[counter].dataType;
 240       break;
 241     }
 242   }
 243
 244   return dwReturn;
 245 }
 246 /******************************************************************************
 247  * Extracts from a [HKEY\some\key\path] type of line the key name (what starts
 248  * after the first '\' and end before the ']'
 249  */
 250 LPSTR getRegKeyName(LPSTR lpLine)
 251 {
 252   LPSTR keyNameBeg = NULL;
 253   LPSTR keyNameEnd = NULL;
 254   char  lpLineCopy[KEY_MAX_LEN];
 255
 256   if (lpLine == NULL)
 257     return NULL;
 258
 259   strcpy(lpLineCopy, lpLine);
 260
 261   keyNameBeg  = strstr(lpLineCopy, "\\");  /* The key name start by '\' */
 262   keyNameBeg++;                            /* but is not part of the key name */
 263   keyNameEnd  = strstr(lpLineCopy, "]");   /* The key name end by ']' */
 264   *keyNameEnd = NULL;                      /* Isolate the key name */
 265
 266   currentKeyName = HeapAlloc(GetProcessHeap(), 0, strlen(keyNameBeg)+1);
 267   if (currentKeyName != NULL)
 268     strcpy(currentKeyName, keyNameBeg);
 269
 270   return currentKeyName;
 271 }
 272
 273 /******************************************************************************
 274  * Extracts from a [HKEY/some/key/path] type of line the key class (what
 275  * starts after the '[' and end before the first '\'
 276  */
 277 static HKEY getRegClass(LPSTR lpClass)
 278 {
 279   LPSTR classNameEnd;
 280   LPSTR classNameBeg;
 281
 282   char  lpClassCopy[KEY_MAX_LEN];
 283
 284   if (lpClass == NULL)
 285     return ERROR_INVALID_PARAMETER;
 286
 287   strcpy(lpClassCopy, lpClass);
 288
 289   classNameEnd  = strstr(lpClassCopy, "\\");  /* The class name end by '\' */
 290   *classNameEnd = NULL;                       /* Isolate the class name */
 291   classNameBeg  = &lpClassCopy[1];            /* Skip the '[' */
 292
 293   if      (strcmp( classNameBeg, "HKEY_LOCAL_MACHINE") == IDENTICAL )
 294     return  HKEY_LOCAL_MACHINE;
 295   else if (strcmp( classNameBeg, "HKEY_USERS") == IDENTICAL )
 296     return  HKEY_USERS;
 297   else if (strcmp( classNameBeg, "HKEY_CLASSES_ROOT") == IDENTICAL )
 298     return  HKEY_CLASSES_ROOT;
 299   else if (strcmp( classNameBeg, "HKEY_CURRENT_CONFIG") == IDENTICAL )
 300     return  HKEY_CURRENT_CONFIG;
 301   else if (strcmp( classNameBeg, "HKEY_CURRENT_USER") == IDENTICAL )
 302     return  HKEY_CURRENT_USER;
 303   else
 304     return ERROR_INVALID_PARAMETER;
 305 }
 306
 307 /******************************************************************************
 308  * Returns an allocated buffer with a cleaned copy (removed the surrounding
 309  * dbl quotes) of the passed value.
 310  */
 311 static LPSTR getArg( LPSTR arg)
 312 {
 313   LPSTR tmp = NULL;
 314   ULONG len;
 315
 316   if (arg == NULL)
 317     return NULL;
 318
 319   /*
 320    * Get rid of surrounding quotes
 321    */
 322   len = strlen(arg);
 323
 324   if( arg[len-1] == '\"' ) arg[len-1] = NULL;
 325   if( arg[0]     == '\"' ) arg++;
 326
 327   tmp = HeapAlloc(GetProcessHeap(), 0, strlen(arg)+1);
 328   strcpy(tmp, arg);
 329
 330   return tmp;
 331 }
 332
 333 /******************************************************************************
 334  * Returns the index in the commands array of the command to process.
 335  */
 336 static INT getCommand(LPSTR commandName)
 337 {
 338   INT count;
 339   for (count=0; count < COMMAND_COUNT; count++)
 340     if ( strcmp(commandName, commandNames[count]) == IDENTICAL)
 341       return count;
 342
 343   return COMMAND_NOT_FOUND;
 344 }
 345
 346 /******************************************************************************
 347  * Converts a hex representation of a DWORD into a DWORD.
 348  */
 349 static DWORD convertHexToDWord(char *str, BYTE *buf)
 350 {
 351   char  *s        = str;  /* Pointer to current */
 352   char  *b        = buf;  /* Pointer to result  */
 353   ULONG strPos    = 0;
 354
 355   memset(buf, 0, 4);
 356
 357   while (strPos < 4)  /* 8 byte in a DWORD */
 358   {
 359     char xbuf[3];
 360     char wc;
 361
 362     memcpy(xbuf,s,2); xbuf[2]='\0';
 363     sscanf(xbuf,"%02x",(UINT*)&wc);
 364     *b++ =(unsigned char)wc;
 365
 366     s+=2;
 367     strPos+=1;
 368   }
 369
 370   return 4; /* always 4 byte for the word */
 371 }
 372
 373 /******************************************************************************
 374  * Converts a hex buffer into a hex coma separated values
 375  */
 376 static char* convertHexToHexCSV(BYTE *buf, ULONG bufLen)
 377 {
 378   char* str;
 379   char* ptrStr;
 380   BYTE* ptrBuf;
 381
 382   ULONG current = 0;
 383
 384   str    = HeapAlloc(GetProcessHeap(), 0, (bufLen+1)*2);
 385   memset(str, 0, (bufLen+1)*2);
 386   ptrStr = str;  /* Pointer to result  */
 387   ptrBuf = buf;  /* Pointer to current */
 388
 389   while (current < bufLen)
 390   {
 391     BYTE bCur = ptrBuf[current++];
 392     char res[3];
 393
 394     sprintf(res, "%02x", (unsigned int)*&bCur);
 395     strcat(str, res);
 396     strcat(str, ",");
 397   }
 398
 399   /* Get rid of the last coma */
 400   str[strlen(str)-1] = NULL;
 401   return str;
 402 }
 403
 404 /******************************************************************************
 405  * Converts a hex buffer into a DWORD string
 406  */
 407 static char* convertHexToDWORDStr(BYTE *buf, ULONG bufLen)
 408 {
 409   char* str;
 410   char* ptrStr;
 411   BYTE* ptrBuf;
 412
 413   ULONG current = 0;
 414
 415   str    = HeapAlloc(GetProcessHeap(), 0, (bufLen*2)+1);
 416   memset(str, 0, (bufLen*2)+1);
 417   ptrStr = str;  /* Pointer to result  */
 418   ptrBuf = buf;  /* Pointer to current */
 419
 420   while (current < bufLen)
 421   {
 422     BYTE bCur = ptrBuf[current++];
 423     char res[3];
 424
 425     sprintf(res, "%02x", (unsigned int)*&bCur);
 426     strcat(str, res);
 427   }
 428
 429   /* Get rid of the last coma */
 430   return str;
 431 }
 432 /******************************************************************************
 433  * Converts a hex coma separated values list into a hex list.
 434  */
 435 static DWORD convertHexCSVToHex(char *str, BYTE *buf, ULONG bufLen)
 436 {
 437   char *s = str;  /* Pointer to current */
 438   char *b = buf;  /* Pointer to result  */
 439
 440   ULONG strLen    = strlen(str);
 441   ULONG strPos    = 0;
 442   DWORD byteCount = 0;
 443
 444   memset(buf, 0, bufLen);
 445
 446   /*
 447    * warn the user if we are here with a string longer than 2 bytes that does
 448    * not contains ",".  It is more likely because the data is invalid.
 449    */
 450   if ( ( strlen(str) > 2) && ( strstr(str, ",") == NULL) )
 451     printf("regapi: WARNING converting CSV hex stream with no coma, "
 452            "input data seems invalid.\n");
 453
 454   while (strPos < strLen)
 455   {
 456     char xbuf[3];
 457     char wc;
 458
 459     memcpy(xbuf,s,2); xbuf[3]='\0';
 460     sscanf(xbuf,"%02x",(UINT*)&wc);
 461     *b++ =(unsigned char)wc;
 462
 463     s+=3;
 464     strPos+=3;
 465     byteCount++;
 466   }
 467
 468   return byteCount;
 469 }
 470
 471
 472 /******************************************************************************
 473  * Sets the value in argv[0] to the data in argv[1] for the currently
 474  * opened key.
 475  */
 476 static HRESULT setValue(LPSTR *argv)
 477 {
 478   HRESULT hRes;
 479   DWORD   dwSize          = KEY_MAX_LEN;
 480   DWORD   dwType          = NULL;
 481   DWORD   dwDataType;
 482
 483   CHAR    lpsCurrentValue[KEY_MAX_LEN];
 484
 485   LPSTR   keyValue = argv[0];
 486   LPSTR   keyData  = argv[1];
 487
 488   /* Make some checks */
 489   if ( (keyValue == NULL) || (keyData == NULL) )
 490     return ERROR_INVALID_PARAMETER;
 491
 492   /*
 493    * Default registry values are encoded in the input stream as '@' but as
 494    * blank in the wine registry.
 495    */
 496   if( (keyValue[0] == '@') && (strlen(keyValue) == 1) )
 497     keyValue[0] = NULL;
 498
 499   /* Get the data type stored into the value field */
 500   dwDataType = getDataType(&keyData);
 501
 502   memset(lpsCurrentValue, 0, KEY_MAX_LEN);
 503   hRes = RegQueryValueExA(
 504           currentKeyHandle,
 505           keyValue,
 506           NULL,
 507           &dwType,
 508           (LPBYTE)lpsCurrentValue,
 509           &dwSize);
 510
 511   if( ( strlen(lpsCurrentValue) == 0 ) ||  /* The value is not existing */
 512       ( bForce ))         /* -force option */
 513   {
 514     LPBYTE lpbData;
 515     BYTE   convert[KEY_MAX_LEN];
 516     DWORD  dwLen;
 517
 518     if ( dwDataType == REG_SZ )        /* no convertion for string */
 519     {
 520       dwLen   = strlen(keyData);
 521       lpbData = keyData;
 522     }
 523     else if (dwDataType == REG_DWORD)  /* Convert the dword types */
 524     {
 525       dwLen   = convertHexToDWord(keyData, convert);
 526       lpbData = convert;
 527     }
 528     else                               /* Convert the hexadecimal types */
 529     {
 530       dwLen   = convertHexCSVToHex(keyData, convert, KEY_MAX_LEN);
 531       lpbData = convert;
 532     }
 533
 534     hRes = RegSetValueEx(
 535             currentKeyHandle,
 536             keyValue,
 537             0,                  /* Reserved */
 538             dwDataType,
 539             lpbData,
 540             dwLen);
 541   }
 542   else
 543   {
 544     /* return the current value data into argv[1] */
 545     if (argv[1] != NULL)
 546     {
 547       HeapFree(GetProcessHeap(), 0, argv[1]);
 548       argv[1] = HeapAlloc(GetProcessHeap(), 0, dwSize+1);
 549
 550       if ( argv[1] != NULL )
 551         strncpy(argv[1], lpsCurrentValue, dwSize);
 552     }
 553
 554     return KEY_VALUE_ALREADY_SET;
 555   }
 556   return hRes;
 557 }
 558
 559
 560 /******************************************************************************
 561  * Open the key
 562  */
 563 static HRESULT openKey( LPSTR stdInput)
 564 {
 565   DWORD   dwDisp;
 566   HRESULT hRes;
 567
 568   /* Sanity checks */
 569   if (stdInput == NULL)
 570     return ERROR_INVALID_PARAMETER;
 571
 572   /* Get the registry class */
 573   currentKeyClass = getRegClass(stdInput); /* Sets global variable */
 574   if (currentKeyClass == ERROR_INVALID_PARAMETER)
 575     return ERROR_INVALID_PARAMETER;
 576
 577   /* Get the key name */
 578   currentKeyName = getRegKeyName(stdInput); /* Sets global variable */
 579   if (currentKeyName == NULL)
 580     return ERROR_INVALID_PARAMETER;
 581
 582   hRes = RegCreateKeyEx(
 583           currentKeyClass,          /* Class     */
 584           currentKeyName,           /* Sub Key   */
 585           0,                        /* MUST BE 0 */
 586           NULL,                     /* object type */
 587           REG_OPTION_NON_VOLATILE,  /* option, REG_OPTION_NON_VOLATILE ... */
 588           KEY_ALL_ACCESS,           /* access mask, KEY_ALL_ACCESS */
 589           NULL,                     /* security attribute */
 590           &currentKeyHandle,        /* result */
 591           &dwDisp);                 /* disposition, REG_CREATED_NEW_KEY or
 592                                                     REG_OPENED_EXISTING_KEY */
 593
 594   if (hRes == ERROR_SUCCESS)
 595     bTheKeyIsOpen = TRUE;
 596
 597   return hRes;
 598
 599 }
 600 /******************************************************************************
 601  * This function is a wrapper arround the setValue function.  It prepares the
 602  * land and clean the area once completed.
 603  */
 604 static void processSetValue(LPSTR cmdline)
 605 {
 606   LPSTR argv[SET_VALUE_MAX_ARGS];  /* args storage    */
 607
 608   LPSTR token         = NULL;      /* current token analized */
 609   ULONG argCounter    = 0;         /* counter of args */
 610   INT   counter;
 611   HRESULT hRes = NULL;
 612
 613   /*
 614    * Init storage and parse the line
 615    */
 616   for (counter=0; counter<SET_VALUE_MAX_ARGS; counter++)
 617     argv[counter]=NULL;
 618
 619   while( (token = strsep(&cmdline, setValueDelim[argCounter])) != NULL )
 620   {
 621     argv[argCounter++] = getArg(token);
 622
 623     if (argCounter == SET_VALUE_MAX_ARGS)
 624       break;  /* Stop processing args no matter what */
 625   }
 626
 627   hRes = setValue(argv);
 628   if ( hRes == ERROR_SUCCESS )
 629     printf(
 630       "regapi: Value \"%s\" has been set to \"%s\" in key [%s]\n",
 631       argv[0],
 632       argv[1],
 633       currentKeyName);
 634
 635   else if ( hRes == KEY_VALUE_ALREADY_SET )
 636     printf(
 637       "regapi: Value \"%s\" already set to \"%s\" in key [%s]\n",
 638       argv[0],
 639       argv[1],
 640       currentKeyName);
 641
 642   else
 643     printf("regapi: ERROR Key %s not created. Value: %s, Data: %s\n",
 644       currentKeyName,
 645       argv[0],
 646       argv[1]);
 647
 648   /*
 649    * Do some cleanup
 650    */
 651   for (counter=0; counter<argCounter; counter++)
 652     if (argv[counter] != NULL)
 653       HeapFree(GetProcessHeap(), 0, argv[counter]);
 654 }
 655
 656 /******************************************************************************
 657  * This function is a wrapper arround the queryValue function.  It prepares the
 658  * land and clean the area once completed.
 659  */
 660 static void processQueryValue(LPSTR cmdline)
 661 {
 662   LPSTR   argv[QUERY_VALUE_MAX_ARGS];/* args storage    */
 663   LPSTR   token      = NULL;         /* current token analized */
 664   ULONG   argCounter = 0;            /* counter of args */
 665   INT     counter;
 666   HRESULT hRes       = NULL;
 667   LPSTR   keyValue   = NULL;
 668   LPSTR   lpsRes     = NULL;
 669
 670   /*
 671    * Init storage and parse the line
 672    */
 673   for (counter=0; counter<QUERY_VALUE_MAX_ARGS; counter++)
 674     argv[counter]=NULL;
 675
 676   while( (token = strsep(&cmdline, queryValueDelim[argCounter])) != NULL )
 677   {
 678     argv[argCounter++] = getArg(token);
 679
 680     if (argCounter == QUERY_VALUE_MAX_ARGS)
 681       break;  /* Stop processing args no matter what */
 682   }
 683
 684   /* The value we look for is the first token on the line */
 685   if ( argv[0] == NULL )
 686     return; /* SHOULD NOT OCCURS */
 687   else
 688     keyValue = argv[0];
 689
 690   if( (keyValue[0] == '@') && (strlen(keyValue) == 1) )
 691   {
 692     LONG  lLen  = KEY_MAX_LEN;
 693     CHAR  lpsData[KEY_MAX_LEN];
 694     /*
 695      * We need to query the key default value
 696      */
 697     hRes = RegQueryValue(
 698              currentKeyHandle,
 699              currentKeyName,
 700              (LPBYTE)lpsData,
 701              &lLen);
 702
 703     if (hRes == ERROR_SUCCESS)
 704     {
 705       lpsRes = HeapAlloc( GetProcessHeap(), 0, lLen);
 706       strncpy(lpsRes, lpsData, lLen);
 707     }
 708   }
 709   else
 710   {
 711     DWORD  dwLen  = KEY_MAX_LEN;
 712     BYTE   lpbData[KEY_MAX_LEN];
 713     DWORD  dwType;
 714     /*
 715      * We need to query a specific value for the key
 716      */
 717     hRes = RegQueryValueEx(
 718              currentKeyHandle,
 719              keyValue,
 720              0,
 721              &dwType,
 722              (LPBYTE)lpbData,
 723              &dwLen);
 724
 725     if (hRes == ERROR_SUCCESS)
 726     {
 727       /*
 728        * Convert the returned data to a displayable format
 729        */
 730       switch ( dwType )
 731       {
 732         case REG_SZ:
 733         {
 734           lpsRes = HeapAlloc( GetProcessHeap(), 0, dwLen);
 735           strncpy(lpsRes, lpbData, dwLen);
 736           break;
 737         }
 738         case REG_DWORD:
 739         {
 740           lpsRes = convertHexToDWORDStr(lpbData, dwLen);
 741           break;
 742         }
 743         default:
 744         {
 745           lpsRes = convertHexToHexCSV(lpbData, dwLen);
 746           break;
 747         }
 748       }
 749     }
 750   }
 751
 752
 753   if ( hRes == ERROR_SUCCESS )
 754     printf(
 755       "regapi: Value \"%s\" = \"%s\" in key [%s]\n",
 756       keyValue,
 757       lpsRes,
 758       currentKeyName);
 759
 760   else
 761     printf("regapi: ERROR Value \"%s\" not found. for key \"%s\"\n",
 762       keyValue,
 763       currentKeyName);
 764
 765   /*
 766    * Do some cleanup
 767    */
 768   for (counter=0; counter<argCounter; counter++)
 769     if (argv[counter] != NULL)
 770       HeapFree(GetProcessHeap(), 0, argv[counter]);
 771
 772   if (lpsRes != NULL)
 773     HeapFree(GetProcessHeap(), 0, lpsRes);
 774
 775 }
 776
 777 /******************************************************************************
 778  * Close the currently opened key.
 779  */
 780 static void closeKey()
 781 {
 782   RegCloseKey(currentKeyHandle);
 783
 784   HeapFree(GetProcessHeap(), 0, currentKeyName); /* Allocated by getKeyName */
 785
 786   bTheKeyIsOpen    = FALSE;
 787
 788   currentKeyName   = NULL;
 789   currentKeyClass  = NULL;
 790   currentKeyHandle = NULL;
 791 }
 792
 793 /******************************************************************************
 794  * This funtion is the main entry point to the setValue type of action.  It
 795  * receives the currently read line and dispatch the work depending on the
 796  * context.
 797  */
 798 static void doSetValue(LPSTR stdInput)
 799 {
 800   /*
 801    * We encoutered the end of the file, make sure we
 802    * close the opened key and exit
 803    */
 804   if (stdInput == NULL)
 805   {
 806     if (bTheKeyIsOpen != FALSE)
 807       closeKey();
 808
 809     return;
 810   }
 811
 812   if      ( stdInput[0] == '[')      /* We are reading a new key */
 813   {
 814     if ( bTheKeyIsOpen != FALSE )
 815       closeKey();                    /* Close the previous key before */
 816
 817     if ( openKey(stdInput) != ERROR_SUCCESS )
 818       printf ("regapi: doSetValue failed to open key %s\n", stdInput);
 819   }
 820   else if( ( bTheKeyIsOpen ) &&
 821            (( stdInput[0] == '@') || /* reading a default @=data pair */
 822             ( stdInput[0] == '\"'))) /* reading a new value=data pair */
 823   {
 824     processSetValue(stdInput);
 825   }
 826   else                               /* since we are assuming that the */
 827   {                                  /* file format is valid we must   */
 828     if ( bTheKeyIsOpen )             /* be reading a blank line which  */
 829       closeKey();                    /* indicate end of this key processing */
 830   }
 831 }
 832
 833 /******************************************************************************
 834  * This funtion is the main entry point to the queryValue type of action.  It
 835  * receives the currently read line and dispatch the work depending on the
 836  * context.
 837  */
 838 static void doQueryValue(LPSTR stdInput) {
 839   /*
 840    * We encoutered the end of the file, make sure we
 841    * close the opened key and exit
 842    */
 843   if (stdInput == NULL)
 844   {
 845     if (bTheKeyIsOpen != FALSE)
 846       closeKey();
 847
 848     return;
 849   }
 850
 851   if      ( stdInput[0] == '[')      /* We are reading a new key */
 852   {
 853     if ( bTheKeyIsOpen != FALSE )
 854       closeKey();                    /* Close the previous key before */
 855
 856     if ( openKey(stdInput) != ERROR_SUCCESS )
 857       printf ("regapi: doSetValue failed to open key %s\n", stdInput);
 858   }
 859   else if( ( bTheKeyIsOpen ) &&
 860            (( stdInput[0] == '@') || /* reading a default @=data pair */
 861             ( stdInput[0] == '\"'))) /* reading a new value=data pair */
 862   {
 863     processQueryValue(stdInput);
 864   }
 865   else                               /* since we are assuming that the */
 866   {                                  /* file format is valid we must   */
 867     if ( bTheKeyIsOpen )             /* be reading a blank line which  */
 868       closeKey();                    /* indicate end of this key processing */
 869   }
 870 }
 871
 872 /******************************************************************************
 873  * This funtion is the main entry point to the deletetValue type of action.  It
 874  * receives the currently read line and dispatch the work depending on the
 875  * context.
 876  */
 877 static void doDeleteValue(LPSTR line) {
 878   printf ("regapi: deleteValue not yet implemented\n");
 879 }
 880 /******************************************************************************
 881  * This funtion is the main entry point to the deleteKey type of action.  It
 882  * receives the currently read line and dispatch the work depending on the
 883  * context.
 884  */
 885 static void doDeleteKey(LPSTR line)   {
 886   printf ("regapi: deleteKey not yet implemented\n");
 887 }
 888 /******************************************************************************
 889  * This funtion is the main entry point to the createKey type of action.  It
 890  * receives the currently read line and dispatch the work depending on the
 891  * context.
 892  */
 893 static void doCreateKey(LPSTR line)   {
 894   printf ("regapi: createKey not yet implemented\n");
 895 }
 896
 897 /******************************************************************************
 898  * MAIN - The main simply validate the first parameter (command to perform)
 899  *        It then read the STDIN lines by lines forwarding their processing
 900  *        to the appropriate method.
 901  */
 902 int PASCAL WinMain (HANDLE inst, HANDLE prev, LPSTR cmdline, int show)
 903 {
 904   LPSTR  token          = NULL;  /* current token analized */
 905   LPSTR  stdInput       = NULL;  /* line read from stdin */
 906   INT    cmdIndex       = -1;    /* index of the command in array */
 907
 908   stdInput = HeapAlloc(GetProcessHeap(), 0, STDIN_MAX_LEN);
 909   if (stdInput == NULL)
 910     return NOT_ENOUGH_MEMORY;
 911
 912   /*
 913    * get the command, should be the first arg (modify cmdLine)
 914    */
 915   token = strsep(&cmdline, " ");
 916   if (token != NULL)
 917   {
 918     cmdIndex = getCommand(token);
 919     if (cmdIndex == COMMAND_NOT_FOUND)
 920     {
 921       printf("regapi: Command \"%s\" is not supported.\n", token);
 922       printf(helpText);
 923       return COMMAND_NOT_SUPPORTED;
 924     }
 925   }
 926   else
 927   {
 928     printf(
 929       "regapi: The first item on the command line must be the command name.\n");
 930     printf(helpText);
 931     return COMMAND_NOT_SUPPORTED;
 932   }
 933
 934   /*
 935    * check to see weather we force the action
 936    * (meaning differ depending on the command performed)
 937    */
 938   if ( cmdline != NULL ) /* will be NULL if '-force' is not provided */
 939     if ( strstr(cmdline, "-force") != NULL )
 940       bForce = TRUE;
 941
 942   printf("Processing stdin...\n");
 943
 944   while ( TRUE )
 945   {
 946     /*
 947      * read a line
 948      */
 949     stdInput = fgets(stdInput, STDIN_MAX_LEN, stdin);
 950
 951     /*
 952      * Make some handy generic stuff here...
 953      */
 954     if ( stdInput != NULL )
 955     {
 956       stdInput[strlen(stdInput) -1] = NULL; /* get rid of new line */
 957
 958       if( stdInput[0] == '#' )              /* this is a comment, skip */
 959         continue;
 960     }
 961
 962     /*
 963      * We process every lines even the NULL (last) line, to indicate the
 964      * end of the processing to the specific process.
 965      */
 966     commandAPIs[cmdIndex](stdInput);
 967
 968     if (stdInput == NULL)  /* EOF encountered */
 969       break;
 970   }
 971
 972   /*
 973    * Save the registry only if it was modified
 974    */
 975   if ( commandSaveRegistry[cmdIndex] != FALSE )
 976     SHELL_SaveRegistry();
 977
 978   HeapFree(GetProcessHeap(), 0, stdInput);
 979   return SUCCESS;
 980 }
 981
 982
 983