/* -*- Mode: C; tab-width: 4 -*- * * Copyright (c) 1997-2004 Apple Computer, Inc. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. To Do: - Use StackWalk on Windows to optionally print stack frames. */ #if 0 #pragma mark == Includes == #endif //=========================================================================================================================== // Includes //=========================================================================================================================== #if( !KERNEL ) #include #include #include #endif #include "CommonServices.h" #include "DebugServices.h" #if( DEBUG ) #if( TARGET_OS_VXWORKS ) #include "intLib.h" #endif #if( TARGET_OS_WIN32 ) #include #if( !TARGET_OS_WINDOWS_CE ) #include #include #endif #endif #if( DEBUG_IDEBUG_ENABLED && TARGET_API_MAC_OSX_KERNEL ) #include #endif // If MDNS_DEBUGMSGS is defined (even if defined 0), it is aware of mDNS and it is probably safe to include mDNSEmbeddedAPI.h. #if( defined( MDNS_DEBUGMSGS ) ) #include "mDNSEmbeddedAPI.h" #endif #if 0 #pragma mark == Macros == #endif //=========================================================================================================================== // Macros //=========================================================================================================================== #define DebugIsPrint( C ) ( ( ( C ) >= 0x20 ) && ( ( C ) <= 0x7E ) ) #if 0 #pragma mark == Prototypes == #endif //=========================================================================================================================== // Prototypes //=========================================================================================================================== static OSStatus DebugPrint( DebugLevel inLevel, char *inData, size_t inSize ); // fprintf #if( DEBUG_FPRINTF_ENABLED ) static OSStatus DebugFPrintFInit( DebugOutputTypeFlags inFlags, const char *inFilename ); static void DebugFPrintFPrint( char *inData, size_t inSize ); #endif // iDebug (Mac OS X user and kernel) #if( DEBUG_IDEBUG_ENABLED ) static OSStatus DebugiDebugInit( void ); static void DebugiDebugPrint( char *inData, size_t inSize ); #endif // kprintf (Mac OS X Kernel) #if( DEBUG_KPRINTF_ENABLED ) static void DebugKPrintFPrint( char *inData, size_t inSize ); #endif // Mac OS X IOLog (Mac OS X Kernel) #if( DEBUG_MAC_OS_X_IOLOG_ENABLED ) static void DebugMacOSXIOLogPrint( char *inData, size_t inSize ); #endif // Mac OS X Log #if( TARGET_OS_MAC ) static OSStatus DebugMacOSXLogInit( void ); static void DebugMacOSXLogPrint( char *inData, size_t inSize ); #endif // Windows Debugger #if( TARGET_OS_WIN32 ) static void DebugWindowsDebuggerPrint( char *inData, size_t inSize ); #endif // Windows Event Log #if( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) static OSStatus DebugWindowsEventLogInit( const char *inName, HMODULE inModule ); static void DebugWindowsEventLogPrint( DebugLevel inLevel, char *inData, size_t inSize ); #endif // DebugLib support #if( DEBUG_CORE_SERVICE_ASSERTS_ENABLED ) static pascal void DebugAssertOutputHandler( OSType inComponentSignature, UInt32 inOptions, const char * inAssertionString, const char * inExceptionString, const char * inErrorString, const char * inFileName, long inLineNumber, void * inValue, ConstStr255Param inOutputMsg ); #endif // Utilities static char * DebugNumVersionToString( uint32_t inVersion, char *inString ); #if( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) static void DebugWinEnableConsole( void ); #endif #if( TARGET_OS_WIN32 ) static TCHAR * DebugWinCharToTCharString( const char * inCharString, size_t inCharCount, TCHAR * outTCharString, size_t inTCharCountMax, size_t * outTCharCount ); #endif #if 0 #pragma mark == Globals == #endif //=========================================================================================================================== // Private Globals //=========================================================================================================================== #if( TARGET_OS_VXWORKS ) // TCP States for inetstatShow. extern char ** pTcpstates; // defined in tcpLib.c const char * kDebugTCPStates[] = { "(0) TCPS_CLOSED", "(1) TCPS_LISTEN", "(2) TCPS_SYN_SENT", "(3) TCPS_SYN_RECEIVED", "(4) TCPS_ESTABLISHED", "(5) TCPS_CLOSE_WAIT", "(6) TCPS_FIN_WAIT_1", "(7) TCPS_CLOSING", "(8) TCPS_LAST_ACK", "(9) TCPS_FIN_WAIT_2", "(10) TCPS_TIME_WAIT", }; #endif // General static bool gDebugInitialized = false; static DebugOutputType gDebugOutputType = kDebugOutputTypeNone; static DebugLevel gDebugPrintLevelMin = kDebugLevelInfo; static DebugLevel gDebugPrintLevelMax = kDebugLevelMax; static DebugLevel gDebugBreakLevel = kDebugLevelAssert; #if( DEBUG_CORE_SERVICE_ASSERTS_ENABLED ) static DebugAssertOutputHandlerUPP gDebugAssertOutputHandlerUPP = NULL; #endif // Custom static DebugOutputFunctionPtr gDebugCustomOutputFunction = NULL; static void * gDebugCustomOutputContext = NULL; // fprintf #if( DEBUG_FPRINTF_ENABLED ) static FILE * gDebugFPrintFFile = NULL; #endif // MacOSXLog #if( TARGET_OS_MAC ) typedef int ( *DebugMacOSXLogFunctionPtr )( const char *inFormat, ... ); static DebugMacOSXLogFunctionPtr gDebugMacOSXLogFunction = NULL; #endif // WindowsEventLog #if( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) static HANDLE gDebugWindowsEventLogEventSource = NULL; #endif #if 0 #pragma mark - #pragma mark == General == #endif //=========================================================================================================================== // DebugInitialize //=========================================================================================================================== DEBUG_EXPORT OSStatus DebugInitialize( DebugOutputType inType, ... ) { OSStatus err; DebugOutputType type; va_list args; va_start( args, inType ); #if( TARGET_OS_VXWORKS ) // Set up the TCP state strings if they are not already set up by VxWorks (normally not set up for some reason). if( !pTcpstates ) { pTcpstates = (char **) kDebugTCPStates; } #endif // Set up DebugLib stuff (if building with Debugging.h). #if( DEBUG_CORE_SERVICE_ASSERTS_ENABLED ) if( !gDebugAssertOutputHandlerUPP ) { gDebugAssertOutputHandlerUPP = NewDebugAssertOutputHandlerUPP( DebugAssertOutputHandler ); check( gDebugAssertOutputHandlerUPP ); if( gDebugAssertOutputHandlerUPP ) { InstallDebugAssertOutputHandler( gDebugAssertOutputHandlerUPP ); } } #endif // Pre-process meta-output kind to pick an appropriate output kind for the platform. type = inType; if( type == kDebugOutputTypeMetaConsole ) { #if( TARGET_OS_MAC ) type = kDebugOutputTypeMacOSXLog; #elif( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) #if( DEBUG_FPRINTF_ENABLED ) type = kDebugOutputTypeFPrintF; #else type = kDebugOutputTypeWindowsDebugger; #endif #elif( TARGET_API_MAC_OSX_KERNEL ) #if( DEBUG_MAC_OS_X_IOLOG_ENABLED ) type = kDebugOutputTypeMacOSXIOLog; #elif( DEBUG_IDEBUG_ENABLED ) type = kDebugOutputTypeiDebug; #elif( DEBUG_KPRINTF_ENABLED ) type = kDebugOutputTypeKPrintF; #endif #elif( TARGET_OS_VXWORKS ) #if( DEBUG_FPRINTF_ENABLED ) type = kDebugOutputTypeFPrintF; #else #error target is VxWorks, but fprintf output is disabled #endif #else #if( DEBUG_FPRINTF_ENABLED ) type = kDebugOutputTypeFPrintF; #endif #endif } // Process output kind. gDebugOutputType = type; switch( type ) { case kDebugOutputTypeNone: err = kNoErr; break; case kDebugOutputTypeCustom: gDebugCustomOutputFunction = va_arg( args, DebugOutputFunctionPtr ); gDebugCustomOutputContext = va_arg( args, void * ); err = kNoErr; break; #if( DEBUG_FPRINTF_ENABLED ) case kDebugOutputTypeFPrintF: if( inType == kDebugOutputTypeMetaConsole ) { err = DebugFPrintFInit( kDebugOutputTypeFlagsStdErr, NULL ); } else { DebugOutputTypeFlags flags; const char * filename; flags = (DebugOutputTypeFlags) va_arg( args, unsigned int ); if( ( flags & kDebugOutputTypeFlagsTypeMask ) == kDebugOutputTypeFlagsFile ) { filename = va_arg( args, const char * ); } else { filename = NULL; } err = DebugFPrintFInit( flags, filename ); } break; #endif #if( DEBUG_IDEBUG_ENABLED ) case kDebugOutputTypeiDebug: err = DebugiDebugInit(); break; #endif #if( DEBUG_KPRINTF_ENABLED ) case kDebugOutputTypeKPrintF: err = kNoErr; break; #endif #if( DEBUG_MAC_OS_X_IOLOG_ENABLED ) case kDebugOutputTypeMacOSXIOLog: err = kNoErr; break; #endif #if( TARGET_OS_MAC ) case kDebugOutputTypeMacOSXLog: err = DebugMacOSXLogInit(); break; #endif #if( TARGET_OS_WIN32 ) case kDebugOutputTypeWindowsDebugger: err = kNoErr; break; #endif #if( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) case kDebugOutputTypeWindowsEventLog: { const char * name; HMODULE module; name = va_arg( args, const char * ); module = va_arg( args, HMODULE ); err = DebugWindowsEventLogInit( name, module ); } break; #endif default: err = kParamErr; goto exit; } gDebugInitialized = true; exit: va_end( args ); return( err ); } //=========================================================================================================================== // DebugFinalize //=========================================================================================================================== DEBUG_EXPORT void DebugFinalize( void ) { #if( DEBUG_CORE_SERVICE_ASSERTS_ENABLED ) check( gDebugAssertOutputHandlerUPP ); if( gDebugAssertOutputHandlerUPP ) { InstallDebugAssertOutputHandler( NULL ); DisposeDebugAssertOutputHandlerUPP( gDebugAssertOutputHandlerUPP ); gDebugAssertOutputHandlerUPP = NULL; } #endif } //=========================================================================================================================== // DebugGetProperty //=========================================================================================================================== DEBUG_EXPORT OSStatus DebugGetProperty( DebugPropertyTag inTag, ... ) { OSStatus err; va_list args; DebugLevel * level; va_start( args, inTag ); switch( inTag ) { case kDebugPropertyTagPrintLevelMin: level = va_arg( args, DebugLevel * ); *level = gDebugPrintLevelMin; err = kNoErr; break; case kDebugPropertyTagPrintLevelMax: level = va_arg( args, DebugLevel * ); *level = gDebugPrintLevelMax; err = kNoErr; break; case kDebugPropertyTagBreakLevel: level = va_arg( args, DebugLevel * ); *level = gDebugBreakLevel; err = kNoErr; break; default: err = kUnsupportedErr; break; } va_end( args ); return( err ); } //=========================================================================================================================== // DebugSetProperty //=========================================================================================================================== DEBUG_EXPORT OSStatus DebugSetProperty( DebugPropertyTag inTag, ... ) { OSStatus err; va_list args; DebugLevel level; va_start( args, inTag ); switch( inTag ) { case kDebugPropertyTagPrintLevelMin: level = va_arg( args, DebugLevel ); gDebugPrintLevelMin = level; err = kNoErr; break; case kDebugPropertyTagPrintLevelMax: level = va_arg( args, DebugLevel ); gDebugPrintLevelMax = level; err = kNoErr; break; case kDebugPropertyTagBreakLevel: level = va_arg( args, DebugLevel ); gDebugBreakLevel = level; err = kNoErr; break; default: err = kUnsupportedErr; break; } va_end( args ); return( err ); } #if 0 #pragma mark - #pragma mark == Output == #endif //=========================================================================================================================== // DebugPrintF //=========================================================================================================================== DEBUG_EXPORT size_t DebugPrintF( DebugLevel inLevel, const char *inFormat, ... ) { va_list args; size_t n; // Skip if the level is not in the enabled range.. if( ( inLevel < gDebugPrintLevelMin ) || ( inLevel > gDebugPrintLevelMax ) ) { n = 0; goto exit; } va_start( args, inFormat ); n = DebugPrintFVAList( inLevel, inFormat, args ); va_end( args ); exit: return( n ); } //=========================================================================================================================== // DebugPrintFVAList //=========================================================================================================================== DEBUG_EXPORT size_t DebugPrintFVAList( DebugLevel inLevel, const char *inFormat, va_list inArgs ) { size_t n; char buffer[ 512 ]; // Skip if the level is not in the enabled range.. if( ( inLevel < gDebugPrintLevelMin ) || ( inLevel > gDebugPrintLevelMax ) ) { n = 0; goto exit; } n = DebugSNPrintFVAList( buffer, sizeof( buffer ), inFormat, inArgs ); DebugPrint( inLevel, buffer, (size_t) n ); exit: return( n ); } //=========================================================================================================================== // DebugPrint //=========================================================================================================================== static OSStatus DebugPrint( DebugLevel inLevel, char *inData, size_t inSize ) { OSStatus err; // Skip if the level is not in the enabled range.. if( ( inLevel < gDebugPrintLevelMin ) || ( inLevel > gDebugPrintLevelMax ) ) { err = kRangeErr; goto exit; } // Printing is not safe at interrupt time so check for this and warn with an interrupt safe mechanism (if available). if( DebugTaskLevel() & kDebugInterruptLevelMask ) { #if( TARGET_OS_VXWORKS ) logMsg( "\ncannot print at interrupt time\n\n", 1, 2, 3, 4, 5, 6 ); #endif err = kExecutionStateErr; goto exit; } // Initialize the debugging library if it hasn't already been initialized (allows for zero-config usage). if( !gDebugInitialized ) { debug_initialize( kDebugOutputTypeMetaConsole ); } // Print based on the current output type. switch( gDebugOutputType ) { case kDebugOutputTypeNone: break; case kDebugOutputTypeCustom: if( gDebugCustomOutputFunction ) { gDebugCustomOutputFunction( inData, inSize, gDebugCustomOutputContext ); } break; #if( DEBUG_FPRINTF_ENABLED ) case kDebugOutputTypeFPrintF: DebugFPrintFPrint( inData, inSize ); break; #endif #if( DEBUG_IDEBUG_ENABLED ) case kDebugOutputTypeiDebug: DebugiDebugPrint( inData, inSize ); break; #endif #if( DEBUG_KPRINTF_ENABLED ) case kDebugOutputTypeKPrintF: DebugKPrintFPrint( inData, inSize ); break; #endif #if( DEBUG_MAC_OS_X_IOLOG_ENABLED ) case kDebugOutputTypeMacOSXIOLog: DebugMacOSXIOLogPrint( inData, inSize ); break; #endif #if( TARGET_OS_MAC ) case kDebugOutputTypeMacOSXLog: DebugMacOSXLogPrint( inData, inSize ); break; #endif #if( TARGET_OS_WIN32 ) case kDebugOutputTypeWindowsDebugger: DebugWindowsDebuggerPrint( inData, inSize ); break; #endif #if( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) case kDebugOutputTypeWindowsEventLog: DebugWindowsEventLogPrint( inLevel, inData, inSize ); break; #endif default: break; } err = kNoErr; exit: return( err ); } //=========================================================================================================================== // DebugPrintAssert // // Warning: This routine relies on several of the strings being string constants that will exist forever because the // underlying logMsg API that does the printing is asynchronous so it cannot use temporary/stack-based // pointer variables (e.g. local strings). The debug macros that invoke this function only use constant // constant strings, but if this function is invoked directly from other places, it must use constant strings. //=========================================================================================================================== DEBUG_EXPORT void DebugPrintAssert( int_least32_t inErrorCode, const char * inAssertString, const char * inMessage, const char * inFilename, int_least32_t inLineNumber, const char * inFunction ) { // Skip if the level is not in the enabled range.. if( ( kDebugLevelAssert < gDebugPrintLevelMin ) || ( kDebugLevelAssert > gDebugPrintLevelMax ) ) { return; } if( inErrorCode != 0 ) { DebugPrintF( kDebugLevelAssert, "\n" "[ASSERT] error: %ld (%m)\n" "[ASSERT] where: \"%s\", line %ld, \"%s\"\n" "\n", inErrorCode, inErrorCode, inFilename ? inFilename : "", inLineNumber, inFunction ? inFunction : "" ); } else { DebugPrintF( kDebugLevelAssert, "\n" "[ASSERT] assert: \"%s\" %s\n" "[ASSERT] where: \"%s\", line %ld, \"%s\"\n" "\n", inAssertString ? inAssertString : "", inMessage ? inMessage : "", inFilename ? inFilename : "", inLineNumber, inFunction ? inFunction : "" ); } // Break into the debugger if enabled. #if( TARGET_OS_WIN32 ) if( gDebugBreakLevel <= kDebugLevelAssert ) { if( IsDebuggerPresent() ) { DebugBreak(); } } #endif } #if 0 #pragma mark - #endif #if( DEBUG_FPRINTF_ENABLED ) //=========================================================================================================================== // DebugFPrintFInit //=========================================================================================================================== static OSStatus DebugFPrintFInit( DebugOutputTypeFlags inFlags, const char *inFilename ) { OSStatus err; DebugOutputTypeFlags typeFlags; typeFlags = inFlags & kDebugOutputTypeFlagsTypeMask; if( typeFlags == kDebugOutputTypeFlagsStdOut ) { #if( TARGET_OS_WIN32 ) DebugWinEnableConsole(); #endif gDebugFPrintFFile = stdout; } else if( typeFlags == kDebugOutputTypeFlagsStdErr ) { #if( TARGET_OS_WIN32 ) DebugWinEnableConsole(); #endif gDebugFPrintFFile = stdout; } else if( typeFlags == kDebugOutputTypeFlagsFile ) { require_action_quiet( inFilename && ( *inFilename != '\0' ), exit, err = kOpenErr ); gDebugFPrintFFile = fopen( inFilename, "a" ); require_action_quiet( gDebugFPrintFFile, exit, err = kOpenErr ); } else { err = kParamErr; goto exit; } err = kNoErr; exit: return( err ); } //=========================================================================================================================== // DebugFPrintFPrint //=========================================================================================================================== static void DebugFPrintFPrint( char *inData, size_t inSize ) { char * p; char * q; // Convert \r to \n. fprintf will interpret \n and convert to whatever is appropriate for the platform. p = inData; q = p + inSize; while( p < q ) { if( *p == '\r' ) { *p = '\n'; } ++p; } // Write the data and flush. if( gDebugFPrintFFile ) { fprintf( gDebugFPrintFFile, "%.*s", (int) inSize, inData ); fflush( gDebugFPrintFFile ); } } #endif // DEBUG_FPRINTF_ENABLED #if( DEBUG_IDEBUG_ENABLED ) //=========================================================================================================================== // DebugiDebugInit //=========================================================================================================================== static OSStatus DebugiDebugInit( void ) { OSStatus err; #if( TARGET_API_MAC_OSX_KERNEL ) extern uint32_t * _giDebugReserved1; // Emulate the iDebugSetOutputType macro in iDebugServices.h. // Note: This is not thread safe, but neither is iDebugServices.h nor iDebugKext. if( !_giDebugReserved1 ) { _giDebugReserved1 = (uint32_t *) IOMalloc( sizeof( uint32_t ) ); require_action_quiet( _giDebugReserved1, exit, err = kNoMemoryErr ); } *_giDebugReserved1 = 0x00010000U; err = kNoErr; exit: #else __private_extern__ void iDebugSetOutputTypeInternal( uint32_t inType ); iDebugSetOutputTypeInternal( 0x00010000U ); err = kNoErr; #endif return( err ); } //=========================================================================================================================== // DebugiDebugPrint //=========================================================================================================================== static void DebugiDebugPrint( char *inData, size_t inSize ) { #if( TARGET_API_MAC_OSX_KERNEL ) // Locally declared here so we do not need to include iDebugKext.h. // Note: IOKit uses a global namespace for all code and only a partial link occurs at build time. When the // KEXT is loaded, the runtime linker will link in this extern'd symbol (assuming iDebug is present). // _giDebugLogInternal is actually part of IOKit proper so this should link even if iDebug is not present. typedef void ( *iDebugLogFunctionPtr )( uint32_t inLevel, uint32_t inTag, const char *inFormat, ... ); extern iDebugLogFunctionPtr _giDebugLogInternal; if( _giDebugLogInternal ) { _giDebugLogInternal( 0, 0, "%.*s", (int) inSize, inData ); } #else __private_extern__ void iDebugLogInternal( uint32_t inLevel, uint32_t inTag, const char *inFormat, ... ); iDebugLogInternal( 0, 0, "%.*s", (int) inSize, inData ); #endif } #endif #if( DEBUG_KPRINTF_ENABLED ) //=========================================================================================================================== // DebugKPrintFPrint //=========================================================================================================================== static void DebugKPrintFPrint( char *inData, size_t inSize ) { extern void kprintf( const char *inFormat, ... ); kprintf( "%.*s", (int) inSize, inData ); } #endif #if( DEBUG_MAC_OS_X_IOLOG_ENABLED ) //=========================================================================================================================== // DebugMacOSXIOLogPrint //=========================================================================================================================== static void DebugMacOSXIOLogPrint( char *inData, size_t inSize ) { extern void IOLog( const char *inFormat, ... ); IOLog( "%.*s", (int) inSize, inData ); } #endif #if( TARGET_OS_MAC ) //=========================================================================================================================== // DebugMacOSXLogInit //=========================================================================================================================== static OSStatus DebugMacOSXLogInit( void ) { OSStatus err; CFStringRef path; CFURLRef url; CFBundleRef bundle; CFStringRef functionName; void * functionPtr; bundle = NULL; // Create a bundle reference for System.framework. path = CFSTR( "/System/Library/Frameworks/System.framework" ); url = CFURLCreateWithFileSystemPath( NULL, path, kCFURLPOSIXPathStyle, true ); require_action_quiet( url, exit, err = memFullErr ); bundle = CFBundleCreate( NULL, url ); CFRelease( url ); require_action_quiet( bundle, exit, err = memFullErr ); // Get a ptr to the system's "printf" function from System.framework. functionName = CFSTR( "printf" ); functionPtr = CFBundleGetFunctionPointerForName( bundle, functionName ); require_action_quiet( functionPtr, exit, err = memFullErr ); // Success! Note: The bundle cannot be released because it would invalidate the function ptr. gDebugMacOSXLogFunction = (DebugMacOSXLogFunctionPtr) functionPtr; bundle = NULL; err = noErr; exit: if( bundle ) { CFRelease( bundle ); } return( err ); } //=========================================================================================================================== // DebugMacOSXLogPrint //=========================================================================================================================== static void DebugMacOSXLogPrint( char *inData, size_t inSize ) { if( gDebugMacOSXLogFunction ) { gDebugMacOSXLogFunction( "%.*s", (int) inSize, inData ); } } #endif #if( TARGET_OS_WIN32 ) //=========================================================================================================================== // DebugWindowsDebuggerPrint //=========================================================================================================================== void DebugWindowsDebuggerPrint( char *inData, size_t inSize ) { TCHAR buffer[ 512 ]; const char * src; const char * end; TCHAR * dst; char c; // Copy locally and null terminate the string. This also converts from char to TCHAR in case we are // building with UNICODE enabled since the input is always char. Also convert \r to \n in the process. src = inData; if( inSize >= sizeof_array( buffer ) ) { inSize = sizeof_array( buffer ) - 1; } end = src + inSize; dst = buffer; while( src < end ) { c = *src++; if( c == '\r' ) { c = '\n'; } *dst++ = (TCHAR) c; } *dst = 0; // Print out the string to the debugger. OutputDebugString( buffer ); } #endif #if( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) //=========================================================================================================================== // DebugWindowsEventLogInit //=========================================================================================================================== static OSStatus DebugWindowsEventLogInit( const char *inName, HMODULE inModule ) { OSStatus err; HKEY key; TCHAR name[ 128 ]; const char * src; TCHAR path[ MAX_PATH ]; size_t size; DWORD typesSupported; DWORD n; key = NULL; // Use a default name if needed then convert the name to TCHARs so it works on ANSI or Unicode builds. if( !inName || ( *inName == '\0' ) ) { inName = "DefaultApp"; } DebugWinCharToTCharString( inName, kSizeCString, name, sizeof( name ), NULL ); // Build the path string using the fixed registry path and app name. src = "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\"; DebugWinCharToTCharString( src, kSizeCString, path, sizeof_array( path ), &size ); DebugWinCharToTCharString( inName, kSizeCString, path + size, sizeof_array( path ) - size, NULL ); // Add/Open the source name as a sub-key under the Application key in the EventLog registry key. err = RegCreateKeyEx( HKEY_LOCAL_MACHINE, path, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, NULL ); require_noerr_quiet( err, exit ); // Set the path in the EventMessageFile subkey. Add 1 to the TCHAR count to include the null terminator. n = GetModuleFileName( inModule, path, sizeof_array( path ) ); err = translate_errno( n > 0, (OSStatus) GetLastError(), kParamErr ); require_noerr_quiet( err, exit ); n += 1; n *= sizeof( TCHAR ); err = RegSetValueEx( key, TEXT( "EventMessageFile" ), 0, REG_EXPAND_SZ, (const LPBYTE) path, n ); require_noerr_quiet( err, exit ); // Set the supported event types in the TypesSupported subkey. typesSupported = EVENTLOG_SUCCESS | EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE | EVENTLOG_AUDIT_SUCCESS | EVENTLOG_AUDIT_FAILURE; err = RegSetValueEx( key, TEXT( "TypesSupported" ), 0, REG_DWORD, (const LPBYTE) &typesSupported, sizeof( DWORD ) ); require_noerr_quiet( err, exit ); // Set up the event source. gDebugWindowsEventLogEventSource = RegisterEventSource( NULL, name ); err = translate_errno( gDebugWindowsEventLogEventSource, (OSStatus) GetLastError(), kParamErr ); require_noerr_quiet( err, exit ); exit: if( key ) { RegCloseKey( key ); } return( err ); } //=========================================================================================================================== // DebugWindowsEventLogPrint //=========================================================================================================================== static void DebugWindowsEventLogPrint( DebugLevel inLevel, char *inData, size_t inSize ) { WORD type; TCHAR buffer[ 512 ]; const char * src; const char * end; TCHAR * dst; char c; const TCHAR * array[ 1 ]; // Map the debug level to a Windows EventLog type. if( inLevel <= kDebugLevelNotice ) { type = EVENTLOG_INFORMATION_TYPE; } else if( inLevel <= kDebugLevelWarning ) { type = EVENTLOG_WARNING_TYPE; } else { type = EVENTLOG_ERROR_TYPE; } // Copy locally and null terminate the string. This also converts from char to TCHAR in case we are // building with UNICODE enabled since the input is always char. Also convert \r to \n in the process. src = inData; if( inSize >= sizeof_array( buffer ) ) { inSize = sizeof_array( buffer ) - 1; } end = src + inSize; dst = buffer; while( src < end ) { c = *src++; if( c == '\r' ) { c = '\n'; } *dst++ = (TCHAR) c; } *dst = 0; // Add the the string to the event log. array[ 0 ] = buffer; if( gDebugWindowsEventLogEventSource ) { ReportEvent( gDebugWindowsEventLogEventSource, type, 0, 0x20000001L, NULL, 1, 0, array, NULL ); } } #endif // TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE #if( DEBUG_CORE_SERVICE_ASSERTS_ENABLED ) //=========================================================================================================================== // DebugAssertOutputHandler //=========================================================================================================================== static pascal void DebugAssertOutputHandler( OSType inComponentSignature, UInt32 inOptions, const char * inAssertString, const char * inExceptionString, const char * inErrorString, const char * inFileName, long inLineNumber, void * inValue, ConstStr255Param inOutputMsg ) { DEBUG_UNUSED( inComponentSignature ); DEBUG_UNUSED( inOptions ); DEBUG_UNUSED( inExceptionString ); DEBUG_UNUSED( inValue ); DEBUG_UNUSED( inOutputMsg ); DebugPrintAssert( 0, inAssertString, inErrorString, inFileName, (int_least32_t) inLineNumber, "" ); } #endif #if 0 #pragma mark - #pragma mark == Utilities == #endif //=========================================================================================================================== // DebugSNPrintF // // Stolen from mDNS.c's mDNS_snprintf/mDNS_vsnprintf with the following changes: // // Changed names to avoid name collisions with the mDNS versions. // Changed types to standard C types since mDNSEmbeddedAPI.h may not be available. // Conditionalized mDNS stuff so it can be used with or with mDNSEmbeddedAPI.h. // Added 64-bit support for %d (%lld), %i (%lli), %u (%llu), %o (%llo), %x (%llx), and %b (%llb). // Added %@ - Cocoa/CoreFoundation object. Param is the object. Strings are used directly. Others use CFCopyDescription. // Added %.8a - FIbre Channel address. Arg=ptr to address. // Added %##a - IPv4 (if AF_INET defined) or IPv6 (if AF_INET6 defined) sockaddr. Arg=ptr to sockaddr. // Added %b - Binary representation of integer (e.g. 01101011). Modifiers and arg=the same as %d, %x, etc. // Added %C - Mac-style FourCharCode (e.g. 'APPL'). Arg=32-bit value to print as a Mac-style FourCharCode. // Added %H - Hex Dump (e.g. "\x6b\xa7" -> "6B A7"). 1st arg=ptr, 2nd arg=size, 3rd arg=max size. // Added %#H - Hex Dump & ASCII (e.g. "\x41\x62" -> "6B A7 'Ab'"). 1st arg=ptr, 2nd arg=size, 3rd arg=max size. // Added %m - Error Message (e.g. 0 -> "kNoErr"). Modifiers and error code args are the same as %d, %x, etc. // Added %S - UTF-16 string. Host order if no BOM. Precision is UTF-16 char count. BOM counts in any precision. Arg=ptr. // Added %#S - Big Endian UTF-16 string (unless BOM overrides). Otherwise the same as %S. // Added %##S - Little Endian UTF-16 string (unless BOM overrides). Otherwise the same as %S. // Added %U - Universally Unique Identifier (UUID) (e.g. 6ba7b810-9dad-11d1-80b4-00c04fd430c8). Arg=ptr to 16-byte UUID. //=========================================================================================================================== DEBUG_EXPORT size_t DebugSNPrintF(char *sbuffer, size_t buflen, const char *fmt, ...) { size_t length; va_list ptr; va_start(ptr,fmt); length = DebugSNPrintFVAList(sbuffer, buflen, fmt, ptr); va_end(ptr); return(length); } //=========================================================================================================================== // DebugSNPrintFVAList - va_list version of DebugSNPrintF. See DebugSNPrintF for more info. //=========================================================================================================================== DEBUG_EXPORT size_t DebugSNPrintFVAList(char *sbuffer, size_t buflen, const char *fmt, va_list arg) { static const struct DebugSNPrintF_format { unsigned leftJustify : 1; unsigned forceSign : 1; unsigned zeroPad : 1; unsigned havePrecision : 1; unsigned hSize : 1; char lSize; char altForm; char sign; // +, - or space unsigned int fieldWidth; unsigned int precision; } DebugSNPrintF_format_default = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; size_t nwritten = 0; int c; if (buflen == 0) return(0); buflen--; // Pre-reserve one space in the buffer for the terminating nul if (buflen == 0) goto exit; for (c = *fmt; c != 0; c = *++fmt) { if (c != '%') { *sbuffer++ = (char)c; if (++nwritten >= buflen) goto exit; } else { size_t i=0, j; // The mDNS Vsprintf Argument Conversion Buffer is used as a temporary holding area for // generating decimal numbers, hexdecimal numbers, IP addresses, domain name strings, etc. // The size needs to be enough for a 256-byte domain name plus some error text. #define mDNS_VACB_Size 300 char mDNS_VACB[mDNS_VACB_Size]; #define mDNS_VACB_Lim (&mDNS_VACB[mDNS_VACB_Size]) #define mDNS_VACB_Remain(s) ((size_t)(mDNS_VACB_Lim - s)) char *s = mDNS_VACB_Lim; const char *digits = "0123456789ABCDEF"; struct DebugSNPrintF_format F = DebugSNPrintF_format_default; for(;;) // decode flags { c = *++fmt; if (c == '-') F.leftJustify = 1; else if (c == '+') F.forceSign = 1; else if (c == ' ') F.sign = ' '; else if (c == '#') F.altForm++; else if (c == '0') F.zeroPad = 1; else break; } if (c == '*') // decode field width { int f = va_arg(arg, int); if (f < 0) { f = -f; F.leftJustify = 1; } F.fieldWidth = (unsigned int)f; c = *++fmt; } else { for (; c >= '0' && c <= '9'; c = *++fmt) F.fieldWidth = (10 * F.fieldWidth) + (c - '0'); } if (c == '.') // decode precision { if ((c = *++fmt) == '*') { F.precision = va_arg(arg, unsigned int); c = *++fmt; } else for (; c >= '0' && c <= '9'; c = *++fmt) F.precision = (10 * F.precision) + (c - '0'); F.havePrecision = 1; } if (F.leftJustify) F.zeroPad = 0; conv: switch (c) // perform appropriate conversion { #if TYPE_LONGLONG_NATIVE unsigned_long_long_compat n; unsigned_long_long_compat base; #else unsigned long n; unsigned long base; #endif case 'h' : F.hSize = 1; c = *++fmt; goto conv; case 'l' : // fall through case 'L' : F.lSize++; c = *++fmt; goto conv; case 'd' : case 'i' : base = 10; goto canBeSigned; case 'u' : base = 10; goto notSigned; case 'o' : base = 8; goto notSigned; case 'b' : base = 2; goto notSigned; case 'p' : n = va_arg(arg, uintptr_t); F.havePrecision = 1; F.precision = (sizeof(uintptr_t) == 4) ? 8 : 16; F.sign = 0; base = 16; c = 'x'; goto number; case 'x' : digits = "0123456789abcdef"; case 'X' : base = 16; goto notSigned; canBeSigned: #if TYPE_LONGLONG_NATIVE if (F.lSize == 1) n = (unsigned_long_long_compat)va_arg(arg, long); else if (F.lSize == 2) n = (unsigned_long_long_compat)va_arg(arg, long_long_compat); else n = (unsigned_long_long_compat)va_arg(arg, int); #else if (F.lSize == 1) n = (unsigned long)va_arg(arg, long); else if (F.lSize == 2) goto exit; else n = (unsigned long)va_arg(arg, int); #endif if (F.hSize) n = (short) n; #if TYPE_LONGLONG_NATIVE if ((long_long_compat) n < 0) { n = (unsigned_long_long_compat)-(long_long_compat)n; F.sign = '-'; } #else if ((long) n < 0) { n = (unsigned long)-(long)n; F.sign = '-'; } #endif else if (F.forceSign) F.sign = '+'; goto number; notSigned: if (F.lSize == 1) n = va_arg(arg, unsigned long); else if (F.lSize == 2) { #if TYPE_LONGLONG_NATIVE n = va_arg(arg, unsigned_long_long_compat); #else goto exit; #endif } else n = va_arg(arg, unsigned int); if (F.hSize) n = (unsigned short) n; F.sign = 0; goto number; number: if (!F.havePrecision) { if (F.zeroPad) { F.precision = F.fieldWidth; if (F.altForm) F.precision -= 2; if (F.sign) --F.precision; } if (F.precision < 1) F.precision = 1; } if (F.precision > mDNS_VACB_Size - 1) F.precision = mDNS_VACB_Size - 1; for (i = 0; n; n /= base, i++) *--s = (char)(digits[n % base]); for (; i < F.precision; i++) *--s = '0'; if (F.altForm) { *--s = (char)c; *--s = '0'; i += 2; } if (F.sign) { *--s = F.sign; i++; } break; case 'a' : { unsigned char *a = va_arg(arg, unsigned char *); char pre[4] = ""; char post[32] = ""; if (!a) { static char emsg[] = "<>"; s = emsg; i = sizeof(emsg)-1; } else { s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end if (F.altForm == 1) { #if(defined(MDNS_DEBUGMSGS)) mDNSAddr *ip = (mDNSAddr*)a; switch (ip->type) { case mDNSAddrType_IPv4: F.precision = 4; a = (unsigned char *)&ip->ip.v4; break; case mDNSAddrType_IPv6: F.precision = 16; a = (unsigned char *)&ip->ip.v6; break; default: F.precision = 0; break; } #else F.precision = 0; // mDNSEmbeddedAPI.h not included so no mDNSAddr support #endif } else if (F.altForm == 2) { #ifdef AF_INET const struct sockaddr *sa; unsigned char *port; sa = (const struct sockaddr*)a; switch (sa->sa_family) { case AF_INET: F.precision = 4; a = (unsigned char*)&((const struct sockaddr_in *)a)->sin_addr; port = (unsigned char*)&((const struct sockaddr_in *)sa)->sin_port; DebugSNPrintF(post, sizeof(post), ":%d", (port[0] << 8) | port[1]); break; #ifdef AF_INET6 case AF_INET6: F.precision = 16; a = (unsigned char*)&((const struct sockaddr_in6 *)a)->sin6_addr; pre[0] = '['; pre[1] = '\0'; port = (unsigned char*)&((const struct sockaddr_in6 *)sa)->sin6_port; DebugSNPrintF(post, sizeof(post), "%%%d]:%d", (int)((const struct sockaddr_in6 *)sa)->sin6_scope_id, (port[0] << 8) | port[1]); break; #endif default: F.precision = 0; break; } #else F.precision = 0; // socket interfaces not included so no sockaddr support #endif } switch (F.precision) { case 4: i = DebugSNPrintF(mDNS_VACB, sizeof(mDNS_VACB), "%d.%d.%d.%d%s", a[0], a[1], a[2], a[3], post); break; case 6: i = DebugSNPrintF(mDNS_VACB, sizeof(mDNS_VACB), "%02X:%02X:%02X:%02X:%02X:%02X", a[0], a[1], a[2], a[3], a[4], a[5]); break; case 8: i = DebugSNPrintF(mDNS_VACB, sizeof(mDNS_VACB), "%02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X", a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]); break; case 16: i = DebugSNPrintF(mDNS_VACB, sizeof(mDNS_VACB), "%s%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X%s", pre, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15], post); break; default: i = DebugSNPrintF(mDNS_VACB, sizeof(mDNS_VACB), "%s", "<< ERROR: Must specify address size " "(i.e. %.4a=IPv4, %.6a=Ethernet, %.8a=Fibre Channel %.16a=IPv6) >>"); break; } } } break; case 'U' : { unsigned char *a = va_arg(arg, unsigned char *); if (!a) { static char emsg[] = "<>"; s = emsg; i = sizeof(emsg)-1; } else { s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end i = DebugSNPrintF(mDNS_VACB, sizeof(mDNS_VACB), "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", *((uint32_t*) &a[0]), *((uint16_t*) &a[4]), *((uint16_t*) &a[6]), a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]); break; } } break; case 'c' : *--s = (char)va_arg(arg, int); i = 1; break; case 'C' : if (F.lSize) n = va_arg(arg, unsigned long); else n = va_arg(arg, unsigned int); if (F.hSize) n = (unsigned short) n; c = (int)( n & 0xFF); *--s = (char)(DebugIsPrint(c) ? c : '^'); c = (int)((n >> 8) & 0xFF); *--s = (char)(DebugIsPrint(c) ? c : '^'); c = (int)((n >> 16) & 0xFF); *--s = (char)(DebugIsPrint(c) ? c : '^'); c = (int)((n >> 24) & 0xFF); *--s = (char)(DebugIsPrint(c) ? c : '^'); i = 4; break; case 's' : s = va_arg(arg, char *); if (!s) { static char emsg[] = "<>"; s = emsg; i = sizeof(emsg)-1; } else switch (F.altForm) { case 0: i=0; if (F.havePrecision) // C string { while((i < F.precision) && s[i]) i++; // Make sure we don't truncate in the middle of a UTF-8 character. // If the last character is part of a multi-byte UTF-8 character, back up to the start of it. j=0; while((i > 0) && ((c = s[i-1]) & 0x80)) { j++; i--; if((c & 0xC0) != 0x80) break; } // If the actual count of UTF-8 characters matches the encoded UTF-8 count, add it back. if((j > 1) && (j <= 6)) { int test = (0xFF << (8-j)) & 0xFF; int mask = test | (1 << ((8-j)-1)); if((c & mask) == test) i += j; } } else while(s[i]) i++; break; case 1: i = (unsigned char) *s++; break; // Pascal string case 2: { // DNS label-sequence name unsigned char *a = (unsigned char *)s; s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end if (*a == 0) *s++ = '.'; // Special case for root DNS name while (*a) { if (*a > 63) { s += DebugSNPrintF(s, mDNS_VACB_Remain(s), "<>", *a); break; } if (s + *a >= &mDNS_VACB[254]) { s += DebugSNPrintF(s, mDNS_VACB_Remain(s), "<>"); break; } s += DebugSNPrintF(s, mDNS_VACB_Remain(s), "%#s.", a); a += 1 + *a; } i = (size_t)(s - mDNS_VACB); s = mDNS_VACB; // Reset s back to the start of the buffer break; } } if (F.havePrecision && i > F.precision) // Make sure we don't truncate in the middle of a UTF-8 character { i = F.precision; while (i>0 && (s[i] & 0xC0) == 0x80) i--; } break; case 'S': { // UTF-16 string unsigned char *a = va_arg(arg, unsigned char *); uint16_t *u = (uint16_t*)a; if (!u) { static char emsg[] = "<>"; s = emsg; i = sizeof(emsg)-1; } if ((!F.havePrecision || F.precision)) { if ((a[0] == 0xFE) && (a[1] == 0xFF)) { F.altForm = 1; u += 1; a += 2; F.precision--; } // Big Endian else if ((a[0] == 0xFF) && (a[1] == 0xFE)) { F.altForm = 2; u += 1; a += 2; F.precision--; } // Little Endian } s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end switch (F.altForm) { case 0: while ((!F.havePrecision || (i < F.precision)) && u[i] && mDNS_VACB_Remain(s)) // Host Endian { c = u[i]; *s++ = (char)(DebugIsPrint(c) ? c : '^'); i++; } break; case 1: while ((!F.havePrecision || (i < F.precision)) && u[i] && mDNS_VACB_Remain(s)) // Big Endian { c = ((a[0] << 8) | a[1]) & 0xFF; *s++ = (char)(DebugIsPrint(c) ? c : '^'); i++; a += 2; } break; case 2: while ((!F.havePrecision || (i < F.precision)) && u[i] && mDNS_VACB_Remain(s)) // Little Endian { c = ((a[1] << 8) | a[0]) & 0xFF; *s++ = (char)(DebugIsPrint(c) ? c : '^'); i++; a += 2; } break; } } s = mDNS_VACB; // Reset s back to the start of the buffer break; #if TARGET_OS_MAC case '@': { // Cocoa/CoreFoundation object CFTypeRef cfObj; CFStringRef cfStr; cfObj = (CFTypeRef) va_arg(arg, void *); cfStr = (CFGetTypeID(cfObj) == CFStringGetTypeID()) ? (CFStringRef)CFRetain(cfObj) : CFCopyDescription(cfObj); s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end if (cfStr) { CFRange range; CFIndex m; range = CFRangeMake(0, CFStringGetLength(cfStr)); m = 0; CFStringGetBytes(cfStr, range, kCFStringEncodingUTF8, '^', false, (UInt8*)mDNS_VACB, (CFIndex)sizeof(mDNS_VACB), &m); CFRelease(cfStr); i = (size_t) m; } else { i = DebugSNPrintF(mDNS_VACB, sizeof(mDNS_VACB), "%s", "ERROR: " ); } } if (F.havePrecision && i > F.precision) // Make sure we don't truncate in the middle of a UTF-8 character { i = F.precision; while (i>0 && (s[i] & 0xC0) == 0x80) i--; } break; #endif case 'm' : { // Error Message long err; if (F.lSize) err = va_arg(arg, long); else err = va_arg(arg, int); if (F.hSize) err = (short)err; DebugGetErrorString(err, mDNS_VACB, sizeof(mDNS_VACB)); s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end for(i=0;s[i];i++) {} } break; case 'H' : { // Hex Dump void *a = va_arg(arg, void *); size_t size = (size_t)va_arg(arg, int); size_t max = (size_t)va_arg(arg, int); DebugFlags flags = kDebugFlagsNoAddress | kDebugFlagsNoOffset | kDebugFlagsNoNewLine | kDebugFlags8BitSeparator | kDebugFlagsNo32BitSeparator | kDebugFlagsNo16ByteHexPad | kDebugFlagsNoByteCount; if (F.altForm == 0) flags |= kDebugFlagsNoASCII; size = (max < size) ? max : size; s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end i = DebugHexDump(kDebugLevelMax, 0, NULL, 0, 0, NULL, 0, a, a, size, flags, mDNS_VACB, sizeof(mDNS_VACB)); } break; case 'v' : { // Version uint32_t version; version = va_arg(arg, unsigned int); DebugNumVersionToString(version, mDNS_VACB); s = mDNS_VACB; // Adjust s to point to the start of the buffer, not the end for(i=0;s[i];i++) {} } break; case 'n' : s = va_arg(arg, char *); if (F.hSize) * (short *) s = (short)nwritten; else if (F.lSize) * (long *) s = (long)nwritten; else * (int *) s = (int)nwritten; continue; default: s = mDNS_VACB; i = DebugSNPrintF(mDNS_VACB, sizeof(mDNS_VACB), "<>", c); case '%' : *sbuffer++ = (char)c; if (++nwritten >= buflen) goto exit; break; } if (i < F.fieldWidth && !F.leftJustify) // Pad on the left do { *sbuffer++ = ' '; if (++nwritten >= buflen) goto exit; } while (i < --F.fieldWidth); if (i > buflen - nwritten) // Make sure we don't truncate in the middle of a UTF-8 character { i = buflen - nwritten; while (i>0 && (s[i] & 0xC0) == 0x80) i--; } for (j=0; j= buflen) goto exit; for (; i < F.fieldWidth; i++) // Pad on the right { *sbuffer++ = ' '; if (++nwritten >= buflen) goto exit; } } } exit: *sbuffer++ = 0; return(nwritten); } //=========================================================================================================================== // DebugGetErrorString //=========================================================================================================================== DEBUG_EXPORT const char * DebugGetErrorString( int_least32_t inErrorCode, char *inBuffer, size_t inBufferSize ) { const char * s; char * dst; char * end; #if( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) char buffer[ 256 ]; #endif switch( inErrorCode ) { #define CaseErrorString( X, STR ) case X: s = STR; break #define CaseErrorStringify( X ) case X: s = # X; break #define CaseErrorStringifyHardCode( VALUE, X ) case VALUE: s = # X; break // General Errors CaseErrorString( 0, "no error" ); CaseErrorString( 1, "in-progress/waiting" ); CaseErrorString( -1, "catch-all unknown error" ); // ACP Errors CaseErrorStringifyHardCode( -2, kACPBadRequestErr ); CaseErrorStringifyHardCode( -3, kACPNoMemoryErr ); CaseErrorStringifyHardCode( -4, kACPBadParamErr ); CaseErrorStringifyHardCode( -5, kACPNotFoundErr ); CaseErrorStringifyHardCode( -6, kACPBadChecksumErr ); CaseErrorStringifyHardCode( -7, kACPCommandNotHandledErr ); CaseErrorStringifyHardCode( -8, kACPNetworkErr ); CaseErrorStringifyHardCode( -9, kACPDuplicateCommandHandlerErr ); CaseErrorStringifyHardCode( -10, kACPUnknownPropertyErr ); CaseErrorStringifyHardCode( -11, kACPImmutablePropertyErr ); CaseErrorStringifyHardCode( -12, kACPBadPropertyValueErr ); CaseErrorStringifyHardCode( -13, kACPNoResourcesErr ); CaseErrorStringifyHardCode( -14, kACPBadOptionErr ); CaseErrorStringifyHardCode( -15, kACPBadSizeErr ); CaseErrorStringifyHardCode( -16, kACPBadPasswordErr ); CaseErrorStringifyHardCode( -17, kACPNotInitializedErr ); CaseErrorStringifyHardCode( -18, kACPNonReadablePropertyErr ); CaseErrorStringifyHardCode( -19, kACPBadVersionErr ); CaseErrorStringifyHardCode( -20, kACPBadSignatureErr ); CaseErrorStringifyHardCode( -21, kACPBadIndexErr ); CaseErrorStringifyHardCode( -22, kACPUnsupportedErr ); CaseErrorStringifyHardCode( -23, kACPInUseErr ); CaseErrorStringifyHardCode( -24, kACPParamCountErr ); CaseErrorStringifyHardCode( -25, kACPIDErr ); CaseErrorStringifyHardCode( -26, kACPFormatErr ); CaseErrorStringifyHardCode( -27, kACPUnknownUserErr ); CaseErrorStringifyHardCode( -28, kACPAccessDeniedErr ); CaseErrorStringifyHardCode( -29, kACPIncorrectFWErr ); // Common Services Errors CaseErrorStringify( kUnknownErr ); CaseErrorStringify( kOptionErr ); CaseErrorStringify( kSelectorErr ); CaseErrorStringify( kExecutionStateErr ); CaseErrorStringify( kPathErr ); CaseErrorStringify( kParamErr ); CaseErrorStringify( kParamCountErr ); CaseErrorStringify( kCommandErr ); CaseErrorStringify( kIDErr ); CaseErrorStringify( kStateErr ); CaseErrorStringify( kRangeErr ); CaseErrorStringify( kRequestErr ); CaseErrorStringify( kResponseErr ); CaseErrorStringify( kChecksumErr ); CaseErrorStringify( kNotHandledErr ); CaseErrorStringify( kVersionErr ); CaseErrorStringify( kSignatureErr ); CaseErrorStringify( kFormatErr ); CaseErrorStringify( kNotInitializedErr ); CaseErrorStringify( kAlreadyInitializedErr ); CaseErrorStringify( kNotInUseErr ); CaseErrorStringify( kInUseErr ); CaseErrorStringify( kTimeoutErr ); CaseErrorStringify( kCanceledErr ); CaseErrorStringify( kAlreadyCanceledErr ); CaseErrorStringify( kCannotCancelErr ); CaseErrorStringify( kDeletedErr ); CaseErrorStringify( kNotFoundErr ); CaseErrorStringify( kNoMemoryErr ); CaseErrorStringify( kNoResourcesErr ); CaseErrorStringify( kDuplicateErr ); CaseErrorStringify( kImmutableErr ); CaseErrorStringify( kUnsupportedDataErr ); CaseErrorStringify( kIntegrityErr ); CaseErrorStringify( kIncompatibleErr ); CaseErrorStringify( kUnsupportedErr ); CaseErrorStringify( kUnexpectedErr ); CaseErrorStringify( kValueErr ); CaseErrorStringify( kNotReadableErr ); CaseErrorStringify( kNotWritableErr ); CaseErrorStringify( kBadReferenceErr ); CaseErrorStringify( kFlagErr ); CaseErrorStringify( kMalformedErr ); CaseErrorStringify( kSizeErr ); CaseErrorStringify( kNameErr ); CaseErrorStringify( kNotReadyErr ); CaseErrorStringify( kReadErr ); CaseErrorStringify( kWriteErr ); CaseErrorStringify( kMismatchErr ); CaseErrorStringify( kDateErr ); CaseErrorStringify( kUnderrunErr ); CaseErrorStringify( kOverrunErr ); CaseErrorStringify( kEndingErr ); CaseErrorStringify( kConnectionErr ); CaseErrorStringify( kAuthenticationErr ); CaseErrorStringify( kOpenErr ); CaseErrorStringify( kTypeErr ); CaseErrorStringify( kSkipErr ); CaseErrorStringify( kNoAckErr ); CaseErrorStringify( kCollisionErr ); CaseErrorStringify( kBackoffErr ); CaseErrorStringify( kNoAddressAckErr ); CaseErrorStringify( kBusyErr ); CaseErrorStringify( kNoSpaceErr ); // mDNS/DNS-SD Errors CaseErrorStringifyHardCode( -65537, mStatus_UnknownErr ); CaseErrorStringifyHardCode( -65538, mStatus_NoSuchNameErr ); CaseErrorStringifyHardCode( -65539, mStatus_NoMemoryErr ); CaseErrorStringifyHardCode( -65540, mStatus_BadParamErr ); CaseErrorStringifyHardCode( -65541, mStatus_BadReferenceErr ); CaseErrorStringifyHardCode( -65542, mStatus_BadStateErr ); CaseErrorStringifyHardCode( -65543, mStatus_BadFlagsErr ); CaseErrorStringifyHardCode( -65544, mStatus_UnsupportedErr ); CaseErrorStringifyHardCode( -65545, mStatus_NotInitializedErr ); CaseErrorStringifyHardCode( -65546, mStatus_NoCache ); CaseErrorStringifyHardCode( -65547, mStatus_AlreadyRegistered ); CaseErrorStringifyHardCode( -65548, mStatus_NameConflict ); CaseErrorStringifyHardCode( -65549, mStatus_Invalid ); CaseErrorStringifyHardCode( -65550, mStatus_GrowCache ); CaseErrorStringifyHardCode( -65551, mStatus_BadInterfaceErr ); CaseErrorStringifyHardCode( -65552, mStatus_Incompatible ); CaseErrorStringifyHardCode( -65791, mStatus_ConfigChanged ); CaseErrorStringifyHardCode( -65792, mStatus_MemFree ); // RSP Errors CaseErrorStringifyHardCode( -400000, kRSPUnknownErr ); CaseErrorStringifyHardCode( -400050, kRSPParamErr ); CaseErrorStringifyHardCode( -400108, kRSPNoMemoryErr ); CaseErrorStringifyHardCode( -405246, kRSPRangeErr ); CaseErrorStringifyHardCode( -409057, kRSPSizeErr ); CaseErrorStringifyHardCode( -400200, kRSPHardwareErr ); CaseErrorStringifyHardCode( -401712, kRSPTimeoutErr ); CaseErrorStringifyHardCode( -402053, kRSPUnsupportedErr ); CaseErrorStringifyHardCode( -402419, kRSPIDErr ); CaseErrorStringifyHardCode( -403165, kRSPFlagErr ); CaseErrorString( -200000, "kRSPControllerStatusBase - 0x50" ); CaseErrorString( -200080, "kRSPCommandSucceededErr - 0x50" ); CaseErrorString( -200001, "kRSPCommandFailedErr - 0x01" ); CaseErrorString( -200051, "kRSPChecksumErr - 0x33" ); CaseErrorString( -200132, "kRSPCommandTimeoutErr - 0x84" ); CaseErrorString( -200034, "kRSPPasswordRequiredErr - 0x22 OBSOLETE" ); CaseErrorString( -200128, "kRSPCanceledErr - 0x02 Async" ); // XML Errors CaseErrorStringifyHardCode( -100043, kXMLNotFoundErr ); CaseErrorStringifyHardCode( -100050, kXMLParamErr ); CaseErrorStringifyHardCode( -100108, kXMLNoMemoryErr ); CaseErrorStringifyHardCode( -100206, kXMLFormatErr ); CaseErrorStringifyHardCode( -100586, kXMLNoRootElementErr ); CaseErrorStringifyHardCode( -101703, kXMLWrongDataTypeErr ); CaseErrorStringifyHardCode( -101726, kXMLKeyErr ); CaseErrorStringifyHardCode( -102053, kXMLUnsupportedErr ); CaseErrorStringifyHardCode( -102063, kXMLMissingElementErr ); CaseErrorStringifyHardCode( -103026, kXMLParseErr ); CaseErrorStringifyHardCode( -103159, kXMLBadDataErr ); CaseErrorStringifyHardCode( -103170, kXMLBadNameErr ); CaseErrorStringifyHardCode( -105246, kXMLRangeErr ); CaseErrorStringifyHardCode( -105251, kXMLUnknownElementErr ); CaseErrorStringifyHardCode( -108739, kXMLMalformedInputErr ); CaseErrorStringifyHardCode( -109057, kXMLBadSizeErr ); CaseErrorStringifyHardCode( -101730, kXMLMissingChildElementErr ); CaseErrorStringifyHardCode( -102107, kXMLMissingParentElementErr ); CaseErrorStringifyHardCode( -130587, kXMLNonRootElementErr ); CaseErrorStringifyHardCode( -102015, kXMLDateErr ); #if( __MACH__ ) // Mach Errors CaseErrorStringifyHardCode( 0x00002000, MACH_MSG_IPC_SPACE ); CaseErrorStringifyHardCode( 0x00001000, MACH_MSG_VM_SPACE ); CaseErrorStringifyHardCode( 0x00000800, MACH_MSG_IPC_KERNEL ); CaseErrorStringifyHardCode( 0x00000400, MACH_MSG_VM_KERNEL ); CaseErrorStringifyHardCode( 0x10000001, MACH_SEND_IN_PROGRESS ); CaseErrorStringifyHardCode( 0x10000002, MACH_SEND_INVALID_DATA ); CaseErrorStringifyHardCode( 0x10000003, MACH_SEND_INVALID_DEST ); CaseErrorStringifyHardCode( 0x10000004, MACH_SEND_TIMED_OUT ); CaseErrorStringifyHardCode( 0x10000007, MACH_SEND_INTERRUPTED ); CaseErrorStringifyHardCode( 0x10000008, MACH_SEND_MSG_TOO_SMALL ); CaseErrorStringifyHardCode( 0x10000009, MACH_SEND_INVALID_REPLY ); CaseErrorStringifyHardCode( 0x1000000A, MACH_SEND_INVALID_RIGHT ); CaseErrorStringifyHardCode( 0x1000000B, MACH_SEND_INVALID_NOTIFY ); CaseErrorStringifyHardCode( 0x1000000C, MACH_SEND_INVALID_MEMORY ); CaseErrorStringifyHardCode( 0x1000000D, MACH_SEND_NO_BUFFER ); CaseErrorStringifyHardCode( 0x1000000E, MACH_SEND_TOO_LARGE ); CaseErrorStringifyHardCode( 0x1000000F, MACH_SEND_INVALID_TYPE ); CaseErrorStringifyHardCode( 0x10000010, MACH_SEND_INVALID_HEADER ); CaseErrorStringifyHardCode( 0x10000011, MACH_SEND_INVALID_TRAILER ); CaseErrorStringifyHardCode( 0x10000015, MACH_SEND_INVALID_RT_OOL_SIZE ); CaseErrorStringifyHardCode( 0x10004001, MACH_RCV_IN_PROGRESS ); CaseErrorStringifyHardCode( 0x10004002, MACH_RCV_INVALID_NAME ); CaseErrorStringifyHardCode( 0x10004003, MACH_RCV_TIMED_OUT ); CaseErrorStringifyHardCode( 0x10004004, MACH_RCV_TOO_LARGE ); CaseErrorStringifyHardCode( 0x10004005, MACH_RCV_INTERRUPTED ); CaseErrorStringifyHardCode( 0x10004006, MACH_RCV_PORT_CHANGED ); CaseErrorStringifyHardCode( 0x10004007, MACH_RCV_INVALID_NOTIFY ); CaseErrorStringifyHardCode( 0x10004008, MACH_RCV_INVALID_DATA ); CaseErrorStringifyHardCode( 0x10004009, MACH_RCV_PORT_DIED ); CaseErrorStringifyHardCode( 0x1000400A, MACH_RCV_IN_SET ); CaseErrorStringifyHardCode( 0x1000400B, MACH_RCV_HEADER_ERROR ); CaseErrorStringifyHardCode( 0x1000400C, MACH_RCV_BODY_ERROR ); CaseErrorStringifyHardCode( 0x1000400D, MACH_RCV_INVALID_TYPE ); CaseErrorStringifyHardCode( 0x1000400E, MACH_RCV_SCATTER_SMALL ); CaseErrorStringifyHardCode( 0x1000400F, MACH_RCV_INVALID_TRAILER ); CaseErrorStringifyHardCode( 0x10004011, MACH_RCV_IN_PROGRESS_TIMED ); // Mach OSReturn Errors CaseErrorStringifyHardCode( 0xDC000001, kOSReturnError ); CaseErrorStringifyHardCode( 0xDC004001, kOSMetaClassInternal ); CaseErrorStringifyHardCode( 0xDC004002, kOSMetaClassHasInstances ); CaseErrorStringifyHardCode( 0xDC004003, kOSMetaClassNoInit ); CaseErrorStringifyHardCode( 0xDC004004, kOSMetaClassNoTempData ); CaseErrorStringifyHardCode( 0xDC004005, kOSMetaClassNoDicts ); CaseErrorStringifyHardCode( 0xDC004006, kOSMetaClassNoKModSet ); CaseErrorStringifyHardCode( 0xDC004007, kOSMetaClassNoInsKModSet ); CaseErrorStringifyHardCode( 0xDC004008, kOSMetaClassNoSuper ); CaseErrorStringifyHardCode( 0xDC004009, kOSMetaClassInstNoSuper ); CaseErrorStringifyHardCode( 0xDC00400A, kOSMetaClassDuplicateClass ); // IOKit Errors CaseErrorStringifyHardCode( 0xE00002BC, kIOReturnError ); CaseErrorStringifyHardCode( 0xE00002BD, kIOReturnNoMemory ); CaseErrorStringifyHardCode( 0xE00002BE, kIOReturnNoResources ); CaseErrorStringifyHardCode( 0xE00002BF, kIOReturnIPCError ); CaseErrorStringifyHardCode( 0xE00002C0, kIOReturnNoDevice ); CaseErrorStringifyHardCode( 0xE00002C1, kIOReturnNotPrivileged ); CaseErrorStringifyHardCode( 0xE00002C2, kIOReturnBadArgument ); CaseErrorStringifyHardCode( 0xE00002C3, kIOReturnLockedRead ); CaseErrorStringifyHardCode( 0xE00002C4, kIOReturnLockedWrite ); CaseErrorStringifyHardCode( 0xE00002C5, kIOReturnExclusiveAccess ); CaseErrorStringifyHardCode( 0xE00002C6, kIOReturnBadMessageID ); CaseErrorStringifyHardCode( 0xE00002C7, kIOReturnUnsupported ); CaseErrorStringifyHardCode( 0xE00002C8, kIOReturnVMError ); CaseErrorStringifyHardCode( 0xE00002C9, kIOReturnInternalError ); CaseErrorStringifyHardCode( 0xE00002CA, kIOReturnIOError ); CaseErrorStringifyHardCode( 0xE00002CC, kIOReturnCannotLock ); CaseErrorStringifyHardCode( 0xE00002CD, kIOReturnNotOpen ); CaseErrorStringifyHardCode( 0xE00002CE, kIOReturnNotReadable ); CaseErrorStringifyHardCode( 0xE00002CF, kIOReturnNotWritable ); CaseErrorStringifyHardCode( 0xE00002D0, kIOReturnNotAligned ); CaseErrorStringifyHardCode( 0xE00002D1, kIOReturnBadMedia ); CaseErrorStringifyHardCode( 0xE00002D2, kIOReturnStillOpen ); CaseErrorStringifyHardCode( 0xE00002D3, kIOReturnRLDError ); CaseErrorStringifyHardCode( 0xE00002D4, kIOReturnDMAError ); CaseErrorStringifyHardCode( 0xE00002D5, kIOReturnBusy ); CaseErrorStringifyHardCode( 0xE00002D6, kIOReturnTimeout ); CaseErrorStringifyHardCode( 0xE00002D7, kIOReturnOffline ); CaseErrorStringifyHardCode( 0xE00002D8, kIOReturnNotReady ); CaseErrorStringifyHardCode( 0xE00002D9, kIOReturnNotAttached ); CaseErrorStringifyHardCode( 0xE00002DA, kIOReturnNoChannels ); CaseErrorStringifyHardCode( 0xE00002DB, kIOReturnNoSpace ); CaseErrorStringifyHardCode( 0xE00002DD, kIOReturnPortExists ); CaseErrorStringifyHardCode( 0xE00002DE, kIOReturnCannotWire ); CaseErrorStringifyHardCode( 0xE00002DF, kIOReturnNoInterrupt ); CaseErrorStringifyHardCode( 0xE00002E0, kIOReturnNoFrames ); CaseErrorStringifyHardCode( 0xE00002E1, kIOReturnMessageTooLarge ); CaseErrorStringifyHardCode( 0xE00002E2, kIOReturnNotPermitted ); CaseErrorStringifyHardCode( 0xE00002E3, kIOReturnNoPower ); CaseErrorStringifyHardCode( 0xE00002E4, kIOReturnNoMedia ); CaseErrorStringifyHardCode( 0xE00002E5, kIOReturnUnformattedMedia ); CaseErrorStringifyHardCode( 0xE00002E6, kIOReturnUnsupportedMode ); CaseErrorStringifyHardCode( 0xE00002E7, kIOReturnUnderrun ); CaseErrorStringifyHardCode( 0xE00002E8, kIOReturnOverrun ); CaseErrorStringifyHardCode( 0xE00002E9, kIOReturnDeviceError ); CaseErrorStringifyHardCode( 0xE00002EA, kIOReturnNoCompletion ); CaseErrorStringifyHardCode( 0xE00002EB, kIOReturnAborted ); CaseErrorStringifyHardCode( 0xE00002EC, kIOReturnNoBandwidth ); CaseErrorStringifyHardCode( 0xE00002ED, kIOReturnNotResponding ); CaseErrorStringifyHardCode( 0xE00002EE, kIOReturnIsoTooOld ); CaseErrorStringifyHardCode( 0xE00002EF, kIOReturnIsoTooNew ); CaseErrorStringifyHardCode( 0xE00002F0, kIOReturnNotFound ); CaseErrorStringifyHardCode( 0xE0000001, kIOReturnInvalid ); // IOKit FireWire Errors CaseErrorStringifyHardCode( 0xE0008010, kIOFireWireResponseBase ); CaseErrorStringifyHardCode( 0xE0008020, kIOFireWireBusReset ); CaseErrorStringifyHardCode( 0xE0008001, kIOConfigNoEntry ); CaseErrorStringifyHardCode( 0xE0008002, kIOFireWirePending ); CaseErrorStringifyHardCode( 0xE0008003, kIOFireWireLastDCLToken ); CaseErrorStringifyHardCode( 0xE0008004, kIOFireWireConfigROMInvalid ); CaseErrorStringifyHardCode( 0xE0008005, kIOFireWireAlreadyRegistered ); CaseErrorStringifyHardCode( 0xE0008006, kIOFireWireMultipleTalkers ); CaseErrorStringifyHardCode( 0xE0008007, kIOFireWireChannelActive ); CaseErrorStringifyHardCode( 0xE0008008, kIOFireWireNoListenerOrTalker ); CaseErrorStringifyHardCode( 0xE0008009, kIOFireWireNoChannels ); CaseErrorStringifyHardCode( 0xE000800A, kIOFireWireChannelNotAvailable ); CaseErrorStringifyHardCode( 0xE000800B, kIOFireWireSeparateBus ); CaseErrorStringifyHardCode( 0xE000800C, kIOFireWireBadSelfIDs ); CaseErrorStringifyHardCode( 0xE000800D, kIOFireWireLowCableVoltage ); CaseErrorStringifyHardCode( 0xE000800E, kIOFireWireInsufficientPower ); CaseErrorStringifyHardCode( 0xE000800F, kIOFireWireOutOfTLabels ); CaseErrorStringifyHardCode( 0xE0008101, kIOFireWireBogusDCLProgram ); CaseErrorStringifyHardCode( 0xE0008102, kIOFireWireTalkingAndListening ); CaseErrorStringifyHardCode( 0xE0008103, kIOFireWireHardwareSlept ); CaseErrorStringifyHardCode( 0xE00087D0, kIOFWMessageServiceIsRequestingClose ); CaseErrorStringifyHardCode( 0xE00087D1, kIOFWMessagePowerStateChanged ); CaseErrorStringifyHardCode( 0xE00087D2, kIOFWMessageTopologyChanged ); // IOKit USB Errors CaseErrorStringifyHardCode( 0xE0004061, kIOUSBUnknownPipeErr ); CaseErrorStringifyHardCode( 0xE0004060, kIOUSBTooManyPipesErr ); CaseErrorStringifyHardCode( 0xE000405F, kIOUSBNoAsyncPortErr ); CaseErrorStringifyHardCode( 0xE000405E, kIOUSBNotEnoughPipesErr ); CaseErrorStringifyHardCode( 0xE000405D, kIOUSBNotEnoughPowerErr ); CaseErrorStringifyHardCode( 0xE0004057, kIOUSBEndpointNotFound ); CaseErrorStringifyHardCode( 0xE0004056, kIOUSBConfigNotFound ); CaseErrorStringifyHardCode( 0xE0004051, kIOUSBTransactionTimeout ); CaseErrorStringifyHardCode( 0xE0004050, kIOUSBTransactionReturned ); CaseErrorStringifyHardCode( 0xE000404F, kIOUSBPipeStalled ); CaseErrorStringifyHardCode( 0xE000404E, kIOUSBInterfaceNotFound ); CaseErrorStringifyHardCode( 0xE000404D, kIOUSBLowLatencyBufferNotPreviouslyAllocated ); CaseErrorStringifyHardCode( 0xE000404C, kIOUSBLowLatencyFrameListNotPreviouslyAllocated ); CaseErrorStringifyHardCode( 0xE000404B, kIOUSBHighSpeedSplitError ); CaseErrorStringifyHardCode( 0xE0004010, kIOUSBLinkErr ); CaseErrorStringifyHardCode( 0xE000400F, kIOUSBNotSent2Err ); CaseErrorStringifyHardCode( 0xE000400E, kIOUSBNotSent1Err ); CaseErrorStringifyHardCode( 0xE000400D, kIOUSBBufferUnderrunErr ); CaseErrorStringifyHardCode( 0xE000400C, kIOUSBBufferOverrunErr ); CaseErrorStringifyHardCode( 0xE000400B, kIOUSBReserved2Err ); CaseErrorStringifyHardCode( 0xE000400A, kIOUSBReserved1Err ); CaseErrorStringifyHardCode( 0xE0004007, kIOUSBWrongPIDErr ); CaseErrorStringifyHardCode( 0xE0004006, kIOUSBPIDCheckErr ); CaseErrorStringifyHardCode( 0xE0004003, kIOUSBDataToggleErr ); CaseErrorStringifyHardCode( 0xE0004002, kIOUSBBitstufErr ); CaseErrorStringifyHardCode( 0xE0004001, kIOUSBCRCErr ); #endif // __MACH__ // Other Errors default: s = NULL; #if( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) if( inBuffer && ( inBufferSize > 0 ) ) { DWORD n; n = FormatMessageA( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, (DWORD) inErrorCode, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), buffer, sizeof( buffer ), NULL ); if( n > 0 ) { // Remove any trailing CR's or LF's since some messages have them. while( ( n > 0 ) && isspace( ( (unsigned char *) buffer )[ n - 1 ] ) ) { buffer[ --n ] = '\0'; } s = buffer; } } #endif if( !s ) { #if( !TARGET_API_MAC_OSX_KERNEL && !TARGET_OS_WINDOWS_CE ) s = strerror( inErrorCode ); #endif if( !s ) { s = ""; } } break; } // Copy the string to the output buffer. If no buffer is supplied or it is empty, return an empty string. if( inBuffer && ( inBufferSize > 0 ) ) { dst = inBuffer; end = dst + ( inBufferSize - 1 ); while( ( ( end - dst ) > 0 ) && ( *s != '\0' ) ) { *dst++ = *s++; } *dst = '\0'; s = inBuffer; } return( s ); } //=========================================================================================================================== // DebugHexDump //=========================================================================================================================== DEBUG_EXPORT size_t DebugHexDump( DebugLevel inLevel, int inIndent, const char * inLabel, size_t inLabelSize, int inLabelMinWidth, const char * inType, size_t inTypeSize, const void * inDataStart, const void * inData, size_t inDataSize, DebugFlags inFlags, char * outBuffer, size_t inBufferSize ) { static const char kHexChars[] = "0123456789ABCDEF"; const uint8_t * start; const uint8_t * src; char * dst; char * end; size_t n; int offset; int width; const char * newline; char separator[ 8 ]; char * s; DEBUG_UNUSED( inType ); DEBUG_UNUSED( inTypeSize ); // Set up the function-wide variables. if( inLabelSize == kSizeCString ) { inLabelSize = strlen( inLabel ); } start = (const uint8_t *) inData; src = start; dst = outBuffer; end = dst + inBufferSize; offset = (int)( (intptr_t) inData - (intptr_t) inDataStart ); width = ( (int) inLabelSize > inLabelMinWidth ) ? (int) inLabelSize : inLabelMinWidth; newline = ( inFlags & kDebugFlagsNoNewLine ) ? "" : "\n"; // Set up the separator string. This is used to insert spaces on subsequent "lines" when not using newlines. s = separator; if( inFlags & kDebugFlagsNoNewLine ) { if( inFlags & kDebugFlags8BitSeparator ) { *s++ = ' '; } if( inFlags & kDebugFlags16BitSeparator ) { *s++ = ' '; } if( !( inFlags & kDebugFlagsNo32BitSeparator ) ) { *s++ = ' '; } check( ( (size_t)( s - separator ) ) < sizeof( separator ) ); } *s = '\0'; for( ;; ) { char prefixString[ 32 ]; char hexString[ 64 ]; char asciiString[ 32 ]; char byteCountString[ 32 ]; int c; size_t chunkSize; size_t i; // If this is a label-only item (i.e. no data), print the label (accounting for prefix string spacing) and exit. if( inDataSize == 0 ) { if( inLabel && ( inLabelSize > 0 ) ) { width = 0; if( !( inFlags & kDebugFlagsNoAddress ) ) { width += 8; // "00000000" if( !( inFlags & kDebugFlagsNoOffset ) ) { width += 1; // "+" } } if( inFlags & kDebugFlags32BitOffset ) { width += 8; // "00000000" } else if( !( inFlags & kDebugFlagsNoOffset ) ) { width += 4; // "0000" } if( outBuffer ) { dst += DebugSNPrintF( dst, (size_t)( end - dst ), "%*s" "%-*.*s" "%.*s" "%s", width, "", ( width > 0 ) ? ": " : "", width, (int) inLabelSize, inLabel, newline ); } else { dst += DebugPrintF( inLevel, "%*s" "%-*.*s" "%.*s" "%s", width, "", ( width > 0 ) ? ": " : "", width, (int) inLabelSize, inLabel, newline ); } } break; } // Build the prefix string. It will be in one of the following formats: // // 1) "00000000+0000[0000]" (address and offset) // 2) "00000000" (address only) // 3) "0000[0000]" (offset only) // 4) "" (no address or offset) // // Note: If we're printing multiple "lines", but not printing newlines, a space is used to separate. s = prefixString; if( !( inFlags & kDebugFlagsNoAddress ) ) { *s++ = kHexChars[ ( ( (uintptr_t) src ) >> 28 ) & 0xF ]; *s++ = kHexChars[ ( ( (uintptr_t) src ) >> 24 ) & 0xF ]; *s++ = kHexChars[ ( ( (uintptr_t) src ) >> 20 ) & 0xF ]; *s++ = kHexChars[ ( ( (uintptr_t) src ) >> 16 ) & 0xF ]; *s++ = kHexChars[ ( ( (uintptr_t) src ) >> 12 ) & 0xF ]; *s++ = kHexChars[ ( ( (uintptr_t) src ) >> 8 ) & 0xF ]; *s++ = kHexChars[ ( ( (uintptr_t) src ) >> 4 ) & 0xF ]; *s++ = kHexChars[ ( (uintptr_t) src ) & 0xF ]; if( !( inFlags & kDebugFlagsNoOffset ) ) { *s++ = '+'; } } if( !( inFlags & kDebugFlagsNoOffset ) ) { if( inFlags & kDebugFlags32BitOffset ) { *s++ = kHexChars[ ( offset >> 28 ) & 0xF ]; *s++ = kHexChars[ ( offset >> 24 ) & 0xF ]; *s++ = kHexChars[ ( offset >> 20 ) & 0xF ]; *s++ = kHexChars[ ( offset >> 16 ) & 0xF ]; } *s++ = kHexChars[ ( offset >> 12 ) & 0xF ]; *s++ = kHexChars[ ( offset >> 8 ) & 0xF ]; *s++ = kHexChars[ ( offset >> 4 ) & 0xF ]; *s++ = kHexChars[ offset & 0xF ]; } if( s != prefixString ) { *s++ = ':'; *s++ = ' '; } check( ( (size_t)( s - prefixString ) ) < sizeof( prefixString ) ); *s = '\0'; // Build a hex string with a optional spaces after every 1, 2, and/or 4 bytes to make it easier to read. // Optionally pads the hex string with space to fill the full 16 byte range (so it lines up). s = hexString; chunkSize = ( inDataSize < 16 ) ? inDataSize : 16; n = ( inFlags & kDebugFlagsNo16ByteHexPad ) ? chunkSize : 16; for( i = 0; i < n; ++i ) { if( ( inFlags & kDebugFlags8BitSeparator ) && ( i > 0 ) ) { *s++ = ' '; } if( ( inFlags & kDebugFlags16BitSeparator ) && ( i > 0 ) && ( ( i % 2 ) == 0 ) ) { *s++ = ' '; } if( !( inFlags & kDebugFlagsNo32BitSeparator ) && ( i > 0 ) && ( ( i % 4 ) == 0 ) ) { *s++ = ' '; } if( i < chunkSize ) { *s++ = kHexChars[ src[ i ] >> 4 ]; *s++ = kHexChars[ src[ i ] & 0xF ]; } else { *s++ = ' '; *s++ = ' '; } } check( ( (size_t)( s - hexString ) ) < sizeof( hexString ) ); *s = '\0'; // Build a string with the ASCII version of the data (replaces non-printable characters with '^'). // Optionally pads the string with '`' to fill the full 16 byte range (so it lines up). s = asciiString; if( !( inFlags & kDebugFlagsNoASCII ) ) { *s++ = ' '; *s++ = '|'; for( i = 0; i < n; ++i ) { if( i < chunkSize ) { c = src[ i ]; if( !DebugIsPrint( c ) ) { c = '^'; } } else { c = '`'; } *s++ = (char) c; } *s++ = '|'; check( ( (size_t)( s - asciiString ) ) < sizeof( asciiString ) ); } *s = '\0'; // Build a string indicating how bytes are in the hex dump. Only printed on the first line. s = byteCountString; if( !( inFlags & kDebugFlagsNoByteCount ) ) { if( src == start ) { s += DebugSNPrintF( s, sizeof( byteCountString ), " (%d bytes)", (int) inDataSize ); } } check( ( (size_t)( s - byteCountString ) ) < sizeof( byteCountString ) ); *s = '\0'; // Build the entire line from all the pieces we've previously built. if( outBuffer ) { if( src == start ) { dst += DebugSNPrintF( dst, (size_t)( end - dst ), "%*s" // Indention "%s" // Separator (only if needed) "%s" // Prefix "%-*.*s" // Label "%s" // Separator "%s" // Hex "%s" // ASCII "%s" // Byte Count "%s", // Newline inIndent, "", ( src != start ) ? separator : "", prefixString, width, (int) inLabelSize, inLabel ? inLabel : "", ( width > 0 ) ? " " : "", hexString, asciiString, byteCountString, newline ); } else { dst += DebugSNPrintF( dst, (size_t)( end - dst ), "%*s" // Indention "%s" // Separator (only if needed) "%s" // Prefix "%*s" // Label Spacing "%s" // Separator "%s" // Hex "%s" // ASCII "%s" // Byte Count "%s", // Newline inIndent, "", ( src != start ) ? separator : "", prefixString, width, "", ( width > 0 ) ? " " : "", hexString, asciiString, byteCountString, newline ); } } else { if( src == start ) { dst += DebugPrintF( inLevel, "%*s" // Indention "%s" // Separator (only if needed) "%s" // Prefix "%-*.*s" // Label "%s" // Separator "%s" // Hex "%s" // ASCII "%s" // Byte Count "%s", // Newline inIndent, "", ( src != start ) ? separator : "", prefixString, width, (int) inLabelSize, inLabel, ( width > 0 ) ? " " : "", hexString, asciiString, byteCountString, newline ); } else { dst += DebugPrintF( inLevel, "%*s" // Indention "%s" // Separator (only if needed) "%s" // Prefix "%*s" // Label Spacing "%s" // Separator "%s" // Hex "%s" // ASCII "%s" // Byte Count "%s", // Newline inIndent, "", ( src != start ) ? separator : "", prefixString, width, "", ( width > 0 ) ? " " : "", hexString, asciiString, byteCountString, newline ); } } // Move to the next chunk. Exit if there is no more data. offset += (int) chunkSize; src += chunkSize; inDataSize -= chunkSize; if( inDataSize == 0 ) { break; } } // Note: The "dst - outBuffer" size calculation works even if "outBuffer" is NULL because it's all relative. return( (size_t)( dst - outBuffer ) ); } //=========================================================================================================================== // DebugNumVersionToString //=========================================================================================================================== static char * DebugNumVersionToString( uint32_t inVersion, char *inString ) { char * s; uint8_t majorRev; uint8_t minor; uint8_t bugFix; uint8_t stage; uint8_t revision; check( inString ); majorRev = (uint8_t)( ( inVersion >> 24 ) & 0xFF ); minor = (uint8_t)( ( inVersion >> 20 ) & 0x0F ); bugFix = (uint8_t)( ( inVersion >> 16 ) & 0x0F ); stage = (uint8_t)( ( inVersion >> 8 ) & 0xFF ); revision = (uint8_t)( inVersion & 0xFF ); // Convert the major, minor, and bugfix numbers. s = inString; s += sprintf( s, "%u", majorRev ); s += sprintf( s, ".%u", minor ); if( bugFix != 0 ) { s += sprintf( s, ".%u", bugFix ); } // Convert the version stage and non-release revision number. switch( stage ) { case kVersionStageDevelopment: s += sprintf( s, "d%u", revision ); break; case kVersionStageAlpha: s += sprintf( s, "a%u", revision ); break; case kVersionStageBeta: s += sprintf( s, "b%u", revision ); break; case kVersionStageFinal: // A non-release revision of zero is a special case indicating the software is GM (at the golden master // stage) and therefore, the non-release revision should not be added to the string. if( revision != 0 ) { s += sprintf( s, "f%u", revision ); } break; default: dlog( kDebugLevelError, "invalid NumVersion stage (0x%02X)\n", stage ); break; } return( inString ); } //=========================================================================================================================== // DebugTaskLevel //=========================================================================================================================== DEBUG_EXPORT uint32_t DebugTaskLevel( void ) { uint32_t level; level = 0; #if( TARGET_OS_VXWORKS ) if( intContext() ) { level |= ( ( 1 << kDebugInterruptLevelShift ) & kDebugInterruptLevelMask ); } #endif return( level ); } #if( TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE ) //=========================================================================================================================== // DebugWinEnableConsole //=========================================================================================================================== #pragma warning( disable:4311 ) static void DebugWinEnableConsole( void ) { static bool sConsoleEnabled = false; BOOL result; int fileHandle; FILE * file; int err; if( sConsoleEnabled ) { goto exit; } // Create console window. result = AllocConsole(); require_quiet( result, exit ); // Redirect stdin to the console stdin. fileHandle = _open_osfhandle( (long) GetStdHandle( STD_INPUT_HANDLE ), _O_TEXT ); #if( defined( __MWERKS__ ) ) file = __handle_reopen( (unsigned long) fileHandle, "r", stdin ); require_quiet( file, exit ); #else file = _fdopen( fileHandle, "r" ); require_quiet( file, exit ); *stdin = *file; #endif err = setvbuf( stdin, NULL, _IONBF, 0 ); require_noerr_quiet( err, exit ); // Redirect stdout to the console stdout. fileHandle = _open_osfhandle( (long) GetStdHandle( STD_OUTPUT_HANDLE ), _O_TEXT ); #if( defined( __MWERKS__ ) ) file = __handle_reopen( (unsigned long) fileHandle, "w", stdout ); require_quiet( file, exit ); #else file = _fdopen( fileHandle, "w" ); require_quiet( file, exit ); *stdout = *file; #endif err = setvbuf( stdout, NULL, _IONBF, 0 ); require_noerr_quiet( err, exit ); // Redirect stderr to the console stdout. fileHandle = _open_osfhandle( (long) GetStdHandle( STD_OUTPUT_HANDLE ), _O_TEXT ); #if( defined( __MWERKS__ ) ) file = __handle_reopen( (unsigned long) fileHandle, "w", stderr ); require_quiet( file, exit ); #else file = _fdopen( fileHandle, "w" ); require_quiet( file, exit ); *stderr = *file; #endif err = setvbuf( stderr, NULL, _IONBF, 0 ); require_noerr_quiet( err, exit ); sConsoleEnabled = true; exit: return; } #pragma warning( default:4311 ) #endif // TARGET_OS_WIN32 && !TARGET_OS_WINDOWS_CE #if( TARGET_OS_WIN32 ) //=========================================================================================================================== // DebugWinCharToTCharString //=========================================================================================================================== static TCHAR * DebugWinCharToTCharString( const char * inCharString, size_t inCharCount, TCHAR * outTCharString, size_t inTCharCountMax, size_t * outTCharCount ) { const char * src; TCHAR * dst; TCHAR * end; if( inCharCount == kSizeCString ) { inCharCount = strlen( inCharString ); } src = inCharString; dst = outTCharString; if( inTCharCountMax > 0 ) { inTCharCountMax -= 1; if( inTCharCountMax > inCharCount ) { inTCharCountMax = inCharCount; } end = dst + inTCharCountMax; while( dst < end ) { *dst++ = (TCHAR) *src++; } *dst = 0; } if( outTCharCount ) { *outTCharCount = (size_t)( dst - outTCharString ); } return( outTCharString ); } #endif #if 0 #pragma mark - #pragma mark == Debugging == #endif //=========================================================================================================================== // DebugServicesTest //=========================================================================================================================== DEBUG_EXPORT OSStatus DebugServicesTest( void ) { OSStatus err; char s[ 512 ]; uint8_t * p; uint8_t data[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xA0, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, 0x81, 0x91, 0xA1 }; debug_initialize( kDebugOutputTypeMetaConsole ); // check's check( 0 && "SHOULD SEE: check" ); check( 1 && "SHOULD *NOT* SEE: check (valid)" ); check_string( 0, "SHOULD SEE: check_string" ); check_string( 1, "SHOULD *NOT* SEE: check_string (valid)" ); check_noerr( -123 ); check_noerr( 10038 ); check_noerr( 22 ); check_noerr( 0 ); check_noerr_string( -6712, "SHOULD SEE: check_noerr_string" ); check_noerr_string( 0, "SHOULD *NOT* SEE: check_noerr_string (valid)" ); check_translated_errno( 0 >= 0 && "SHOULD *NOT* SEE", -384, -999 ); check_translated_errno( -1 >= 0 && "SHOULD SEE", -384, -999 ); check_translated_errno( -1 >= 0 && "SHOULD SEE", 0, -999 ); check_ptr_overlap( "SHOULD *NOT* SEE" ? 10 : 0, 10, 22, 10 ); check_ptr_overlap( "SHOULD SEE" ? 10 : 0, 10, 5, 10 ); check_ptr_overlap( "SHOULD SEE" ? 10 : 0, 10, 12, 6 ); check_ptr_overlap( "SHOULD SEE" ? 12 : 0, 6, 10, 10 ); check_ptr_overlap( "SHOULD SEE" ? 12 : 0, 10, 10, 10 ); check_ptr_overlap( "SHOULD *NOT* SEE" ? 22 : 0, 10, 10, 10 ); check_ptr_overlap( "SHOULD *NOT* SEE" ? 10 : 0, 10, 20, 10 ); check_ptr_overlap( "SHOULD *NOT* SEE" ? 20 : 0, 10, 10, 10 ); // require's require( 0 && "SHOULD SEE", require1 ); { err = kResponseErr; goto exit; } require1: require( 1 && "SHOULD *NOT* SEE", require2 ); goto require2Good; require2: { err = kResponseErr; goto exit; } require2Good: require_string( 0 && "SHOULD SEE", require3, "SHOULD SEE: require_string" ); { err = kResponseErr; goto exit; } require3: require_string( 1 && "SHOULD *NOT* SEE", require4, "SHOULD *NOT* SEE: require_string (valid)" ); goto require4Good; require4: { err = kResponseErr; goto exit; } require4Good: require_quiet( 0 && "SHOULD SEE", require5 ); { err = kResponseErr; goto exit; } require5: require_quiet( 1 && "SHOULD *NOT* SEE", require6 ); goto require6Good; require6: { err = kResponseErr; goto exit; } require6Good: require_noerr( -1, require7 ); { err = kResponseErr; goto exit; } require7: require_noerr( 0, require8 ); goto require8Good; require8: { err = kResponseErr; goto exit; } require8Good: require_noerr_string( -2, require9, "SHOULD SEE: require_noerr_string"); { err = kResponseErr; goto exit; } require9: require_noerr_string( 0, require10, "SHOULD *NOT* SEE: require_noerr_string (valid)" ); goto require10Good; require10: { err = kResponseErr; goto exit; } require10Good: require_noerr_action_string( -3, require11, dlog( kDebugLevelMax, "action 1 (expected)\n" ), "require_noerr_action_string" ); { err = kResponseErr; goto exit; } require11: require_noerr_action_string( 0, require12, dlog( kDebugLevelMax, "action 2\n" ), "require_noerr_action_string (valid)" ); goto require12Good; require12: { err = kResponseErr; goto exit; } require12Good: require_noerr_quiet( -4, require13 ); { err = kResponseErr; goto exit; } require13: require_noerr_quiet( 0, require14 ); goto require14Good; require14: { err = kResponseErr; goto exit; } require14Good: require_noerr_action( -5, require15, dlog( kDebugLevelMax, "SHOULD SEE: action 3 (expected)\n" ) ); { err = kResponseErr; goto exit; } require15: require_noerr_action( 0, require16, dlog( kDebugLevelMax, "SHOULD *NOT* SEE: action 4\n" ) ); goto require16Good; require16: { err = kResponseErr; goto exit; } require16Good: require_noerr_action_quiet( -4, require17, dlog( kDebugLevelMax, "SHOULD SEE: action 5 (expected)\n" ) ); { err = kResponseErr; goto exit; } require17: require_noerr_action_quiet( 0, require18, dlog( kDebugLevelMax, "SHOULD *NOT* SEE: action 6\n" ) ); goto require18Good; require18: { err = kResponseErr; goto exit; } require18Good: require_action( 0 && "SHOULD SEE", require19, dlog( kDebugLevelMax, "SHOULD SEE: action 7 (expected)\n" ) ); { err = kResponseErr; goto exit; } require19: require_action( 1 && "SHOULD *NOT* SEE", require20, dlog( kDebugLevelMax, "SHOULD *NOT* SEE: action 8\n" ) ); goto require20Good; require20: { err = kResponseErr; goto exit; } require20Good: require_action_quiet( 0, require21, dlog( kDebugLevelMax, "SHOULD SEE: action 9 (expected)\n" ) ); { err = kResponseErr; goto exit; } require21: require_action_quiet( 1, require22, dlog( kDebugLevelMax, "SHOULD *NOT* SEE: action 10\n" ) ); goto require22Good; require22: { err = kResponseErr; goto exit; } require22Good: require_action_string( 0, require23, dlog( kDebugLevelMax, "SHOULD SEE: action 11 (expected)\n" ), "SHOULD SEE: require_action_string" ); { err = kResponseErr; goto exit; } require23: require_action_string( 1, require24, dlog( kDebugLevelMax, "SHOULD *NOT* SEE: action 12\n" ), "SHOULD *NOT* SEE: require_action_string" ); goto require24Good; require24: { err = kResponseErr; goto exit; } require24Good: #if( defined( __MWERKS__ ) ) #if( defined( __cplusplus ) && __option( exceptions ) ) #define COMPILER_HAS_EXCEPTIONS 1 #else #define COMPILER_HAS_EXCEPTIONS 0 #endif #else #if( defined( __cplusplus ) ) #define COMPILER_HAS_EXCEPTIONS 1 #else #define COMPILER_HAS_EXCEPTIONS 0 #endif #endif #if( COMPILER_HAS_EXCEPTIONS ) try { require_throw( 1 && "SHOULD *NOT* SEE" ); require_throw( 0 && "SHOULD SEE" ); } catch( ... ) { goto require26Good; } { err = kResponseErr; goto exit; } require26Good: #endif // translate_errno err = translate_errno( 1 != -1, -123, -567 ); require( ( err == 0 ) && "SHOULD *NOT* SEE", exit ); err = translate_errno( -1 != -1, -123, -567 ); require( ( err == -123 ) && "SHOULD *NOT* SEE", exit ); err = translate_errno( -1 != -1, 0, -567 ); require( ( err == -567 ) && "SHOULD *NOT* SEE", exit ); // debug_string debug_string( "debug_string" ); // DebugSNPrintF DebugSNPrintF( s, sizeof( s ), "%d", 1234 ); require_action( strcmp( s, "1234" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%X", 0x2345 ); require_action( strcmp( s, "2345" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%#s", "\05test" ); require_action( strcmp( s, "test" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%##s", "\03www\05apple\03com" ); require_action( strcmp( s, "www.apple.com." ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%ld", (long) INT32_C( 2147483647 ) ); require_action( strcmp( s, "2147483647" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%lu", (unsigned long) UINT32_C( 4294967295 ) ); require_action( strcmp( s, "4294967295" ) == 0, exit, err = -1 ); #if( TYPE_LONGLONG_NATIVE ) DebugSNPrintF( s, sizeof( s ), "%lld", (long_long_compat) INT64_C( 9223372036854775807 ) ); require_action( strcmp( s, "9223372036854775807" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%lld", (long_long_compat) INT64_C( -9223372036854775807 ) ); require_action( strcmp( s, "-9223372036854775807" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%llu", (unsigned_long_long_compat) UINT64_C( 18446744073709551615 ) ); require_action( strcmp( s, "18446744073709551615" ) == 0, exit, err = -1 ); #endif DebugSNPrintF( s, sizeof( s ), "%lb", (unsigned long) binary_32( 01111011, 01111011, 01111011, 01111011 ) ); require_action( strcmp( s, "1111011011110110111101101111011" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%C", 0x41624364 ); // 'AbCd' require_action( strcmp( s, "AbCd" ) == 0, exit, err = -1 ); #if( defined( MDNS_DEBUGMSGS ) ) { mDNSAddr maddr; memset( &maddr, 0, sizeof( maddr ) ); maddr.type = mDNSAddrType_IPv4; maddr.ip.v4.b[ 0 ] = 127; maddr.ip.v4.b[ 1 ] = 0; maddr.ip.v4.b[ 2 ] = 0; maddr.ip.v4.b[ 3 ] = 1; DebugSNPrintF( s, sizeof( s ), "%#a", &maddr ); require_action( strcmp( s, "127.0.0.1" ) == 0, exit, err = -1 ); memset( &maddr, 0, sizeof( maddr ) ); maddr.type = mDNSAddrType_IPv6; maddr.ip.v6.b[ 0 ] = 0xFE; maddr.ip.v6.b[ 1 ] = 0x80; maddr.ip.v6.b[ 15 ] = 0x01; DebugSNPrintF( s, sizeof( s ), "%#a", &maddr ); require_action( strcmp( s, "FE80:0000:0000:0000:0000:0000:0000:0001" ) == 0, exit, err = -1 ); } #endif #if( AF_INET ) { struct sockaddr_in sa4; memset( &sa4, 0, sizeof( sa4 ) ); sa4.sin_family = AF_INET; p = (uint8_t *) &sa4.sin_port; p[ 0 ] = (uint8_t)( ( 80 >> 8 ) & 0xFF ); p[ 1 ] = (uint8_t)( 80 & 0xFF ); p = (uint8_t *) &sa4.sin_addr.s_addr; p[ 0 ] = (uint8_t)( ( INADDR_LOOPBACK >> 24 ) & 0xFF ); p[ 1 ] = (uint8_t)( ( INADDR_LOOPBACK >> 16 ) & 0xFF ); p[ 2 ] = (uint8_t)( ( INADDR_LOOPBACK >> 8 ) & 0xFF ); p[ 3 ] = (uint8_t)( INADDR_LOOPBACK & 0xFF ); DebugSNPrintF( s, sizeof( s ), "%##a", &sa4 ); require_action( strcmp( s, "127.0.0.1:80" ) == 0, exit, err = -1 ); } #endif #if( AF_INET6 ) { struct sockaddr_in6 sa6; memset( &sa6, 0, sizeof( sa6 ) ); sa6.sin6_family = AF_INET6; p = (uint8_t *) &sa6.sin6_port; p[ 0 ] = (uint8_t)( ( 80 >> 8 ) & 0xFF ); p[ 1 ] = (uint8_t)( 80 & 0xFF ); sa6.sin6_addr.s6_addr[ 0 ] = 0xFE; sa6.sin6_addr.s6_addr[ 1 ] = 0x80; sa6.sin6_addr.s6_addr[ 15 ] = 0x01; sa6.sin6_scope_id = 2; DebugSNPrintF( s, sizeof( s ), "%##a", &sa6 ); require_action( strcmp( s, "[FE80:0000:0000:0000:0000:0000:0000:0001%2]:80" ) == 0, exit, err = -1 ); } #endif // Unicode DebugSNPrintF(s, sizeof(s), "%.*s", 4, "tes" ); require_action( strcmp( s, "tes" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 4, "test" ); require_action( strcmp( s, "test" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 4, "testing" ); require_action( strcmp( s, "test" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 4, "te\xC3\xA9" ); require_action( strcmp( s, "te\xC3\xA9" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 4, "te\xC3\xA9ing" ); require_action( strcmp( s, "te\xC3\xA9" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 4, "tes\xC3\xA9ing" ); require_action( strcmp( s, "tes" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 4, "t\xed\x9f\xbf" ); require_action( strcmp( s, "t\xed\x9f\xbf" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 4, "t\xed\x9f\xbfing" ); require_action( strcmp( s, "t\xed\x9f\xbf" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 4, "te\xed\x9f\xbf" ); require_action( strcmp( s, "te" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 4, "te\xed\x9f\xbfing" ); require_action( strcmp( s, "te" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 7, "te\xC3\xA9\xed\x9f\xbfing" ); require_action( strcmp( s, "te\xC3\xA9\xed\x9f\xbf" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 6, "te\xC3\xA9\xed\x9f\xbfing" ); require_action( strcmp( s, "te\xC3\xA9" ) == 0, exit, err = kResponseErr ); DebugSNPrintF(s, sizeof(s), "%.*s", 5, "te\xC3\xA9\xed\x9f\xbfing" ); require_action( strcmp( s, "te\xC3\xA9" ) == 0, exit, err = kResponseErr ); #if( TARGET_RT_BIG_ENDIAN ) DebugSNPrintF( s, sizeof( s ), "%S", "\x00" "a" "\x00" "b" "\x00" "c" "\x00" "d" "\x00" "\x00" ); require_action( strcmp( s, "abcd" ) == 0, exit, err = -1 ); #else DebugSNPrintF( s, sizeof( s ), "%S", "a" "\x00" "b" "\x00" "c" "\x00" "d" "\x00" "\x00" "\x00" ); require_action( strcmp( s, "abcd" ) == 0, exit, err = -1 ); #endif DebugSNPrintF( s, sizeof( s ), "%S", "\xFE\xFF" "\x00" "a" "\x00" "b" "\x00" "c" "\x00" "d" "\x00" "\x00" ); // Big Endian BOM require_action( strcmp( s, "abcd" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%S", "\xFF\xFE" "a" "\x00" "b" "\x00" "c" "\x00" "d" "\x00" "\x00" "\x00" ); // Little Endian BOM require_action( strcmp( s, "abcd" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%#S", "\x00" "a" "\x00" "b" "\x00" "c" "\x00" "d" "\x00" "\x00" ); // Big Endian require_action( strcmp( s, "abcd" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%##S", "a" "\x00" "b" "\x00" "c" "\x00" "d" "\x00" "\x00" "\x00" ); // Little Endian require_action( strcmp( s, "abcd" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%.*S", 4, "\xFE\xFF" "\x00" "a" "\x00" "b" "\x00" "c" "\x00" "d" ); // Big Endian BOM require_action( strcmp( s, "abc" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%.*S", 4, "\xFF\xFE" "a" "\x00" "b" "\x00" "c" "\x00" "d" "\x00" ); // Little Endian BOM require_action( strcmp( s, "abc" ) == 0, exit, err = -1 ); #if( TARGET_RT_BIG_ENDIAN ) DebugSNPrintF( s, sizeof( s ), "%.*S", 3, "\x00" "a" "\x00" "b" "\x00" "c" "\x00" "d" ); require_action( strcmp( s, "abc" ) == 0, exit, err = -1 ); #else DebugSNPrintF( s, sizeof( s ), "%.*S", 3, "a" "\x00" "b" "\x00" "c" "\x00" "d" "\x00" ); require_action( strcmp( s, "abc" ) == 0, exit, err = -1 ); #endif DebugSNPrintF( s, sizeof( s ), "%#.*S", 3, "\x00" "a" "\x00" "b" "\x00" "c" "\x00" "d" ); // Big Endian require_action( strcmp( s, "abc" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%##.*S", 3, "a" "\x00" "b" "\x00" "c" "\x00" "d" "\x00" ); // Little Endian require_action( strcmp( s, "abc" ) == 0, exit, err = -1 ); // Misc DebugSNPrintF( s, sizeof( s ), "%U", "\x10\xb8\xa7\x6b" "\xad\x9d" "\xd1\x11" "\x80\xb4" "\x00\xc0\x4f\xd4\x30\xc8" ); require_action( strcmp( s, "6ba7b810-9dad-11d1-80b4-00c04fd430c8" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%m", 0 ); require_action( strcmp( s, "no error" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "%lm", (long) 0 ); require_action( strcmp( s, "no error" ) == 0, exit, err = -1 ); DebugSNPrintF( s, sizeof( s ), "\"%H\"", "\x6b\xa7\xb8\x10\x9d\xad\x11\xd1\x80\xb4\x00\xc0\x4f\xd4\x30\xc8", 16, 16 ); DebugPrintF( kDebugLevelMax, "%s\n\n", s ); DebugSNPrintF( s, sizeof( s ), "\"%H\"", "\x6b\xa7\xb8\x10\x9d\xad\x11\xd1\x80\xb4\x00\xc0\x4f\xd4\x30\xc8" "\x6b\xa7\xb8\x10\x9d\xad\x11\xd1\x80\xb4\x00\xc0\x4f\xd4\x30\xc8", 32, 32 ); DebugPrintF( kDebugLevelMax, "%s\n\n", s ); DebugSNPrintF( s, sizeof( s ), "\"%H\"", "\x6b\xa7", 2, 2 ); DebugPrintF( kDebugLevelMax, "%s\n\n", s ); // Hex Dumps s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, "My Label", kSizeCString, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNone, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, NULL, 0, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNoAddress | kDebugFlagsNoOffset, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, "My Label", kSizeCString, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNoAddress | kDebugFlagsNoOffset, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, "My Label", kSizeCString, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNoAddress, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, NULL, 0, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNoOffset, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, NULL, 0, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNoAddress, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, NULL, 0, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNoOffset, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, NULL, 0, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNoByteCount, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, NULL, 0, 0, NULL, 0, "\x41\x62\x43\x64", "\x41\x62\x43\x64", 4, // 'AbCd' kDebugFlagsNoAddress | kDebugFlagsNoOffset | kDebugFlagsNoNewLine | kDebugFlagsNo32BitSeparator | kDebugFlagsNo16ByteHexPad | kDebugFlagsNoByteCount, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 0, NULL, 0, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNoAddress | kDebugFlagsNoOffset | kDebugFlagsNoASCII | kDebugFlagsNoNewLine | kDebugFlags16BitSeparator | kDebugFlagsNo32BitSeparator | kDebugFlagsNo16ByteHexPad | kDebugFlagsNoByteCount, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); s[ 0 ] = '\0'; DebugHexDump( kDebugLevelMax, 8, NULL, 0, 0, NULL, 0, data, data, sizeof( data ), kDebugFlagsNone, s, sizeof( s ) ); DebugPrintF( kDebugLevelMax, "%s\n", s ); // dlog's dlog( kDebugLevelNotice, "dlog\n" ); dlog( kDebugLevelNotice, "dlog integer: %d\n", 123 ); dlog( kDebugLevelNotice, "dlog string: \"%s\"\n", "test string" ); dlogmem( kDebugLevelNotice, data, sizeof( data ) ); // Done DebugPrintF( kDebugLevelMax, "\n\nALL TESTS DONE\n\n" ); err = kNoErr; exit: if( err ) { DebugPrintF( kDebugLevelMax, "\n\n### TEST FAILED ###\n\n" ); } return( err ); } #endif // DEBUG