From b82a7a5e35be1ea184b3ce81b763c5943bf70b70 Mon Sep 17 00:00:00 2001
From: Christopher Faylor <me@cgf.cx>
Date: Wed, 10 Jan 2001 14:20:16 +0000
Subject: * regtool.cc (translate): Ensure that 'c' is initialized. (cmd_set):
 Ditto for rv.

---
 winsup/utils/regtool.cc | 473 +++++++++++++++++++++++++-----------------------
 1 file changed, 245 insertions(+), 228 deletions(-)

(limited to 'winsup/utils/regtool.cc')

diff --git a/winsup/utils/regtool.cc b/winsup/utils/regtool.cc
index 8ba9f8901..cb0c666af 100644
--- a/winsup/utils/regtool.cc
+++ b/winsup/utils/regtool.cc
@@ -14,7 +14,8 @@ details. */
 #include <getopt.h>
 #include <windows.h>
 
-enum {
+enum
+{
   KT_AUTO, KT_INT, KT_STRING, KT_EXPAND, KT_MULTI
 } key_type = KT_AUTO;
 
@@ -25,8 +26,7 @@ char **argv;
 HKEY key;
 char *value;
 
-const char *usage_msg[] =
-{
+const char *usage_msg[] = {
   "Regtool Copyright (c) 2000 Red Hat Inc",
   " regtool -h  - print this message",
   " regtool [-v] list [key]  - list subkeys and values",
@@ -49,51 +49,54 @@ const char *usage_msg[] =
 };
 
 void
-usage(void)
+usage (void)
 {
   int i;
-  for (i=0; usage_msg[i]; i++)
-    fprintf(stderr, "%s\n", usage_msg[i]);
-  exit(1);
+  for (i = 0; usage_msg[i]; i++)
+    fprintf (stderr, "%s\n", usage_msg[i]);
+  exit (1);
 }
 
 void
-Fail(DWORD rv)
+Fail (DWORD rv)
 {
   char *buf;
   if (!quiet)
     {
-      FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
-		    | FORMAT_MESSAGE_FROM_SYSTEM,
-		    0, rv, 0, (CHAR *)&buf, 0, 0);
-      fprintf(stderr, "Error: %s\n", buf);
+      FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER
+		     | FORMAT_MESSAGE_FROM_SYSTEM,
+		     0, rv, 0, (CHAR *) & buf, 0, 0);
+      fprintf (stderr, "Error: %s\n", buf);
     }
-  exit(1);
+  exit (1);
 }
 
-struct {
+struct
+{
   const char *string;
   HKEY key;
-} wkprefixes[] = {
-  { "root", HKEY_CLASSES_ROOT },
-  { "HKCR", HKEY_CLASSES_ROOT },
-  { "HKEY_CLASSES_ROOT", HKEY_CLASSES_ROOT },
-  { "config", HKEY_CURRENT_CONFIG },
-  { "HKCC", HKEY_CURRENT_CONFIG },
-  { "HKEY_CURRENT_CONFIG", HKEY_CURRENT_CONFIG },
-  { "user", HKEY_CURRENT_USER },
-  { "HKCU", HKEY_CURRENT_USER },
-  { "HKEY_CURRENT_USER", HKEY_CURRENT_USER },
-  { "machine", HKEY_LOCAL_MACHINE },
-  { "HKLM", HKEY_LOCAL_MACHINE },
-  { "HKEY_LOCAL_MACHINE", HKEY_LOCAL_MACHINE },
-  { "users", HKEY_USERS },
-  { "HKU", HKEY_USERS },
-  { "HKEY_USERS", HKEY_USERS },
-  { 0, 0 }
+} wkprefixes[] =
+{
+  {"root", HKEY_CLASSES_ROOT},
+  {"HKCR", HKEY_CLASSES_ROOT},
+  {"HKEY_CLASSES_ROOT", HKEY_CLASSES_ROOT},
+  {"config", HKEY_CURRENT_CONFIG},
+  {"HKCC", HKEY_CURRENT_CONFIG},
+  {"HKEY_CURRENT_CONFIG", HKEY_CURRENT_CONFIG},
+  {"user", HKEY_CURRENT_USER},
+  {"HKCU", HKEY_CURRENT_USER},
+  {"HKEY_CURRENT_USER", HKEY_CURRENT_USER},
+  {"machine", HKEY_LOCAL_MACHINE},
+  {"HKLM", HKEY_LOCAL_MACHINE},
+  {"HKEY_LOCAL_MACHINE", HKEY_LOCAL_MACHINE},
+  {"users", HKEY_USERS},
+  {"HKU", HKEY_USERS},
+  {"HKEY_USERS", HKEY_USERS},
+  {0, 0}
 };
 
-void translate(char *key)
+void
+translate (char *key)
 {
 #define isodigit(c) (strchr("01234567", c))
 #define tooct(c)    ((c)-'0')
@@ -107,119 +110,127 @@ void translate(char *key)
   while (*s)
     {
       if (*s == '\\')
-        switch (*++s)
-          {
-          case 'a':
-            *d++ = '\007';
-            break;
-          case 'b':
-            *d++ = '\b';
-            break;
-          case 'e':
-            *d++ = '\033';
-            break;
-          case 'f':
-            *d++ = '\f';
-            break;
-          case 'n':
-            *d++ = '\n';
-            break;
-          case 'r':
-            *d++ = '\r';
-            break;
-          case 't':
-            *d++ = '\t';
-            break;
-          case 'v':
-            *d++ = '\v';
-            break;
-          case '0': case '1': case '2': case '3':
-          case '4': case '5': case '6': case '7':
-            c = tooct(*s);
-            if (isodigit(s[1]))
-              {
-                c = (c << 3) | tooct(*++s);
-                if (isodigit(s[1]))
-                  c = (c << 3) | tooct(*++s);
-              }
-            *d++ = c;
-            break;
-          case 'x':
-            if (isxdigit(s[1]))
-              {
-                c = tohex(*++s);
-                if (isxdigit(s[1]))
-                  c = (c << 4) | tohex(*++s);
-              }
-            *d++ = c;
-            break;
-          default:     /* before non-special char: just add the char */
-            *d++ = *s;
-            break;
-          }
+	switch (*++s)
+	  {
+	  case 'a':
+	    *d++ = '\007';
+	    break;
+	  case 'b':
+	    *d++ = '\b';
+	    break;
+	  case 'e':
+	    *d++ = '\033';
+	    break;
+	  case 'f':
+	    *d++ = '\f';
+	    break;
+	  case 'n':
+	    *d++ = '\n';
+	    break;
+	  case 'r':
+	    *d++ = '\r';
+	    break;
+	  case 't':
+	    *d++ = '\t';
+	    break;
+	  case 'v':
+	    *d++ = '\v';
+	    break;
+	  case '0':
+	  case '1':
+	  case '2':
+	  case '3':
+	  case '4':
+	  case '5':
+	  case '6':
+	  case '7':
+	    c = tooct (*s);
+	    if (isodigit (s[1]))
+	      {
+		c = (c << 3) | tooct (*++s);
+		if (isodigit (s[1]))
+		  c = (c << 3) | tooct (*++s);
+	      }
+	    *d++ = c;
+	    break;
+	  case 'x':
+	    if (!isxdigit (s[1]))
+	      c = 0;
+	    else
+	      {
+		c = tohex (*++s);
+		if (isxdigit (s[1]))
+		  c = (c << 4) | tohex (*++s);
+	      }
+	    *d++ = c;
+	    break;
+	  default:		/* before non-special char: just add the char */
+	    *d++ = *s;
+	    break;
+	  }
       else if (*s == '/')
-        *d++ = '\\';
+	*d++ = '\\';
       else
-        *d++ = *s;
+	*d++ = *s;
       ++s;
     }
   *d = '\0';
 }
 
 void
-find_key(int howmanyparts, REGSAM access)
+find_key (int howmanyparts, REGSAM access)
 {
   char *n = argv[0], *e, c;
   int i;
   if (*n == '/')
-    translate(n);
+    translate (n);
   while (*n == '\\')
     n++;
-  for (e=n; *e && *e != '\\'; e++);
+  for (e = n; *e && *e != '\\'; e++);
   c = *e;
   *e = 0;
-  for (i=0; wkprefixes[i].string; i++)
-    if (strcmp(wkprefixes[i].string, n) == 0)
+  for (i = 0; wkprefixes[i].string; i++)
+    if (strcmp (wkprefixes[i].string, n) == 0)
       break;
   if (!wkprefixes[i].string)
     {
-      fprintf(stderr, "Unknown key prefix.  Valid prefixes are:\n");
-      for (i=0; wkprefixes[i].string; i++)
-	fprintf(stderr, "\t%s\n", wkprefixes[i].string);
-      exit(1);
+      fprintf (stderr, "Unknown key prefix.  Valid prefixes are:\n");
+      for (i = 0; wkprefixes[i].string; i++)
+	fprintf (stderr, "\t%s\n", wkprefixes[i].string);
+      exit (1);
     }
 
   n = e;
   *e = c;
   while (*n && *n == '\\')
     n++;
-  e = n+strlen(n);
+  e = n + strlen (n);
   if (howmanyparts > 1)
     {
       while (n < e && *e != '\\')
 	e--;
       if (*e != '\\')
 	{
-	  fprintf(stderr, "Invalid key\n");
-	  exit(1);
+	  fprintf (stderr, "Invalid key\n");
+	  exit (1);
 	}
       *e = 0;
-      value = e+1;
+      value = e + 1;
     }
   if (n[0] == 0)
     {
       key = wkprefixes[i].key;
       return;
     }
-  int rv = RegOpenKeyEx(wkprefixes[i].key, n, 0, access, &key);
+  int rv = RegOpenKeyEx (wkprefixes[i].key, n, 0, access, &key);
   if (rv != ERROR_SUCCESS)
-    Fail(rv);
+    Fail (rv);
   //printf("key `%s' value `%s'\n", n, value);
 }
 
 
 int
-cmd_list()
+cmd_list ()
 {
   DWORD num_subkeys, maxsubkeylen, num_values, maxvalnamelen, maxvaluelen;
   DWORD maxclasslen;
@@ -228,71 +239,70 @@ cmd_list()
   DWORD i, j, m, n, t;
   int v;
 
-  find_key(1, KEY_READ);
-  RegQueryInfoKey(key, 0, 0, 0, &num_subkeys, &maxsubkeylen, &maxclasslen,
-		  &num_values, &maxvalnamelen, &maxvaluelen, 0, 0);
+  find_key (1, KEY_READ);
+  RegQueryInfoKey (key, 0, 0, 0, &num_subkeys, &maxsubkeylen, &maxclasslen,
+		   &num_values, &maxvalnamelen, &maxvaluelen, 0, 0);
 
-  subkey_name = (char *)malloc(maxsubkeylen+1);
-  class_name = (char *)malloc(maxclasslen+1);
-  value_name = (char *)malloc(maxvalnamelen+1);
-  value_data = (unsigned char *)malloc(maxvaluelen+1);
+  subkey_name = (char *) malloc (maxsubkeylen + 1);
+  class_name = (char *) malloc (maxclasslen + 1);
+  value_name = (char *) malloc (maxvalnamelen + 1);
+  value_data = (unsigned char *) malloc (maxvaluelen + 1);
 
-  for (i=0; i<num_subkeys; i++)
+  for (i = 0; i < num_subkeys; i++)
     {
-      m = maxsubkeylen+1;
-      n = maxclasslen+1;
-      RegEnumKeyEx(key, i, subkey_name, &m, 0, class_name, &n, 0);
+      m = maxsubkeylen + 1;
+      n = maxclasslen + 1;
+      RegEnumKeyEx (key, i, subkey_name, &m, 0, class_name, &n, 0);
       if (verbose)
-	printf("%s\\ (%s)\n", subkey_name, class_name);
+	printf ("%s\\ (%s)\n", subkey_name, class_name);
       else
-	printf("%s\n", subkey_name);
+	printf ("%s\n", subkey_name);
     }
 
-  for (i=0; i<num_values; i++)
+  for (i = 0; i < num_values; i++)
     {
-      m = maxvalnamelen+1;
-      n = maxvaluelen+1;
-      RegEnumValue(key, i, value_name, &m, 0, &t, (BYTE *)value_data, &n);
+      m = maxvalnamelen + 1;
+      n = maxvaluelen + 1;
+      RegEnumValue (key, i, value_name, &m, 0, &t, (BYTE *) value_data, &n);
       if (!verbose)
-	printf("%s\n", value_name);
+	printf ("%s\n", value_name);
       else
 	{
-	  printf("%s = ", value_name);
+	  printf ("%s = ", value_name);
 	  switch (t)
 	    {
 	    case REG_BINARY:
-	      for (j=0; j<8 && j<n; j++)
-		printf("%02x ", value_data[j]);
-	      printf("\n");
+	      for (j = 0; j < 8 && j < n; j++)
+		printf ("%02x ", value_data[j]);
+	      printf ("\n");
 	      break;
 	    case REG_DWORD:
-	      printf("0x%08lx (%lu)\n", *(DWORD *)value_data,
-		     *(DWORD *)value_data);
+	      printf ("0x%08lx (%lu)\n", *(DWORD *) value_data,
+		      *(DWORD *) value_data);
 	      break;
 	    case REG_DWORD_BIG_ENDIAN:
 	      v = ((value_data[0] << 24)
 		   | (value_data[1] << 16)
-		   | (value_data[2] << 8)
-		   | (value_data[3]));
-	      printf("0x%08x (%d)\n", v, v);
+		   | (value_data[2] << 8) | (value_data[3]));
+	      printf ("0x%08x (%d)\n", v, v);
 	      break;
 	    case REG_EXPAND_SZ:
 	    case REG_SZ:
-	      printf("\"%s\"\n", value_data);
+	      printf ("\"%s\"\n", value_data);
 	      break;
 	    case REG_MULTI_SZ:
 	      vd = value_data;
 	      while (vd && *vd)
 		{
-		  printf("\"%s\"", vd);
-		  vd = vd+strlen((const char *)vd) + 1;
+		  printf ("\"%s\"", vd);
+		  vd = vd + strlen ((const char *) vd) + 1;
 		  if (*vd)
-		    printf(", ");
+		    printf (", ");
 		}
-	      printf("\n");
+	      printf ("\n");
 	      break;
 	    default:
-	      printf("? (type %d)\n", (int)t);
+	      printf ("? (type %d)\n", (int) t);
 	    }
 	}
     }
@@ -300,59 +310,59 @@ cmd_list()
 }
 
 int
-cmd_add()
+cmd_add ()
 {
-  find_key(2, KEY_ALL_ACCESS);
+  find_key (2, KEY_ALL_ACCESS);
   HKEY newkey;
   DWORD newtype;
-  int rv = RegCreateKeyEx(key, value, 0, (char *)"", REG_OPTION_NON_VOLATILE,
-			  KEY_ALL_ACCESS, 0, &newkey, &newtype);
+  int rv = RegCreateKeyEx (key, value, 0, (char *) "", REG_OPTION_NON_VOLATILE,
+			   KEY_ALL_ACCESS, 0, &newkey, &newtype);
   if (rv != ERROR_SUCCESS)
-    Fail(rv);
+    Fail (rv);
 
   if (verbose)
     {
       if (newtype == REG_OPENED_EXISTING_KEY)
-	printf("Key %s already exists\n", value);
+	printf ("Key %s already exists\n", value);
       else
-	printf("Key %s created\n", value);
+	printf ("Key %s created\n", value);
     }
   return 0;
 }
 
 int
-cmd_remove()
+cmd_remove ()
 {
-  find_key(2, KEY_ALL_ACCESS);
-  DWORD rv = RegDeleteKey(key, value);
+  find_key (2, KEY_ALL_ACCESS);
+  DWORD rv = RegDeleteKey (key, value);
   if (rv != ERROR_SUCCESS)
-    Fail(rv);
+    Fail (rv);
   if (verbose)
-    printf("subkey %s deleted\n", value);
+    printf ("subkey %s deleted\n", value);
   return 0;
 }
 
 int
-cmd_check()
+cmd_check ()
 {
-  find_key(1, KEY_READ);
+  find_key (1, KEY_READ);
   if (verbose)
-    printf("key %s exists\n", argv[0]);
+    printf ("key %s exists\n", argv[0]);
   return 0;
 }
 
 int
-cmd_set()
+cmd_set ()
 {
   int i, n;
   DWORD v, rv;
   char *a = argv[1], *data;
-  find_key(2, KEY_ALL_ACCESS);
+  find_key (2, KEY_ALL_ACCESS);
 
   if (key_type == KT_AUTO)
     {
       char *e;
-      strtoul(a, &e, 0);
+      strtoul (a, &e, 0);
       if (a[0] == '%')
 	key_type = KT_EXPAND;
       else if (a[0] && !*e)
@@ -366,114 +376,121 @@ cmd_set()
   switch (key_type)
     {
     case KT_INT:
-      v = strtoul(a, 0, 0);
-      rv = RegSetValueEx(key, value, 0, REG_DWORD, (const BYTE *)&v, sizeof(v));
+      v = strtoul (a, 0, 0);
+      rv = RegSetValueEx (key, value, 0, REG_DWORD, (const BYTE *) &v,
+			  sizeof (v));
       break;
     case KT_STRING:
-      rv = RegSetValueEx(key, value, 0, REG_SZ, (const BYTE *)a, strlen(a));
+      rv = RegSetValueEx (key, value, 0, REG_SZ, (const BYTE *) a, strlen (a));
       break;
     case KT_EXPAND:
-      rv = RegSetValueEx(key, value, 0, REG_EXPAND_SZ, (const BYTE *)a, strlen(a));
+      rv = RegSetValueEx (key, value, 0, REG_EXPAND_SZ, (const BYTE *) a,
+			  strlen (a));
       break;
     case KT_MULTI:
-      for (i=1, n=1; argv[i]; i++)
-	n += strlen(argv[i])+1;
-      data = (char *)malloc(n);
-      for (i=1, n=0; argv[i]; i++)
+      for (i = 1, n = 1; argv[i]; i++)
+	n += strlen (argv[i]) + 1;
+      data = (char *) malloc (n);
+      for (i = 1, n = 0; argv[i]; i++)
 	{
-	  strcpy(data+n, argv[i]);
-	  n += strlen(argv[i])+1;
+	  strcpy (data + n, argv[i]);
+	  n += strlen (argv[i]) + 1;
 	}
       data[n] = 0;
-      rv = RegSetValueEx(key, value, 0, REG_MULTI_SZ, (const BYTE *)data, n+1);
+      rv = RegSetValueEx (key, value, 0, REG_MULTI_SZ, (const BYTE *) data,
+			  n + 1);
       break;
     case KT_AUTO:
+    default:
+      rv = ERROR_SUCCESS;
       break;
     }
 
   if (rv != ERROR_SUCCESS)
-    Fail(rv);
+    Fail (rv);
 
   return 0;
 }
 
 int
-cmd_unset()
+cmd_unset ()
 {
-  find_key(2, KEY_ALL_ACCESS);
-  DWORD rv = RegDeleteValue(key, value);
+  find_key (2, KEY_ALL_ACCESS);
+  DWORD rv = RegDeleteValue (key, value);
   if (rv != ERROR_SUCCESS)
-    Fail(rv);
+    Fail (rv);
   if (verbose)
-    printf("value %s deleted\n", value);
+    printf ("value %s deleted\n", value);
   return 0;
 }
 
 int
-cmd_get()
+cmd_get ()
 {
-  find_key(2, KEY_READ);
+  find_key (2, KEY_READ);
   DWORD vtype, dsize, rv;
   char *data, *vd;
-  rv = RegQueryValueEx(key, value, 0, &vtype, 0, &dsize);
+  rv = RegQueryValueEx (key, value, 0, &vtype, 0, &dsize);
   if (rv != ERROR_SUCCESS)
-    Fail(rv);
+    Fail (rv);
   dsize++;
-  data = (char *)malloc(dsize);
-  rv = RegQueryValueEx(key, value, 0, &vtype, (BYTE *)data, &dsize);
+  data = (char *) malloc (dsize);
+  rv = RegQueryValueEx (key, value, 0, &vtype, (BYTE *) data, &dsize);
   if (rv != ERROR_SUCCESS)
-    Fail(rv);
+    Fail (rv);
   switch (vtype)
     {
     case REG_BINARY:
-      fwrite(data, dsize, 0, stdout);
+      fwrite (data, dsize, 0, stdout);
       break;
     case REG_DWORD:
-      printf("%lu\n", *(DWORD *)data);
+      printf ("%lu\n", *(DWORD *) data);
       break;
     case REG_SZ:
-      printf("%s\n", data);
+      printf ("%s\n", data);
       break;
     case REG_EXPAND_SZ:
-      if (key_type == KT_EXPAND) // hack
+      if (key_type == KT_EXPAND)	// hack
 	{
 	  char *buf;
 	  DWORD bufsize;
-	  bufsize = ExpandEnvironmentStrings(data, 0, 0);
-	  buf = (char *)malloc(bufsize+1);
-	  ExpandEnvironmentStrings(data, buf, bufsize+1);
+	  bufsize = ExpandEnvironmentStrings (data, 0, 0);
+	  buf = (char *) malloc (bufsize + 1);
+	  ExpandEnvironmentStrings (data, buf, bufsize + 1);
 	  data = buf;
 	}
-      printf("%s\n", data);
+      printf ("%s\n", data);
       break;
     case REG_MULTI_SZ:
       vd = data;
       while (vd && *vd)
 	{
-	  printf("%s\n", vd);
-	  vd = vd+strlen((const char *)vd) + 1;
+	  printf ("%s\n", vd);
+	  vd = vd + strlen ((const char *) vd) + 1;
 	}
       break;
     }
   return 0;
 }
 
-struct {
+struct
+{
   const char *name;
-  int (*func)();
-} commands[] = {
-  { "list", cmd_list },
-  { "add", cmd_add },
-  { "remove", cmd_remove },
-  { "check", cmd_check },
-  { "set", cmd_set },
-  { "unset", cmd_unset },
-  { "get", cmd_get },
-  { 0, 0 }
+  int (*func) ();
+} commands[] =
+{
+  {"list", cmd_list},
+  {"add", cmd_add},
+  {"remove", cmd_remove},
+  {"check", cmd_check},
+  {"set", cmd_set},
+  {"unset", cmd_unset},
+  {"get", cmd_get},
+  {0, 0}
 };
 
 int
-main(int argc, char **_argv)
+main (int argc, char **_argv)
 {
   while (1)
     {
@@ -481,44 +498,44 @@ main(int argc, char **_argv)
       if (g == -1)
 	break;
       switch (g)
-      {
-      case 'v':
-	verbose ++;
-	break;
-      case 'q':
-	quiet ++;
-	break;
-
-      case 'i':
-	key_type = KT_INT;
-	break;
-      case 's':
-	key_type = KT_STRING;
-	break;
-      case 'e':
-	key_type = KT_EXPAND;
-	break;
-      case 'm':
-	key_type = KT_MULTI;
-	break;
-
-      case '?':
-      case 'h':
-	usage();
-      }
+	{
+	case 'v':
+	  verbose++;
+	  break;
+	case 'q':
+	  quiet++;
+	  break;
+
+	case 'i':
+	  key_type = KT_INT;
+	  break;
+	case 's':
+	  key_type = KT_STRING;
+	  break;
+	case 'e':
+	  key_type = KT_EXPAND;
+	  break;
+	case 'm':
+	  key_type = KT_MULTI;
+	  break;
+
+	case '?':
+	case 'h':
+	  usage ();
+	}
     }
   if (_argv[optind] == NULL)
-    usage();
+    usage ();
 
-  argv = _argv+optind;
+  argv = _argv + optind;
   int i;
-  for (i=0; commands[i].name; i++)
-    if (strcmp(commands[i].name, argv[0]) == 0)
+  for (i = 0; commands[i].name; i++)
+    if (strcmp (commands[i].name, argv[0]) == 0)
       {
 	argv++;
-	return commands[i].func();
+	return commands[i].func ();
       }
-  usage();
+  usage ();
 
   return 0;
 }
-- 
cgit v1.2.3