/********************************************************************* * _cprintf (MSVCRT.@) */ int CDECL _cprintf(const char* format, ...) { char buf[2048], *mem = buf; int written, resize = sizeof(buf), retval; __ms_va_list valist; __ms_va_start( valist, format ); /* There are two conventions for snprintf failing: * Return -1 if we truncated, or * Return the number of bytes that would have been written * The code below handles both cases */ while ((written = MSVCRT_vsnprintf( mem, resize, format, valist )) == -1 || written > resize) { resize = (written == -1 ? resize * 2 : written + 1); if (mem != buf) MSVCRT_free (mem); if (!(mem = MSVCRT_malloc(resize))) return MSVCRT_EOF; __ms_va_start( valist, format ); } __ms_va_end(valist); LOCK_CONSOLE; retval = _cputs( mem ); UNLOCK_CONSOLE; if (mem != buf) MSVCRT_free (mem); return retval; }
static void __cdecl output_string(const WCHAR *fmt, ...) { __ms_va_list va_args; __ms_va_start(va_args, fmt); output_formatstring(fmt, va_args); __ms_va_end(va_args); }
static int __cdecl _vsnwprintf_wrapper(wchar_t *str, size_t len, const wchar_t *format, ...) { int ret; __ms_va_list valist; __ms_va_start(valist, format); ret = _vsnwprintf(str, len, format, valist); __ms_va_end(valist); return ret; }
static int __cdecl _vscwprintf_wrapper(const wchar_t *format, ...) { int ret; __ms_va_list valist; __ms_va_start(valist, format); ret = p__vscwprintf(format, valist); __ms_va_end(valist); return ret; }
/********************************************************************* * fscanf (MSVCRT.@) */ int CDECL MSVCRT_fscanf(MSVCRT_FILE *file, const char *format, ...) { __ms_va_list valist; int res; __ms_va_start(valist, format); res = MSVCRT_vfscanf(file, format, valist); __ms_va_end(valist); return res; }
/********************************************************************* * _cscanf (MSVCRT.@) */ int CDECL _cscanf(const char *format, ...) { __ms_va_list valist; int res; __ms_va_start(valist, format); res = MSVCRT_vcscanf(format, valist); __ms_va_end(valist); return res; }
static int __cdecl _vsnwprintf_s_wrapper(wchar_t *str, size_t sizeOfBuffer, size_t count, const wchar_t *format, ...) { int ret; __ms_va_list valist; __ms_va_start(valist, format); ret = p__vsnwprintf_s(str, sizeOfBuffer, count, format, valist); __ms_va_end(valist); return ret; }
/********************************************************************* * swscanf (MSVCRT.@) */ int CDECL MSVCRT_swscanf(const MSVCRT_wchar_t *str, const MSVCRT_wchar_t *format, ...) { __ms_va_list valist; int res; __ms_va_start(valist, format); res = MSVCRT_vswscanf(str, format, valist); __ms_va_end(valist); return res; }
static int __cdecl vfwprintf_wrapper(FILE *file, const wchar_t *format, ...) { int ret; __ms_va_list valist; __ms_va_start(valist, format); ret = p_vfwprintf(0, file, format, NULL, valist); __ms_va_end(valist); return ret; }
/************************************************************************* * wnsprintfW (SHLWAPI.@) * * See wnsprintfA. */ int WINAPIV wnsprintfW(LPWSTR lpOut, int cchLimitIn, LPCWSTR lpFmt, ...) { __ms_va_list valist; INT res; __ms_va_start( valist, lpFmt ); res = wvnsprintfW( lpOut, cchLimitIn, lpFmt, valist ); __ms_va_end( valist ); return res; }
/*********************************************************************** * wsprintfW (USER32.@) */ INT WINAPIV wsprintfW( LPWSTR buffer, LPCWSTR spec, ... ) { __ms_va_list valist; INT res; __ms_va_start( valist, spec ); res = wvsnprintfW( buffer, 1024, spec, valist ); __ms_va_end( valist ); return ( res == -1 ) ? 1024 : res; }
static int __cdecl _vsnprintf_s_wrapper(char *str, size_t sizeOfBuffer, size_t count, const char *format, ...) { int ret; __ms_va_list valist; __ms_va_start(valist, format); ret = p_vsnprintf_s(0, str, sizeOfBuffer, count, format, NULL, valist); __ms_va_end(valist); return ret; }
/****************************************************************************** * TraceMessage [ADVAPI32.@] */ ULONG WINAPIV TraceMessage( TRACEHANDLE handle, ULONG flags, LPGUID guid, USHORT number, ... ) { __ms_va_list valist; ULONG ret; __ms_va_start( valist, number ); ret = TraceMessageVa( handle, flags, guid, number, valist ); __ms_va_end( valist ); return ret; }
static int __cdecl vswprintf_wrapper(unsigned __int64 options, wchar_t *str, size_t len, const wchar_t *format, ...) { int ret; __ms_va_list valist; __ms_va_start(valist, format); ret = p_vswprintf(options, str, len, format, NULL, valist); __ms_va_end(valist); return ret; }
/********************************************************************* * _cprintf (MSVCRT.@) */ int CDECL _cprintf(const char* format, ...) { int retval; __ms_va_list valist; __ms_va_start( valist, format ); retval = _vcprintf(format, valist); __ms_va_end(valist); return retval; }
/********************************************************************* * _cwprintf (MSVCRT.@) */ int CDECL _cwprintf(const MSVCRT_wchar_t* format, ...) { int retval; __ms_va_list valist; __ms_va_start( valist, format ); retval = _vcwprintf(format, valist); __ms_va_end(valist); return retval; }
static int CDECL taskkill_printfW(const WCHAR *msg, ...) { __ms_va_list va_args; int len; __ms_va_start(va_args, msg); len = taskkill_vprintfW(msg, va_args); __ms_va_end(va_args); return len; }
static void __cdecl output_message(unsigned int id, ...) { WCHAR fmt[1024]; __ms_va_list va_args; if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, ARRAY_SIZE(fmt))) { WINE_FIXME("LoadString failed with %d\n", GetLastError()); return; } __ms_va_start(va_args, id); output_formatstring(fmt, va_args); __ms_va_end(va_args); }
static int CDECL taskkill_message_printfW(int msg, ...) { __ms_va_list va_args; WCHAR msg_buffer[8192]; int len; LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer, sizeof(msg_buffer)/sizeof(WCHAR)); __ms_va_start(va_args, msg); len = taskkill_vprintfW(msg_buffer, va_args); __ms_va_end(va_args); return len; }
static void __cdecl output_write(UINT id, ...) { WCHAR fmt[1024]; __ms_va_list va_args; WCHAR *str; DWORD len, nOut, ret; if (Silent) return; if (!LoadStringW(GetModuleHandleW(NULL), id, fmt, sizeof(fmt)/sizeof(fmt[0]))) { WINE_FIXME("LoadString failed with %d\n", GetLastError()); return; } __ms_va_start(va_args, id); SetLastError(NO_ERROR); len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ALLOCATE_BUFFER, fmt, 0, 0, (LPWSTR)&str, 0, &va_args); __ms_va_end(va_args); if (len == 0 && GetLastError() != NO_ERROR) { WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(fmt)); return; } ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), str, len, &nOut, NULL); /* WriteConsole fails if its output is redirected to a file. * If this occurs, we should use an OEM codepage and call WriteFile. */ if (!ret) { DWORD lenA; char *strA; lenA = WideCharToMultiByte(GetConsoleOutputCP(), 0, str, len, NULL, 0, NULL, NULL); strA = HeapAlloc(GetProcessHeap(), 0, lenA); if (strA) { WideCharToMultiByte(GetConsoleOutputCP(), 0, str, len, strA, lenA, NULL, NULL); WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), strA, lenA, &nOut, FALSE); HeapFree(GetProcessHeap(), 0, strA); } } LocalFree(str); }
/* ========================================================================= * Output a unicode string. Ideally this will go to the console * and hence required WriteConsoleW to output it, however if file i/o is * redirected, it needs to be WriteFile'd using OEM (not ANSI) format * ========================================================================= */ static int __cdecl NETSTAT_wprintf(const WCHAR *format, ...) { static WCHAR *output_bufW = NULL; static char *output_bufA = NULL; static BOOL toConsole = TRUE; static BOOL traceOutput = FALSE; #define MAX_WRITECONSOLE_SIZE 65535 __ms_va_list parms; DWORD nOut; int len; DWORD res = 0; /* * Allocate buffer to use when writing to console * Note: Not freed - memory will be allocated once and released when * xcopy ends */ if (!output_bufW) output_bufW = HeapAlloc(GetProcessHeap(), 0, MAX_WRITECONSOLE_SIZE); if (!output_bufW) { WINE_FIXME("Out of memory - could not allocate 2 x 64K buffers\n"); return 0; } __ms_va_start(parms, format); len = wvsprintfW(output_bufW, format, parms); __ms_va_end(parms); /* Try to write as unicode all the time we think its a console */ if (toConsole) { res = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), output_bufW, len, &nOut, NULL); } /* If writing to console has failed (ever) we assume its file i/o so convert to OEM codepage and output */ if (!res) { BOOL usedDefaultChar = FALSE; DWORD convertedChars; toConsole = FALSE; /* * Allocate buffer to use when writing to file. Not freed, as above */ if (!output_bufA) output_bufA = HeapAlloc(GetProcessHeap(), 0, MAX_WRITECONSOLE_SIZE); if (!output_bufA) { WINE_FIXME("Out of memory - could not allocate 2 x 64K buffers\n"); return 0; } /* Convert to OEM, then output */ convertedChars = WideCharToMultiByte(GetConsoleOutputCP(), 0, output_bufW, len, output_bufA, MAX_WRITECONSOLE_SIZE, "?", &usedDefaultChar); WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), output_bufA, convertedChars, &nOut, FALSE); } /* Trace whether screen or console */ if (!traceOutput) { WINE_TRACE("Writing to console? (%d)\n", toConsole); traceOutput = TRUE; } return nOut; }
/* ========================================================================= * Output a formatted unicode string. Ideally this will go to the console * and hence required WriteConsoleW to output it, however if file i/o is * redirected, it needs to be WriteFile'd using OEM (not ANSI) format * ========================================================================= */ static int __cdecl XCOPY_wprintf(const WCHAR *format, ...) { static WCHAR *output_bufW = NULL; static char *output_bufA = NULL; static BOOL toConsole = TRUE; static BOOL traceOutput = FALSE; #define MAX_WRITECONSOLE_SIZE 65535 __ms_va_list parms; DWORD nOut; int len; DWORD res = 0; /* * Allocate buffer to use when writing to console * Note: Not freed - memory will be allocated once and released when * xcopy ends */ if (!output_bufW) output_bufW = HeapAlloc(GetProcessHeap(), 0, MAX_WRITECONSOLE_SIZE*sizeof(WCHAR)); if (!output_bufW) { WINE_FIXME("Out of memory - could not allocate 2 x 64K buffers\n"); return 0; } __ms_va_start(parms, format); SetLastError(NO_ERROR); len = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, format, 0, 0, output_bufW, MAX_WRITECONSOLE_SIZE/sizeof(*output_bufW), &parms); __ms_va_end(parms); if (len == 0 && GetLastError() != NO_ERROR) { WINE_FIXME("Could not format string: le=%u, fmt=%s\n", GetLastError(), wine_dbgstr_w(format)); return 0; } /* Try to write as unicode whenever we think it's a console */ if (toConsole) { res = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), output_bufW, len, &nOut, NULL); } /* If writing to console has failed (ever) we assume it's file i/o so convert to OEM codepage and output */ if (!res) { BOOL usedDefaultChar = FALSE; DWORD convertedChars; toConsole = FALSE; /* * Allocate buffer to use when writing to file. Not freed, as above */ if (!output_bufA) output_bufA = HeapAlloc(GetProcessHeap(), 0, MAX_WRITECONSOLE_SIZE); if (!output_bufA) { WINE_FIXME("Out of memory - could not allocate 2 x 64K buffers\n"); return 0; } /* Convert to OEM, then output */ convertedChars = WideCharToMultiByte(GetConsoleOutputCP(), 0, output_bufW, len, output_bufA, MAX_WRITECONSOLE_SIZE, "?", &usedDefaultChar); WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), output_bufA, convertedChars, &nOut, FALSE); } /* Trace whether screen or console */ if (!traceOutput) { WINE_TRACE("Writing to console? (%d)\n", toConsole); traceOutput = TRUE; } return nOut; }
/*********************************************************************** * ber_scanf (WLDAP32.@) * * Decode a berelement structure. * * PARAMS * berelement [I/O] Pointer to a berelement structure. * fmt [I] Format string. * ... [I] Pointers to values to be decoded. * * RETURNS * Success: Non-negative number. * Failure: LBER_ERROR * * NOTES * berelement must have been allocated with ber_init. This function * can be called multiple times to decode data. */ INT CDECL WLDAP32_ber_scanf( BerElement *berelement, PCHAR fmt, ... ) { #ifdef HAVE_LDAP __ms_va_list list; int ret = 0; char new_fmt[2]; new_fmt[1] = 0; __ms_va_start( list, fmt ); while (*fmt) { new_fmt[0] = *fmt++; switch(new_fmt[0]) { case 'a': { char **ptr = va_arg( list, char ** ); ret = ber_scanf( berelement, new_fmt, ptr ); break; } case 'b': case 'e': case 'i': { int *i = va_arg( list, int * ); ret = ber_scanf( berelement, new_fmt, i ); break; } case 't': { unsigned int *tag = va_arg( list, unsigned int * ); ret = ber_scanf( berelement, new_fmt, tag ); break; } case 'v': { char ***array = va_arg( list, char *** ); ret = ber_scanf( berelement, new_fmt, array ); break; } case 'B': { char **str = va_arg( list, char ** ); int *len = va_arg( list, int * ); ret = ber_scanf( berelement, new_fmt, str, len ); break; } case 'O': { struct berval **ptr = va_arg( list, struct berval ** ); ret = ber_scanf( berelement, new_fmt, ptr ); break; } case 'V': { struct berval ***array = va_arg( list, struct berval *** ); ret = ber_scanf( berelement, new_fmt, array ); break; } case 'n': case 'x': case '{': case '}': case '[': case ']': ret = ber_scanf( berelement, new_fmt ); break; default: FIXME( "Unknown format '%c'\n", new_fmt[0] ); ret = -1; break; } if (ret == -1) break; } __ms_va_end( list ); return ret; #else return LBER_ERROR; #endif }
/*********************************************************************** * NdrMesProcEncodeDecode [RPCRT4.@] */ void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC * pStubDesc, PFORMAT_STRING pFormat, ...) { /* pointer to start of stack where arguments start */ RPC_MESSAGE rpcMsg; MIDL_ES_MESSAGE *pEsMsg = Handle; /* size of stack */ unsigned short stack_size; /* header for procedure string */ const NDR_PROC_HEADER *pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0]; const RPC_CLIENT_INTERFACE *client_interface; __ms_va_list args; unsigned int number_of_params; ULONG_PTR arg_buffer[256]; TRACE("Handle %p, pStubDesc %p, pFormat %p, ...\n", Handle, pStubDesc, pFormat); /* Later NDR language versions probably won't be backwards compatible */ if (pStubDesc->Version > 0x50002) { FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version); RpcRaiseException(RPC_X_WRONG_STUB_VERSION); } client_interface = pStubDesc->RpcInterfaceInformation; pEsMsg->InterfaceId = client_interface->InterfaceId; if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS) { const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0]; stack_size = header_rpc->stack_size; pEsMsg->ProcNumber = header_rpc->proc_num; pFormat += sizeof(NDR_PROC_HEADER_RPC); } else { stack_size = pProcHeader->stack_size; pEsMsg->ProcNumber = pProcHeader->proc_num; pFormat += sizeof(NDR_PROC_HEADER); } if (pProcHeader->handle_type == RPC_FC_BIND_EXPLICIT) { switch (*pFormat) /* handle_type */ { case RPC_FC_BIND_PRIMITIVE: /* explicit primitive */ pFormat += sizeof(NDR_EHD_PRIMITIVE); break; case RPC_FC_BIND_GENERIC: /* explicit generic */ pFormat += sizeof(NDR_EHD_GENERIC); break; case RPC_FC_BIND_CONTEXT: /* explicit context */ pFormat += sizeof(NDR_EHD_CONTEXT); break; default: ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type); RpcRaiseException(RPC_X_BAD_STUB_DATA); } } TRACE("stack size: 0x%x\n", stack_size); TRACE("proc num: %d\n", pEsMsg->ProcNumber); memset(&rpcMsg, 0, sizeof(rpcMsg)); pEsMsg->StubMsg.RpcMsg = &rpcMsg; pEsMsg->StubMsg.StubDesc = pStubDesc; pEsMsg->StubMsg.pfnAllocate = pStubDesc->pfnAllocate; pEsMsg->StubMsg.pfnFree = pStubDesc->pfnFree; /* create the full pointer translation tables, if requested */ if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR) pEsMsg->StubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT); TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags); TRACE("stubdesc version = 0x%x\n", pStubDesc->Version); TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion); /* needed for conformance of top-level objects */ __ms_va_start( args, pFormat ); pEsMsg->StubMsg.StackTop = va_arg( args, unsigned char * ); __ms_va_end( args ); pFormat = convert_old_args( &pEsMsg->StubMsg, pFormat, stack_size, FALSE, arg_buffer, sizeof(arg_buffer), &number_of_params ); switch (pEsMsg->Operation) { case MES_ENCODE: pEsMsg->StubMsg.BufferLength = mes_proc_header_buffer_size(); client_do_args( &pEsMsg->StubMsg, pFormat, STUBLESS_CALCSIZE, NULL, number_of_params, NULL ); pEsMsg->ByteCount = pEsMsg->StubMsg.BufferLength - mes_proc_header_buffer_size(); es_data_alloc(pEsMsg, pEsMsg->StubMsg.BufferLength); mes_proc_header_marshal(pEsMsg); client_do_args( &pEsMsg->StubMsg, pFormat, STUBLESS_MARSHAL, NULL, number_of_params, NULL ); es_data_write(pEsMsg, pEsMsg->ByteCount); break; case MES_DECODE: mes_proc_header_unmarshal(pEsMsg); es_data_read(pEsMsg, pEsMsg->ByteCount); client_do_args( &pEsMsg->StubMsg, pFormat, STUBLESS_UNMARSHAL, NULL, number_of_params, NULL ); break; default: RpcRaiseException(RPC_S_INTERNAL_ERROR); return; } /* free the full pointer translation tables */ if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR) NdrFullPointerXlatFree(pEsMsg->StubMsg.FullPtrXlatTables); }
/*********************************************************************** * ber_printf (WLDAP32.@) * * Encode a berelement structure. * * PARAMS * berelement [I/O] Pointer to a berelement structure. * fmt [I] Format string. * ... [I] Values to encode. * * RETURNS * Success: Non-negative number. * Failure: LBER_ERROR * * NOTES * berelement must have been allocated with ber_alloc_t. This function * can be called multiple times to append data. */ INT WINAPIV WLDAP32_ber_printf( BerElement *berelement, PCHAR fmt, ... ) { #ifdef HAVE_LDAP __ms_va_list list; int ret = 0; char new_fmt[2]; new_fmt[1] = 0; __ms_va_start( list, fmt ); while (*fmt) { new_fmt[0] = *fmt++; switch(new_fmt[0]) { case 'b': case 'e': case 'i': { int i = va_arg( list, int ); ret = ber_printf( berelement, new_fmt, i ); break; } case 'o': case 's': { char *str = va_arg( list, char * ); ret = ber_printf( berelement, new_fmt, str ); break; } case 't': { unsigned int tag = va_arg( list, unsigned int ); ret = ber_printf( berelement, new_fmt, tag ); break; } case 'v': { char **array = va_arg( list, char ** ); ret = ber_printf( berelement, new_fmt, array ); break; } case 'V': { struct berval **array = va_arg( list, struct berval ** ); ret = ber_printf( berelement, new_fmt, array ); break; } case 'X': { char *str = va_arg( list, char * ); int len = va_arg( list, int ); new_fmt[0] = 'B'; /* 'X' is deprecated */ ret = ber_printf( berelement, new_fmt, str, len ); break; } case 'n': case '{': case '}': case '[': case ']': ret = ber_printf( berelement, new_fmt ); break; default: FIXME( "Unknown format '%c'\n", new_fmt[0] ); ret = -1; break; } if (ret == -1) break; } __ms_va_end( list ); return ret; #else return LBER_ERROR; #endif }