integ-test.c

   1 /* integration tests */
   2
   3 #include <stdint.h>
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <unistd.h>
   7 #include <signal.h>
   8 #include <sys/stat.h>
   9 #include <sys/socket.h>
  10 #include <netdb.h>
  11 #include <netinet/ip.h>
  12 #include <arpa/inet.h>
  13 #include <fcntl.h>
  14 #include <sys/wait.h>
  15 #include <errno.h>
  16 #include "ct/ct.h"
  17 #include "dat.h"
  18
  19 static void testsrv(char*, char*, int);
  20 static void forksrv(int*, int*);
  21 static int copy(int, int, int);
  22 static int diff(char*, int);
  23 static int diallocal(int);
  24 static void cleanup(int sig);
  25
  26 typedef struct T T;
  27 struct T {
  28     char *cmd;
  29     char *exp;
  30 };
  31
  32 static T ts[] = {
  33     {"sh-tests/allow-underscore.commands", "sh-tests/allow-underscore.expected"},
  34     {"sh-tests/delete_ready.commands", "sh-tests/delete_ready.expected"},
  35     {"sh-tests/multi-tube.commands", "sh-tests/multi-tube.expected"},
  36     {"sh-tests/no_negative_delays.commands", "sh-tests/no_negative_delays.expected"},
  37     {"sh-tests/omit-time-left.commands", "sh-tests/omit-time-left.expected"},
  38     {"sh-tests/pause-tube.commands", "sh-tests/pause-tube.expected"},
  39     {"sh-tests/small_delay.commands", "sh-tests/small_delay.expected"},
  40     {"sh-tests/too-big.commands", "sh-tests/too-big.expected"},
  41     {"sh-tests/ttr-large.commands", "sh-tests/ttr-large.expected"},
  42     {"sh-tests/zero_delay.commands", "sh-tests/zero_delay.expected"},
  43     {},
  44 };
  45
  46 static int srvpid;
  47
  48
  49 void
  50 cttestsrv()
  51 {
  52     int i;
  53
  54     for (i = 0; ts[i].cmd; i++) {
  55         testsrv(ts[i].cmd, ts[i].exp, 4096);
  56         testsrv(ts[i].cmd, ts[i].exp, 1);
  57     }
  58 }
  59
  60
  61 static void
  62 testsrv(char *cmd, char *exp, int bufsiz)
  63 {
  64     int diffst, srvst, port = 0, cfd, tfd, diffpid;
  65     struct sigaction sa = {};
  66
  67     job_data_size_limit = 10;
  68
  69     progname = cmd;
  70     puts(cmd);
  71     forksrv(&port, &srvpid);
  72     if (port == -1 || srvpid == -1) {
  73         puts("forksrv failed");
  74         exit(1);
  75     }
  76
  77     // Fail if this test takes more than 10 seconds.
  78     // If we have trouble installing the timeout,
  79     // just proceed anyway.
  80     sa.sa_handler = cleanup;
  81     sigaction(SIGALRM, &sa, 0);
  82     alarm(10);
  83
  84     cfd = diallocal(port);
  85     if (cfd == -1) {
  86         twarn("diallocal");
  87         kill(srvpid, 9);
  88         exit(1);
  89     }
  90
  91     tfd = open(cmd, O_RDONLY, 0);
  92     if (tfd == -1) {
  93         twarn("open");
  94         kill(srvpid, 9);
  95         exit(1);
  96     }
  97
  98     if (copy(cfd, tfd, bufsiz) == -1) {
  99         twarn("copy");
 100         kill(srvpid, 9);
 101         exit(1);
 102     }
 103
 104     diffpid = diff(exp, cfd);
 105     if (diffpid == -1) {
 106         twarn("diff");
 107         kill(srvpid, 9);
 108         exit(1);
 109     }
 110
 111     waitpid(diffpid, &diffst, 0);
 112
 113     // wait until after diff has finished to kill srvpid
 114     kill(srvpid, 9);
 115     waitpid(srvpid, &srvst, 0);
 116     printf("srv status %d, signal %d\n", WEXITSTATUS(srvst), WTERMSIG(srvst));
 117     assertf(WIFSIGNALED(srvst) && WTERMSIG(srvst) == 9, "srv status");
 118
 119     printf("diff status %d\n", diffst);
 120     assertf(diffst == 0, "diff status");
 121 }
 122
 123
 124 static void
 125 forksrv(int *port, int *pid)
 126 {
 127     int r, len;
 128     Srv s = {};
 129     struct sockaddr_in addr;
 130
 131     s.sock.fd = make_server_socket("127.0.0.1", "0");
 132     if (s.sock.fd == -1) return;
 133
 134     len = sizeof(addr);
 135     r = getsockname(s.sock.fd, (struct sockaddr*)&addr, (socklen_t*)&len);
 136     if (r == -1 || len > sizeof(addr)) return;
 137
 138     *port = addr.sin_port;
 139
 140     *pid = fork();
 141     if (*pid != 0) return;
 142
 143     /* now in child */
 144
 145     prot_init();
 146
 147     srv(&s); /* does not return */
 148     exit(1); /* satisfy the compiler */
 149 }
 150
 151
 152 static int
 153 diff(char *f0, int fd)
 154 {
 155     int pid;
 156
 157     pid = fork();
 158     if (pid != 0) return pid;
 159
 160     /* now in child */
 161
 162     dup2(fd, 0);
 163     close(fd);
 164
 165     execlp("diff", "diff", f0, "-", (char*)0);
 166     /* not reached */
 167     exit(1);
 168 }
 169
 170
 171 static int
 172 copy(int dst, int src, int bs)
 173 {
 174     char buf[bs];
 175     int r, w, c;
 176
 177     for (;;) {
 178         r = read(src, buf, sizeof buf);
 179         if (r == -1) return -1;
 180         if (r == 0) break;
 181
 182         for (w = 0; w < r; w += c) {
 183             c = write(dst, buf+w, r-w);
 184             if (c == -1) return -1;
 185         }
 186     }
 187     return 0;
 188 }
 189
 190
 191 static int
 192 diallocal(int port)
 193 {
 194     int r, fd;
 195     struct sockaddr_in addr = {};
 196
 197     addr.sin_family = AF_INET;
 198     addr.sin_port = port;
 199     r = inet_aton("127.0.0.1", &addr.sin_addr);
 200     if (!r) {
 201         errno = EINVAL;
 202         return -1;
 203     }
 204
 205     fd = socket(PF_INET, SOCK_STREAM, 0);
 206     if (fd == -1) {
 207         return -1;
 208     }
 209
 210     r = connect(fd, (struct sockaddr*)&addr, sizeof addr);
 211     if (r == -1) {
 212         return -1;
 213     }
 214
 215     return fd;
 216 }
 217
 218
 219 static void
 220 cleanup(int sig)
 221 {
 222     puts("timed out");
 223     if (srvpid > 0) {
 224         kill(srvpid, 9);
 225     }
 226     exit(1);
 227 }