How can I capture [unix] signals in sync - c

Question

client:
static void get_bit(int pid, char c)
{
int bit;
int n;
int i;
n = 7;
i = 0;
while (n >= 0)
{
bit = (c >> n) & 1;
if (bit == 0)
kill(pid, SIGUSR1);
else
kill(pid, SIGUSR2);
usleep(50);
n--;
}
}
server:
static void sighandler(int sig, siginfo_t *info, void *context)
{
static int i = 0;
static pid_t client_pid = 0;
static unsigned char c = 0;
(void)context;
if (!client_pid)
client_pid = info->si_pid;
c |= (sig == SIGUSR2);
if (++i == 8)
{
i = 0;
if (!c)
{
kill(client_pid, SIGUSR2);
client_pid = 0;
return ;
}
ft_putchar_fd(c, 1);
c = 0;
kill(client_pid, SIGUSR1);
}
else
c <<= 1;
}
int main(int argc, char *argv[])
{
int pid;
struct sigaction act;
sigset_t set;
pid = getpid();
memset(&act, 0, sizeof act);
sigemptyset(&set);
sigaddset(&set, SIGUSR1);
sigaddset(&set, SIGUSR2);
act.sa_mask = set;
act.sa_flags = SA_SIGINFO;
act.sa_sigaction = sighandler;
ft_putnbr_fd(pid, 1);
write(1, "\n", 1);
sigaction(SIGUSR1, &act, NULL);
sigaction(SIGUSR2, &act, NULL);
while (1)
{
pause();
}
return (0);
}
Although I use masking, when the usleep gives a low value on the client, the signals are mixed. processing one signal(s) without processing another
The client sends the bits of the character sequentially and the server collects these bits
if bit is 1 SIGUSR2 is 0 then SIGUSR1 is used
If the signal is 1, the char is shifted to the left and the bit is collected and if it is done 8 times, 1 character is obtained.
Since the client sends the bits asynchronously, each event does not seem to run sequentially, or more than one event is running at the same time, so the same handler function is running more than once at the same time and the events overlap because they run almost simultaneously.
so the usleep is used and the other bit is sent during this time, usually after the event has finished (not guaranteed).
I used sa_mask to prevent this and I know that one of the 2 events must complete itself before it receives a signal. that is, when a signal comes to sigusr2 or sigusr1, if a signal has already been captured, blocked signals are processed after that signal is processed.
but it didn't work, when I run the program, I get good output for a while, then probably due to conflict in the handler, the bits get mixed up and print different characters.
to test https://github.com/murmurlab/ecole42kocaeli/tree/main/42cursus/mini_talk
$ make
$ ./server
> PID
$ ./client PID "$(cat a)"
allowed functions in my project
◦ signal
◦ sigemptyset
◦ sigaddset
◦ sigaction
◦ kill
◦ getpid
◦ pause
◦ sleep
◦ usleep
◦ exit
edit:
A sensible solution might be to send bits when the client receives a feedback signal from each server.