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