rtmpsrv.c

   1 /*  Simple RTMP Server
   2  *  Copyright (C) 2009 Andrej Stepanchuk
   3  *  Copyright (C) 2009-2011 Howard Chu
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with RTMPDump; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  *  Boston, MA  02110-1301, USA.
  19  *  http://www.gnu.org/copyleft/gpl.html
  20  *
  21  */
  22
  23 /* This is just a stub for an RTMP server. It doesn't do anything
  24  * beyond obtaining the connection parameters from the client.
  25  */
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <math.h>
  30 #include <limits.h>
  31
  32 #include <signal.h>
  33 #include <getopt.h>
  34
  35 #include <assert.h>
  36
  37 #include "librtmp/rtmp_sys.h"
  38 #include "librtmp/log.h"
  39
  40 #include "thread.h"
  41
  42 #ifdef linux
  43 #include <linux/netfilter_ipv4.h>
  44 #endif
  45
  46 #ifndef WIN32
  47 #include <sys/types.h>
  48 #include <sys/wait.h>
  49 #endif
  50
  51 #define RD_SUCCESS              0
  52 #define RD_FAILED               1
  53 #define RD_INCOMPLETE           2
  54
  55 #define PACKET_SIZE 1024*1024
  56
  57 #ifdef WIN32
  58 #define InitSockets()   {\
  59         WORD version;                   \
  60         WSADATA wsaData;                \
  61                                         \
  62         version = MAKEWORD(1,1);        \
  63         WSAStartup(version, &wsaData);  }
  64
  65 #define CleanupSockets()        WSACleanup()
  66 #else
  67 #define InitSockets()
  68 #define CleanupSockets()
  69 #endif
  70
  71 #define DUPTIME 5000    /* interval we disallow duplicate requests, in msec */
  72
  73 enum
  74 {
  75   STREAMING_ACCEPTING,
  76   STREAMING_IN_PROGRESS,
  77   STREAMING_STOPPING,
  78   STREAMING_STOPPED
  79 };
  80
  81 typedef struct
  82 {
  83   int socket;
  84   int state;
  85   int streamID;
  86   int arglen;
  87   int argc;
  88   uint32_t filetime;    /* time of last download we started */
  89   AVal filename;        /* name of last download */
  90   char *connect;
  91
  92 } STREAMING_SERVER;
  93
  94 STREAMING_SERVER *rtmpServer = 0;       // server structure pointer
  95 void *sslCtx = NULL;
  96
  97 STREAMING_SERVER *startStreaming(const char *address, int port);
  98 void stopStreaming(STREAMING_SERVER * server);
  99 void AVreplace(AVal *src, const AVal *orig, const AVal *repl);
 100
 101 static const AVal av_dquote = AVC("\"");
 102 static const AVal av_escdquote = AVC("\\\"");
 103
 104 typedef struct
 105 {
 106   char *hostname;
 107   int rtmpport;
 108   int protocol;
 109   int bLiveStream;              // is it a live stream? then we can't seek/resume
 110
 111   long int timeout;             // timeout connection afte 300 seconds
 112   uint32_t bufferTime;
 113
 114   char *rtmpurl;
 115   AVal playpath;
 116   AVal swfUrl;
 117   AVal tcUrl;
 118   AVal pageUrl;
 119   AVal app;
 120   AVal auth;
 121   AVal swfHash;
 122   AVal flashVer;
 123   AVal subscribepath;
 124   uint32_t swfSize;
 125
 126   uint32_t dStartOffset;
 127   uint32_t dStopOffset;
 128   uint32_t nTimeStamp;
 129 } RTMP_REQUEST;
 130
 131 #define STR2AVAL(av,str)        av.av_val = str; av.av_len = strlen(av.av_val)
 132
 133 /* this request is formed from the parameters and used to initialize a new request,
 134  * thus it is a default settings list. All settings can be overriden by specifying the
 135  * parameters in the GET request. */
 136 RTMP_REQUEST defaultRTMPRequest;
 137
 138 #ifdef _DEBUG
 139 uint32_t debugTS = 0;
 140
 141 int pnum = 0;
 142
 143 FILE *netstackdump = NULL;
 144 FILE *netstackdump_read = NULL;
 145 #endif
 146
 147 #define SAVC(x) static const AVal av_##x = AVC(#x)
 148
 149 SAVC(app);
 150 SAVC(connect);
 151 SAVC(flashVer);
 152 SAVC(swfUrl);
 153 SAVC(pageUrl);
 154 SAVC(tcUrl);
 155 SAVC(fpad);
 156 SAVC(capabilities);
 157 SAVC(audioCodecs);
 158 SAVC(videoCodecs);
 159 SAVC(videoFunction);
 160 SAVC(objectEncoding);
 161 SAVC(_result);
 162 SAVC(createStream);
 163 SAVC(getStreamLength);
 164 SAVC(play);
 165 SAVC(fmsVer);
 166 SAVC(mode);
 167 SAVC(level);
 168 SAVC(code);
 169 SAVC(description);
 170 SAVC(secureToken);
 171
 172 static int
 173 SendConnectResult(RTMP *r, double txn)
 174 {
 175   RTMPPacket packet;
 176   char pbuf[384], *pend = pbuf+sizeof(pbuf);
 177   AMFObject obj;
 178   AMFObjectProperty p, op;
 179   AVal av;
 180
 181   packet.m_nChannel = 0x03;     // control channel (invoke)
 182   packet.m_headerType = 1; /* RTMP_PACKET_SIZE_MEDIUM; */
 183   packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
 184   packet.m_nTimeStamp = 0;
 185   packet.m_nInfoField2 = 0;
 186   packet.m_hasAbsTimestamp = 0;
 187   packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
 188
 189   char *enc = packet.m_body;
 190   enc = AMF_EncodeString(enc, pend, &av__result);
 191   enc = AMF_EncodeNumber(enc, pend, txn);
 192   *enc++ = AMF_OBJECT;
 193
 194   STR2AVAL(av, "FMS/3,5,1,525");
 195   enc = AMF_EncodeNamedString(enc, pend, &av_fmsVer, &av);
 196   enc = AMF_EncodeNamedNumber(enc, pend, &av_capabilities, 31.0);
 197   enc = AMF_EncodeNamedNumber(enc, pend, &av_mode, 1.0);
 198   *enc++ = 0;
 199   *enc++ = 0;
 200   *enc++ = AMF_OBJECT_END;
 201
 202   *enc++ = AMF_OBJECT;
 203
 204   STR2AVAL(av, "status");
 205   enc = AMF_EncodeNamedString(enc, pend, &av_level, &av);
 206   STR2AVAL(av, "NetConnection.Connect.Success");
 207   enc = AMF_EncodeNamedString(enc, pend, &av_code, &av);
 208   STR2AVAL(av, "Connection succeeded.");
 209   enc = AMF_EncodeNamedString(enc, pend, &av_description, &av);
 210   enc = AMF_EncodeNamedNumber(enc, pend, &av_objectEncoding, r->m_fEncoding);
 211 #if 0
 212   STR2AVAL(av, "58656322c972d6cdf2d776167575045f8484ea888e31c086f7b5ffbd0baec55ce442c2fb");
 213   enc = AMF_EncodeNamedString(enc, pend, &av_secureToken, &av);
 214 #endif
 215   STR2AVAL(p.p_name, "version");
 216   STR2AVAL(p.p_vu.p_aval, "3,5,1,525");
 217   p.p_type = AMF_STRING;
 218   obj.o_num = 1;
 219   obj.o_props = &p;
 220   op.p_type = AMF_OBJECT;
 221   STR2AVAL(op.p_name, "data");
 222   op.p_vu.p_object = obj;
 223   enc = AMFProp_Encode(&op, enc, pend);
 224   *enc++ = 0;
 225   *enc++ = 0;
 226   *enc++ = AMF_OBJECT_END;
 227
 228   packet.m_nBodySize = enc - packet.m_body;
 229
 230   return RTMP_SendPacket(r, &packet, FALSE);
 231 }
 232
 233 static int
 234 SendResultNumber(RTMP *r, double txn, double ID)
 235 {
 236   RTMPPacket packet;
 237   char pbuf[256], *pend = pbuf+sizeof(pbuf);
 238
 239   packet.m_nChannel = 0x03;     // control channel (invoke)
 240   packet.m_headerType = 1; /* RTMP_PACKET_SIZE_MEDIUM; */
 241   packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
 242   packet.m_nTimeStamp = 0;
 243   packet.m_nInfoField2 = 0;
 244   packet.m_hasAbsTimestamp = 0;
 245   packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
 246
 247   char *enc = packet.m_body;
 248   enc = AMF_EncodeString(enc, pend, &av__result);
 249   enc = AMF_EncodeNumber(enc, pend, txn);
 250   *enc++ = AMF_NULL;
 251   enc = AMF_EncodeNumber(enc, pend, ID);
 252
 253   packet.m_nBodySize = enc - packet.m_body;
 254
 255   return RTMP_SendPacket(r, &packet, FALSE);
 256 }
 257
 258 SAVC(onStatus);
 259 SAVC(status);
 260 static const AVal av_NetStream_Play_Start = AVC("NetStream.Play.Start");
 261 static const AVal av_Started_playing = AVC("Started playing");
 262 static const AVal av_NetStream_Play_Stop = AVC("NetStream.Play.Stop");
 263 static const AVal av_Stopped_playing = AVC("Stopped playing");
 264 SAVC(details);
 265 SAVC(clientid);
 266 static const AVal av_NetStream_Authenticate_UsherToken = AVC("NetStream.Authenticate.UsherToken");
 267
 268 static int
 269 SendPlayStart(RTMP *r)
 270 {
 271   RTMPPacket packet;
 272   char pbuf[512], *pend = pbuf+sizeof(pbuf);
 273
 274   packet.m_nChannel = 0x03;     // control channel (invoke)
 275   packet.m_headerType = 1; /* RTMP_PACKET_SIZE_MEDIUM; */
 276   packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
 277   packet.m_nTimeStamp = 0;
 278   packet.m_nInfoField2 = 0;
 279   packet.m_hasAbsTimestamp = 0;
 280   packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
 281
 282   char *enc = packet.m_body;
 283   enc = AMF_EncodeString(enc, pend, &av_onStatus);
 284   enc = AMF_EncodeNumber(enc, pend, 0);
 285   *enc++ = AMF_OBJECT;
 286
 287   enc = AMF_EncodeNamedString(enc, pend, &av_level, &av_status);
 288   enc = AMF_EncodeNamedString(enc, pend, &av_code, &av_NetStream_Play_Start);
 289   enc = AMF_EncodeNamedString(enc, pend, &av_description, &av_Started_playing);
 290   enc = AMF_EncodeNamedString(enc, pend, &av_details, &r->Link.playpath);
 291   enc = AMF_EncodeNamedString(enc, pend, &av_clientid, &av_clientid);
 292   *enc++ = 0;
 293   *enc++ = 0;
 294   *enc++ = AMF_OBJECT_END;
 295
 296   packet.m_nBodySize = enc - packet.m_body;
 297   return RTMP_SendPacket(r, &packet, FALSE);
 298 }
 299
 300 static int
 301 SendPlayStop(RTMP *r)
 302 {
 303   RTMPPacket packet;
 304   char pbuf[512], *pend = pbuf+sizeof(pbuf);
 305
 306   packet.m_nChannel = 0x03;     // control channel (invoke)
 307   packet.m_headerType = 1; /* RTMP_PACKET_SIZE_MEDIUM; */
 308   packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
 309   packet.m_nTimeStamp = 0;
 310   packet.m_nInfoField2 = 0;
 311   packet.m_hasAbsTimestamp = 0;
 312   packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
 313
 314   char *enc = packet.m_body;
 315   enc = AMF_EncodeString(enc, pend, &av_onStatus);
 316   enc = AMF_EncodeNumber(enc, pend, 0);
 317   *enc++ = AMF_OBJECT;
 318
 319   enc = AMF_EncodeNamedString(enc, pend, &av_level, &av_status);
 320   enc = AMF_EncodeNamedString(enc, pend, &av_code, &av_NetStream_Play_Stop);
 321   enc = AMF_EncodeNamedString(enc, pend, &av_description, &av_Stopped_playing);
 322   enc = AMF_EncodeNamedString(enc, pend, &av_details, &r->Link.playpath);
 323   enc = AMF_EncodeNamedString(enc, pend, &av_clientid, &av_clientid);
 324   *enc++ = 0;
 325   *enc++ = 0;
 326   *enc++ = AMF_OBJECT_END;
 327
 328   packet.m_nBodySize = enc - packet.m_body;
 329   return RTMP_SendPacket(r, &packet, FALSE);
 330 }
 331
 332 static void
 333 spawn_dumper(int argc, AVal *av, char *cmd)
 334 {
 335 #ifdef WIN32
 336   STARTUPINFO si = {0};
 337   PROCESS_INFORMATION pi = {0};
 338
 339   si.cb = sizeof(si);
 340   if (CreateProcess(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL,
 341     &si, &pi))
 342     {
 343       CloseHandle(pi.hThread);
 344       CloseHandle(pi.hProcess);
 345     }
 346 #else
 347   /* reap any dead children */
 348   while (waitpid(-1, NULL, WNOHANG) > 0);
 349
 350   if (fork() == 0) {
 351     char **argv = malloc((argc+1) * sizeof(char *));
 352     int i;
 353
 354     for (i=0; i<argc; i++) {
 355       argv[i] = av[i].av_val;
 356       argv[i][av[i].av_len] = '\0';
 357     }
 358     argv[i] = NULL;
 359     if ((i = execvp(argv[0], argv)))
 360       _exit(i);
 361   }
 362 #endif
 363 }
 364
 365 static int
 366 countAMF(AMFObject *obj, int *argc)
 367 {
 368   int i, len;
 369
 370   for (i=0, len=0; i < obj->o_num; i++)
 371     {
 372       AMFObjectProperty *p = &obj->o_props[i];
 373       len += 4;
 374       (*argc)+= 2;
 375       if (p->p_name.av_val)
 376         len += 1;
 377       len += 2;
 378       if (p->p_name.av_val)
 379         len += p->p_name.av_len + 1;
 380       switch(p->p_type)
 381         {
 382         case AMF_BOOLEAN:
 383           len += 1;
 384           break;
 385         case AMF_STRING:
 386           len += p->p_vu.p_aval.av_len;
 387           break;
 388         case AMF_NUMBER:
 389           len += 40;
 390           break;
 391         case AMF_OBJECT:
 392           len += 9;
 393           len += countAMF(&p->p_vu.p_object, argc);
 394           (*argc) += 2;
 395           break;
 396         case AMF_NULL:
 397         default:
 398           break;
 399         }
 400     }
 401   return len;
 402 }
 403
 404 static char *
 405 dumpAMF(AMFObject *obj, char *ptr, AVal *argv, int *argc)
 406 {
 407   int i, ac = *argc;
 408   const char opt[] = "NBSO Z";
 409
 410   for (i=0; i < obj->o_num; i++)
 411     {
 412       AMFObjectProperty *p = &obj->o_props[i];
 413       argv[ac].av_val = ptr+1;
 414       argv[ac++].av_len = 2;
 415       ptr += sprintf(ptr, " -C ");
 416       argv[ac].av_val = ptr;
 417       if (p->p_name.av_val)
 418         *ptr++ = 'N';
 419       *ptr++ = opt[p->p_type];
 420       *ptr++ = ':';
 421       if (p->p_name.av_val)
 422         ptr += sprintf(ptr, "%.*s:", p->p_name.av_len, p->p_name.av_val);
 423       switch(p->p_type)
 424         {
 425         case AMF_BOOLEAN:
 426           *ptr++ = p->p_vu.p_number != 0 ? '1' : '0';
 427           argv[ac].av_len = ptr - argv[ac].av_val;
 428           break;
 429         case AMF_STRING:
 430           memcpy(ptr, p->p_vu.p_aval.av_val, p->p_vu.p_aval.av_len);
 431           ptr += p->p_vu.p_aval.av_len;
 432           argv[ac].av_len = ptr - argv[ac].av_val;
 433           break;
 434         case AMF_NUMBER:
 435           ptr += sprintf(ptr, "%f", p->p_vu.p_number);
 436           argv[ac].av_len = ptr - argv[ac].av_val;
 437           break;
 438         case AMF_OBJECT:
 439           *ptr++ = '1';
 440           argv[ac].av_len = ptr - argv[ac].av_val;
 441           ac++;
 442           *argc = ac;
 443           ptr = dumpAMF(&p->p_vu.p_object, ptr, argv, argc);
 444           ac = *argc;
 445           argv[ac].av_val = ptr+1;
 446           argv[ac++].av_len = 2;
 447           argv[ac].av_val = ptr+4;
 448           argv[ac].av_len = 3;
 449           ptr += sprintf(ptr, " -C O:0");
 450           break;
 451         case AMF_NULL:
 452         default:
 453           argv[ac].av_len = ptr - argv[ac].av_val;
 454           break;
 455         }
 456       ac++;
 457     }
 458   *argc = ac;
 459   return ptr;
 460 }
 461
 462 // Returns 0 for OK/Failed/error, 1 for 'Stop or Complete'
 463 int
 464 ServeInvoke(STREAMING_SERVER *server, RTMP * r, RTMPPacket *packet, unsigned int offset)
 465 {
 466   const char *body;
 467   unsigned int nBodySize;
 468   int ret = 0, nRes;
 469
 470   body = packet->m_body + offset;
 471   nBodySize = packet->m_nBodySize - offset;
 472
 473   if (body[0] != 0x02)          // make sure it is a string method name we start with
 474     {
 475       RTMP_Log(RTMP_LOGWARNING, "%s, Sanity failed. no string method in invoke packet",
 476           __FUNCTION__);
 477       return 0;
 478     }
 479
 480   AMFObject obj;
 481   nRes = AMF_Decode(&obj, body, nBodySize, FALSE);
 482   if (nRes < 0)
 483     {
 484       RTMP_Log(RTMP_LOGERROR, "%s, error decoding invoke packet", __FUNCTION__);
 485       return 0;
 486     }
 487
 488   AMF_Dump(&obj);
 489   AVal method;
 490   AMFProp_GetString(AMF_GetProp(&obj, NULL, 0), &method);
 491   double txn = AMFProp_GetNumber(AMF_GetProp(&obj, NULL, 1));
 492   RTMP_Log(RTMP_LOGDEBUG, "%s, client invoking <%s>", __FUNCTION__, method.av_val);
 493
 494   if (AVMATCH(&method, &av_connect))
 495     {
 496       AMFObject cobj;
 497       AVal pname, pval;
 498       int i;
 499
 500       server->connect = packet->m_body;
 501       packet->m_body = NULL;
 502
 503       AMFProp_GetObject(AMF_GetProp(&obj, NULL, 2), &cobj);
 504       for (i=0; i<cobj.o_num; i++)
 505         {
 506           pname = cobj.o_props[i].p_name;
 507           pval.av_val = NULL;
 508           pval.av_len = 0;
 509           if (cobj.o_props[i].p_type == AMF_STRING)
 510             pval = cobj.o_props[i].p_vu.p_aval;
 511           if (AVMATCH(&pname, &av_app))
 512             {
 513               r->Link.app = pval;
 514               pval.av_val = NULL;
 515               if (!r->Link.app.av_val)
 516                 r->Link.app.av_val = "";
 517               server->arglen += 6 + pval.av_len;
 518               server->argc += 2;
 519             }
 520           else if (AVMATCH(&pname, &av_flashVer))
 521             {
 522               r->Link.flashVer = pval;
 523               pval.av_val = NULL;
 524               server->arglen += 6 + pval.av_len;
 525               server->argc += 2;
 526             }
 527           else if (AVMATCH(&pname, &av_swfUrl))
 528             {
 529               r->Link.swfUrl = pval;
 530               pval.av_val = NULL;
 531               server->arglen += 6 + pval.av_len;
 532               server->argc += 2;
 533             }
 534           else if (AVMATCH(&pname, &av_tcUrl))
 535             {
 536               r->Link.tcUrl = pval;
 537               pval.av_val = NULL;
 538               server->arglen += 6 + pval.av_len;
 539               server->argc += 2;
 540             }
 541           else if (AVMATCH(&pname, &av_pageUrl))
 542             {
 543               r->Link.pageUrl = pval;
 544               pval.av_val = NULL;
 545               server->arglen += 6 + pval.av_len;
 546               server->argc += 2;
 547             }
 548           else if (AVMATCH(&pname, &av_audioCodecs))
 549             {
 550               r->m_fAudioCodecs = cobj.o_props[i].p_vu.p_number;
 551             }
 552           else if (AVMATCH(&pname, &av_videoCodecs))
 553             {
 554               r->m_fVideoCodecs = cobj.o_props[i].p_vu.p_number;
 555             }
 556           else if (AVMATCH(&pname, &av_objectEncoding))
 557             {
 558               r->m_fEncoding = cobj.o_props[i].p_vu.p_number;
 559             }
 560         }
 561       /* Still have more parameters? Copy them */
 562       if (obj.o_num > 3)
 563         {
 564           int i = obj.o_num - 3;
 565           r->Link.extras.o_num = i;
 566           r->Link.extras.o_props = malloc(i*sizeof(AMFObjectProperty));
 567           memcpy(r->Link.extras.o_props, obj.o_props+3, i*sizeof(AMFObjectProperty));
 568           obj.o_num = 3;
 569           server->arglen += countAMF(&r->Link.extras, &server->argc);
 570         }
 571       SendConnectResult(r, txn);
 572     }
 573   else if (AVMATCH(&method, &av_createStream))
 574     {
 575       SendResultNumber(r, txn, ++server->streamID);
 576     }
 577   else if (AVMATCH(&method, &av_getStreamLength))
 578     {
 579       SendResultNumber(r, txn, 10.0);
 580     }
 581   else if (AVMATCH(&method, &av_NetStream_Authenticate_UsherToken))
 582     {
 583       AVal usherToken;
 584       AMFProp_GetString(AMF_GetProp(&obj, NULL, 3), &usherToken);
 585       AVreplace(&usherToken, &av_dquote, &av_escdquote);
 586       server->arglen += 6 + usherToken.av_len;
 587       server->argc += 2;
 588       r->Link.usherToken = usherToken;
 589     }
 590   else if (AVMATCH(&method, &av_play))
 591     {
 592       char *file, *p, *q, *cmd, *ptr;
 593       AVal *argv, av;
 594       int len, argc;
 595       uint32_t now;
 596       RTMPPacket pc = {0};
 597       AMFProp_GetString(AMF_GetProp(&obj, NULL, 3), &r->Link.playpath);
 598       if (!r->Link.playpath.av_len)
 599         return 0;
 600       /*
 601       r->Link.seekTime = AMFProp_GetNumber(AMF_GetProp(&obj, NULL, 4));
 602       if (obj.o_num > 5)
 603         r->Link.length = AMFProp_GetNumber(AMF_GetProp(&obj, NULL, 5));
 604       */
 605       if (r->Link.tcUrl.av_len)
 606         {
 607           len = server->arglen + r->Link.playpath.av_len + 4 +
 608             sizeof("rtmpdump") + r->Link.playpath.av_len + 12;
 609           server->argc += 5;
 610
 611           cmd = malloc(len + server->argc * sizeof(AVal));
 612           ptr = cmd;
 613           argv = (AVal *)(cmd + len);
 614           argv[0].av_val = cmd;
 615           argv[0].av_len = sizeof("rtmpdump")-1;
 616           ptr += sprintf(ptr, "rtmpdump");
 617           argc = 1;
 618
 619           argv[argc].av_val = ptr + 1;
 620           argv[argc++].av_len = 2;
 621           argv[argc].av_val = ptr + 5;
 622           ptr += sprintf(ptr," -r \"%s\"", r->Link.tcUrl.av_val);
 623           argv[argc++].av_len = r->Link.tcUrl.av_len;
 624
 625           if (r->Link.app.av_val)
 626             {
 627               argv[argc].av_val = ptr + 1;
 628               argv[argc++].av_len = 2;
 629               argv[argc].av_val = ptr + 5;
 630               ptr += sprintf(ptr, " -a \"%s\"", r->Link.app.av_val);
 631               argv[argc++].av_len = r->Link.app.av_len;
 632             }
 633           if (r->Link.flashVer.av_val)
 634             {
 635               argv[argc].av_val = ptr + 1;
 636               argv[argc++].av_len = 2;
 637               argv[argc].av_val = ptr + 5;
 638               ptr += sprintf(ptr, " -f \"%s\"", r->Link.flashVer.av_val);
 639               argv[argc++].av_len = r->Link.flashVer.av_len;
 640             }
 641           if (r->Link.swfUrl.av_val)
 642             {
 643               argv[argc].av_val = ptr + 1;
 644               argv[argc++].av_len = 2;
 645               argv[argc].av_val = ptr + 5;
 646               ptr += sprintf(ptr, " -W \"%s\"", r->Link.swfUrl.av_val);
 647               argv[argc++].av_len = r->Link.swfUrl.av_len;
 648             }
 649           if (r->Link.pageUrl.av_val)
 650             {
 651               argv[argc].av_val = ptr + 1;
 652               argv[argc++].av_len = 2;
 653               argv[argc].av_val = ptr + 5;
 654               ptr += sprintf(ptr, " -p \"%s\"", r->Link.pageUrl.av_val);
 655               argv[argc++].av_len = r->Link.pageUrl.av_len;
 656             }
 657           if (r->Link.usherToken.av_val)
 658             {
 659               argv[argc].av_val = ptr + 1;
 660               argv[argc++].av_len = 2;
 661               argv[argc].av_val = ptr + 5;
 662               ptr += sprintf(ptr, " -j \"%s\"", r->Link.usherToken.av_val);
 663               argv[argc++].av_len = r->Link.usherToken.av_len;
 664               free(r->Link.usherToken.av_val);
 665               r->Link.usherToken.av_val = NULL;
 666               r->Link.usherToken.av_len = 0;
 667             }
 668           if (r->Link.extras.o_num) {
 669             ptr = dumpAMF(&r->Link.extras, ptr, argv, &argc);
 670             AMF_Reset(&r->Link.extras);
 671           }
 672           argv[argc].av_val = ptr + 1;
 673           argv[argc++].av_len = 2;
 674           argv[argc].av_val = ptr + 5;
 675           ptr += sprintf(ptr, " -y \"%.*s\"",
 676             r->Link.playpath.av_len, r->Link.playpath.av_val);
 677           argv[argc++].av_len = r->Link.playpath.av_len;
 678
 679           av = r->Link.playpath;
 680           /* strip trailing URL parameters */
 681           q = memchr(av.av_val, '?', av.av_len);
 682           if (q)
 683             {
 684               if (q == av.av_val)
 685                 {
 686                   av.av_val++;
 687                   av.av_len--;
 688                 }
 689               else
 690                 {
 691                   av.av_len = q - av.av_val;
 692                 }
 693             }
 694           /* strip leading slash components */
 695           for (p=av.av_val+av.av_len-1; p>=av.av_val; p--)
 696             if (*p == '/')
 697               {
 698                 p++;
 699                 av.av_len -= p - av.av_val;
 700                 av.av_val = p;
 701                 break;
 702               }
 703           /* skip leading dot */
 704           if (av.av_val[0] == '.')
 705             {
 706               av.av_val++;
 707               av.av_len--;
 708             }
 709           file = malloc(av.av_len+5);
 710
 711           memcpy(file, av.av_val, av.av_len);
 712           file[av.av_len] = '\0';
 713           for (p=file; *p; p++)
 714             if (*p == ':')
 715               *p = '_';
 716
 717           /* Add extension if none present */
 718           if (file[av.av_len - 4] != '.')
 719             {
 720               av.av_len += 4;
 721             }
 722           /* Always use flv extension, regardless of original */
 723           if (strcmp(file+av.av_len-4, ".flv"))
 724             {
 725               strcpy(file+av.av_len-4, ".flv");
 726             }
 727           argv[argc].av_val = ptr + 1;
 728           argv[argc++].av_len = 2;
 729           argv[argc].av_val = file;
 730           argv[argc].av_len = av.av_len;
 731           ptr += sprintf(ptr, " -o %s", file);
 732           now = RTMP_GetTime();
 733           if (now - server->filetime < DUPTIME && AVMATCH(&argv[argc], &server->filename))
 734             {
 735               printf("Duplicate request, skipping.\n");
 736               free(file);
 737             }
 738           else
 739             {
 740               printf("\n%s\n\n", cmd);
 741               fflush(stdout);
 742               server->filetime = now;
 743               free(server->filename.av_val);
 744               server->filename = argv[argc++];
 745               spawn_dumper(argc, argv, cmd);
 746             }
 747
 748           free(cmd);
 749         }
 750       pc.m_body = server->connect;
 751       server->connect = NULL;
 752       RTMPPacket_Free(&pc);
 753       ret = 1;
 754           RTMP_SendCtrl(r, 0, 1, 0);
 755           SendPlayStart(r);
 756           RTMP_SendCtrl(r, 1, 1, 0);
 757           SendPlayStop(r);
 758     }
 759   AMF_Reset(&obj);
 760   return ret;
 761 }
 762
 763 int
 764 ServePacket(STREAMING_SERVER *server, RTMP *r, RTMPPacket *packet)
 765 {
 766   int ret = 0;
 767
 768   RTMP_Log(RTMP_LOGDEBUG, "%s, received packet type %02X, size %u bytes", __FUNCTION__,
 769     packet->m_packetType, packet->m_nBodySize);
 770
 771   switch (packet->m_packetType)
 772     {
 773     case RTMP_PACKET_TYPE_CHUNK_SIZE:
 774 //      HandleChangeChunkSize(r, packet);
 775       break;
 776
 777     case RTMP_PACKET_TYPE_BYTES_READ_REPORT:
 778       break;
 779
 780     case RTMP_PACKET_TYPE_CONTROL:
 781 //      HandleCtrl(r, packet);
 782       break;
 783
 784     case RTMP_PACKET_TYPE_SERVER_BW:
 785 //      HandleServerBW(r, packet);
 786       break;
 787
 788     case RTMP_PACKET_TYPE_CLIENT_BW:
 789  //     HandleClientBW(r, packet);
 790       break;
 791
 792     case RTMP_PACKET_TYPE_AUDIO:
 793       //RTMP_Log(RTMP_LOGDEBUG, "%s, received: audio %lu bytes", __FUNCTION__, packet.m_nBodySize);
 794       break;
 795
 796     case RTMP_PACKET_TYPE_VIDEO:
 797       //RTMP_Log(RTMP_LOGDEBUG, "%s, received: video %lu bytes", __FUNCTION__, packet.m_nBodySize);
 798       break;
 799
 800     case RTMP_PACKET_TYPE_FLEX_STREAM_SEND:
 801       break;
 802
 803     case RTMP_PACKET_TYPE_FLEX_SHARED_OBJECT:
 804       break;
 805
 806     case RTMP_PACKET_TYPE_FLEX_MESSAGE:
 807       {
 808         RTMP_Log(RTMP_LOGDEBUG, "%s, flex message, size %u bytes, not fully supported",
 809             __FUNCTION__, packet->m_nBodySize);
 810         //RTMP_LogHex(packet.m_body, packet.m_nBodySize);
 811
 812         // some DEBUG code
 813         /*RTMP_LIB_AMFObject obj;
 814            int nRes = obj.Decode(packet.m_body+1, packet.m_nBodySize-1);
 815            if(nRes < 0) {
 816            RTMP_Log(RTMP_LOGERROR, "%s, error decoding AMF3 packet", __FUNCTION__);
 817            //return;
 818            }
 819
 820            obj.Dump(); */
 821
 822         if (ServeInvoke(server, r, packet, 1))
 823           RTMP_Close(r);
 824         break;
 825       }
 826     case RTMP_PACKET_TYPE_INFO:
 827       break;
 828
 829     case RTMP_PACKET_TYPE_SHARED_OBJECT:
 830       break;
 831
 832     case RTMP_PACKET_TYPE_INVOKE:
 833       RTMP_Log(RTMP_LOGDEBUG, "%s, received: invoke %u bytes", __FUNCTION__,
 834           packet->m_nBodySize);
 835       //RTMP_LogHex(packet.m_body, packet.m_nBodySize);
 836
 837       if (ServeInvoke(server, r, packet, 0))
 838         RTMP_Close(r);
 839       break;
 840
 841     case RTMP_PACKET_TYPE_FLASH_VIDEO:
 842         break;
 843     default:
 844       RTMP_Log(RTMP_LOGDEBUG, "%s, unknown packet type received: 0x%02x", __FUNCTION__,
 845           packet->m_packetType);
 846 #ifdef _DEBUG
 847       RTMP_LogHex(RTMP_LOGDEBUG, packet->m_body, packet->m_nBodySize);
 848 #endif
 849     }
 850   return ret;
 851 }
 852
 853 TFTYPE
 854 controlServerThread(void *unused)
 855 {
 856   char ich;
 857   while (1)
 858     {
 859       ich = getchar();
 860       switch (ich)
 861         {
 862         case 'q':
 863           RTMP_LogPrintf("Exiting\n");
 864           stopStreaming(rtmpServer);
 865           exit(0);
 866           break;
 867         default:
 868           RTMP_LogPrintf("Unknown command \'%c\', ignoring\n", ich);
 869         }
 870     }
 871   TFRET();
 872 }
 873
 874
 875 void doServe(STREAMING_SERVER * server, // server socket and state (our listening socket)
 876   int sockfd    // client connection socket
 877   )
 878 {
 879   server->state = STREAMING_IN_PROGRESS;
 880
 881   RTMP *rtmp = RTMP_Alloc();            /* our session with the real client */
 882   RTMPPacket packet = { 0 };
 883
 884   // timeout for http requests
 885   fd_set fds;
 886   struct timeval tv;
 887
 888   memset(&tv, 0, sizeof(struct timeval));
 889   tv.tv_sec = 5;
 890
 891   FD_ZERO(&fds);
 892   FD_SET(sockfd, &fds);
 893
 894   if (select(sockfd + 1, &fds, NULL, NULL, &tv) <= 0)
 895     {
 896       RTMP_Log(RTMP_LOGERROR, "Request timeout/select failed, ignoring request");
 897       goto quit;
 898     }
 899   else
 900     {
 901       RTMP_Init(rtmp);
 902       rtmp->m_sb.sb_socket = sockfd;
 903       if (sslCtx && !RTMP_TLS_Accept(rtmp, sslCtx))
 904         {
 905           RTMP_Log(RTMP_LOGERROR, "TLS handshake failed");
 906           goto cleanup;
 907         }
 908       if (!RTMP_Serve(rtmp))
 909         {
 910           RTMP_Log(RTMP_LOGERROR, "Handshake failed");
 911           goto cleanup;
 912         }
 913     }
 914   server->arglen = 0;
 915   while (RTMP_IsConnected(rtmp) && RTMP_ReadPacket(rtmp, &packet))
 916     {
 917       if (!RTMPPacket_IsReady(&packet))
 918         continue;
 919       ServePacket(server, rtmp, &packet);
 920       RTMPPacket_Free(&packet);
 921     }
 922
 923 cleanup:
 924   RTMP_LogPrintf("Closing connection... ");
 925   RTMP_Close(rtmp);
 926   /* Should probably be done by RTMP_Close() ... */
 927   rtmp->Link.playpath.av_val = NULL;
 928   rtmp->Link.tcUrl.av_val = NULL;
 929   rtmp->Link.swfUrl.av_val = NULL;
 930   rtmp->Link.pageUrl.av_val = NULL;
 931   rtmp->Link.app.av_val = NULL;
 932   rtmp->Link.flashVer.av_val = NULL;
 933   if (rtmp->Link.usherToken.av_val)
 934     {
 935       free(rtmp->Link.usherToken.av_val);
 936       rtmp->Link.usherToken.av_val = NULL;
 937     }
 938   RTMP_Free(rtmp);
 939   RTMP_LogPrintf("done!\n\n");
 940
 941 quit:
 942   if (server->state == STREAMING_IN_PROGRESS)
 943     server->state = STREAMING_ACCEPTING;
 944
 945   return;
 946 }
 947
 948 TFTYPE
 949 serverThread(void *arg)
 950 {
 951   STREAMING_SERVER *server = arg;
 952   server->state = STREAMING_ACCEPTING;
 953
 954   while (server->state == STREAMING_ACCEPTING)
 955     {
 956       struct sockaddr_in addr;
 957       socklen_t addrlen = sizeof(struct sockaddr_in);
 958       int sockfd =
 959         accept(server->socket, (struct sockaddr *) &addr, &addrlen);
 960
 961       if (sockfd > 0)
 962         {
 963 #ifdef linux
 964           struct sockaddr_in dest;
 965           char destch[16];
 966           socklen_t destlen = sizeof(struct sockaddr_in);
 967           getsockopt(sockfd, SOL_IP, SO_ORIGINAL_DST, &dest, &destlen);
 968           strcpy(destch, inet_ntoa(dest.sin_addr));
 969           RTMP_Log(RTMP_LOGDEBUG, "%s: accepted connection from %s to %s\n", __FUNCTION__,
 970               inet_ntoa(addr.sin_addr), destch);
 971 #else
 972           RTMP_Log(RTMP_LOGDEBUG, "%s: accepted connection from %s\n", __FUNCTION__,
 973               inet_ntoa(addr.sin_addr));
 974 #endif
 975           /* Create a new thread and transfer the control to that */
 976           doServe(server, sockfd);
 977           RTMP_Log(RTMP_LOGDEBUG, "%s: processed request\n", __FUNCTION__);
 978         }
 979       else
 980         {
 981           RTMP_Log(RTMP_LOGERROR, "%s: accept failed", __FUNCTION__);
 982         }
 983     }
 984   server->state = STREAMING_STOPPED;
 985   TFRET();
 986 }
 987
 988 STREAMING_SERVER *
 989 startStreaming(const char *address, int port)
 990 {
 991   struct sockaddr_in addr;
 992   int sockfd, tmp;
 993   STREAMING_SERVER *server;
 994
 995   sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 996   if (sockfd == -1)
 997     {
 998       RTMP_Log(RTMP_LOGERROR, "%s, couldn't create socket", __FUNCTION__);
 999       return 0;
1000     }
1001
1002   tmp = 1;
1003   setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
1004                                 (char *) &tmp, sizeof(tmp) );
1005
1006   addr.sin_family = AF_INET;
1007   addr.sin_addr.s_addr = inet_addr(address);    //htonl(INADDR_ANY);
1008   addr.sin_port = htons(port);
1009
1010   if (bind(sockfd, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) ==
1011       -1)
1012     {
1013       RTMP_Log(RTMP_LOGERROR, "%s, TCP bind failed for port number: %d", __FUNCTION__,
1014           port);
1015       return 0;
1016     }
1017
1018   if (listen(sockfd, 10) == -1)
1019     {
1020       RTMP_Log(RTMP_LOGERROR, "%s, listen failed", __FUNCTION__);
1021       closesocket(sockfd);
1022       return 0;
1023     }
1024
1025   server = (STREAMING_SERVER *) calloc(1, sizeof(STREAMING_SERVER));
1026   server->socket = sockfd;
1027
1028   ThreadCreate(serverThread, server);
1029
1030   return server;
1031 }
1032
1033 void
1034 stopStreaming(STREAMING_SERVER * server)
1035 {
1036   assert(server);
1037
1038   if (server->state != STREAMING_STOPPED)
1039     {
1040       if (server->state == STREAMING_IN_PROGRESS)
1041         {
1042           server->state = STREAMING_STOPPING;
1043
1044           // wait for streaming threads to exit
1045           while (server->state != STREAMING_STOPPED)
1046             msleep(1);
1047         }
1048
1049       if (closesocket(server->socket))
1050         RTMP_Log(RTMP_LOGERROR, "%s: Failed to close listening socket, error %d",
1051             __FUNCTION__, GetSockError());
1052
1053       server->state = STREAMING_STOPPED;
1054     }
1055 }
1056
1057
1058 void
1059 sigIntHandler(int sig)
1060 {
1061   RTMP_ctrlC = TRUE;
1062   RTMP_LogPrintf("Caught signal: %d, cleaning up, just a second...\n", sig);
1063   if (rtmpServer)
1064     stopStreaming(rtmpServer);
1065   signal(SIGINT, SIG_DFL);
1066 }
1067
1068 int
1069 main(int argc, char **argv)
1070 {
1071   int nStatus = RD_SUCCESS;
1072   int i;
1073
1074   // http streaming server
1075   char DEFAULT_HTTP_STREAMING_DEVICE[] = "0.0.0.0";     // 0.0.0.0 is any device
1076
1077   char *rtmpStreamingDevice = DEFAULT_HTTP_STREAMING_DEVICE;    // streaming device, default 0.0.0.0
1078   int nRtmpStreamingPort = 1935;        // port
1079   char *cert = NULL, *key = NULL;
1080
1081   RTMP_LogPrintf("RTMP Server %s\n", RTMPDUMP_VERSION);
1082   RTMP_LogPrintf("(c) 2010 Andrej Stepanchuk, Howard Chu; license: GPL\n\n");
1083
1084   RTMP_debuglevel = RTMP_LOGINFO;
1085
1086   for (i = 1; i < argc; i++)
1087     {
1088       if (!strcmp(argv[i], "-z"))
1089         RTMP_debuglevel = RTMP_LOGALL;
1090       else if (!strcmp(argv[i], "-c") && i + 1 < argc)
1091         cert = argv[++i];
1092       else if (!strcmp(argv[i], "-k") && i + 1 < argc)
1093         key = argv[++i];
1094     }
1095
1096   if (cert && key)
1097     sslCtx = RTMP_TLS_AllocServerContext(cert, key);
1098
1099   // init request
1100   memset(&defaultRTMPRequest, 0, sizeof(RTMP_REQUEST));
1101
1102   defaultRTMPRequest.rtmpport = -1;
1103   defaultRTMPRequest.protocol = RTMP_PROTOCOL_UNDEFINED;
1104   defaultRTMPRequest.bLiveStream = FALSE;       // is it a live stream? then we can't seek/resume
1105
1106   defaultRTMPRequest.timeout = 300;     // timeout connection afte 300 seconds
1107   defaultRTMPRequest.bufferTime = 20 * 1000;
1108
1109
1110   signal(SIGINT, sigIntHandler);
1111 #ifndef WIN32
1112   signal(SIGPIPE, SIG_IGN);
1113 #endif
1114
1115 #ifdef _DEBUG
1116   netstackdump = fopen("netstackdump", "wb");
1117   netstackdump_read = fopen("netstackdump_read", "wb");
1118 #endif
1119
1120   InitSockets();
1121
1122   // start text UI
1123   ThreadCreate(controlServerThread, 0);
1124
1125   // start http streaming
1126   if ((rtmpServer =
1127        startStreaming(rtmpStreamingDevice, nRtmpStreamingPort)) == 0)
1128     {
1129       RTMP_Log(RTMP_LOGERROR, "Failed to start RTMP server, exiting!");
1130       return RD_FAILED;
1131     }
1132   RTMP_LogPrintf("Streaming on rtmp://%s:%d\n", rtmpStreamingDevice,
1133             nRtmpStreamingPort);
1134
1135   while (rtmpServer->state != STREAMING_STOPPED)
1136     {
1137       sleep(1);
1138     }
1139   RTMP_Log(RTMP_LOGDEBUG, "Done, exiting...");
1140
1141   if (sslCtx)
1142     RTMP_TLS_FreeServerContext(sslCtx);
1143
1144   CleanupSockets();
1145
1146 #ifdef _DEBUG
1147   if (netstackdump != 0)
1148     fclose(netstackdump);
1149   if (netstackdump_read != 0)
1150     fclose(netstackdump_read);
1151 #endif
1152   return nStatus;
1153 }
1154
1155 void
1156 AVreplace(AVal *src, const AVal *orig, const AVal *repl)
1157 {
1158   char *srcbeg = src->av_val;
1159   char *srcend = src->av_val + src->av_len;
1160   char *dest, *sptr, *dptr;
1161   int n = 0;
1162
1163   /* count occurrences of orig in src */
1164   sptr = src->av_val;
1165   while (sptr < srcend && (sptr = strstr(sptr, orig->av_val)))
1166     {
1167       n++;
1168       sptr += orig->av_len;
1169     }
1170   if (!n)
1171     return;
1172
1173   dest = malloc(src->av_len + 1 + (repl->av_len - orig->av_len) * n);
1174
1175   sptr = src->av_val;
1176   dptr = dest;
1177   while (sptr < srcend && (sptr = strstr(sptr, orig->av_val)))
1178     {
1179       n = sptr - srcbeg;
1180       memcpy(dptr, srcbeg, n);
1181       dptr += n;
1182       memcpy(dptr, repl->av_val, repl->av_len);
1183       dptr += repl->av_len;
1184       sptr += orig->av_len;
1185       srcbeg = sptr;
1186     }
1187   n = srcend - srcbeg;
1188   memcpy(dptr, srcbeg, n);
1189   dptr += n;
1190   *dptr = '\0';
1191   src->av_val = dest;
1192   src->av_len = dptr - dest;
1193 }