trunk/Src/wptErrors.cpp

/* wptErrors.cpp - Error management
 *      Copyright (C) 2000-2004 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT 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.
 *  
 * WinPT 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 WinPT; 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 <windows.h>
#include <stdio.h>

#include "wptErrors.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptGPG.h"
#include "wptNLS.h"


static char *
gpg_strerror( int errid )
{
    static char buf[512];
    char * path = NULL;

    path = get_gnupg_path();
    if( !path )
        BUG( NULL );
    switch( errid ) {
    case WPTERR_GPG_EXEFILE:
        _snprintf( buf, sizeof buf - 1, _("Could not locate GPG.exe in %s."), path );   
        break;
    case WPTERR_GPG_OPT_KEYRINGS:
    case WPTERR_GPG_KEYRINGS:
        _snprintf( buf, sizeof buf - 1, 
                   _("Could not find keyring entries into the options file in %s "
                     "or the file does NOT exist."), path );
        break;
    }
    free_if_alloc( path );
    return buf;
} /* gpg_strerror */


static void 
w32_fmt_msg (char *buf, size_t buflen)
{
    FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError (), 
                   MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), 
                   buf, buflen, NULL);
}

/* Return an error specific message.
   If there is a translation available, it returns the translated text. */
const char*
winpt_strerror (int errid)
{       
    static char buf[256];
        
    switch( errid ) {
    case -1: w32_fmt_msg (buf, 255); return buf;
    case WPTERR_GENERAL: return _("General error occured");
    case WPTERR_FILE_OPEN: return _("Could not open file");
    case WPTERR_FILE_CREAT: return _("Could not create file");
    case WPTERR_FILE_READ: return _("Could not read file");
    case WPTERR_FILE_WRITE: return _("Could not write file");
    case WPTERR_FILE_CLOSE: return _("Could not close file");
    case WPTERR_FILE_EXIST: return _("File does not exist");
    case WPTERR_FILE_REMOVE: return _("Could not delete file");
    case WPTERR_CLIP_OPEN: return _("Could not open Clipboard");
    case WPTERR_CLIP_CLOSE: return _("Could not close Clipboard");
    case WPTERR_CLIP_EMPTY: return _("Could not empty Clipboard");
    case WPTERR_CLIP_SET: return _("Could not set Clipboard data");
    case WPTERR_CLIP_GET: return _("Could not get Clipboard data");
    case WPTERR_CLIP_ISEMPTY: return _("There is no text in the Clipboard");
    case WPTERR_CLIP_SECURED: return _("The Clipboard already contains GPG data");
    case WPTERR_CLIP: return _("General Clipboard error");
    case WPTERR_REGISTRY: sprintf (buf, "%s", _("Registry error: "));
                          w32_fmt_msg (buf + strlen (buf), 128);
                          return buf;
    case WPTERR_WINSOCK_INIT: return _("Could not startup Winsock 2 interface");
    case WPTERR_WINSOCK_RESOLVE: return _("Could not resolve hostname");
    case WPTERR_WINSOCK_SOCKET: return _("Could not create new socket");
    case WPTERR_WINSOCK_CONNECT: return _("Could not connect to the host");
    case WPTERR_WINSOCK_SENDKEY: return _("Could not send the key to the keyserver");
    case WPTERR_WINSOCK_RECVKEY: return _("Could not receive the key from the keyserver");
    case WPTERR_WINSOCK_TIMEOUT: return _("Socket timed out, no data");
    case WPTERR_KEYSERVER_NOTFOUND: return _("Keyserver returned: no matching keys in database");
    case WPTERR_HOTKEY: sprintf (buf, "%s", _("Could not register hotkey: "));
                        w32_fmt_msg (buf + strlen (buf), 128);
                        return buf;
    case WPTERR_DIR_OPEN: return _("Could not open directory");
    case WPTERR_DIR_CREAT: return _("Could not create directory");
    case WPTERR_CURR_WND: return _("Could not extract data from the current window");
    case WPTERR_CONFIG_FILE: return _("Could not load config file");    
    case WPTERR_GPG_EXEFILE:    
    case WPTERR_GPG_OPT_KEYRINGS:
    case WPTERR_GPG_KEYRINGS: return gpg_strerror (errid);
    case WPTERR_NOCARD: return _("There is no card in the reader");
    case WPTERR_NOREADER: return _("There was no reader found");
    case WPTERR_NOPGPCARD: return _("This is not an OpenPGP card");
    case WPTERR_CDISK_LOCK: return _("Could not lock or unlock volume");
    case WPTERR_CDISK_MOUNT: return _("Could not mount volume");
    case WPTERR_CDISK_UMOUNT: return _("Could not unmount volume");
    case WPTERR_CDISK_OPEN: return _("Could not  open volume");
    case WPTERR_CDISK_BUSY: return _("Drive that belongs to the volume is busy");
    case WPTERR_CDISK_QUERY: return _("Could not query volume information");
    default: _snprintf (buf, sizeof (buf) - 1, _("Unknown error=%d"), errid); return buf;
    }

    return NULL;
} /* winpt_strerror */


void
winpt_errmsg (const char * name, int is_file)
{       
    TCHAR buf[500], head[500];
    DWORD last_err;

    memset (head, 0, sizeof head);
    last_err = GetLastError ();
    if (!name)
        strcpy (head, _("WinPT Error"));
    else if (is_file)
        _snprintf (head, DIM (head)-1, "%s: %d", name, last_err);
    else
        strncpy (head, name, DIM (head)-1);
    FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, last_err, 
                   MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), 
                   buf, DIM (buf)-1, NULL);
    MessageBox (NULL, buf, head, MB_OK);
} /* winpt_errmsg */


void
winpt_debug_msg( void )
{       
    char output[768], temp[384];
        
    GetTempPath( sizeof temp -1, temp );
    _snprintf( output, sizeof output - 1, 
        "The GPGME output file is gpgme.dbg\n"
        "The WinPT output file is %swinpt.log\n", temp );
    MessageBox( NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO );
} /* winpt_debug_msg */


/* Dummy function.  Not sure for what it is used. */
void
debug_end (void)
{
  
  
}


void
debug_box( const char *msg, const char *file, int line )
{
#if _DEBUG
    char output[4096];

    memset( output, 0, sizeof output ); 
    _snprintf( output, sizeof output -1,
        "WinPT DBG:\n \"%s\", file %s, line %d\n", msg, file, line );   
    MessageBox( NULL, output, PGM_NAME, MB_OK | MB_ICONERROR );
#endif
} /* debug_box */


void
debug_f( const char *msg, const char *file, int line )
{
#if _DEBUG
    FILE *fp;
    char temp_path[ 1024 ];
    char output[ 4096 ];

    GetTempPath( sizeof temp_path - 1, temp_path );     
    strcat( temp_path, "\\WinPT.DEBUG" );       
    fp = fopen( temp_path, "a+b" );     
    if( !fp )
        return;
    memset( output, 0, sizeof output );
    _snprintf( output, sizeof output -1,
               "WinPT DBG:\n \"%s\", file %s, line %d\n", msg, file, line );
    fwrite( output, 1, strlen( output ), fp );
    fflush( fp );
    fclose( fp );
#endif
} /* debug_f */


void
log_debug (const char *format, ...)
{
    FILE *fp;
    char temp_path[384];
    va_list arg_ptr;

    if (!debug)
        return;

    GetTempPath (sizeof temp_path - 1, temp_path);
    strcat (temp_path, "\\WinPT.LOG");
    fp = fopen (temp_path, "a+b");
    if (!fp)
        return;
    va_start (arg_ptr, format);
    vfprintf (fp, format, arg_ptr);
    va_end (arg_ptr);
    fflush (fp);
    fclose (fp);
}


int
printf_box (const char *title, int style, const char *format, ...)
{
    va_list arg_ptr;
    char log[8192];
    int id;

    va_start (arg_ptr, format);
    _vsnprintf (log, sizeof (log)-1, format, arg_ptr);    
    id = msg_box (NULL, log, title? title : "Log Output", style);
    va_end( arg_ptr );

    return id;
} /* log_box */
1	/* wptErrors.cpp - Error management
2	* Copyright (C) 2000-2004 Timo Schulz
3	*
4	* This file is part of WinPT.
5	*
6	* WinPT is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU General Public License
8	* as published by the Free Software Foundation; either version 2
9	* of the License, or (at your option) any later version.
10	*
11	* WinPT is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with WinPT; if not, write to the Free Software Foundation,
18	* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	#ifdef HAVE_CONFIG_H
22	#include <config.h>
23	#endif
24
25	#include <windows.h>
26	#include <stdio.h>
27
28	#include "wptErrors.h"
29	#include "wptTypes.h"
30	#include "wptW32API.h"
31	#include "wptVersion.h"
32	#include "wptGPG.h"
33	#include "wptNLS.h"
34
35
36	static char *
37	gpg_strerror( int errid )
38	{
39	static char buf[512];
40	char * path = NULL;
41
42	path = get_gnupg_path();
43	if( !path )
44	BUG( NULL );
45	switch( errid ) {
46	case WPTERR_GPG_EXEFILE:
47	_snprintf( buf, sizeof buf - 1, _("Could not locate GPG.exe in %s."), path );
48	break;
49	case WPTERR_GPG_OPT_KEYRINGS:
50	case WPTERR_GPG_KEYRINGS:
51	_snprintf( buf, sizeof buf - 1,
52	_("Could not find keyring entries into the options file in %s "
53	"or the file does NOT exist."), path );
54	break;
55	}
56	free_if_alloc( path );
57	return buf;
58	} /* gpg_strerror */
59
60
61	static void
62	w32_fmt_msg (char *buf, size_t buflen)
63	{
64	FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError (),
65	MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
66	buf, buflen, NULL);
67	}
68
69	/* Return an error specific message.
70	If there is a translation available, it returns the translated text. */
71	const char*
72	winpt_strerror (int errid)
73	{
74	static char buf[256];
75
76	switch( errid ) {
77	case -1: w32_fmt_msg (buf, 255); return buf;
78	case WPTERR_GENERAL: return _("General error occured");
79	case WPTERR_FILE_OPEN: return _("Could not open file");
80	case WPTERR_FILE_CREAT: return _("Could not create file");
81	case WPTERR_FILE_READ: return _("Could not read file");
82	case WPTERR_FILE_WRITE: return _("Could not write file");
83	case WPTERR_FILE_CLOSE: return _("Could not close file");
84	case WPTERR_FILE_EXIST: return _("File does not exist");
85	case WPTERR_FILE_REMOVE: return _("Could not delete file");
86	case WPTERR_CLIP_OPEN: return _("Could not open Clipboard");
87	case WPTERR_CLIP_CLOSE: return _("Could not close Clipboard");
88	case WPTERR_CLIP_EMPTY: return _("Could not empty Clipboard");
89	case WPTERR_CLIP_SET: return _("Could not set Clipboard data");
90	case WPTERR_CLIP_GET: return _("Could not get Clipboard data");
91	case WPTERR_CLIP_ISEMPTY: return _("There is no text in the Clipboard");
92	case WPTERR_CLIP_SECURED: return _("The Clipboard already contains GPG data");
93	case WPTERR_CLIP: return _("General Clipboard error");
94	case WPTERR_REGISTRY: sprintf (buf, "%s", _("Registry error: "));
95	w32_fmt_msg (buf + strlen (buf), 128);
96	return buf;
97	case WPTERR_WINSOCK_INIT: return _("Could not startup Winsock 2 interface");
98	case WPTERR_WINSOCK_RESOLVE: return _("Could not resolve hostname");
99	case WPTERR_WINSOCK_SOCKET: return _("Could not create new socket");
100	case WPTERR_WINSOCK_CONNECT: return _("Could not connect to the host");
101	case WPTERR_WINSOCK_SENDKEY: return _("Could not send the key to the keyserver");
102	case WPTERR_WINSOCK_RECVKEY: return _("Could not receive the key from the keyserver");
103	case WPTERR_WINSOCK_TIMEOUT: return _("Socket timed out, no data");
104	case WPTERR_KEYSERVER_NOTFOUND: return _("Keyserver returned: no matching keys in database");
105	case WPTERR_HOTKEY: sprintf (buf, "%s", _("Could not register hotkey: "));
106	w32_fmt_msg (buf + strlen (buf), 128);
107	return buf;
108	case WPTERR_DIR_OPEN: return _("Could not open directory");
109	case WPTERR_DIR_CREAT: return _("Could not create directory");
110	case WPTERR_CURR_WND: return _("Could not extract data from the current window");
111	case WPTERR_CONFIG_FILE: return _("Could not load config file");
112	case WPTERR_GPG_EXEFILE:
113	case WPTERR_GPG_OPT_KEYRINGS:
114	case WPTERR_GPG_KEYRINGS: return gpg_strerror (errid);
115	case WPTERR_NOCARD: return _("There is no card in the reader");
116	case WPTERR_NOREADER: return _("There was no reader found");
117	case WPTERR_NOPGPCARD: return _("This is not an OpenPGP card");
118	case WPTERR_CDISK_LOCK: return _("Could not lock or unlock volume");
119	case WPTERR_CDISK_MOUNT: return _("Could not mount volume");
120	case WPTERR_CDISK_UMOUNT: return _("Could not unmount volume");
121	case WPTERR_CDISK_OPEN: return _("Could not open volume");
122	case WPTERR_CDISK_BUSY: return _("Drive that belongs to the volume is busy");
123	case WPTERR_CDISK_QUERY: return _("Could not query volume information");
124	default: _snprintf (buf, sizeof (buf) - 1, _("Unknown error=%d"), errid); return buf;
125	}
126
127	return NULL;
128	} /* winpt_strerror */
129
130
131	void
132	winpt_errmsg (const char * name, int is_file)
133	{
134	TCHAR buf[500], head[500];
135	DWORD last_err;
136
137	memset (head, 0, sizeof head);
138	last_err = GetLastError ();
139	if (!name)
140	strcpy (head, _("WinPT Error"));
141	else if (is_file)
142	_snprintf (head, DIM (head)-1, "%s: %d", name, last_err);
143	else
144	strncpy (head, name, DIM (head)-1);
145	FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL, last_err,
146	MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
147	buf, DIM (buf)-1, NULL);
148	MessageBox (NULL, buf, head, MB_OK);
149	} /* winpt_errmsg */
150
151
152
153	void
154	winpt_debug_msg( void )
155	{
156	char output[768], temp[384];
157
158	GetTempPath( sizeof temp -1, temp );
159	_snprintf( output, sizeof output - 1,
160	"The GPGME output file is gpgme.dbg\n"
161	"The WinPT output file is %swinpt.log\n", temp );
162	MessageBox( NULL, output, "WinPT now runs in DEBUG MODE", MB_INFO );
163	} /* winpt_debug_msg */
164
165
166	/* Dummy function. Not sure for what it is used. */
167	void
168	debug_end (void)
169	{
170
171
172	}
173
174
175
176	void
177	debug_box( const char msg, const char file, int line )
178	{
179	#if _DEBUG
180	char output[4096];
181
182	memset( output, 0, sizeof output );
183	_snprintf( output, sizeof output -1,
184	"WinPT DBG:\n \"%s\", file %s, line %d\n", msg, file, line );
185	MessageBox( NULL, output, PGM_NAME, MB_OK \| MB_ICONERROR );
186	#endif
187	} /* debug_box */
188
189
190	void
191	debug_f( const char msg, const char file, int line )
192	{
193	#if _DEBUG
194	FILE *fp;
195	char temp_path[ 1024 ];
196	char output[ 4096 ];
197
198	GetTempPath( sizeof temp_path - 1, temp_path );
199	strcat( temp_path, "\\WinPT.DEBUG" );
200	fp = fopen( temp_path, "a+b" );
201	if( !fp )
202	return;
203	memset( output, 0, sizeof output );
204	_snprintf( output, sizeof output -1,
205	"WinPT DBG:\n \"%s\", file %s, line %d\n", msg, file, line );
206	fwrite( output, 1, strlen( output ), fp );
207	fflush( fp );
208	fclose( fp );
209	#endif
210	} /* debug_f */
211
212
213	void
214	log_debug (const char *format, ...)
215	{
216	FILE *fp;
217	char temp_path[384];
218	va_list arg_ptr;
219
220	if (!debug)
221	return;
222
223	GetTempPath (sizeof temp_path - 1, temp_path);
224	strcat (temp_path, "\\WinPT.LOG");
225	fp = fopen (temp_path, "a+b");
226	if (!fp)
227	return;
228	va_start (arg_ptr, format);
229	vfprintf (fp, format, arg_ptr);
230	va_end (arg_ptr);
231	fflush (fp);
232	fclose (fp);
233	}
234
235
236	int
237	printf_box (const char title, int style, const char format, ...)
238	{
239	va_list arg_ptr;
240	char log[8192];
241	int id;
242
243	va_start (arg_ptr, format);
244	_vsnprintf (log, sizeof (log)-1, format, arg_ptr);
245	id = msg_box (NULL, log, title? title : "Log Output", style);
246	va_end( arg_ptr );
247
248	return id;
249	} /* log_box */