trunk/MyGPGME/w32-util.c

/* w32-util.c - Utility functions for the W32 API
 *      Copyright (C) 1999 Free Software Foundation, Inc
 *      Copyright (C) 2001 Werner Koch (dd9jn)
 *      Copyright (C) 2002, 2005 Timo Schulz
 *
 * This file is part of MyGPGME.
 *
 * MyGPGME 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.
 *
 * MyGPGME 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <sys/types.h>
#include <windows.h>
#include <process.h>
#include <io.h>

#include "util.h"


static char *
expand_path (const char *path)
{
    DWORD len;
    char *p;

    len = ExpandEnvironmentStrings (path, NULL, 0);
    if (!len)
        return NULL;
    len += 1;
    p = calloc (1, len+1);
    if (!p)
        return NULL;
    len = ExpandEnvironmentStrings (path, p, len);
    if (!len) {
        free (p);
        return NULL;
    }
    return p; 
}

/****************
 * 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 fro HKEY_CURRENT_USER
 */
static char *
read_w32_registry_string ( const char *root,
                           const char *dir, const char *name )
{
    HKEY root_key, key_handle;
    DWORD n1, nbytes;
    DWORD type;
    char *result = NULL;
    
    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;
    
    if( RegOpenKeyEx( root_key, dir, 0, KEY_READ, &key_handle ) )
        return NULL; /* no need for a RegClose, so return direct */
    
    nbytes = 1;
    if( RegQueryValueEx (key_handle, name, 0, NULL, NULL, &nbytes))
        goto leave;
    result = calloc (1, (n1=nbytes+1));
    if (!result)
        goto leave;
    if (RegQueryValueEx (key_handle, name, 0, &type, result, &n1)) {
        safe_free (result); result = NULL;
        goto leave;
    }
    if (type == REG_EXPAND_SZ && strchr (result, '%')) {
        char *p = expand_path (result);
        DEBUG2 ("gpgProgram is expandable: %s -> %s\n", result, p);
        free (result);
        result = p;
    }
    
leave:
    RegCloseKey (key_handle);
    return result;
}


const char *
_gpgme_get_gpg_path (int cleanup)
{
    static char *gpg_program = NULL;
    
    if (cleanup) {
        if (gpg_program) {
            free (gpg_program);
            gpg_program = NULL;
        }
        return NULL;
    }

    if (!gpg_program) {
        gpg_program = read_w32_registry_string (NULL,
                                                "Software\\GNU\\GnuPG", "gpgProgram");
        if (gpg_program) {
            int i;
            
            DEBUG1 ("found gpgProgram in registry: `%s'\n", gpg_program );
            for (i=0; gpg_program[i]; i++) {
                if (gpg_program[i] == '/')
                    gpg_program[i] = '\\';
            }
        }
        else
            gpg_program = strdup ("C:\\GNUPG\\GPG.EXE");
    }
    
    return gpg_program;
}


const char *
_gpgme_get_gpg_optfile (int cleanup)
{    
    static char *gpg_optfile = NULL;
    
    if (cleanup) {
        if (gpg_optfile) {
            free (gpg_optfile);
            gpg_optfile = NULL;
        }
        return NULL;
    }

    if (!gpg_optfile) {
        FILE *fp;
        gpg_optfile = read_w32_registry_string(
                            NULL, "Software\\GNU\\GnuPG", "OptFile" );
        if (gpg_optfile) {
            int i;
            for (i = 0; gpg_optfile[i]; i++) {
                if (gpg_optfile[i] == '/')
                    gpg_optfile[i] = '\\';
            }
            if (!strcmp(gpg_optfile, ""))
                return NULL; /* Then ignore the file */
            fp = fopen (gpg_optfile, "r");
            if (fp == NULL)
                return NULL;
            fclose (fp);
        }
    }

    return gpg_optfile;
} /* _gpgme_get_gpg_optfile */


void
util_cleanup (void)
{
    _gpgme_get_gpg_optfile (1);
    _gpgme_get_gpg_path (1);
}
1	twoaday	2	/* w32-util.c - Utility functions for the W32 API
2			* Copyright (C) 1999 Free Software Foundation, Inc
3			* Copyright (C) 2001 Werner Koch (dd9jn)
4	twoaday	7	* Copyright (C) 2002, 2005 Timo Schulz
5	twoaday	2	*
6			* This file is part of MyGPGME.
7			*
8			* MyGPGME is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* (at your option) any later version.
12			*
13			* MyGPGME is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program; if not, write to the Free Software
20			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
21			*/
22
23			#include <stdio.h>
24			#include <stdlib.h>
25			#include <string.h>
26			#include <assert.h>
27			#include <errno.h>
28			#include <sys/types.h>
29			#include <windows.h>
30			#include <process.h>
31			#include <io.h>
32
33			#include "util.h"
34
35	twoaday	23
36			static char *
37			expand_path (const char *path)
38			{
39			DWORD len;
40			char *p;
41
42			len = ExpandEnvironmentStrings (path, NULL, 0);
43			if (!len)
44			return NULL;
45			len += 1;
46			p = calloc (1, len+1);
47			if (!p)
48			return NULL;
49			len = ExpandEnvironmentStrings (path, p, len);
50			if (!len) {
51			free (p);
52			return NULL;
53			}
54			return p;
55			}
56
57	twoaday	2	/****************
58			* Return a string from the Win32 Registry or NULL in case of
59			* error. Caller must release the return value. A NULL for root
60			* is an alias fro HKEY_CURRENT_USER
61			*/
62			static char *
63			read_w32_registry_string ( const char *root,
64			const char dir, const char name )
65			{
66			HKEY root_key, key_handle;
67			DWORD n1, nbytes;
68	twoaday	23	DWORD type;
69	twoaday	2	char *result = NULL;
70
71			if( !root )
72			root_key = HKEY_CURRENT_USER;
73			else if( !strcmp( root, "HKEY_CLASSES_ROOT" ) )
74			root_key = HKEY_CLASSES_ROOT;
75			else if( !strcmp( root, "HKEY_CURRENT_USER" ) )
76			root_key = HKEY_CURRENT_USER;
77			else if( !strcmp( root, "HKEY_LOCAL_MACHINE" ) )
78			root_key = HKEY_LOCAL_MACHINE;
79			else if( !strcmp( root, "HKEY_USERS" ) )
80			root_key = HKEY_USERS;
81			else if( !strcmp( root, "HKEY_PERFORMANCE_DATA" ) )
82			root_key = HKEY_PERFORMANCE_DATA;
83			else if( !strcmp( root, "HKEY_CURRENT_CONFIG" ) )
84			root_key = HKEY_CURRENT_CONFIG;
85			else
86			return NULL;
87
88			if( RegOpenKeyEx( root_key, dir, 0, KEY_READ, &key_handle ) )
89			return NULL; /* no need for a RegClose, so return direct */
90
91			nbytes = 1;
92	twoaday	23	if( RegQueryValueEx (key_handle, name, 0, NULL, NULL, &nbytes))
93	twoaday	2	goto leave;
94	twoaday	23	result = calloc (1, (n1=nbytes+1));
95			if (!result)
96	twoaday	2	goto leave;
97	twoaday	23	if (RegQueryValueEx (key_handle, name, 0, &type, result, &n1)) {
98			safe_free (result); result = NULL;
99	twoaday	2	goto leave;
100			}
101	twoaday	23	if (type == REG_EXPAND_SZ && strchr (result, '%')) {
102			char *p = expand_path (result);
103			DEBUG2 ("gpgProgram is expandable: %s -> %s\n", result, p);
104			free (result);
105			result = p;
106			}
107	twoaday	2
108			leave:
109	twoaday	23	RegCloseKey (key_handle);
110	twoaday	2	return result;
111			}
112
113
114			const char *
115	twoaday	7	_gpgme_get_gpg_path (int cleanup)
116	twoaday	2	{
117			static char *gpg_program = NULL;
118
119	twoaday	7	if (cleanup) {
120			if (gpg_program) {
121			free (gpg_program);
122			gpg_program = NULL;
123			}
124			return NULL;
125			}
126
127	twoaday	2	if (!gpg_program) {
128	twoaday	7	gpg_program = read_w32_registry_string (NULL,
129			"Software\\GNU\\GnuPG", "gpgProgram");
130	twoaday	2	if (gpg_program) {
131			int i;
132
133			DEBUG1 ("found gpgProgram in registry: `%s'\n", gpg_program );
134			for (i=0; gpg_program[i]; i++) {
135			if (gpg_program[i] == '/')
136			gpg_program[i] = '\\';
137			}
138			}
139	twoaday	7	else
140			gpg_program = strdup ("C:\\GNUPG\\GPG.EXE");
141	twoaday	2	}
142
143			return gpg_program;
144			}
145
146	twoaday	7
147			const char *
148			_gpgme_get_gpg_optfile (int cleanup)
149			{
150			static char *gpg_optfile = NULL;
151	twoaday	2
152	twoaday	7	if (cleanup) {
153			if (gpg_optfile) {
154			free (gpg_optfile);
155			gpg_optfile = NULL;
156			}
157			return NULL;
158	twoaday	2	}
159
160	twoaday	7	if (!gpg_optfile) {
161			FILE *fp;
162			gpg_optfile = read_w32_registry_string(
163			NULL, "Software\\GNU\\GnuPG", "OptFile" );
164			if (gpg_optfile) {
165			int i;
166			for (i = 0; gpg_optfile[i]; i++) {
167			if (gpg_optfile[i] == '/')
168			gpg_optfile[i] = '\\';
169			}
170			if (!strcmp(gpg_optfile, ""))
171			return NULL; /* Then ignore the file */
172			fp = fopen (gpg_optfile, "r");
173			if (fp == NULL)
174			return NULL;
175			fclose (fp);
176			}
177			}
178
179	twoaday	2	return gpg_optfile;
180			} /* _gpgme_get_gpg_optfile */
181
182	twoaday	7
183			void
184			util_cleanup (void)
185	twoaday	2	{
186	twoaday	7	_gpgme_get_gpg_optfile (1);
187			_gpgme_get_gpg_path (1);
188			}