#include <fcntl.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

int main(int argc, char **argv) {
  if (argc < 3)
    return 1;

  /* Create three processes, then sort by pid in each.  The parent and
     the second child can easily learn all three pids, but the first
     child only knows two of the pids, so we pass the third over a
     pipe.  */
  pid_t pids[3] = { 0 }; // All three pids, eventually sorted.
  pid_t parent = pids[0] = getpid(); // Valid in all processes
  pid_t child1 = 0; // Valid only in parent
  pid_t child2 = 0; // Valid only in parent
  int fds[2]; // Communicate from parent to child1
  char name[] = "lockXXXXXX";
  int file = mkstemp(name);
  struct flock fl;
  if (file < 0)
    return 2;
  if (pipe(fds) < 0)
    return 3;
  pid_t pid = fork();
  if (pid < 0)
    return 4;
  if (pid) { // parent
    child1 = pids[1] = pid;
    if (close(fds[0]) < 0)
      return 5;
    pid = fork();
    if (pid < 0)
      return 6;
    if (pid) { // still parent
      child2 = pids[2] = pid;
      if (dprintf(fds[1], "%ld\n", (long)pid) < 0)
    return 7;
      if (close(fds[1]) < 0)
    return 8;
    } else { // child 2
      pids[2] = getpid();
      if (close(fds[1]) < 0)
    return 9;
    }
  } else { // child 1
    pids[1] = getpid();
    if (close(fds[1]) < 0)
      return 10;
    char buf[20];
    if (read(fds[0], buf, sizeof(buf)) < 0)
      return 11;
    pids[2] = strtoull(buf, NULL, 10);
    if (!pids[2])
      return 12;
    if (close(fds[0]) < 0)
      return 13;
  }

  /* All three processes, start by sorting pids.  */
  if (pids[1] < pids[0]) {
    pid = pids[1];
    pids[1] = pids[0];
    pids[0] = pid;
  }
  if (pids[2] < pids[1]) {
    pid = pids[2];
    pids[2] = pids[1];
    pids[1] = pid;
  }
  if (pids[1] < pids[0]) {
    pid = pids[1];
    pids[1] = pids[0];
    pids[0] = pid;
  }

  /* Now for the test, based on argv.  The test uses three steps,
     where two processes create distinct read locks, then the third
     process queries whether a write lock that overlaps both read
     locks would succeed.  argv[1] controls which order the processes
     run in (6 possibilities), and argv[2] controls whether the higher
     or lower read lock will be created first (2 possibilities).  */
  switch (atoi(argv[1])) {
  case 0: case 1: pid = pids[0]; break;
  case 2: case 3: pid = pids[1]; break;
  case 4: case 5: pid = pids[2]; break;
  }
  if (getpid() == pid) {
    // create read lock 1
    fl.l_type = F_RDLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start = atoi(argv[2]) ? 2 : 1;
    fl.l_len = 1;
    if (fcntl(file, F_SETLK, &fl) < 0)
      return 14;
    printf("pid %ld got read lock\n", (long) pid);
  } else {
    sleep(1);
  }
  switch (atoi(argv[1])) {
  case 2: case 4: pid = pids[0]; break;
  case 0: case 5: pid = pids[1]; break;
  case 1: case 3: pid = pids[2]; break;
  }
  if (getpid() == pid) {
    // create read lock 2
    fl.l_type = F_RDLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start = atoi(argv[2]) ? 1 : 2;
    fl.l_len = 1;
    if (fcntl(file, F_SETLK, &fl) < 0)
      return 15;
    printf("pid %ld got read lock\n", (long) pid);
  } else {
    sleep(1);
  }
  switch (atoi(argv[1])) {
  case 3: case 5: pid = pids[0]; break;
  case 1: case 4: pid = pids[1]; break;
  case 0: case 2: pid = pids[2]; break;
  }
  if (getpid() == pid) {
    // probe write lock
    fl.l_type = F_WRLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start = 1;
    fl.l_len = 2;
    if (fcntl(file, F_GETLK, &fl) < 0)
      return 16;
    if (fl.l_type == F_UNLCK)
      return 17;
    printf("pid %ld would block on offset %ld from pid %ld\n",
       (long) pid, (long) fl.l_start, (long) fl.l_pid);
  } else {
    sleep(2);
  }

  /* Parent-specific cleanup (reflect non-zero status from either
     child into the parent).  */
  if (getpid() == parent) {
    int status;
    if (child1) {
      if (waitpid(child1, &status, 0) != child1)
    return 18;
      if (status) {
    if (!WIFEXITED(status))
      return 19;
    return WEXITSTATUS(status);
      }
    }
    if (child2) {
      if (waitpid(child2, &status, 0) != child2)
    return 20;
      if (status) {
    if (!WIFEXITED(status))
      return 21;
    return WEXITSTATUS(status);
      }
    }
    if (close(file) < 0)
      return 22;
    if (unlink(name) < 0)
      return 23;
  }
  /* We got here, test is complete. */
  return 0;
}