Speaking of locks if you are writing something that can run a long time and produces a log file it might be nice if you locked the log file before appending a new log entry.

If you do that, someone who wants to rotate logs can do it by (1) locking the log file, (2) copying it to the rotated file, (3) truncating the log file, and (4) releasing the lock.

Here's a C program, cat-trunc, that does that. Usage is "cat-trunc logfile".

  #include <stdio.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>
  #include <unistd.h>

  char buf[65536];

  int main(int argc, char *argv[])
  {
    struct flock l;
    ssize_t got;
    ssize_t copied = 0;
    off_t eof;
    int finished = 0;
    int status = 0;

    if (argc != 2)
    {
        fprintf(stderr, "%s: error: no log file specified!\n", argv[0]);
        return 1;
    }

    int fd = open(argv[1], O_RDWR);
    if (fd == -1)
    {
        perror(argv[0]);
        return 2;
    }

    l.l_whence = SEEK_SET;
    l.l_start = 0;
    l.l_len = 0;

    while (! finished) {
        got = read(fd, buf, sizeof buf);
        if (got > 0) {
            copied += got;
            if (write(1, buf, got) != got) {
                status = -1;
                finished = 1;
                perror(argv[0]);
            }
        } else if (got == 0) {
            l.l_type = F_WRLCK;
            fcntl(fd, F_SETLKW, &l); 
            eof = lseek(fd, 0, SEEK_END);
            if (eof == copied) {
                ftruncate(fd, 0);
                finished = 1;
            } else {
                lseek(fd, copied, SEEK_SET);
            }
            l.l_type = F_UNLCK;
            fcntl(fd, F_SETLKW, &l);
        } else {
            status = -1;
            finished = 1;
            perror(argv[0]);
        }
    }
    return status;
  }

That's a little more complicated than is necessary, because it tries to minimize the time it holds the lock.

If you've got a long running program whose stdout you want to log here's a C++ program (but written like it is C plus std::string and std::list because I am lazy), lock-save, to help with that. Usage is "lock-save [-t] file". It copies stdin to file, writing a line at a time, locking the file for those writes. You can then use cat-trunc to rotate the file. The -t option makes it also copy stdin to stdout, making it essentially tee with locks.

  #include <stdio.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <pwd.h>
  #include <fcntl.h>
  #include <unistd.h>
  #include <string>
  #include <list>

  std::list<std::string>  lines;

  int main(int argc, char *argv[])
  {
    char * prog_name = argv[0];
    char \* file_name = 0;
    int t_flag = 0;
    struct flock l;
    int c;
    std::string line;

    if (argc > 1 && strcmp(argv[1], "-t") == 0) {
        t_flag = 1;
    }
    if (argc != 2+t_flag) {
        fprintf(stderr, "Usage: %s [-t] file\n", prog_name);
        return 1;
    }
    file_name = argv[1+t_flag];

    int fd = open(file_name, O_RDWR | O_CREAT | O_APPEND, 0666);
    if (fd == -1) {
        perror(prog_name);
        return 2;
    }

    l.l_whence = SEEK_SET;
    l.l_start = 0;
    l.l_len = 0;
    while ((c = getchar()) != EOF) {
        if (t_flag) {
            putchar(c);
        }
        line += c;
        if (c == '\n') {
            lines.push_back(line);
            l.l_type = F_WRLCK;
            if (fcntl(fd, F_SETLK, &l) != -1) {
                while (lines.size())
                {
                    line = lines.front();
                    lines.pop_front();
                    write(fd, line.c_str(), line.length());
                }
                l.l_type = F_UNLCK;
                fcntl(fd, F_SETLK, &l);
                line = "";
            }
        }
    }
    return 0;
  }