dlls/ntdll/debugtools.c - wine - Git at Google

 /*
  * Debugging functions
  *
  * Copyright 2000 Alexandre Julliard
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library 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
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */

 #include "config.h"
 #include "wine/port.h"

 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifdef HAVE_UNISTD_H
 # include <unistd.h>
 #endif
 #include <ctype.h>

 #include "wine/debug.h"
 #include "wine/exception.h"
 #include "wine/library.h"
 #include "wine/unicode.h"
 #include "ntstatus.h"
 #include "thread.h"
 #include "winbase.h"
 #include "winnt.h"
 #include "winternl.h"
 #include "excpt.h"
 #include "ntdll_misc.h"

 WINE_DECLARE_DEBUG_CHANNEL(tid);

 /* ---------------------------------------------------------------------- */

 /* filter for page-fault exceptions */
 static WINE_EXCEPTION_FILTER(page_fault)
 {
     if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
         return EXCEPTION_EXECUTE_HANDLER;
     return EXCEPTION_CONTINUE_SEARCH;
 }

 /* get the debug info pointer for the current thread */
 static inline struct debug_info *get_info(void)
 {
     return NtCurrentTeb()->debug_info;
 }

 /* allocate some tmp space for a string */
 static void *gimme1(int n)
 {
     struct debug_info *info = get_info();
     char *res = info->str_pos;

     if (res + n >= &info->strings[sizeof(info->strings)]) res = info->strings;
     info->str_pos = res + n;
     return res;
 }

 /* release extra space that we requested in gimme1() */
 static inline void release( void *ptr )
 {
     struct debug_info *info = NtCurrentTeb()->debug_info;
     info->str_pos = ptr;
 }

 /* put an ASCII string into the debug buffer */
 inline static char *put_string_a( const char *src, int n )
 {
     static const char hex[16] = "0123456789abcdef";
     char *dst, *res;
     size_t size;

     if (n == -1) n = strlen(src);
     if (n < 0) n = 0;
     size = 10 + min( 300, n * 4 );
     dst = res = gimme1( size );
     *dst++ = '"';
     while (n-- > 0 && dst <= res + size - 9)
     {
         unsigned char c = *src++;
         switch (c)
         {
         case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
         case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
         case '\t': *dst++ = '\\'; *dst++ = 't'; break;
         case '"': *dst++ = '\\'; *dst++ = '"'; break;
         case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
         default:
             if (c >= ' ' && c <= 126)
                 *dst++ = c;
             else
             {
                 *dst++ = '\\';
                 *dst++ = 'x';
                 *dst++ = hex[(c >> 4) & 0x0f];
                 *dst++ = hex[c & 0x0f];
             }
         }
     }
     *dst++ = '"';
     if (*src)
     {
         *dst++ = '.';
         *dst++ = '.';
         *dst++ = '.';
     }
     *dst++ = '\0';
     release( dst );
     return res;
 }

 /* put a Unicode string into the debug buffer */
 inline static char *put_string_w( const WCHAR *src, int n )
 {
     char *dst, *res;
     size_t size;

     if (n == -1) n = strlenW(src);
     if (n < 0) n = 0;
     size = 12 + min( 300, n * 5 );
     dst = res = gimme1( size );
     *dst++ = 'L';
     *dst++ = '"';
     while (n-- > 0 && dst <= res + size - 10)
     {
         WCHAR c = *src++;
         switch (c)
         {
         case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
         case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
         case '\t': *dst++ = '\\'; *dst++ = 't'; break;
         case '"': *dst++ = '\\'; *dst++ = '"'; break;
         case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
         default:
             if (c >= ' ' && c <= 126)
                 *dst++ = c;
             else
             {
                 *dst++ = '\\';
                 sprintf(dst,"%04x",c);
                 dst+=4;
             }
         }
     }
     *dst++ = '"';
     if (*src)
     {
         *dst++ = '.';
         *dst++ = '.';
         *dst++ = '.';
     }
     *dst++ = '\0';
     release( dst );
     return res;
 }

 /***********************************************************************
  *		NTDLL_dbgstr_an
  */
 static const char *NTDLL_dbgstr_an( const char *src, int n )
 {
     char *res, *old_pos;
     struct debug_info *info = get_info();

     if (!HIWORD(src))
     {
         if (!src) return "(null)";
         res = gimme1(6);
         sprintf(res, "#%04x", LOWORD(src) );
         return res;
     }
     /* save current position to restore it on exception */
     old_pos = info->str_pos;
     __TRY
     {
         res = put_string_a( src, n );
     }
     __EXCEPT(page_fault)
     {
         release( old_pos );
         return "(invalid)";
     }
     __ENDTRY
     return res;
 }

 /***********************************************************************
  *		NTDLL_dbgstr_wn
  */
 static const char *NTDLL_dbgstr_wn( const WCHAR *src, int n )
 {
     char *res, *old_pos;
     struct debug_info *info = get_info();

     if (!HIWORD(src))
     {
         if (!src) return "(null)";
         res = gimme1(6);
         sprintf(res, "#%04x", LOWORD(src) );
         return res;
     }

     /* save current position to restore it on exception */
     old_pos = info->str_pos;
     __TRY
     {
         res = put_string_w( src, n );
     }
     __EXCEPT(page_fault)
     {
         release( old_pos );
         return "(invalid)";
     }
     __ENDTRY
      return res;
 }

 /***********************************************************************
  *		NTDLL_dbg_vsprintf
  */
 static const char *NTDLL_dbg_vsprintf( const char *format, va_list args )
 {
     static const int max_size = 200;

     char *res = gimme1( max_size );
     int len = vsnprintf( res, max_size, format, args );
     if (len == -1 || len >= max_size) res[max_size-1] = 0;
     else release( res + len + 1 );
     return res;
 }

 /***********************************************************************
  *		NTDLL_dbg_vprintf
  */
 static int NTDLL_dbg_vprintf( const char *format, va_list args )
 {
     struct debug_info *info = get_info();
     char *p;

     int ret = vsnprintf( info->out_pos, sizeof(info->output) - (info->out_pos - info->output),
                          format, args );

     /* make sure we didn't exceed the buffer length
      * the two checks are due to glibc changes in vsnprintfs return value
      * the buffer size can be exceeded in case of a missing \n in
      * debug output */
     if ((ret == -1) || (ret >= sizeof(info->output) - (info->out_pos - info->output)))
     {
        fprintf( stderr, "wine_dbg_vprintf: debugstr buffer overflow (contents: '%s')\n",
                 info->output);
        info->out_pos = info->output;
        abort();
     }

     p = strrchr( info->out_pos, '\n' );
     if (!p) info->out_pos += ret;
     else
     {
         char *pos = info->output;
         p++;
         write( 2, pos, p - pos );
         /* move beginning of next line to start of buffer */
         while ((*pos = *p++)) pos++;
         info->out_pos = pos;
     }
     return ret;
 }

 /***********************************************************************
  *		NTDLL_dbg_vlog
  */
 static int NTDLL_dbg_vlog( unsigned int cls, const char *channel,
                            const char *function, const char *format, va_list args )
 {
     static const char * const classes[] = { "fixme", "err", "warn", "trace" };
     struct debug_info *info = get_info();
     int ret = 0;

     /* only print header if we are at the beginning of the line */
     if (info->out_pos == info->output || info->out_pos[-1] == '\n')
     {
         if (TRACE_ON(tid))
             ret = wine_dbg_printf( "%04lx:", GetCurrentThreadId() );
         if (cls < sizeof(classes)/sizeof(classes[0]))
             ret += wine_dbg_printf( "%s:%s:%s ", classes[cls], channel + 1, function );
     }
     if (format)
         ret += NTDLL_dbg_vprintf( format, args );
     return ret;
 }

 /***********************************************************************
  *		debug_init
  */
 void debug_init(void)
 {
     extern void __wine_dbg_ntdll_init(void);

     __wine_dbgstr_an    = NTDLL_dbgstr_an;
     __wine_dbgstr_wn    = NTDLL_dbgstr_wn;
     __wine_dbg_vsprintf = NTDLL_dbg_vsprintf;
     __wine_dbg_vprintf  = NTDLL_dbg_vprintf;
     __wine_dbg_vlog     = NTDLL_dbg_vlog;
     __wine_dbg_ntdll_init();  /* hack: register debug channels early */
 }
	/*
	* Debugging functions
	*
	* Copyright 2000 Alexandre Julliard
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library 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
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include "config.h"
	#include "wine/port.h"

	#include <assert.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#ifdef HAVE_UNISTD_H
	# include <unistd.h>
	#endif
	#include <ctype.h>

	#include "wine/debug.h"
	#include "wine/exception.h"
	#include "wine/library.h"
	#include "wine/unicode.h"
	#include "ntstatus.h"
	#include "thread.h"
	#include "winbase.h"
	#include "winnt.h"
	#include "winternl.h"
	#include "excpt.h"
	#include "ntdll_misc.h"

	WINE_DECLARE_DEBUG_CHANNEL(tid);

	/* ---------------------------------------------------------------------- */

	/* filter for page-fault exceptions */
	static WINE_EXCEPTION_FILTER(page_fault)
	{
	if (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
	return EXCEPTION_EXECUTE_HANDLER;
	return EXCEPTION_CONTINUE_SEARCH;
	}

	/* get the debug info pointer for the current thread */
	static inline struct debug_info *get_info(void)
	{
	return NtCurrentTeb()->debug_info;
	}

	/* allocate some tmp space for a string */
	static void *gimme1(int n)
	{
	struct debug_info *info = get_info();
	char *res = info->str_pos;

	if (res + n >= &info->strings[sizeof(info->strings)]) res = info->strings;
	info->str_pos = res + n;
	return res;
	}

	/* release extra space that we requested in gimme1() */
	static inline void release( void *ptr )
	{
	struct debug_info *info = NtCurrentTeb()->debug_info;
	info->str_pos = ptr;
	}

	/* put an ASCII string into the debug buffer */
	inline static char put_string_a( const char src, int n )
	{
	static const char hex[16] = "0123456789abcdef";
	char dst, res;
	size_t size;

	if (n == -1) n = strlen(src);
	if (n < 0) n = 0;
	size = 10 + min( 300, n * 4 );
	dst = res = gimme1( size );
	*dst++ = '"';
	while (n-- > 0 && dst <= res + size - 9)
	{
	unsigned char c = *src++;
	switch (c)
	{
	case '\n': dst++ = '\\'; dst++ = 'n'; break;
	case '\r': dst++ = '\\'; dst++ = 'r'; break;
	case '\t': dst++ = '\\'; dst++ = 't'; break;
	case '"': dst++ = '\\'; dst++ = '"'; break;
	case '\\': dst++ = '\\'; dst++ = '\\'; break;
	default:
	if (c >= ' ' && c <= 126)
	*dst++ = c;
	else
	{
	*dst++ = '\\';
	*dst++ = 'x';
	*dst++ = hex[(c >> 4) & 0x0f];
	*dst++ = hex[c & 0x0f];
	}
	}
	}
	*dst++ = '"';
	if (*src)
	{
	*dst++ = '.';
	*dst++ = '.';
	*dst++ = '.';
	}
	*dst++ = '\0';
	release( dst );
	return res;
	}

	/* put a Unicode string into the debug buffer */
	inline static char put_string_w( const WCHAR src, int n )
	{
	char dst, res;
	size_t size;

	if (n == -1) n = strlenW(src);
	if (n < 0) n = 0;
	size = 12 + min( 300, n * 5 );
	dst = res = gimme1( size );
	*dst++ = 'L';
	*dst++ = '"';
	while (n-- > 0 && dst <= res + size - 10)
	{
	WCHAR c = *src++;
	switch (c)
	{
	case '\n': dst++ = '\\'; dst++ = 'n'; break;
	case '\r': dst++ = '\\'; dst++ = 'r'; break;
	case '\t': dst++ = '\\'; dst++ = 't'; break;
	case '"': dst++ = '\\'; dst++ = '"'; break;
	case '\\': dst++ = '\\'; dst++ = '\\'; break;
	default:
	if (c >= ' ' && c <= 126)
	*dst++ = c;
	else
	{
	*dst++ = '\\';
	sprintf(dst,"%04x",c);
	dst+=4;
	}
	}
	}
	*dst++ = '"';
	if (*src)
	{
	*dst++ = '.';
	*dst++ = '.';
	*dst++ = '.';
	}
	*dst++ = '\0';
	release( dst );
	return res;
	}

	/***********************************************************************
	* NTDLL_dbgstr_an
	*/
	static const char NTDLL_dbgstr_an( const char src, int n )
	{
	char res, old_pos;
	struct debug_info *info = get_info();

	if (!HIWORD(src))
	{
	if (!src) return "(null)";
	res = gimme1(6);
	sprintf(res, "#%04x", LOWORD(src) );
	return res;
	}
	/* save current position to restore it on exception */
	old_pos = info->str_pos;
	__TRY
	{
	res = put_string_a( src, n );
	}
	__EXCEPT(page_fault)
	{
	release( old_pos );
	return "(invalid)";
	}
	__ENDTRY
	return res;
	}

	/***********************************************************************
	* NTDLL_dbgstr_wn
	*/
	static const char NTDLL_dbgstr_wn( const WCHAR src, int n )
	{
	char res, old_pos;
	struct debug_info *info = get_info();

	if (!HIWORD(src))
	{
	if (!src) return "(null)";
	res = gimme1(6);
	sprintf(res, "#%04x", LOWORD(src) );
	return res;
	}

	/* save current position to restore it on exception */
	old_pos = info->str_pos;
	__TRY
	{
	res = put_string_w( src, n );
	}
	__EXCEPT(page_fault)
	{
	release( old_pos );
	return "(invalid)";
	}
	__ENDTRY
	return res;
	}

	/***********************************************************************
	* NTDLL_dbg_vsprintf
	*/
	static const char NTDLL_dbg_vsprintf( const char format, va_list args )
	{
	static const int max_size = 200;

	char *res = gimme1( max_size );
	int len = vsnprintf( res, max_size, format, args );
	if (len == -1 \|\| len >= max_size) res[max_size-1] = 0;
	else release( res + len + 1 );
	return res;
	}

	/***********************************************************************
	* NTDLL_dbg_vprintf
	*/
	static int NTDLL_dbg_vprintf( const char *format, va_list args )
	{
	struct debug_info *info = get_info();
	char *p;

	int ret = vsnprintf( info->out_pos, sizeof(info->output) - (info->out_pos - info->output),
	format, args );

	/* make sure we didn't exceed the buffer length
	* the two checks are due to glibc changes in vsnprintfs return value
	* the buffer size can be exceeded in case of a missing \n in
	* debug output */
	if ((ret == -1) \|\| (ret >= sizeof(info->output) - (info->out_pos - info->output)))
	{
	fprintf( stderr, "wine_dbg_vprintf: debugstr buffer overflow (contents: '%s')\n",
	info->output);
	info->out_pos = info->output;
	abort();
	}

	p = strrchr( info->out_pos, '\n' );
	if (!p) info->out_pos += ret;
	else
	{
	char *pos = info->output;
	p++;
	write( 2, pos, p - pos );
	/* move beginning of next line to start of buffer */
	while ((pos = p++)) pos++;
	info->out_pos = pos;
	}
	return ret;
	}

	/***********************************************************************
	* NTDLL_dbg_vlog
	*/
	static int NTDLL_dbg_vlog( unsigned int cls, const char *channel,
	const char function, const char format, va_list args )
	{
	static const char * const classes[] = { "fixme", "err", "warn", "trace" };
	struct debug_info *info = get_info();
	int ret = 0;

	/* only print header if we are at the beginning of the line */
	if (info->out_pos == info->output \|\| info->out_pos[-1] == '\n')
	{
	if (TRACE_ON(tid))
	ret = wine_dbg_printf( "%04lx:", GetCurrentThreadId() );
	if (cls < sizeof(classes)/sizeof(classes[0]))
	ret += wine_dbg_printf( "%s:%s:%s ", classes[cls], channel + 1, function );
	}
	if (format)
	ret += NTDLL_dbg_vprintf( format, args );
	return ret;
	}

	/***********************************************************************
	* debug_init
	*/
	void debug_init(void)
	{
	extern void __wine_dbg_ntdll_init(void);

	__wine_dbgstr_an = NTDLL_dbgstr_an;
	__wine_dbgstr_wn = NTDLL_dbgstr_wn;
	__wine_dbg_vsprintf = NTDLL_dbg_vsprintf;
	__wine_dbg_vprintf = NTDLL_dbg_vprintf;
	__wine_dbg_vlog = NTDLL_dbg_vlog;
	__wine_dbg_ntdll_init(); /* hack: register debug channels early */
	}