Catching SIGSEGV exception - c

Question

I'm trying to use an exception handler to catch bad memory access but I'm not entirely sure how to go about doing it. I tried registering it with sigaction but my handler isn't triggering..
Old code
#include <stdio.h>
#include <signal.h>
void handler(int sig)
{
//exception should land here
printf("caught exception");
}
int main(int argc, const char * argv[]) {
struct sigaction act;
act.sa_flags = SA_SIGINFO;
sigemptyset(&act.sa_mask);
act.sa_handler = handler;
if(sigaction(SIGSEGV, &act, NULL)==-1){
printf("Could not register handler");
}else{
printf("handler registered\n");
}
*(int*)0 = 0;//throw exception
return 0;
}
And once inside the handler, how can I read the thread context registers?
I'm also on a MacOS so I'm unsure if there's any OS specific implementations.
Edit: New Code
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#define _XOPEN_SOURCE 600
#include <ucontext.h>
void handler(int sig, siginfo_t *info, void *uc)
{
(void) sig;
write (STDOUT_FILENO, "Caught exception\n", 17);
struct ucontext* mc = (struct ucontext*)uc;
}
int main(int argc, const char * argv[]) {
struct sigaction act;
act.sa_flags = SA_SIGINFO;
sigemptyset(&act.sa_mask);
act.sa_handler = handler;
if(sigaction(SIGSEGV, &act, NULL)==-1){
printf("Could not register handler");
}else{
printf("handler registered\n");
}
raise (SIGSEGV);
return 0;
}
When I included ucontext.h my compiler through this error
#else /* !_XOPEN_SOURCE */
#error The deprecated ucontext routines require _XOPEN_SOURCE to be defined
#endif /* _XOPEN_SOURCE */
Which I resolved by defining _XOPEN_SOURCE
But the compiler still doesn't know what ucontext is because I'm not getting any intellisence.. I might have to define the structure myself
Edit: Since I was on M1 I was compiling form ARM instead of x86_64 and ucontext and mcontext both have to use the 64bit variants..

Answer 1

Undefined behavior is not reliable:
Instead of relying on it, send a signal to the calling process with raise():
raise (SIGSEGV);
So the code becomes:
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
static void func (int signo, siginfo_t *info, void *context);
{
write (STDOUT_FILENO, "Caught exception\n", 17);
/* Restores the default handler. This is the only
* portable use of signal().
*/
signal (sig, SIG_DFL);
raise (sig);
}
int main (int argc, char *argv[])
{
struct sigaction act;
act.sa_flags = SA_SIGINFO;
/* Upon successful completion, sigemptyset() shall return 0;
* otherwise, it shall return -1 and set errno to indicate the error.
*/
if (sigemptyset (&act.sa_mask) == -1) {
perror ("sigemptyset()");
return EXIT_FAILURE;
}
act.sa_sigaction = handler;
if (sigaction (SIGSEGV, &act, NULL) == -1) {
fprintf (stderr, "Could not register handler\n");
} else {
fprintf (stderr, "handler registered\n");
}
raise (SIGSEGV);
return EXIT_SUCCESS;
}
Output:
handler registered
caught exception
Print error messages to stderr:
//printf ("Could not register handler\n");
fprintf (stderr, "Could not register handler.\n");
Do not call async-signal-unsafe functions in signal handlers:
Neither the C standard, nor the POSIX standard specifies printf() to be async-signal-safe, which means that it can not be safely called inside a signal handler.
Though,the POSIX standard does specify write() to be async-signal safe. So printf() should be replaced with it.
// printf ("Caught exception\n");
write (STDOUT_FILENO, "Caught exception\n", 17);
Incorrect declaration of handler():
void handler(int sig) is not correct if SA_SIGINFO is set: "If SA_SIGINFO is set and the signal is caught, the signal-catching function shall be entered as: void func(int signo, siginfo_t *info, void *context);" - #AndrewHenle
//void func (int signo);
void func(int signo, siginfo_t *info, void *context);
Assign handler() to the correct member:
The sigaction structure is defined as something like:
struct sigaction {
void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
void (*sa_restorer)(void);
};
When you use the SA_SIGINFO flag, you need to assign the signal handling function to .sa_sigaction instead of .sa_handler.
// act.sa_handler = handler;
sig.sa_sigaction = handler;

Answer 2

Your first question appears to have been answered so I won't get further into it. As for your second issue, Apple has its own definition of mcontext and ucontext specifically mcontext64 and ucontex64. Additionally, You're compiling for ARM64 instead of x86_64, hence why those registers would no longer exist in your compiled binary.
Go into your Build Settings->Architectures
Remove the standard architecture and replace it with x86_64, your handler should then be able to access the registers.