?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
More for input buffer checks
[rtmpdump.git] / librtmp / rtmp.c
blobca7db6a49aebb8f14b505d4505f3c6415a5daa00
1 /*
2 * Copyright (C) 2005-2008 Team XBMC
3 * http://www.xbmc.org
4 * Copyright (C) 2008-2009 Andrej Stepanchuk
5 * Copyright (C) 2009-2010 Howard Chu
6 *
7 * This file is part of librtmp.
8 *
9 * librtmp is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as
11 * published by the Free Software Foundation; either version 2.1,
12 * or (at your option) any later version.
13 *
14 * librtmp is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with librtmp see the file COPYING. If not, write to
21 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 * Boston, MA 02110-1301, USA.
23 * http://www.gnu.org/copyleft/lgpl.html
24 */
25
26 #include <stdint.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <assert.h>
30 #include <time.h>
31
32 #include "rtmp_sys.h"
33 #include "log.h"
34
35 #ifdef CRYPTO
36 #ifdef USE_POLARSSL
37 #include <polarssl/havege.h>
38 #include <polarssl/md5.h>
39 #include <polarssl/base64.h>
40 #define MD5_DIGEST_LENGTH 16
41
42 static const char *my_dhm_P =
43 "E4004C1F94182000103D883A448B3F80" \
44 "2CE4B44A83301270002C20D0321CFD00" \
45 "11CCEF784C26A400F43DFB901BCA7538" \
46 "F2C6B176001CF5A0FD16D2C48B1D0C1C" \
47 "F6AC8E1DA6BCC3B4E1F96B0564965300" \
48 "FFA1D0B601EB2800F489AA512C4B248C" \
49 "01F76949A60BB7F00A40B1EAB64BDD48" \
50 "E8A700D60B7F1200FA8E77B0A979DABF";
51
52 static const char *my_dhm_G = "4";
53
54 #elif defined(USE_GNUTLS)
55 #include <gnutls/gnutls.h>
56 #define MD5_DIGEST_LENGTH 16
57 #include <nettle/base64.h>
58 #include <nettle/md5.h>
59 #else /* USE_OPENSSL */
60 #include <openssl/ssl.h>
61 #include <openssl/rc4.h>
62 #include <openssl/md5.h>
63 #include <openssl/bio.h>
64 #include <openssl/buffer.h>
65 #endif
66 TLS_CTX RTMP_TLS_ctx;
67 #endif
68
69 #define RTMP_SIG_SIZE 1536
70 #define RTMP_LARGE_HEADER_SIZE 12
71
72 static const int packetSize[] = { 12, 8, 4, 1 };
73
74 int RTMP_ctrlC;
75
76 const char RTMPProtocolStrings[][7] = {
77 "RTMP",
78 "RTMPT",
79 "RTMPE",
80 "RTMPTE",
81 "RTMPS",
82 "RTMPTS",
83 "",
84 "",
85 "RTMFP"
86 };
87
88 const char RTMPProtocolStringsLower[][7] = {
89 "rtmp",
90 "rtmpt",
91 "rtmpe",
92 "rtmpte",
93 "rtmps",
94 "rtmpts",
95 "",
96 "",
97 "rtmfp"
98 };
99
100 static const char *RTMPT_cmds[] = {
101 "open",
102 "send",
103 "idle",
104 "close"
105 };
106
107 typedef enum {
108 RTMPT_OPEN=0, RTMPT_SEND, RTMPT_IDLE, RTMPT_CLOSE
109 } RTMPTCmd;
110
111 static int DumpMetaData(AMFObject *obj);
112 static int HandShake(RTMP *r, int FP9HandShake);
113 static int SocksNegotiate(RTMP *r);
114
115 static int SendConnectPacket(RTMP *r, RTMPPacket *cp);
116 static int SendCheckBW(RTMP *r);
117 static int SendCheckBWResult(RTMP *r, double txn);
118 static int SendDeleteStream(RTMP *r, double dStreamId);
119 static int SendFCSubscribe(RTMP *r, AVal *subscribepath);
120 static int SendPlay(RTMP *r);
121 static int SendBytesReceived(RTMP *r);
122 static int SendUsherToken(RTMP *r, AVal *usherToken);
123
124 #if 0 /* unused */
125 static int SendBGHasStream(RTMP *r, double dId, AVal *playpath);
126 #endif
127
128 static int HandleInvoke(RTMP *r, const char *body, unsigned int nBodySize);
129 static int HandleMetadata(RTMP *r, char *body, unsigned int len);
130 static void HandleChangeChunkSize(RTMP *r, const RTMPPacket *packet);
131 static void HandleAudio(RTMP *r, const RTMPPacket *packet);
132 static void HandleVideo(RTMP *r, const RTMPPacket *packet);
133 static void HandleCtrl(RTMP *r, const RTMPPacket *packet);
134 static void HandleServerBW(RTMP *r, const RTMPPacket *packet);
135 static void HandleClientBW(RTMP *r, const RTMPPacket *packet);
136
137 static int ReadN(RTMP *r, char *buffer, int n);
138 static int WriteN(RTMP *r, const char *buffer, int n);
139
140 static void DecodeTEA(AVal *key, AVal *text);
141
142 static int HTTP_Post(RTMP *r, RTMPTCmd cmd, const char *buf, int len);
143 static int HTTP_read(RTMP *r, int fill);
144
145 static void CloseInternal(RTMP *r, int reconnect);
146
147 #ifndef _WIN32
148 static int clk_tck;
149 #endif
150
151 #ifdef CRYPTO
152 #include "handshake.h"
153 #endif
154
155 uint32_t
156 RTMP_GetTime()
157 {
158 #ifdef _DEBUG
159 return 0;
160 #elif defined(_WIN32)
161 return timeGetTime();
162 #else
163 struct tms t;
164 if (!clk_tck) clk_tck = sysconf(_SC_CLK_TCK);
165 return times(&t) * 1000 / clk_tck;
166 #endif
167 }
168
169 void
170 RTMP_UserInterrupt()
171 {
172 RTMP_ctrlC = TRUE;
173 }
174
175 void
176 RTMPPacket_Reset(RTMPPacket *p)
177 {
178 p->m_headerType = 0;
179 p->m_packetType = 0;
180 p->m_nChannel = 0;
181 p->m_nTimeStamp = 0;
182 p->m_nInfoField2 = 0;
183 p->m_hasAbsTimestamp = FALSE;
184 p->m_nBodySize = 0;
185 p->m_nBytesRead = 0;
186 }
187
188 int
189 RTMPPacket_Alloc(RTMPPacket *p, int nSize)
190 {
191 char *ptr = calloc(1, nSize + RTMP_MAX_HEADER_SIZE);
192 if (!ptr)
193 return FALSE;
194 p->m_body = ptr + RTMP_MAX_HEADER_SIZE;
195 p->m_nBytesRead = 0;
196 return TRUE;
197 }
198
199 void
200 RTMPPacket_Free(RTMPPacket *p)
201 {
202 if (p->m_body)
203 {
204 free(p->m_body - RTMP_MAX_HEADER_SIZE);
205 p->m_body = NULL;
206 }
207 }
208
209 void
210 RTMPPacket_Dump(RTMPPacket *p)
211 {
212 RTMP_Log(RTMP_LOGDEBUG,
213 "RTMP PACKET: packet type: 0x%02x. channel: 0x%02x. info 1: %d info 2: %d. Body size: %u. body: 0x%02x",
214 p->m_packetType, p->m_nChannel, p->m_nTimeStamp, p->m_nInfoField2,
215 p->m_nBodySize, p->m_body ? (unsigned char)p->m_body[0] : 0);
216 }
217
218 int
219 RTMP_LibVersion()
220 {
221 return RTMP_LIB_VERSION;
222 }
223
224 void
225 RTMP_TLS_Init()
226 {
227 #ifdef CRYPTO
228 #ifdef USE_POLARSSL
229 /* Do this regardless of NO_SSL, we use havege for rtmpe too */
230 RTMP_TLS_ctx = calloc(1,sizeof(struct tls_ctx));
231 havege_init(&RTMP_TLS_ctx->hs);
232 #elif defined(USE_GNUTLS) && !defined(NO_SSL)
233 /* Technically we need to initialize libgcrypt ourselves if
234 * we're not going to call gnutls_global_init(). Ignoring this
235 * for now.
236 */
237 gnutls_global_init();
238 RTMP_TLS_ctx = malloc(sizeof(struct tls_ctx));
239 gnutls_certificate_allocate_credentials(&RTMP_TLS_ctx->cred);
240 gnutls_priority_init(&RTMP_TLS_ctx->prios, "NORMAL", NULL);
241 gnutls_certificate_set_x509_trust_file(RTMP_TLS_ctx->cred,
242 "ca.pem", GNUTLS_X509_FMT_PEM);
243 #elif !defined(NO_SSL) /* USE_OPENSSL */
244 /* libcrypto doesn't need anything special */
245 SSL_load_error_strings();
246 SSL_library_init();
247 OpenSSL_add_all_digests();
248 RTMP_TLS_ctx = SSL_CTX_new(SSLv23_method());
249 SSL_CTX_set_options(RTMP_TLS_ctx, SSL_OP_ALL);
250 SSL_CTX_set_default_verify_paths(RTMP_TLS_ctx);
251 #endif
252 #endif
253 }
254
255 void *
256 RTMP_TLS_AllocServerContext(const char* cert, const char* key)
257 {
258 void *ctx = NULL;
259 #ifdef CRYPTO
260 if (!RTMP_TLS_ctx)
261 RTMP_TLS_Init();
262 #ifdef USE_POLARSSL
263 tls_server_ctx *tc = ctx = calloc(1, sizeof(struct tls_server_ctx));
264 tc->dhm_P = my_dhm_P;
265 tc->dhm_G = my_dhm_G;
266 tc->hs = &RTMP_TLS_ctx->hs;
267 if (x509parse_crtfile(&tc->cert, cert)) {
268 free(tc);
269 return NULL;
270 }
271 if (x509parse_keyfile(&tc->key, key, NULL)) {
272 x509_free(&tc->cert);
273 free(tc);
274 return NULL;
275 }
276 #elif defined(USE_GNUTLS) && !defined(NO_SSL)
277 gnutls_certificate_allocate_credentials((gnutls_certificate_credentials*) &ctx);
278 if (gnutls_certificate_set_x509_key_file(ctx, cert, key, GNUTLS_X509_FMT_PEM) != 0) {
279 gnutls_certificate_free_credentials(ctx);
280 return NULL;
281 }
282 #elif !defined(NO_SSL) /* USE_OPENSSL */
283 ctx = SSL_CTX_new(SSLv23_server_method());
284 if (!SSL_CTX_use_certificate_chain_file(ctx, cert)) {
285 SSL_CTX_free(ctx);
286 return NULL;
287 }
288 if (!SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM)) {
289 SSL_CTX_free(ctx);
290 return NULL;
291 }
292 #endif
293 #endif
294 return ctx;
295 }
296
297 void
298 RTMP_TLS_FreeServerContext(void *ctx)
299 {
300 #ifdef CRYPTO
301 #ifdef USE_POLARSSL
302 x509_free(&((tls_server_ctx*)ctx)->cert);
303 rsa_free(&((tls_server_ctx*)ctx)->key);
304 free(ctx);
305 #elif defined(USE_GNUTLS) && !defined(NO_SSL)
306 gnutls_certificate_free_credentials(ctx);
307 #elif !defined(NO_SSL) /* USE_OPENSSL */
308 SSL_CTX_free(ctx);
309 #endif
310 #endif
311 }
312
313 RTMP *
314 RTMP_Alloc()
315 {
316 return calloc(1, sizeof(RTMP));
317 }
318
319 void
320 RTMP_Free(RTMP *r)
321 {
322 free(r);
323 }
324
325 void
326 RTMP_Init(RTMP *r)
327 {
328 #ifdef CRYPTO
329 if (!RTMP_TLS_ctx)
330 RTMP_TLS_Init();
331 #endif
332
333 memset(r, 0, sizeof(RTMP));
334 r->m_sb.sb_socket = -1;
335 r->m_inChunkSize = RTMP_DEFAULT_CHUNKSIZE;
336 r->m_outChunkSize = RTMP_DEFAULT_CHUNKSIZE;
337 r->m_nBufferMS = 30000;
338 r->m_nClientBW = 2500000;
339 r->m_nClientBW2 = 2;
340 r->m_nServerBW = 2500000;
341 r->m_fAudioCodecs = 3191.0;
342 r->m_fVideoCodecs = 252.0;
343 r->Link.timeout = 30;
344 r->Link.swfAge = 30;
345 }
346
347 void
348 RTMP_EnableWrite(RTMP *r)
349 {
350 r->Link.protocol |= RTMP_FEATURE_WRITE;
351 }
352
353 double
354 RTMP_GetDuration(RTMP *r)
355 {
356 return r->m_fDuration;
357 }
358
359 int
360 RTMP_IsConnected(RTMP *r)
361 {
362 return r->m_sb.sb_socket != -1;
363 }
364
365 int
366 RTMP_Socket(RTMP *r)
367 {
368 return r->m_sb.sb_socket;
369 }
370
371 int
372 RTMP_IsTimedout(RTMP *r)
373 {
374 return r->m_sb.sb_timedout;
375 }
376
377 void
378 RTMP_SetBufferMS(RTMP *r, int size)
379 {
380 r->m_nBufferMS = size;
381 }
382
383 void
384 RTMP_UpdateBufferMS(RTMP *r)
385 {
386 RTMP_SendCtrl(r, 3, r->m_stream_id, r->m_nBufferMS);
387 }
388
389 #undef OSS
390 #ifdef _WIN32
391 #define OSS "WIN"
392 #elif defined(__sun__)
393 #define OSS "SOL"
394 #elif defined(__APPLE__)
395 #define OSS "MAC"
396 #elif defined(__linux__)
397 #define OSS "LNX"
398 #else
399 #define OSS "GNU"
400 #endif
401 #define DEF_VERSTR OSS " 10,0,32,18"
402 static const char DEFAULT_FLASH_VER[] = DEF_VERSTR;
403 const AVal RTMP_DefaultFlashVer =
404 { (char *)DEFAULT_FLASH_VER, sizeof(DEFAULT_FLASH_VER) - 1 };
405
406 static void
407 SocksSetup(RTMP *r, AVal *sockshost)
408 {
409 if (sockshost->av_len)
410 {
411 const char *socksport = strchr(sockshost->av_val, ':');
412 char *hostname = strdup(sockshost->av_val);
413
414 if (socksport)
415 hostname[socksport - sockshost->av_val] = '\0';
416 r->Link.sockshost.av_val = hostname;
417 r->Link.sockshost.av_len = strlen(hostname);
418
419 r->Link.socksport = socksport ? atoi(socksport + 1) : 1080;
420 RTMP_Log(RTMP_LOGDEBUG, "Connecting via SOCKS proxy: %s:%d", r->Link.sockshost.av_val,
421 r->Link.socksport);
422 }
423 else
424 {
425 r->Link.sockshost.av_val = NULL;
426 r->Link.sockshost.av_len = 0;
427 r->Link.socksport = 0;
428 }
429 }
430
431 void
432 RTMP_SetupStream(RTMP *r,
433 int protocol,
434 AVal *host,
435 unsigned int port,
436 AVal *sockshost,
437 AVal *playpath,
438 AVal *tcUrl,
439 AVal *swfUrl,
440 AVal *pageUrl,
441 AVal *app,
442 AVal *auth,
443 AVal *swfSHA256Hash,
444 uint32_t swfSize,
445 AVal *flashVer,
446 AVal *subscribepath,
447 AVal *usherToken,
448 int dStart,
449 int dStop, int bLiveStream, long int timeout)
450 {
451 RTMP_Log(RTMP_LOGDEBUG, "Protocol : %s", RTMPProtocolStrings[protocol&7]);
452 RTMP_Log(RTMP_LOGDEBUG, "Hostname : %.*s", host->av_len, host->av_val);
453 RTMP_Log(RTMP_LOGDEBUG, "Port : %d", port);
454 RTMP_Log(RTMP_LOGDEBUG, "Playpath : %s", playpath->av_val);
455
456 if (tcUrl && tcUrl->av_val)
457 RTMP_Log(RTMP_LOGDEBUG, "tcUrl : %s", tcUrl->av_val);
458 if (swfUrl && swfUrl->av_val)
459 RTMP_Log(RTMP_LOGDEBUG, "swfUrl : %s", swfUrl->av_val);
460 if (pageUrl && pageUrl->av_val)
461 RTMP_Log(RTMP_LOGDEBUG, "pageUrl : %s", pageUrl->av_val);
462 if (app && app->av_val)
463 RTMP_Log(RTMP_LOGDEBUG, "app : %.*s", app->av_len, app->av_val);
464 if (auth && auth->av_val)
465 RTMP_Log(RTMP_LOGDEBUG, "auth : %s", auth->av_val);
466 if (subscribepath && subscribepath->av_val)
467 RTMP_Log(RTMP_LOGDEBUG, "subscribepath : %s", subscribepath->av_val);
468 if (usherToken && usherToken->av_val)
469 RTMP_Log(RTMP_LOGDEBUG, "NetStream.Authenticate.UsherToken : %s", usherToken->av_val);
470 if (flashVer && flashVer->av_val)
471 RTMP_Log(RTMP_LOGDEBUG, "flashVer : %s", flashVer->av_val);
472 if (dStart > 0)
473 RTMP_Log(RTMP_LOGDEBUG, "StartTime : %d msec", dStart);
474 if (dStop > 0)
475 RTMP_Log(RTMP_LOGDEBUG, "StopTime : %d msec", dStop);
476
477 RTMP_Log(RTMP_LOGDEBUG, "live : %s", bLiveStream ? "yes" : "no");
478 RTMP_Log(RTMP_LOGDEBUG, "timeout : %ld sec", timeout);
479
480 #ifdef CRYPTO
481 if (swfSHA256Hash != NULL && swfSize > 0)
482 {
483 memcpy(r->Link.SWFHash, swfSHA256Hash->av_val, sizeof(r->Link.SWFHash));
484 r->Link.SWFSize = swfSize;
485 RTMP_Log(RTMP_LOGDEBUG, "SWFSHA256:");
486 RTMP_LogHex(RTMP_LOGDEBUG, r->Link.SWFHash, sizeof(r->Link.SWFHash));
487 RTMP_Log(RTMP_LOGDEBUG, "SWFSize : %u", r->Link.SWFSize);
488 }
489 else
490 {
491 r->Link.SWFSize = 0;
492 }
493 #endif
494
495 SocksSetup(r, sockshost);
496
497 if (tcUrl && tcUrl->av_len)
498 r->Link.tcUrl = *tcUrl;
499 if (swfUrl && swfUrl->av_len)
500 r->Link.swfUrl = *swfUrl;
501 if (pageUrl && pageUrl->av_len)
502 r->Link.pageUrl = *pageUrl;
503 if (app && app->av_len)
504 r->Link.app = *app;
505 if (auth && auth->av_len)
506 {
507 r->Link.auth = *auth;
508 r->Link.lFlags |= RTMP_LF_AUTH;
509 }
510 if (flashVer && flashVer->av_len)
511 r->Link.flashVer = *flashVer;
512 else
513 r->Link.flashVer = RTMP_DefaultFlashVer;
514 if (subscribepath && subscribepath->av_len)
515 r->Link.subscribepath = *subscribepath;
516 if (usherToken && usherToken->av_len)
517 r->Link.usherToken = *usherToken;
518 r->Link.seekTime = dStart;
519 r->Link.stopTime = dStop;
520 if (bLiveStream)
521 r->Link.lFlags |= RTMP_LF_LIVE;
522 r->Link.timeout = timeout;
523
524 r->Link.protocol = protocol;
525 r->Link.hostname = *host;
526 r->Link.port = port;
527 r->Link.playpath = *playpath;
528
529 if (r->Link.port == 0)
530 {
531 if (protocol & RTMP_FEATURE_SSL)
532 r->Link.port = 443;
533 else if (protocol & RTMP_FEATURE_HTTP)
534 r->Link.port = 80;
535 else
536 r->Link.port = 1935;
537 }
538 }
539
540 enum { OPT_STR=0, OPT_INT, OPT_BOOL, OPT_CONN };
541 static const char *optinfo[] = {
542 "string", "integer", "boolean", "AMF" };
543
544 #define OFF(x) offsetof(struct RTMP,x)
545
546 static struct urlopt {
547 AVal name;
548 off_t off;
549 int otype;
550 int omisc;
551 char *use;
552 } options[] = {
553 { AVC("socks"), OFF(Link.sockshost), OPT_STR, 0,
554 "Use the specified SOCKS proxy" },
555 { AVC("app"), OFF(Link.app), OPT_STR, 0,
556 "Name of target app on server" },
557 { AVC("tcUrl"), OFF(Link.tcUrl), OPT_STR, 0,
558 "URL to played stream" },
559 { AVC("pageUrl"), OFF(Link.pageUrl), OPT_STR, 0,
560 "URL of played media's web page" },
561 { AVC("swfUrl"), OFF(Link.swfUrl), OPT_STR, 0,
562 "URL to player SWF file" },
563 { AVC("flashver"), OFF(Link.flashVer), OPT_STR, 0,
564 "Flash version string (default " DEF_VERSTR ")" },
565 { AVC("conn"), OFF(Link.extras), OPT_CONN, 0,
566 "Append arbitrary AMF data to Connect message" },
567 { AVC("playpath"), OFF(Link.playpath), OPT_STR, 0,
568 "Path to target media on server" },
569 { AVC("playlist"), OFF(Link.lFlags), OPT_BOOL, RTMP_LF_PLST,
570 "Set playlist before play command" },
571 { AVC("live"), OFF(Link.lFlags), OPT_BOOL, RTMP_LF_LIVE,
572 "Stream is live, no seeking possible" },
573 { AVC("subscribe"), OFF(Link.subscribepath), OPT_STR, 0,
574 "Stream to subscribe to" },
575 { AVC("jtv"), OFF(Link.usherToken), OPT_STR, 0,
576 "Justin.tv authentication token" },
577 { AVC("token"), OFF(Link.token), OPT_STR, 0,
578 "Key for SecureToken response" },
579 { AVC("swfVfy"), OFF(Link.lFlags), OPT_BOOL, RTMP_LF_SWFV,
580 "Perform SWF Verification" },
581 { AVC("swfAge"), OFF(Link.swfAge), OPT_INT, 0,
582 "Number of days to use cached SWF hash" },
583 { AVC("start"), OFF(Link.seekTime), OPT_INT, 0,
584 "Stream start position in milliseconds" },
585 { AVC("stop"), OFF(Link.stopTime), OPT_INT, 0,
586 "Stream stop position in milliseconds" },
587 { AVC("buffer"), OFF(m_nBufferMS), OPT_INT, 0,
588 "Buffer time in milliseconds" },
589 { AVC("timeout"), OFF(Link.timeout), OPT_INT, 0,
590 "Session timeout in seconds" },
591 { AVC("pubUser"), OFF(Link.pubUser), OPT_STR, 0,
592 "Publisher username" },
593 { AVC("pubPasswd"), OFF(Link.pubPasswd), OPT_STR, 0,
594 "Publisher password" },
595 { {NULL,0}, 0, 0}
596 };
597
598 static const AVal truth[] = {
599 AVC("1"),
600 AVC("on"),
601 AVC("yes"),
602 AVC("true"),
603 {0,0}
604 };
605
606 static void RTMP_OptUsage()
607 {
608 int i;
609
610 RTMP_Log(RTMP_LOGERROR, "Valid RTMP options are:\n");
611 for (i=0; options[i].name.av_len; i++) {
612 RTMP_Log(RTMP_LOGERROR, "%10s %-7s %s\n", options[i].name.av_val,
613 optinfo[options[i].otype], options[i].use);
614 }
615 }
616
617 static int
618 parseAMF(AMFObject *obj, AVal *av, int *depth)
619 {
620 AMFObjectProperty prop = {{0,0}};
621 int i;
622 char *p, *arg = av->av_val;
623
624 if (arg[1] == ':')
625 {
626 p = (char *)arg+2;
627 switch(arg[0])
628 {
629 case 'B':
630 prop.p_type = AMF_BOOLEAN;
631 prop.p_vu.p_number = atoi(p);
632 break;
633 case 'S':
634 prop.p_type = AMF_STRING;
635 prop.p_vu.p_aval.av_val = p;
636 prop.p_vu.p_aval.av_len = av->av_len - (p-arg);
637 break;
638 case 'N':
639 prop.p_type = AMF_NUMBER;
640 prop.p_vu.p_number = strtod(p, NULL);
641 break;
642 case 'Z':
643 prop.p_type = AMF_NULL;
644 break;
645 case 'O':
646 i = atoi(p);
647 if (i)
648 {
649 prop.p_type = AMF_OBJECT;
650 }
651 else
652 {
653 (*depth)--;
654 return 0;
655 }
656 break;
657 default:
658 return -1;
659 }
660 }
661 else if (arg[2] == ':' && arg[0] == 'N')
662 {
663 p = strchr(arg+3, ':');
664 if (!p || !*depth)
665 return -1;
666 prop.p_name.av_val = (char *)arg+3;
667 prop.p_name.av_len = p - (arg+3);
668
669 p++;
670 switch(arg[1])
671 {
672 case 'B':
673 prop.p_type = AMF_BOOLEAN;
674 prop.p_vu.p_number = atoi(p);
675 break;
676 case 'S':
677 prop.p_type = AMF_STRING;
678 prop.p_vu.p_aval.av_val = p;
679 prop.p_vu.p_aval.av_len = av->av_len - (p-arg);
680 break;
681 case 'N':
682 prop.p_type = AMF_NUMBER;
683 prop.p_vu.p_number = strtod(p, NULL);
684 break;
685 case 'O':
686 prop.p_type = AMF_OBJECT;
687 break;
688 default:
689 return -1;
690 }
691 }
692 else
693 return -1;
694
695 if (*depth)
696 {
697 AMFObject *o2;
698 for (i=0; i<*depth; i++)
699 {
700 o2 = &obj->o_props[obj->o_num-1].p_vu.p_object;
701 obj = o2;
702 }
703 }
704 AMF_AddProp(obj, &prop);
705 if (prop.p_type == AMF_OBJECT)
706 (*depth)++;
707 return 0;
708 }
709
710 int RTMP_SetOpt(RTMP *r, const AVal *opt, AVal *arg)
711 {
712 int i;
713 void *v;
714
715 for (i=0; options[i].name.av_len; i++) {
716 if (opt->av_len != options[i].name.av_len) continue;
717 if (strcasecmp(opt->av_val, options[i].name.av_val)) continue;
718 v = (char *)r + options[i].off;
719 switch(options[i].otype) {
720 case OPT_STR: {
721 AVal *aptr = v;
722 *aptr = *arg; }
723 break;
724 case OPT_INT: {
725 long l = strtol(arg->av_val, NULL, 0);
726 *(int *)v = l; }
727 break;
728 case OPT_BOOL: {
729 int j, fl;
730 fl = *(int *)v;
731 for (j=0; truth[j].av_len; j++) {
732 if (arg->av_len != truth[j].av_len) continue;
733 if (strcasecmp(arg->av_val, truth[j].av_val)) continue;
734 fl |= options[i].omisc; break; }
735 *(int *)v = fl;
736 }
737 break;
738 case OPT_CONN:
739 if (parseAMF(&r->Link.extras, arg, &r->Link.edepth))
740 return FALSE;
741 break;
742 }
743 break;
744 }
745 if (!options[i].name.av_len) {
746 RTMP_Log(RTMP_LOGERROR, "Unknown option %s", opt->av_val);
747 RTMP_OptUsage();
748 return FALSE;
749 }
750
751 return TRUE;
752 }
753
754 int RTMP_SetupURL(RTMP *r, char *url)
755 {
756 AVal opt, arg;
757 char *p1, *p2, *ptr = strchr(url, ' ');
758 int ret, len;
759 unsigned int port = 0;
760
761 if (ptr)
762 *ptr = '\0';
763
764 len = strlen(url);
765 ret = RTMP_ParseURL(url, &r->Link.protocol, &r->Link.hostname,
766 &port, &r->Link.playpath0, &r->Link.app);
767 if (!ret)
768 return ret;
769 r->Link.port = port;
770 r->Link.playpath = r->Link.playpath0;
771
772 while (ptr) {
773 *ptr++ = '\0';
774 p1 = ptr;
775 p2 = strchr(p1, '=');
776 if (!p2)
777 break;
778 opt.av_val = p1;
779 opt.av_len = p2 - p1;
780 *p2++ = '\0';
781 arg.av_val = p2;
782 ptr = strchr(p2, ' ');
783 if (ptr) {
784 *ptr = '\0';
785 arg.av_len = ptr - p2;
786 /* skip repeated spaces */
787 while(ptr[1] == ' ')
788 *ptr++ = '\0';
789 } else {
790 arg.av_len = strlen(p2);
791 }
792
793 /* unescape */
794 port = arg.av_len;
795 for (p1=p2; port >0;) {
796 if (*p1 == '\\') {
797 unsigned int c;
798 if (port < 3)
799 return FALSE;
800 sscanf(p1+1, "%02x", &c);
801 *p2++ = c;
802 port -= 3;
803 p1 += 3;
804 } else {
805 *p2++ = *p1++;
806 port--;
807 }
808 }
809 arg.av_len = p2 - arg.av_val;
810
811 ret = RTMP_SetOpt(r, &opt, &arg);
812 if (!ret)
813 return ret;
814 }
815
816 if (!r->Link.tcUrl.av_len)
817 {
818 r->Link.tcUrl.av_val = url;
819 if (r->Link.app.av_len)
820 {
821 if (r->Link.app.av_val < url + len)
822 {
823 /* if app is part of original url, just use it */
824 r->Link.tcUrl.av_len = r->Link.app.av_len + (r->Link.app.av_val - url);
825 }
826 else
827 {
828 len = r->Link.hostname.av_len + r->Link.app.av_len +
829 sizeof("rtmpte://:65535/");
830 r->Link.tcUrl.av_val = malloc(len);
831 r->Link.tcUrl.av_len = snprintf(r->Link.tcUrl.av_val, len,
832 "%s://%.*s:%d/%.*s",
833 RTMPProtocolStringsLower[r->Link.protocol],
834 r->Link.hostname.av_len, r->Link.hostname.av_val,
835 r->Link.port,
836 r->Link.app.av_len, r->Link.app.av_val);
837 r->Link.lFlags |= RTMP_LF_FTCU;
838 }
839 }
840 else
841 {
842 r->Link.tcUrl.av_len = strlen(url);
843 }
844 }
845
846 #ifdef CRYPTO
847 if ((r->Link.lFlags & RTMP_LF_SWFV) && r->Link.swfUrl.av_len)
848 RTMP_HashSWF(r->Link.swfUrl.av_val, &r->Link.SWFSize,
849 (unsigned char *)r->Link.SWFHash, r->Link.swfAge);
850 #endif
851
852 SocksSetup(r, &r->Link.sockshost);
853
854 if (r->Link.port == 0)
855 {
856 if (r->Link.protocol & RTMP_FEATURE_SSL)
857 r->Link.port = 443;
858 else if (r->Link.protocol & RTMP_FEATURE_HTTP)
859 r->Link.port = 80;
860 else
861 r->Link.port = 1935;
862 }
863 return TRUE;
864 }
865
866 static int
867 add_addr_info(struct sockaddr_in *service, AVal *host, int port)
868 {
869 char *hostname;
870 int ret = TRUE;
871 if (host->av_val[host->av_len])
872 {
873 hostname = malloc(host->av_len+1);
874 memcpy(hostname, host->av_val, host->av_len);
875 hostname[host->av_len] = '\0';
876 }
877 else
878 {
879 hostname = host->av_val;
880 }
881
882 service->sin_addr.s_addr = inet_addr(hostname);
883 if (service->sin_addr.s_addr == INADDR_NONE)
884 {
885 struct hostent *host = gethostbyname(hostname);
886 if (host == NULL || host->h_addr == NULL)
887 {
888 RTMP_Log(RTMP_LOGERROR, "Problem accessing the DNS. (addr: %s)", hostname);
889 ret = FALSE;
890 goto finish;
891 }
892 service->sin_addr = *(struct in_addr *)host->h_addr;
893 }
894
895 service->sin_port = htons(port);
896 finish:
897 if (hostname != host->av_val)
898 free(hostname);
899 return ret;
900 }
901
902 int
903 RTMP_Connect0(RTMP *r, struct sockaddr * service)
904 {
905 int on = 1;
906 r->m_sb.sb_timedout = FALSE;
907 r->m_pausing = 0;
908 r->m_fDuration = 0.0;
909
910 r->m_sb.sb_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
911 if (r->m_sb.sb_socket != -1)
912 {
913 if (connect(r->m_sb.sb_socket, service, sizeof(struct sockaddr)) < 0)
914 {
915 int err = GetSockError();
916 RTMP_Log(RTMP_LOGERROR, "%s, failed to connect socket. %d (%s)",
917 __FUNCTION__, err, strerror(err));
918 RTMP_Close(r);
919 return FALSE;
920 }
921
922 if (r->Link.socksport)
923 {
924 RTMP_Log(RTMP_LOGDEBUG, "%s ... SOCKS negotiation", __FUNCTION__);
925 if (!SocksNegotiate(r))
926 {
927 RTMP_Log(RTMP_LOGERROR, "%s, SOCKS negotiation failed.", __FUNCTION__);
928 RTMP_Close(r);
929 return FALSE;
930 }
931 }
932 }
933 else
934 {
935 RTMP_Log(RTMP_LOGERROR, "%s, failed to create socket. Error: %d", __FUNCTION__,
936 GetSockError());
937 return FALSE;
938 }
939
940 /* set timeout */
941 {
942 SET_RCVTIMEO(tv, r->Link.timeout);
943 if (setsockopt
944 (r->m_sb.sb_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)))
945 {
946 RTMP_Log(RTMP_LOGERROR, "%s, Setting socket timeout to %ds failed!",
947 __FUNCTION__, r->Link.timeout);
948 }
949 }
950
951 setsockopt(r->m_sb.sb_socket, IPPROTO_TCP, TCP_NODELAY, (char *) &on, sizeof(on));
952
953 return TRUE;
954 }
955
956 int
957 RTMP_TLS_Accept(RTMP *r, void *ctx)
958 {
959 #if defined(CRYPTO) && !defined(NO_SSL)
960 TLS_server(ctx, r->m_sb.sb_ssl);
961 TLS_setfd(r->m_sb.sb_ssl, r->m_sb.sb_socket);
962 if (TLS_accept(r->m_sb.sb_ssl) < 0)
963 {
964 RTMP_Log(RTMP_LOGERROR, "%s, TLS_Connect failed", __FUNCTION__);
965 return FALSE;
966 }
967 return TRUE;
968 #else
969 return FALSE;
970 #endif
971 }
972
973 int
974 RTMP_Connect1(RTMP *r, RTMPPacket *cp)
975 {
976 if (r->Link.protocol & RTMP_FEATURE_SSL)
977 {
978 #if defined(CRYPTO) && !defined(NO_SSL)
979 TLS_client(RTMP_TLS_ctx, r->m_sb.sb_ssl);
980 TLS_setfd(r->m_sb.sb_ssl, r->m_sb.sb_socket);
981 if (TLS_connect(r->m_sb.sb_ssl) < 0)
982 {
983 RTMP_Log(RTMP_LOGERROR, "%s, TLS_Connect failed", __FUNCTION__);
984 RTMP_Close(r);
985 return FALSE;
986 }
987 #else
988 RTMP_Log(RTMP_LOGERROR, "%s, no SSL/TLS support", __FUNCTION__);
989 RTMP_Close(r);
990 return FALSE;
991
992 #endif
993 }
994 if (r->Link.protocol & RTMP_FEATURE_HTTP)
995 {
996 r->m_msgCounter = 1;
997 r->m_clientID.av_val = NULL;
998 r->m_clientID.av_len = 0;
999 HTTP_Post(r, RTMPT_OPEN, "", 1);
1000 if (HTTP_read(r, 1) != 0)
1001 {
1002 r->m_msgCounter = 0;
1003 RTMP_Log(RTMP_LOGDEBUG, "%s, Could not connect for handshake", __FUNCTION__);
1004 RTMP_Close(r);
1005 return 0;
1006 }
1007 r->m_msgCounter = 0;
1008 }
1009 RTMP_Log(RTMP_LOGDEBUG, "%s, ... connected, handshaking", __FUNCTION__);
1010 if (!HandShake(r, TRUE))
1011 {
1012 RTMP_Log(RTMP_LOGERROR, "%s, handshake failed.", __FUNCTION__);
1013 RTMP_Close(r);
1014 return FALSE;
1015 }
1016 RTMP_Log(RTMP_LOGDEBUG, "%s, handshaked", __FUNCTION__);
1017
1018 if (!SendConnectPacket(r, cp))
1019 {
1020 RTMP_Log(RTMP_LOGERROR, "%s, RTMP connect failed.", __FUNCTION__);
1021 RTMP_Close(r);
1022 return FALSE;
1023 }
1024 return TRUE;
1025 }
1026
1027 int
1028 RTMP_Connect(RTMP *r, RTMPPacket *cp)
1029 {
1030 struct sockaddr_in service;
1031 if (!r->Link.hostname.av_len)
1032 return FALSE;
1033
1034 memset(&service, 0, sizeof(struct sockaddr_in));
1035 service.sin_family = AF_INET;
1036
1037 if (r->Link.socksport)
1038 {
1039 /* Connect via SOCKS */
1040 if (!add_addr_info(&service, &r->Link.sockshost, r->Link.socksport))
1041 return FALSE;
1042 }
1043 else
1044 {
1045 /* Connect directly */
1046 if (!add_addr_info(&service, &r->Link.hostname, r->Link.port))
1047 return FALSE;
1048 }
1049
1050 if (!RTMP_Connect0(r, (struct sockaddr *)&service))
1051 return FALSE;
1052
1053 r->m_bSendCounter = TRUE;
1054
1055 return RTMP_Connect1(r, cp);
1056 }
1057
1058 static int
1059 SocksNegotiate(RTMP *r)
1060 {
1061 unsigned long addr;
1062 struct sockaddr_in service;
1063 memset(&service, 0, sizeof(struct sockaddr_in));
1064
1065 add_addr_info(&service, &r->Link.hostname, r->Link.port);
1066 addr = htonl(service.sin_addr.s_addr);
1067
1068 {
1069 char packet[] = {
1070 4, 1, /* SOCKS 4, connect */
1071 (r->Link.port >> 8) & 0xFF,
1072 (r->Link.port) & 0xFF,
1073 (char)(addr >> 24) & 0xFF, (char)(addr >> 16) & 0xFF,
1074 (char)(addr >> 8) & 0xFF, (char)addr & 0xFF,
1075 0
1076 }; /* NULL terminate */
1077
1078 WriteN(r, packet, sizeof packet);
1079
1080 if (ReadN(r, packet, 8) != 8)
1081 return FALSE;
1082
1083 if (packet[0] == 0 && packet[1] == 90)
1084 {
1085 return TRUE;
1086 }
1087 else
1088 {
1089 RTMP_Log(RTMP_LOGERROR, "%s, SOCKS returned error code %d", __FUNCTION__, packet[1]);
1090 return FALSE;
1091 }
1092 }
1093 }
1094
1095 int
1096 RTMP_ConnectStream(RTMP *r, int seekTime)
1097 {
1098 RTMPPacket packet = { 0 };
1099
1100 /* seekTime was already set by SetupStream / SetupURL.
1101 * This is only needed by ReconnectStream.
1102 */
1103 if (seekTime > 0)
1104 r->Link.seekTime = seekTime;
1105
1106 r->m_mediaChannel = 0;
1107
1108 while (!r->m_bPlaying && RTMP_IsConnected(r) && RTMP_ReadPacket(r, &packet))
1109 {
1110 if (RTMPPacket_IsReady(&packet))
1111 {
1112 if (!packet.m_nBodySize)
1113 continue;
1114 if ((packet.m_packetType == RTMP_PACKET_TYPE_AUDIO) ||
1115 (packet.m_packetType == RTMP_PACKET_TYPE_VIDEO) ||
1116 (packet.m_packetType == RTMP_PACKET_TYPE_INFO))
1117 {
1118 RTMP_Log(RTMP_LOGWARNING, "Received FLV packet before play()! Ignoring.");
1119 RTMPPacket_Free(&packet);
1120 continue;
1121 }
1122
1123 RTMP_ClientPacket(r, &packet);
1124 RTMPPacket_Free(&packet);
1125 }
1126 }
1127
1128 return r->m_bPlaying;
1129 }
1130
1131 int
1132 RTMP_ReconnectStream(RTMP *r, int seekTime)
1133 {
1134 RTMP_DeleteStream(r);
1135
1136 RTMP_SendCreateStream(r);
1137
1138 return RTMP_ConnectStream(r, seekTime);
1139 }
1140
1141 int
1142 RTMP_ToggleStream(RTMP *r)
1143 {
1144 int res;
1145
1146 if (!r->m_pausing)
1147 {
1148 if (RTMP_IsTimedout(r) && r->m_read.status == RTMP_READ_EOF)
1149 r->m_read.status = 0;
1150
1151 res = RTMP_SendPause(r, TRUE, r->m_pauseStamp);
1152 if (!res)
1153 return res;
1154
1155 r->m_pausing = 1;
1156 sleep(1);
1157 }
1158 res = RTMP_SendPause(r, FALSE, r->m_pauseStamp);
1159 r->m_pausing = 3;
1160 return res;
1161 }
1162
1163 void
1164 RTMP_DeleteStream(RTMP *r)
1165 {
1166 if (r->m_stream_id < 0)
1167 return;
1168
1169 r->m_bPlaying = FALSE;
1170
1171 SendDeleteStream(r, r->m_stream_id);
1172 r->m_stream_id = -1;
1173 }
1174
1175 int
1176 RTMP_GetNextMediaPacket(RTMP *r, RTMPPacket *packet)
1177 {
1178 int bHasMediaPacket = 0;
1179
1180 while (!bHasMediaPacket && RTMP_IsConnected(r)
1181 && RTMP_ReadPacket(r, packet))
1182 {
1183 if (!RTMPPacket_IsReady(packet))
1184 {
1185 continue;
1186 }
1187
1188 bHasMediaPacket = RTMP_ClientPacket(r, packet);
1189
1190 if (!bHasMediaPacket)
1191 {
1192 RTMPPacket_Free(packet);
1193 }
1194 else if (r->m_pausing == 3)
1195 {
1196 if (packet->m_nTimeStamp <= r->m_mediaStamp)
1197 {
1198 bHasMediaPacket = 0;
1199 #ifdef _DEBUG
1200 RTMP_Log(RTMP_LOGDEBUG,
1201 "Skipped type: %02X, size: %d, TS: %d ms, abs TS: %d, pause: %d ms",
1202 packet->m_packetType, packet->m_nBodySize,
1203 packet->m_nTimeStamp, packet->m_hasAbsTimestamp,
1204 r->m_mediaStamp);
1205 #endif
1206 RTMPPacket_Free(packet);
1207 continue;
1208 }
1209 r->m_pausing = 0;
1210 }
1211 }
1212
1213 if (bHasMediaPacket)
1214 r->m_bPlaying = TRUE;
1215 else if (r->m_sb.sb_timedout && !r->m_pausing)
1216 r->m_pauseStamp = r->m_mediaChannel < r->m_channelsAllocatedIn ?
1217 r->m_channelTimestamp[r->m_mediaChannel] : 0;
1218
1219 return bHasMediaPacket;
1220 }
1221
1222 int
1223 RTMP_ClientPacket(RTMP *r, RTMPPacket *packet)
1224 {
1225 int bHasMediaPacket = 0;
1226 switch (packet->m_packetType)
1227 {
1228 case RTMP_PACKET_TYPE_CHUNK_SIZE:
1229 /* chunk size */
1230 HandleChangeChunkSize(r, packet);
1231 break;
1232
1233 case RTMP_PACKET_TYPE_BYTES_READ_REPORT:
1234 /* bytes read report */
1235 RTMP_Log(RTMP_LOGDEBUG, "%s, received: bytes read report", __FUNCTION__);
1236 break;
1237
1238 case RTMP_PACKET_TYPE_CONTROL:
1239 /* ctrl */
1240 HandleCtrl(r, packet);
1241 break;
1242
1243 case RTMP_PACKET_TYPE_SERVER_BW:
1244 /* server bw */
1245 HandleServerBW(r, packet);
1246 break;
1247
1248 case RTMP_PACKET_TYPE_CLIENT_BW:
1249 /* client bw */
1250 HandleClientBW(r, packet);
1251 break;
1252
1253 case RTMP_PACKET_TYPE_AUDIO:
1254 /* audio data */
1255 /*RTMP_Log(RTMP_LOGDEBUG, "%s, received: audio %lu bytes", __FUNCTION__, packet.m_nBodySize); */
1256 HandleAudio(r, packet);
1257 bHasMediaPacket = 1;
1258 if (!r->m_mediaChannel)
1259 r->m_mediaChannel = packet->m_nChannel;
1260 if (!r->m_pausing)
1261 r->m_mediaStamp = packet->m_nTimeStamp;
1262 break;
1263
1264 case RTMP_PACKET_TYPE_VIDEO:
1265 /* video data */
1266 /*RTMP_Log(RTMP_LOGDEBUG, "%s, received: video %lu bytes", __FUNCTION__, packet.m_nBodySize); */
1267 HandleVideo(r, packet);
1268 bHasMediaPacket = 1;
1269 if (!r->m_mediaChannel)
1270 r->m_mediaChannel = packet->m_nChannel;
1271 if (!r->m_pausing)
1272 r->m_mediaStamp = packet->m_nTimeStamp;
1273 break;
1274
1275 case RTMP_PACKET_TYPE_FLEX_STREAM_SEND:
1276 /* flex stream send */
1277 RTMP_Log(RTMP_LOGDEBUG,
1278 "%s, flex stream send, size %u bytes, not supported, ignoring",
1279 __FUNCTION__, packet->m_nBodySize);
1280 break;
1281
1282 case RTMP_PACKET_TYPE_FLEX_SHARED_OBJECT:
1283 /* flex shared object */
1284 RTMP_Log(RTMP_LOGDEBUG,
1285 "%s, flex shared object, size %u bytes, not supported, ignoring",
1286 __FUNCTION__, packet->m_nBodySize);
1287 break;
1288
1289 case RTMP_PACKET_TYPE_FLEX_MESSAGE:
1290 /* flex message */
1291 {
1292 RTMP_Log(RTMP_LOGDEBUG,
1293 "%s, flex message, size %u bytes, not fully supported",
1294 __FUNCTION__, packet->m_nBodySize);
1295 /*RTMP_LogHex(packet.m_body, packet.m_nBodySize); */
1296
1297 /* some DEBUG code */
1298 #if 0
1299 RTMP_LIB_AMFObject obj;
1300 int nRes = obj.Decode(packet.m_body+1, packet.m_nBodySize-1);
1301 if(nRes < 0) {
1302 RTMP_Log(RTMP_LOGERROR, "%s, error decoding AMF3 packet", __FUNCTION__);
1303 /*return; */
1304 }
1305
1306 obj.Dump();
1307 #endif
1308
1309 if (HandleInvoke(r, packet->m_body + 1, packet->m_nBodySize - 1) == 1)
1310 bHasMediaPacket = 2;
1311 break;
1312 }
1313 case RTMP_PACKET_TYPE_INFO:
1314 /* metadata (notify) */
1315 RTMP_Log(RTMP_LOGDEBUG, "%s, received: notify %u bytes", __FUNCTION__,
1316 packet->m_nBodySize);
1317 if (HandleMetadata(r, packet->m_body, packet->m_nBodySize))
1318 bHasMediaPacket = 1;
1319 break;
1320
1321 case RTMP_PACKET_TYPE_SHARED_OBJECT:
1322 RTMP_Log(RTMP_LOGDEBUG, "%s, shared object, not supported, ignoring",
1323 __FUNCTION__);
1324 break;
1325
1326 case RTMP_PACKET_TYPE_INVOKE:
1327 /* invoke */
1328 RTMP_Log(RTMP_LOGDEBUG, "%s, received: invoke %u bytes", __FUNCTION__,
1329 packet->m_nBodySize);
1330 /*RTMP_LogHex(packet.m_body, packet.m_nBodySize); */
1331
1332 if (HandleInvoke(r, packet->m_body, packet->m_nBodySize) == 1)
1333 bHasMediaPacket = 2;
1334 break;
1335
1336 case RTMP_PACKET_TYPE_FLASH_VIDEO:
1337 {
1338 /* go through FLV packets and handle metadata packets */
1339 unsigned int pos = 0;
1340 uint32_t nTimeStamp = packet->m_nTimeStamp;
1341
1342 while (pos + 11 < packet->m_nBodySize)
1343 {
1344 uint32_t dataSize = AMF_DecodeInt24(packet->m_body + pos + 1); /* size without header (11) and prevTagSize (4) */
1345
1346 if (pos + 11 + dataSize + 4 > packet->m_nBodySize)
1347 {
1348 RTMP_Log(RTMP_LOGWARNING, "Stream corrupt?!");
1349 break;
1350 }
1351 if (packet->m_body[pos] == 0x12)
1352 {
1353 HandleMetadata(r, packet->m_body + pos + 11, dataSize);
1354 }
1355 else if (packet->m_body[pos] == 8 || packet->m_body[pos] == 9)
1356 {
1357 nTimeStamp = AMF_DecodeInt24(packet->m_body + pos + 4);
1358 nTimeStamp |= (packet->m_body[pos + 7] << 24);
1359 }
1360 pos += (11 + dataSize + 4);
1361 }
1362 if (!r->m_pausing)
1363 r->m_mediaStamp = nTimeStamp;
1364
1365 /* FLV tag(s) */
1366 /*RTMP_Log(RTMP_LOGDEBUG, "%s, received: FLV tag(s) %lu bytes", __FUNCTION__, packet.m_nBodySize); */
1367 bHasMediaPacket = 1;
1368 break;
1369 }
1370 default:
1371 RTMP_Log(RTMP_LOGDEBUG, "%s, unknown packet type received: 0x%02x", __FUNCTION__,
1372 packet->m_packetType);
1373 #ifdef _DEBUG
1374 RTMP_LogHex(RTMP_LOGDEBUG, packet->m_body, packet->m_nBodySize);
1375 #endif
1376 }
1377
1378 return bHasMediaPacket;
1379 }
1380
1381 #ifdef _DEBUG
1382 extern FILE *netstackdump;
1383 extern FILE *netstackdump_read;
1384 #endif
1385
1386 static int
1387 ReadN(RTMP *r, char *buffer, int n)
1388 {
1389 int nOriginalSize = n;
1390 int avail;
1391 char *ptr;
1392
1393 r->m_sb.sb_timedout = FALSE;
1394
1395 #ifdef _DEBUG
1396 memset(buffer, 0, n);
1397 #endif
1398
1399 ptr = buffer;
1400 while (n > 0)
1401 {
1402 int nBytes = 0, nRead;
1403 if (r->Link.protocol & RTMP_FEATURE_HTTP)
1404 {
1405 int refill = 0;
1406 while (!r->m_resplen)
1407 {
1408 int ret;
1409 if (r->m_sb.sb_size < 13 || refill)
1410 {
1411 if (!r->m_unackd)
1412 HTTP_Post(r, RTMPT_IDLE, "", 1);
1413 if (RTMPSockBuf_Fill(&r->m_sb) < 1)
1414 {
1415 if (!r->m_sb.sb_timedout)
1416 RTMP_Close(r);
1417 return 0;
1418 }
1419 }
1420 if ((ret = HTTP_read(r, 0)) == -1)
1421 {
1422 RTMP_Log(RTMP_LOGDEBUG, "%s, No valid HTTP response found", __FUNCTION__);
1423 RTMP_Close(r);
1424 return 0;
1425 }
1426 else if (ret == -2)
1427 {
1428 refill = 1;
1429 }
1430 else
1431 {
1432 refill = 0;
1433 }
1434 }
1435 if (r->m_resplen && !r->m_sb.sb_size)
1436 RTMPSockBuf_Fill(&r->m_sb);
1437 avail = r->m_sb.sb_size;
1438 if (avail > r->m_resplen)
1439 avail = r->m_resplen;
1440 }
1441 else
1442 {
1443 avail = r->m_sb.sb_size;
1444 if (avail == 0)
1445 {
1446 if (RTMPSockBuf_Fill(&r->m_sb) < 1)
1447 {
1448 if (!r->m_sb.sb_timedout)
1449 RTMP_Close(r);
1450 return 0;
1451 }
1452 avail = r->m_sb.sb_size;
1453 }
1454 }
1455 nRead = ((n < avail) ? n : avail);
1456 if (nRead > 0)
1457 {
1458 memcpy(ptr, r->m_sb.sb_start, nRead);
1459 r->m_sb.sb_start += nRead;
1460 r->m_sb.sb_size -= nRead;
1461 nBytes = nRead;
1462 r->m_nBytesIn += nRead;
1463 if (r->m_bSendCounter
1464 && r->m_nBytesIn > ( r->m_nBytesInSent + r->m_nClientBW / 10))
1465 if (!SendBytesReceived(r))
1466 return FALSE;
1467 }
1468 /*RTMP_Log(RTMP_LOGDEBUG, "%s: %d bytes\n", __FUNCTION__, nBytes); */
1469 #ifdef _DEBUG
1470 fwrite(ptr, 1, nBytes, netstackdump_read);
1471 #endif
1472
1473 if (nBytes == 0)
1474 {
1475 RTMP_Log(RTMP_LOGDEBUG, "%s, RTMP socket closed by peer", __FUNCTION__);
1476 /*goto again; */
1477 RTMP_Close(r);
1478 break;
1479 }
1480
1481 if (r->Link.protocol & RTMP_FEATURE_HTTP)
1482 r->m_resplen -= nBytes;
1483
1484 #ifdef CRYPTO
1485 if (r->Link.rc4keyIn)
1486 {
1487 RC4_encrypt(r->Link.rc4keyIn, nBytes, ptr);
1488 }
1489 #endif
1490
1491 n -= nBytes;
1492 ptr += nBytes;
1493 }
1494
1495 return nOriginalSize - n;
1496 }
1497
1498 static int
1499 WriteN(RTMP *r, const char *buffer, int n)
1500 {
1501 const char *ptr = buffer;
1502 #ifdef CRYPTO
1503 char *encrypted = 0;
1504 char buf[RTMP_BUFFER_CACHE_SIZE];
1505
1506 if (r->Link.rc4keyOut)
1507 {
1508 if (n > sizeof(buf))
1509 encrypted = (char *)malloc(n);
1510 else
1511 encrypted = (char *)buf;
1512 ptr = encrypted;
1513 RC4_encrypt2(r->Link.rc4keyOut, n, buffer, ptr);
1514 }
1515 #endif
1516
1517 while (n > 0)
1518 {
1519 int nBytes;
1520
1521 if (r->Link.protocol & RTMP_FEATURE_HTTP)
1522 nBytes = HTTP_Post(r, RTMPT_SEND, ptr, n);
1523 else
1524 nBytes = RTMPSockBuf_Send(&r->m_sb, ptr, n);
1525 /*RTMP_Log(RTMP_LOGDEBUG, "%s: %d\n", __FUNCTION__, nBytes); */
1526
1527 if (nBytes < 0)
1528 {
1529 int sockerr = GetSockError();
1530 RTMP_Log(RTMP_LOGERROR, "%s, RTMP send error %d (%d bytes)", __FUNCTION__,
1531 sockerr, n);
1532
1533 if (sockerr == EINTR && !RTMP_ctrlC)
1534 continue;
1535
1536 RTMP_Close(r);
1537 n = 1;
1538 break;
1539 }
1540
1541 if (nBytes == 0)
1542 break;
1543
1544 n -= nBytes;
1545 ptr += nBytes;
1546 }
1547
1548 #ifdef CRYPTO
1549 if (encrypted && encrypted != buf)
1550 free(encrypted);
1551 #endif
1552
1553 return n == 0;
1554 }
1555
1556 #define SAVC(x) static const AVal av_##x = AVC(#x)
1557
1558 SAVC(app);
1559 SAVC(connect);
1560 SAVC(flashVer);
1561 SAVC(swfUrl);
1562 SAVC(pageUrl);
1563 SAVC(tcUrl);
1564 SAVC(fpad);
1565 SAVC(capabilities);
1566 SAVC(audioCodecs);
1567 SAVC(videoCodecs);
1568 SAVC(videoFunction);
1569 SAVC(objectEncoding);
1570 SAVC(secureToken);
1571 SAVC(secureTokenResponse);
1572 SAVC(type);
1573 SAVC(nonprivate);
1574
1575 static int
1576 SendConnectPacket(RTMP *r, RTMPPacket *cp)
1577 {
1578 RTMPPacket packet;
1579 char pbuf[4096], *pend = pbuf + sizeof(pbuf);
1580 char *enc;
1581
1582 if (cp)
1583 return RTMP_SendPacket(r, cp, TRUE);
1584
1585 packet.m_nChannel = 0x03; /* control channel (invoke) */
1586 packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
1587 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1588 packet.m_nTimeStamp = 0;
1589 packet.m_nInfoField2 = 0;
1590 packet.m_hasAbsTimestamp = 0;
1591 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1592
1593 enc = packet.m_body;
1594 enc = AMF_EncodeString(enc, pend, &av_connect);
1595 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1596 *enc++ = AMF_OBJECT;
1597
1598 enc = AMF_EncodeNamedString(enc, pend, &av_app, &r->Link.app);
1599 if (!enc)
1600 return FALSE;
1601 if (r->Link.protocol & RTMP_FEATURE_WRITE)
1602 {
1603 enc = AMF_EncodeNamedString(enc, pend, &av_type, &av_nonprivate);
1604 if (!enc)
1605 return FALSE;
1606 }
1607 if (r->Link.flashVer.av_len)
1608 {
1609 enc = AMF_EncodeNamedString(enc, pend, &av_flashVer, &r->Link.flashVer);
1610 if (!enc)
1611 return FALSE;
1612 }
1613 if (r->Link.swfUrl.av_len)
1614 {
1615 enc = AMF_EncodeNamedString(enc, pend, &av_swfUrl, &r->Link.swfUrl);
1616 if (!enc)
1617 return FALSE;
1618 }
1619 if (r->Link.tcUrl.av_len)
1620 {
1621 enc = AMF_EncodeNamedString(enc, pend, &av_tcUrl, &r->Link.tcUrl);
1622 if (!enc)
1623 return FALSE;
1624 }
1625 if (!(r->Link.protocol & RTMP_FEATURE_WRITE))
1626 {
1627 enc = AMF_EncodeNamedBoolean(enc, pend, &av_fpad, FALSE);
1628 if (!enc)
1629 return FALSE;
1630 enc = AMF_EncodeNamedNumber(enc, pend, &av_capabilities, 15.0);
1631 if (!enc)
1632 return FALSE;
1633 enc = AMF_EncodeNamedNumber(enc, pend, &av_audioCodecs, r->m_fAudioCodecs);
1634 if (!enc)
1635 return FALSE;
1636 enc = AMF_EncodeNamedNumber(enc, pend, &av_videoCodecs, r->m_fVideoCodecs);
1637 if (!enc)
1638 return FALSE;
1639 enc = AMF_EncodeNamedNumber(enc, pend, &av_videoFunction, 1.0);
1640 if (!enc)
1641 return FALSE;
1642 if (r->Link.pageUrl.av_len)
1643 {
1644 enc = AMF_EncodeNamedString(enc, pend, &av_pageUrl, &r->Link.pageUrl);
1645 if (!enc)
1646 return FALSE;
1647 }
1648 }
1649 if (r->m_fEncoding != 0.0 || r->m_bSendEncoding)
1650 { /* AMF0, AMF3 not fully supported yet */
1651 enc = AMF_EncodeNamedNumber(enc, pend, &av_objectEncoding, r->m_fEncoding);
1652 if (!enc)
1653 return FALSE;
1654 }
1655 if (enc + 3 >= pend)
1656 return FALSE;
1657 *enc++ = 0;
1658 *enc++ = 0; /* end of object - 0x00 0x00 0x09 */
1659 *enc++ = AMF_OBJECT_END;
1660
1661 /* add auth string */
1662 if (r->Link.auth.av_len)
1663 {
1664 enc = AMF_EncodeBoolean(enc, pend, r->Link.lFlags & RTMP_LF_AUTH);
1665 if (!enc)
1666 return FALSE;
1667 enc = AMF_EncodeString(enc, pend, &r->Link.auth);
1668 if (!enc)
1669 return FALSE;
1670 }
1671 if (r->Link.extras.o_num)
1672 {
1673 int i;
1674 for (i = 0; i < r->Link.extras.o_num; i++)
1675 {
1676 enc = AMFProp_Encode(&r->Link.extras.o_props[i], enc, pend);
1677 if (!enc)
1678 return FALSE;
1679 }
1680 }
1681 packet.m_nBodySize = enc - packet.m_body;
1682
1683 return RTMP_SendPacket(r, &packet, TRUE);
1684 }
1685
1686 #if 0 /* unused */
1687 SAVC(bgHasStream);
1688
1689 static int
1690 SendBGHasStream(RTMP *r, double dId, AVal *playpath)
1691 {
1692 RTMPPacket packet;
1693 char pbuf[1024], *pend = pbuf + sizeof(pbuf);
1694 char *enc;
1695
1696 packet.m_nChannel = 0x03; /* control channel (invoke) */
1697 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
1698 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1699 packet.m_nTimeStamp = 0;
1700 packet.m_nInfoField2 = 0;
1701 packet.m_hasAbsTimestamp = 0;
1702 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1703
1704 enc = packet.m_body;
1705 enc = AMF_EncodeString(enc, pend, &av_bgHasStream);
1706 enc = AMF_EncodeNumber(enc, pend, dId);
1707 *enc++ = AMF_NULL;
1708
1709 enc = AMF_EncodeString(enc, pend, playpath);
1710 if (enc == NULL)
1711 return FALSE;
1712
1713 packet.m_nBodySize = enc - packet.m_body;
1714
1715 return RTMP_SendPacket(r, &packet, TRUE);
1716 }
1717 #endif
1718
1719 SAVC(createStream);
1720
1721 int
1722 RTMP_SendCreateStream(RTMP *r)
1723 {
1724 RTMPPacket packet;
1725 char pbuf[256], *pend = pbuf + sizeof(pbuf);
1726 char *enc;
1727
1728 packet.m_nChannel = 0x03; /* control channel (invoke) */
1729 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
1730 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1731 packet.m_nTimeStamp = 0;
1732 packet.m_nInfoField2 = 0;
1733 packet.m_hasAbsTimestamp = 0;
1734 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1735
1736 enc = packet.m_body;
1737 enc = AMF_EncodeString(enc, pend, &av_createStream);
1738 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1739 *enc++ = AMF_NULL; /* NULL */
1740
1741 packet.m_nBodySize = enc - packet.m_body;
1742
1743 return RTMP_SendPacket(r, &packet, TRUE);
1744 }
1745
1746 SAVC(FCSubscribe);
1747
1748 static int
1749 SendFCSubscribe(RTMP *r, AVal *subscribepath)
1750 {
1751 RTMPPacket packet;
1752 char pbuf[512], *pend = pbuf + sizeof(pbuf);
1753 char *enc;
1754 packet.m_nChannel = 0x03; /* control channel (invoke) */
1755 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
1756 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1757 packet.m_nTimeStamp = 0;
1758 packet.m_nInfoField2 = 0;
1759 packet.m_hasAbsTimestamp = 0;
1760 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1761
1762 RTMP_Log(RTMP_LOGDEBUG, "FCSubscribe: %s", subscribepath->av_val);
1763 enc = packet.m_body;
1764 enc = AMF_EncodeString(enc, pend, &av_FCSubscribe);
1765 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1766 *enc++ = AMF_NULL;
1767 enc = AMF_EncodeString(enc, pend, subscribepath);
1768
1769 if (!enc)
1770 return FALSE;
1771
1772 packet.m_nBodySize = enc - packet.m_body;
1773
1774 return RTMP_SendPacket(r, &packet, TRUE);
1775 }
1776
1777 /* Justin.tv specific authentication */
1778 static const AVal av_NetStream_Authenticate_UsherToken = AVC("NetStream.Authenticate.UsherToken");
1779
1780 static int
1781 SendUsherToken(RTMP *r, AVal *usherToken)
1782 {
1783 RTMPPacket packet;
1784 char pbuf[1024], *pend = pbuf + sizeof(pbuf);
1785 char *enc;
1786 packet.m_nChannel = 0x03; /* control channel (invoke) */
1787 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
1788 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1789 packet.m_nTimeStamp = 0;
1790 packet.m_nInfoField2 = 0;
1791 packet.m_hasAbsTimestamp = 0;
1792 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1793
1794 RTMP_Log(RTMP_LOGDEBUG, "UsherToken: %s", usherToken->av_val);
1795 enc = packet.m_body;
1796 enc = AMF_EncodeString(enc, pend, &av_NetStream_Authenticate_UsherToken);
1797 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1798 *enc++ = AMF_NULL;
1799 enc = AMF_EncodeString(enc, pend, usherToken);
1800
1801 if (!enc)
1802 return FALSE;
1803
1804 packet.m_nBodySize = enc - packet.m_body;
1805
1806 return RTMP_SendPacket(r, &packet, FALSE);
1807 }
1808 /******************************************/
1809
1810 SAVC(releaseStream);
1811
1812 static int
1813 SendReleaseStream(RTMP *r)
1814 {
1815 RTMPPacket packet;
1816 char pbuf[1024], *pend = pbuf + sizeof(pbuf);
1817 char *enc;
1818
1819 packet.m_nChannel = 0x03; /* control channel (invoke) */
1820 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
1821 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1822 packet.m_nTimeStamp = 0;
1823 packet.m_nInfoField2 = 0;
1824 packet.m_hasAbsTimestamp = 0;
1825 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1826
1827 enc = packet.m_body;
1828 enc = AMF_EncodeString(enc, pend, &av_releaseStream);
1829 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1830 *enc++ = AMF_NULL;
1831 enc = AMF_EncodeString(enc, pend, &r->Link.playpath);
1832 if (!enc)
1833 return FALSE;
1834
1835 packet.m_nBodySize = enc - packet.m_body;
1836
1837 return RTMP_SendPacket(r, &packet, FALSE);
1838 }
1839
1840 SAVC(FCPublish);
1841
1842 static int
1843 SendFCPublish(RTMP *r)
1844 {
1845 RTMPPacket packet;
1846 char pbuf[1024], *pend = pbuf + sizeof(pbuf);
1847 char *enc;
1848
1849 packet.m_nChannel = 0x03; /* control channel (invoke) */
1850 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
1851 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1852 packet.m_nTimeStamp = 0;
1853 packet.m_nInfoField2 = 0;
1854 packet.m_hasAbsTimestamp = 0;
1855 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1856
1857 enc = packet.m_body;
1858 enc = AMF_EncodeString(enc, pend, &av_FCPublish);
1859 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1860 *enc++ = AMF_NULL;
1861 enc = AMF_EncodeString(enc, pend, &r->Link.playpath);
1862 if (!enc)
1863 return FALSE;
1864
1865 packet.m_nBodySize = enc - packet.m_body;
1866
1867 return RTMP_SendPacket(r, &packet, FALSE);
1868 }
1869
1870 SAVC(FCUnpublish);
1871
1872 static int
1873 SendFCUnpublish(RTMP *r)
1874 {
1875 RTMPPacket packet;
1876 char pbuf[1024], *pend = pbuf + sizeof(pbuf);
1877 char *enc;
1878
1879 packet.m_nChannel = 0x03; /* control channel (invoke) */
1880 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
1881 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1882 packet.m_nTimeStamp = 0;
1883 packet.m_nInfoField2 = 0;
1884 packet.m_hasAbsTimestamp = 0;
1885 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1886
1887 enc = packet.m_body;
1888 enc = AMF_EncodeString(enc, pend, &av_FCUnpublish);
1889 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1890 *enc++ = AMF_NULL;
1891 enc = AMF_EncodeString(enc, pend, &r->Link.playpath);
1892 if (!enc)
1893 return FALSE;
1894
1895 packet.m_nBodySize = enc - packet.m_body;
1896
1897 return RTMP_SendPacket(r, &packet, FALSE);
1898 }
1899
1900 SAVC(publish);
1901 SAVC(live);
1902 SAVC(record);
1903
1904 static int
1905 SendPublish(RTMP *r)
1906 {
1907 RTMPPacket packet;
1908 char pbuf[1024], *pend = pbuf + sizeof(pbuf);
1909 char *enc;
1910
1911 packet.m_nChannel = 0x04; /* source channel (invoke) */
1912 packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
1913 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1914 packet.m_nTimeStamp = 0;
1915 packet.m_nInfoField2 = r->m_stream_id;
1916 packet.m_hasAbsTimestamp = 0;
1917 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1918
1919 enc = packet.m_body;
1920 enc = AMF_EncodeString(enc, pend, &av_publish);
1921 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1922 *enc++ = AMF_NULL;
1923 enc = AMF_EncodeString(enc, pend, &r->Link.playpath);
1924 if (!enc)
1925 return FALSE;
1926
1927 /* FIXME: should we choose live based on Link.lFlags & RTMP_LF_LIVE? */
1928 enc = AMF_EncodeString(enc, pend, &av_live);
1929 if (!enc)
1930 return FALSE;
1931
1932 packet.m_nBodySize = enc - packet.m_body;
1933
1934 return RTMP_SendPacket(r, &packet, TRUE);
1935 }
1936
1937 SAVC(deleteStream);
1938
1939 static int
1940 SendDeleteStream(RTMP *r, double dStreamId)
1941 {
1942 RTMPPacket packet;
1943 char pbuf[256], *pend = pbuf + sizeof(pbuf);
1944 char *enc;
1945
1946 packet.m_nChannel = 0x03; /* control channel (invoke) */
1947 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
1948 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1949 packet.m_nTimeStamp = 0;
1950 packet.m_nInfoField2 = 0;
1951 packet.m_hasAbsTimestamp = 0;
1952 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1953
1954 enc = packet.m_body;
1955 enc = AMF_EncodeString(enc, pend, &av_deleteStream);
1956 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1957 *enc++ = AMF_NULL;
1958 enc = AMF_EncodeNumber(enc, pend, dStreamId);
1959
1960 packet.m_nBodySize = enc - packet.m_body;
1961
1962 /* no response expected */
1963 return RTMP_SendPacket(r, &packet, FALSE);
1964 }
1965
1966 SAVC(pause);
1967
1968 int
1969 RTMP_SendPause(RTMP *r, int DoPause, int iTime)
1970 {
1971 RTMPPacket packet;
1972 char pbuf[256], *pend = pbuf + sizeof(pbuf);
1973 char *enc;
1974
1975 packet.m_nChannel = 0x08; /* video channel */
1976 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
1977 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
1978 packet.m_nTimeStamp = 0;
1979 packet.m_nInfoField2 = 0;
1980 packet.m_hasAbsTimestamp = 0;
1981 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
1982
1983 enc = packet.m_body;
1984 enc = AMF_EncodeString(enc, pend, &av_pause);
1985 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
1986 *enc++ = AMF_NULL;
1987 enc = AMF_EncodeBoolean(enc, pend, DoPause);
1988 enc = AMF_EncodeNumber(enc, pend, (double)iTime);
1989
1990 packet.m_nBodySize = enc - packet.m_body;
1991
1992 RTMP_Log(RTMP_LOGDEBUG, "%s, %d, pauseTime=%d", __FUNCTION__, DoPause, iTime);
1993 return RTMP_SendPacket(r, &packet, TRUE);
1994 }
1995
1996 int RTMP_Pause(RTMP *r, int DoPause)
1997 {
1998 if (DoPause)
1999 r->m_pauseStamp = r->m_mediaChannel < r->m_channelsAllocatedIn ?
2000 r->m_channelTimestamp[r->m_mediaChannel] : 0;
2001 return RTMP_SendPause(r, DoPause, r->m_pauseStamp);
2002 }
2003
2004 SAVC(seek);
2005
2006 int
2007 RTMP_SendSeek(RTMP *r, int iTime)
2008 {
2009 RTMPPacket packet;
2010 char pbuf[256], *pend = pbuf + sizeof(pbuf);
2011 char *enc;
2012
2013 packet.m_nChannel = 0x08; /* video channel */
2014 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
2015 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
2016 packet.m_nTimeStamp = 0;
2017 packet.m_nInfoField2 = 0;
2018 packet.m_hasAbsTimestamp = 0;
2019 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2020
2021 enc = packet.m_body;
2022 enc = AMF_EncodeString(enc, pend, &av_seek);
2023 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
2024 *enc++ = AMF_NULL;
2025 enc = AMF_EncodeNumber(enc, pend, (double)iTime);
2026
2027 packet.m_nBodySize = enc - packet.m_body;
2028
2029 r->m_read.flags |= RTMP_READ_SEEKING;
2030 r->m_read.nResumeTS = 0;
2031
2032 return RTMP_SendPacket(r, &packet, TRUE);
2033 }
2034
2035 int
2036 RTMP_SendServerBW(RTMP *r)
2037 {
2038 RTMPPacket packet;
2039 char pbuf[256], *pend = pbuf + sizeof(pbuf);
2040
2041 packet.m_nChannel = 0x02; /* control channel (invoke) */
2042 packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
2043 packet.m_packetType = RTMP_PACKET_TYPE_SERVER_BW;
2044 packet.m_nTimeStamp = 0;
2045 packet.m_nInfoField2 = 0;
2046 packet.m_hasAbsTimestamp = 0;
2047 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2048
2049 packet.m_nBodySize = 4;
2050
2051 AMF_EncodeInt32(packet.m_body, pend, r->m_nServerBW);
2052 return RTMP_SendPacket(r, &packet, FALSE);
2053 }
2054
2055 int
2056 RTMP_SendClientBW(RTMP *r)
2057 {
2058 RTMPPacket packet;
2059 char pbuf[256], *pend = pbuf + sizeof(pbuf);
2060
2061 packet.m_nChannel = 0x02; /* control channel (invoke) */
2062 packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
2063 packet.m_packetType = RTMP_PACKET_TYPE_CLIENT_BW;
2064 packet.m_nTimeStamp = 0;
2065 packet.m_nInfoField2 = 0;
2066 packet.m_hasAbsTimestamp = 0;
2067 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2068
2069 packet.m_nBodySize = 5;
2070
2071 AMF_EncodeInt32(packet.m_body, pend, r->m_nClientBW);
2072 packet.m_body[4] = r->m_nClientBW2;
2073 return RTMP_SendPacket(r, &packet, FALSE);
2074 }
2075
2076 static int
2077 SendBytesReceived(RTMP *r)
2078 {
2079 RTMPPacket packet;
2080 char pbuf[256], *pend = pbuf + sizeof(pbuf);
2081
2082 packet.m_nChannel = 0x02; /* control channel (invoke) */
2083 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
2084 packet.m_packetType = RTMP_PACKET_TYPE_BYTES_READ_REPORT;
2085 packet.m_nTimeStamp = 0;
2086 packet.m_nInfoField2 = 0;
2087 packet.m_hasAbsTimestamp = 0;
2088 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2089
2090 packet.m_nBodySize = 4;
2091
2092 AMF_EncodeInt32(packet.m_body, pend, r->m_nBytesIn); /* hard coded for now */
2093 r->m_nBytesInSent = r->m_nBytesIn;
2094
2095 /*RTMP_Log(RTMP_LOGDEBUG, "Send bytes report. 0x%x (%d bytes)", (unsigned int)m_nBytesIn, m_nBytesIn); */
2096 return RTMP_SendPacket(r, &packet, FALSE);
2097 }
2098
2099 SAVC(_checkbw);
2100
2101 static int
2102 SendCheckBW(RTMP *r)
2103 {
2104 RTMPPacket packet;
2105 char pbuf[256], *pend = pbuf + sizeof(pbuf);
2106 char *enc;
2107
2108 packet.m_nChannel = 0x03; /* control channel (invoke) */
2109 packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
2110 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
2111 packet.m_nTimeStamp = 0; /* RTMP_GetTime(); */
2112 packet.m_nInfoField2 = 0;
2113 packet.m_hasAbsTimestamp = 0;
2114 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2115
2116 enc = packet.m_body;
2117 enc = AMF_EncodeString(enc, pend, &av__checkbw);
2118 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
2119 *enc++ = AMF_NULL;
2120
2121 packet.m_nBodySize = enc - packet.m_body;
2122
2123 /* triggers _onbwcheck and eventually results in _onbwdone */
2124 return RTMP_SendPacket(r, &packet, FALSE);
2125 }
2126
2127 SAVC(_result);
2128
2129 static int
2130 SendCheckBWResult(RTMP *r, double txn)
2131 {
2132 RTMPPacket packet;
2133 char pbuf[256], *pend = pbuf + sizeof(pbuf);
2134 char *enc;
2135
2136 packet.m_nChannel = 0x03; /* control channel (invoke) */
2137 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
2138 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
2139 packet.m_nTimeStamp = 0x16 * r->m_nBWCheckCounter; /* temp inc value. till we figure it out. */
2140 packet.m_nInfoField2 = 0;
2141 packet.m_hasAbsTimestamp = 0;
2142 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2143
2144 enc = packet.m_body;
2145 enc = AMF_EncodeString(enc, pend, &av__result);
2146 enc = AMF_EncodeNumber(enc, pend, txn);
2147 *enc++ = AMF_NULL;
2148 enc = AMF_EncodeNumber(enc, pend, (double)r->m_nBWCheckCounter++);
2149
2150 packet.m_nBodySize = enc - packet.m_body;
2151
2152 return RTMP_SendPacket(r, &packet, FALSE);
2153 }
2154
2155 SAVC(ping);
2156 SAVC(pong);
2157
2158 static int
2159 SendPong(RTMP *r, double txn)
2160 {
2161 RTMPPacket packet;
2162 char pbuf[256], *pend = pbuf + sizeof(pbuf);
2163 char *enc;
2164
2165 packet.m_nChannel = 0x03; /* control channel (invoke) */
2166 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
2167 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
2168 packet.m_nTimeStamp = 0x16 * r->m_nBWCheckCounter; /* temp inc value. till we figure it out. */
2169 packet.m_nInfoField2 = 0;
2170 packet.m_hasAbsTimestamp = 0;
2171 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2172
2173 enc = packet.m_body;
2174 enc = AMF_EncodeString(enc, pend, &av_pong);
2175 enc = AMF_EncodeNumber(enc, pend, txn);
2176 *enc++ = AMF_NULL;
2177
2178 packet.m_nBodySize = enc - packet.m_body;
2179
2180 return RTMP_SendPacket(r, &packet, FALSE);
2181 }
2182
2183 SAVC(play);
2184
2185 static int
2186 SendPlay(RTMP *r)
2187 {
2188 RTMPPacket packet;
2189 char pbuf[1024], *pend = pbuf + sizeof(pbuf);
2190 char *enc;
2191
2192 packet.m_nChannel = 0x08; /* we make 8 our stream channel */
2193 packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
2194 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
2195 packet.m_nTimeStamp = 0;
2196 packet.m_nInfoField2 = r->m_stream_id; /*0x01000000; */
2197 packet.m_hasAbsTimestamp = 0;
2198 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2199
2200 enc = packet.m_body;
2201 enc = AMF_EncodeString(enc, pend, &av_play);
2202 enc = AMF_EncodeNumber(enc, pend, ++r->m_numInvokes);
2203 *enc++ = AMF_NULL;
2204
2205 RTMP_Log(RTMP_LOGDEBUG, "%s, seekTime=%d, stopTime=%d, sending play: %s",
2206 __FUNCTION__, r->Link.seekTime, r->Link.stopTime,
2207 r->Link.playpath.av_val);
2208 enc = AMF_EncodeString(enc, pend, &r->Link.playpath);
2209 if (!enc)
2210 return FALSE;
2211
2212 /* Optional parameters start and len.
2213 *
2214 * start: -2, -1, 0, positive number
2215 * -2: looks for a live stream, then a recorded stream,
2216 * if not found any open a live stream
2217 * -1: plays a live stream
2218 * >=0: plays a recorded streams from 'start' milliseconds
2219 */
2220 if (r->Link.lFlags & RTMP_LF_LIVE)
2221 enc = AMF_EncodeNumber(enc, pend, -1000.0);
2222 else
2223 {
2224 if (r->Link.seekTime > 0.0)
2225 enc = AMF_EncodeNumber(enc, pend, r->Link.seekTime); /* resume from here */
2226 else
2227 enc = AMF_EncodeNumber(enc, pend, 0.0); /*-2000.0);*/ /* recorded as default, -2000.0 is not reliable since that freezes the player if the stream is not found */
2228 }
2229 if (!enc)
2230 return FALSE;
2231
2232 /* len: -1, 0, positive number
2233 * -1: plays live or recorded stream to the end (default)
2234 * 0: plays a frame 'start' ms away from the beginning
2235 * >0: plays a live or recoded stream for 'len' milliseconds
2236 */
2237 /*enc += EncodeNumber(enc, -1.0); */ /* len */
2238 if (r->Link.stopTime)
2239 {
2240 enc = AMF_EncodeNumber(enc, pend, r->Link.stopTime - r->Link.seekTime);
2241 if (!enc)
2242 return FALSE;
2243 }
2244
2245 packet.m_nBodySize = enc - packet.m_body;
2246
2247 return RTMP_SendPacket(r, &packet, TRUE);
2248 }
2249
2250 SAVC(set_playlist);
2251 SAVC(0);
2252
2253 static int
2254 SendPlaylist(RTMP *r)
2255 {
2256 RTMPPacket packet;
2257 char pbuf[1024], *pend = pbuf + sizeof(pbuf);
2258 char *enc;
2259
2260 packet.m_nChannel = 0x08; /* we make 8 our stream channel */
2261 packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
2262 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
2263 packet.m_nTimeStamp = 0;
2264 packet.m_nInfoField2 = r->m_stream_id; /*0x01000000; */
2265 packet.m_hasAbsTimestamp = 0;
2266 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2267
2268 enc = packet.m_body;
2269 enc = AMF_EncodeString(enc, pend, &av_set_playlist);
2270 enc = AMF_EncodeNumber(enc, pend, 0);
2271 *enc++ = AMF_NULL;
2272 *enc++ = AMF_ECMA_ARRAY;
2273 *enc++ = 0;
2274 *enc++ = 0;
2275 *enc++ = 0;
2276 *enc++ = AMF_OBJECT;
2277 enc = AMF_EncodeNamedString(enc, pend, &av_0, &r->Link.playpath);
2278 if (!enc)
2279 return FALSE;
2280 if (enc + 3 >= pend)
2281 return FALSE;
2282 *enc++ = 0;
2283 *enc++ = 0;
2284 *enc++ = AMF_OBJECT_END;
2285
2286 packet.m_nBodySize = enc - packet.m_body;
2287
2288 return RTMP_SendPacket(r, &packet, TRUE);
2289 }
2290
2291 static int
2292 SendSecureTokenResponse(RTMP *r, AVal *resp)
2293 {
2294 RTMPPacket packet;
2295 char pbuf[1024], *pend = pbuf + sizeof(pbuf);
2296 char *enc;
2297
2298 packet.m_nChannel = 0x03; /* control channel (invoke) */
2299 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
2300 packet.m_packetType = RTMP_PACKET_TYPE_INVOKE;
2301 packet.m_nTimeStamp = 0;
2302 packet.m_nInfoField2 = 0;
2303 packet.m_hasAbsTimestamp = 0;
2304 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2305
2306 enc = packet.m_body;
2307 enc = AMF_EncodeString(enc, pend, &av_secureTokenResponse);
2308 enc = AMF_EncodeNumber(enc, pend, 0.0);
2309 *enc++ = AMF_NULL;
2310 enc = AMF_EncodeString(enc, pend, resp);
2311 if (!enc)
2312 return FALSE;
2313
2314 packet.m_nBodySize = enc - packet.m_body;
2315
2316 return RTMP_SendPacket(r, &packet, FALSE);
2317 }
2318
2319 /*
2320 from http://jira.red5.org/confluence/display/docs/Ping:
2321
2322 Ping is the most mysterious message in RTMP and till now we haven't fully interpreted it yet. In summary, Ping message is used as a special command that are exchanged between client and server. This page aims to document all known Ping messages. Expect the list to grow.
2323
2324 The type of Ping packet is 0x4 and contains two mandatory parameters and two optional parameters. The first parameter is the type of Ping and in short integer. The second parameter is the target of the ping. As Ping is always sent in Channel 2 (control channel) and the target object in RTMP header is always 0 which means the Connection object, it's necessary to put an extra parameter to indicate the exact target object the Ping is sent to. The second parameter takes this responsibility. The value has the same meaning as the target object field in RTMP header. (The second value could also be used as other purposes, like RTT Ping/Pong. It is used as the timestamp.) The third and fourth parameters are optional and could be looked upon as the parameter of the Ping packet. Below is an unexhausted list of Ping messages.
2325
2326 * type 0: Clear the stream. No third and fourth parameters. The second parameter could be 0. After the connection is established, a Ping 0,0 will be sent from server to client. The message will also be sent to client on the start of Play and in response of a Seek or Pause/Resume request. This Ping tells client to re-calibrate the clock with the timestamp of the next packet server sends.
2327 * type 1: Tell the stream to clear the playing buffer.
2328 * type 3: Buffer time of the client. The third parameter is the buffer time in millisecond.
2329 * type 4: Reset a stream. Used together with type 0 in the case of VOD. Often sent before type 0.
2330 * type 6: Ping the client from server. The second parameter is the current time.
2331 * type 7: Pong reply from client. The second parameter is the time the server sent with his ping request.
2332 * type 26: SWFVerification request
2333 * type 27: SWFVerification response
2334 */
2335 int
2336 RTMP_SendCtrl(RTMP *r, short nType, unsigned int nObject, unsigned int nTime)
2337 {
2338 RTMPPacket packet;
2339 char pbuf[256], *pend = pbuf + sizeof(pbuf);
2340 int nSize;
2341 char *buf;
2342
2343 RTMP_Log(RTMP_LOGDEBUG, "sending ctrl. type: 0x%04x", (unsigned short)nType);
2344
2345 packet.m_nChannel = 0x02; /* control channel (ping) */
2346 packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
2347 packet.m_packetType = RTMP_PACKET_TYPE_CONTROL;
2348 packet.m_nTimeStamp = 0; /* RTMP_GetTime(); */
2349 packet.m_nInfoField2 = 0;
2350 packet.m_hasAbsTimestamp = 0;
2351 packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
2352
2353 switch(nType) {
2354 case 0x03: nSize = 10; break; /* buffer time */
2355 case 0x1A: nSize = 3; break; /* SWF verify request */
2356 case 0x1B: nSize = 44; break; /* SWF verify response */
2357 default: nSize = 6; break;
2358 }
2359
2360 packet.m_nBodySize = nSize;
2361
2362 buf = packet.m_body;
2363 buf = AMF_EncodeInt16(buf, pend, nType);
2364
2365 if (nType == 0x1B)
2366 {
2367 #ifdef CRYPTO
2368 memcpy(buf, r->Link.SWFVerificationResponse, 42);
2369 RTMP_Log(RTMP_LOGDEBUG, "Sending SWFVerification response: ");
2370 RTMP_LogHex(RTMP_LOGDEBUG, (uint8_t *)packet.m_body, packet.m_nBodySize);
2371 #endif
2372 }
2373 else if (nType == 0x1A)
2374 {
2375 *buf = nObject & 0xff;
2376 }
2377 else
2378 {
2379 if (nSize > 2)
2380 buf = AMF_EncodeInt32(buf, pend, nObject);
2381
2382 if (nSize > 6)
2383 buf = AMF_EncodeInt32(buf, pend, nTime);
2384 }
2385
2386 return RTMP_SendPacket(r, &packet, FALSE);
2387 }
2388
2389 static void
2390 AV_erase(RTMP_METHOD *vals, int *num, int i, int freeit)
2391 {
2392 if (freeit)
2393 free(vals[i].name.av_val);
2394 (*num)--;
2395 for (; i < *num; i++)
2396 {
2397 vals[i] = vals[i + 1];
2398 }
2399 vals[i].name.av_val = NULL;
2400 vals[i].name.av_len = 0;
2401 vals[i].num = 0;
2402 }
2403
2404 void
2405 RTMP_DropRequest(RTMP *r, int i, int freeit)
2406 {
2407 AV_erase(r->m_methodCalls, &r->m_numCalls, i, freeit);
2408 }
2409
2410 static void
2411 AV_queue(RTMP_METHOD **vals, int *num, AVal *av, int txn)
2412 {
2413 char *tmp;
2414 if (!(*num & 0x0f))
2415 *vals = realloc(*vals, (*num + 16) * sizeof(RTMP_METHOD));
2416 tmp = malloc(av->av_len + 1);
2417 memcpy(tmp, av->av_val, av->av_len);
2418 tmp[av->av_len] = '\0';
2419 (*vals)[*num].num = txn;
2420 (*vals)[*num].name.av_len = av->av_len;
2421 (*vals)[(*num)++].name.av_val = tmp;
2422 }
2423
2424 static void
2425 AV_clear(RTMP_METHOD *vals, int num)
2426 {
2427 int i;
2428 for (i = 0; i < num; i++)
2429 free(vals[i].name.av_val);
2430 free(vals);
2431 }
2432
2433
2434 #ifdef CRYPTO
2435 static int
2436 b64enc(const unsigned char *input, int length, char *output, int maxsize)
2437 {
2438 #ifdef USE_POLARSSL
2439 size_t buf_size = maxsize;
2440 if(base64_encode((unsigned char *) output, &buf_size, input, length) == 0)
2441 {
2442 output[buf_size] = '\0';
2443 return 1;
2444 }
2445 else
2446 {
2447 RTMP_Log(RTMP_LOGDEBUG, "%s, error", __FUNCTION__);
2448 return 0;
2449 }
2450 #elif defined(USE_GNUTLS)
2451 if (BASE64_ENCODE_RAW_LENGTH(length) <= maxsize)
2452 base64_encode_raw((uint8_t*) output, length, input);
2453 else
2454 {
2455 RTMP_Log(RTMP_LOGDEBUG, "%s, error", __FUNCTION__);
2456 return 0;
2457 }
2458 #else /* USE_OPENSSL */
2459 BIO *bmem, *b64;
2460 BUF_MEM *bptr;
2461
2462 b64 = BIO_new(BIO_f_base64());
2463 bmem = BIO_new(BIO_s_mem());
2464 b64 = BIO_push(b64, bmem);
2465 BIO_write(b64, input, length);
2466 if (BIO_flush(b64) == 1)
2467 {
2468 BIO_get_mem_ptr(b64, &bptr);
2469 memcpy(output, bptr->data, bptr->length-1);
2470 output[bptr->length-1] = '\0';
2471 }
2472 else
2473 {
2474 RTMP_Log(RTMP_LOGDEBUG, "%s, error", __FUNCTION__);
2475 return 0;
2476 }
2477 BIO_free_all(b64);
2478 #endif
2479 return 1;
2480 }
2481
2482 #ifdef USE_POLARSSL
2483 #define MD5_CTX md5_context
2484 #define MD5_Init(ctx) md5_starts(ctx)
2485 #define MD5_Update(ctx,data,len) md5_update(ctx,(unsigned char *)data,len)
2486 #define MD5_Final(dig,ctx) md5_finish(ctx,dig)
2487 #elif defined(USE_GNUTLS)
2488 typedef struct md5_ctx MD5_CTX;
2489 #define MD5_Init(ctx) md5_init(ctx)
2490 #define MD5_Update(ctx,data,len) md5_update(ctx,len,data)
2491 #define MD5_Final(dig,ctx) md5_digest(ctx,MD5_DIGEST_LENGTH,dig)
2492 #else
2493 #endif
2494
2495 static const AVal av_authmod_adobe = AVC("authmod=adobe");
2496 static const AVal av_authmod_llnw = AVC("authmod=llnw");
2497
2498 static void hexenc(unsigned char *inbuf, int len, char *dst)
2499 {
2500 char *ptr = dst;
2501 while(len--) {
2502 sprintf(ptr, "%02x", *inbuf++);
2503 ptr += 2;
2504 }
2505 *ptr = '\0';
2506 }
2507
2508 static char *
2509 AValChr(AVal *av, char c)
2510 {
2511 int i;
2512 for (i = 0; i < av->av_len; i++)
2513 if (av->av_val[i] == c)
2514 return &av->av_val[i];
2515 return NULL;
2516 }
2517
2518 static int
2519 PublisherAuth(RTMP *r, AVal *description)
2520 {
2521 char *token_in = NULL;
2522 char *ptr;
2523 unsigned char md5sum_val[MD5_DIGEST_LENGTH+1];
2524 MD5_CTX md5ctx;
2525 int challenge2_data;
2526 #define RESPONSE_LEN 32
2527 #define CHALLENGE2_LEN 16
2528 #define SALTED2_LEN (32+8+8+8)
2529 #define B64DIGEST_LEN 24 /* 16 byte digest => 22 b64 chars + 2 chars padding */
2530 #define B64INT_LEN 8 /* 4 byte int => 6 b64 chars + 2 chars padding */
2531 #define HEXHASH_LEN (2*MD5_DIGEST_LENGTH)
2532 char response[RESPONSE_LEN];
2533 char challenge2[CHALLENGE2_LEN];
2534 char salted2[SALTED2_LEN];
2535 AVal pubToken;
2536
2537 if (strstr(description->av_val, av_authmod_adobe.av_val) != NULL)
2538 {
2539 if(strstr(description->av_val, "code=403 need auth") != NULL)
2540 {
2541 if (strstr(r->Link.app.av_val, av_authmod_adobe.av_val) != NULL) {
2542 RTMP_Log(RTMP_LOGERROR, "%s, wrong pubUser & pubPasswd for publisher auth", __FUNCTION__);
2543 return 0;
2544 } else if(r->Link.pubUser.av_len && r->Link.pubPasswd.av_len) {
2545 pubToken.av_val = malloc(r->Link.pubUser.av_len + av_authmod_adobe.av_len + 8);
2546 pubToken.av_len = sprintf(pubToken.av_val, "?%s&user=%s",
2547 av_authmod_adobe.av_val,
2548 r->Link.pubUser.av_val);
2549 RTMP_Log(RTMP_LOGDEBUG, "%s, pubToken1: %s", __FUNCTION__, pubToken.av_val);
2550 } else {
2551 RTMP_Log(RTMP_LOGERROR, "%s, need to set pubUser & pubPasswd for publisher auth", __FUNCTION__);
2552 return 0;
2553 }
2554 }
2555 else if((token_in = strstr(description->av_val, "?reason=needauth")) != NULL)
2556 {
2557 char *par, *val = NULL, *orig_ptr;
2558 AVal user, salt, opaque, challenge, *aptr = NULL;
2559 opaque.av_len = 0;
2560 challenge.av_len = 0;
2561
2562 ptr = orig_ptr = strdup(token_in);
2563 while (ptr)
2564 {
2565 par = ptr;
2566 ptr = strchr(par, '&');
2567 if(ptr)
2568 *ptr++ = '\0';
2569
2570 val = strchr(par, '=');
2571 if(val)
2572 *val++ = '\0';
2573
2574 if (aptr) {
2575 aptr->av_len = par - aptr->av_val - 1;
2576 aptr = NULL;
2577 }
2578 if (strcmp(par, "user") == 0){
2579 user.av_val = val;
2580 aptr = &user;
2581 } else if (strcmp(par, "salt") == 0){
2582 salt.av_val = val;
2583 aptr = &salt;
2584 } else if (strcmp(par, "opaque") == 0){
2585 opaque.av_val = val;
2586 aptr = &opaque;
2587 } else if (strcmp(par, "challenge") == 0){
2588 challenge.av_val = val;
2589 aptr = &challenge;
2590 }
2591
2592 RTMP_Log(RTMP_LOGDEBUG, "%s, par:\"%s\" = val:\"%s\"", __FUNCTION__, par, val);
2593 }
2594 if (aptr)
2595 aptr->av_len = strlen(aptr->av_val);
2596
2597 /* hash1 = base64enc(md5(user + _aodbeAuthSalt + password)) */
2598 MD5_Init(&md5ctx);
2599 MD5_Update(&md5ctx, user.av_val, user.av_len);
2600 MD5_Update(&md5ctx, salt.av_val, salt.av_len);
2601 MD5_Update(&md5ctx, r->Link.pubPasswd.av_val, r->Link.pubPasswd.av_len);
2602 MD5_Final(md5sum_val, &md5ctx);
2603 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s%s%s) =>", __FUNCTION__,
2604 user.av_val, salt.av_val, r->Link.pubPasswd.av_val);
2605 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2606
2607 b64enc(md5sum_val, MD5_DIGEST_LENGTH, salted2, SALTED2_LEN);
2608 RTMP_Log(RTMP_LOGDEBUG, "%s, b64(md5_1) = %s", __FUNCTION__, salted2);
2609
2610 challenge2_data = rand();
2611
2612 b64enc((unsigned char *) &challenge2_data, sizeof(int), challenge2, CHALLENGE2_LEN);
2613 RTMP_Log(RTMP_LOGDEBUG, "%s, b64(%d) = %s", __FUNCTION__, challenge2_data, challenge2);
2614
2615 MD5_Init(&md5ctx);
2616 MD5_Update(&md5ctx, salted2, B64DIGEST_LEN);
2617 /* response = base64enc(md5(hash1 + opaque + challenge2)) */
2618 if (opaque.av_len)
2619 MD5_Update(&md5ctx, opaque.av_val, opaque.av_len);
2620 else if (challenge.av_len)
2621 MD5_Update(&md5ctx, challenge.av_val, challenge.av_len);
2622 MD5_Update(&md5ctx, challenge2, B64INT_LEN);
2623 MD5_Final(md5sum_val, &md5ctx);
2624
2625 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s%s%s) =>", __FUNCTION__,
2626 salted2, opaque.av_len ? opaque.av_val : "", challenge2);
2627 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2628
2629 b64enc(md5sum_val, MD5_DIGEST_LENGTH, response, RESPONSE_LEN);
2630 RTMP_Log(RTMP_LOGDEBUG, "%s, b64(md5_2) = %s", __FUNCTION__, response);
2631
2632 /* have all hashes, create auth token for the end of app */
2633 pubToken.av_val = malloc(32 + B64INT_LEN + B64DIGEST_LEN + opaque.av_len);
2634 pubToken.av_len = sprintf(pubToken.av_val,
2635 "&challenge=%s&response=%s&opaque=%s",
2636 challenge2,
2637 response,
2638 opaque.av_len ? opaque.av_val : "");
2639 RTMP_Log(RTMP_LOGDEBUG, "%s, pubToken2: %s", __FUNCTION__, pubToken.av_val);
2640 free(orig_ptr);
2641 }
2642 else if(strstr(description->av_val, "?reason=authfailed") != NULL)
2643 {
2644 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: wrong password", __FUNCTION__);
2645 return 0;
2646 }
2647 else if(strstr(description->av_val, "?reason=nosuchuser") != NULL)
2648 {
2649 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: no such user", __FUNCTION__);
2650 return 0;
2651 }
2652 else
2653 {
2654 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: unknown auth mode: %s",
2655 __FUNCTION__, description->av_val);
2656 return 0;
2657 }
2658
2659 ptr = malloc(r->Link.app.av_len + pubToken.av_len);
2660 strncpy(ptr, r->Link.app.av_val, r->Link.app.av_len);
2661 strncpy(ptr + r->Link.app.av_len, pubToken.av_val, pubToken.av_len);
2662 r->Link.app.av_len += pubToken.av_len;
2663 if(r->Link.lFlags & RTMP_LF_FAPU)
2664 free(r->Link.app.av_val);
2665 r->Link.app.av_val = ptr;
2666
2667 ptr = malloc(r->Link.tcUrl.av_len + pubToken.av_len);
2668 strncpy(ptr, r->Link.tcUrl.av_val, r->Link.tcUrl.av_len);
2669 strncpy(ptr + r->Link.tcUrl.av_len, pubToken.av_val, pubToken.av_len);
2670 r->Link.tcUrl.av_len += pubToken.av_len;
2671 if(r->Link.lFlags & RTMP_LF_FTCU)
2672 free(r->Link.tcUrl.av_val);
2673 r->Link.tcUrl.av_val = ptr;
2674
2675 free(pubToken.av_val);
2676 r->Link.lFlags |= RTMP_LF_FTCU | RTMP_LF_FAPU;
2677
2678 RTMP_Log(RTMP_LOGDEBUG, "%s, new app: %.*s tcUrl: %.*s playpath: %s", __FUNCTION__,
2679 r->Link.app.av_len, r->Link.app.av_val,
2680 r->Link.tcUrl.av_len, r->Link.tcUrl.av_val,
2681 r->Link.playpath.av_val);
2682 }
2683 else if (strstr(description->av_val, av_authmod_llnw.av_val) != NULL)
2684 {
2685 if(strstr(description->av_val, "code=403 need auth") != NULL)
2686 {
2687 /* This part seems to be the same for llnw and adobe */
2688
2689 if (strstr(r->Link.app.av_val, av_authmod_llnw.av_val) != NULL) {
2690 RTMP_Log(RTMP_LOGERROR, "%s, wrong pubUser & pubPasswd for publisher auth", __FUNCTION__);
2691 return 0;
2692 } else if(r->Link.pubUser.av_len && r->Link.pubPasswd.av_len) {
2693 pubToken.av_val = malloc(r->Link.pubUser.av_len + av_authmod_llnw.av_len + 8);
2694 pubToken.av_len = sprintf(pubToken.av_val, "?%s&user=%s",
2695 av_authmod_llnw.av_val,
2696 r->Link.pubUser.av_val);
2697 RTMP_Log(RTMP_LOGDEBUG, "%s, pubToken1: %s", __FUNCTION__, pubToken.av_val);
2698 } else {
2699 RTMP_Log(RTMP_LOGERROR, "%s, need to set pubUser & pubPasswd for publisher auth", __FUNCTION__);
2700 return 0;
2701 }
2702 }
2703 else if((token_in = strstr(description->av_val, "?reason=needauth")) != NULL)
2704 {
2705 char *orig_ptr;
2706 char *par, *val = NULL;
2707 char hash1[HEXHASH_LEN+1], hash2[HEXHASH_LEN+1], hash3[HEXHASH_LEN+1];
2708 AVal user, nonce, *aptr = NULL;
2709 AVal apptmp;
2710
2711 /* llnw auth method
2712 * Seems to be closely based on HTTP Digest Auth:
2713 * http://tools.ietf.org/html/rfc2617
2714 * http://en.wikipedia.org/wiki/Digest_access_authentication
2715 */
2716
2717 const char authmod[] = "llnw";
2718 const char realm[] = "live";
2719 const char method[] = "publish";
2720 const char qop[] = "auth";
2721 /* nc = 1..connection count (or rather, number of times cnonce has been reused) */
2722 int nc = 1;
2723 /* nchex = hexenc(nc) (8 hex digits according to RFC 2617) */
2724 char nchex[9];
2725 /* cnonce = hexenc(4 random bytes) (initialized on first connection) */
2726 char cnonce[9];
2727
2728 ptr = orig_ptr = strdup(token_in);
2729 /* Extract parameters (we need user and nonce) */
2730 while (ptr)
2731 {
2732 par = ptr;
2733 ptr = strchr(par, '&');
2734 if(ptr)
2735 *ptr++ = '\0';
2736
2737 val = strchr(par, '=');
2738 if(val)
2739 *val++ = '\0';
2740
2741 if (aptr) {
2742 aptr->av_len = par - aptr->av_val - 1;
2743 aptr = NULL;
2744 }
2745 if (strcmp(par, "user") == 0){
2746 user.av_val = val;
2747 aptr = &user;
2748 } else if (strcmp(par, "nonce") == 0){
2749 nonce.av_val = val;
2750 aptr = &nonce;
2751 }
2752
2753 RTMP_Log(RTMP_LOGDEBUG, "%s, par:\"%s\" = val:\"%s\"", __FUNCTION__, par, val);
2754 }
2755 if (aptr)
2756 aptr->av_len = strlen(aptr->av_val);
2757
2758 /* FIXME: handle case where user==NULL or nonce==NULL */
2759
2760 sprintf(nchex, "%08x", nc);
2761 sprintf(cnonce, "%08x", rand());
2762
2763 /* hash1 = hexenc(md5(user + ":" + realm + ":" + password)) */
2764 MD5_Init(&md5ctx);
2765 MD5_Update(&md5ctx, user.av_val, user.av_len);
2766 MD5_Update(&md5ctx, ":", 1);
2767 MD5_Update(&md5ctx, realm, sizeof(realm)-1);
2768 MD5_Update(&md5ctx, ":", 1);
2769 MD5_Update(&md5ctx, r->Link.pubPasswd.av_val, r->Link.pubPasswd.av_len);
2770 MD5_Final(md5sum_val, &md5ctx);
2771 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s:%s:%s) =>", __FUNCTION__,
2772 user.av_val, realm, r->Link.pubPasswd.av_val);
2773 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2774 hexenc(md5sum_val, MD5_DIGEST_LENGTH, hash1);
2775
2776 /* hash2 = hexenc(md5(method + ":/" + app + "/" + appInstance)) */
2777 /* Extract appname + appinstance without query parameters */
2778 apptmp = r->Link.app;
2779 ptr = AValChr(&apptmp, '?');
2780 if (ptr)
2781 apptmp.av_len = ptr - apptmp.av_val;
2782
2783 MD5_Init(&md5ctx);
2784 MD5_Update(&md5ctx, method, sizeof(method)-1);
2785 MD5_Update(&md5ctx, ":/", 2);
2786 MD5_Update(&md5ctx, apptmp.av_val, apptmp.av_len);
2787 if (!AValChr(&apptmp, '/'))
2788 MD5_Update(&md5ctx, "/_definst_", sizeof("/_definst_") - 1);
2789 MD5_Final(md5sum_val, &md5ctx);
2790 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s:/%.*s) =>", __FUNCTION__,
2791 method, apptmp.av_len, apptmp.av_val);
2792 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2793 hexenc(md5sum_val, MD5_DIGEST_LENGTH, hash2);
2794
2795 /* hash3 = hexenc(md5(hash1 + ":" + nonce + ":" + nchex + ":" + cnonce + ":" + qop + ":" + hash2)) */
2796 MD5_Init(&md5ctx);
2797 MD5_Update(&md5ctx, hash1, HEXHASH_LEN);
2798 MD5_Update(&md5ctx, ":", 1);
2799 MD5_Update(&md5ctx, nonce.av_val, nonce.av_len);
2800 MD5_Update(&md5ctx, ":", 1);
2801 MD5_Update(&md5ctx, nchex, sizeof(nchex)-1);
2802 MD5_Update(&md5ctx, ":", 1);
2803 MD5_Update(&md5ctx, cnonce, sizeof(cnonce)-1);
2804 MD5_Update(&md5ctx, ":", 1);
2805 MD5_Update(&md5ctx, qop, sizeof(qop)-1);
2806 MD5_Update(&md5ctx, ":", 1);
2807 MD5_Update(&md5ctx, hash2, HEXHASH_LEN);
2808 MD5_Final(md5sum_val, &md5ctx);
2809 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s:%s:%s:%s:%s:%s) =>", __FUNCTION__,
2810 hash1, nonce.av_val, nchex, cnonce, qop, hash2);
2811 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2812 hexenc(md5sum_val, MD5_DIGEST_LENGTH, hash3);
2813
2814 /* pubToken = &authmod=<authmod>&user=<username>&nonce=<nonce>&cnonce=<cnonce>&nc=<nchex>&response=<hash3> */
2815 /* Append nonces and response to query string which already contains
2816 * user + authmod */
2817 pubToken.av_val = malloc(64 + sizeof(authmod)-1 + user.av_len + nonce.av_len + sizeof(cnonce)-1 + sizeof(nchex)-1 + HEXHASH_LEN);
2818 sprintf(pubToken.av_val,
2819 "&nonce=%s&cnonce=%s&nc=%s&response=%s",
2820 nonce.av_val, cnonce, nchex, hash3);
2821 pubToken.av_len = strlen(pubToken.av_val);
2822 RTMP_Log(RTMP_LOGDEBUG, "%s, pubToken2: %s", __FUNCTION__, pubToken.av_val);
2823
2824 free(orig_ptr);
2825 }
2826 else if(strstr(description->av_val, "?reason=authfail") != NULL)
2827 {
2828 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed", __FUNCTION__);
2829 return 0;
2830 }
2831 else if(strstr(description->av_val, "?reason=nosuchuser") != NULL)
2832 {
2833 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: no such user", __FUNCTION__);
2834 return 0;
2835 }
2836 else
2837 {
2838 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: unknown auth mode: %s",
2839 __FUNCTION__, description->av_val);
2840 return 0;
2841 }
2842
2843 ptr = malloc(r->Link.app.av_len + pubToken.av_len);
2844 strncpy(ptr, r->Link.app.av_val, r->Link.app.av_len);
2845 strncpy(ptr + r->Link.app.av_len, pubToken.av_val, pubToken.av_len);
2846 r->Link.app.av_len += pubToken.av_len;
2847 if(r->Link.lFlags & RTMP_LF_FAPU)
2848 free(r->Link.app.av_val);
2849 r->Link.app.av_val = ptr;
2850
2851 ptr = malloc(r->Link.tcUrl.av_len + pubToken.av_len);
2852 strncpy(ptr, r->Link.tcUrl.av_val, r->Link.tcUrl.av_len);
2853 strncpy(ptr + r->Link.tcUrl.av_len, pubToken.av_val, pubToken.av_len);
2854 r->Link.tcUrl.av_len += pubToken.av_len;
2855 if(r->Link.lFlags & RTMP_LF_FTCU)
2856 free(r->Link.tcUrl.av_val);
2857 r->Link.tcUrl.av_val = ptr;
2858
2859 free(pubToken.av_val);
2860 r->Link.lFlags |= RTMP_LF_FTCU | RTMP_LF_FAPU;
2861
2862 RTMP_Log(RTMP_LOGDEBUG, "%s, new app: %.*s tcUrl: %.*s playpath: %s", __FUNCTION__,
2863 r->Link.app.av_len, r->Link.app.av_val,
2864 r->Link.tcUrl.av_len, r->Link.tcUrl.av_val,
2865 r->Link.playpath.av_val);
2866 }
2867 else
2868 {
2869 return 0;
2870 }
2871 return 1;
2872 }
2873 #endif
2874
2875
2876 SAVC(onBWDone);
2877 SAVC(onFCSubscribe);
2878 SAVC(onFCUnsubscribe);
2879 SAVC(_onbwcheck);
2880 SAVC(_onbwdone);
2881 SAVC(_error);
2882 SAVC(close);
2883 SAVC(code);
2884 SAVC(level);
2885 SAVC(description);
2886 SAVC(onStatus);
2887 SAVC(playlist_ready);
2888 static const AVal av_NetStream_Failed = AVC("NetStream.Failed");
2889 static const AVal av_NetStream_Play_Failed = AVC("NetStream.Play.Failed");
2890 static const AVal av_NetStream_Play_StreamNotFound =
2891 AVC("NetStream.Play.StreamNotFound");
2892 static const AVal av_NetConnection_Connect_InvalidApp =
2893 AVC("NetConnection.Connect.InvalidApp");
2894 static const AVal av_NetStream_Play_Start = AVC("NetStream.Play.Start");
2895 static const AVal av_NetStream_Play_Complete = AVC("NetStream.Play.Complete");
2896 static const AVal av_NetStream_Play_Stop = AVC("NetStream.Play.Stop");
2897 static const AVal av_NetStream_Seek_Notify = AVC("NetStream.Seek.Notify");
2898 static const AVal av_NetStream_Pause_Notify = AVC("NetStream.Pause.Notify");
2899 static const AVal av_NetStream_Play_PublishNotify =
2900 AVC("NetStream.Play.PublishNotify");
2901 static const AVal av_NetStream_Play_UnpublishNotify =
2902 AVC("NetStream.Play.UnpublishNotify");
2903 static const AVal av_NetStream_Publish_Start = AVC("NetStream.Publish.Start");
2904 static const AVal av_NetConnection_Connect_Rejected =
2905 AVC("NetConnection.Connect.Rejected");
2906
2907 /* Returns 0 for OK/Failed/error, 1 for 'Stop or Complete' */
2908 static int
2909 HandleInvoke(RTMP *r, const char *body, unsigned int nBodySize)
2910 {
2911 AMFObject obj;
2912 AVal method;
2913 double txn;
2914 int ret = 0, nRes;
2915 if (body[0] != 0x02) /* make sure it is a string method name we start with */
2916 {
2917 RTMP_Log(RTMP_LOGWARNING, "%s, Sanity failed. no string method in invoke packet",
2918 __FUNCTION__);
2919 return 0;
2920 }
2921
2922 nRes = AMF_Decode(&obj, body, nBodySize, FALSE);
2923 if (nRes < 0)
2924 {
2925 RTMP_Log(RTMP_LOGERROR, "%s, error decoding invoke packet", __FUNCTION__);
2926 return 0;
2927 }
2928
2929 AMF_Dump(&obj);
2930 AMFProp_GetString(AMF_GetProp(&obj, NULL, 0), &method);
2931 txn = AMFProp_GetNumber(AMF_GetProp(&obj, NULL, 1));
2932 RTMP_Log(RTMP_LOGDEBUG, "%s, server invoking <%s>", __FUNCTION__, method.av_val);
2933
2934 if (AVMATCH(&method, &av__result))
2935 {
2936 AVal methodInvoked = {0};
2937 int i;
2938
2939 for (i=0; i<r->m_numCalls; i++) {
2940 if (r->m_methodCalls[i].num == (int)txn) {
2941 methodInvoked = r->m_methodCalls[i].name;
2942 AV_erase(r->m_methodCalls, &r->m_numCalls, i, FALSE);
2943 break;
2944 }
2945 }
2946 if (!methodInvoked.av_val) {
2947 RTMP_Log(RTMP_LOGDEBUG, "%s, received result id %f without matching request",
2948 __FUNCTION__, txn);
2949 goto leave;
2950 }
2951
2952 RTMP_Log(RTMP_LOGDEBUG, "%s, received result for method call <%s>", __FUNCTION__,
2953 methodInvoked.av_val);
2954
2955 if (AVMATCH(&methodInvoked, &av_connect))
2956 {
2957 if (r->Link.token.av_len)
2958 {
2959 AMFObjectProperty p;
2960 if (RTMP_FindFirstMatchingProperty(&obj, &av_secureToken, &p))
2961 {
2962 DecodeTEA(&r->Link.token, &p.p_vu.p_aval);
2963 SendSecureTokenResponse(r, &p.p_vu.p_aval);
2964 }
2965 }
2966 if (r->Link.protocol & RTMP_FEATURE_WRITE)
2967 {
2968 SendReleaseStream(r);
2969 SendFCPublish(r);
2970 }
2971 else
2972 {
2973 RTMP_SendServerBW(r);
2974 RTMP_SendCtrl(r, 3, 0, 300);
2975 }
2976 RTMP_SendCreateStream(r);
2977
2978 if (!(r->Link.protocol & RTMP_FEATURE_WRITE))
2979 {
2980 /* Authenticate on Justin.tv legacy servers before sending FCSubscribe */
2981 if (r->Link.usherToken.av_len)
2982 SendUsherToken(r, &r->Link.usherToken);
2983 /* Send the FCSubscribe if live stream or if subscribepath is set */
2984 if (r->Link.subscribepath.av_len)
2985 SendFCSubscribe(r, &r->Link.subscribepath);
2986 else if (r->Link.lFlags & RTMP_LF_LIVE)
2987 SendFCSubscribe(r, &r->Link.playpath);
2988 }
2989 }
2990 else if (AVMATCH(&methodInvoked, &av_createStream))
2991 {
2992 r->m_stream_id = (int)AMFProp_GetNumber(AMF_GetProp(&obj, NULL, 3));
2993
2994 if (r->Link.protocol & RTMP_FEATURE_WRITE)
2995 {
2996 SendPublish(r);
2997 }
2998 else
2999 {
3000 if (r->Link.lFlags & RTMP_LF_PLST)
3001 SendPlaylist(r);
3002 SendPlay(r);
3003 RTMP_SendCtrl(r, 3, r->m_stream_id, r->m_nBufferMS);
3004 }
3005 }
3006 else if (AVMATCH(&methodInvoked, &av_play) ||
3007 AVMATCH(&methodInvoked, &av_publish))
3008 {
3009 r->m_bPlaying = TRUE;
3010 }
3011 free(methodInvoked.av_val);
3012 }
3013 else if (AVMATCH(&method, &av_onBWDone))
3014 {
3015 if (!r->m_nBWCheckCounter)
3016 SendCheckBW(r);
3017 }
3018 else if (AVMATCH(&method, &av_onFCSubscribe))
3019 {
3020 /* SendOnFCSubscribe(); */
3021 }
3022 else if (AVMATCH(&method, &av_onFCUnsubscribe))
3023 {
3024 RTMP_Close(r);
3025 ret = 1;
3026 }
3027 else if (AVMATCH(&method, &av_ping))
3028 {
3029 SendPong(r, txn);
3030 }
3031 else if (AVMATCH(&method, &av__onbwcheck))
3032 {
3033 SendCheckBWResult(r, txn);
3034 }
3035 else if (AVMATCH(&method, &av__onbwdone))
3036 {
3037 int i;
3038 for (i = 0; i < r->m_numCalls; i++)
3039 if (AVMATCH(&r->m_methodCalls[i].name, &av__checkbw))
3040 {
3041 AV_erase(r->m_methodCalls, &r->m_numCalls, i, TRUE);
3042 break;
3043 }
3044 }
3045 else if (AVMATCH(&method, &av__error))
3046 {
3047 #ifdef CRYPTO
3048 AVal methodInvoked = {0};
3049 int i;
3050
3051 if (r->Link.protocol & RTMP_FEATURE_WRITE)
3052 {
3053 for (i=0; i<r->m_numCalls; i++)
3054 {
3055 if (r->m_methodCalls[i].num == txn)
3056 {
3057 methodInvoked = r->m_methodCalls[i].name;
3058 AV_erase(r->m_methodCalls, &r->m_numCalls, i, FALSE);
3059 break;
3060 }
3061 }
3062 if (!methodInvoked.av_val)
3063 {
3064 RTMP_Log(RTMP_LOGDEBUG, "%s, received result id %f without matching request",
3065 __FUNCTION__, txn);
3066 goto leave;
3067 }
3068
3069 RTMP_Log(RTMP_LOGDEBUG, "%s, received error for method call <%s>", __FUNCTION__,
3070 methodInvoked.av_val);
3071
3072 if (AVMATCH(&methodInvoked, &av_connect))
3073 {
3074 AMFObject obj2;
3075 AVal code, level, description;
3076 AMFProp_GetObject(AMF_GetProp(&obj, NULL, 3), &obj2);
3077 AMFProp_GetString(AMF_GetProp(&obj2, &av_code, -1), &code);
3078 AMFProp_GetString(AMF_GetProp(&obj2, &av_level, -1), &level);
3079 AMFProp_GetString(AMF_GetProp(&obj2, &av_description, -1), &description);
3080 RTMP_Log(RTMP_LOGDEBUG, "%s, error description: %s", __FUNCTION__, description.av_val);
3081 /* if PublisherAuth returns 1, then reconnect */
3082 if (PublisherAuth(r, &description) == 1)
3083 {
3084 CloseInternal(r, 1);
3085 if (!RTMP_Connect(r, NULL) || !RTMP_ConnectStream(r, 0))
3086 goto leave;
3087 }
3088 }
3089 }
3090 else
3091 {
3092 RTMP_Log(RTMP_LOGERROR, "rtmp server sent error");
3093 }
3094 free(methodInvoked.av_val);
3095 #else
3096 RTMP_Log(RTMP_LOGERROR, "rtmp server sent error");
3097 #endif
3098 }
3099 else if (AVMATCH(&method, &av_close))
3100 {
3101 RTMP_Log(RTMP_LOGERROR, "rtmp server requested close");
3102 RTMP_Close(r);
3103 }
3104 else if (AVMATCH(&method, &av_onStatus))
3105 {
3106 AMFObject obj2;
3107 AVal code, level;
3108 AMFProp_GetObject(AMF_GetProp(&obj, NULL, 3), &obj2);
3109 AMFProp_GetString(AMF_GetProp(&obj2, &av_code, -1), &code);
3110 AMFProp_GetString(AMF_GetProp(&obj2, &av_level, -1), &level);
3111
3112 RTMP_Log(RTMP_LOGDEBUG, "%s, onStatus: %s", __FUNCTION__, code.av_val);
3113 if (AVMATCH(&code, &av_NetStream_Failed)
3114 || AVMATCH(&code, &av_NetStream_Play_Failed)
3115 || AVMATCH(&code, &av_NetStream_Play_StreamNotFound)
3116 || AVMATCH(&code, &av_NetConnection_Connect_InvalidApp))
3117 {
3118 r->m_stream_id = -1;
3119 RTMP_Close(r);
3120 RTMP_Log(RTMP_LOGERROR, "Closing connection: %s", code.av_val);
3121 }
3122
3123 else if (AVMATCH(&code, &av_NetStream_Play_Start)
3124 || AVMATCH(&code, &av_NetStream_Play_PublishNotify))
3125 {
3126 int i;
3127 r->m_bPlaying = TRUE;
3128 for (i = 0; i < r->m_numCalls; i++)
3129 {
3130 if (AVMATCH(&r->m_methodCalls[i].name, &av_play))
3131 {
3132 AV_erase(r->m_methodCalls, &r->m_numCalls, i, TRUE);
3133 break;
3134 }
3135 }
3136 }
3137
3138 else if (AVMATCH(&code, &av_NetStream_Publish_Start))
3139 {
3140 int i;
3141 r->m_bPlaying = TRUE;
3142 for (i = 0; i < r->m_numCalls; i++)
3143 {
3144 if (AVMATCH(&r->m_methodCalls[i].name, &av_publish))
3145 {
3146 AV_erase(r->m_methodCalls, &r->m_numCalls, i, TRUE);
3147 break;
3148 }
3149 }
3150 }
3151
3152 /* Return 1 if this is a Play.Complete or Play.Stop */
3153 else if (AVMATCH(&code, &av_NetStream_Play_Complete)
3154 || AVMATCH(&code, &av_NetStream_Play_Stop)
3155 || AVMATCH(&code, &av_NetStream_Play_UnpublishNotify))
3156 {
3157 RTMP_Close(r);
3158 ret = 1;
3159 }
3160
3161 else if (AVMATCH(&code, &av_NetStream_Seek_Notify))
3162 {
3163 r->m_read.flags &= ~RTMP_READ_SEEKING;
3164 }
3165
3166 else if (AVMATCH(&code, &av_NetStream_Pause_Notify))
3167 {
3168 if (r->m_pausing == 1 || r->m_pausing == 2)
3169 {
3170 RTMP_SendPause(r, FALSE, r->m_pauseStamp);
3171 r->m_pausing = 3;
3172 }
3173 }
3174 }
3175 else if (AVMATCH(&method, &av_playlist_ready))
3176 {
3177 int i;
3178 for (i = 0; i < r->m_numCalls; i++)
3179 {
3180 if (AVMATCH(&r->m_methodCalls[i].name, &av_set_playlist))
3181 {
3182 AV_erase(r->m_methodCalls, &r->m_numCalls, i, TRUE);
3183 break;
3184 }
3185 }
3186 }
3187 else
3188 {
3189
3190 }
3191 leave:
3192 AMF_Reset(&obj);
3193 return ret;
3194 }
3195
3196 int
3197 RTMP_FindFirstMatchingProperty(AMFObject *obj, const AVal *name,
3198 AMFObjectProperty * p)
3199 {
3200 int n;
3201 /* this is a small object search to locate the "duration" property */
3202 for (n = 0; n < obj->o_num; n++)
3203 {
3204 AMFObjectProperty *prop = AMF_GetProp(obj, NULL, n);
3205
3206 if (AVMATCH(&prop->p_name, name))
3207 {
3208 memcpy(p, prop, sizeof(*prop));
3209 return TRUE;
3210 }
3211
3212 if (prop->p_type == AMF_OBJECT || prop->p_type == AMF_ECMA_ARRAY)
3213 {
3214 if (RTMP_FindFirstMatchingProperty(&prop->p_vu.p_object, name, p))
3215 return TRUE;
3216 }
3217 }
3218 return FALSE;
3219 }
3220
3221 /* Like above, but only check if name is a prefix of property */
3222 int
3223 RTMP_FindPrefixProperty(AMFObject *obj, const AVal *name,
3224 AMFObjectProperty * p)
3225 {
3226 int n;
3227 for (n = 0; n < obj->o_num; n++)
3228 {
3229 AMFObjectProperty *prop = AMF_GetProp(obj, NULL, n);
3230
3231 if (prop->p_name.av_len > name->av_len &&
3232 !memcmp(prop->p_name.av_val, name->av_val, name->av_len))
3233 {
3234 memcpy(p, prop, sizeof(*prop));
3235 return TRUE;
3236 }
3237
3238 if (prop->p_type == AMF_OBJECT)
3239 {
3240 if (RTMP_FindPrefixProperty(&prop->p_vu.p_object, name, p))
3241 return TRUE;
3242 }
3243 }
3244 return FALSE;
3245 }
3246
3247 static int
3248 DumpMetaData(AMFObject *obj)
3249 {
3250 AMFObjectProperty *prop;
3251 int n, len;
3252 for (n = 0; n < obj->o_num; n++)
3253 {
3254 char str[256] = "";
3255 prop = AMF_GetProp(obj, NULL, n);
3256 switch (prop->p_type)
3257 {
3258 case AMF_OBJECT:
3259 case AMF_ECMA_ARRAY:
3260 case AMF_STRICT_ARRAY:
3261 if (prop->p_name.av_len)
3262 RTMP_Log(RTMP_LOGINFO, "%.*s:", prop->p_name.av_len, prop->p_name.av_val);
3263 DumpMetaData(&prop->p_vu.p_object);
3264 break;
3265 case AMF_NUMBER:
3266 snprintf(str, 255, "%.2f", prop->p_vu.p_number);
3267 break;
3268 case AMF_BOOLEAN:
3269 snprintf(str, 255, "%s",
3270 prop->p_vu.p_number != 0. ? "TRUE" : "FALSE");
3271 break;
3272 case AMF_STRING:
3273 len = snprintf(str, 255, "%.*s", prop->p_vu.p_aval.av_len,
3274 prop->p_vu.p_aval.av_val);
3275 if (len >= 1 && str[len-1] == '\n')
3276 str[len-1] = '\0';
3277 break;
3278 case AMF_DATE:
3279 snprintf(str, 255, "timestamp:%.2f", prop->p_vu.p_number);
3280 break;
3281 default:
3282 snprintf(str, 255, "INVALID TYPE 0x%02x",
3283 (unsigned char)prop->p_type);
3284 }
3285 if (str[0] && prop->p_name.av_len)
3286 {
3287 RTMP_Log(RTMP_LOGINFO, " %-22.*s%s", prop->p_name.av_len,
3288 prop->p_name.av_val, str);
3289 }
3290 }
3291 return FALSE;
3292 }
3293
3294 SAVC(onMetaData);
3295 SAVC(duration);
3296 SAVC(video);
3297 SAVC(audio);
3298
3299 static int
3300 HandleMetadata(RTMP *r, char *body, unsigned int len)
3301 {
3302 /* allright we get some info here, so parse it and print it */
3303 /* also keep duration or filesize to make a nice progress bar */
3304
3305 AMFObject obj;
3306 AVal metastring;
3307 int ret = FALSE;
3308
3309 int nRes = AMF_Decode(&obj, body, len, FALSE);
3310 if (nRes < 0)
3311 {
3312 RTMP_Log(RTMP_LOGERROR, "%s, error decoding meta data packet", __FUNCTION__);
3313 return FALSE;
3314 }
3315
3316 AMF_Dump(&obj);
3317 AMFProp_GetString(AMF_GetProp(&obj, NULL, 0), &metastring);
3318
3319 if (AVMATCH(&metastring, &av_onMetaData))
3320 {
3321 AMFObjectProperty prop;
3322 /* Show metadata */
3323 RTMP_Log(RTMP_LOGINFO, "Metadata:");
3324 DumpMetaData(&obj);
3325 if (RTMP_FindFirstMatchingProperty(&obj, &av_duration, &prop))
3326 {
3327 r->m_fDuration = prop.p_vu.p_number;
3328 /*RTMP_Log(RTMP_LOGDEBUG, "Set duration: %.2f", m_fDuration); */
3329 }
3330 /* Search for audio or video tags */
3331 if (RTMP_FindPrefixProperty(&obj, &av_video, &prop))
3332 r->m_read.dataType |= 1;
3333 if (RTMP_FindPrefixProperty(&obj, &av_audio, &prop))
3334 r->m_read.dataType |= 4;
3335 ret = TRUE;
3336 }
3337 AMF_Reset(&obj);
3338 return ret;
3339 }
3340
3341 static void
3342 HandleChangeChunkSize(RTMP *r, const RTMPPacket *packet)
3343 {
3344 if (packet->m_nBodySize >= 4)
3345 {
3346 r->m_inChunkSize = AMF_DecodeInt32(packet->m_body);
3347 RTMP_Log(RTMP_LOGDEBUG, "%s, received: chunk size change to %d", __FUNCTION__,
3348 r->m_inChunkSize);
3349 }
3350 }
3351
3352 static void
3353 HandleAudio(RTMP *r, const RTMPPacket *packet)
3354 {
3355 }
3356
3357 static void
3358 HandleVideo(RTMP *r, const RTMPPacket *packet)
3359 {
3360 }
3361
3362 static void
3363 HandleCtrl(RTMP *r, const RTMPPacket *packet)
3364 {
3365 short nType = -1;
3366 unsigned int tmp;
3367 if (packet->m_body && packet->m_nBodySize >= 2)
3368 nType = AMF_DecodeInt16(packet->m_body);
3369 RTMP_Log(RTMP_LOGDEBUG, "%s, received ctrl. type: %d, len: %d", __FUNCTION__, nType,
3370 packet->m_nBodySize);
3371 /*RTMP_LogHex(packet.m_body, packet.m_nBodySize); */
3372
3373 if (packet->m_nBodySize >= 6)
3374 {
3375 switch (nType)
3376 {
3377 case 0:
3378 tmp = AMF_DecodeInt32(packet->m_body + 2);
3379 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream Begin %d", __FUNCTION__, tmp);
3380 break;
3381
3382 case 1:
3383 tmp = AMF_DecodeInt32(packet->m_body + 2);
3384 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream EOF %d", __FUNCTION__, tmp);
3385 if (r->m_pausing == 1)
3386 r->m_pausing = 2;
3387 break;
3388
3389 case 2:
3390 tmp = AMF_DecodeInt32(packet->m_body + 2);
3391 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream Dry %d", __FUNCTION__, tmp);
3392 break;
3393
3394 case 4:
3395 tmp = AMF_DecodeInt32(packet->m_body + 2);
3396 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream IsRecorded %d", __FUNCTION__, tmp);
3397 break;
3398
3399 case 6: /* server ping. reply with pong. */
3400 tmp = AMF_DecodeInt32(packet->m_body + 2);
3401 RTMP_Log(RTMP_LOGDEBUG, "%s, Ping %d", __FUNCTION__, tmp);
3402 RTMP_SendCtrl(r, 0x07, tmp, 0);
3403 break;
3404
3405 /* FMS 3.5 servers send the following two controls to let the client
3406 * know when the server has sent a complete buffer. I.e., when the
3407 * server has sent an amount of data equal to m_nBufferMS in duration.
3408 * The server meters its output so that data arrives at the client
3409 * in realtime and no faster.
3410 *
3411 * The rtmpdump program tries to set m_nBufferMS as large as
3412 * possible, to force the server to send data as fast as possible.
3413 * In practice, the server appears to cap this at about 1 hour's
3414 * worth of data. After the server has sent a complete buffer, and
3415 * sends this BufferEmpty message, it will wait until the play
3416 * duration of that buffer has passed before sending a new buffer.
3417 * The BufferReady message will be sent when the new buffer starts.
3418 * (There is no BufferReady message for the very first buffer;
3419 * presumably the Stream Begin message is sufficient for that
3420 * purpose.)
3421 *
3422 * If the network speed is much faster than the data bitrate, then
3423 * there may be long delays between the end of one buffer and the
3424 * start of the next.
3425 *
3426 * Since usually the network allows data to be sent at
3427 * faster than realtime, and rtmpdump wants to download the data
3428 * as fast as possible, we use this RTMP_LF_BUFX hack: when we
3429 * get the BufferEmpty message, we send a Pause followed by an
3430 * Unpause. This causes the server to send the next buffer immediately
3431 * instead of waiting for the full duration to elapse. (That's
3432 * also the purpose of the ToggleStream function, which rtmpdump
3433 * calls if we get a read timeout.)
3434 *
3435 * Media player apps don't need this hack since they are just
3436 * going to play the data in realtime anyway. It also doesn't work
3437 * for live streams since they obviously can only be sent in
3438 * realtime. And it's all moot if the network speed is actually
3439 * slower than the media bitrate.
3440 */
3441 case 31:
3442 tmp = AMF_DecodeInt32(packet->m_body + 2);
3443 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream BufferEmpty %d", __FUNCTION__, tmp);
3444 if (!(r->Link.lFlags & RTMP_LF_BUFX))
3445 break;
3446 if (!r->m_pausing)
3447 {
3448 r->m_pauseStamp = r->m_mediaChannel < r->m_channelsAllocatedIn ?
3449 r->m_channelTimestamp[r->m_mediaChannel] : 0;
3450 RTMP_SendPause(r, TRUE, r->m_pauseStamp);
3451 r->m_pausing = 1;
3452 }
3453 else if (r->m_pausing == 2)
3454 {
3455 RTMP_SendPause(r, FALSE, r->m_pauseStamp);
3456 r->m_pausing = 3;
3457 }
3458 break;
3459
3460 case 32:
3461 tmp = AMF_DecodeInt32(packet->m_body + 2);
3462 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream BufferReady %d", __FUNCTION__, tmp);
3463 break;
3464
3465 default:
3466 tmp = AMF_DecodeInt32(packet->m_body + 2);
3467 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream xx %d", __FUNCTION__, tmp);
3468 break;
3469 }
3470
3471 }
3472
3473 if (nType == 0x1A)
3474 {
3475 RTMP_Log(RTMP_LOGDEBUG, "%s, SWFVerification ping received: ", __FUNCTION__);
3476 if (packet->m_nBodySize > 2 && packet->m_body[2] > 0x01)
3477 {
3478 RTMP_Log(RTMP_LOGERROR,
3479 "%s: SWFVerification Type %d request not supported! Patches welcome...",
3480 __FUNCTION__, packet->m_body[2]);
3481 }
3482 #ifdef CRYPTO
3483 /*RTMP_LogHex(packet.m_body, packet.m_nBodySize); */
3484
3485 /* respond with HMAC SHA256 of decompressed SWF, key is the 30byte player key, also the last 30 bytes of the server handshake are applied */
3486 else if (r->Link.SWFSize)
3487 {
3488 RTMP_SendCtrl(r, 0x1B, 0, 0);
3489 }
3490 else
3491 {
3492 RTMP_Log(RTMP_LOGERROR,
3493 "%s: Ignoring SWFVerification request, use --swfVfy!",
3494 __FUNCTION__);
3495 }
3496 #else
3497 RTMP_Log(RTMP_LOGERROR,
3498 "%s: Ignoring SWFVerification request, no CRYPTO support!",
3499 __FUNCTION__);
3500 #endif
3501 }
3502 }
3503
3504 static void
3505 HandleServerBW(RTMP *r, const RTMPPacket *packet)
3506 {
3507 r->m_nServerBW = AMF_DecodeInt32(packet->m_body);
3508 RTMP_Log(RTMP_LOGDEBUG, "%s: server BW = %d", __FUNCTION__, r->m_nServerBW);
3509 }
3510
3511 static void
3512 HandleClientBW(RTMP *r, const RTMPPacket *packet)
3513 {
3514 r->m_nClientBW = AMF_DecodeInt32(packet->m_body);
3515 if (packet->m_nBodySize > 4)
3516 r->m_nClientBW2 = packet->m_body[4];
3517 else
3518 r->m_nClientBW2 = -1;
3519 RTMP_Log(RTMP_LOGDEBUG, "%s: client BW = %d %d", __FUNCTION__, r->m_nClientBW,
3520 r->m_nClientBW2);
3521 }
3522
3523 static int
3524 DecodeInt32LE(const char *data)
3525 {
3526 unsigned char *c = (unsigned char *)data;
3527 unsigned int val;
3528
3529 val = (c[3] << 24) | (c[2] << 16) | (c[1] << 8) | c[0];
3530 return val;
3531 }
3532
3533 static int
3534 EncodeInt32LE(char *output, int nVal)
3535 {
3536 output[0] = nVal;
3537 nVal >>= 8;
3538 output[1] = nVal;
3539 nVal >>= 8;
3540 output[2] = nVal;
3541 nVal >>= 8;
3542 output[3] = nVal;
3543 return 4;
3544 }
3545
3546 int
3547 RTMP_ReadPacket(RTMP *r, RTMPPacket *packet)
3548 {
3549 uint8_t hbuf[RTMP_MAX_HEADER_SIZE] = { 0 };
3550 char *header = (char *)hbuf;
3551 int nSize, hSize, nToRead, nChunk;
3552 int didAlloc = FALSE;
3553 int extendedTimestamp;
3554
3555 RTMP_Log(RTMP_LOGDEBUG2, "%s: fd=%d", __FUNCTION__, r->m_sb.sb_socket);
3556
3557 if (ReadN(r, (char *)hbuf, 1) == 0)
3558 {
3559 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet header", __FUNCTION__);
3560 return FALSE;
3561 }
3562
3563 packet->m_headerType = (hbuf[0] & 0xc0) >> 6;
3564 packet->m_nChannel = (hbuf[0] & 0x3f);
3565 header++;
3566 if (packet->m_nChannel == 0)
3567 {
3568 if (ReadN(r, (char *)&hbuf[1], 1) != 1)
3569 {
3570 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet header 2nd byte",
3571 __FUNCTION__);
3572 return FALSE;
3573 }
3574 packet->m_nChannel = hbuf[1];
3575 packet->m_nChannel += 64;
3576 header++;
3577 }
3578 else if (packet->m_nChannel == 1)
3579 {
3580 int tmp;
3581 if (ReadN(r, (char *)&hbuf[1], 2) != 2)
3582 {
3583 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet header 3nd byte",
3584 __FUNCTION__);
3585 return FALSE;
3586 }
3587 tmp = (hbuf[2] << 8) + hbuf[1];
3588 packet->m_nChannel = tmp + 64;
3589 RTMP_Log(RTMP_LOGDEBUG, "%s, m_nChannel: %0x", __FUNCTION__, packet->m_nChannel);
3590 header += 2;
3591 }
3592
3593 nSize = packetSize[packet->m_headerType];
3594
3595 if (packet->m_nChannel >= r->m_channelsAllocatedIn)
3596 {
3597 int n = packet->m_nChannel + 10;
3598 int *timestamp = realloc(r->m_channelTimestamp, sizeof(int) * n);
3599 RTMPPacket **packets = realloc(r->m_vecChannelsIn, sizeof(RTMPPacket*) * n);
3600 if (!timestamp)
3601 free(r->m_channelTimestamp);
3602 if (!packets)
3603 free(r->m_vecChannelsIn);
3604 r->m_channelTimestamp = timestamp;
3605 r->m_vecChannelsIn = packets;
3606 if (!timestamp || !packets) {
3607 r->m_channelsAllocatedIn = 0;
3608 return FALSE;
3609 }
3610 memset(r->m_channelTimestamp + r->m_channelsAllocatedIn, 0, sizeof(int) * (n - r->m_channelsAllocatedIn));
3611 memset(r->m_vecChannelsIn + r->m_channelsAllocatedIn, 0, sizeof(RTMPPacket*) * (n - r->m_channelsAllocatedIn));
3612 r->m_channelsAllocatedIn = n;
3613 }
3614
3615 if (nSize == RTMP_LARGE_HEADER_SIZE) /* if we get a full header the timestamp is absolute */
3616 packet->m_hasAbsTimestamp = TRUE;
3617
3618 else if (nSize < RTMP_LARGE_HEADER_SIZE)
3619 { /* using values from the last message of this channel */
3620 if (r->m_vecChannelsIn[packet->m_nChannel])
3621 memcpy(packet, r->m_vecChannelsIn[packet->m_nChannel],
3622 sizeof(RTMPPacket));
3623 }
3624
3625 nSize--;
3626
3627 if (nSize > 0 && ReadN(r, header, nSize) != nSize)
3628 {
3629 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet header. type: %x",
3630 __FUNCTION__, (unsigned int)hbuf[0]);
3631 return FALSE;
3632 }
3633
3634 hSize = nSize + (header - (char *)hbuf);
3635
3636 if (nSize >= 3)
3637 {
3638 packet->m_nTimeStamp = AMF_DecodeInt24(header);
3639
3640 /*RTMP_Log(RTMP_LOGDEBUG, "%s, reading RTMP packet chunk on channel %x, headersz %i, timestamp %i, abs timestamp %i", __FUNCTION__, packet.m_nChannel, nSize, packet.m_nTimeStamp, packet.m_hasAbsTimestamp); */
3641
3642 if (nSize >= 6)
3643 {
3644 packet->m_nBodySize = AMF_DecodeInt24(header + 3);
3645 packet->m_nBytesRead = 0;
3646 RTMPPacket_Free(packet);
3647
3648 if (nSize > 6)
3649 {
3650 packet->m_packetType = header[6];
3651
3652 if (nSize == 11)
3653 packet->m_nInfoField2 = DecodeInt32LE(header + 7);
3654 }
3655 }
3656 }
3657
3658 extendedTimestamp = packet->m_nTimeStamp == 0xffffff;
3659 if (extendedTimestamp)
3660 {
3661 if (ReadN(r, header + nSize, 4) != 4)
3662 {
3663 RTMP_Log(RTMP_LOGERROR, "%s, failed to read extended timestamp",
3664 __FUNCTION__);
3665 return FALSE;
3666 }
3667 packet->m_nTimeStamp = AMF_DecodeInt32(header + nSize);
3668 hSize += 4;
3669 }
3670
3671 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)hbuf, hSize);
3672
3673 if (packet->m_nBodySize > 0 && packet->m_body == NULL)
3674 {
3675 if (!RTMPPacket_Alloc(packet, packet->m_nBodySize))
3676 {
3677 RTMP_Log(RTMP_LOGDEBUG, "%s, failed to allocate packet", __FUNCTION__);
3678 return FALSE;
3679 }
3680 didAlloc = TRUE;
3681 packet->m_headerType = (hbuf[0] & 0xc0) >> 6;
3682 }
3683
3684 nToRead = packet->m_nBodySize - packet->m_nBytesRead;
3685 nChunk = r->m_inChunkSize;
3686 if (nToRead < nChunk)
3687 nChunk = nToRead;
3688
3689 /* Does the caller want the raw chunk? */
3690 if (packet->m_chunk)
3691 {
3692 packet->m_chunk->c_headerSize = hSize;
3693 memcpy(packet->m_chunk->c_header, hbuf, hSize);
3694 packet->m_chunk->c_chunk = packet->m_body + packet->m_nBytesRead;
3695 packet->m_chunk->c_chunkSize = nChunk;
3696 }
3697
3698 if (ReadN(r, packet->m_body + packet->m_nBytesRead, nChunk) != nChunk)
3699 {
3700 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet body. len: %u",
3701 __FUNCTION__, packet->m_nBodySize);
3702 return FALSE;
3703 }
3704
3705 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)packet->m_body + packet->m_nBytesRead, nChunk);
3706
3707 packet->m_nBytesRead += nChunk;
3708
3709 /* keep the packet as ref for other packets on this channel */
3710 if (!r->m_vecChannelsIn[packet->m_nChannel])
3711 r->m_vecChannelsIn[packet->m_nChannel] = malloc(sizeof(RTMPPacket));
3712 memcpy(r->m_vecChannelsIn[packet->m_nChannel], packet, sizeof(RTMPPacket));
3713 if (extendedTimestamp)
3714 {
3715 r->m_vecChannelsIn[packet->m_nChannel]->m_nTimeStamp = 0xffffff;
3716 }
3717
3718 if (RTMPPacket_IsReady(packet))
3719 {
3720 /* make packet's timestamp absolute */
3721 if (!packet->m_hasAbsTimestamp)
3722 packet->m_nTimeStamp += r->m_channelTimestamp[packet->m_nChannel]; /* timestamps seem to be always relative!! */
3723
3724 r->m_channelTimestamp[packet->m_nChannel] = packet->m_nTimeStamp;
3725
3726 /* reset the data from the stored packet. we keep the header since we may use it later if a new packet for this channel */
3727 /* arrives and requests to re-use some info (small packet header) */
3728 r->m_vecChannelsIn[packet->m_nChannel]->m_body = NULL;
3729 r->m_vecChannelsIn[packet->m_nChannel]->m_nBytesRead = 0;
3730 r->m_vecChannelsIn[packet->m_nChannel]->m_hasAbsTimestamp = FALSE; /* can only be false if we reuse header */
3731 }
3732 else
3733 {
3734 packet->m_body = NULL; /* so it won't be erased on free */
3735 }
3736
3737 return TRUE;
3738 }
3739
3740 #ifndef CRYPTO
3741 static int
3742 HandShake(RTMP *r, int FP9HandShake)
3743 {
3744 int i;
3745 uint32_t uptime, suptime;
3746 int bMatch;
3747 char type;
3748 char clientbuf[RTMP_SIG_SIZE + 1], *clientsig = clientbuf + 1;
3749 char serversig[RTMP_SIG_SIZE];
3750
3751 clientbuf[0] = 0x03; /* not encrypted */
3752
3753 uptime = htonl(RTMP_GetTime());
3754 memcpy(clientsig, &uptime, 4);
3755
3756 memset(&clientsig[4], 0, 4);
3757
3758 #ifdef _DEBUG
3759 for (i = 8; i < RTMP_SIG_SIZE; i++)
3760 clientsig[i] = 0xff;
3761 #else
3762 for (i = 8; i < RTMP_SIG_SIZE; i++)
3763 clientsig[i] = (char)(rand() % 256);
3764 #endif
3765
3766 if (!WriteN(r, clientbuf, RTMP_SIG_SIZE + 1))
3767 return FALSE;
3768
3769 if (ReadN(r, &type, 1) != 1) /* 0x03 or 0x06 */
3770 return FALSE;
3771
3772 RTMP_Log(RTMP_LOGDEBUG, "%s: Type Answer : %02X", __FUNCTION__, type);
3773
3774 if (type != clientbuf[0])
3775 RTMP_Log(RTMP_LOGWARNING, "%s: Type mismatch: client sent %d, server answered %d",
3776 __FUNCTION__, clientbuf[0], type);
3777
3778 if (ReadN(r, serversig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
3779 return FALSE;
3780
3781 /* decode server response */
3782
3783 memcpy(&suptime, serversig, 4);
3784 suptime = ntohl(suptime);
3785
3786 RTMP_Log(RTMP_LOGDEBUG, "%s: Server Uptime : %d", __FUNCTION__, suptime);
3787 RTMP_Log(RTMP_LOGDEBUG, "%s: FMS Version : %d.%d.%d.%d", __FUNCTION__,
3788 serversig[4], serversig[5], serversig[6], serversig[7]);
3789
3790 /* 2nd part of handshake */
3791 if (!WriteN(r, serversig, RTMP_SIG_SIZE))
3792 return FALSE;
3793
3794 if (ReadN(r, serversig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
3795 return FALSE;
3796
3797 bMatch = (memcmp(serversig, clientsig, RTMP_SIG_SIZE) == 0);
3798 if (!bMatch)
3799 {
3800 RTMP_Log(RTMP_LOGWARNING, "%s, client signature does not match!", __FUNCTION__);
3801 }
3802 return TRUE;
3803 }
3804
3805 static int
3806 SHandShake(RTMP *r)
3807 {
3808 int i;
3809 char serverbuf[RTMP_SIG_SIZE + 1], *serversig = serverbuf + 1;
3810 char clientsig[RTMP_SIG_SIZE];
3811 uint32_t uptime;
3812 int bMatch;
3813
3814 if (ReadN(r, serverbuf, 1) != 1) /* 0x03 or 0x06 */
3815 return FALSE;
3816
3817 RTMP_Log(RTMP_LOGDEBUG, "%s: Type Request : %02X", __FUNCTION__, serverbuf[0]);
3818
3819 if (serverbuf[0] != 3)
3820 {
3821 RTMP_Log(RTMP_LOGERROR, "%s: Type unknown: client sent %02X",
3822 __FUNCTION__, serverbuf[0]);
3823 return FALSE;
3824 }
3825
3826 uptime = htonl(RTMP_GetTime());
3827 memcpy(serversig, &uptime, 4);
3828
3829 memset(&serversig[4], 0, 4);
3830 #ifdef _DEBUG
3831 for (i = 8; i < RTMP_SIG_SIZE; i++)
3832 serversig[i] = 0xff;
3833 #else
3834 for (i = 8; i < RTMP_SIG_SIZE; i++)
3835 serversig[i] = (char)(rand() % 256);
3836 #endif
3837
3838 if (!WriteN(r, serverbuf, RTMP_SIG_SIZE + 1))
3839 return FALSE;
3840
3841 if (ReadN(r, clientsig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
3842 return FALSE;
3843
3844 /* decode client response */
3845
3846 memcpy(&uptime, clientsig, 4);
3847 uptime = ntohl(uptime);
3848
3849 RTMP_Log(RTMP_LOGDEBUG, "%s: Client Uptime : %d", __FUNCTION__, uptime);
3850 RTMP_Log(RTMP_LOGDEBUG, "%s: Player Version: %d.%d.%d.%d", __FUNCTION__,
3851 clientsig[4], clientsig[5], clientsig[6], clientsig[7]);
3852
3853 /* 2nd part of handshake */
3854 if (!WriteN(r, clientsig, RTMP_SIG_SIZE))
3855 return FALSE;
3856
3857 if (ReadN(r, clientsig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
3858 return FALSE;
3859
3860 bMatch = (memcmp(serversig, clientsig, RTMP_SIG_SIZE) == 0);
3861 if (!bMatch)
3862 {
3863 RTMP_Log(RTMP_LOGWARNING, "%s, client signature does not match!", __FUNCTION__);
3864 }
3865 return TRUE;
3866 }
3867 #endif
3868
3869 int
3870 RTMP_SendChunk(RTMP *r, RTMPChunk *chunk)
3871 {
3872 int wrote;
3873 char hbuf[RTMP_MAX_HEADER_SIZE];
3874
3875 RTMP_Log(RTMP_LOGDEBUG2, "%s: fd=%d, size=%d", __FUNCTION__, r->m_sb.sb_socket,
3876 chunk->c_chunkSize);
3877 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)chunk->c_header, chunk->c_headerSize);
3878 if (chunk->c_chunkSize)
3879 {
3880 char *ptr = chunk->c_chunk - chunk->c_headerSize;
3881 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)chunk->c_chunk, chunk->c_chunkSize);
3882 /* save header bytes we're about to overwrite */
3883 memcpy(hbuf, ptr, chunk->c_headerSize);
3884 memcpy(ptr, chunk->c_header, chunk->c_headerSize);
3885 wrote = WriteN(r, ptr, chunk->c_headerSize + chunk->c_chunkSize);
3886 memcpy(ptr, hbuf, chunk->c_headerSize);
3887 }
3888 else
3889 wrote = WriteN(r, chunk->c_header, chunk->c_headerSize);
3890 return wrote;
3891 }
3892
3893 int
3894 RTMP_SendPacket(RTMP *r, RTMPPacket *packet, int queue)
3895 {
3896 const RTMPPacket *prevPacket;
3897 uint32_t last = 0;
3898 int nSize;
3899 int hSize, cSize;
3900 char *header, *hptr, *hend, hbuf[RTMP_MAX_HEADER_SIZE], c;
3901 uint32_t t;
3902 char *buffer, *tbuf = NULL, *toff = NULL;
3903 int nChunkSize;
3904 int tlen;
3905
3906 if (packet->m_nChannel >= r->m_channelsAllocatedOut)
3907 {
3908 int n = packet->m_nChannel + 10;
3909 RTMPPacket **packets = realloc(r->m_vecChannelsOut, sizeof(RTMPPacket*) * n);
3910 if (!packets) {
3911 free(r->m_vecChannelsOut);
3912 r->m_vecChannelsOut = NULL;
3913 r->m_channelsAllocatedOut = 0;
3914 return FALSE;
3915 }
3916 r->m_vecChannelsOut = packets;
3917 memset(r->m_vecChannelsOut + r->m_channelsAllocatedOut, 0, sizeof(RTMPPacket*) * (n - r->m_channelsAllocatedOut));
3918 r->m_channelsAllocatedOut = n;
3919 }
3920
3921 prevPacket = r->m_vecChannelsOut[packet->m_nChannel];
3922 if (prevPacket && packet->m_headerType != RTMP_PACKET_SIZE_LARGE)
3923 {
3924 /* compress a bit by using the prev packet's attributes */
3925 if (prevPacket->m_nBodySize == packet->m_nBodySize
3926 && prevPacket->m_packetType == packet->m_packetType
3927 && packet->m_headerType == RTMP_PACKET_SIZE_MEDIUM)
3928 packet->m_headerType = RTMP_PACKET_SIZE_SMALL;
3929
3930 if (prevPacket->m_nTimeStamp == packet->m_nTimeStamp
3931 && packet->m_headerType == RTMP_PACKET_SIZE_SMALL)
3932 packet->m_headerType = RTMP_PACKET_SIZE_MINIMUM;
3933 last = prevPacket->m_nTimeStamp;
3934 }
3935
3936 if (packet->m_headerType > 3) /* sanity */
3937 {
3938 RTMP_Log(RTMP_LOGERROR, "sanity failed!! trying to send header of type: 0x%02x.",
3939 (unsigned char)packet->m_headerType);
3940 return FALSE;
3941 }
3942
3943 nSize = packetSize[packet->m_headerType];
3944 hSize = nSize; cSize = 0;
3945 t = packet->m_nTimeStamp - last;
3946
3947 if (packet->m_body)
3948 {
3949 header = packet->m_body - nSize;
3950 hend = packet->m_body;
3951 }
3952 else
3953 {
3954 header = hbuf + 6;
3955 hend = hbuf + sizeof(hbuf);
3956 }
3957
3958 if (packet->m_nChannel > 319)
3959 cSize = 2;
3960 else if (packet->m_nChannel > 63)
3961 cSize = 1;
3962 if (cSize)
3963 {
3964 header -= cSize;
3965 hSize += cSize;
3966 }
3967
3968 if (t >= 0xffffff)
3969 {
3970 header -= 4;
3971 hSize += 4;
3972 RTMP_Log(RTMP_LOGWARNING, "Larger timestamp than 24-bit: 0x%x", t);
3973 }
3974
3975 hptr = header;
3976 c = packet->m_headerType << 6;
3977 switch (cSize)
3978 {
3979 case 0:
3980 c |= packet->m_nChannel;
3981 break;
3982 case 1:
3983 break;
3984 case 2:
3985 c |= 1;
3986 break;
3987 }
3988 *hptr++ = c;
3989 if (cSize)
3990 {
3991 int tmp = packet->m_nChannel - 64;
3992 *hptr++ = tmp & 0xff;
3993 if (cSize == 2)
3994 *hptr++ = tmp >> 8;
3995 }
3996
3997 if (nSize > 1)
3998 {
3999 hptr = AMF_EncodeInt24(hptr, hend, t > 0xffffff ? 0xffffff : t);
4000 }
4001
4002 if (nSize > 4)
4003 {
4004 hptr = AMF_EncodeInt24(hptr, hend, packet->m_nBodySize);
4005 *hptr++ = packet->m_packetType;
4006 }
4007
4008 if (nSize > 8)
4009 hptr += EncodeInt32LE(hptr, packet->m_nInfoField2);
4010
4011 if (t >= 0xffffff)
4012 hptr = AMF_EncodeInt32(hptr, hend, t);
4013
4014 nSize = packet->m_nBodySize;
4015 buffer = packet->m_body;
4016 nChunkSize = r->m_outChunkSize;
4017
4018 RTMP_Log(RTMP_LOGDEBUG2, "%s: fd=%d, size=%d", __FUNCTION__, r->m_sb.sb_socket,
4019 nSize);
4020 /* send all chunks in one HTTP request */
4021 if (r->Link.protocol & RTMP_FEATURE_HTTP)
4022 {
4023 int chunks = (nSize+nChunkSize-1) / nChunkSize;
4024 if (chunks > 1)
4025 {
4026 tlen = chunks * (cSize + 1) + nSize + hSize;
4027 tbuf = malloc(tlen);
4028 if (!tbuf)
4029 return FALSE;
4030 toff = tbuf;
4031 }
4032 }
4033 while (nSize + hSize)
4034 {
4035 int wrote;
4036
4037 if (nSize < nChunkSize)
4038 nChunkSize = nSize;
4039
4040 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)header, hSize);
4041 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)buffer, nChunkSize);
4042 if (tbuf)
4043 {
4044 memcpy(toff, header, nChunkSize + hSize);
4045 toff += nChunkSize + hSize;
4046 }
4047 else
4048 {
4049 wrote = WriteN(r, header, nChunkSize + hSize);
4050 if (!wrote)
4051 return FALSE;
4052 }
4053 nSize -= nChunkSize;
4054 buffer += nChunkSize;
4055 hSize = 0;
4056
4057 if (nSize > 0)
4058 {
4059 header = buffer - 1;
4060 hSize = 1;
4061 if (cSize)
4062 {
4063 header -= cSize;
4064 hSize += cSize;
4065 }
4066 if (t >= 0xffffff)
4067 {
4068 header -= 4;
4069 hSize += 4;
4070 }
4071 *header = (0xc0 | c);
4072 if (cSize)
4073 {
4074 int tmp = packet->m_nChannel - 64;
4075 header[1] = tmp & 0xff;
4076 if (cSize == 2)
4077 header[2] = tmp >> 8;
4078 }
4079 if (t >= 0xffffff)
4080 {
4081 char* extendedTimestamp = header + 1 + cSize;
4082 AMF_EncodeInt32(extendedTimestamp, extendedTimestamp + 4, t);
4083 }
4084 }
4085 }
4086 if (tbuf)
4087 {
4088 int wrote = WriteN(r, tbuf, toff-tbuf);
4089 free(tbuf);
4090 tbuf = NULL;
4091 if (!wrote)
4092 return FALSE;
4093 }
4094
4095 /* we invoked a remote method */
4096 if (packet->m_packetType == RTMP_PACKET_TYPE_INVOKE)
4097 {
4098 AVal method;
4099 char *ptr;
4100 ptr = packet->m_body + 1;
4101 AMF_DecodeString(ptr, &method);
4102 RTMP_Log(RTMP_LOGDEBUG, "Invoking %s", method.av_val);
4103 /* keep it in call queue till result arrives */
4104 if (queue) {
4105 int txn;
4106 ptr += 3 + method.av_len;
4107 txn = (int)AMF_DecodeNumber(ptr);
4108 AV_queue(&r->m_methodCalls, &r->m_numCalls, &method, txn);
4109 }
4110 }
4111
4112 if (!r->m_vecChannelsOut[packet->m_nChannel])
4113 r->m_vecChannelsOut[packet->m_nChannel] = malloc(sizeof(RTMPPacket));
4114 memcpy(r->m_vecChannelsOut[packet->m_nChannel], packet, sizeof(RTMPPacket));
4115 return TRUE;
4116 }
4117
4118 int
4119 RTMP_Serve(RTMP *r)
4120 {
4121 return SHandShake(r);
4122 }
4123
4124 void
4125 RTMP_Close(RTMP *r)
4126 {
4127 CloseInternal(r, 0);
4128 }
4129
4130 static void
4131 CloseInternal(RTMP *r, int reconnect)
4132 {
4133 int i;
4134
4135 if (RTMP_IsConnected(r))
4136 {
4137 if (r->m_stream_id > 0)
4138 {
4139 i = r->m_stream_id;
4140 r->m_stream_id = 0;
4141 if ((r->Link.protocol & RTMP_FEATURE_WRITE))
4142 SendFCUnpublish(r);
4143 SendDeleteStream(r, i);
4144 }
4145 if (r->m_clientID.av_val)
4146 {
4147 HTTP_Post(r, RTMPT_CLOSE, "", 1);
4148 free(r->m_clientID.av_val);
4149 r->m_clientID.av_val = NULL;
4150 r->m_clientID.av_len = 0;
4151 }
4152 RTMPSockBuf_Close(&r->m_sb);
4153 }
4154
4155 r->m_stream_id = -1;
4156 r->m_sb.sb_socket = -1;
4157 r->m_nBWCheckCounter = 0;
4158 r->m_nBytesIn = 0;
4159 r->m_nBytesInSent = 0;
4160
4161 if (r->m_read.flags & RTMP_READ_HEADER) {
4162 free(r->m_read.buf);
4163 r->m_read.buf = NULL;
4164 }
4165 r->m_read.dataType = 0;
4166 r->m_read.flags = 0;
4167 r->m_read.status = 0;
4168 r->m_read.nResumeTS = 0;
4169 r->m_read.nIgnoredFrameCounter = 0;
4170 r->m_read.nIgnoredFlvFrameCounter = 0;
4171
4172 r->m_write.m_nBytesRead = 0;
4173 RTMPPacket_Free(&r->m_write);
4174
4175 for (i = 0; i < r->m_channelsAllocatedIn; i++)
4176 {
4177 if (r->m_vecChannelsIn[i])
4178 {
4179 RTMPPacket_Free(r->m_vecChannelsIn[i]);
4180 free(r->m_vecChannelsIn[i]);
4181 r->m_vecChannelsIn[i] = NULL;
4182 }
4183 }
4184 free(r->m_vecChannelsIn);
4185 r->m_vecChannelsIn = NULL;
4186 free(r->m_channelTimestamp);
4187 r->m_channelTimestamp = NULL;
4188 r->m_channelsAllocatedIn = 0;
4189 for (i = 0; i < r->m_channelsAllocatedOut; i++)
4190 {
4191 if (r->m_vecChannelsOut[i])
4192 {
4193 free(r->m_vecChannelsOut[i]);
4194 r->m_vecChannelsOut[i] = NULL;
4195 }
4196 }
4197 free(r->m_vecChannelsOut);
4198 r->m_vecChannelsOut = NULL;
4199 r->m_channelsAllocatedOut = 0;
4200 AV_clear(r->m_methodCalls, r->m_numCalls);
4201 r->m_methodCalls = NULL;
4202 r->m_numCalls = 0;
4203 r->m_numInvokes = 0;
4204
4205 r->m_bPlaying = FALSE;
4206 r->m_sb.sb_size = 0;
4207
4208 r->m_msgCounter = 0;
4209 r->m_resplen = 0;
4210 r->m_unackd = 0;
4211
4212 if (r->Link.lFlags & RTMP_LF_FTCU && !reconnect)
4213 {
4214 free(r->Link.tcUrl.av_val);
4215 r->Link.tcUrl.av_val = NULL;
4216 r->Link.lFlags ^= RTMP_LF_FTCU;
4217 }
4218 if (r->Link.lFlags & RTMP_LF_FAPU && !reconnect)
4219 {
4220 free(r->Link.app.av_val);
4221 r->Link.app.av_val = NULL;
4222 r->Link.lFlags ^= RTMP_LF_FAPU;
4223 }
4224
4225 if (!reconnect)
4226 {
4227 free(r->Link.playpath0.av_val);
4228 r->Link.playpath0.av_val = NULL;
4229 }
4230 #ifdef CRYPTO
4231 if (r->Link.dh)
4232 {
4233 MDH_free(r->Link.dh);
4234 r->Link.dh = NULL;
4235 }
4236 if (r->Link.rc4keyIn)
4237 {
4238 RC4_free(r->Link.rc4keyIn);
4239 r->Link.rc4keyIn = NULL;
4240 }
4241 if (r->Link.rc4keyOut)
4242 {
4243 RC4_free(r->Link.rc4keyOut);
4244 r->Link.rc4keyOut = NULL;
4245 }
4246 #endif
4247 }
4248
4249 int
4250 RTMPSockBuf_Fill(RTMPSockBuf *sb)
4251 {
4252 int nBytes;
4253
4254 if (!sb->sb_size)
4255 sb->sb_start = sb->sb_buf;
4256
4257 while (1)
4258 {
4259 nBytes = sizeof(sb->sb_buf) - 1 - sb->sb_size - (sb->sb_start - sb->sb_buf);
4260 #if defined(CRYPTO) && !defined(NO_SSL)
4261 if (sb->sb_ssl)
4262 {
4263 nBytes = TLS_read(sb->sb_ssl, sb->sb_start + sb->sb_size, nBytes);
4264 }
4265 else
4266 #endif
4267 {
4268 nBytes = recv(sb->sb_socket, sb->sb_start + sb->sb_size, nBytes, 0);
4269 }
4270 if (nBytes != -1)
4271 {
4272 sb->sb_size += nBytes;
4273 }
4274 else
4275 {
4276 int sockerr = GetSockError();
4277 RTMP_Log(RTMP_LOGDEBUG, "%s, recv returned %d. GetSockError(): %d (%s)",
4278 __FUNCTION__, nBytes, sockerr, strerror(sockerr));
4279 if (sockerr == EINTR && !RTMP_ctrlC)
4280 continue;
4281
4282 if (sockerr == EWOULDBLOCK || sockerr == EAGAIN)
4283 {
4284 sb->sb_timedout = TRUE;
4285 nBytes = 0;
4286 }
4287 }
4288 break;
4289 }
4290
4291 return nBytes;
4292 }
4293
4294 int
4295 RTMPSockBuf_Send(RTMPSockBuf *sb, const char *buf, int len)
4296 {
4297 int rc;
4298
4299 #ifdef _DEBUG
4300 fwrite(buf, 1, len, netstackdump);
4301 #endif
4302
4303 #if defined(CRYPTO) && !defined(NO_SSL)
4304 if (sb->sb_ssl)
4305 {
4306 rc = TLS_write(sb->sb_ssl, buf, len);
4307 }
4308 else
4309 #endif
4310 {
4311 rc = send(sb->sb_socket, buf, len, 0);
4312 }
4313 return rc;
4314 }
4315
4316 int
4317 RTMPSockBuf_Close(RTMPSockBuf *sb)
4318 {
4319 #if defined(CRYPTO) && !defined(NO_SSL)
4320 if (sb->sb_ssl)
4321 {
4322 TLS_shutdown(sb->sb_ssl);
4323 TLS_close(sb->sb_ssl);
4324 sb->sb_ssl = NULL;
4325 }
4326 #endif
4327 if (sb->sb_socket != -1)
4328 return closesocket(sb->sb_socket);
4329 return 0;
4330 }
4331
4332 #define HEX2BIN(a) (((a)&0x40)?((a)&0xf)+9:((a)&0xf))
4333
4334 static void
4335 DecodeTEA(AVal *key, AVal *text)
4336 {
4337 uint32_t *v, k[4] = { 0 }, u;
4338 uint32_t z, y, sum = 0, e, DELTA = 0x9e3779b9;
4339 int32_t p, q;
4340 int i, n;
4341 unsigned char *ptr, *out;
4342
4343 /* prep key: pack 1st 16 chars into 4 LittleEndian ints */
4344 ptr = (unsigned char *)key->av_val;
4345 u = 0;
4346 n = 0;
4347 v = k;
4348 p = key->av_len > 16 ? 16 : key->av_len;
4349 for (i = 0; i < p; i++)
4350 {
4351 u |= ptr[i] << (n * 8);
4352 if (n == 3)
4353 {
4354 *v++ = u;
4355 u = 0;
4356 n = 0;
4357 }
4358 else
4359 {
4360 n++;
4361 }
4362 }
4363 /* any trailing chars */
4364 if (u)
4365 *v = u;
4366
4367 /* prep text: hex2bin, multiples of 4 */
4368 n = (text->av_len + 7) / 8;
4369 out = malloc(n * 8);
4370 ptr = (unsigned char *)text->av_val;
4371 v = (uint32_t *) out;
4372 for (i = 0; i < n; i++)
4373 {
4374 u = (HEX2BIN(ptr[0]) << 4) + HEX2BIN(ptr[1]);
4375 u |= ((HEX2BIN(ptr[2]) << 4) + HEX2BIN(ptr[3])) << 8;
4376 u |= ((HEX2BIN(ptr[4]) << 4) + HEX2BIN(ptr[5])) << 16;
4377 u |= ((HEX2BIN(ptr[6]) << 4) + HEX2BIN(ptr[7])) << 24;
4378 *v++ = u;
4379 ptr += 8;
4380 }
4381 v = (uint32_t *) out;
4382
4383 /* http://www.movable-type.co.uk/scripts/tea-block.html */
4384 #define MX (((z>>5)^(y<<2)) + ((y>>3)^(z<<4))) ^ ((sum^y) + (k[(p&3)^e]^z));
4385 z = v[n - 1];
4386 y = v[0];
4387 q = 6 + 52 / n;
4388 sum = q * DELTA;
4389 while (sum != 0)
4390 {
4391 e = sum >> 2 & 3;
4392 for (p = n - 1; p > 0; p--)
4393 z = v[p - 1], y = v[p] -= MX;
4394 z = v[n - 1];
4395 y = v[0] -= MX;
4396 sum -= DELTA;
4397 }
4398
4399 text->av_len /= 2;
4400 memcpy(text->av_val, out, text->av_len);
4401 free(out);
4402 }
4403
4404 static int
4405 HTTP_Post(RTMP *r, RTMPTCmd cmd, const char *buf, int len)
4406 {
4407 char hbuf[512];
4408 int hlen = snprintf(hbuf, sizeof(hbuf), "POST /%s%s/%d HTTP/1.1\r\n"
4409 "Host: %.*s:%d\r\n"
4410 "Accept: */*\r\n"
4411 "User-Agent: Shockwave Flash\r\n"
4412 "Connection: Keep-Alive\r\n"
4413 "Cache-Control: no-cache\r\n"
4414 "Content-type: application/x-fcs\r\n"
4415 "Content-length: %d\r\n\r\n", RTMPT_cmds[cmd],
4416 r->m_clientID.av_val ? r->m_clientID.av_val : "",
4417 r->m_msgCounter, r->Link.hostname.av_len, r->Link.hostname.av_val,
4418 r->Link.port, len);
4419 RTMPSockBuf_Send(&r->m_sb, hbuf, hlen);
4420 hlen = RTMPSockBuf_Send(&r->m_sb, buf, len);
4421 r->m_msgCounter++;
4422 r->m_unackd++;
4423 return hlen;
4424 }
4425
4426 static int
4427 HTTP_read(RTMP *r, int fill)
4428 {
4429 char *ptr;
4430 int hlen;
4431
4432 restart:
4433 if (fill)
4434 RTMPSockBuf_Fill(&r->m_sb);
4435 if (r->m_sb.sb_size < 13) {
4436 if (fill)
4437 goto restart;
4438 return -2;
4439 }
4440 if (strncmp(r->m_sb.sb_start, "HTTP/1.1 200 ", 13))
4441 return -1;
4442 r->m_sb.sb_start[r->m_sb.sb_size] = '\0';
4443 if (!strstr(r->m_sb.sb_start, "\r\n\r\n")) {
4444 if (fill)
4445 goto restart;
4446 return -2;
4447 }
4448
4449 ptr = r->m_sb.sb_start + sizeof("HTTP/1.1 200");
4450 while ((ptr = strstr(ptr, "Content-"))) {
4451 if (!strncasecmp(ptr+8, "length:", 7)) break;
4452 ptr += 8;
4453 }
4454 if (!ptr)
4455 return -1;
4456 hlen = atoi(ptr+16);
4457 ptr = strstr(ptr+16, "\r\n\r\n");
4458 if (!ptr)
4459 return -1;
4460 ptr += 4;
4461 if (ptr + (r->m_clientID.av_val ? 1 : hlen) > r->m_sb.sb_start + r->m_sb.sb_size)
4462 {
4463 if (fill)
4464 goto restart;
4465 return -2;
4466 }
4467 r->m_sb.sb_size -= ptr - r->m_sb.sb_start;
4468 r->m_sb.sb_start = ptr;
4469 r->m_unackd--;
4470
4471 if (!r->m_clientID.av_val)
4472 {
4473 r->m_clientID.av_len = hlen;
4474 r->m_clientID.av_val = malloc(hlen+1);
4475 if (!r->m_clientID.av_val)
4476 return -1;
4477 r->m_clientID.av_val[0] = '/';
4478 memcpy(r->m_clientID.av_val+1, ptr, hlen-1);
4479 r->m_clientID.av_val[hlen] = 0;
4480 r->m_sb.sb_size = 0;
4481 }
4482 else
4483 {
4484 r->m_polling = *ptr++;
4485 r->m_resplen = hlen - 1;
4486 r->m_sb.sb_start++;
4487 r->m_sb.sb_size--;
4488 }
4489 return 0;
4490 }
4491
4492 #define MAX_IGNORED_FRAMES 50
4493
4494 /* Read from the stream until we get a media packet.
4495 * Returns -3 if Play.Close/Stop, -2 if fatal error, -1 if no more media
4496 * packets, 0 if ignorable error, >0 if there is a media packet
4497 */
4498 static int
4499 Read_1_Packet(RTMP *r, char *buf, unsigned int buflen)
4500 {
4501 uint32_t prevTagSize = 0;
4502 int rtnGetNextMediaPacket = 0, ret = RTMP_READ_EOF;
4503 RTMPPacket packet = { 0 };
4504 int recopy = FALSE;
4505 unsigned int size;
4506 char *ptr, *pend;
4507 uint32_t nTimeStamp = 0;
4508 unsigned int len;
4509
4510 rtnGetNextMediaPacket = RTMP_GetNextMediaPacket(r, &packet);
4511 while (rtnGetNextMediaPacket)
4512 {
4513 char *packetBody = packet.m_body;
4514 unsigned int nPacketLen = packet.m_nBodySize;
4515
4516 /* Return RTMP_READ_COMPLETE if this was completed nicely with
4517 * invoke message Play.Stop or Play.Complete
4518 */
4519 if (rtnGetNextMediaPacket == 2)
4520 {
4521 RTMP_Log(RTMP_LOGDEBUG,
4522 "Got Play.Complete or Play.Stop from server. "
4523 "Assuming stream is complete");
4524 ret = RTMP_READ_COMPLETE;
4525 break;
4526 }
4527
4528 r->m_read.dataType |= (((packet.m_packetType == RTMP_PACKET_TYPE_AUDIO) << 2) |
4529 (packet.m_packetType == RTMP_PACKET_TYPE_VIDEO));
4530
4531 if (packet.m_packetType == RTMP_PACKET_TYPE_VIDEO && nPacketLen <= 5)
4532 {
4533 RTMP_Log(RTMP_LOGDEBUG, "ignoring too small video packet: size: %d",
4534 nPacketLen);
4535 ret = RTMP_READ_IGNORE;
4536 break;
4537 }
4538 if (packet.m_packetType == RTMP_PACKET_TYPE_AUDIO && nPacketLen <= 1)
4539 {
4540 RTMP_Log(RTMP_LOGDEBUG, "ignoring too small audio packet: size: %d",
4541 nPacketLen);
4542 ret = RTMP_READ_IGNORE;
4543 break;
4544 }
4545
4546 if (r->m_read.flags & RTMP_READ_SEEKING)
4547 {
4548 ret = RTMP_READ_IGNORE;
4549 break;
4550 }
4551 #ifdef _DEBUG
4552 RTMP_Log(RTMP_LOGDEBUG, "type: %02X, size: %d, TS: %d ms, abs TS: %d",
4553 packet.m_packetType, nPacketLen, packet.m_nTimeStamp,
4554 packet.m_hasAbsTimestamp);
4555 if (packet.m_packetType == RTMP_PACKET_TYPE_VIDEO)
4556 RTMP_Log(RTMP_LOGDEBUG, "frametype: %02X", (*packetBody & 0xf0));
4557 #endif
4558
4559 if (r->m_read.flags & RTMP_READ_RESUME)
4560 {
4561 /* check the header if we get one */
4562 if (packet.m_nTimeStamp == 0)
4563 {
4564 if (r->m_read.nMetaHeaderSize > 0
4565 && packet.m_packetType == RTMP_PACKET_TYPE_INFO)
4566 {
4567 AMFObject metaObj;
4568 int nRes =
4569 AMF_Decode(&metaObj, packetBody, nPacketLen, FALSE);
4570 if (nRes >= 0)
4571 {
4572 AVal metastring;
4573 AMFProp_GetString(AMF_GetProp(&metaObj, NULL, 0),
4574 &metastring);
4575
4576 if (AVMATCH(&metastring, &av_onMetaData))
4577 {
4578 /* compare */
4579 if ((r->m_read.nMetaHeaderSize != nPacketLen) ||
4580 (memcmp
4581 (r->m_read.metaHeader, packetBody,
4582 r->m_read.nMetaHeaderSize) != 0))
4583 {
4584 ret = RTMP_READ_ERROR;
4585 }
4586 }
4587 AMF_Reset(&metaObj);
4588 if (ret == RTMP_READ_ERROR)
4589 break;
4590 }
4591 }
4592
4593 /* check first keyframe to make sure we got the right position
4594 * in the stream! (the first non ignored frame)
4595 */
4596 if (r->m_read.nInitialFrameSize > 0)
4597 {
4598 /* video or audio data */
4599 if (packet.m_packetType == r->m_read.initialFrameType
4600 && r->m_read.nInitialFrameSize == nPacketLen)
4601 {
4602 /* we don't compare the sizes since the packet can
4603 * contain several FLV packets, just make sure the
4604 * first frame is our keyframe (which we are going
4605 * to rewrite)
4606 */
4607 if (memcmp
4608 (r->m_read.initialFrame, packetBody,
4609 r->m_read.nInitialFrameSize) == 0)
4610 {
4611 RTMP_Log(RTMP_LOGDEBUG, "Checked keyframe successfully!");
4612 r->m_read.flags |= RTMP_READ_GOTKF;
4613 /* ignore it! (what about audio data after it? it is
4614 * handled by ignoring all 0ms frames, see below)
4615 */
4616 ret = RTMP_READ_IGNORE;
4617 break;
4618 }
4619 }
4620
4621 /* hande FLV streams, even though the server resends the
4622 * keyframe as an extra video packet it is also included
4623 * in the first FLV stream chunk and we have to compare
4624 * it and filter it out !!
4625 */
4626 if (packet.m_packetType == RTMP_PACKET_TYPE_FLASH_VIDEO)
4627 {
4628 /* basically we have to find the keyframe with the
4629 * correct TS being nResumeTS
4630 */
4631 unsigned int pos = 0;
4632 uint32_t ts = 0;
4633
4634 while (pos + 11 < nPacketLen)
4635 {
4636 /* size without header (11) and prevTagSize (4) */
4637 uint32_t dataSize =
4638 AMF_DecodeInt24(packetBody + pos + 1);
4639 ts = AMF_DecodeInt24(packetBody + pos + 4);
4640 ts |= (packetBody[pos + 7] << 24);
4641
4642 #ifdef _DEBUG
4643 RTMP_Log(RTMP_LOGDEBUG,
4644 "keyframe search: FLV Packet: type %02X, dataSize: %d, timeStamp: %d ms",
4645 packetBody[pos], dataSize, ts);
4646 #endif
4647 /* ok, is it a keyframe?:
4648 * well doesn't work for audio!
4649 */
4650 if (packetBody[pos /*6928, test 0 */ ] ==
4651 r->m_read.initialFrameType
4652 /* && (packetBody[11]&0xf0) == 0x10 */ )
4653 {
4654 if (ts == r->m_read.nResumeTS)
4655 {
4656 RTMP_Log(RTMP_LOGDEBUG,
4657 "Found keyframe with resume-keyframe timestamp!");
4658 if (r->m_read.nInitialFrameSize != dataSize
4659 || memcmp(r->m_read.initialFrame,
4660 packetBody + pos + 11,
4661 r->m_read.
4662 nInitialFrameSize) != 0)
4663 {
4664 RTMP_Log(RTMP_LOGERROR,
4665 "FLV Stream: Keyframe doesn't match!");
4666 ret = RTMP_READ_ERROR;
4667 break;
4668 }
4669 r->m_read.flags |= RTMP_READ_GOTFLVK;
4670
4671 /* skip this packet?
4672 * check whether skippable:
4673 */
4674 if (pos + 11 + dataSize + 4 > nPacketLen)
4675 {
4676 RTMP_Log(RTMP_LOGWARNING,
4677 "Non skipable packet since it doesn't end with chunk, stream corrupt!");
4678 ret = RTMP_READ_ERROR;
4679 break;
4680 }
4681 packetBody += (pos + 11 + dataSize + 4);
4682 nPacketLen -= (pos + 11 + dataSize + 4);
4683
4684 goto stopKeyframeSearch;
4685
4686 }
4687 else if (r->m_read.nResumeTS < ts)
4688 {
4689 /* the timestamp ts will only increase with
4690 * further packets, wait for seek
4691 */
4692 goto stopKeyframeSearch;
4693 }
4694 }
4695 pos += (11 + dataSize + 4);
4696 }
4697 if (ts < r->m_read.nResumeTS)
4698 {
4699 RTMP_Log(RTMP_LOGERROR,
4700 "First packet does not contain keyframe, all "
4701 "timestamps are smaller than the keyframe "
4702 "timestamp; probably the resume seek failed?");
4703 }
4704 stopKeyframeSearch:
4705 ;
4706 if (!(r->m_read.flags & RTMP_READ_GOTFLVK))
4707 {
4708 RTMP_Log(RTMP_LOGERROR,
4709 "Couldn't find the seeked keyframe in this chunk!");
4710 ret = RTMP_READ_IGNORE;
4711 break;
4712 }
4713 }
4714 }
4715 }
4716
4717 if (packet.m_nTimeStamp > 0
4718 && (r->m_read.flags & (RTMP_READ_GOTKF|RTMP_READ_GOTFLVK)))
4719 {
4720 /* another problem is that the server can actually change from
4721 * 09/08 video/audio packets to an FLV stream or vice versa and
4722 * our keyframe check will prevent us from going along with the
4723 * new stream if we resumed.
4724 *
4725 * in this case set the 'found keyframe' variables to true.
4726 * We assume that if we found one keyframe somewhere and were
4727 * already beyond TS > 0 we have written data to the output
4728 * which means we can accept all forthcoming data including the
4729 * change between 08/09 <-> FLV packets
4730 */
4731 r->m_read.flags |= (RTMP_READ_GOTKF|RTMP_READ_GOTFLVK);
4732 }
4733
4734 /* skip till we find our keyframe
4735 * (seeking might put us somewhere before it)
4736 */
4737 if (!(r->m_read.flags & RTMP_READ_GOTKF) &&
4738 packet.m_packetType != RTMP_PACKET_TYPE_FLASH_VIDEO)
4739 {
4740 RTMP_Log(RTMP_LOGWARNING,
4741 "Stream does not start with requested frame, ignoring data... ");
4742 r->m_read.nIgnoredFrameCounter++;
4743 if (r->m_read.nIgnoredFrameCounter > MAX_IGNORED_FRAMES)
4744 ret = RTMP_READ_ERROR; /* fatal error, couldn't continue stream */
4745 else
4746 ret = RTMP_READ_IGNORE;
4747 break;
4748 }
4749 /* ok, do the same for FLV streams */
4750 if (!(r->m_read.flags & RTMP_READ_GOTFLVK) &&
4751 packet.m_packetType == RTMP_PACKET_TYPE_FLASH_VIDEO)
4752 {
4753 RTMP_Log(RTMP_LOGWARNING,
4754 "Stream does not start with requested FLV frame, ignoring data... ");
4755 r->m_read.nIgnoredFlvFrameCounter++;
4756 if (r->m_read.nIgnoredFlvFrameCounter > MAX_IGNORED_FRAMES)
4757 ret = RTMP_READ_ERROR;
4758 else
4759 ret = RTMP_READ_IGNORE;
4760 break;
4761 }
4762
4763 /* we have to ignore the 0ms frames since these are the first
4764 * keyframes; we've got these so don't mess around with multiple
4765 * copies sent by the server to us! (if the keyframe is found at a
4766 * later position there is only one copy and it will be ignored by
4767 * the preceding if clause)
4768 */
4769 if (!(r->m_read.flags & RTMP_READ_NO_IGNORE) &&
4770 packet.m_packetType != RTMP_PACKET_TYPE_FLASH_VIDEO)
4771 {
4772 /* exclude type RTMP_PACKET_TYPE_FLASH_VIDEO since it can
4773 * contain several FLV packets
4774 */
4775 if (packet.m_nTimeStamp == 0)
4776 {
4777 ret = RTMP_READ_IGNORE;
4778 break;
4779 }
4780 else
4781 {
4782 /* stop ignoring packets */
4783 r->m_read.flags |= RTMP_READ_NO_IGNORE;
4784 }
4785 }
4786 }
4787
4788 /* calculate packet size and allocate slop buffer if necessary */
4789 size = nPacketLen +
4790 ((packet.m_packetType == RTMP_PACKET_TYPE_AUDIO
4791 || packet.m_packetType == RTMP_PACKET_TYPE_VIDEO
4792 || packet.m_packetType == RTMP_PACKET_TYPE_INFO) ? 11 : 0) +
4793 (packet.m_packetType != RTMP_PACKET_TYPE_FLASH_VIDEO ? 4 : 0);
4794
4795 if (size + 4 > buflen)
4796 {
4797 /* the extra 4 is for the case of an FLV stream without a last
4798 * prevTagSize (we need extra 4 bytes to append it) */
4799 r->m_read.buf = malloc(size + 4);
4800 if (r->m_read.buf == 0)
4801 {
4802 RTMP_Log(RTMP_LOGERROR, "Couldn't allocate memory!");
4803 ret = RTMP_READ_ERROR; /* fatal error */
4804 break;
4805 }
4806 recopy = TRUE;
4807 ptr = r->m_read.buf;
4808 }
4809 else
4810 {
4811 ptr = buf;
4812 }
4813 pend = ptr + size + 4;
4814
4815 /* use to return timestamp of last processed packet */
4816
4817 /* audio (0x08), video (0x09) or metadata (0x12) packets :
4818 * construct 11 byte header then add rtmp packet's data */
4819 if (packet.m_packetType == RTMP_PACKET_TYPE_AUDIO
4820 || packet.m_packetType == RTMP_PACKET_TYPE_VIDEO
4821 || packet.m_packetType == RTMP_PACKET_TYPE_INFO)
4822 {
4823 nTimeStamp = r->m_read.nResumeTS + packet.m_nTimeStamp;
4824 prevTagSize = 11 + nPacketLen;
4825
4826 *ptr = packet.m_packetType;
4827 ptr++;
4828 ptr = AMF_EncodeInt24(ptr, pend, nPacketLen);
4829
4830 #if 0
4831 if(packet.m_packetType == RTMP_PACKET_TYPE_VIDEO) {
4832
4833 /* H264 fix: */
4834 if((packetBody[0] & 0x0f) == 7) { /* CodecId = H264 */
4835 uint8_t packetType = *(packetBody+1);
4836
4837 uint32_t ts = AMF_DecodeInt24(packetBody+2); /* composition time */
4838 int32_t cts = (ts+0xff800000)^0xff800000;
4839 RTMP_Log(RTMP_LOGDEBUG, "cts : %d\n", cts);
4840
4841 nTimeStamp -= cts;
4842 /* get rid of the composition time */
4843 CRTMP::EncodeInt24(packetBody+2, 0);
4844 }
4845 RTMP_Log(RTMP_LOGDEBUG, "VIDEO: nTimeStamp: 0x%08X (%d)\n", nTimeStamp, nTimeStamp);
4846 }
4847 #endif
4848
4849 ptr = AMF_EncodeInt24(ptr, pend, nTimeStamp);
4850 *ptr = (char)((nTimeStamp & 0xFF000000) >> 24);
4851 ptr++;
4852
4853 /* stream id */
4854 ptr = AMF_EncodeInt24(ptr, pend, 0);
4855 }
4856
4857 memcpy(ptr, packetBody, nPacketLen);
4858 len = nPacketLen;
4859
4860 /* correct tagSize and obtain timestamp if we have an FLV stream */
4861 if (packet.m_packetType == RTMP_PACKET_TYPE_FLASH_VIDEO)
4862 {
4863 unsigned int pos = 0;
4864 int delta;
4865
4866 /* grab first timestamp and see if it needs fixing */
4867 nTimeStamp = AMF_DecodeInt24(packetBody + 4);
4868 nTimeStamp |= (packetBody[7] << 24);
4869 delta = packet.m_nTimeStamp - nTimeStamp + r->m_read.nResumeTS;
4870
4871 while (pos + 11 < nPacketLen)
4872 {
4873 /* size without header (11) and without prevTagSize (4) */
4874 uint32_t dataSize = AMF_DecodeInt24(packetBody + pos + 1);
4875 nTimeStamp = AMF_DecodeInt24(packetBody + pos + 4);
4876 nTimeStamp |= (packetBody[pos + 7] << 24);
4877
4878 if (delta)
4879 {
4880 nTimeStamp += delta;
4881 AMF_EncodeInt24(ptr+pos+4, pend, nTimeStamp);
4882 ptr[pos+7] = nTimeStamp>>24;
4883 }
4884
4885 /* set data type */
4886 r->m_read.dataType |= (((*(packetBody + pos) == 0x08) << 2) |
4887 (*(packetBody + pos) == 0x09));
4888
4889 if (pos + 11 + dataSize + 4 > nPacketLen)
4890 {
4891 if (pos + 11 + dataSize > nPacketLen)
4892 {
4893 RTMP_Log(RTMP_LOGERROR,
4894 "Wrong data size (%u), stream corrupted, aborting!",
4895 dataSize);
4896 ret = RTMP_READ_ERROR;
4897 break;
4898 }
4899 RTMP_Log(RTMP_LOGWARNING, "No tagSize found, appending!");
4900
4901 /* we have to append a last tagSize! */
4902 prevTagSize = dataSize + 11;
4903 AMF_EncodeInt32(ptr + pos + 11 + dataSize, pend,
4904 prevTagSize);
4905 size += 4;
4906 len += 4;
4907 }
4908 else
4909 {
4910 prevTagSize =
4911 AMF_DecodeInt32(packetBody + pos + 11 + dataSize);
4912
4913 #ifdef _DEBUG
4914 RTMP_Log(RTMP_LOGDEBUG,
4915 "FLV Packet: type %02X, dataSize: %lu, tagSize: %lu, timeStamp: %lu ms",
4916 (unsigned char)packetBody[pos], dataSize, prevTagSize,
4917 nTimeStamp);
4918 #endif
4919
4920 if (prevTagSize != (dataSize + 11))
4921 {
4922 #ifdef _DEBUG
4923 RTMP_Log(RTMP_LOGWARNING,
4924 "Tag and data size are not consitent, writing tag size according to dataSize+11: %d",
4925 dataSize + 11);
4926 #endif
4927
4928 prevTagSize = dataSize + 11;
4929 AMF_EncodeInt32(ptr + pos + 11 + dataSize, pend,
4930 prevTagSize);
4931 }
4932 }
4933
4934 pos += prevTagSize + 4; /*(11+dataSize+4); */
4935 }
4936 }
4937 ptr += len;
4938
4939 if (packet.m_packetType != RTMP_PACKET_TYPE_FLASH_VIDEO)
4940 {
4941 /* FLV tag packets contain their own prevTagSize */
4942 AMF_EncodeInt32(ptr, pend, prevTagSize);
4943 }
4944
4945 /* In non-live this nTimeStamp can contain an absolute TS.
4946 * Update ext timestamp with this absolute offset in non-live mode
4947 * otherwise report the relative one
4948 */
4949 /* RTMP_Log(RTMP_LOGDEBUG, "type: %02X, size: %d, pktTS: %dms, TS: %dms, bLiveStream: %d", packet.m_packetType, nPacketLen, packet.m_nTimeStamp, nTimeStamp, r->Link.lFlags & RTMP_LF_LIVE); */
4950 r->m_read.timestamp = (r->Link.lFlags & RTMP_LF_LIVE) ? packet.m_nTimeStamp : nTimeStamp;
4951
4952 ret = size;
4953 break;
4954 }
4955
4956 if (rtnGetNextMediaPacket)
4957 RTMPPacket_Free(&packet);
4958
4959 if (recopy)
4960 {
4961 len = ret > buflen ? buflen : ret;
4962 memcpy(buf, r->m_read.buf, len);
4963 r->m_read.bufpos = r->m_read.buf + len;
4964 r->m_read.buflen = ret - len;
4965 }
4966 return ret;
4967 }
4968
4969 static const char flvHeader[] = { 'F', 'L', 'V', 0x01,
4970 0x00, /* 0x04 == audio, 0x01 == video */
4971 0x00, 0x00, 0x00, 0x09,
4972 0x00, 0x00, 0x00, 0x00
4973 };
4974
4975 #define HEADERBUF (128*1024)
4976 int
4977 RTMP_Read(RTMP *r, char *buf, int size)
4978 {
4979 int nRead = 0, total = 0;
4980
4981 /* can't continue */
4982 fail:
4983 switch (r->m_read.status) {
4984 case RTMP_READ_EOF:
4985 case RTMP_READ_COMPLETE:
4986 return 0;
4987 case RTMP_READ_ERROR: /* corrupted stream, resume failed */
4988 SetSockError(EINVAL);
4989 return -1;
4990 default:
4991 break;
4992 }
4993
4994 /* first time thru */
4995 if (!(r->m_read.flags & RTMP_READ_HEADER))
4996 {
4997 if (!(r->m_read.flags & RTMP_READ_RESUME))
4998 {
4999 char *mybuf = malloc(HEADERBUF), *end = mybuf + HEADERBUF;
5000 int cnt = 0;
5001 r->m_read.buf = mybuf;
5002 r->m_read.buflen = HEADERBUF;
5003
5004 memcpy(mybuf, flvHeader, sizeof(flvHeader));
5005 r->m_read.buf += sizeof(flvHeader);
5006 r->m_read.buflen -= sizeof(flvHeader);
5007 cnt += sizeof(flvHeader);
5008
5009 while (r->m_read.timestamp == 0)
5010 {
5011 nRead = Read_1_Packet(r, r->m_read.buf, r->m_read.buflen);
5012 if (nRead < 0)
5013 {
5014 free(mybuf);
5015 r->m_read.buf = NULL;
5016 r->m_read.buflen = 0;
5017 r->m_read.status = nRead;
5018 goto fail;
5019 }
5020 /* buffer overflow, fix buffer and give up */
5021 if (r->m_read.buf < mybuf || r->m_read.buf > end) {
5022 mybuf = realloc(mybuf, cnt + nRead);
5023 memcpy(mybuf+cnt, r->m_read.buf, nRead);
5024 free(r->m_read.buf);
5025 r->m_read.buf = mybuf+cnt+nRead;
5026 break;
5027 }
5028 cnt += nRead;
5029 r->m_read.buf += nRead;
5030 r->m_read.buflen -= nRead;
5031 if (r->m_read.dataType == 5)
5032 break;
5033 }
5034 mybuf[4] = r->m_read.dataType;
5035 r->m_read.buflen = r->m_read.buf - mybuf;
5036 r->m_read.buf = mybuf;
5037 r->m_read.bufpos = mybuf;
5038 }
5039 r->m_read.flags |= RTMP_READ_HEADER;
5040 }
5041
5042 if ((r->m_read.flags & RTMP_READ_SEEKING) && r->m_read.buf)
5043 {
5044 /* drop whatever's here */
5045 free(r->m_read.buf);
5046 r->m_read.buf = NULL;
5047 r->m_read.bufpos = NULL;
5048 r->m_read.buflen = 0;
5049 }
5050
5051 /* If there's leftover data buffered, use it up */
5052 if (r->m_read.buf)
5053 {
5054 nRead = r->m_read.buflen;
5055 if (nRead > size)
5056 nRead = size;
5057 memcpy(buf, r->m_read.bufpos, nRead);
5058 r->m_read.buflen -= nRead;
5059 if (!r->m_read.buflen)
5060 {
5061 free(r->m_read.buf);
5062 r->m_read.buf = NULL;
5063 r->m_read.bufpos = NULL;
5064 }
5065 else
5066 {
5067 r->m_read.bufpos += nRead;
5068 }
5069 buf += nRead;
5070 total += nRead;
5071 size -= nRead;
5072 }
5073
5074 while (size > 0 && (nRead = Read_1_Packet(r, buf, size)) >= 0)
5075 {
5076 if (!nRead) continue;
5077 buf += nRead;
5078 total += nRead;
5079 size -= nRead;
5080 break;
5081 }
5082 if (nRead < 0)
5083 r->m_read.status = nRead;
5084
5085 if (size < 0)
5086 total += size;
5087 return total;
5088 }
5089
5090 static const AVal av_setDataFrame = AVC("@setDataFrame");
5091
5092 int
5093 RTMP_Write(RTMP *r, const char *buf, int size)
5094 {
5095 RTMPPacket *pkt = &r->m_write;
5096 char *pend, *enc;
5097 int s2 = size, ret, num;
5098
5099 pkt->m_nChannel = 0x04; /* source channel */
5100 pkt->m_nInfoField2 = r->m_stream_id;
5101
5102 while (s2)
5103 {
5104 if (!pkt->m_nBytesRead)
5105 {
5106 if (size < 11) {
5107 /* FLV pkt too small */
5108 return 0;
5109 }
5110
5111 if (buf[0] == 'F' && buf[1] == 'L' && buf[2] == 'V')
5112 {
5113 buf += 13;
5114 s2 -= 13;
5115 }
5116
5117 pkt->m_packetType = *buf++;
5118 pkt->m_nBodySize = AMF_DecodeInt24(buf);
5119 buf += 3;
5120 pkt->m_nTimeStamp = AMF_DecodeInt24(buf);
5121 buf += 3;
5122 pkt->m_nTimeStamp |= *buf++ << 24;
5123 buf += 3;
5124 s2 -= 11;
5125
5126 if (((pkt->m_packetType == RTMP_PACKET_TYPE_AUDIO
5127 || pkt->m_packetType == RTMP_PACKET_TYPE_VIDEO) &&
5128 !pkt->m_nTimeStamp) || pkt->m_packetType == RTMP_PACKET_TYPE_INFO)
5129 {
5130 pkt->m_headerType = RTMP_PACKET_SIZE_LARGE;
5131 if (pkt->m_packetType == RTMP_PACKET_TYPE_INFO)
5132 pkt->m_nBodySize += 16;
5133 }
5134 else
5135 {
5136 pkt->m_headerType = RTMP_PACKET_SIZE_MEDIUM;
5137 }
5138
5139 if (!RTMPPacket_Alloc(pkt, pkt->m_nBodySize))
5140 {
5141 RTMP_Log(RTMP_LOGDEBUG, "%s, failed to allocate packet", __FUNCTION__);
5142 return FALSE;
5143 }
5144 enc = pkt->m_body;
5145 pend = enc + pkt->m_nBodySize;
5146 if (pkt->m_packetType == RTMP_PACKET_TYPE_INFO)
5147 {
5148 enc = AMF_EncodeString(enc, pend, &av_setDataFrame);
5149 pkt->m_nBytesRead = enc - pkt->m_body;
5150 }
5151 }
5152 else
5153 {
5154 enc = pkt->m_body + pkt->m_nBytesRead;
5155 }
5156 num = pkt->m_nBodySize - pkt->m_nBytesRead;
5157 if (num > s2)
5158 num = s2;
5159 memcpy(enc, buf, num);
5160 pkt->m_nBytesRead += num;
5161 s2 -= num;
5162 buf += num;
5163 if (pkt->m_nBytesRead == pkt->m_nBodySize)
5164 {
5165 ret = RTMP_SendPacket(r, pkt, FALSE);
5166 RTMPPacket_Free(pkt);
5167 pkt->m_nBytesRead = 0;
5168 if (!ret)
5169 return -1;
5170 buf += 4;
5171 s2 -= 4;
5172 if (s2 < 0)
5173 break;
5174 }
5175 }
5176 return size+s2;
5177 }