trunk/MyGPGME/debug.c

/* debug.c
 *      Copyright (C) 2001 Werner Koch (dd9jn)
 *
 * 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 <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <assert.h>
#include <windows.h>
#include <process.h>
#include <io.h>

#include "util.h"
#include "sema.h"


/* XXX find a way to cleanup all static vars at the end */
DEFINE_STATIC_LOCK (debug_lock);

struct debug_control_s {
    FILE *  fp;
    char    fname[100];
};

static int debug_level = 0;
static FILE * errfp = NULL;


void 
debug_cleanup (void)
{
    DESTROY_LOCK (debug_lock);
}

/****************
 * remove leading and trailing white spaces
 */
static char *
trim_spaces( char *str )
{
    char *string, *p, *mark;

    string = str;
    /* find first non space character */
    for( p=string; *p && isspace( *(byte*)p ) ; p++ )
        ;
    /* move characters */
    for( (mark = NULL); (*string = *p); string++, p++ )
        if( isspace( *(byte*)p ) ) {
            if( !mark )
                mark = string ;
        }
        else
            mark = NULL ;
    if( mark )
        *mark = '\0' ;  /* remove trailing spaces */

    return str ;
}

static const char*
extract_fname( const char *file )
{
        const char *p;

        do {
                p = strchr( file, '\\' );
                file += (p-file+1);             
                if ( !strchr( file, '\\' ) )
                        break;
        } while ( p );
        return file;
}

static void
debug_init (void)
{
    static volatile int initialized = 0;
        
    if (initialized) 
        return;
    LOCK (debug_lock);
    if (!initialized) {
        const char *e = getenv ("GPGME_DEBUG");
        const char *s1, *s2;

        initialized = 1;
        debug_level = 0;
        errfp = stderr;         
        if (e) {
            debug_level = atoi (e);
            s1 = strchr (e, ':');
            if (s1) {
                char *p;
                FILE *fp;

                s1++;
                if ( !(s2 = strchr (s1, ':')) )
                    s2 = s1 + strlen(s1);
                p = malloc (s2-s1+1);
                if (p) {
                    memcpy (p, s1, s2-s1);
                    p[s2-s1] = 0;
                    trim_spaces (p);
                    fp = fopen (p,"a");
                    if (fp) {
                        setvbuf (fp, NULL, _IOLBF, 0);
                        errfp = fp;
                    }
                    safe_free (p);
                }
            }
        }

        if (debug_level > 0)
            fprintf (errfp,"gpgme_debug: level=%d\n", debug_level);
    }
    UNLOCK (debug_lock);
}

int
_gpgme_debug_level ()
{
    return debug_level;
}

void
_gpgme_debug (int level, int line, const char *fname, const char *format, ...)
{       
    va_list arg_ptr ;

    debug_init ();
    if ( debug_level < level )
        return;

    LOCK (debug_lock);
    fprintf(errfp, "%s:%d ", extract_fname( fname ), line );
    va_start ( arg_ptr, format );    
    vfprintf (errfp, format, arg_ptr);
    va_end ( arg_ptr ) ;
    if( format && *format && format[strlen(format)-1] != '\n' )
        putc ('\n', errfp);
    UNLOCK (debug_lock);
    fflush (errfp);
}


void
_gpgme_debug_begin ( void **helper, int level, const char *text)
{
    struct debug_control_s *ctl;

    debug_init ();

    *helper = NULL;
    if ( debug_level < level )
        return;
    ctl = calloc (1, sizeof *ctl );
    if (!ctl) {
        _gpgme_debug (255, __LINE__, extract_fname( __FILE__ ), "out of core");
        return;
    }

    /* Oh what a pitty that we don't have a asprintf or snprintf under
     * Windows.  We definitely should write our own clib for W32! */
    sprintf ( ctl->fname, "/tmp/gpgme_debug.%d.%p", getpid (), ctl );
    ctl->fp = fopen (ctl->fname, "w+");
    if (!ctl->fp) {
        _gpgme_debug (255, __LINE__, extract_fname( __FILE__), 
                      "failed to create `%s'", ctl->fname );
        safe_free (ctl);
        return;
    }
    *helper = ctl;
    _gpgme_debug_add (helper, "%s", text );
}

int
_gpgme_debug_enabled (void **helper)
{
    return helper && *helper;
}


void
_gpgme_debug_add (void **helper, const char *format, ...)
{
    struct debug_control_s *ctl = *helper;
    va_list arg_ptr ;

    if ( !*helper )
        return;
    
    va_start ( arg_ptr, format ) ;
    vfprintf (ctl->fp, format, arg_ptr) ;
    va_end ( arg_ptr ) ;
}

void
_gpgme_debug_end (void **helper, const char *text)
{
    struct debug_control_s *ctl = *helper;
    int c, last_c = EOF;

    if (!*helper)
        return;
    
    _gpgme_debug_add (helper, "%s", text );
    fflush (ctl->fp); /* we need this for the buggy Windows libc */
    rewind (ctl->fp);
    LOCK (debug_lock);
    while ( (c=getc (ctl->fp)) != EOF ) {
        putc (c, stderr);
        last_c = c;
    }
    if (last_c != '\n')
        putc ('\n', errfp);
    UNLOCK (debug_lock);
    
    fclose (ctl->fp);
    remove (ctl->fname);
    safe_free (ctl);
    *helper = NULL;
}
1	twoaday	2	/* debug.c
2			* Copyright (C) 2001 Werner Koch (dd9jn)
3			*
4			* This file is part of MyGPGME.
5			*
6			* MyGPGME is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* MyGPGME 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
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20
21			#include <ctype.h>
22			#include <stdio.h>
23			#include <stdlib.h>
24			#include <string.h>
25			#include <stdarg.h>
26			#include <assert.h>
27			#include <windows.h>
28			#include <process.h>
29			#include <io.h>
30
31			#include "util.h"
32			#include "sema.h"
33
34
35			/* XXX find a way to cleanup all static vars at the end */
36			DEFINE_STATIC_LOCK (debug_lock);
37
38			struct debug_control_s {
39			FILE * fp;
40			char fname[100];
41			};
42
43			static int debug_level = 0;
44			static FILE * errfp = NULL;
45
46
47			void
48			debug_cleanup (void)
49			{
50			DESTROY_LOCK (debug_lock);
51			}
52
53			/****************
54			* remove leading and trailing white spaces
55			*/
56			static char *
57			trim_spaces( char *str )
58			{
59			char string, p, *mark;
60
61			string = str;
62			/* find first non space character */
63			for( p=string; p && isspace( (byte*)p ) ; p++ )
64			;
65			/* move characters */
66			for( (mark = NULL); (string = p); string++, p++ )
67			if( isspace( (byte)p ) ) {
68			if( !mark )
69			mark = string ;
70			}
71			else
72			mark = NULL ;
73			if( mark )
74			mark = '\0' ; / remove trailing spaces */
75
76			return str ;
77			}
78
79			static const char*
80			extract_fname( const char *file )
81			{
82			const char *p;
83
84			do {
85			p = strchr( file, '\\' );
86			file += (p-file+1);
87			if ( !strchr( file, '\\' ) )
88			break;
89			} while ( p );
90			return file;
91			}
92
93			static void
94			debug_init (void)
95			{
96			static volatile int initialized = 0;
97
98			if (initialized)
99			return;
100			LOCK (debug_lock);
101			if (!initialized) {
102			const char *e = getenv ("GPGME_DEBUG");
103			const char s1, s2;
104
105			initialized = 1;
106			debug_level = 0;
107			errfp = stderr;
108			if (e) {
109			debug_level = atoi (e);
110			s1 = strchr (e, ':');
111			if (s1) {
112			char *p;
113			FILE *fp;
114
115			s1++;
116			if ( !(s2 = strchr (s1, ':')) )
117			s2 = s1 + strlen(s1);
118			p = malloc (s2-s1+1);
119			if (p) {
120			memcpy (p, s1, s2-s1);
121			p[s2-s1] = 0;
122			trim_spaces (p);
123			fp = fopen (p,"a");
124			if (fp) {
125			setvbuf (fp, NULL, _IOLBF, 0);
126			errfp = fp;
127			}
128			safe_free (p);
129			}
130			}
131			}
132
133			if (debug_level > 0)
134			fprintf (errfp,"gpgme_debug: level=%d\n", debug_level);
135			}
136			UNLOCK (debug_lock);
137			}
138
139			int
140			_gpgme_debug_level ()
141			{
142			return debug_level;
143			}
144
145			void
146			_gpgme_debug (int level, int line, const char fname, const char format, ...)
147			{
148			va_list arg_ptr ;
149
150			debug_init ();
151			if ( debug_level < level )
152			return;
153
154			LOCK (debug_lock);
155			fprintf(errfp, "%s:%d ", extract_fname( fname ), line );
156			va_start ( arg_ptr, format );
157			vfprintf (errfp, format, arg_ptr);
158			va_end ( arg_ptr ) ;
159			if( format && *format && format[strlen(format)-1] != '\n' )
160			putc ('\n', errfp);
161			UNLOCK (debug_lock);
162			fflush (errfp);
163			}
164
165
166
167			void
168			_gpgme_debug_begin ( void *helper, int level, const char text)
169			{
170			struct debug_control_s *ctl;
171
172			debug_init ();
173
174			*helper = NULL;
175			if ( debug_level < level )
176			return;
177			ctl = calloc (1, sizeof *ctl );
178			if (!ctl) {
179			_gpgme_debug (255, __LINE__, extract_fname( __FILE__ ), "out of core");
180			return;
181			}
182
183			/* Oh what a pitty that we don't have a asprintf or snprintf under
184			* Windows. We definitely should write our own clib for W32! */
185			sprintf ( ctl->fname, "/tmp/gpgme_debug.%d.%p", getpid (), ctl );
186			ctl->fp = fopen (ctl->fname, "w+");
187			if (!ctl->fp) {
188			_gpgme_debug (255, __LINE__, extract_fname( __FILE__),
189			"failed to create `%s'", ctl->fname );
190			safe_free (ctl);
191			return;
192			}
193			*helper = ctl;
194			_gpgme_debug_add (helper, "%s", text );
195			}
196
197			int
198			_gpgme_debug_enabled (void **helper)
199			{
200			return helper && *helper;
201			}
202
203
204			void
205			_gpgme_debug_add (void *helper, const char format, ...)
206			{
207			struct debug_control_s ctl = helper;
208			va_list arg_ptr ;
209
210			if ( !*helper )
211			return;
212
213			va_start ( arg_ptr, format ) ;
214			vfprintf (ctl->fp, format, arg_ptr) ;
215			va_end ( arg_ptr ) ;
216			}
217
218			void
219			_gpgme_debug_end (void *helper, const char text)
220			{
221			struct debug_control_s ctl = helper;
222			int c, last_c = EOF;
223
224			if (!*helper)
225			return;
226
227			_gpgme_debug_add (helper, "%s", text );
228			fflush (ctl->fp); /* we need this for the buggy Windows libc */
229			rewind (ctl->fp);
230			LOCK (debug_lock);
231			while ( (c=getc (ctl->fp)) != EOF ) {
232			putc (c, stderr);
233			last_c = c;
234			}
235			if (last_c != '\n')
236			putc ('\n', errfp);
237			UNLOCK (debug_lock);
238
239			fclose (ctl->fp);
240			remove (ctl->fname);
241			safe_free (ctl);
242			*helper = NULL;
243			}