Problem - Kevin Tafuro

solution can likely be ported to some other processors as well, but the non-x86 systems
on which we have tested do not work (in particular, this trick does not work on
Apple Mac G3 or G4 systems). This solution also requires that you do not compile
your program using the optimization option to omit the frame pointer, -fomitframe-pointer,
because it depends on having the frame pointer available.
The second solution we have presented should work with any compiler and processor
combination. It works by adding an extra argument passed to the function that is
a “magic” value. When spc_next_varg( ) gets the next argument by calling va_arg( )
itself, it checks to see whether the value of the argument matches the “magic” value.
The need to add this extra “magic” argument is the reason for the VARARG_CALL_x
macros. We have chosen a magic value of 0xDEADBEEF here, but if a legitimate argument
with that value might be used, it can easily be changed to something else. Certainly,
the code provided here could also be easily modified to allow different
“magic” values to be used for different function calls.
Finally, note that both implementations of spc_next_varg( ) print an error message
to stderr and call abort( ) to terminate the program immediately. Handling this
error condition differently in your own program may take the form of throwing an
exception if you are using the code in C++, or calling a special handler function.
Anything except allowing the function to proceed can be done here. The error
should not necessarily be treated as fatal, but it certainly is serious.
See Also
Recipe 3.2
13.5 Performing Proper Signal Handling
Problem
Your program needs to handle asynchronous signals.
Solution
On Unix systems, it is often necessary to perform some amount of signal handling.
In particular, if a program receives a termination signal, it is often desirable to perform
some kind of cleanup before terminating the program—flushing in-memory
caches to disk, recording the event to a log file, and so on. Unfortunately, many programmers
do not perform their signal handling safely, which of course leads to possible
security vulnerabilities. Even more unfortunate is that there is no cookie-cutter
solution to writing safe signal handlers. Fortunately, following some easy guidelines
will help you write more secure signal-handling code.
712 | Chapter 13: Other Topics
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.