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"

/****************
 * 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;
    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 = malloc( (n1=nbytes+1) );
    if( !result )
        goto leave;
    if( RegQueryValueEx( key_handle, name, 0, NULL, result, &n1 ) ) {
        safe_free(result); result = NULL;
        goto leave;
    }
    result[nbytes] = 0; /* make sure it is really a string  */
    
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			/****************
36			* Return a string from the Win32 Registry or NULL in case of
37			* error. Caller must release the return value. A NULL for root
38			* is an alias fro HKEY_CURRENT_USER
39			*/
40			static char *
41			read_w32_registry_string ( const char *root,
42			const char dir, const char name )
43			{
44			HKEY root_key, key_handle;
45			DWORD n1, nbytes;
46			char *result = NULL;
47
48			if( !root )
49			root_key = HKEY_CURRENT_USER;
50			else if( !strcmp( root, "HKEY_CLASSES_ROOT" ) )
51			root_key = HKEY_CLASSES_ROOT;
52			else if( !strcmp( root, "HKEY_CURRENT_USER" ) )
53			root_key = HKEY_CURRENT_USER;
54			else if( !strcmp( root, "HKEY_LOCAL_MACHINE" ) )
55			root_key = HKEY_LOCAL_MACHINE;
56			else if( !strcmp( root, "HKEY_USERS" ) )
57			root_key = HKEY_USERS;
58			else if( !strcmp( root, "HKEY_PERFORMANCE_DATA" ) )
59			root_key = HKEY_PERFORMANCE_DATA;
60			else if( !strcmp( root, "HKEY_CURRENT_CONFIG" ) )
61			root_key = HKEY_CURRENT_CONFIG;
62			else
63			return NULL;
64
65			if( RegOpenKeyEx( root_key, dir, 0, KEY_READ, &key_handle ) )
66			return NULL; /* no need for a RegClose, so return direct */
67
68			nbytes = 1;
69			if( RegQueryValueEx( key_handle, name, 0, NULL, NULL, &nbytes ) )
70			goto leave;
71			result = malloc( (n1=nbytes+1) );
72			if( !result )
73			goto leave;
74			if( RegQueryValueEx( key_handle, name, 0, NULL, result, &n1 ) ) {
75			safe_free(result); result = NULL;
76			goto leave;
77			}
78			result[nbytes] = 0; /* make sure it is really a string */
79
80			leave:
81			RegCloseKey( key_handle );
82			return result;
83			}
84
85
86			const char *
87	twoaday	7	_gpgme_get_gpg_path (int cleanup)
88	twoaday	2	{
89			static char *gpg_program = NULL;
90
91	twoaday	7	if (cleanup) {
92			if (gpg_program) {
93			free (gpg_program);
94			gpg_program = NULL;
95			}
96			return NULL;
97			}
98
99	twoaday	2	if (!gpg_program) {
100	twoaday	7	gpg_program = read_w32_registry_string (NULL,
101			"Software\\GNU\\GnuPG", "gpgProgram");
102	twoaday	2	if (gpg_program) {
103			int i;
104
105			DEBUG1 ("found gpgProgram in registry: `%s'\n", gpg_program );
106			for (i=0; gpg_program[i]; i++) {
107			if (gpg_program[i] == '/')
108			gpg_program[i] = '\\';
109			}
110			}
111	twoaday	7	else
112			gpg_program = strdup ("C:\\GNUPG\\GPG.EXE");
113	twoaday	2	}
114
115			return gpg_program;
116			}
117
118	twoaday	7
119			const char *
120			_gpgme_get_gpg_optfile (int cleanup)
121			{
122			static char *gpg_optfile = NULL;
123	twoaday	2
124	twoaday	7	if (cleanup) {
125			if (gpg_optfile) {
126			free (gpg_optfile);
127			gpg_optfile = NULL;
128			}
129			return NULL;
130	twoaday	2	}
131
132	twoaday	7	if (!gpg_optfile) {
133			FILE *fp;
134			gpg_optfile = read_w32_registry_string(
135			NULL, "Software\\GNU\\GnuPG", "OptFile" );
136			if (gpg_optfile) {
137			int i;
138			for (i = 0; gpg_optfile[i]; i++) {
139			if (gpg_optfile[i] == '/')
140			gpg_optfile[i] = '\\';
141			}
142			if (!strcmp(gpg_optfile, ""))
143			return NULL; /* Then ignore the file */
144			fp = fopen (gpg_optfile, "r");
145			if (fp == NULL)
146			return NULL;
147			fclose (fp);
148			}
149			}
150
151	twoaday	2	return gpg_optfile;
152			} /* _gpgme_get_gpg_optfile */
153
154	twoaday	7
155			void
156			util_cleanup (void)
157	twoaday	2	{
158	twoaday	7	_gpgme_get_gpg_optfile (1);
159			_gpgme_get_gpg_path (1);
160			}