Changeset 7933 for trunk/tools

Timestamp:

Feb 16, 2002, 5:29:55 PM (24 years ago)

Author:

sandervl

Message:

Wine update

Location:

trunk/tools/regedit

Files:

• README (modified) (5 diffs)
• regapi.c (modified) (19 diffs)

trunk/tools/regedit/README

@@ -27 +27 @@
   1 - Parse the before.reg and after.reg file into regFixer.pl, in order to 
       obtain lines in the form [HKEY\Sub1\Sub2\...\Subn]"Value"="Data"  
-      (where "Data" can be prefixed by the type identifyer : hex:, hex(0000000?) 
+      (where "Data" can be prefixed by the type identifier : hex:, hex(0000000?) 
       or dword:)
 
@@ -34 +34 @@
 
   Now we have a app.reg file that contain what has been done by installing the
-  application.  To this we extract the part's that we are interested in using 
+  application.  To this we extract the parts that we are interested in using 
   grep (and fix it with sed) and put that into app.added by example 
-  ( let say we keep the added values only ).
+  ( let's say we keep the added values only ).
 
   At this point we know which registry entry to add to the wine registry.  It 
@@ -43 +43 @@
 
   I say "similar" because there is a tiny difference between Windows regedit 
-  export format and the format actualy required by the tool.
+  export format and the format actually required by the tool.
 
-  The problem with this (and it is not a big one) is that regedit export long 
-  data streams onto many lines, and since I dont have tons of time I setup 
+  The problem with this (and it is not a big one) is that regedit exports long 
+  data streams onto many lines, and since I don't have tons of time I setup 
   another Perl script (regRestorer.pl) that fixes this (this could easily 
-  be done in C obviously) (left as excercise ;-) ).  
+  be done in C obviously) (left as exercise ;-) ).  
     
-  So, once you parsed app.added into regRestorer.pl you get a app.reg ready to 
+  So, once you parsed app.added into regRestorer.pl you get an app.reg ready to 
   process by regapi.
 
@@ -61 +61 @@
                     something "regapi-able"
   
-  regSet          - Will do the procedure explained herein 
+  regSet.sh       - Will do the procedure explained herein 
                     for the added key only.
 
@@ -71 +71 @@
   -----------------
   1 - Get a snapshot of your windows registry in before.reg, (regedit/export)
-  2 - Install you're application,
+  2 - Install your application,
   3 - Get a snapshot of your windows registry in after.reg.
   4 - Invoke ./regSet.sh before.reg after.reg

trunk/tools/regedit/regapi.c

@@ -69 +69 @@
 #define QUERY_VALUE_MAX_ARGS  1 
 
-static const char *setValueDelim[SET_VALUE_MAX_ARGS]   = {"=", ""};  
-static const char *queryValueDelim[QUERY_VALUE_MAX_ARGS]   = {""};  
-
-/* Array used to extract the data type from a string in getDataType. */
-typedef struct tagDataTypeMap
-{
-  char  mask[15];
-  DWORD dataType;
-} dataTypeMap; 
-  
-static const dataTypeMap typeMap[] = 
-{
-  {"hex:",            REG_BINARY},/* could be REG_NONE (?) */
-  {"dword:",          REG_DWORD},
-  {"hex(0):",         REG_NONE},
-  {"hex(1):",         REG_SZ},
-  {"hex(2):",         REG_EXPAND_SZ},
-  {"hex(3):",         REG_BINARY},
-  {"hex(4):",         REG_DWORD},
-  {"hex(5):",         REG_DWORD_BIG_ENDIAN},
-  {"hex(6):",         REG_LINK},
-  {"hex(7):",         REG_MULTI_SZ},
-  {"hex(8):",         REG_RESOURCE_LIST},
-  {"hex(9):",         REG_FULL_RESOURCE_DESCRIPTOR},
-  {"hex(10):",        REG_RESOURCE_REQUIREMENTS_LIST},
-  {"hex(80000000):",  0x80000000},
-  {"hex(80000001):",  0x80000001},
-  {"hex(80000002):",  0x80000002},
-  {"hex(80000003):",  0x80000003},
-  {"hex(80000004):",  0x80000004},
-  {"hex(80000005):",  0x80000005},
-  {"hex(80000006):",  0x80000006},
-  {"hex(80000007):",  0x80000007},
-  {"hex(80000008):",  0x80000008},
-  {"hex(80000009):",  0x80000000},
-  {"hex(8000000a):",  0x8000000A}
-};
-const static int LAST_TYPE_MAP = sizeof(typeMap)/sizeof(dataTypeMap);
+static const char *setValueDelim[SET_VALUE_MAX_ARGS]   = {"=", ""};
+static const char *queryValueDelim[QUERY_VALUE_MAX_ARGS]   = {""};
 
 
@@ -164 +128 @@
  * Generic prototypes
  */
-static DWORD   getDataType(LPSTR *lpValue);
+static DWORD   getDataType(LPSTR *lpValue, DWORD* parse_type);
 static LPSTR   getRegKeyName(LPSTR lpLine);
 static HKEY    getRegClass(LPSTR lpLine);
@@ -250 +214 @@
 "                                February 1999.\n"
 ;
-              
+
 
 /******************************************************************************
@@ -256 +220 @@
  * value.  It modifies the input parameter (key value) in order to skip this 
  * "now useless" data type information.
- */
-DWORD getDataType(LPSTR *lpValue) 
-{
-  INT   counter  = 0;
-  DWORD dwReturn = REG_SZ;
-
-  for (; counter < LAST_TYPE_MAP; counter++)
-  {
-    LONG len = strlen(typeMap[counter].mask);
-    if ( strncasecmp( *lpValue, typeMap[counter].mask, len) == IDENTICAL)
+ *
+ * Note: Updated based on the algorithm used in 'server/registry.c'
+ */
+DWORD getDataType(LPSTR *lpValue, DWORD* parse_type)
+{
+    struct data_type { const char *tag; int len; int type; int parse_type; };
+
+    static const struct data_type data_types[] =
+    {                   /* actual type */  /* type to assume for parsing */
+        { "\"",        1,   REG_SZ,              REG_SZ },
+        { "str:\"",    5,   REG_SZ,              REG_SZ },
+        { "str(2):\"", 8,   REG_EXPAND_SZ,       REG_SZ },
+        { "str(7):\"", 8,   REG_MULTI_SZ,        REG_SZ },
+        { "hex:",      4,   REG_BINARY,          REG_BINARY },
+        { "dword:",    6,   REG_DWORD,           REG_DWORD },
+        { "hex(",      4,   -1,                  REG_BINARY },
+        { NULL,        0,    0,                  0 }
+    };
+
+    const struct data_type *ptr;
+    int type;
+
+    for (ptr = data_types; ptr->tag; ptr++)
     {
-      /*
-       * We found it, modify the value's pointer in order to skip the data 
-       * type identifier, set the return value and exit the loop.
-       */
-      (*lpValue) += len;
-      dwReturn    = typeMap[counter].dataType;
-      break; 
-    }
-  }
-
-  return dwReturn;
-}
+        if (memcmp( ptr->tag, *lpValue, ptr->len ))
+            continue;
+
+        /* Found! */
+        *parse_type = ptr->parse_type;
+        type=ptr->type;
+        *lpValue+=ptr->len;
+        if (type == -1) {
+            char* end;
+            /* "hex(xx):" is special */
+            *lpValue += 4;
+            type = (int)strtoul( *lpValue , &end, 16 );
+            if (**lpValue=='\0' || *end!=')' || *(end+1)!=':') {
+                type=REG_NONE;
+            } else {
+                *lpValue=end+2;
+            }
+        }
+        return type;
+    }
+    return (**lpValue=='\0'?REG_SZ:REG_NONE);
+}
+
 /******************************************************************************
  * Extracts from a [HKEY\some\key\path] type of line the key name (what starts 
@@ -341 +329 @@
 
 /******************************************************************************
+ * This is a replacement for strsep which is not portable (missing on Solaris).
+ */
+static char* getToken(char** str, const char* delims)
+{
+    char* token;
+
+    if (*str==NULL) {
+        /* No more tokens */
+        return NULL;
+    }
+
+    token=*str;
+    while (**str!='\0') {
+        if (strchr(delims,**str)!=NULL) {
+            **str='\0';
+            (*str)++;
+            return token;
+        }
+        (*str)++;
+    }
+    /* There is no other token */
+    *str=NULL;
+    return token;
+}
+
+/******************************************************************************
  * Returns an allocated buffer with a cleaned copy (removed the surrounding 
  * dbl quotes) of the passed value.
@@ -384 +398 @@
 static DWORD convertHexToDWord(char *str, BYTE *buf)
 {
-  char  *s        = str;  /* Pointer to current */
-  char  *b        = buf;  /* Pointer to result  */
-  ULONG strPos    = 0;    
-
-  memset(buf, 0, 4);
-
-  while (strPos < 4)  /* 8 byte in a DWORD */
-  {
-    char xbuf[3];
-    char wc;
-
-    memcpy(xbuf,s,2); xbuf[2]='\0';
-    sscanf(xbuf,"%02x",(UINT*)&wc);
-    *b++ =(unsigned char)wc;
-
-    s+=2;
-    strPos+=1;
-  }                                   
-
-  return 4; /* always 4 byte for the word */
+  DWORD dw;
+  char xbuf[9];
+
+  memcpy(xbuf,str,8);
+  xbuf[8]='\0';
+  sscanf(xbuf,"%08lx",&dw);
+  memcpy(buf,&dw,sizeof(DWORD));
+  return sizeof(DWORD);
 }
 
@@ -443 +445 @@
 {
   char* str;
-  char* ptrStr;
-  BYTE* ptrBuf;
-
-  ULONG current = 0;
-
-  str    = HeapAlloc(GetProcessHeap(), 0, (bufLen*2)+1);
-  memset(str, 0, (bufLen*2)+1);
-  ptrStr = str;  /* Pointer to result  */
-  ptrBuf = buf;  /* Pointer to current */
-
-  while (current < bufLen)
-  {
-    BYTE bCur = ptrBuf[current++];
-    char res[3];
-
-    sprintf(res, "%02x", (unsigned int)*&bCur);
-    strcat(str, res);
-  }                                   
+  DWORD dw;
+
+  if ( bufLen != sizeof(DWORD) ) return NULL;
+
+  str = HeapAlloc(GetProcessHeap(), 0, (bufLen*2)+1);
+
+  memcpy(&dw,buf,sizeof(DWORD));
+  sprintf(str, "%08lx", dw);
 
   /* Get rid of the last comma */
@@ -514 +506 @@
   DWORD   dwSize          = KEY_MAX_LEN;
   DWORD   dwType          = 0;
-  DWORD   dwDataType;
+  DWORD   dwDataType,dwParseType;
 
   LPSTR   lpsCurrentValue;
 
-  LPSTR   keyValue = argv[0];
+  LPSTR   keyValue = getArg(argv[0]);
   LPSTR   keyData  = argv[1];
 
@@ -534 +526 @@
 
   /* Get the data type stored into the value field */
-  dwDataType = getDataType(&keyData);
-    
+  dwDataType = getDataType(&keyData,&dwParseType);
+
   memset(lpsCurrentValue, 0, KEY_MAX_LEN);
   hRes = RegQueryValueExA(
@@ -558 +550 @@
     DWORD  dwLen;
 
-    if ( dwDataType == REG_SZ )        /* no convertion for string */
+    if ( dwParseType == REG_SZ)        /* no conversion for string */
     {
       dwLen   = strlen(keyData);
+      if (dwLen>0 && keyData[dwLen-1]=='"')
+      {
+        dwLen--;
+        keyData[dwLen]='\0';
+      }
       lpbData = keyData;
     } 
-    else if (dwDataType == REG_DWORD)  /* Convert the dword types */
+    else if (dwParseType == REG_DWORD)  /* Convert the dword types */
     {
       dwLen   = convertHexToDWord(keyData, convert);
@@ -593 +590 @@
         strncpy(argv[1], lpsCurrentValue, dwSize);
         argv[1][dwSize]='\0';
-    }
-    }
-
-    return KEY_VALUE_ALREADY_SET;
-  }
+      }
+    }
+
+    hRes=KEY_VALUE_ALREADY_SET;
+  }
+  if (keyValue != NULL)
+      HeapFree(GetProcessHeap(), 0, keyValue);
   return hRes;
 }
@@ -661 +660 @@
     argv[counter]=NULL;
 
-  while( (token = strsep(&cmdline, setValueDelim[argCounter])) != NULL ) 
-  {
-    argv[argCounter++] = getArg(token);
+  while( (token = getToken(&cmdline, setValueDelim[argCounter])) != NULL ) 
+  {
+    argv[argCounter++] = token;
 
     if (argCounter == SET_VALUE_MAX_ARGS)
@@ -683 +682 @@
       argv[1], 
       currentKeyName);
-  
+
   else
     printf("regapi: ERROR Key %s not created. Value: %s, Data: %s\n",
@@ -689 +688 @@
       argv[0], 
       argv[1]);
-    
-  /*
-   * Do some cleanup
-   */
-  for (counter=0; counter<argCounter; counter++)
-    if (argv[counter] != NULL)
-      HeapFree(GetProcessHeap(), 0, argv[counter]);
 }
 
@@ -718 +710 @@
     argv[counter]=NULL;
 
-  while( (token = strsep(&cmdline, queryValueDelim[argCounter])) != NULL ) 
+  while( (token = getToken(&cmdline, queryValueDelim[argCounter])) != NULL ) 
   {
     argv[argCounter++] = getArg(token);
@@ -728 +720 @@
   /* The value we look for is the first token on the line */
   if ( argv[0] == NULL )
-    return; /* SHOULD NOT OCCURS */
+    return; /* SHOULD NOT HAPPEN */
   else
     keyValue = argv[0]; 
@@ -1022 +1014 @@
 /******************************************************************************
  * MAIN - WinMain simply validates the first parameter (command to perform)
- *        It then reads the STDIN lines by lines forwarding their processing
+ *        It then reads the STDIN line by line forwarding their processing
  *        to the appropriate method.
  */
@@ -1042 +1034 @@
    * get the command, should be the first arg (modify cmdLine)
    */ 
-  token = strsep(&cmdline, " "); 
+#ifdef __WIN32OS2__
+  token = "setValue";
+#else
+  token = getToken(&cmdline, " "); 
+#endif
   if (token != NULL) 
   {
@@ -1062 +1058 @@
 
   /* 
-   * check to see weather we force the action 
-   * (meaning differ depending on the command performed)
+   * check to see wether we force the action 
+   * (meaning differs depending on the command performed)
    */
   if ( cmdline != NULL ) /* will be NULL if '-force' is not provided */