First take on a W32 port

9 files changed, 706 insertions, 1 deletions

diff --git a/common/ChangeLog b/common/ChangeLog
index d5ded50c9..9224055df 100644
--- a/common/ChangeLog
+++ b/common/ChangeLog
@@ -1,3 +1,12 @@
+2004-11-26  Werner Koch  <wk@g10code.com>
+
+	* simple-gettext.c: New taken from gnupg 1.3.x
+
+	* simple-pwquery.c [_WIN32]: Include winsock2.h.
+	(agent_open): Disable it until we have our AF_UNIX implementation
+	ready.
+	* fseeko.c, ftello.c: Include sys/types for the sake of W32.
+
 2004-11-23  Werner Koch  <wk@g10code.com>
 
 	* b64enc.c: Include stdio.h and string.h
diff --git a/common/Makefile.am b/common/Makefile.am
index 64b565cd2..12fdf7b5e 100644
--- a/common/Makefile.am
+++ b/common/Makefile.am
@@ -41,6 +41,8 @@ libcommon_a_SOURCES = \
 	iobuf.c iobuf.h \
 	ttyio.c ttyio.h \
 	asshelp.c asshelp.h \
+	simple-gettext.c \
+	w32reg.c \
 	signal.c \
 	dynload.h
 
diff --git a/common/fseeko.c b/common/fseeko.c
index f151b09ec..06838e4c4 100644
--- a/common/fseeko.c
+++ b/common/fseeko.c
@@ -22,6 +22,7 @@
 #include <config.h>
 #endif
 #include <stdio.h>
+#include <sys/types.h>  /* Defines off_t under W32.  */
 
 int
 fseeko (FILE *stream, off_t off, int whence)
diff --git a/common/ftello.c b/common/ftello.c
index e3141900d..6837be959 100644
--- a/common/ftello.c
+++ b/common/ftello.c
@@ -22,6 +22,7 @@
 #include <config.h>
 #endif
 #include <stdio.h>
+#include <sys/types.h>  /* Defines off_t under W32.  */
 
 off_t
 ftello (FILE *stream)
diff --git a/common/simple-gettext.c b/common/simple-gettext.c
new file mode 100644
index 000000000..4287606e3
--- /dev/null
+++ b/common/simple-gettext.c
@@ -0,0 +1,437 @@
+/* simple-gettext.c  - a simplified version of gettext.
+ * Copyright (C) 1995, 1996, 1997, 1999 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+/* This is a simplified version of gettext written by Ulrich Drepper.
+ * It is used for the Win32 version of GnuPG beucase all the overhead
+ * of gettext is not needed and we have to do some special Win32 stuff.
+ * I decided that this is far easier than to tweak gettext for the special
+ * cases (I tried it but it is a lot of code).	wk 15.09.99
+ */
+
+#include <config.h>
+#ifdef USE_SIMPLE_GETTEXT
+#if !defined (_WIN32) && !defined (__CYGWIN32__)
+#error This file can only be used under Windows or Cygwin32
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "util.h"
+
+
+/* The magic number of the GNU message catalog format.	*/
+#define MAGIC	      0x950412de
+#define MAGIC_SWAPPED 0xde120495
+
+/* Revision number of the currently used .mo (binary) file format.  */
+#define MO_REVISION_NUMBER 0
+
+
+/* Header for binary .mo file format.  */
+struct mo_file_header
+{
+  /* The magic number.	*/
+  u32 magic;
+  /* The revision number of the file format.  */
+  u32 revision;
+  /* The number of strings pairs.  */
+  u32 nstrings;
+  /* Offset of table with start offsets of original strings.  */
+  u32 orig_tab_offset;
+  /* Offset of table with start offsets of translation strings.  */
+  u32 trans_tab_offset;
+  /* Size of hashing table.  */
+  u32 hash_tab_size;
+  /* Offset of first hashing entry.  */
+  u32 hash_tab_offset;
+};
+
+struct string_desc
+{
+  /* Length of addressed string.  */
+  u32 length;
+  /* Offset of string in file.	*/
+  u32 offset;
+};
+
+
+struct overflow_space_s
+{
+  struct overflow_space_s *next;
+  u32 idx;
+  char d[1];
+};
+
+struct loaded_domain
+{
+  char *data;
+  int must_swap;
+  u32 nstrings;
+  char *mapped;  /* 0 = not yet mapped, 1 = mapped,
+                    2 = mapped to
+                    overflow space */
+  struct overflow_space_s *overflow_space;
+  struct string_desc *orig_tab;
+  struct string_desc *trans_tab;
+  u32 hash_size;
+  u32 *hash_tab;
+};
+
+
+static struct loaded_domain *the_domain;
+
+static __inline__ u32
+do_swap_u32( u32 i )
+{
+  return (i << 24) | ((i & 0xff00) << 8) | ((i >> 8) & 0xff00) | (i >> 24);
+}
+
+#define SWAPIT(flag, data) ((flag) ? do_swap_u32(data) : (data) )
+
+
+/* We assume to have `unsigned long int' value with at least 32 bits.  */
+#define HASHWORDBITS 32
+
+/* The so called `hashpjw' function by P.J. Weinberger
+   [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
+   1986, 1987 Bell Telephone Laboratories, Inc.]  */
+
+static __inline__ ulong
+hash_string( const char *str_param )
+{
+    unsigned long int hval, g;
+    const char *str = str_param;
+
+    hval = 0;
+    while (*str != '\0')
+    {
+	hval <<= 4;
+	hval += (unsigned long int) *str++;
+	g = hval & ((unsigned long int) 0xf << (HASHWORDBITS - 4));
+	if (g != 0)
+	{
+	  hval ^= g >> (HASHWORDBITS - 8);
+	  hval ^= g;
+	}
+    }
+    return hval;
+}
+
+
+static struct loaded_domain *
+load_domain( const char *filename )
+{
+    FILE *fp;
+    size_t size;
+    struct stat st;
+    struct mo_file_header *data = NULL;
+    struct loaded_domain *domain = NULL;
+    size_t to_read;
+    char *read_ptr;
+
+    fp = fopen( filename, "rb" );
+    if( !fp )
+       return NULL; /* can't open the file */
+    /* we must know about the size of the file */
+    if( fstat( fileno(fp ), &st )
+	|| (size = (size_t)st.st_size) != st.st_size
+	|| size < sizeof (struct mo_file_header) ) {
+	fclose( fp );
+	return NULL;
+    }
+
+    data = malloc( size );
+    if( !data ) {
+	fclose( fp );
+	return NULL; /* out of memory */
+    }
+
+    to_read = size;
+    read_ptr = (char *) data;
+    do {
+	long int nb = fread( read_ptr, 1, to_read, fp );
+	if( nb < to_read ) {
+	    fclose (fp);
+	    free(data);
+	    return NULL; /* read error */
+	}
+	read_ptr += nb;
+	to_read -= nb;
+    } while( to_read > 0 );
+    fclose (fp);
+
+    /* Using the magic number we can test whether it really is a message
+     * catalog file.  */
+    if( data->magic != MAGIC && data->magic != MAGIC_SWAPPED ) {
+	/* The magic number is wrong: not a message catalog file.  */
+	free( data );
+	return NULL;
+    }
+
+    domain = calloc( 1, sizeof *domain );
+    if( !domain )  {
+	free( data );
+	return NULL;
+    }
+    domain->data = (char *) data;
+    domain->must_swap = data->magic != MAGIC;
+
+    /* Fill in the information about the available tables.  */
+    switch( SWAPIT(domain->must_swap, data->revision) ) {
+      case 0:
+	domain->nstrings = SWAPIT(domain->must_swap, data->nstrings);
+	domain->orig_tab = (struct string_desc *)
+	  ((char *) data + SWAPIT(domain->must_swap, data->orig_tab_offset));
+	domain->trans_tab = (struct string_desc *)
+	  ((char *) data + SWAPIT(domain->must_swap, data->trans_tab_offset));
+	domain->hash_size = SWAPIT(domain->must_swap, data->hash_tab_size);
+	domain->hash_tab = (u32 *)
+	  ((char *) data + SWAPIT(domain->must_swap, data->hash_tab_offset));
+      break;
+
+      default: /* This is an invalid revision.	*/
+	free( data );
+	free( domain );
+	return NULL;
+    }
+
+    /* Allocate an array to keep track of code page mappings. */
+    domain->mapped = calloc( 1, domain->nstrings );
+    if( !domain->mapped ) {
+        free( data );
+        free( domain );
+        return NULL;
+    }
+
+    return domain;
+}
+
+
+/****************
+ * Set the file used for translations.	Pass a NULL to disable
+ * translation.  A new filename may be set at anytime.
+ * WARNING: After changing the filename you should not access any data
+ *	    retrieved by gettext().
+ */
+int
+set_gettext_file( const char *filename )
+{
+    struct loaded_domain *domain = NULL;
+
+    if( filename && *filename ) {
+	if( filename[0] == '/'
+#ifdef HAVE_DRIVE_LETTERS
+	    || ( isalpha(filename[0])
+		 && filename[1] == ':'
+		 && (filename[2] == '/' || filename[2] == '\\') )
+#endif
+	   ) {
+	    /* absolute path - use it as is */
+	    domain = load_domain( filename );
+	}
+	else { /* relative path - append ".mo" and get dir from the environment */
+	    char *buf = NULL;
+	    char *dir;
+            char *p;
+
+	    dir = read_w32_registry_string( NULL,
+					    "Control Panel\\Mingw32\\NLS",
+					    "MODir" );
+	    if( dir && (buf=malloc(strlen(dir)+strlen(filename)+1+3+1)) ) {
+		strcpy(stpcpy(stpcpy(stpcpy( buf, dir),"\\"), filename),".mo");
+                /* Better make sure that we don't mix forward and
+                   backward slashes.  It seems that some Windoze
+                   versions don't accept this. */
+                for (p=buf; *p; p++)
+                  {
+                    if (*p == '/')
+                      *p = '\\';
+                  }
+		domain = load_domain( buf );
+		free(buf);
+	    }
+	    free(dir);
+	}
+	if( !domain )
+	    return -1;
+    }
+
+    if( the_domain ) {
+        struct overflow_space_s *os, *os2;
+	free( the_domain->data );
+  	free( the_domain->mapped );
+        for (os=the_domain->overflow_space; os; os = os2) {
+            os2 = os->next;
+            free (os);
+        }
+	free( the_domain );
+	the_domain = NULL;
+    }
+    the_domain = domain;
+    return 0;
+}
+
+
+static const char*
+get_string( struct loaded_domain *domain, u32 idx )
+{
+  struct overflow_space_s *os;
+  char *p;
+
+  p = domain->data + SWAPIT(domain->must_swap, domain->trans_tab[idx].offset);
+  if (!domain->mapped[idx]) 
+    {
+      size_t plen, buflen;
+      char *buf;
+
+      domain->mapped[idx] = 1;
+
+      plen = strlen (p);
+      buf = utf8_to_native (p, plen, -1);
+      buflen = strlen (buf);
+      if (buflen <= plen)
+        strcpy (p, buf);
+      else
+        {
+          /* There is not enough space for the translation - store it
+             in the overflow_space else and mark that in the mapped
+             array.  Because we expect that this won't happen too
+             often, we use a simple linked list.  */
+          os = malloc (sizeof *os + buflen);
+          if (os)
+            {
+              os->idx = idx;
+              strcpy (os->d, buf);
+              os->next = domain->overflow_space;
+              domain->overflow_space = os;
+              p = os->d;
+            }
+          else
+            p = "ERROR in GETTEXT MALLOC";
+        }
+      xfree (buf);
+    }
+  else if (domain->mapped[idx] == 2) 
+    { /* We need to get the string from the overflow_space. */
+      for (os=domain->overflow_space; os; os = os->next)
+        if (os->idx == idx)
+          return (const char*)os->d;
+      p = "ERROR in GETTEXT\n";
+    }
+  return (const char*)p;
+}
+
+
+
+const char *
+gettext( const char *msgid )
+{
+    struct loaded_domain *domain;
+    size_t act = 0;
+    size_t top, bottom;
+
+    if( !(domain = the_domain) )
+	goto not_found;
+
+    /* Locate the MSGID and its translation.  */
+    if( domain->hash_size > 2 && domain->hash_tab ) {
+	/* Use the hashing table.  */
+	u32 len = strlen (msgid);
+	u32 hash_val = hash_string (msgid);
+	u32 idx = hash_val % domain->hash_size;
+	u32 incr = 1 + (hash_val % (domain->hash_size - 2));
+	u32 nstr = SWAPIT (domain->must_swap, domain->hash_tab[idx]);
+
+	if ( !nstr ) /* Hash table entry is empty.  */
+	    goto not_found;
+
+	if( SWAPIT(domain->must_swap,
+		    domain->orig_tab[nstr - 1].length) == len
+	    && !strcmp( msgid,
+		       domain->data + SWAPIT(domain->must_swap,
+				    domain->orig_tab[nstr - 1].offset)) )
+	    return get_string( domain, nstr - 1 );
+
+	for(;;) {
+	    if (idx >= domain->hash_size - incr)
+		idx -= domain->hash_size - incr;
+	    else
+		idx += incr;
+
+	    nstr = SWAPIT(domain->must_swap, domain->hash_tab[idx]);
+	    if( !nstr )
+		goto not_found; /* Hash table entry is empty.  */
+
+	    if ( SWAPIT(domain->must_swap,
+				domain->orig_tab[nstr - 1].length) == len
+		 && !strcmp (msgid,
+			 domain->data + SWAPIT(domain->must_swap,
+					   domain->orig_tab[nstr - 1].offset)))
+		return get_string( domain, nstr-1 );
+	}
+	/* NOTREACHED */
+    }
+
+    /* Now we try the default method:  binary search in the sorted
+       array of messages.  */
+    bottom = 0;
+    top = domain->nstrings;
+    while( bottom < top ) {
+	int cmp_val;
+
+	act = (bottom + top) / 2;
+	cmp_val = strcmp(msgid, domain->data
+			       + SWAPIT(domain->must_swap,
+					domain->orig_tab[act].offset));
+	if (cmp_val < 0)
+	    top = act;
+	else if (cmp_val > 0)
+	    bottom = act + 1;
+	else
+	    return get_string( domain, act );
+    }
+
+  not_found:
+    return msgid;
+}
+
+#if 0
+       unsigned int cp1, cp2;
+
+       cp1 = GetConsoleCP();
+       cp2 = GetConsoleOutputCP();
+
+       log_info("InputCP=%u  OutputCP=%u\n", cp1, cp2 );
+
+       if( !SetConsoleOutputCP( 1252 ) )
+            log_info("SetConsoleOutputCP failed: %s\n", w32_strerror (0));
+
+       cp1 = GetConsoleCP();
+       cp2 = GetConsoleOutputCP();
+       log_info("InputCP=%u  OutputCP=%u after switch1\n", cp1, cp2 );
+#endif
+
+#endif /* USE_SIMPLE_GETTEXT */
diff --git a/common/simple-pwquery.c b/common/simple-pwquery.c
index 0bc8128e1..fab6306fa 100644
--- a/common/simple-pwquery.c
+++ b/common/simple-pwquery.c
@@ -31,8 +31,12 @@
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
+#ifdef _WIN32
+#include <winsock2.h>
+#else
 #include <sys/socket.h>
 #include <sys/un.h>
+#endif
 #ifdef HAVE_LOCALE_H
 #include <locale.h>
 #endif
@@ -255,6 +259,9 @@ agent_send_all_options (int fd)
 static int
 agent_open (int *rfd)
 {
+#ifdef _WIN32
+  return SPWQ_NO_AGENT;  /* FIXME */
+#else
   int rc;
   int fd;
   char *infostr, *p;
@@ -346,6 +353,7 @@ agent_open (int *rfd)
 
   *rfd = fd;
   return 0;
+#endif
 }
 
 
diff --git a/common/strsep.c b/common/strsep.c
new file mode 100644
index 000000000..af3f02e07
--- /dev/null
+++ b/common/strsep.c
@@ -0,0 +1,73 @@
+/* strsep.c - Replacement for strsep().
+ * Copyright (C) 2002 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include <string.h>
+
+/* Code taken from glibc-2.2.1/sysdeps/generic/strsep.c */
+#warning need to get the correct copyright years from glibc
+char *
+strsep (char **stringp, const char *delim)
+{
+  char *begin, *end;
+
+  begin = *stringp;
+  if (begin == NULL)
+    return NULL;
+
+  /* A frequent case is when the delimiter string contains only one
+     character.  Here we don't need to call the expensive `strpbrk'
+     function and instead work using `strchr'.  */
+  if (delim[0] == '\0' || delim[1] == '\0')
+    {
+      char ch = delim[0];
+
+      if (ch == '\0')
+        end = NULL;
+      else
+        {
+          if (*begin == ch)
+            end = begin;
+          else if (*begin == '\0')
+            end = NULL;
+          else
+            end = strchr (begin + 1, ch);
+        }
+    }
+  else
+    /* Find the end of the token.  */
+    end = strpbrk (begin, delim);
+
+  if (end)
+    {
+      /* Terminate the token and set *STRINGP past NUL character.  */
+      *end++ = '\0';
+      *stringp = end;
+    }
+  else
+    /* No more delimiters; this is the last token.  */
+    *stringp = NULL;
+
+  return begin;
+}
+
diff --git a/common/util.h b/common/util.h
index b9ffe6562..fad7d38cc 100644
--- a/common/util.h
+++ b/common/util.h
@@ -144,7 +144,9 @@ int is_file_compressed (const char *s, int *ret_rc);
 int vasprintf (char **result, const char *format, va_list args);
 int asprintf (char **result, const char *format, ...) JNLIB_GCC_A_PRINTF(2,3);
 #endif
-
+#ifndef HAVE_STRSEP
+char *strsep (char **stringp, const char *delim);
+#endif
 
 
 /*-- some macros to replace ctype ones and avoid locale problems --*/
diff --git a/common/w32reg.c b/common/w32reg.c
new file mode 100644
index 000000000..19fb613e7
--- /dev/null
+++ b/common/w32reg.c
@@ -0,0 +1,172 @@
+/* w32reg.c -  MS-Windows Registry access
+ *	Copyright (C) 1999, 2002 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <config.h>
+#if defined (_WIN32) || defined (__CYGWIN32__)
+ /* This module is only used in this environment */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <windows.h>
+
+#include "util.h"
+
+static HKEY
+get_root_key(const char *root)
+{
+    HKEY root_key;
+	
+    if( !root )
+        root_key = HKEY_CURRENT_USER;
+    else if( !strcmp( root, "HKEY_CLASSES_ROOT" ) )
+	root_key = HKEY_CLASSES_ROOT;
+    else if( !strcmp( root, "HKEY_CURRENT_USER" ) )
+	root_key = HKEY_CURRENT_USER;
+    else if( !strcmp( root, "HKEY_LOCAL_MACHINE" ) )
+	root_key = HKEY_LOCAL_MACHINE;
+    else if( !strcmp( root, "HKEY_USERS" ) )
+	root_key = HKEY_USERS;
+    else if( !strcmp( root, "HKEY_PERFORMANCE_DATA" ) )
+	root_key = HKEY_PERFORMANCE_DATA;
+    else if( !strcmp( root, "HKEY_CURRENT_CONFIG" ) )
+	root_key = HKEY_CURRENT_CONFIG;
+    else
+        return NULL;
+	
+    return root_key;
+}
+
+
+/****************
+ * Return a string from the Win32 Registry or NULL in case of
+ * error.  Caller must release the return value.   A NULL for root
+ * is an alias for HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE in turn.
+ * NOTE: The value is allocated with a plain malloc() - use free() and not
+ * the usual m_free()!!!
+ */
+char *
+read_w32_registry_string( const char *root, const char *dir, const char *name )
+{
+    HKEY root_key, key_handle;
+    DWORD n1, nbytes, type;
+    char *result = NULL;
+
+    if ( !(root_key = get_root_key(root) ) )
+	return NULL;
+
+    if( RegOpenKeyEx( root_key, dir, 0, KEY_READ, &key_handle ) )
+      {
+        if (root)
+          return NULL; /* no need for a RegClose, so return direct */
+        /* It seems to be common practise to fall back to HLM. */
+        if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, dir, 0, KEY_READ, &key_handle) )
+          return NULL; /* still no need for a RegClose, so return direct */
+      }
+
+    nbytes = 1;
+    if( RegQueryValueEx( key_handle, name, 0, NULL, NULL, &nbytes ) )
+	goto leave;
+    result = malloc( (n1=nbytes+1) );
+    if( !result )
+	goto leave;
+    if( RegQueryValueEx( key_handle, name, 0, &type, result, &n1 ) ) {
+	free(result); result = NULL;
+	goto leave;
+    }
+    result[nbytes] = 0; /* make sure it is really a string  */
+    if (type == REG_EXPAND_SZ && strchr (result, '%')) {
+        char *tmp;
+        
+        n1 += 1000;
+        tmp = malloc (n1+1);
+        if (!tmp)
+            goto leave;
+        nbytes = ExpandEnvironmentStrings (result, tmp, n1);
+        if (nbytes && nbytes > n1) {
+            free (tmp);
+            n1 = nbytes;
+            tmp = malloc (n1 + 1);
+            if (!tmp)
+                goto leave;
+            nbytes = ExpandEnvironmentStrings (result, tmp, n1);
+            if (nbytes && nbytes > n1) {
+                free (tmp); /* oops - truncated, better don't expand at all */
+                goto leave;
+            }
+            tmp[nbytes] = 0;
+            free (result);
+            result = tmp;
+        }
+        else if (nbytes) { /* okay, reduce the length */
+            tmp[nbytes] = 0;
+            free (result);
+            result = malloc (strlen (tmp)+1);
+            if (!result)
+                result = tmp;
+            else {
+                strcpy (result, tmp);
+                free (tmp);
+            }
+        }
+        else {  /* error - don't expand */
+            free (tmp);
+        }
+    }
+
+  leave:
+    RegCloseKey( key_handle );
+    return result;
+}
+
+
+int
+write_w32_registry_string(const char *root, const char *dir, 
+                          const char *name, const char *value)
+{
+    HKEY root_key, reg_key;
+	
+    if ( !(root_key = get_root_key(root) ) )
+	return -1;
+
+    if ( RegOpenKeyEx( root_key, dir, 0, KEY_WRITE, &reg_key ) 
+         != ERROR_SUCCESS )
+	return -1;
+	
+    if ( RegSetValueEx( reg_key, name, 0, REG_SZ, (BYTE *)value, 
+                        strlen( value ) ) != ERROR_SUCCESS ) {
+        if ( RegCreateKey( root_key, name, &reg_key ) != ERROR_SUCCESS ) {
+            RegCloseKey(reg_key);
+            return -1;
+        }
+        if ( RegSetValueEx( reg_key, name, 0, REG_SZ, (BYTE *)value,
+                            strlen( value ) ) != ERROR_SUCCESS ) {
+            RegCloseKey(reg_key);
+            return -1;
+        }
+    }
+
+    RegCloseKey( reg_key );
+	
+    return 0;
+}
+
+#endif /* __MINGW32__ || __CYGWIN32__ */