diplodocus.org Git - nmh/blob - test/fakesmtp.c

   1 /*
   2  * fakesmtp - A fake SMTP server used by the nmh test suite
   3  *
   4  * This code is Copyright (c) 2012, by the authors of nmh.  See the
   5  * COPYRIGHT file in the root directory of the nmh distribution for
   6  * complete copyright information.
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13 #include <netdb.h>
  14 #include <errno.h>
  15 #include <sys/socket.h>
  16 #include <netinet/in.h>
  17 #include <sys/types.h>
  18 #include <sys/select.h>
  19 #include <sys/stat.h>
  20 #include <sys/uio.h>
  21 #include <signal.h>
  22
  23 #define PIDFILE "/tmp/fakesmtp.pid"
  24
  25 #define LINESIZE 1024
  26
  27 static void killpidfile(void);
  28 static void handleterm(int);
  29 static void putsmtp(int, char *);
  30 static int getsmtp(int, char *);
  31
  32 int
  33 main(int argc, char *argv[])
  34 {
  35         struct addrinfo hints, *res;
  36         int rc, l, conn, on, datamode;
  37         FILE *f, *pid;
  38         pid_t child;
  39         fd_set readfd;
  40         struct stat st;
  41         struct timeval tv;
  42
  43         if (argc != 3) {
  44                 fprintf(stderr, "Usage: %s output-filename port\n", argv[0]);
  45                 exit(1);
  46         }
  47
  48         if (!(f = fopen(argv[1], "w"))) {
  49                 fprintf(stderr, "Unable to open output file \"%s\": %s\n",
  50                         argv[1], strerror(errno));
  51                 exit(1);
  52         }
  53
  54         /*
  55          * If there is a pid file already around, kill the previously running
  56          * fakesmtp process.  Hopefully this will reduce the race conditions
  57          * that crop up when running the test suite.
  58          */
  59
  60         if (stat(PIDFILE, &st) == 0) {
  61                 long oldpid;
  62
  63                 if (!(pid = fopen(PIDFILE, "r"))) {
  64                         fprintf(stderr, "Cannot open " PIDFILE
  65                                 " (%s), continuing ...\n", strerror(errno));
  66                 } else {
  67                         rc = fscanf(pid, "%ld", &oldpid);
  68                         fclose(pid);
  69
  70                         if (rc != 1) {
  71                                 fprintf(stderr, "Unable to parse pid in "
  72                                         PIDFILE ", continuing ...\n");
  73                         } else {
  74                                 kill((pid_t) oldpid, SIGTERM);
  75                         }
  76                 }
  77
  78                 unlink(PIDFILE);
  79         }
  80
  81         memset(&hints, 0, sizeof(hints));
  82
  83         hints.ai_family = PF_INET;
  84         hints.ai_socktype = SOCK_STREAM;
  85         hints.ai_protocol = IPPROTO_TCP;
  86         hints.ai_flags = AI_PASSIVE;
  87
  88         rc = getaddrinfo("127.0.0.1", argv[2], &hints, &res);
  89
  90         if (rc) {
  91                 fprintf(stderr, "Unable to resolve localhost/%s: %s\n",
  92                         argv[2], gai_strerror(rc));
  93                 exit(1);
  94         }
  95
  96         l = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
  97
  98         if (l == -1) {
  99                 fprintf(stderr, "Unable to create listening socket: %s\n",
 100                         strerror(errno));
 101                 exit(1);
 102         }
 103
 104         on = 1;
 105
 106         if (setsockopt(l, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
 107                 fprintf(stderr, "Unable to set SO_REUSEADDR: %s\n",
 108                         strerror(errno));
 109                 exit(1);
 110         }
 111
 112         if (bind(l, res->ai_addr, res->ai_addrlen) == -1) {
 113                 fprintf(stderr, "Unable to bind socket: %s\n", strerror(errno));
 114                 exit(1);
 115         }
 116
 117         if (listen(l, 1) == -1) {
 118                 fprintf(stderr, "Unable to listen on socket: %s\n",
 119                         strerror(errno));
 120                 exit(1);
 121         }
 122
 123         /*
 124          * Now we fork() and print out the process ID of our child
 125          * for scripts to use.  Once we do that, then exit.
 126          */
 127
 128         child = fork();
 129
 130         switch (child) {
 131         case -1:
 132                 fprintf(stderr, "Unable to fork child: %s\n", strerror(errno));
 133                 exit(1);
 134                 break;
 135         case 0:
 136                 /*
 137                  * Close stdin & stdout, otherwise people can
 138                  * think we're still doing stuff.  For now leave stderr
 139                  * open.
 140                  */
 141                 fclose(stdin);
 142                 fclose(stdout);
 143                 break;
 144         default:
 145                 printf("%ld\n", (long) child);
 146                 exit(0);
 147         }
 148
 149         /*
 150          * Now that our socket & files are set up, wait 30 seconds for
 151          * a connection.  If there isn't one, then exit.
 152          */
 153
 154         if (!(pid = fopen(PIDFILE, "w"))) {
 155                 fprintf(stderr, "Cannot open " PIDFILE ": %s\n",
 156                         strerror(errno));
 157                 exit(1);
 158         }
 159
 160         fprintf(pid, "%ld\n", (long) getpid());
 161         fclose(pid);
 162
 163         signal(SIGTERM, handleterm);
 164         atexit(killpidfile);
 165
 166         FD_ZERO(&readfd);
 167         FD_SET(l, &readfd);
 168         tv.tv_sec = 30;
 169         tv.tv_usec = 0;
 170
 171         rc = select(l + 1, &readfd, NULL, NULL, &tv);
 172
 173         if (rc < 0) {
 174                 fprintf(stderr, "select() failed: %s\n", strerror(errno));
 175                 exit(1);
 176         }
 177
 178         /*
 179          * I think if we get a timeout, we should just exit quietly.
 180          */
 181
 182         if (rc == 0) {
 183                 exit(1);
 184         }
 185
 186         /*
 187          * Alright, got a connection!  Accept it.
 188          */
 189
 190         if ((conn = accept(l, NULL, NULL)) == -1) {
 191                 fprintf(stderr, "Unable to accept connection: %s\n",
 192                         strerror(errno));
 193                 exit(1);
 194         }
 195
 196         close(l);
 197
 198         /*
 199          * Pretend to be an SMTP server.
 200          */
 201
 202         putsmtp(conn, "220 Not really an ESMTP server");
 203         datamode = 0;
 204
 205         for (;;) {
 206                 char line[LINESIZE];
 207
 208                 rc = getsmtp(conn, line);
 209
 210                 if (rc == -1)
 211                         break;  /* EOF */
 212
 213                 fprintf(f, "%s\n", line);
 214
 215                 /*
 216                  * If we're in DATA mode, then check to see if we've got
 217                  * a "."; otherwise, continue
 218                  */
 219
 220                 if (datamode) {
 221                         if (strcmp(line, ".") == 0) {
 222                                 datamode = 0;
 223                                 putsmtp(conn, "250 Thanks for the info!");
 224                         }
 225                         continue;
 226                 }
 227
 228                 /*
 229                  * Most commands we ignore and send the same response to.
 230                  */
 231
 232                 if (strcmp(line, "QUIT") == 0) {
 233                         fclose(f);
 234                         f = NULL;
 235                         putsmtp(conn, "221 Later alligator!");
 236                         close(conn);
 237                         break;
 238                 } else if (strcmp(line, "DATA") == 0) {
 239                         putsmtp(conn, "354 Go ahead");
 240                         datamode = 1;
 241                 } else {
 242                         putsmtp(conn, "250 I'll buy that for a dollar!");
 243                 }
 244         }
 245
 246         if (f)
 247                 fclose(f);
 248
 249         exit(0);
 250 }
 251
 252 /*
 253  * Write a line to the SMTP client on the other end
 254  */
 255
 256 static void
 257 putsmtp(int socket, char *data)
 258 {
 259         struct iovec iov[2];
 260
 261         iov[0].iov_base = data;
 262         iov[0].iov_len = strlen(data);
 263         iov[1].iov_base = "\r\n";
 264         iov[1].iov_len = 2;
 265
 266         if (writev(socket, iov, 2) < 0) {
 267             perror ("writev");
 268         }
 269 }
 270
 271 /*
 272  * Read a line (up to the \r\n)
 273  */
 274
 275 static int
 276 getsmtp(int socket, char *data)
 277 {
 278         int cc;
 279         static unsigned int bytesinbuf = 0;
 280         static char buffer[LINESIZE * 2], *p;
 281
 282         for (;;) {
 283                 /*
 284                  * Find our \r\n
 285                  */
 286
 287                 if (bytesinbuf > 0 && (p = strchr(buffer, '\r')) &&
 288                                                         *(p + 1) == '\n') {
 289                         *p = '\0';
 290                         strncpy(data, buffer, LINESIZE);
 291                         data[LINESIZE - 1] = '\0';
 292                         cc = strlen(buffer);
 293
 294                         /*
 295                          * Shuffle leftover bytes back to the beginning
 296                          */
 297
 298                         bytesinbuf -= cc + 2;   /* Don't forget \r\n */
 299                         if (bytesinbuf > 0) {
 300                                 memmove(buffer, buffer + cc + 2, bytesinbuf);
 301                         }
 302                         return cc;
 303                 }
 304
 305                 if (bytesinbuf >= sizeof(buffer)) {
 306                         fprintf(stderr, "Buffer overflow in getsmtp()!\n");
 307                         exit(1);
 308                 }
 309
 310                 memset(buffer + bytesinbuf, 0, sizeof(buffer) - bytesinbuf);
 311                 cc = read(socket, buffer + bytesinbuf,
 312                           sizeof(buffer) - bytesinbuf);
 313
 314                 if (cc < 0) {
 315                         fprintf(stderr, "Read failed: %s\n", strerror(errno));
 316                         exit(1);
 317                 }
 318
 319                 if (cc == 0)
 320                         return -1;
 321
 322                 bytesinbuf += cc;
 323         }
 324 }
 325
 326 /*
 327  * Handle a SIGTERM
 328  */
 329
 330 static void
 331 handleterm(int signal)
 332 {
 333         (void) signal;
 334
 335         killpidfile();
 336         fflush(NULL);
 337         _exit(1);
 338 }
 339
 340 /*
 341  * Get rid of our pid file
 342  */
 343
 344 static void
 345 killpidfile(void)
 346 {
 347         unlink(PIDFILE);
 348 }