Can't use system call write() correctly - c

Question

The assignment is
Write a program in C/Posix (Linux environment) that synchronizes a parent process and his child process (using signals) that reads and write one by one numbers from 1 to n (given by the user) in the first position of a txt file.
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
int main(int argc, char const *argv[])
{
int n = atoi(argv[1]);
int i;
int fd = open("exercise.txt", O_RDWR | O_CREAT, 0777);
pid_t pid = fork();
if (!pid) {
for (i = 1; i <= (n / 2); i++) {
pause();
char c[2];
sprintf(c, "%d", i + 1);
write(fd, c, sizeof(c));
kill(pid, SIGUSR1);
}
}
else {
for (i = 1; i <= (n / 2); i++) {
char c[2];
sprintf(c, "%d", i);
write(fd, c, sizeof(c));
kill(pid, SIGUSR1);
pause();
}
}
return 0;
}
For each number I pass to my program I always find a txt file with just "1" written in it instead of 1234...n.
What did I do wrong?

Answer 1

The child process will immediately pause upon entering the first iteration of the loop, waiting to receive a signal.
In the first iteration of its loop, the parent process will write two bytes of data to the file, send the SIGUSR1 signal to the child process, and then itself pause, waiting to receive a signal.
The default action when receiving SIGUSR1 is to terminate the process.
pause() returns only when a signal was caught and the signal-catching function returned.
Thus the child process never does anything but possibly wait for a signal and certainly terminate almost immediately.
The parent process remains paused, waiting for a signal.
Some notes:
signal(7) for an overview of signals.
The instructions were, as far as I can tell, to write in one process, and read in the other. Your program attempts to write in both processes.
char c[2];
sprintf(c, "%d", i); /* or i + 1 */
c is only large enough to store strings of, at most, length 1 (optionally one character, plus the null-terminating byte, always). This risks Undefined Behaviour, as there will not be enough room in the buffer if the third argument to sprintf is outside the range [0, 9].
In the child process, pid will be 0 in kill(pid, SIGUSR1);. From kill(2):
If pid equals 0, then sig is sent to every process in the process group of the calling process.
Opening the file before forking, means the two processes share the same file description. Changing the file offset (by reading, writing, or seeking) in one process will change it in the other.
In any case, the instructions are to always write and read at the start of the file (lseek(2)).
You need to catch the delivery of SIGUSR1, or the default action of process termination will occur.
Additionally, the pattern of kill and then pause is not sufficient to avoid a race condition wherein a signal is delivered before the process pauses to wait for signals. This answer covers the problem, and a solution. The method detailed is to use sigprocmask(2) to normally delay (block) the delivery of signals and then sigsupend(2) to temporarily handle those signals.
Here is a cursory example, lacking error handling, wherein the parent process writes and the child process reads.
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
void pdie(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}
void handler(int sig)
{
signal(sig, handler);
}
int main(int argc, char const *argv[])
{
if (argc < 2)
return EXIT_FAILURE;
int fd = open("exercise.txt", O_RDWR | O_CREAT | O_TRUNC, 0777);
if (-1 == fd)
pdie("open");
int n = atoi(argv[1]);
if (n < 1)
n = 10;
sigset_t set, old;
sigemptyset(&set);
sigaddset(&set, SIGUSR1);
sigprocmask(SIG_BLOCK, &set, &old);
signal(SIGUSR1, handler);
pid_t pid = fork();
if (-1 == pid)
pdie("fork");
for (int i = 0; i < n; i++) {
char buf[32];
if (pid) {
/* parent writes */
int len = snprintf(buf, sizeof buf, "%d", i + 1);
lseek(fd, 0, SEEK_SET);
write(fd, buf, (size_t) len);
kill(pid, SIGUSR1);
sigsuspend(&old);
} else {
/* child reads */
sigsuspend(&old);
memset(buf, 0, sizeof buf);
lseek(fd, 0, SEEK_SET);
ssize_t bytes = read(fd, buf, sizeof buf - 1);
printf("Child read %zd bytes: %s\n", bytes, buf);
kill(getppid(), SIGUSR1);
}
}
close(fd);
if (pid)
waitpid(pid, NULL, WUNTRACED);
}