luna - curl/tests/server/rtspd.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 *
  10 * This software is licensed as described in the file COPYING, which
  11 * you should have received as part of this distribution. The terms
  12 * are also available at https://curl.se/docs/copyright.html.
  13 *
  14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15 * copies of the Software, and permit persons to whom the Software is
  16 * furnished to do so, under the terms of the COPYING file.
  17 *
  18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19 * KIND, either express or implied.
  20 *
  21 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "first.h"
  25
  26/*
  27 * curl's test suite Real Time Streaming Protocol (RTSP) server.
  28 *
  29 * This source file was started based on curl's HTTP test suite server.
  30 */
  31
  32#ifdef HAVE_NETINET_TCP_H
  33#include <netinet/tcp.h> /* for TCP_NODELAY */
  34#endif
  35
  36static long rtspd_prevtestno = -1;    /* previous test number we served */
  37static long rtspd_prevpartno = -1;    /* previous part number we served */
  38static bool rtspd_prevbounce = FALSE; /* instructs the server to override the
  39                                         requested part number to
  40                                         prevpartno + 1 when prevtestno and
  41                                         current test are the same */
  42
  43#define RCMD_NORMALREQ 0 /* default request, use the tests file normally */
  44#define RCMD_IDLE      1 /* told to sit idle */
  45#define RCMD_STREAM    2 /* told to stream */
  46
  47typedef enum {
  48  RPROT_NONE = 0,
  49  RPROT_RTSP = 1,
  50  RPROT_HTTP = 2
  51} reqprot_t;
  52
  53#define SET_RTP_PKT_CHN(p, c)  ((p)[1] = (char)((c) & 0xFF))
  54
  55#define SET_RTP_PKT_LEN(p, l) (((p)[2] = (char)(((l) >> 8) & 0xFF)), \
  56                               ((p)[3] = (char)((l) & 0xFF)))
  57
  58struct rtspd_httprequest {
  59  char reqbuf[150000]; /* buffer area for the incoming request */
  60  size_t checkindex; /* where to start checking of the request */
  61  size_t offset;     /* size of the incoming request */
  62  long testno;       /* test number found in the request */
  63  long partno;       /* part number found in the request */
  64  bool open;      /* keep connection open info, as found in the request */
  65  bool auth_req;  /* authentication required, do not wait for body unless
  66                     there is an Authorization header */
  67  bool auth;      /* Authorization header present in the incoming request */
  68  size_t cl;      /* Content-Length of the incoming request */
  69  bool digest;    /* Authorization digest header found */
  70  bool ntlm;      /* Authorization NTLM header found */
  71  int pipe;       /* if non-zero, expect this many requests to do a "piped"
  72                     request/response */
  73  int skip;       /* if non-zero, the server is instructed to not read this
  74                     many bytes from a PUT/POST request. Ie the client sends N
  75                     bytes said in Content-Length, but the server only reads N
  76                     - skip bytes. */
  77  int rcmd;       /* doing a special command, see defines above */
  78  reqprot_t protocol; /* request protocol, HTTP or RTSP */
  79  int prot_version;   /* HTTP or RTSP version (major*10 + minor) */
  80  bool pipelining;    /* true if request is pipelined */
  81  char *rtp_buffer;
  82  size_t rtp_buffersize;
  83};
  84
  85#define RTSPDVERSION "curl test suite RTSP server/0.1"
  86
  87#define REQUEST_DUMP  "server.input"
  88#define RESPONSE_DUMP "server.response"
  89
  90/* very-big-path support */
  91#define MAXDOCNAMELEN     140000
  92#define MAXDOCNAMELEN_TXT "139999"
  93
  94#define REQUEST_KEYWORD_SIZE     256
  95#define REQUEST_KEYWORD_SIZE_TXT "255"
  96
  97#define CMD_AUTH_REQUIRED "auth_required"
  98
  99/* 'idle' means that it will accept the request fine but never respond
 100   any data. Just keep the connection alive. */
 101#define CMD_IDLE "idle"
 102
 103/* 'stream' means to send a never-ending stream of data */
 104#define CMD_STREAM "stream"
 105
 106#define END_OF_HEADERS "\r\n\r\n"
 107
 108/* sent as reply to a QUIT */
 109static const char *docquit_rtsp = "HTTP/1.1 200 Goodbye" END_OF_HEADERS;
 110
 111/* sent as reply to a CONNECT */
 112static const char *docconnect =
 113  "HTTP/1.1 200 Mighty fine indeed" END_OF_HEADERS;
 114
 115/* sent as reply to a "bad" CONNECT */
 116static const char *docbadconnect =
 117  "HTTP/1.1 501 Forbidden you fool" END_OF_HEADERS;
 118
 119/* send back this on HTTP 404 file not found */
 120static const char *doc404_HTTP =
 121  "HTTP/1.1 404 Not Found\r\n"
 122  "Server: " RTSPDVERSION "\r\n"
 123  "Connection: close\r\n"
 124  "Content-Type: text/html"
 125  END_OF_HEADERS
 126  "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
 127  "<HTML><HEAD>\n"
 128  "<TITLE>404 Not Found</TITLE>\n"
 129  "</HEAD><BODY>\n"
 130  "<H1>Not Found</H1>\n"
 131  "The requested URL was not found on this server.\n"
 132  "<P><HR><ADDRESS>" RTSPDVERSION "</ADDRESS>\n"
 133  "</BODY></HTML>\n";
 134
 135/* send back this on RTSP 404 file not found */
 136static const char *doc404_RTSP = "RTSP/1.0 404 Not Found\r\n"
 137  "Server: " RTSPDVERSION
 138  END_OF_HEADERS;
 139
 140/* Default size to send away fake RTP data */
 141#define RTP_DATA_SIZE 12
 142static const char *RTP_DATA = "$_1234\n\0Rsdf";
 143
 144static int rtspd_ProcessRequest(struct rtspd_httprequest *req)
 145{
 146  const char *line = &req->reqbuf[req->checkindex];
 147  bool chunked = FALSE;
 148  static char request[REQUEST_KEYWORD_SIZE];
 149  static char doc[MAXDOCNAMELEN];
 150  static char prot_str[5];
 151  int prot_major, prot_minor;
 152  const char *end = strstr(line, END_OF_HEADERS);
 153
 154  logmsg("rtspd_ProcessRequest() called with testno %ld and line [%s]",
 155         req->testno, line);
 156
 157  /* try to figure out the request characteristics as soon as possible, but
 158     only once! */
 159  if((req->testno == DOCNUMBER_NOTHING) &&
 160     sscanf(line,
 161            "%" REQUEST_KEYWORD_SIZE_TXT"s %" MAXDOCNAMELEN_TXT "s %4s/%d.%d",
 162            request,
 163            doc,
 164            prot_str,
 165            &prot_major,
 166            &prot_minor) == 5) {
 167    const char *ptr;
 168    const char *pval;
 169    curl_off_t testnum;
 170
 171    if(!strcmp(prot_str, "HTTP")) {
 172      req->protocol = RPROT_HTTP;
 173    }
 174    else if(!strcmp(prot_str, "RTSP")) {
 175      req->protocol = RPROT_RTSP;
 176    }
 177    else {
 178      req->protocol = RPROT_NONE;
 179      logmsg("got unknown protocol %s", prot_str);
 180      return 1;
 181    }
 182
 183    req->prot_version = (prot_major * 10) + prot_minor;
 184
 185    /* find the last slash */
 186    ptr = strrchr(doc, '/');
 187
 188    /* get the number after it */
 189    if(ptr) {
 190      FILE *stream;
 191      if((strlen(doc) + strlen(request)) < 200)
 192        logmsg("Got request: %s %s %s/%d.%d",
 193               request, doc, prot_str, prot_major, prot_minor);
 194      else
 195        logmsg("Got a *HUGE* request %s/%d.%d",
 196               prot_str, prot_major, prot_minor);
 197
 198      if(!strncmp("/verifiedserver", ptr, 15)) {
 199        logmsg("Are-we-friendly question received");
 200        req->testno = DOCNUMBER_WERULEZ;
 201        return 1; /* done */
 202      }
 203
 204      if(!strncmp("/quit", ptr, 5)) {
 205        logmsg("Request-to-quit received");
 206        req->testno = DOCNUMBER_QUIT;
 207        return 1; /* done */
 208      }
 209
 210      ptr++; /* skip the slash */
 211
 212      /* skip all non-numericals following the slash */
 213      while(*ptr && !ISDIGIT(*ptr))
 214        ptr++;
 215
 216      pval = ptr;
 217      if(!curlx_str_number(&pval, &testnum, INT_MAX))
 218        req->testno = (long)testnum;
 219      else {
 220        req->protocol = RPROT_NONE;
 221        logmsg("rtspd: failed to read the test number from '%s'", doc);
 222        return 1;
 223      }
 224
 225      if(req->testno > 10000) {
 226        req->partno = req->testno % 10000;
 227        req->testno /= 10000;
 228      }
 229      else
 230        req->partno = 0;
 231
 232      logmsg("Requested test number %ld part %ld", req->testno, req->partno);
 233
 234      stream = test2fopen(req->testno, logdir);
 235
 236      if(!stream) {
 237        char errbuf[STRERROR_LEN];
 238        int error = errno;
 239        logmsg("fopen() failed with error (%d) %s",
 240               error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 241        logmsg("Could not open test file %ld", req->testno);
 242        req->open = FALSE; /* closes connection */
 243        return 1; /* done */
 244      }
 245      else {
 246        char *cmd = NULL;
 247        size_t cmdsize = 0;
 248        int num = 0;
 249
 250        int rtp_channel = 0;
 251        int rtp_size = 0;
 252        int rtp_size_err = 0;
 253        int rtp_partno = -1;
 254        char *rtp_scratch = NULL;
 255
 256        /* get the custom server control "commands" */
 257        int error = getpart(&cmd, &cmdsize, "reply", "servercmd", stream);
 258        curlx_fclose(stream);
 259        if(error) {
 260          logmsg("getpart() failed with error (%d)", error);
 261          req->open = FALSE; /* closes connection */
 262          return 1; /* done */
 263        }
 264        ptr = cmd;
 265
 266        if(cmdsize) {
 267          logmsg("Found a reply-servercmd section!");
 268          do {
 269            rtp_size_err = 0;
 270            if(!strncmp(CMD_AUTH_REQUIRED, ptr, strlen(CMD_AUTH_REQUIRED))) {
 271              logmsg("instructed to require authorization header");
 272              req->auth_req = TRUE;
 273            }
 274            else if(!strncmp(CMD_IDLE, ptr, strlen(CMD_IDLE))) {
 275              logmsg("instructed to idle");
 276              req->rcmd = RCMD_IDLE;
 277              req->open = TRUE;
 278            }
 279            else if(!strncmp(CMD_STREAM, ptr, strlen(CMD_STREAM))) {
 280              logmsg("instructed to stream");
 281              req->rcmd = RCMD_STREAM;
 282            }
 283            else if(sscanf(ptr, "pipe: %d", &num) == 1) {
 284              logmsg("instructed to allow a pipe size of %d", num);
 285              if(num < 0)
 286                logmsg("negative pipe size ignored");
 287              else if(num > 0)
 288                req->pipe = num - 1; /* decrease by one since we do not count
 289                                        the first request in this number */
 290            }
 291            else if(sscanf(ptr, "skip: %d", &num) == 1) {
 292              logmsg("instructed to skip this number of bytes %d", num);
 293              req->skip = num;
 294            }
 295            else if(3 <= sscanf(ptr,
 296                                "rtp: part %d channel %d size %d size_err %d",
 297                                &rtp_partno, &rtp_channel, &rtp_size,
 298                                &rtp_size_err)) {
 299
 300              if(rtp_partno == req->partno) {
 301                int i = 0;
 302                logmsg("RTP: part %d channel %d size %d size_err %d",
 303                       rtp_partno, rtp_channel, rtp_size, rtp_size_err);
 304
 305                /* Make our scratch buffer enough to fit all the
 306                 * desired data and one for padding */
 307                rtp_scratch = malloc(rtp_size + 4 + RTP_DATA_SIZE);
 308
 309                /* RTP is signalled with a $ */
 310                rtp_scratch[0] = '$';
 311
 312                /* The channel follows and is one byte */
 313                SET_RTP_PKT_CHN(rtp_scratch, rtp_channel);
 314
 315                /* Length follows and is a two byte short in network order */
 316                SET_RTP_PKT_LEN(rtp_scratch, rtp_size + rtp_size_err);
 317
 318                /* Fill it with junk data */
 319                for(i = 0; i < rtp_size; i += RTP_DATA_SIZE) {
 320                  /* NOLINTNEXTLINE(bugprone-not-null-terminated-result) */
 321                  memcpy(rtp_scratch + 4 + i, RTP_DATA, RTP_DATA_SIZE);
 322                }
 323
 324                if(!req->rtp_buffer) {
 325                  req->rtp_buffer = rtp_scratch;
 326                  req->rtp_buffersize = rtp_size + 4;
 327                }
 328                else {
 329                  char *rtp_buffer = realloc(req->rtp_buffer,
 330                                             req->rtp_buffersize +
 331                                             rtp_size + 4);
 332                  if(rtp_buffer) {
 333                    req->rtp_buffer = rtp_buffer;
 334                    memcpy(req->rtp_buffer + req->rtp_buffersize, rtp_scratch,
 335                           rtp_size + 4);
 336                    req->rtp_buffersize += rtp_size + 4;
 337                  }
 338                  else
 339                    logmsg("failed resizing buffer.");
 340                  free(rtp_scratch);
 341                }
 342                logmsg("rtp_buffersize is %zu, rtp_size is %d.",
 343                       req->rtp_buffersize, rtp_size);
 344              }
 345            }
 346            else {
 347              logmsg("funny instruction found: %s", ptr);
 348            }
 349
 350            ptr = strchr(ptr, '\n');
 351            if(ptr)
 352              ptr++;
 353            else
 354              ptr = NULL;
 355          } while(ptr && *ptr);
 356          logmsg("Done parsing server commands");
 357        }
 358        free(cmd);
 359      }
 360    }
 361    else {
 362      if(sscanf(req->reqbuf, "CONNECT %" MAXDOCNAMELEN_TXT "s HTTP/%d.%d",
 363                doc, &prot_major, &prot_minor) == 3) {
 364        logmsg("Received a CONNECT %s HTTP/%d.%d request",
 365               doc, prot_major, prot_minor);
 366
 367        if(req->prot_version == 10)
 368          req->open = FALSE; /* HTTP 1.0 closes connection by default */
 369
 370        if(!strncmp(doc, "bad", 3))
 371          /* if the hostname starts with bad, we fake an error here */
 372          req->testno = DOCNUMBER_BADCONNECT;
 373        else if(!strncmp(doc, "test", 4)) {
 374          /* if the hostname starts with test, the port number used in the
 375             CONNECT line will be used as test number! */
 376          const char *portp = strchr(doc, ':');
 377          if(portp && (*(portp + 1) != '\0') && ISDIGIT(*(portp + 1))) {
 378            pval = portp + 1;
 379            if(!curlx_str_number(&pval, &testnum, INT_MAX))
 380              req->testno = (long)testnum;
 381            else
 382              req->testno = DOCNUMBER_CONNECT;
 383          }
 384          else
 385            req->testno = DOCNUMBER_CONNECT;
 386        }
 387        else
 388          req->testno = DOCNUMBER_CONNECT;
 389      }
 390      else {
 391        logmsg("Did not find test number in PATH");
 392        req->testno = DOCNUMBER_404;
 393      }
 394    }
 395  }
 396
 397  if(!end) {
 398    /* we do not have a complete request yet! */
 399    logmsg("rtspd_ProcessRequest returned without a complete request");
 400    return 0; /* not complete yet */
 401  }
 402  logmsg("rtspd_ProcessRequest found a complete request");
 403
 404  if(req->pipe)
 405    /* we do have a full set, advance the checkindex to after the end of the
 406       headers, for the pipelining case mostly */
 407    req->checkindex += (end - line) + strlen(END_OF_HEADERS);
 408
 409  /* **** Persistence ****
 410   *
 411   * If the request is an HTTP/1.0 one, we close the connection unconditionally
 412   * when we are done.
 413   *
 414   * If the request is an HTTP/1.1 one, we MUST check for a "Connection:"
 415   * header that might say "close". If it does, we close a connection when
 416   * this request is processed. Otherwise, we keep the connection alive for X
 417   * seconds.
 418   */
 419
 420  do {
 421    if(got_exit_signal)
 422      return 1; /* done */
 423
 424    if((req->cl == 0) && !CURL_STRNICMP("Content-Length:", line, 15)) {
 425      /* If we do not ignore content-length, we read it and we read the whole
 426         request including the body before we return. If we have been told to
 427         ignore the content-length, we will return as soon as all headers
 428         have been received */
 429      curl_off_t clen;
 430      const char *p = line + strlen("Content-Length:");
 431      if(curlx_str_numblanks(&p, &clen)) {
 432        /* this assumes that a zero Content-Length is valid */
 433        logmsg("Found invalid '%s' in the request", line);
 434        req->open = FALSE; /* closes connection */
 435        return 1; /* done */
 436      }
 437      req->cl = (size_t)clen - req->skip;
 438
 439      logmsg("Found Content-Length: %zu in the request", (size_t)clen);
 440      if(req->skip)
 441        logmsg("... but will abort after %zu bytes", req->cl);
 442      break;
 443    }
 444    else if(!CURL_STRNICMP("Transfer-Encoding: chunked", line,
 445                           strlen("Transfer-Encoding: chunked"))) {
 446      /* chunked data coming in */
 447      chunked = TRUE;
 448    }
 449
 450    if(chunked) {
 451      if(strstr(req->reqbuf, "\r\n0\r\n\r\n"))
 452        /* end of chunks reached */
 453        return 1; /* done */
 454      else
 455        return 0; /* not done */
 456    }
 457
 458    line = strchr(line, '\n');
 459    if(line)
 460      line++;
 461
 462  } while(line);
 463
 464  if(!req->auth && strstr(req->reqbuf, "Authorization:")) {
 465    req->auth = TRUE; /* Authorization: header present! */
 466    if(req->auth_req)
 467      logmsg("Authorization header found, as required");
 468  }
 469
 470  if(!req->digest && strstr(req->reqbuf, "Authorization: Digest")) {
 471    /* If the client is passing this Digest-header, we set the part number
 472       to 1000. Not only to spice up the complexity of this, but to make
 473       Digest stuff to work in the test suite. */
 474    req->partno += 1000;
 475    req->digest = TRUE; /* header found */
 476    logmsg("Received Digest request, sending back data %ld", req->partno);
 477  }
 478  else if(!req->ntlm &&
 479          strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAD")) {
 480    /* If the client is passing this type-3 NTLM header */
 481    req->partno += 1002;
 482    req->ntlm = TRUE; /* NTLM found */
 483    logmsg("Received NTLM type-3, sending back data %ld", req->partno);
 484    if(req->cl) {
 485      logmsg("  Expecting %zu POSTed bytes", req->cl);
 486    }
 487  }
 488  else if(!req->ntlm &&
 489          strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAB")) {
 490    /* If the client is passing this type-1 NTLM header */
 491    req->partno += 1001;
 492    req->ntlm = TRUE; /* NTLM found */
 493    logmsg("Received NTLM type-1, sending back data %ld", req->partno);
 494  }
 495  else if((req->partno >= 1000) &&
 496          strstr(req->reqbuf, "Authorization: Basic")) {
 497    /* If the client is passing this Basic-header and the part number is
 498       already >=1000, we add 1 to the part number.  This allows simple Basic
 499       authentication negotiation to work in the test suite. */
 500    req->partno += 1;
 501    logmsg("Received Basic request, sending back data %ld", req->partno);
 502  }
 503  if(strstr(req->reqbuf, "Connection: close"))
 504    req->open = FALSE; /* close connection after this request */
 505
 506  if(!req->pipe &&
 507     req->open &&
 508     req->prot_version >= 11 &&
 509     req->reqbuf + req->offset > end + strlen(END_OF_HEADERS) &&
 510     (!strncmp(req->reqbuf, "GET", strlen("GET")) ||
 511      !strncmp(req->reqbuf, "HEAD", strlen("HEAD")))) {
 512    /* If we have a persistent connection, HTTP version >= 1.1
 513       and GET/HEAD request, enable pipelining. */
 514    req->checkindex = (end - req->reqbuf) + strlen(END_OF_HEADERS);
 515    req->pipelining = TRUE;
 516  }
 517
 518  while(req->pipe) {
 519    if(got_exit_signal)
 520      return 1; /* done */
 521    /* scan for more header ends within this chunk */
 522    line = &req->reqbuf[req->checkindex];
 523    end = strstr(line, END_OF_HEADERS);
 524    if(!end)
 525      break;
 526    req->checkindex += (end - line) + strlen(END_OF_HEADERS);
 527    req->pipe--;
 528  }
 529
 530  /* If authentication is required and no auth was provided, end now. This
 531     makes the server NOT wait for PUT/POST data and you can then make the
 532     test case send a rejection before any such data has been sent. Test case
 533     154 uses this.*/
 534  if(req->auth_req && !req->auth)
 535    return 1; /* done */
 536
 537  if(req->cl > 0) {
 538    if(req->cl <= req->offset - (end - req->reqbuf) - strlen(END_OF_HEADERS))
 539      return 1; /* done */
 540    else
 541      return 0; /* not complete yet */
 542  }
 543
 544  return 1; /* done */
 545}
 546
 547/* store the entire request in a file */
 548static void rtspd_storerequest(const char *reqbuf, size_t totalsize)
 549{
 550  int res;
 551  int error = 0;
 552  char errbuf[STRERROR_LEN];
 553  size_t written;
 554  size_t writeleft;
 555  FILE *dump;
 556  char dumpfile[256];
 557
 558  snprintf(dumpfile, sizeof(dumpfile), "%s/%s", logdir, REQUEST_DUMP);
 559
 560  if(!reqbuf)
 561    return;
 562  if(totalsize == 0)
 563    return;
 564
 565  do {
 566    dump = curlx_fopen(dumpfile, "ab");
 567    /* !checksrc! disable ERRNOVAR 1 */
 568  } while(!dump && ((error = errno) == EINTR));
 569  if(!dump) {
 570    logmsg("Error opening file %s error (%d) %s", dumpfile,
 571           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 572    logmsg("Failed to write request input to %s", dumpfile);
 573    return;
 574  }
 575
 576  writeleft = totalsize;
 577  do {
 578    written = fwrite(&reqbuf[totalsize - writeleft], 1, writeleft, dump);
 579    if(got_exit_signal)
 580      goto storerequest_cleanup;
 581    if(written > 0)
 582      writeleft -= written;
 583    error = errno;
 584    /* !checksrc! disable ERRNOVAR 1 */
 585  } while((writeleft > 0) && (error == EINTR));
 586
 587  if(writeleft == 0)
 588    logmsg("Wrote request (%zu bytes) input to %s", totalsize, dumpfile);
 589  else if(writeleft > 0) {
 590    logmsg("Error writing file %s error (%d) %s", dumpfile,
 591           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 592    logmsg("Wrote only (%zu bytes) of (%zu bytes) request input to %s",
 593           totalsize - writeleft, totalsize, dumpfile);
 594  }
 595
 596storerequest_cleanup:
 597
 598  res = curlx_fclose(dump);
 599  if(res)
 600    logmsg("Error closing file %s error (%d) %s", dumpfile,
 601           errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
 602}
 603
 604/* return 0 on success, non-zero on failure */
 605static int rtspd_get_request(curl_socket_t sock, struct rtspd_httprequest *req)
 606{
 607  int error;
 608  char errbuf[STRERROR_LEN];
 609  int fail = 0;
 610  int done_processing = 0;
 611  char *reqbuf = req->reqbuf;
 612  ssize_t got = 0;
 613
 614  char *pipereq = NULL;
 615  size_t pipereq_length = 0;
 616
 617  if(req->pipelining) {
 618    pipereq = reqbuf + req->checkindex;
 619    pipereq_length = req->offset - req->checkindex;
 620  }
 621
 622  /* Init the httprequest structure properly for the upcoming request */
 623
 624  req->checkindex = 0;
 625  req->offset = 0;
 626  req->testno = DOCNUMBER_NOTHING;
 627  req->partno = 0;
 628  req->open = TRUE;
 629  req->auth_req = FALSE;
 630  req->auth = FALSE;
 631  req->cl = 0;
 632  req->digest = FALSE;
 633  req->ntlm = FALSE;
 634  req->pipe = 0;
 635  req->skip = 0;
 636  req->rcmd = RCMD_NORMALREQ;
 637  req->protocol = RPROT_NONE;
 638  req->prot_version = 0;
 639  req->pipelining = FALSE;
 640  req->rtp_buffer = NULL;
 641  req->rtp_buffersize = 0;
 642
 643  /* end of httprequest init */
 644
 645  while(!done_processing && (req->offset < sizeof(req->reqbuf) - 1)) {
 646    if(pipereq_length && pipereq) {
 647      memmove(reqbuf, pipereq, pipereq_length);
 648      got = curlx_uztosz(pipereq_length);
 649      pipereq_length = 0;
 650    }
 651    else {
 652      if(req->skip)
 653        /* we are instructed to not read the entire thing, so we make sure to
 654           only read what we are supposed to and NOT read the entire thing the
 655           client wants to send! */
 656        got = sread(sock, reqbuf + req->offset, req->cl);
 657      else
 658        got = sread(sock, reqbuf + req->offset,
 659                    sizeof(req->reqbuf) - 1 - req->offset);
 660    }
 661    if(got_exit_signal)
 662      return 1;
 663    if(got == 0) {
 664      logmsg("Connection closed by client");
 665      fail = 1;
 666    }
 667    else if(got < 0) {
 668      error = SOCKERRNO;
 669      logmsg("recv() returned error (%d) %s",
 670             error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 671      fail = 1;
 672    }
 673    if(fail) {
 674      /* dump the request received so far to the external file */
 675      reqbuf[req->offset] = '\0';
 676      rtspd_storerequest(reqbuf, req->offset);
 677      return 1;
 678    }
 679
 680    logmsg("Read %zd bytes", got);
 681
 682    req->offset += (size_t)got;
 683    reqbuf[req->offset] = '\0';
 684
 685    done_processing = rtspd_ProcessRequest(req);
 686    if(got_exit_signal)
 687      return 1;
 688    if(done_processing && req->pipe) {
 689      logmsg("Waiting for another piped request");
 690      done_processing = 0;
 691      req->pipe--;
 692    }
 693  }
 694
 695  if((req->offset == sizeof(req->reqbuf) - 1) && (got > 0)) {
 696    logmsg("Request would overflow buffer, closing connection");
 697    /* dump request received so far to external file anyway */
 698    reqbuf[sizeof(req->reqbuf) - 1] = '\0';
 699    fail = 1;
 700  }
 701  else if(req->offset > sizeof(req->reqbuf) - 1) {
 702    logmsg("Request buffer overflow, closing connection");
 703    /* dump request received so far to external file anyway */
 704    reqbuf[sizeof(req->reqbuf) - 1] = '\0';
 705    fail = 1;
 706  }
 707  else
 708    reqbuf[req->offset] = '\0';
 709
 710  /* dump the request to an external file */
 711  rtspd_storerequest(reqbuf, req->pipelining ? req->checkindex : req->offset);
 712  if(got_exit_signal)
 713    return 1;
 714
 715  return fail; /* return 0 on success */
 716}
 717
 718/* returns -1 on failure */
 719static int rtspd_send_doc(curl_socket_t sock, struct rtspd_httprequest *req)
 720{
 721  ssize_t written;
 722  size_t count;
 723  const char *buffer;
 724  char *ptr = NULL;
 725  char *cmd = NULL;
 726  size_t cmdsize = 0;
 727  FILE *dump;
 728  bool persistent = TRUE;
 729  bool sendfailure = FALSE;
 730  size_t responsesize;
 731  int error = 0;
 732  char errbuf[STRERROR_LEN];
 733  int res;
 734  static char weare[256];
 735  char responsedump[256];
 736
 737  snprintf(responsedump, sizeof(responsedump), "%s/%s", logdir, RESPONSE_DUMP);
 738
 739  logmsg("Send response number %ld part %ld", req->testno, req->partno);
 740
 741  switch(req->rcmd) {
 742  default:
 743  case RCMD_NORMALREQ:
 744    break; /* continue with business as usual */
 745  case RCMD_STREAM: {
 746    static const char streamthis[] = "a string to stream 01234567890\n";
 747    for(;;) {
 748      written = swrite(sock, streamthis, sizeof(streamthis) - 1);
 749      if(got_exit_signal)
 750        return -1;
 751      if(written != (ssize_t)(sizeof(streamthis) - 1)) {
 752        logmsg("Stopped streaming");
 753        break;
 754      }
 755    }
 756    return -1;
 757  }
 758  case RCMD_IDLE:
 759    /* Do nothing. Sit idle. Pretend it rains. */
 760    return 0;
 761  }
 762
 763  req->open = FALSE;
 764
 765  if(req->testno < 0) {
 766    size_t msglen;
 767    char msgbuf[64];
 768
 769    switch(req->testno) {
 770    case DOCNUMBER_QUIT:
 771      logmsg("Replying to QUIT");
 772      buffer = docquit_rtsp;
 773      break;
 774    case DOCNUMBER_WERULEZ:
 775      /* we got a "friends?" question, reply back that we sure are */
 776      logmsg("Identifying ourselves as friends");
 777      snprintf(msgbuf, sizeof(msgbuf), "RTSP_SERVER WE ROOLZ: %ld\r\n",
 778               (long)our_getpid());
 779      msglen = strlen(msgbuf);
 780      snprintf(weare, sizeof(weare),
 781               "HTTP/1.1 200 OK\r\nContent-Length: %u\r\n\r\n%s",
 782               (unsigned int)msglen, msgbuf);
 783      buffer = weare;
 784      break;
 785    case DOCNUMBER_INTERNAL:
 786      logmsg("Bailing out due to internal error");
 787      return -1;
 788    case DOCNUMBER_CONNECT:
 789      logmsg("Replying to CONNECT");
 790      buffer = docconnect;
 791      break;
 792    case DOCNUMBER_BADCONNECT:
 793      logmsg("Replying to a bad CONNECT");
 794      buffer = docbadconnect;
 795      break;
 796    case DOCNUMBER_404:
 797    default:
 798      logmsg("Replying to with a 404");
 799      if(req->protocol == RPROT_HTTP) {
 800        buffer = doc404_HTTP;
 801      }
 802      else {
 803        buffer = doc404_RTSP;
 804      }
 805      break;
 806    }
 807
 808    count = strlen(buffer);
 809  }
 810  else {
 811    FILE *stream = test2fopen(req->testno, logdir);
 812    char partbuf[80] = "data";
 813    if(req->partno)
 814      snprintf(partbuf, sizeof(partbuf), "data%ld", req->partno);
 815    if(!stream) {
 816      error = errno;
 817      logmsg("fopen() failed with error (%d) %s",
 818             error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 819      logmsg("Could not open test file");
 820      return 0;
 821    }
 822    else {
 823      error = getpart(&ptr, &count, "reply", partbuf, stream);
 824      curlx_fclose(stream);
 825      if(error) {
 826        logmsg("getpart() failed with error (%d)", error);
 827        return 0;
 828      }
 829      buffer = ptr;
 830    }
 831
 832    if(got_exit_signal) {
 833      free(ptr);
 834      return -1;
 835    }
 836
 837    /* re-open the same file again */
 838    stream = test2fopen(req->testno, logdir);
 839    if(!stream) {
 840      error = errno;
 841      logmsg("fopen() failed with error (%d) %s",
 842             error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 843      logmsg("Could not open test file");
 844      free(ptr);
 845      return 0;
 846    }
 847    else {
 848      /* get the custom server control "commands" */
 849      error = getpart(&cmd, &cmdsize, "reply", "postcmd", stream);
 850      curlx_fclose(stream);
 851      if(error) {
 852        logmsg("getpart() failed with error (%d)", error);
 853        free(ptr);
 854        return 0;
 855      }
 856    }
 857  }
 858
 859  if(got_exit_signal) {
 860    free(ptr);
 861    free(cmd);
 862    return -1;
 863  }
 864
 865  /* If the word 'swsclose' is present anywhere in the reply chunk, the
 866     connection will be closed after the data has been sent to the requesting
 867     client... */
 868  if(strstr(buffer, "swsclose") || !count) {
 869    persistent = FALSE;
 870    logmsg("connection close instruction \"swsclose\" found in response");
 871  }
 872  if(strstr(buffer, "swsbounce")) {
 873    rtspd_prevbounce = TRUE;
 874    logmsg("enable \"swsbounce\" in the next request");
 875  }
 876  else
 877    rtspd_prevbounce = FALSE;
 878
 879  dump = curlx_fopen(responsedump, "ab");
 880  if(!dump) {
 881    error = errno;
 882    logmsg("fopen() failed with error (%d) %s",
 883           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 884    logmsg("Error opening file '%s'", responsedump);
 885    logmsg("could not create logfile '%s'", responsedump);
 886    free(ptr);
 887    free(cmd);
 888    return -1;
 889  }
 890
 891  responsesize = count;
 892  do {
 893    /* Ok, we send no more than 200 bytes at a time, just to make sure that
 894       larger chunks are split up so that the client will need to do multiple
 895       recv() calls to get it and thus we exercise that code better */
 896    size_t num = count;
 897    if(num > 200)
 898      num = 200;
 899    written = swrite(sock, buffer, num);
 900    if(written < 0) {
 901      sendfailure = TRUE;
 902      break;
 903    }
 904    else {
 905      logmsg("Sent off %zd bytes", written);
 906    }
 907    /* write to file as well */
 908    fwrite(buffer, 1, (size_t)written, dump);
 909    if(got_exit_signal)
 910      break;
 911
 912    count -= written;
 913    buffer += written;
 914  } while(count > 0);
 915
 916  /* Send out any RTP data */
 917  if(req->rtp_buffer) {
 918    logmsg("About to write %zu RTP bytes", req->rtp_buffersize);
 919    count = req->rtp_buffersize;
 920    do {
 921      size_t num = count;
 922      if(num > 200)
 923        num = 200;
 924      written = swrite(sock, req->rtp_buffer + (req->rtp_buffersize - count),
 925                       num);
 926      if(written < 0) {
 927        sendfailure = TRUE;
 928        break;
 929      }
 930      count -= written;
 931    } while(count > 0);
 932
 933    free(req->rtp_buffer);
 934    req->rtp_buffersize = 0;
 935  }
 936
 937  res = curlx_fclose(dump);
 938  if(res)
 939    logmsg("Error closing file %s error (%d) %s", responsedump,
 940           errno, curlx_strerror(errno, errbuf, sizeof(errbuf)));
 941
 942  if(got_exit_signal) {
 943    free(ptr);
 944    free(cmd);
 945    return -1;
 946  }
 947
 948  if(sendfailure) {
 949    logmsg("Sending response failed. Only (%zu bytes) of "
 950           "(%zu bytes) were sent",
 951           responsesize - count, responsesize);
 952    free(ptr);
 953    free(cmd);
 954    return -1;
 955  }
 956
 957  logmsg("Response sent (%zu bytes) and written to %s",
 958         responsesize, responsedump);
 959  free(ptr);
 960
 961  if(cmdsize > 0) {
 962    char command[32];
 963    int quarters;
 964    int num;
 965    ptr = cmd;
 966    do {
 967      if(sscanf(ptr, "%31s %d", command, &num) == 2) {
 968        if(!strcmp("wait", command)) {
 969          logmsg("Told to sleep for %d seconds", num);
 970          quarters = num * 4;
 971          while(quarters > 0) {
 972            quarters--;
 973            res = curlx_wait_ms(250);
 974            if(got_exit_signal)
 975              break;
 976            if(res) {
 977              /* should not happen */
 978              error = SOCKERRNO;
 979              logmsg("curlx_wait_ms() failed with error (%d) %s",
 980                     error, curlx_strerror(error, errbuf, sizeof(errbuf)));
 981              break;
 982            }
 983          }
 984          if(!quarters)
 985            logmsg("Continuing after sleeping %d seconds", num);
 986        }
 987        else
 988          logmsg("Unknown command in reply command section");
 989      }
 990      ptr = strchr(ptr, '\n');
 991      if(ptr)
 992        ptr++;
 993      else
 994        ptr = NULL;
 995    } while(ptr && *ptr);
 996  }
 997  free(cmd);
 998  req->open = persistent;
 999
1000  rtspd_prevtestno = req->testno;
1001  rtspd_prevpartno = req->partno;
1002
1003  return 0;
1004}
1005
1006static int test_rtspd(int argc, const char *argv[])
1007{
1008  srvr_sockaddr_union_t me;
1009  curl_socket_t sock = CURL_SOCKET_BAD;
1010  curl_socket_t msgsock = CURL_SOCKET_BAD;
1011  int wrotepidfile = 0;
1012  int wroteportfile = 0;
1013  int flag;
1014  unsigned short port = 8999;
1015  struct rtspd_httprequest req;
1016  int rc;
1017  int error;
1018  char errbuf[STRERROR_LEN];
1019  int arg = 1;
1020
1021  memset(&req, 0, sizeof(req));
1022
1023  pidname = ".rtsp.pid";
1024  serverlogfile = "log/rtspd.log";
1025  serverlogslocked = 0;
1026
1027  while(argc > arg) {
1028    const char *opt;
1029    curl_off_t num;
1030    if(!strcmp("--version", argv[arg])) {
1031      printf("rtspd IPv4%s"
1032             "\n",
1033#ifdef USE_IPV6
1034             "/IPv6"
1035#else
1036             ""
1037#endif
1038      );
1039      return 0;
1040    }
1041    else if(!strcmp("--pidfile", argv[arg])) {
1042      arg++;
1043      if(argc > arg)
1044        pidname = argv[arg++];
1045    }
1046    else if(!strcmp("--portfile", argv[arg])) {
1047      arg++;
1048      if(argc > arg)
1049        portname = argv[arg++];
1050    }
1051    else if(!strcmp("--logfile", argv[arg])) {
1052      arg++;
1053      if(argc > arg)
1054        serverlogfile = argv[arg++];
1055    }
1056    else if(!strcmp("--logdir", argv[arg])) {
1057      arg++;
1058      if(argc > arg)
1059        logdir = argv[arg++];
1060    }
1061    else if(!strcmp("--ipv4", argv[arg])) {
1062#ifdef USE_IPV6
1063      ipv_inuse = "IPv4";
1064      use_ipv6 = FALSE;
1065#endif
1066      arg++;
1067    }
1068    else if(!strcmp("--ipv6", argv[arg])) {
1069#ifdef USE_IPV6
1070      ipv_inuse = "IPv6";
1071      use_ipv6 = TRUE;
1072#endif
1073      arg++;
1074    }
1075    else if(!strcmp("--port", argv[arg])) {
1076      arg++;
1077      if(argc > arg) {
1078        opt = argv[arg];
1079        if(!curlx_str_number(&opt, &num, 0xffff))
1080          port = (unsigned short)num;
1081        arg++;
1082      }
1083    }
1084    else if(!strcmp("--srcdir", argv[arg])) {
1085      arg++;
1086      if(argc > arg) {
1087        srcpath = argv[arg];
1088        arg++;
1089      }
1090    }
1091    else {
1092      puts("Usage: rtspd [option]\n"
1093           " --version\n"
1094           " --logfile [file]\n"
1095           " --logdir [directory]\n"
1096           " --pidfile [file]\n"
1097           " --portfile [file]\n"
1098           " --ipv4\n"
1099           " --ipv6\n"
1100           " --port [port]\n"
1101           " --srcdir [path]");
1102      return 0;
1103    }
1104  }
1105
1106  snprintf(loglockfile, sizeof(loglockfile), "%s/%s/rtsp-%s.lock",
1107           logdir, SERVERLOGS_LOCKDIR, ipv_inuse);
1108
1109  install_signal_handlers(false);
1110
1111#ifdef USE_IPV6
1112  if(!use_ipv6)
1113#endif
1114    sock = socket(AF_INET, SOCK_STREAM, 0);
1115#ifdef USE_IPV6
1116  else
1117    sock = socket(AF_INET6, SOCK_STREAM, 0);
1118#endif
1119
1120  if(sock == CURL_SOCKET_BAD) {
1121    error = SOCKERRNO;
1122    logmsg("Error creating socket (%d) %s",
1123           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
1124    goto server_cleanup;
1125  }
1126
1127  flag = 1;
1128  if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) {
1129    error = SOCKERRNO;
1130    logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
1131           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
1132    goto server_cleanup;
1133  }
1134
1135#ifdef USE_IPV6
1136  if(!use_ipv6) {
1137#endif
1138    memset(&me.sa4, 0, sizeof(me.sa4));
1139    me.sa4.sin_family = AF_INET;
1140    me.sa4.sin_addr.s_addr = INADDR_ANY;
1141    me.sa4.sin_port = htons(port);
1142    rc = bind(sock, &me.sa, sizeof(me.sa4));
1143#ifdef USE_IPV6
1144  }
1145  else {
1146    memset(&me.sa6, 0, sizeof(me.sa6));
1147    me.sa6.sin6_family = AF_INET6;
1148    me.sa6.sin6_addr = in6addr_any;
1149    me.sa6.sin6_port = htons(port);
1150    rc = bind(sock, &me.sa, sizeof(me.sa6));
1151  }
1152#endif /* USE_IPV6 */
1153  if(rc) {
1154    error = SOCKERRNO;
1155    logmsg("Error binding socket on port %hu (%d) %s", port,
1156           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
1157    goto server_cleanup;
1158  }
1159
1160  if(!port) {
1161    /* The system was supposed to choose a port number, figure out which
1162       port we actually got and update the listener port value with it. */
1163    curl_socklen_t la_size;
1164    srvr_sockaddr_union_t localaddr;
1165    memset(&localaddr, 0, sizeof(localaddr));
1166#ifdef USE_IPV6
1167    if(!use_ipv6)
1168#endif
1169      la_size = sizeof(localaddr.sa4);
1170#ifdef USE_IPV6
1171    else
1172      la_size = sizeof(localaddr.sa6);
1173#endif
1174    if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
1175      error = SOCKERRNO;
1176      logmsg("getsockname() failed with error (%d) %s",
1177             error, curlx_strerror(error, errbuf, sizeof(errbuf)));
1178      sclose(sock);
1179      goto server_cleanup;
1180    }
1181    switch(localaddr.sa.sa_family) {
1182    case AF_INET:
1183      port = ntohs(localaddr.sa4.sin_port);
1184      break;
1185#ifdef USE_IPV6
1186    case AF_INET6:
1187      port = ntohs(localaddr.sa6.sin6_port);
1188      break;
1189#endif
1190    default:
1191      break;
1192    }
1193    if(!port) {
1194      /* Real failure, listener port shall not be zero beyond this point. */
1195      logmsg("Apparently getsockname() succeeded, with listener port zero.");
1196      logmsg("A valid reason for this failure is a binary built without");
1197      logmsg("proper network library linkage. This might not be the only");
1198      logmsg("reason, but double check it before anything else.");
1199      sclose(sock);
1200      goto server_cleanup;
1201    }
1202  }
1203  logmsg("Running %s version on port %d", ipv_inuse, (int)port);
1204
1205  /* start accepting connections */
1206  rc = listen(sock, 5);
1207  if(rc) {
1208    error = SOCKERRNO;
1209    logmsg("listen() failed with error (%d) %s",
1210           error, curlx_strerror(error, errbuf, sizeof(errbuf)));
1211    goto server_cleanup;
1212  }
1213
1214  /*
1215   * As soon as this server writes its pid file the test harness will
1216   * attempt to connect to this server and initiate its verification.
1217   */
1218
1219  wrotepidfile = write_pidfile(pidname);
1220  if(!wrotepidfile)
1221    goto server_cleanup;
1222
1223  if(portname) {
1224    wroteportfile = write_portfile(portname, port);
1225    if(!wroteportfile)
1226      goto server_cleanup;
1227  }
1228
1229  for(;;) {
1230    msgsock = accept(sock, NULL, NULL);
1231
1232    if(got_exit_signal)
1233      break;
1234    if(msgsock == CURL_SOCKET_BAD) {
1235      error = SOCKERRNO;
1236      logmsg("MAJOR ERROR, accept() failed with error (%d) %s",
1237             error, curlx_strerror(error, errbuf, sizeof(errbuf)));
1238      break;
1239    }
1240
1241    /*
1242     * As soon as this server accepts a connection from the test harness it
1243     * must set the server logs advisor read lock to indicate that server
1244     * logs should not be read until this lock is removed by this server.
1245     */
1246
1247    set_advisor_read_lock(loglockfile);
1248    serverlogslocked = 1;
1249
1250    logmsg("====> Client connect");
1251
1252#if defined(TCP_NODELAY) && !defined(__EMSCRIPTEN__)
1253    /*
1254     * Disable the Nagle algorithm to make it easier to send out a large
1255     * response in many small segments to torture the clients more.
1256     */
1257    flag = 1;
1258    if(setsockopt(msgsock, IPPROTO_TCP, TCP_NODELAY,
1259                  (void *)&flag, sizeof(flag)) == -1) {
1260      logmsg("====> TCP_NODELAY failed");
1261    }
1262#endif
1263
1264    /* initialization of httprequest struct is done in rtspd_get_request(),
1265       but due to pipelining treatment the pipelining struct field must be
1266       initialized previously to FALSE every time a new connection arrives. */
1267
1268    req.pipelining = FALSE;
1269
1270    do {
1271      if(got_exit_signal)
1272        break;
1273
1274      if(rtspd_get_request(msgsock, &req))
1275        /* non-zero means error, break out of loop */
1276        break;
1277
1278      if(rtspd_prevbounce) {
1279        /* bounce treatment requested */
1280        if(req.testno == rtspd_prevtestno) {
1281          req.partno = rtspd_prevpartno + 1;
1282          logmsg("BOUNCE part number to %ld", req.partno);
1283        }
1284        else {
1285          rtspd_prevbounce = FALSE;
1286          rtspd_prevtestno = -1;
1287          rtspd_prevpartno = -1;
1288        }
1289      }
1290
1291      rtspd_send_doc(msgsock, &req);
1292      if(got_exit_signal)
1293        break;
1294
1295      if((req.testno < 0) && (req.testno != DOCNUMBER_CONNECT)) {
1296        logmsg("special request received, no persistency");
1297        break;
1298      }
1299      if(!req.open) {
1300        logmsg("instructed to close connection after server-reply");
1301        break;
1302      }
1303
1304      if(req.open)
1305        logmsg("=> persistent connection request ended, awaits new request");
1306      /* if we got a CONNECT, loop and get another request as well! */
1307    } while(req.open || (req.testno == DOCNUMBER_CONNECT));
1308
1309    if(got_exit_signal)
1310      break;
1311
1312    logmsg("====> Client disconnect");
1313    sclose(msgsock);
1314    msgsock = CURL_SOCKET_BAD;
1315
1316    if(serverlogslocked) {
1317      serverlogslocked = 0;
1318      clear_advisor_read_lock(loglockfile);
1319    }
1320
1321    if(req.testno == DOCNUMBER_QUIT)
1322      break;
1323  }
1324
1325server_cleanup:
1326
1327  if((msgsock != sock) && (msgsock != CURL_SOCKET_BAD))
1328    sclose(msgsock);
1329
1330  if(sock != CURL_SOCKET_BAD)
1331    sclose(sock);
1332
1333  if(got_exit_signal)
1334    logmsg("signalled to die");
1335
1336  if(wrotepidfile)
1337    unlink(pidname);
1338  if(wroteportfile)
1339    unlink(portname);
1340
1341  if(serverlogslocked) {
1342    serverlogslocked = 0;
1343    clear_advisor_read_lock(loglockfile);
1344  }
1345
1346  restore_signal_handlers(false);
1347
1348  if(got_exit_signal) {
1349    logmsg("========> %s rtspd (port: %d pid: %ld) exits with signal (%d)",
1350           ipv_inuse, (int)port, (long)our_getpid(), exit_signal);
1351    /*
1352     * To properly set the return status of the process we
1353     * must raise the same signal SIGINT or SIGTERM that we
1354     * caught and let the old handler take care of it.
1355     */
1356    raise(exit_signal);
1357  }
1358
1359  logmsg("========> rtspd quits");
1360  return 0;
1361}