在 C 中，是否可以转发可变参数函数的调用？如中，
int my_printf(char *fmt, ...) {
fprintf(stderr, "Calling printf with fmt %s", fmt);
return SOMEHOW_INVOKE_LIBC_PRINTF;
}
在这种情况下，以上述方式转发调用显然不是绝对必要的（因为您可以以其他方式记录调用，或使用 vfprintf），但我正在处理的代码库需要包装器做一些实际工作，并且不'没有（也不能添加）类似于 vfprintf 的辅助函数。
[更新：根据迄今为止提供的答案，似乎有些混乱。用另一种方式来表达这个问题：一般来说，你可以包装一些任意可变参数函数而不修改该函数的定义。]
如果你没有一个类似的函数，vfprintf它需要 ava_list而不是可变数量的参数，你就不能这样做。看http://c-faq.com/varargs/handoff.html。
例子：
void myfun(const char *fmt, va_list argp) {
vfprintf(stderr, fmt, argp);
}
不是直接的，但是通常（您会在标准库中发现几乎普遍的情况）可变参数函数与varargs样式替代函数成对出现。例如printf/vprintf
v... 函数采用 va_list 参数，其实现通常由编译器特定的“宏魔法”完成，但您可以保证从这样的可变参数函数调用 v... 样式函数将起作用：
#include <stdarg.h>
int m_printf(char *fmt, ...)
{
int ret;
/* Declare a va_list type variable */
va_list myargs;
/* Initialise the va_list variable with the ... after fmt */
va_start(myargs, fmt);
/* Forward the '...' to vprintf */
ret = vprintf(fmt, myargs);
/* Clean up the va_list */
va_end(myargs);
return ret;
}
这应该会给你你正在寻找的效果。
如果您正在考虑编写可变参数库函数，您还应该考虑将 va_list 样式伴侣作为库的一部分。从您的问题中可以看出，它可以证明对您的用户有用。
C99 支持带有可变参数的宏；根据您的编译器，您可能可以声明一个执行您想要的宏：
#define my_printf(format, ...) \
do { \
fprintf(stderr, "Calling printf with fmt %s\n", format); \
some_other_variadac_function(format, ##__VA_ARGS__); \
} while(0)
不过，一般来说，最好的解决方案是使用您要包装的函数的va_list形式，如果存在的话。
几乎，使用可用的设施<stdarg.h>：
#include <stdarg.h>
int my_printf(char *format, ...)
{
va_list args;
va_start(args, format);
int r = vprintf(format, args);
va_end(args);
return r;
}
请注意，您将需要使用vprintfversion 而不是 plain printf。在这种情况下，没有办法直接调用可变参数函数而不使用va_list.
由于实际上不可能以一种好的方式转发此类调用，因此我们通过使用原始堆栈帧的副本设置一个新的堆栈帧来解决此问题。然而，这是高度不可移植的，并且会做出各种假设，例如代码使用帧指针和“标准”调用约定。
此头文件允许为 x86_64 和 i386 (GCC) 包装可变参数函数。它不适用于浮点参数，但应该直接扩展以支持这些参数。
#ifndef _VA_ARGS_WRAPPER_H
#define _VA_ARGS_WRAPPER_H
#include <limits.h>
#include <stdint.h>
#include <alloca.h>
#include <inttypes.h>
#include <string.h>
/* This macros allow wrapping variadic functions.
* Currently we don't care about floating point arguments and
* we assume that the standard calling conventions are used.
*
* The wrapper function has to start with VA_WRAP_PROLOGUE()
* and the original function can be called by
* VA_WRAP_CALL(function, ret), whereas the return value will
* be stored in ret. The caller has to provide ret
* even if the original function was returning void.
*/
#define __VA_WRAP_CALL_FUNC __attribute__ ((noinline))
#define VA_WRAP_CALL_COMMON() \
uintptr_t va_wrap_this_bp,va_wrap_old_bp; \
va_wrap_this_bp = va_wrap_get_bp(); \
va_wrap_old_bp = *(uintptr_t *) va_wrap_this_bp; \
va_wrap_this_bp += 2 * sizeof(uintptr_t); \
size_t volatile va_wrap_size = va_wrap_old_bp - va_wrap_this_bp; \
uintptr_t *va_wrap_stack = alloca(va_wrap_size); \
memcpy((void *) va_wrap_stack, \
(void *)(va_wrap_this_bp), va_wrap_size);
#if ( __WORDSIZE == 64 )
/* System V AMD64 AB calling convention */
static inline uintptr_t __attribute__((always_inline))
va_wrap_get_bp()
{
uintptr_t ret;
asm volatile ("mov %%rbp, %0":"=r"(ret));
return ret;
}
#define VA_WRAP_PROLOGUE() \
uintptr_t va_wrap_ret; \
uintptr_t va_wrap_saved_args[7]; \
asm volatile ( \
"mov %%rsi, (%%rax)\n\t" \
"mov %%rdi, 0x8(%%rax)\n\t" \
"mov %%rdx, 0x10(%%rax)\n\t" \
"mov %%rcx, 0x18(%%rax)\n\t" \
"mov %%r8, 0x20(%%rax)\n\t" \
"mov %%r9, 0x28(%%rax)\n\t" \
: \
:"a"(va_wrap_saved_args) \
);
#define VA_WRAP_CALL(func, ret) \
VA_WRAP_CALL_COMMON(); \
va_wrap_saved_args[6] = (uintptr_t)va_wrap_stack; \
asm volatile ( \
"mov (%%rax), %%rsi \n\t" \
"mov 0x8(%%rax), %%rdi \n\t" \
"mov 0x10(%%rax), %%rdx \n\t" \
"mov 0x18(%%rax), %%rcx \n\t" \
"mov 0x20(%%rax), %%r8 \n\t" \
"mov 0x28(%%rax), %%r9 \n\t" \
"mov $0, %%rax \n\t" \
"call *%%rbx \n\t" \
: "=a" (va_wrap_ret) \
: "b" (func), "a" (va_wrap_saved_args) \
: "%rcx", "%rdx", \
"%rsi", "%rdi", "%r8", "%r9", \
"%r10", "%r11", "%r12", "%r14", \
"%r15" \
); \
ret = (typeof(ret)) va_wrap_ret;
#else
/* x86 stdcall */
static inline uintptr_t __attribute__((always_inline))
va_wrap_get_bp()
{
uintptr_t ret;
asm volatile ("mov %%ebp, %0":"=a"(ret));
return ret;
}
#define VA_WRAP_PROLOGUE() \
uintptr_t va_wrap_ret;
#define VA_WRAP_CALL(func, ret) \
VA_WRAP_CALL_COMMON(); \
asm volatile ( \
"mov %2, %%esp \n\t" \
"call *%1 \n\t" \
: "=a"(va_wrap_ret) \
: "r" (func), \
"r"(va_wrap_stack) \
: "%ebx", "%ecx", "%edx" \
); \
ret = (typeof(ret))va_wrap_ret;
#endif
#endif
最后，您可以像这样包装调用：
int __VA_WRAP_CALL_FUNC wrap_printf(char *str, ...)
{
VA_WRAP_PROLOGUE();
int ret;
VA_WRAP_CALL(printf, ret);
printf("printf returned with %d \n", ret);
return ret;
}
gcc 提供了一个可以做到这一点的扩展：__builtin_apply和亲戚。请参阅gcc 手册中的构造函数调用。
一个例子：
#include <stdio.h>
int my_printf(const char *fmt, ...) {
void *args = __builtin_apply_args();
printf("Hello there! Format string is %s\n", fmt);
void *ret = __builtin_apply((void (*)())printf, args, 1000);
__builtin_return(ret);
}
int main(void) {
my_printf("%d %f %s\n", -37, 3.1415, "spam");
return 0;
}
文档中有一些注意事项，它可能无法在更复杂的情况下工作。而且您必须硬编码参数的最大大小（这里我使用了 1000）。但它可能是其他涉及用 C 或汇编语言剖析堆栈的方法的合理替代方案。
使用 vfprintf：
int my_printf(char *fmt, ...) {
va_list va;
int ret;
va_start(va, fmt);
ret = vfprintf(stderr, fmt, va);
va_end(va);
return ret;
}
无法转发此类函数调用，因为您可以检索原始堆栈元素的唯一位置是my_print(). 像这样包装调用的常用方法是有两个函数，一个只是将参数转换为各种varargs结构，另一个是实际操作这些结构。使用这样的双功能模型，您可以（例如）通过在withprintf()中初始化结构来包装，然后将它们传递给.my_printf()va_start()vfprintf()
是的，你可以做到，但它有点难看，你必须知道参数的最大数量。此外，如果您使用的架构不像 x86（例如，PowerPC）那样在堆栈上传递参数，您将必须知道是否使用“特殊”类型（double、float、altivec 等）以及是否使用所以，相应地处理它们。这可能很快就会很痛苦，但如果您使用的是 x86，或者如果原始函数具有明确定义且有限的边界，则它可以工作。 它仍然是一个 hack，用于调试目的。不要围绕它构建你的软件。无论如何，这是一个关于 x86 的工作示例：
#include <stdio.h>
#include <stdarg.h>
int old_variadic_function(int n, ...)
{
va_list args;
int i = 0;
va_start(args, n);
if(i++<n) printf("arg %d is 0x%x\n", i, va_arg(args, int));
if(i++<n) printf("arg %d is %g\n", i, va_arg(args, double));
if(i++<n) printf("arg %d is %g\n", i, va_arg(args, double));
va_end(args);
return n;
}
int old_variadic_function_wrapper(int n, ...)
{
va_list args;
int a1;
int a2;
int a3;
int a4;
int a5;
int a6;
int a7;
int a8;
/* Do some work, possibly with another va_list to access arguments */
/* Work done */
va_start(args, n);
a1 = va_arg(args, int);
a2 = va_arg(args, int);
a3 = va_arg(args, int);
a4 = va_arg(args, int);
a5 = va_arg(args, int);
a6 = va_arg(args, int);
a7 = va_arg(args, int);
va_end(args);
return old_variadic_function(n, a1, a2, a3, a4, a5, a6, a7, a8);
}
int main(void)
{
printf("Call 1: 1, 0x123\n");
old_variadic_function(1, 0x123);
printf("Call 2: 2, 0x456, 1.234\n");
old_variadic_function(2, 0x456, 1.234);
printf("Call 3: 3, 0x456, 4.456, 7.789\n");
old_variadic_function(3, 0x456, 4.456, 7.789);
printf("Wrapped call 1: 1, 0x123\n");
old_variadic_function_wrapper(1, 0x123);
printf("Wrapped call 2: 2, 0x456, 1.234\n");
old_variadic_function_wrapper(2, 0x456, 1.234);
printf("Wrapped call 3: 3, 0x456, 4.456, 7.789\n");
old_variadic_function_wrapper(3, 0x456, 4.456, 7.789);
return 0;
}
出于某种原因，您不能将浮点数与 va_arg 一起使用，gcc 表示它们已转换为双精度，但程序崩溃了。仅此一项就表明该解决方案是一种 hack，并且没有通用解决方案。在我的示例中，我假设参数的最大数量为 8，但您可以增加该数量。包装函数也只使用整数，但它与其他“普通”参数的工作方式相同，因为它们总是转换为整数。目标函数将知道它们的类型，但您的中间包装器不需要。包装器也不需要知道正确数量的参数，因为目标函数也会知道它。要进行有用的工作（除了记录通话），您可能必须同时了解两者。
不确定这是否有助于回答 OP 的问题，因为我不知道为什么在包装函数中使用类似于 vfprintf 的辅助函数的限制适用。我认为这里的关键问题是转发可变参数列表而不解释它们是困难的。可能的是执行格式化（使用类似于 vfprintf: vsnprintf 的辅助函数）并将格式化的输出转发到带有可变参数的包装函数（即不修改包装函数的定义）。所以，我们开始：
#include <stdio.h>
#include <stdarg.h>
int my_printf(char *fmt, ...)
{
if (fmt == NULL) {
/* Invalid format pointer */
return -1;
} else {
va_list args;
int len;
/* Initialize a variable argument list */
va_start(args, fmt);
/* Get length of format including arguments */
len = vsnprintf(NULL, 0, fmt, args);
/* End using variable argument list */
va_end(args);
if (len < 0) {
/* vsnprintf failed */
return -1;
} else {
/* Declare a character buffer for the formatted string */
char formatted[len + 1];
/* Initialize a variable argument list */
va_start(args, fmt);
/* Write the formatted output */
vsnprintf(formatted, sizeof(formatted), fmt, args);
/* End using variable argument list */
va_end(args);
/* Call the wrapped function using the formatted output and return */
fprintf(stderr, "Calling printf with fmt %s", fmt);
return printf("%s", formatted);
}
}
}
int main()
{
/* Expected output: Test
* Expected error: Calling printf with fmt Test
*/
my_printf("Test\n");
//printf("Test\n");
/* Expected output: Test
* Expected error: Calling printf with fmt %s
*/
my_printf("%s\n", "Test");
//printf("%s\n", "Test");
/* Expected output: %s
* Expected error: Calling printf with fmt %s
*/
my_printf("%s\n", "%s");
//printf("%s\n", "%s");
return 0;
}
我在这里遇到了这个解决方案。
已编辑：修正了 egmont 指出的错误
基本上有三种选择。
一种是不传递它，而是使用目标函数的可变参数实现而不传递省略号。另一种是使用可变参数宏。第三个选项是我缺少的所有东西。
我通常选择选项一，因为我觉得这很容易处理。选项二有一个缺点，因为调用可变参数宏有一些限制。
这是一些示例代码：
#include <stdio.h>
#include <stdarg.h>
#define Option_VariadicMacro(f, ...)\
printf("printing using format: %s", f);\
printf(f, __VA_ARGS__)
int Option_ResolveVariadicAndPassOn(const char * f, ... )
{
int r;
va_list args;
printf("printing using format: %s", f);
va_start(args, f);
r = vprintf(f, args);
va_end(args);
return r;
}
void main()
{
const char * f = "%s %s %s\n";
const char * a = "One";
const char * b = "Two";
const char * c = "Three";
printf("---- Normal Print ----\n");
printf(f, a, b, c);
printf("\n");
printf("---- Option_VariadicMacro ----\n");
Option_VariadicMacro(f, a, b, c);
printf("\n");
printf("---- Option_ResolveVariadicAndPassOn ----\n");
Option_ResolveVariadicAndPassOn(f, a, b, c);
printf("\n");
}
最好的方法是
static BOOL(__cdecl *OriginalVarArgsFunction)(BYTE variable1, char* format, ...)(0x12345678); //TODO: change address lolz
BOOL __cdecl HookedVarArgsFunction(BYTE variable1, char* format, ...)
{
BOOL res;
va_list vl;
va_start(vl, format);
// Get variable arguments count from disasm. -2 because of existing 'format', 'variable1'
uint32_t argCount = *((uint8_t*)_ReturnAddress() + 2) / sizeof(void*) - 2;
printf("arg count = %d\n", argCount);
// ((int( __cdecl* )(const char*, ...))&oldCode)(fmt, ...);
__asm
{
mov eax, argCount
test eax, eax
je noLoop
mov edx, vl
loop1 :
push dword ptr[edx + eax * 4 - 4]
sub eax, 1
jnz loop1
noLoop :
push format
push variable1
//lea eax, [oldCode] // oldCode - original function pointer
mov eax, OriginalVarArgsFunction
call eax
mov res, eax
mov eax, argCount
lea eax, [eax * 4 + 8] //+8 because 2 parameters (format and variable1)
add esp, eax
}
return res;
}