?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Simplify the logic for freeing reused strings in RTMP_Close
[rtmpdump.git] / librtmp / rtmp.c
blob32aaa297fd22056481a398b088ed93a392898c68
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 tcUrl is allocated, set RTMP_PUB_ALLOC instead to simplify checks below.
2538 if (r->Link.lFlags & RTMP_LF_FTCU && !(r->Link.pFlags & RTMP_PUB_ALLOC))
2539 {
2540 ptr = malloc(r->Link.app.av_len + 1);
2541 strncpy(ptr, r->Link.app.av_val, r->Link.app.av_len);
2542 ptr[r->Link.app.av_len] = '\0'; // We use strstr on this string below
2543 r->Link.app.av_val = ptr;
2544
2545 r->Link.lFlags &= ~RTMP_LF_FTCU;
2546 r->Link.pFlags |= RTMP_PUB_ALLOC;
2547 }
2548
2549 if (strstr(description->av_val, av_authmod_adobe.av_val) != NULL)
2550 {
2551 if(strstr(description->av_val, "code=403 need auth") != NULL)
2552 {
2553 if (strstr(r->Link.app.av_val, av_authmod_adobe.av_val) != NULL) {
2554 RTMP_Log(RTMP_LOGERROR, "%s, wrong pubUser & pubPasswd for publisher auth", __FUNCTION__);
2555 return 0;
2556 } else if(r->Link.pubUser.av_len && r->Link.pubPasswd.av_len) {
2557 pubToken.av_val = malloc(r->Link.pubUser.av_len + av_authmod_adobe.av_len + 8);
2558 pubToken.av_len = sprintf(pubToken.av_val, "?%s&user=%s",
2559 av_authmod_adobe.av_val,
2560 r->Link.pubUser.av_val);
2561 RTMP_Log(RTMP_LOGDEBUG, "%s, pubToken1: %s", __FUNCTION__, pubToken.av_val);
2562 } else {
2563 RTMP_Log(RTMP_LOGERROR, "%s, need to set pubUser & pubPasswd for publisher auth", __FUNCTION__);
2564 return 0;
2565 }
2566 }
2567 else if((token_in = strstr(description->av_val, "?reason=needauth")) != NULL)
2568 {
2569 char *par, *val = NULL, *orig_ptr;
2570 AVal user, salt, opaque, challenge, *aptr = NULL;
2571 opaque.av_len = 0;
2572 challenge.av_len = 0;
2573
2574 ptr = orig_ptr = strdup(token_in);
2575 while (ptr)
2576 {
2577 par = ptr;
2578 ptr = strchr(par, '&');
2579 if(ptr)
2580 *ptr++ = '\0';
2581
2582 val = strchr(par, '=');
2583 if(val)
2584 *val++ = '\0';
2585
2586 if (aptr) {
2587 aptr->av_len = par - aptr->av_val - 1;
2588 aptr = NULL;
2589 }
2590 if (strcmp(par, "user") == 0){
2591 user.av_val = val;
2592 aptr = &user;
2593 } else if (strcmp(par, "salt") == 0){
2594 salt.av_val = val;
2595 aptr = &salt;
2596 } else if (strcmp(par, "opaque") == 0){
2597 opaque.av_val = val;
2598 aptr = &opaque;
2599 } else if (strcmp(par, "challenge") == 0){
2600 challenge.av_val = val;
2601 aptr = &challenge;
2602 }
2603
2604 RTMP_Log(RTMP_LOGDEBUG, "%s, par:\"%s\" = val:\"%s\"", __FUNCTION__, par, val);
2605 }
2606 if (aptr)
2607 aptr->av_len = strlen(aptr->av_val);
2608
2609 /* hash1 = base64enc(md5(user + _aodbeAuthSalt + password)) */
2610 MD5_Init(&md5ctx);
2611 MD5_Update(&md5ctx, user.av_val, user.av_len);
2612 MD5_Update(&md5ctx, salt.av_val, salt.av_len);
2613 MD5_Update(&md5ctx, r->Link.pubPasswd.av_val, r->Link.pubPasswd.av_len);
2614 MD5_Final(md5sum_val, &md5ctx);
2615 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s%s%s) =>", __FUNCTION__,
2616 user.av_val, salt.av_val, r->Link.pubPasswd.av_val);
2617 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2618
2619 b64enc(md5sum_val, MD5_DIGEST_LENGTH, salted2, SALTED2_LEN);
2620 RTMP_Log(RTMP_LOGDEBUG, "%s, b64(md5_1) = %s", __FUNCTION__, salted2);
2621
2622 challenge2_data = rand();
2623
2624 b64enc((unsigned char *) &challenge2_data, sizeof(int), challenge2, CHALLENGE2_LEN);
2625 RTMP_Log(RTMP_LOGDEBUG, "%s, b64(%d) = %s", __FUNCTION__, challenge2_data, challenge2);
2626
2627 MD5_Init(&md5ctx);
2628 MD5_Update(&md5ctx, salted2, B64DIGEST_LEN);
2629 /* response = base64enc(md5(hash1 + opaque + challenge2)) */
2630 if (opaque.av_len)
2631 MD5_Update(&md5ctx, opaque.av_val, opaque.av_len);
2632 else if (challenge.av_len)
2633 MD5_Update(&md5ctx, challenge.av_val, challenge.av_len);
2634 MD5_Update(&md5ctx, challenge2, B64INT_LEN);
2635 MD5_Final(md5sum_val, &md5ctx);
2636
2637 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s%s%s) =>", __FUNCTION__,
2638 salted2, opaque.av_len ? opaque.av_val : "", challenge2);
2639 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2640
2641 b64enc(md5sum_val, MD5_DIGEST_LENGTH, response, RESPONSE_LEN);
2642 RTMP_Log(RTMP_LOGDEBUG, "%s, b64(md5_2) = %s", __FUNCTION__, response);
2643
2644 /* have all hashes, create auth token for the end of app */
2645 pubToken.av_val = malloc(32 + B64INT_LEN + B64DIGEST_LEN + opaque.av_len);
2646 pubToken.av_len = sprintf(pubToken.av_val,
2647 "&challenge=%s&response=%s&opaque=%s",
2648 challenge2,
2649 response,
2650 opaque.av_len ? opaque.av_val : "");
2651 RTMP_Log(RTMP_LOGDEBUG, "%s, pubToken2: %s", __FUNCTION__, pubToken.av_val);
2652 free(orig_ptr);
2653 }
2654 else if(strstr(description->av_val, "?reason=authfailed") != NULL)
2655 {
2656 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: wrong password", __FUNCTION__);
2657 return 0;
2658 }
2659 else if(strstr(description->av_val, "?reason=nosuchuser") != NULL)
2660 {
2661 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: no such user", __FUNCTION__);
2662 return 0;
2663 }
2664 else
2665 {
2666 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: unknown auth mode: %s",
2667 __FUNCTION__, description->av_val);
2668 return 0;
2669 }
2670
2671 ptr = malloc(r->Link.app.av_len + pubToken.av_len);
2672 strncpy(ptr, r->Link.app.av_val, r->Link.app.av_len);
2673 strncpy(ptr + r->Link.app.av_len, pubToken.av_val, pubToken.av_len);
2674 r->Link.app.av_len += pubToken.av_len;
2675 if(r->Link.pFlags & RTMP_PUB_ALLOC)
2676 free(r->Link.app.av_val);
2677 r->Link.app.av_val = ptr;
2678
2679 ptr = malloc(r->Link.tcUrl.av_len + pubToken.av_len);
2680 strncpy(ptr, r->Link.tcUrl.av_val, r->Link.tcUrl.av_len);
2681 strncpy(ptr + r->Link.tcUrl.av_len, pubToken.av_val, pubToken.av_len);
2682 r->Link.tcUrl.av_len += pubToken.av_len;
2683 if(r->Link.pFlags & RTMP_PUB_ALLOC)
2684 free(r->Link.tcUrl.av_val);
2685 r->Link.tcUrl.av_val = ptr;
2686
2687 free(pubToken.av_val);
2688 r->Link.pFlags |= RTMP_PUB_ALLOC;
2689
2690 RTMP_Log(RTMP_LOGDEBUG, "%s, new app: %.*s tcUrl: %.*s playpath: %s", __FUNCTION__,
2691 r->Link.app.av_len, r->Link.app.av_val,
2692 r->Link.tcUrl.av_len, r->Link.tcUrl.av_val,
2693 r->Link.playpath.av_val);
2694 }
2695 else if (strstr(description->av_val, av_authmod_llnw.av_val) != NULL)
2696 {
2697 if(strstr(description->av_val, "code=403 need auth") != NULL)
2698 {
2699 /* This part seems to be the same for llnw and adobe */
2700
2701 if (strstr(r->Link.app.av_val, av_authmod_llnw.av_val) != NULL) {
2702 RTMP_Log(RTMP_LOGERROR, "%s, wrong pubUser & pubPasswd for publisher auth", __FUNCTION__);
2703 return 0;
2704 } else if(r->Link.pubUser.av_len && r->Link.pubPasswd.av_len) {
2705 pubToken.av_val = malloc(r->Link.pubUser.av_len + av_authmod_llnw.av_len + 8);
2706 pubToken.av_len = sprintf(pubToken.av_val, "?%s&user=%s",
2707 av_authmod_llnw.av_val,
2708 r->Link.pubUser.av_val);
2709 RTMP_Log(RTMP_LOGDEBUG, "%s, pubToken1: %s", __FUNCTION__, pubToken.av_val);
2710 } else {
2711 RTMP_Log(RTMP_LOGERROR, "%s, need to set pubUser & pubPasswd for publisher auth", __FUNCTION__);
2712 return 0;
2713 }
2714 }
2715 else if((token_in = strstr(description->av_val, "?reason=needauth")) != NULL)
2716 {
2717 char *orig_ptr;
2718 char *par, *val = NULL;
2719 char hash1[HEXHASH_LEN+1], hash2[HEXHASH_LEN+1], hash3[HEXHASH_LEN+1];
2720 AVal user, nonce, *aptr = NULL;
2721 AVal apptmp;
2722
2723 /* llnw auth method
2724 * Seems to be closely based on HTTP Digest Auth:
2725 * http://tools.ietf.org/html/rfc2617
2726 * http://en.wikipedia.org/wiki/Digest_access_authentication
2727 */
2728
2729 const char authmod[] = "llnw";
2730 const char realm[] = "live";
2731 const char method[] = "publish";
2732 const char qop[] = "auth";
2733 /* nc = 1..connection count (or rather, number of times cnonce has been reused) */
2734 int nc = 1;
2735 /* nchex = hexenc(nc) (8 hex digits according to RFC 2617) */
2736 char nchex[9];
2737 /* cnonce = hexenc(4 random bytes) (initialized on first connection) */
2738 char cnonce[9];
2739
2740 ptr = orig_ptr = strdup(token_in);
2741 /* Extract parameters (we need user and nonce) */
2742 while (ptr)
2743 {
2744 par = ptr;
2745 ptr = strchr(par, '&');
2746 if(ptr)
2747 *ptr++ = '\0';
2748
2749 val = strchr(par, '=');
2750 if(val)
2751 *val++ = '\0';
2752
2753 if (aptr) {
2754 aptr->av_len = par - aptr->av_val - 1;
2755 aptr = NULL;
2756 }
2757 if (strcmp(par, "user") == 0){
2758 user.av_val = val;
2759 aptr = &user;
2760 } else if (strcmp(par, "nonce") == 0){
2761 nonce.av_val = val;
2762 aptr = &nonce;
2763 }
2764
2765 RTMP_Log(RTMP_LOGDEBUG, "%s, par:\"%s\" = val:\"%s\"", __FUNCTION__, par, val);
2766 }
2767 if (aptr)
2768 aptr->av_len = strlen(aptr->av_val);
2769
2770 /* FIXME: handle case where user==NULL or nonce==NULL */
2771
2772 sprintf(nchex, "%08x", nc);
2773 sprintf(cnonce, "%08x", rand());
2774
2775 /* hash1 = hexenc(md5(user + ":" + realm + ":" + password)) */
2776 MD5_Init(&md5ctx);
2777 MD5_Update(&md5ctx, user.av_val, user.av_len);
2778 MD5_Update(&md5ctx, ":", 1);
2779 MD5_Update(&md5ctx, realm, sizeof(realm)-1);
2780 MD5_Update(&md5ctx, ":", 1);
2781 MD5_Update(&md5ctx, r->Link.pubPasswd.av_val, r->Link.pubPasswd.av_len);
2782 MD5_Final(md5sum_val, &md5ctx);
2783 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s:%s:%s) =>", __FUNCTION__,
2784 user.av_val, realm, r->Link.pubPasswd.av_val);
2785 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2786 hexenc(md5sum_val, MD5_DIGEST_LENGTH, hash1);
2787
2788 /* hash2 = hexenc(md5(method + ":/" + app + "/" + appInstance)) */
2789 /* Extract appname + appinstance without query parameters */
2790 apptmp = r->Link.app;
2791 ptr = AValChr(&apptmp, '?');
2792 if (ptr)
2793 apptmp.av_len = ptr - apptmp.av_val;
2794
2795 MD5_Init(&md5ctx);
2796 MD5_Update(&md5ctx, method, sizeof(method)-1);
2797 MD5_Update(&md5ctx, ":/", 2);
2798 MD5_Update(&md5ctx, apptmp.av_val, apptmp.av_len);
2799 if (!AValChr(&apptmp, '/'))
2800 MD5_Update(&md5ctx, "/_definst_", sizeof("/_definst_") - 1);
2801 MD5_Final(md5sum_val, &md5ctx);
2802 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s:/%.*s) =>", __FUNCTION__,
2803 method, apptmp.av_len, apptmp.av_val);
2804 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2805 hexenc(md5sum_val, MD5_DIGEST_LENGTH, hash2);
2806
2807 /* hash3 = hexenc(md5(hash1 + ":" + nonce + ":" + nchex + ":" + cnonce + ":" + qop + ":" + hash2)) */
2808 MD5_Init(&md5ctx);
2809 MD5_Update(&md5ctx, hash1, HEXHASH_LEN);
2810 MD5_Update(&md5ctx, ":", 1);
2811 MD5_Update(&md5ctx, nonce.av_val, nonce.av_len);
2812 MD5_Update(&md5ctx, ":", 1);
2813 MD5_Update(&md5ctx, nchex, sizeof(nchex)-1);
2814 MD5_Update(&md5ctx, ":", 1);
2815 MD5_Update(&md5ctx, cnonce, sizeof(cnonce)-1);
2816 MD5_Update(&md5ctx, ":", 1);
2817 MD5_Update(&md5ctx, qop, sizeof(qop)-1);
2818 MD5_Update(&md5ctx, ":", 1);
2819 MD5_Update(&md5ctx, hash2, HEXHASH_LEN);
2820 MD5_Final(md5sum_val, &md5ctx);
2821 RTMP_Log(RTMP_LOGDEBUG, "%s, md5(%s:%s:%s:%s:%s:%s) =>", __FUNCTION__,
2822 hash1, nonce.av_val, nchex, cnonce, qop, hash2);
2823 RTMP_LogHexString(RTMP_LOGDEBUG, md5sum_val, MD5_DIGEST_LENGTH);
2824 hexenc(md5sum_val, MD5_DIGEST_LENGTH, hash3);
2825
2826 /* pubToken = &authmod=<authmod>&user=<username>&nonce=<nonce>&cnonce=<cnonce>&nc=<nchex>&response=<hash3> */
2827 /* Append nonces and response to query string which already contains
2828 * user + authmod */
2829 pubToken.av_val = malloc(64 + sizeof(authmod)-1 + user.av_len + nonce.av_len + sizeof(cnonce)-1 + sizeof(nchex)-1 + HEXHASH_LEN);
2830 sprintf(pubToken.av_val,
2831 "&nonce=%s&cnonce=%s&nc=%s&response=%s",
2832 nonce.av_val, cnonce, nchex, hash3);
2833 pubToken.av_len = strlen(pubToken.av_val);
2834 RTMP_Log(RTMP_LOGDEBUG, "%s, pubToken2: %s", __FUNCTION__, pubToken.av_val);
2835
2836 free(orig_ptr);
2837 }
2838 else if(strstr(description->av_val, "?reason=authfail") != NULL)
2839 {
2840 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed", __FUNCTION__);
2841 return 0;
2842 }
2843 else if(strstr(description->av_val, "?reason=nosuchuser") != NULL)
2844 {
2845 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: no such user", __FUNCTION__);
2846 return 0;
2847 }
2848 else
2849 {
2850 RTMP_Log(RTMP_LOGERROR, "%s, Authentication failed: unknown auth mode: %s",
2851 __FUNCTION__, description->av_val);
2852 return 0;
2853 }
2854
2855 ptr = malloc(r->Link.app.av_len + pubToken.av_len);
2856 strncpy(ptr, r->Link.app.av_val, r->Link.app.av_len);
2857 strncpy(ptr + r->Link.app.av_len, pubToken.av_val, pubToken.av_len);
2858 r->Link.app.av_len += pubToken.av_len;
2859 if(r->Link.pFlags & RTMP_PUB_ALLOC)
2860 free(r->Link.app.av_val);
2861 r->Link.app.av_val = ptr;
2862
2863 ptr = malloc(r->Link.tcUrl.av_len + pubToken.av_len);
2864 strncpy(ptr, r->Link.tcUrl.av_val, r->Link.tcUrl.av_len);
2865 strncpy(ptr + r->Link.tcUrl.av_len, pubToken.av_val, pubToken.av_len);
2866 r->Link.tcUrl.av_len += pubToken.av_len;
2867 if(r->Link.pFlags & RTMP_PUB_ALLOC)
2868 free(r->Link.tcUrl.av_val);
2869 r->Link.tcUrl.av_val = ptr;
2870
2871 free(pubToken.av_val);
2872 r->Link.pFlags |= RTMP_PUB_ALLOC;
2873
2874 RTMP_Log(RTMP_LOGDEBUG, "%s, new app: %.*s tcUrl: %.*s playpath: %s", __FUNCTION__,
2875 r->Link.app.av_len, r->Link.app.av_val,
2876 r->Link.tcUrl.av_len, r->Link.tcUrl.av_val,
2877 r->Link.playpath.av_val);
2878 }
2879 else
2880 {
2881 return 0;
2882 }
2883 return 1;
2884 }
2885 #endif
2886
2887
2888 SAVC(onBWDone);
2889 SAVC(onFCSubscribe);
2890 SAVC(onFCUnsubscribe);
2891 SAVC(_onbwcheck);
2892 SAVC(_onbwdone);
2893 SAVC(_error);
2894 SAVC(close);
2895 SAVC(code);
2896 SAVC(level);
2897 SAVC(description);
2898 SAVC(onStatus);
2899 SAVC(playlist_ready);
2900 static const AVal av_NetStream_Failed = AVC("NetStream.Failed");
2901 static const AVal av_NetStream_Play_Failed = AVC("NetStream.Play.Failed");
2902 static const AVal av_NetStream_Play_StreamNotFound =
2903 AVC("NetStream.Play.StreamNotFound");
2904 static const AVal av_NetConnection_Connect_InvalidApp =
2905 AVC("NetConnection.Connect.InvalidApp");
2906 static const AVal av_NetStream_Play_Start = AVC("NetStream.Play.Start");
2907 static const AVal av_NetStream_Play_Complete = AVC("NetStream.Play.Complete");
2908 static const AVal av_NetStream_Play_Stop = AVC("NetStream.Play.Stop");
2909 static const AVal av_NetStream_Seek_Notify = AVC("NetStream.Seek.Notify");
2910 static const AVal av_NetStream_Pause_Notify = AVC("NetStream.Pause.Notify");
2911 static const AVal av_NetStream_Play_PublishNotify =
2912 AVC("NetStream.Play.PublishNotify");
2913 static const AVal av_NetStream_Play_UnpublishNotify =
2914 AVC("NetStream.Play.UnpublishNotify");
2915 static const AVal av_NetStream_Publish_Start = AVC("NetStream.Publish.Start");
2916 static const AVal av_NetConnection_Connect_Rejected =
2917 AVC("NetConnection.Connect.Rejected");
2918
2919 /* Returns 0 for OK/Failed/error, 1 for 'Stop or Complete' */
2920 static int
2921 HandleInvoke(RTMP *r, const char *body, unsigned int nBodySize)
2922 {
2923 AMFObject obj;
2924 AVal method;
2925 double txn;
2926 int ret = 0, nRes;
2927 if (body[0] != 0x02) /* make sure it is a string method name we start with */
2928 {
2929 RTMP_Log(RTMP_LOGWARNING, "%s, Sanity failed. no string method in invoke packet",
2930 __FUNCTION__);
2931 return 0;
2932 }
2933
2934 nRes = AMF_Decode(&obj, body, nBodySize, FALSE);
2935 if (nRes < 0)
2936 {
2937 RTMP_Log(RTMP_LOGERROR, "%s, error decoding invoke packet", __FUNCTION__);
2938 return 0;
2939 }
2940
2941 AMF_Dump(&obj);
2942 AMFProp_GetString(AMF_GetProp(&obj, NULL, 0), &method);
2943 txn = AMFProp_GetNumber(AMF_GetProp(&obj, NULL, 1));
2944 RTMP_Log(RTMP_LOGDEBUG, "%s, server invoking <%s>", __FUNCTION__, method.av_val);
2945
2946 if (AVMATCH(&method, &av__result))
2947 {
2948 AVal methodInvoked = {0};
2949 int i;
2950
2951 for (i=0; i<r->m_numCalls; i++) {
2952 if (r->m_methodCalls[i].num == (int)txn) {
2953 methodInvoked = r->m_methodCalls[i].name;
2954 AV_erase(r->m_methodCalls, &r->m_numCalls, i, FALSE);
2955 break;
2956 }
2957 }
2958 if (!methodInvoked.av_val) {
2959 RTMP_Log(RTMP_LOGDEBUG, "%s, received result id %f without matching request",
2960 __FUNCTION__, txn);
2961 goto leave;
2962 }
2963
2964 RTMP_Log(RTMP_LOGDEBUG, "%s, received result for method call <%s>", __FUNCTION__,
2965 methodInvoked.av_val);
2966
2967 if (AVMATCH(&methodInvoked, &av_connect))
2968 {
2969 if (r->Link.token.av_len)
2970 {
2971 AMFObjectProperty p;
2972 if (RTMP_FindFirstMatchingProperty(&obj, &av_secureToken, &p))
2973 {
2974 DecodeTEA(&r->Link.token, &p.p_vu.p_aval);
2975 SendSecureTokenResponse(r, &p.p_vu.p_aval);
2976 }
2977 }
2978 if (r->Link.protocol & RTMP_FEATURE_WRITE)
2979 {
2980 SendReleaseStream(r);
2981 SendFCPublish(r);
2982 }
2983 else
2984 {
2985 RTMP_SendServerBW(r);
2986 RTMP_SendCtrl(r, 3, 0, 300);
2987 }
2988 RTMP_SendCreateStream(r);
2989
2990 if (!(r->Link.protocol & RTMP_FEATURE_WRITE))
2991 {
2992 /* Authenticate on Justin.tv legacy servers before sending FCSubscribe */
2993 if (r->Link.usherToken.av_len)
2994 SendUsherToken(r, &r->Link.usherToken);
2995 /* Send the FCSubscribe if live stream or if subscribepath is set */
2996 if (r->Link.subscribepath.av_len)
2997 SendFCSubscribe(r, &r->Link.subscribepath);
2998 else if (r->Link.lFlags & RTMP_LF_LIVE)
2999 SendFCSubscribe(r, &r->Link.playpath);
3000 }
3001 }
3002 else if (AVMATCH(&methodInvoked, &av_createStream))
3003 {
3004 r->m_stream_id = (int)AMFProp_GetNumber(AMF_GetProp(&obj, NULL, 3));
3005
3006 if (r->Link.protocol & RTMP_FEATURE_WRITE)
3007 {
3008 SendPublish(r);
3009 }
3010 else
3011 {
3012 if (r->Link.lFlags & RTMP_LF_PLST)
3013 SendPlaylist(r);
3014 SendPlay(r);
3015 RTMP_SendCtrl(r, 3, r->m_stream_id, r->m_nBufferMS);
3016 }
3017 }
3018 else if (AVMATCH(&methodInvoked, &av_play) ||
3019 AVMATCH(&methodInvoked, &av_publish))
3020 {
3021 r->m_bPlaying = TRUE;
3022 }
3023 free(methodInvoked.av_val);
3024 }
3025 else if (AVMATCH(&method, &av_onBWDone))
3026 {
3027 if (!r->m_nBWCheckCounter)
3028 SendCheckBW(r);
3029 }
3030 else if (AVMATCH(&method, &av_onFCSubscribe))
3031 {
3032 /* SendOnFCSubscribe(); */
3033 }
3034 else if (AVMATCH(&method, &av_onFCUnsubscribe))
3035 {
3036 RTMP_Close(r);
3037 ret = 1;
3038 }
3039 else if (AVMATCH(&method, &av_ping))
3040 {
3041 SendPong(r, txn);
3042 }
3043 else if (AVMATCH(&method, &av__onbwcheck))
3044 {
3045 SendCheckBWResult(r, txn);
3046 }
3047 else if (AVMATCH(&method, &av__onbwdone))
3048 {
3049 int i;
3050 for (i = 0; i < r->m_numCalls; i++)
3051 if (AVMATCH(&r->m_methodCalls[i].name, &av__checkbw))
3052 {
3053 AV_erase(r->m_methodCalls, &r->m_numCalls, i, TRUE);
3054 break;
3055 }
3056 }
3057 else if (AVMATCH(&method, &av__error))
3058 {
3059 #ifdef CRYPTO
3060 AVal methodInvoked = {0};
3061 int i;
3062
3063 if (r->Link.protocol & RTMP_FEATURE_WRITE)
3064 {
3065 for (i=0; i<r->m_numCalls; i++)
3066 {
3067 if (r->m_methodCalls[i].num == txn)
3068 {
3069 methodInvoked = r->m_methodCalls[i].name;
3070 AV_erase(r->m_methodCalls, &r->m_numCalls, i, FALSE);
3071 break;
3072 }
3073 }
3074 if (!methodInvoked.av_val)
3075 {
3076 RTMP_Log(RTMP_LOGDEBUG, "%s, received result id %f without matching request",
3077 __FUNCTION__, txn);
3078 goto leave;
3079 }
3080
3081 RTMP_Log(RTMP_LOGDEBUG, "%s, received error for method call <%s>", __FUNCTION__,
3082 methodInvoked.av_val);
3083
3084 if (AVMATCH(&methodInvoked, &av_connect))
3085 {
3086 AMFObject obj2;
3087 AVal code, level, description;
3088 AMFProp_GetObject(AMF_GetProp(&obj, NULL, 3), &obj2);
3089 AMFProp_GetString(AMF_GetProp(&obj2, &av_code, -1), &code);
3090 AMFProp_GetString(AMF_GetProp(&obj2, &av_level, -1), &level);
3091 AMFProp_GetString(AMF_GetProp(&obj2, &av_description, -1), &description);
3092 RTMP_Log(RTMP_LOGDEBUG, "%s, error description: %s", __FUNCTION__, description.av_val);
3093 /* if PublisherAuth returns 1, then reconnect */
3094 if (PublisherAuth(r, &description) == 1)
3095 {
3096 CloseInternal(r, 1);
3097 if (!RTMP_Connect(r, NULL) || !RTMP_ConnectStream(r, 0))
3098 goto leave;
3099 }
3100 }
3101 }
3102 else
3103 {
3104 RTMP_Log(RTMP_LOGERROR, "rtmp server sent error");
3105 }
3106 free(methodInvoked.av_val);
3107 #else
3108 RTMP_Log(RTMP_LOGERROR, "rtmp server sent error");
3109 #endif
3110 }
3111 else if (AVMATCH(&method, &av_close))
3112 {
3113 RTMP_Log(RTMP_LOGERROR, "rtmp server requested close");
3114 RTMP_Close(r);
3115 }
3116 else if (AVMATCH(&method, &av_onStatus))
3117 {
3118 AMFObject obj2;
3119 AVal code, level;
3120 AMFProp_GetObject(AMF_GetProp(&obj, NULL, 3), &obj2);
3121 AMFProp_GetString(AMF_GetProp(&obj2, &av_code, -1), &code);
3122 AMFProp_GetString(AMF_GetProp(&obj2, &av_level, -1), &level);
3123
3124 RTMP_Log(RTMP_LOGDEBUG, "%s, onStatus: %s", __FUNCTION__, code.av_val);
3125 if (AVMATCH(&code, &av_NetStream_Failed)
3126 || AVMATCH(&code, &av_NetStream_Play_Failed)
3127 || AVMATCH(&code, &av_NetStream_Play_StreamNotFound)
3128 || AVMATCH(&code, &av_NetConnection_Connect_InvalidApp))
3129 {
3130 r->m_stream_id = -1;
3131 RTMP_Close(r);
3132 RTMP_Log(RTMP_LOGERROR, "Closing connection: %s", code.av_val);
3133 }
3134
3135 else if (AVMATCH(&code, &av_NetStream_Play_Start)
3136 || AVMATCH(&code, &av_NetStream_Play_PublishNotify))
3137 {
3138 int i;
3139 r->m_bPlaying = TRUE;
3140 for (i = 0; i < r->m_numCalls; i++)
3141 {
3142 if (AVMATCH(&r->m_methodCalls[i].name, &av_play))
3143 {
3144 AV_erase(r->m_methodCalls, &r->m_numCalls, i, TRUE);
3145 break;
3146 }
3147 }
3148 }
3149
3150 else if (AVMATCH(&code, &av_NetStream_Publish_Start))
3151 {
3152 int i;
3153 r->m_bPlaying = TRUE;
3154 for (i = 0; i < r->m_numCalls; i++)
3155 {
3156 if (AVMATCH(&r->m_methodCalls[i].name, &av_publish))
3157 {
3158 AV_erase(r->m_methodCalls, &r->m_numCalls, i, TRUE);
3159 break;
3160 }
3161 }
3162 }
3163
3164 /* Return 1 if this is a Play.Complete or Play.Stop */
3165 else if (AVMATCH(&code, &av_NetStream_Play_Complete)
3166 || AVMATCH(&code, &av_NetStream_Play_Stop)
3167 || AVMATCH(&code, &av_NetStream_Play_UnpublishNotify))
3168 {
3169 RTMP_Close(r);
3170 ret = 1;
3171 }
3172
3173 else if (AVMATCH(&code, &av_NetStream_Seek_Notify))
3174 {
3175 r->m_read.flags &= ~RTMP_READ_SEEKING;
3176 }
3177
3178 else if (AVMATCH(&code, &av_NetStream_Pause_Notify))
3179 {
3180 if (r->m_pausing == 1 || r->m_pausing == 2)
3181 {
3182 RTMP_SendPause(r, FALSE, r->m_pauseStamp);
3183 r->m_pausing = 3;
3184 }
3185 }
3186 }
3187 else if (AVMATCH(&method, &av_playlist_ready))
3188 {
3189 int i;
3190 for (i = 0; i < r->m_numCalls; i++)
3191 {
3192 if (AVMATCH(&r->m_methodCalls[i].name, &av_set_playlist))
3193 {
3194 AV_erase(r->m_methodCalls, &r->m_numCalls, i, TRUE);
3195 break;
3196 }
3197 }
3198 }
3199 else
3200 {
3201
3202 }
3203 leave:
3204 AMF_Reset(&obj);
3205 return ret;
3206 }
3207
3208 int
3209 RTMP_FindFirstMatchingProperty(AMFObject *obj, const AVal *name,
3210 AMFObjectProperty * p)
3211 {
3212 int n;
3213 /* this is a small object search to locate the "duration" property */
3214 for (n = 0; n < obj->o_num; n++)
3215 {
3216 AMFObjectProperty *prop = AMF_GetProp(obj, NULL, n);
3217
3218 if (AVMATCH(&prop->p_name, name))
3219 {
3220 memcpy(p, prop, sizeof(*prop));
3221 return TRUE;
3222 }
3223
3224 if (prop->p_type == AMF_OBJECT || prop->p_type == AMF_ECMA_ARRAY)
3225 {
3226 if (RTMP_FindFirstMatchingProperty(&prop->p_vu.p_object, name, p))
3227 return TRUE;
3228 }
3229 }
3230 return FALSE;
3231 }
3232
3233 /* Like above, but only check if name is a prefix of property */
3234 int
3235 RTMP_FindPrefixProperty(AMFObject *obj, const AVal *name,
3236 AMFObjectProperty * p)
3237 {
3238 int n;
3239 for (n = 0; n < obj->o_num; n++)
3240 {
3241 AMFObjectProperty *prop = AMF_GetProp(obj, NULL, n);
3242
3243 if (prop->p_name.av_len > name->av_len &&
3244 !memcmp(prop->p_name.av_val, name->av_val, name->av_len))
3245 {
3246 memcpy(p, prop, sizeof(*prop));
3247 return TRUE;
3248 }
3249
3250 if (prop->p_type == AMF_OBJECT)
3251 {
3252 if (RTMP_FindPrefixProperty(&prop->p_vu.p_object, name, p))
3253 return TRUE;
3254 }
3255 }
3256 return FALSE;
3257 }
3258
3259 static int
3260 DumpMetaData(AMFObject *obj)
3261 {
3262 AMFObjectProperty *prop;
3263 int n, len;
3264 for (n = 0; n < obj->o_num; n++)
3265 {
3266 char str[256] = "";
3267 prop = AMF_GetProp(obj, NULL, n);
3268 switch (prop->p_type)
3269 {
3270 case AMF_OBJECT:
3271 case AMF_ECMA_ARRAY:
3272 case AMF_STRICT_ARRAY:
3273 if (prop->p_name.av_len)
3274 RTMP_Log(RTMP_LOGINFO, "%.*s:", prop->p_name.av_len, prop->p_name.av_val);
3275 DumpMetaData(&prop->p_vu.p_object);
3276 break;
3277 case AMF_NUMBER:
3278 snprintf(str, 255, "%.2f", prop->p_vu.p_number);
3279 break;
3280 case AMF_BOOLEAN:
3281 snprintf(str, 255, "%s",
3282 prop->p_vu.p_number != 0. ? "TRUE" : "FALSE");
3283 break;
3284 case AMF_STRING:
3285 len = snprintf(str, 255, "%.*s", prop->p_vu.p_aval.av_len,
3286 prop->p_vu.p_aval.av_val);
3287 if (len >= 1 && str[len-1] == '\n')
3288 str[len-1] = '\0';
3289 break;
3290 case AMF_DATE:
3291 snprintf(str, 255, "timestamp:%.2f", prop->p_vu.p_number);
3292 break;
3293 default:
3294 snprintf(str, 255, "INVALID TYPE 0x%02x",
3295 (unsigned char)prop->p_type);
3296 }
3297 if (str[0] && prop->p_name.av_len)
3298 {
3299 RTMP_Log(RTMP_LOGINFO, " %-22.*s%s", prop->p_name.av_len,
3300 prop->p_name.av_val, str);
3301 }
3302 }
3303 return FALSE;
3304 }
3305
3306 SAVC(onMetaData);
3307 SAVC(duration);
3308 SAVC(video);
3309 SAVC(audio);
3310
3311 static int
3312 HandleMetadata(RTMP *r, char *body, unsigned int len)
3313 {
3314 /* allright we get some info here, so parse it and print it */
3315 /* also keep duration or filesize to make a nice progress bar */
3316
3317 AMFObject obj;
3318 AVal metastring;
3319 int ret = FALSE;
3320
3321 int nRes = AMF_Decode(&obj, body, len, FALSE);
3322 if (nRes < 0)
3323 {
3324 RTMP_Log(RTMP_LOGERROR, "%s, error decoding meta data packet", __FUNCTION__);
3325 return FALSE;
3326 }
3327
3328 AMF_Dump(&obj);
3329 AMFProp_GetString(AMF_GetProp(&obj, NULL, 0), &metastring);
3330
3331 if (AVMATCH(&metastring, &av_onMetaData))
3332 {
3333 AMFObjectProperty prop;
3334 /* Show metadata */
3335 RTMP_Log(RTMP_LOGINFO, "Metadata:");
3336 DumpMetaData(&obj);
3337 if (RTMP_FindFirstMatchingProperty(&obj, &av_duration, &prop))
3338 {
3339 r->m_fDuration = prop.p_vu.p_number;
3340 /*RTMP_Log(RTMP_LOGDEBUG, "Set duration: %.2f", m_fDuration); */
3341 }
3342 /* Search for audio or video tags */
3343 if (RTMP_FindPrefixProperty(&obj, &av_video, &prop))
3344 r->m_read.dataType |= 1;
3345 if (RTMP_FindPrefixProperty(&obj, &av_audio, &prop))
3346 r->m_read.dataType |= 4;
3347 ret = TRUE;
3348 }
3349 AMF_Reset(&obj);
3350 return ret;
3351 }
3352
3353 static void
3354 HandleChangeChunkSize(RTMP *r, const RTMPPacket *packet)
3355 {
3356 if (packet->m_nBodySize >= 4)
3357 {
3358 r->m_inChunkSize = AMF_DecodeInt32(packet->m_body);
3359 RTMP_Log(RTMP_LOGDEBUG, "%s, received: chunk size change to %d", __FUNCTION__,
3360 r->m_inChunkSize);
3361 }
3362 }
3363
3364 static void
3365 HandleAudio(RTMP *r, const RTMPPacket *packet)
3366 {
3367 }
3368
3369 static void
3370 HandleVideo(RTMP *r, const RTMPPacket *packet)
3371 {
3372 }
3373
3374 static void
3375 HandleCtrl(RTMP *r, const RTMPPacket *packet)
3376 {
3377 short nType = -1;
3378 unsigned int tmp;
3379 if (packet->m_body && packet->m_nBodySize >= 2)
3380 nType = AMF_DecodeInt16(packet->m_body);
3381 RTMP_Log(RTMP_LOGDEBUG, "%s, received ctrl. type: %d, len: %d", __FUNCTION__, nType,
3382 packet->m_nBodySize);
3383 /*RTMP_LogHex(packet.m_body, packet.m_nBodySize); */
3384
3385 if (packet->m_nBodySize >= 6)
3386 {
3387 switch (nType)
3388 {
3389 case 0:
3390 tmp = AMF_DecodeInt32(packet->m_body + 2);
3391 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream Begin %d", __FUNCTION__, tmp);
3392 break;
3393
3394 case 1:
3395 tmp = AMF_DecodeInt32(packet->m_body + 2);
3396 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream EOF %d", __FUNCTION__, tmp);
3397 if (r->m_pausing == 1)
3398 r->m_pausing = 2;
3399 break;
3400
3401 case 2:
3402 tmp = AMF_DecodeInt32(packet->m_body + 2);
3403 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream Dry %d", __FUNCTION__, tmp);
3404 break;
3405
3406 case 4:
3407 tmp = AMF_DecodeInt32(packet->m_body + 2);
3408 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream IsRecorded %d", __FUNCTION__, tmp);
3409 break;
3410
3411 case 6: /* server ping. reply with pong. */
3412 tmp = AMF_DecodeInt32(packet->m_body + 2);
3413 RTMP_Log(RTMP_LOGDEBUG, "%s, Ping %d", __FUNCTION__, tmp);
3414 RTMP_SendCtrl(r, 0x07, tmp, 0);
3415 break;
3416
3417 /* FMS 3.5 servers send the following two controls to let the client
3418 * know when the server has sent a complete buffer. I.e., when the
3419 * server has sent an amount of data equal to m_nBufferMS in duration.
3420 * The server meters its output so that data arrives at the client
3421 * in realtime and no faster.
3422 *
3423 * The rtmpdump program tries to set m_nBufferMS as large as
3424 * possible, to force the server to send data as fast as possible.
3425 * In practice, the server appears to cap this at about 1 hour's
3426 * worth of data. After the server has sent a complete buffer, and
3427 * sends this BufferEmpty message, it will wait until the play
3428 * duration of that buffer has passed before sending a new buffer.
3429 * The BufferReady message will be sent when the new buffer starts.
3430 * (There is no BufferReady message for the very first buffer;
3431 * presumably the Stream Begin message is sufficient for that
3432 * purpose.)
3433 *
3434 * If the network speed is much faster than the data bitrate, then
3435 * there may be long delays between the end of one buffer and the
3436 * start of the next.
3437 *
3438 * Since usually the network allows data to be sent at
3439 * faster than realtime, and rtmpdump wants to download the data
3440 * as fast as possible, we use this RTMP_LF_BUFX hack: when we
3441 * get the BufferEmpty message, we send a Pause followed by an
3442 * Unpause. This causes the server to send the next buffer immediately
3443 * instead of waiting for the full duration to elapse. (That's
3444 * also the purpose of the ToggleStream function, which rtmpdump
3445 * calls if we get a read timeout.)
3446 *
3447 * Media player apps don't need this hack since they are just
3448 * going to play the data in realtime anyway. It also doesn't work
3449 * for live streams since they obviously can only be sent in
3450 * realtime. And it's all moot if the network speed is actually
3451 * slower than the media bitrate.
3452 */
3453 case 31:
3454 tmp = AMF_DecodeInt32(packet->m_body + 2);
3455 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream BufferEmpty %d", __FUNCTION__, tmp);
3456 if (!(r->Link.lFlags & RTMP_LF_BUFX))
3457 break;
3458 if (!r->m_pausing)
3459 {
3460 r->m_pauseStamp = r->m_mediaChannel < r->m_channelsAllocatedIn ?
3461 r->m_channelTimestamp[r->m_mediaChannel] : 0;
3462 RTMP_SendPause(r, TRUE, r->m_pauseStamp);
3463 r->m_pausing = 1;
3464 }
3465 else if (r->m_pausing == 2)
3466 {
3467 RTMP_SendPause(r, FALSE, r->m_pauseStamp);
3468 r->m_pausing = 3;
3469 }
3470 break;
3471
3472 case 32:
3473 tmp = AMF_DecodeInt32(packet->m_body + 2);
3474 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream BufferReady %d", __FUNCTION__, tmp);
3475 break;
3476
3477 default:
3478 tmp = AMF_DecodeInt32(packet->m_body + 2);
3479 RTMP_Log(RTMP_LOGDEBUG, "%s, Stream xx %d", __FUNCTION__, tmp);
3480 break;
3481 }
3482
3483 }
3484
3485 if (nType == 0x1A)
3486 {
3487 RTMP_Log(RTMP_LOGDEBUG, "%s, SWFVerification ping received: ", __FUNCTION__);
3488 if (packet->m_nBodySize > 2 && packet->m_body[2] > 0x01)
3489 {
3490 RTMP_Log(RTMP_LOGERROR,
3491 "%s: SWFVerification Type %d request not supported! Patches welcome...",
3492 __FUNCTION__, packet->m_body[2]);
3493 }
3494 #ifdef CRYPTO
3495 /*RTMP_LogHex(packet.m_body, packet.m_nBodySize); */
3496
3497 /* respond with HMAC SHA256 of decompressed SWF, key is the 30byte player key, also the last 30 bytes of the server handshake are applied */
3498 else if (r->Link.SWFSize)
3499 {
3500 RTMP_SendCtrl(r, 0x1B, 0, 0);
3501 }
3502 else
3503 {
3504 RTMP_Log(RTMP_LOGERROR,
3505 "%s: Ignoring SWFVerification request, use --swfVfy!",
3506 __FUNCTION__);
3507 }
3508 #else
3509 RTMP_Log(RTMP_LOGERROR,
3510 "%s: Ignoring SWFVerification request, no CRYPTO support!",
3511 __FUNCTION__);
3512 #endif
3513 }
3514 }
3515
3516 static void
3517 HandleServerBW(RTMP *r, const RTMPPacket *packet)
3518 {
3519 r->m_nServerBW = AMF_DecodeInt32(packet->m_body);
3520 RTMP_Log(RTMP_LOGDEBUG, "%s: server BW = %d", __FUNCTION__, r->m_nServerBW);
3521 }
3522
3523 static void
3524 HandleClientBW(RTMP *r, const RTMPPacket *packet)
3525 {
3526 r->m_nClientBW = AMF_DecodeInt32(packet->m_body);
3527 if (packet->m_nBodySize > 4)
3528 r->m_nClientBW2 = packet->m_body[4];
3529 else
3530 r->m_nClientBW2 = -1;
3531 RTMP_Log(RTMP_LOGDEBUG, "%s: client BW = %d %d", __FUNCTION__, r->m_nClientBW,
3532 r->m_nClientBW2);
3533 }
3534
3535 static int
3536 DecodeInt32LE(const char *data)
3537 {
3538 unsigned char *c = (unsigned char *)data;
3539 unsigned int val;
3540
3541 val = (c[3] << 24) | (c[2] << 16) | (c[1] << 8) | c[0];
3542 return val;
3543 }
3544
3545 static int
3546 EncodeInt32LE(char *output, int nVal)
3547 {
3548 output[0] = nVal;
3549 nVal >>= 8;
3550 output[1] = nVal;
3551 nVal >>= 8;
3552 output[2] = nVal;
3553 nVal >>= 8;
3554 output[3] = nVal;
3555 return 4;
3556 }
3557
3558 int
3559 RTMP_ReadPacket(RTMP *r, RTMPPacket *packet)
3560 {
3561 uint8_t hbuf[RTMP_MAX_HEADER_SIZE] = { 0 };
3562 char *header = (char *)hbuf;
3563 int nSize, hSize, nToRead, nChunk;
3564 int didAlloc = FALSE;
3565 int extendedTimestamp;
3566
3567 RTMP_Log(RTMP_LOGDEBUG2, "%s: fd=%d", __FUNCTION__, r->m_sb.sb_socket);
3568
3569 if (ReadN(r, (char *)hbuf, 1) == 0)
3570 {
3571 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet header", __FUNCTION__);
3572 return FALSE;
3573 }
3574
3575 packet->m_headerType = (hbuf[0] & 0xc0) >> 6;
3576 packet->m_nChannel = (hbuf[0] & 0x3f);
3577 header++;
3578 if (packet->m_nChannel == 0)
3579 {
3580 if (ReadN(r, (char *)&hbuf[1], 1) != 1)
3581 {
3582 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet header 2nd byte",
3583 __FUNCTION__);
3584 return FALSE;
3585 }
3586 packet->m_nChannel = hbuf[1];
3587 packet->m_nChannel += 64;
3588 header++;
3589 }
3590 else if (packet->m_nChannel == 1)
3591 {
3592 int tmp;
3593 if (ReadN(r, (char *)&hbuf[1], 2) != 2)
3594 {
3595 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet header 3nd byte",
3596 __FUNCTION__);
3597 return FALSE;
3598 }
3599 tmp = (hbuf[2] << 8) + hbuf[1];
3600 packet->m_nChannel = tmp + 64;
3601 RTMP_Log(RTMP_LOGDEBUG, "%s, m_nChannel: %0x", __FUNCTION__, packet->m_nChannel);
3602 header += 2;
3603 }
3604
3605 nSize = packetSize[packet->m_headerType];
3606
3607 if (packet->m_nChannel >= r->m_channelsAllocatedIn)
3608 {
3609 int n = packet->m_nChannel + 10;
3610 int *timestamp = realloc(r->m_channelTimestamp, sizeof(int) * n);
3611 RTMPPacket **packets = realloc(r->m_vecChannelsIn, sizeof(RTMPPacket*) * n);
3612 if (!timestamp)
3613 free(r->m_channelTimestamp);
3614 if (!packets)
3615 free(r->m_vecChannelsIn);
3616 r->m_channelTimestamp = timestamp;
3617 r->m_vecChannelsIn = packets;
3618 if (!timestamp || !packets) {
3619 r->m_channelsAllocatedIn = 0;
3620 return FALSE;
3621 }
3622 memset(r->m_channelTimestamp + r->m_channelsAllocatedIn, 0, sizeof(int) * (n - r->m_channelsAllocatedIn));
3623 memset(r->m_vecChannelsIn + r->m_channelsAllocatedIn, 0, sizeof(RTMPPacket*) * (n - r->m_channelsAllocatedIn));
3624 r->m_channelsAllocatedIn = n;
3625 }
3626
3627 if (nSize == RTMP_LARGE_HEADER_SIZE) /* if we get a full header the timestamp is absolute */
3628 packet->m_hasAbsTimestamp = TRUE;
3629
3630 else if (nSize < RTMP_LARGE_HEADER_SIZE)
3631 { /* using values from the last message of this channel */
3632 if (r->m_vecChannelsIn[packet->m_nChannel])
3633 memcpy(packet, r->m_vecChannelsIn[packet->m_nChannel],
3634 sizeof(RTMPPacket));
3635 }
3636
3637 nSize--;
3638
3639 if (nSize > 0 && ReadN(r, header, nSize) != nSize)
3640 {
3641 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet header. type: %x",
3642 __FUNCTION__, (unsigned int)hbuf[0]);
3643 return FALSE;
3644 }
3645
3646 hSize = nSize + (header - (char *)hbuf);
3647
3648 if (nSize >= 3)
3649 {
3650 packet->m_nTimeStamp = AMF_DecodeInt24(header);
3651
3652 /*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); */
3653
3654 if (nSize >= 6)
3655 {
3656 packet->m_nBodySize = AMF_DecodeInt24(header + 3);
3657 packet->m_nBytesRead = 0;
3658 RTMPPacket_Free(packet);
3659
3660 if (nSize > 6)
3661 {
3662 packet->m_packetType = header[6];
3663
3664 if (nSize == 11)
3665 packet->m_nInfoField2 = DecodeInt32LE(header + 7);
3666 }
3667 }
3668 }
3669
3670 extendedTimestamp = packet->m_nTimeStamp == 0xffffff;
3671 if (extendedTimestamp)
3672 {
3673 if (ReadN(r, header + nSize, 4) != 4)
3674 {
3675 RTMP_Log(RTMP_LOGERROR, "%s, failed to read extended timestamp",
3676 __FUNCTION__);
3677 return FALSE;
3678 }
3679 packet->m_nTimeStamp = AMF_DecodeInt32(header + nSize);
3680 hSize += 4;
3681 }
3682
3683 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)hbuf, hSize);
3684
3685 if (packet->m_nBodySize > 0 && packet->m_body == NULL)
3686 {
3687 if (!RTMPPacket_Alloc(packet, packet->m_nBodySize))
3688 {
3689 RTMP_Log(RTMP_LOGDEBUG, "%s, failed to allocate packet", __FUNCTION__);
3690 return FALSE;
3691 }
3692 didAlloc = TRUE;
3693 packet->m_headerType = (hbuf[0] & 0xc0) >> 6;
3694 }
3695
3696 nToRead = packet->m_nBodySize - packet->m_nBytesRead;
3697 nChunk = r->m_inChunkSize;
3698 if (nToRead < nChunk)
3699 nChunk = nToRead;
3700
3701 /* Does the caller want the raw chunk? */
3702 if (packet->m_chunk)
3703 {
3704 packet->m_chunk->c_headerSize = hSize;
3705 memcpy(packet->m_chunk->c_header, hbuf, hSize);
3706 packet->m_chunk->c_chunk = packet->m_body + packet->m_nBytesRead;
3707 packet->m_chunk->c_chunkSize = nChunk;
3708 }
3709
3710 if (ReadN(r, packet->m_body + packet->m_nBytesRead, nChunk) != nChunk)
3711 {
3712 RTMP_Log(RTMP_LOGERROR, "%s, failed to read RTMP packet body. len: %u",
3713 __FUNCTION__, packet->m_nBodySize);
3714 return FALSE;
3715 }
3716
3717 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)packet->m_body + packet->m_nBytesRead, nChunk);
3718
3719 packet->m_nBytesRead += nChunk;
3720
3721 /* keep the packet as ref for other packets on this channel */
3722 if (!r->m_vecChannelsIn[packet->m_nChannel])
3723 r->m_vecChannelsIn[packet->m_nChannel] = malloc(sizeof(RTMPPacket));
3724 memcpy(r->m_vecChannelsIn[packet->m_nChannel], packet, sizeof(RTMPPacket));
3725 if (extendedTimestamp)
3726 {
3727 r->m_vecChannelsIn[packet->m_nChannel]->m_nTimeStamp = 0xffffff;
3728 }
3729
3730 if (RTMPPacket_IsReady(packet))
3731 {
3732 /* make packet's timestamp absolute */
3733 if (!packet->m_hasAbsTimestamp)
3734 packet->m_nTimeStamp += r->m_channelTimestamp[packet->m_nChannel]; /* timestamps seem to be always relative!! */
3735
3736 r->m_channelTimestamp[packet->m_nChannel] = packet->m_nTimeStamp;
3737
3738 /* reset the data from the stored packet. we keep the header since we may use it later if a new packet for this channel */
3739 /* arrives and requests to re-use some info (small packet header) */
3740 r->m_vecChannelsIn[packet->m_nChannel]->m_body = NULL;
3741 r->m_vecChannelsIn[packet->m_nChannel]->m_nBytesRead = 0;
3742 r->m_vecChannelsIn[packet->m_nChannel]->m_hasAbsTimestamp = FALSE; /* can only be false if we reuse header */
3743 }
3744 else
3745 {
3746 packet->m_body = NULL; /* so it won't be erased on free */
3747 }
3748
3749 return TRUE;
3750 }
3751
3752 #ifndef CRYPTO
3753 static int
3754 HandShake(RTMP *r, int FP9HandShake)
3755 {
3756 int i;
3757 uint32_t uptime, suptime;
3758 int bMatch;
3759 char type;
3760 char clientbuf[RTMP_SIG_SIZE + 1], *clientsig = clientbuf + 1;
3761 char serversig[RTMP_SIG_SIZE];
3762
3763 clientbuf[0] = 0x03; /* not encrypted */
3764
3765 uptime = htonl(RTMP_GetTime());
3766 memcpy(clientsig, &uptime, 4);
3767
3768 memset(&clientsig[4], 0, 4);
3769
3770 #ifdef _DEBUG
3771 for (i = 8; i < RTMP_SIG_SIZE; i++)
3772 clientsig[i] = 0xff;
3773 #else
3774 for (i = 8; i < RTMP_SIG_SIZE; i++)
3775 clientsig[i] = (char)(rand() % 256);
3776 #endif
3777
3778 if (!WriteN(r, clientbuf, RTMP_SIG_SIZE + 1))
3779 return FALSE;
3780
3781 if (ReadN(r, &type, 1) != 1) /* 0x03 or 0x06 */
3782 return FALSE;
3783
3784 RTMP_Log(RTMP_LOGDEBUG, "%s: Type Answer : %02X", __FUNCTION__, type);
3785
3786 if (type != clientbuf[0])
3787 RTMP_Log(RTMP_LOGWARNING, "%s: Type mismatch: client sent %d, server answered %d",
3788 __FUNCTION__, clientbuf[0], type);
3789
3790 if (ReadN(r, serversig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
3791 return FALSE;
3792
3793 /* decode server response */
3794
3795 memcpy(&suptime, serversig, 4);
3796 suptime = ntohl(suptime);
3797
3798 RTMP_Log(RTMP_LOGDEBUG, "%s: Server Uptime : %d", __FUNCTION__, suptime);
3799 RTMP_Log(RTMP_LOGDEBUG, "%s: FMS Version : %d.%d.%d.%d", __FUNCTION__,
3800 serversig[4], serversig[5], serversig[6], serversig[7]);
3801
3802 /* 2nd part of handshake */
3803 if (!WriteN(r, serversig, RTMP_SIG_SIZE))
3804 return FALSE;
3805
3806 if (ReadN(r, serversig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
3807 return FALSE;
3808
3809 bMatch = (memcmp(serversig, clientsig, RTMP_SIG_SIZE) == 0);
3810 if (!bMatch)
3811 {
3812 RTMP_Log(RTMP_LOGWARNING, "%s, client signature does not match!", __FUNCTION__);
3813 }
3814 return TRUE;
3815 }
3816
3817 static int
3818 SHandShake(RTMP *r)
3819 {
3820 int i;
3821 char serverbuf[RTMP_SIG_SIZE + 1], *serversig = serverbuf + 1;
3822 char clientsig[RTMP_SIG_SIZE];
3823 uint32_t uptime;
3824 int bMatch;
3825
3826 if (ReadN(r, serverbuf, 1) != 1) /* 0x03 or 0x06 */
3827 return FALSE;
3828
3829 RTMP_Log(RTMP_LOGDEBUG, "%s: Type Request : %02X", __FUNCTION__, serverbuf[0]);
3830
3831 if (serverbuf[0] != 3)
3832 {
3833 RTMP_Log(RTMP_LOGERROR, "%s: Type unknown: client sent %02X",
3834 __FUNCTION__, serverbuf[0]);
3835 return FALSE;
3836 }
3837
3838 uptime = htonl(RTMP_GetTime());
3839 memcpy(serversig, &uptime, 4);
3840
3841 memset(&serversig[4], 0, 4);
3842 #ifdef _DEBUG
3843 for (i = 8; i < RTMP_SIG_SIZE; i++)
3844 serversig[i] = 0xff;
3845 #else
3846 for (i = 8; i < RTMP_SIG_SIZE; i++)
3847 serversig[i] = (char)(rand() % 256);
3848 #endif
3849
3850 if (!WriteN(r, serverbuf, RTMP_SIG_SIZE + 1))
3851 return FALSE;
3852
3853 if (ReadN(r, clientsig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
3854 return FALSE;
3855
3856 /* decode client response */
3857
3858 memcpy(&uptime, clientsig, 4);
3859 uptime = ntohl(uptime);
3860
3861 RTMP_Log(RTMP_LOGDEBUG, "%s: Client Uptime : %d", __FUNCTION__, uptime);
3862 RTMP_Log(RTMP_LOGDEBUG, "%s: Player Version: %d.%d.%d.%d", __FUNCTION__,
3863 clientsig[4], clientsig[5], clientsig[6], clientsig[7]);
3864
3865 /* 2nd part of handshake */
3866 if (!WriteN(r, clientsig, RTMP_SIG_SIZE))
3867 return FALSE;
3868
3869 if (ReadN(r, clientsig, RTMP_SIG_SIZE) != RTMP_SIG_SIZE)
3870 return FALSE;
3871
3872 bMatch = (memcmp(serversig, clientsig, RTMP_SIG_SIZE) == 0);
3873 if (!bMatch)
3874 {
3875 RTMP_Log(RTMP_LOGWARNING, "%s, client signature does not match!", __FUNCTION__);
3876 }
3877 return TRUE;
3878 }
3879 #endif
3880
3881 int
3882 RTMP_SendChunk(RTMP *r, RTMPChunk *chunk)
3883 {
3884 int wrote;
3885 char hbuf[RTMP_MAX_HEADER_SIZE];
3886
3887 RTMP_Log(RTMP_LOGDEBUG2, "%s: fd=%d, size=%d", __FUNCTION__, r->m_sb.sb_socket,
3888 chunk->c_chunkSize);
3889 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)chunk->c_header, chunk->c_headerSize);
3890 if (chunk->c_chunkSize)
3891 {
3892 char *ptr = chunk->c_chunk - chunk->c_headerSize;
3893 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)chunk->c_chunk, chunk->c_chunkSize);
3894 /* save header bytes we're about to overwrite */
3895 memcpy(hbuf, ptr, chunk->c_headerSize);
3896 memcpy(ptr, chunk->c_header, chunk->c_headerSize);
3897 wrote = WriteN(r, ptr, chunk->c_headerSize + chunk->c_chunkSize);
3898 memcpy(ptr, hbuf, chunk->c_headerSize);
3899 }
3900 else
3901 wrote = WriteN(r, chunk->c_header, chunk->c_headerSize);
3902 return wrote;
3903 }
3904
3905 int
3906 RTMP_SendPacket(RTMP *r, RTMPPacket *packet, int queue)
3907 {
3908 const RTMPPacket *prevPacket;
3909 uint32_t last = 0;
3910 int nSize;
3911 int hSize, cSize;
3912 char *header, *hptr, *hend, hbuf[RTMP_MAX_HEADER_SIZE], c;
3913 uint32_t t;
3914 char *buffer, *tbuf = NULL, *toff = NULL;
3915 int nChunkSize;
3916 int tlen;
3917
3918 if (packet->m_nChannel >= r->m_channelsAllocatedOut)
3919 {
3920 int n = packet->m_nChannel + 10;
3921 RTMPPacket **packets = realloc(r->m_vecChannelsOut, sizeof(RTMPPacket*) * n);
3922 if (!packets) {
3923 free(r->m_vecChannelsOut);
3924 r->m_vecChannelsOut = NULL;
3925 r->m_channelsAllocatedOut = 0;
3926 return FALSE;
3927 }
3928 r->m_vecChannelsOut = packets;
3929 memset(r->m_vecChannelsOut + r->m_channelsAllocatedOut, 0, sizeof(RTMPPacket*) * (n - r->m_channelsAllocatedOut));
3930 r->m_channelsAllocatedOut = n;
3931 }
3932
3933 prevPacket = r->m_vecChannelsOut[packet->m_nChannel];
3934 if (prevPacket && packet->m_headerType != RTMP_PACKET_SIZE_LARGE)
3935 {
3936 /* compress a bit by using the prev packet's attributes */
3937 if (prevPacket->m_nBodySize == packet->m_nBodySize
3938 && prevPacket->m_packetType == packet->m_packetType
3939 && packet->m_headerType == RTMP_PACKET_SIZE_MEDIUM)
3940 packet->m_headerType = RTMP_PACKET_SIZE_SMALL;
3941
3942 if (prevPacket->m_nTimeStamp == packet->m_nTimeStamp
3943 && packet->m_headerType == RTMP_PACKET_SIZE_SMALL)
3944 packet->m_headerType = RTMP_PACKET_SIZE_MINIMUM;
3945 last = prevPacket->m_nTimeStamp;
3946 }
3947
3948 if (packet->m_headerType > 3) /* sanity */
3949 {
3950 RTMP_Log(RTMP_LOGERROR, "sanity failed!! trying to send header of type: 0x%02x.",
3951 (unsigned char)packet->m_headerType);
3952 return FALSE;
3953 }
3954
3955 nSize = packetSize[packet->m_headerType];
3956 hSize = nSize; cSize = 0;
3957 t = packet->m_nTimeStamp - last;
3958
3959 if (packet->m_body)
3960 {
3961 header = packet->m_body - nSize;
3962 hend = packet->m_body;
3963 }
3964 else
3965 {
3966 header = hbuf + 6;
3967 hend = hbuf + sizeof(hbuf);
3968 }
3969
3970 if (packet->m_nChannel > 319)
3971 cSize = 2;
3972 else if (packet->m_nChannel > 63)
3973 cSize = 1;
3974 if (cSize)
3975 {
3976 header -= cSize;
3977 hSize += cSize;
3978 }
3979
3980 if (nSize > 1 && t >= 0xffffff)
3981 {
3982 header -= 4;
3983 hSize += 4;
3984 }
3985
3986 hptr = header;
3987 c = packet->m_headerType << 6;
3988 switch (cSize)
3989 {
3990 case 0:
3991 c |= packet->m_nChannel;
3992 break;
3993 case 1:
3994 break;
3995 case 2:
3996 c |= 1;
3997 break;
3998 }
3999 *hptr++ = c;
4000 if (cSize)
4001 {
4002 int tmp = packet->m_nChannel - 64;
4003 *hptr++ = tmp & 0xff;
4004 if (cSize == 2)
4005 *hptr++ = tmp >> 8;
4006 }
4007
4008 if (nSize > 1)
4009 {
4010 hptr = AMF_EncodeInt24(hptr, hend, t > 0xffffff ? 0xffffff : t);
4011 }
4012
4013 if (nSize > 4)
4014 {
4015 hptr = AMF_EncodeInt24(hptr, hend, packet->m_nBodySize);
4016 *hptr++ = packet->m_packetType;
4017 }
4018
4019 if (nSize > 8)
4020 hptr += EncodeInt32LE(hptr, packet->m_nInfoField2);
4021
4022 if (nSize > 1 && t >= 0xffffff)
4023 hptr = AMF_EncodeInt32(hptr, hend, t);
4024
4025 nSize = packet->m_nBodySize;
4026 buffer = packet->m_body;
4027 nChunkSize = r->m_outChunkSize;
4028
4029 RTMP_Log(RTMP_LOGDEBUG2, "%s: fd=%d, size=%d", __FUNCTION__, r->m_sb.sb_socket,
4030 nSize);
4031 /* send all chunks in one HTTP request */
4032 if (r->Link.protocol & RTMP_FEATURE_HTTP)
4033 {
4034 int chunks = (nSize+nChunkSize-1) / nChunkSize;
4035 if (chunks > 1)
4036 {
4037 tlen = chunks * (cSize + 1) + nSize + hSize;
4038 tbuf = malloc(tlen);
4039 if (!tbuf)
4040 return FALSE;
4041 toff = tbuf;
4042 }
4043 }
4044 while (nSize + hSize)
4045 {
4046 int wrote;
4047
4048 if (nSize < nChunkSize)
4049 nChunkSize = nSize;
4050
4051 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)header, hSize);
4052 RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)buffer, nChunkSize);
4053 if (tbuf)
4054 {
4055 memcpy(toff, header, nChunkSize + hSize);
4056 toff += nChunkSize + hSize;
4057 }
4058 else
4059 {
4060 wrote = WriteN(r, header, nChunkSize + hSize);
4061 if (!wrote)
4062 return FALSE;
4063 }
4064 nSize -= nChunkSize;
4065 buffer += nChunkSize;
4066 hSize = 0;
4067
4068 if (nSize > 0)
4069 {
4070 header = buffer - 1;
4071 hSize = 1;
4072 if (cSize)
4073 {
4074 header -= cSize;
4075 hSize += cSize;
4076 }
4077 *header = (0xc0 | c);
4078 if (cSize)
4079 {
4080 int tmp = packet->m_nChannel - 64;
4081 header[1] = tmp & 0xff;
4082 if (cSize == 2)
4083 header[2] = tmp >> 8;
4084 }
4085 }
4086 }
4087 if (tbuf)
4088 {
4089 int wrote = WriteN(r, tbuf, toff-tbuf);
4090 free(tbuf);
4091 tbuf = NULL;
4092 if (!wrote)
4093 return FALSE;
4094 }
4095
4096 /* we invoked a remote method */
4097 if (packet->m_packetType == RTMP_PACKET_TYPE_INVOKE)
4098 {
4099 AVal method;
4100 char *ptr;
4101 ptr = packet->m_body + 1;
4102 AMF_DecodeString(ptr, &method);
4103 RTMP_Log(RTMP_LOGDEBUG, "Invoking %s", method.av_val);
4104 /* keep it in call queue till result arrives */
4105 if (queue) {
4106 int txn;
4107 ptr += 3 + method.av_len;
4108 txn = (int)AMF_DecodeNumber(ptr);
4109 AV_queue(&r->m_methodCalls, &r->m_numCalls, &method, txn);
4110 }
4111 }
4112
4113 if (!r->m_vecChannelsOut[packet->m_nChannel])
4114 r->m_vecChannelsOut[packet->m_nChannel] = malloc(sizeof(RTMPPacket));
4115 memcpy(r->m_vecChannelsOut[packet->m_nChannel], packet, sizeof(RTMPPacket));
4116 return TRUE;
4117 }
4118
4119 int
4120 RTMP_Serve(RTMP *r)
4121 {
4122 return SHandShake(r);
4123 }
4124
4125 void
4126 RTMP_Close(RTMP *r)
4127 {
4128 CloseInternal(r, 0);
4129 }
4130
4131 static void
4132 CloseInternal(RTMP *r, int reconnect)
4133 {
4134 int i;
4135
4136 if (RTMP_IsConnected(r))
4137 {
4138 if (r->m_stream_id > 0)
4139 {
4140 i = r->m_stream_id;
4141 r->m_stream_id = 0;
4142 if ((r->Link.protocol & RTMP_FEATURE_WRITE))
4143 SendFCUnpublish(r);
4144 SendDeleteStream(r, i);
4145 }
4146 if (r->m_clientID.av_val)
4147 {
4148 HTTP_Post(r, RTMPT_CLOSE, "", 1);
4149 free(r->m_clientID.av_val);
4150 r->m_clientID.av_val = NULL;
4151 r->m_clientID.av_len = 0;
4152 }
4153 RTMPSockBuf_Close(&r->m_sb);
4154 }
4155
4156 r->m_stream_id = -1;
4157 r->m_sb.sb_socket = -1;
4158 r->m_nBWCheckCounter = 0;
4159 r->m_nBytesIn = 0;
4160 r->m_nBytesInSent = 0;
4161
4162 if (r->m_read.flags & RTMP_READ_HEADER) {
4163 free(r->m_read.buf);
4164 r->m_read.buf = NULL;
4165 }
4166 r->m_read.dataType = 0;
4167 r->m_read.flags = 0;
4168 r->m_read.status = 0;
4169 r->m_read.nResumeTS = 0;
4170 r->m_read.nIgnoredFrameCounter = 0;
4171 r->m_read.nIgnoredFlvFrameCounter = 0;
4172
4173 r->m_write.m_nBytesRead = 0;
4174 RTMPPacket_Free(&r->m_write);
4175
4176 for (i = 0; i < r->m_channelsAllocatedIn; i++)
4177 {
4178 if (r->m_vecChannelsIn[i])
4179 {
4180 RTMPPacket_Free(r->m_vecChannelsIn[i]);
4181 free(r->m_vecChannelsIn[i]);
4182 r->m_vecChannelsIn[i] = NULL;
4183 }
4184 }
4185 free(r->m_vecChannelsIn);
4186 r->m_vecChannelsIn = NULL;
4187 free(r->m_channelTimestamp);
4188 r->m_channelTimestamp = NULL;
4189 r->m_channelsAllocatedIn = 0;
4190 for (i = 0; i < r->m_channelsAllocatedOut; i++)
4191 {
4192 if (r->m_vecChannelsOut[i])
4193 {
4194 free(r->m_vecChannelsOut[i]);
4195 r->m_vecChannelsOut[i] = NULL;
4196 }
4197 }
4198 free(r->m_vecChannelsOut);
4199 r->m_vecChannelsOut = NULL;
4200 r->m_channelsAllocatedOut = 0;
4201 AV_clear(r->m_methodCalls, r->m_numCalls);
4202 r->m_methodCalls = NULL;
4203 r->m_numCalls = 0;
4204 r->m_numInvokes = 0;
4205
4206 r->m_bPlaying = FALSE;
4207 r->m_sb.sb_size = 0;
4208
4209 r->m_msgCounter = 0;
4210 r->m_resplen = 0;
4211 r->m_unackd = 0;
4212
4213 if (r->Link.lFlags & RTMP_LF_FTCU)
4214 {
4215 free(r->Link.tcUrl.av_val);
4216 r->Link.tcUrl.av_val = NULL;
4217 r->Link.lFlags ^= RTMP_LF_FTCU;
4218 }
4219
4220 if (!reconnect)
4221 {
4222 free(r->Link.playpath0.av_val);
4223 r->Link.playpath0.av_val = NULL;
4224 }
4225 #ifdef CRYPTO
4226 if ((r->Link.protocol & RTMP_FEATURE_WRITE) &&
4227 (r->Link.pFlags & RTMP_PUB_ALLOC) && !reconnect)
4228 {
4229 free(r->Link.app.av_val);
4230 r->Link.app.av_val = NULL;
4231 free(r->Link.tcUrl.av_val);
4232 r->Link.tcUrl.av_val = NULL;
4233 }
4234 if (r->Link.dh)
4235 {
4236 MDH_free(r->Link.dh);
4237 r->Link.dh = NULL;
4238 }
4239 if (r->Link.rc4keyIn)
4240 {
4241 RC4_free(r->Link.rc4keyIn);
4242 r->Link.rc4keyIn = NULL;
4243 }
4244 if (r->Link.rc4keyOut)
4245 {
4246 RC4_free(r->Link.rc4keyOut);
4247 r->Link.rc4keyOut = NULL;
4248 }
4249 #endif
4250 }
4251
4252 int
4253 RTMPSockBuf_Fill(RTMPSockBuf *sb)
4254 {
4255 int nBytes;
4256
4257 if (!sb->sb_size)
4258 sb->sb_start = sb->sb_buf;
4259
4260 while (1)
4261 {
4262 nBytes = sizeof(sb->sb_buf) - 1 - sb->sb_size - (sb->sb_start - sb->sb_buf);
4263 #if defined(CRYPTO) && !defined(NO_SSL)
4264 if (sb->sb_ssl)
4265 {
4266 nBytes = TLS_read(sb->sb_ssl, sb->sb_start + sb->sb_size, nBytes);
4267 }
4268 else
4269 #endif
4270 {
4271 nBytes = recv(sb->sb_socket, sb->sb_start + sb->sb_size, nBytes, 0);
4272 }
4273 if (nBytes != -1)
4274 {
4275 sb->sb_size += nBytes;
4276 }
4277 else
4278 {
4279 int sockerr = GetSockError();
4280 RTMP_Log(RTMP_LOGDEBUG, "%s, recv returned %d. GetSockError(): %d (%s)",
4281 __FUNCTION__, nBytes, sockerr, strerror(sockerr));
4282 if (sockerr == EINTR && !RTMP_ctrlC)
4283 continue;
4284
4285 if (sockerr == EWOULDBLOCK || sockerr == EAGAIN)
4286 {
4287 sb->sb_timedout = TRUE;
4288 nBytes = 0;
4289 }
4290 }
4291 break;
4292 }
4293
4294 return nBytes;
4295 }
4296
4297 int
4298 RTMPSockBuf_Send(RTMPSockBuf *sb, const char *buf, int len)
4299 {
4300 int rc;
4301
4302 #ifdef _DEBUG
4303 fwrite(buf, 1, len, netstackdump);
4304 #endif
4305
4306 #if defined(CRYPTO) && !defined(NO_SSL)
4307 if (sb->sb_ssl)
4308 {
4309 rc = TLS_write(sb->sb_ssl, buf, len);
4310 }
4311 else
4312 #endif
4313 {
4314 rc = send(sb->sb_socket, buf, len, 0);
4315 }
4316 return rc;
4317 }
4318
4319 int
4320 RTMPSockBuf_Close(RTMPSockBuf *sb)
4321 {
4322 #if defined(CRYPTO) && !defined(NO_SSL)
4323 if (sb->sb_ssl)
4324 {
4325 TLS_shutdown(sb->sb_ssl);
4326 TLS_close(sb->sb_ssl);
4327 sb->sb_ssl = NULL;
4328 }
4329 #endif
4330 if (sb->sb_socket != -1)
4331 return closesocket(sb->sb_socket);
4332 return 0;
4333 }
4334
4335 #define HEX2BIN(a) (((a)&0x40)?((a)&0xf)+9:((a)&0xf))
4336
4337 static void
4338 DecodeTEA(AVal *key, AVal *text)
4339 {
4340 uint32_t *v, k[4] = { 0 }, u;
4341 uint32_t z, y, sum = 0, e, DELTA = 0x9e3779b9;
4342 int32_t p, q;
4343 int i, n;
4344 unsigned char *ptr, *out;
4345
4346 /* prep key: pack 1st 16 chars into 4 LittleEndian ints */
4347 ptr = (unsigned char *)key->av_val;
4348 u = 0;
4349 n = 0;
4350 v = k;
4351 p = key->av_len > 16 ? 16 : key->av_len;
4352 for (i = 0; i < p; i++)
4353 {
4354 u |= ptr[i] << (n * 8);
4355 if (n == 3)
4356 {
4357 *v++ = u;
4358 u = 0;
4359 n = 0;
4360 }
4361 else
4362 {
4363 n++;
4364 }
4365 }
4366 /* any trailing chars */
4367 if (u)
4368 *v = u;
4369
4370 /* prep text: hex2bin, multiples of 4 */
4371 n = (text->av_len + 7) / 8;
4372 out = malloc(n * 8);
4373 ptr = (unsigned char *)text->av_val;
4374 v = (uint32_t *) out;
4375 for (i = 0; i < n; i++)
4376 {
4377 u = (HEX2BIN(ptr[0]) << 4) + HEX2BIN(ptr[1]);
4378 u |= ((HEX2BIN(ptr[2]) << 4) + HEX2BIN(ptr[3])) << 8;
4379 u |= ((HEX2BIN(ptr[4]) << 4) + HEX2BIN(ptr[5])) << 16;
4380 u |= ((HEX2BIN(ptr[6]) << 4) + HEX2BIN(ptr[7])) << 24;
4381 *v++ = u;
4382 ptr += 8;
4383 }
4384 v = (uint32_t *) out;
4385
4386 /* http://www.movable-type.co.uk/scripts/tea-block.html */
4387 #define MX (((z>>5)^(y<<2)) + ((y>>3)^(z<<4))) ^ ((sum^y) + (k[(p&3)^e]^z));
4388 z = v[n - 1];
4389 y = v[0];
4390 q = 6 + 52 / n;
4391 sum = q * DELTA;
4392 while (sum != 0)
4393 {
4394 e = sum >> 2 & 3;
4395 for (p = n - 1; p > 0; p--)
4396 z = v[p - 1], y = v[p] -= MX;
4397 z = v[n - 1];
4398 y = v[0] -= MX;
4399 sum -= DELTA;
4400 }
4401
4402 text->av_len /= 2;
4403 memcpy(text->av_val, out, text->av_len);
4404 free(out);
4405 }
4406
4407 static int
4408 HTTP_Post(RTMP *r, RTMPTCmd cmd, const char *buf, int len)
4409 {
4410 char hbuf[512];
4411 int hlen = snprintf(hbuf, sizeof(hbuf), "POST /%s%s/%d HTTP/1.1\r\n"
4412 "Host: %.*s:%d\r\n"
4413 "Accept: */*\r\n"
4414 "User-Agent: Shockwave Flash\r\n"
4415 "Connection: Keep-Alive\r\n"
4416 "Cache-Control: no-cache\r\n"
4417 "Content-type: application/x-fcs\r\n"
4418 "Content-length: %d\r\n\r\n", RTMPT_cmds[cmd],
4419 r->m_clientID.av_val ? r->m_clientID.av_val : "",
4420 r->m_msgCounter, r->Link.hostname.av_len, r->Link.hostname.av_val,
4421 r->Link.port, len);
4422 RTMPSockBuf_Send(&r->m_sb, hbuf, hlen);
4423 hlen = RTMPSockBuf_Send(&r->m_sb, buf, len);
4424 r->m_msgCounter++;
4425 r->m_unackd++;
4426 return hlen;
4427 }
4428
4429 static int
4430 HTTP_read(RTMP *r, int fill)
4431 {
4432 char *ptr;
4433 int hlen;
4434
4435 restart:
4436 if (fill)
4437 RTMPSockBuf_Fill(&r->m_sb);
4438 if (r->m_sb.sb_size < 13) {
4439 if (fill)
4440 goto restart;
4441 return -2;
4442 }
4443 if (strncmp(r->m_sb.sb_start, "HTTP/1.1 200 ", 13))
4444 return -1;
4445 r->m_sb.sb_start[r->m_sb.sb_size] = '\0';
4446 if (!strstr(r->m_sb.sb_start, "\r\n\r\n")) {
4447 if (fill)
4448 goto restart;
4449 return -2;
4450 }
4451
4452 ptr = r->m_sb.sb_start + sizeof("HTTP/1.1 200");
4453 while ((ptr = strstr(ptr, "Content-"))) {
4454 if (!strncasecmp(ptr+8, "length:", 7)) break;
4455 ptr += 8;
4456 }
4457 if (!ptr)
4458 return -1;
4459 hlen = atoi(ptr+16);
4460 ptr = strstr(ptr+16, "\r\n\r\n");
4461 if (!ptr)
4462 return -1;
4463 ptr += 4;
4464 if (ptr + (r->m_clientID.av_val ? 1 : hlen) > r->m_sb.sb_start + r->m_sb.sb_size)
4465 {
4466 if (fill)
4467 goto restart;
4468 return -2;
4469 }
4470 r->m_sb.sb_size -= ptr - r->m_sb.sb_start;
4471 r->m_sb.sb_start = ptr;
4472 r->m_unackd--;
4473
4474 if (!r->m_clientID.av_val)
4475 {
4476 r->m_clientID.av_len = hlen;
4477 r->m_clientID.av_val = malloc(hlen+1);
4478 if (!r->m_clientID.av_val)
4479 return -1;
4480 r->m_clientID.av_val[0] = '/';
4481 memcpy(r->m_clientID.av_val+1, ptr, hlen-1);
4482 r->m_clientID.av_val[hlen] = 0;
4483 r->m_sb.sb_size = 0;
4484 }
4485 else
4486 {
4487 r->m_polling = *ptr++;
4488 r->m_resplen = hlen - 1;
4489 r->m_sb.sb_start++;
4490 r->m_sb.sb_size--;
4491 }
4492 return 0;
4493 }
4494
4495 #define MAX_IGNORED_FRAMES 50
4496
4497 /* Read from the stream until we get a media packet.
4498 * Returns -3 if Play.Close/Stop, -2 if fatal error, -1 if no more media
4499 * packets, 0 if ignorable error, >0 if there is a media packet
4500 */
4501 static int
4502 Read_1_Packet(RTMP *r, char *buf, unsigned int buflen)
4503 {
4504 uint32_t prevTagSize = 0;
4505 int rtnGetNextMediaPacket = 0, ret = RTMP_READ_EOF;
4506 RTMPPacket packet = { 0 };
4507 int recopy = FALSE;
4508 unsigned int size;
4509 char *ptr, *pend;
4510 uint32_t nTimeStamp = 0;
4511 unsigned int len;
4512
4513 rtnGetNextMediaPacket = RTMP_GetNextMediaPacket(r, &packet);
4514 while (rtnGetNextMediaPacket)
4515 {
4516 char *packetBody = packet.m_body;
4517 unsigned int nPacketLen = packet.m_nBodySize;
4518
4519 /* Return RTMP_READ_COMPLETE if this was completed nicely with
4520 * invoke message Play.Stop or Play.Complete
4521 */
4522 if (rtnGetNextMediaPacket == 2)
4523 {
4524 RTMP_Log(RTMP_LOGDEBUG,
4525 "Got Play.Complete or Play.Stop from server. "
4526 "Assuming stream is complete");
4527 ret = RTMP_READ_COMPLETE;
4528 break;
4529 }
4530
4531 r->m_read.dataType |= (((packet.m_packetType == RTMP_PACKET_TYPE_AUDIO) << 2) |
4532 (packet.m_packetType == RTMP_PACKET_TYPE_VIDEO));
4533
4534 if (packet.m_packetType == RTMP_PACKET_TYPE_VIDEO && nPacketLen <= 5)
4535 {
4536 RTMP_Log(RTMP_LOGDEBUG, "ignoring too small video packet: size: %d",
4537 nPacketLen);
4538 ret = RTMP_READ_IGNORE;
4539 break;
4540 }
4541 if (packet.m_packetType == RTMP_PACKET_TYPE_AUDIO && nPacketLen <= 1)
4542 {
4543 RTMP_Log(RTMP_LOGDEBUG, "ignoring too small audio packet: size: %d",
4544 nPacketLen);
4545 ret = RTMP_READ_IGNORE;
4546 break;
4547 }
4548
4549 if (r->m_read.flags & RTMP_READ_SEEKING)
4550 {
4551 ret = RTMP_READ_IGNORE;
4552 break;
4553 }
4554 #ifdef _DEBUG
4555 RTMP_Log(RTMP_LOGDEBUG, "type: %02X, size: %d, TS: %d ms, abs TS: %d",
4556 packet.m_packetType, nPacketLen, packet.m_nTimeStamp,
4557 packet.m_hasAbsTimestamp);
4558 if (packet.m_packetType == RTMP_PACKET_TYPE_VIDEO)
4559 RTMP_Log(RTMP_LOGDEBUG, "frametype: %02X", (*packetBody & 0xf0));
4560 #endif
4561
4562 if (r->m_read.flags & RTMP_READ_RESUME)
4563 {
4564 /* check the header if we get one */
4565 if (packet.m_nTimeStamp == 0)
4566 {
4567 if (r->m_read.nMetaHeaderSize > 0
4568 && packet.m_packetType == RTMP_PACKET_TYPE_INFO)
4569 {
4570 AMFObject metaObj;
4571 int nRes =
4572 AMF_Decode(&metaObj, packetBody, nPacketLen, FALSE);
4573 if (nRes >= 0)
4574 {
4575 AVal metastring;
4576 AMFProp_GetString(AMF_GetProp(&metaObj, NULL, 0),
4577 &metastring);
4578
4579 if (AVMATCH(&metastring, &av_onMetaData))
4580 {
4581 /* compare */
4582 if ((r->m_read.nMetaHeaderSize != nPacketLen) ||
4583 (memcmp
4584 (r->m_read.metaHeader, packetBody,
4585 r->m_read.nMetaHeaderSize) != 0))
4586 {
4587 ret = RTMP_READ_ERROR;
4588 }
4589 }
4590 AMF_Reset(&metaObj);
4591 if (ret == RTMP_READ_ERROR)
4592 break;
4593 }
4594 }
4595
4596 /* check first keyframe to make sure we got the right position
4597 * in the stream! (the first non ignored frame)
4598 */
4599 if (r->m_read.nInitialFrameSize > 0)
4600 {
4601 /* video or audio data */
4602 if (packet.m_packetType == r->m_read.initialFrameType
4603 && r->m_read.nInitialFrameSize == nPacketLen)
4604 {
4605 /* we don't compare the sizes since the packet can
4606 * contain several FLV packets, just make sure the
4607 * first frame is our keyframe (which we are going
4608 * to rewrite)
4609 */
4610 if (memcmp
4611 (r->m_read.initialFrame, packetBody,
4612 r->m_read.nInitialFrameSize) == 0)
4613 {
4614 RTMP_Log(RTMP_LOGDEBUG, "Checked keyframe successfully!");
4615 r->m_read.flags |= RTMP_READ_GOTKF;
4616 /* ignore it! (what about audio data after it? it is
4617 * handled by ignoring all 0ms frames, see below)
4618 */
4619 ret = RTMP_READ_IGNORE;
4620 break;
4621 }
4622 }
4623
4624 /* hande FLV streams, even though the server resends the
4625 * keyframe as an extra video packet it is also included
4626 * in the first FLV stream chunk and we have to compare
4627 * it and filter it out !!
4628 */
4629 if (packet.m_packetType == RTMP_PACKET_TYPE_FLASH_VIDEO)
4630 {
4631 /* basically we have to find the keyframe with the
4632 * correct TS being nResumeTS
4633 */
4634 unsigned int pos = 0;
4635 uint32_t ts = 0;
4636
4637 while (pos + 11 < nPacketLen)
4638 {
4639 /* size without header (11) and prevTagSize (4) */
4640 uint32_t dataSize =
4641 AMF_DecodeInt24(packetBody + pos + 1);
4642 ts = AMF_DecodeInt24(packetBody + pos + 4);
4643 ts |= (packetBody[pos + 7] << 24);
4644
4645 #ifdef _DEBUG
4646 RTMP_Log(RTMP_LOGDEBUG,
4647 "keyframe search: FLV Packet: type %02X, dataSize: %d, timeStamp: %d ms",
4648 packetBody[pos], dataSize, ts);
4649 #endif
4650 /* ok, is it a keyframe?:
4651 * well doesn't work for audio!
4652 */
4653 if (packetBody[pos /*6928, test 0 */ ] ==
4654 r->m_read.initialFrameType
4655 /* && (packetBody[11]&0xf0) == 0x10 */ )
4656 {
4657 if (ts == r->m_read.nResumeTS)
4658 {
4659 RTMP_Log(RTMP_LOGDEBUG,
4660 "Found keyframe with resume-keyframe timestamp!");
4661 if (r->m_read.nInitialFrameSize != dataSize
4662 || memcmp(r->m_read.initialFrame,
4663 packetBody + pos + 11,
4664 r->m_read.
4665 nInitialFrameSize) != 0)
4666 {
4667 RTMP_Log(RTMP_LOGERROR,
4668 "FLV Stream: Keyframe doesn't match!");
4669 ret = RTMP_READ_ERROR;
4670 break;
4671 }
4672 r->m_read.flags |= RTMP_READ_GOTFLVK;
4673
4674 /* skip this packet?
4675 * check whether skippable:
4676 */
4677 if (pos + 11 + dataSize + 4 > nPacketLen)
4678 {
4679 RTMP_Log(RTMP_LOGWARNING,
4680 "Non skipable packet since it doesn't end with chunk, stream corrupt!");
4681 ret = RTMP_READ_ERROR;
4682 break;
4683 }
4684 packetBody += (pos + 11 + dataSize + 4);
4685 nPacketLen -= (pos + 11 + dataSize + 4);
4686
4687 goto stopKeyframeSearch;
4688
4689 }
4690 else if (r->m_read.nResumeTS < ts)
4691 {
4692 /* the timestamp ts will only increase with
4693 * further packets, wait for seek
4694 */
4695 goto stopKeyframeSearch;
4696 }
4697 }
4698 pos += (11 + dataSize + 4);
4699 }
4700 if (ts < r->m_read.nResumeTS)
4701 {
4702 RTMP_Log(RTMP_LOGERROR,
4703 "First packet does not contain keyframe, all "
4704 "timestamps are smaller than the keyframe "
4705 "timestamp; probably the resume seek failed?");
4706 }
4707 stopKeyframeSearch:
4708 ;
4709 if (!(r->m_read.flags & RTMP_READ_GOTFLVK))
4710 {
4711 RTMP_Log(RTMP_LOGERROR,
4712 "Couldn't find the seeked keyframe in this chunk!");
4713 ret = RTMP_READ_IGNORE;
4714 break;
4715 }
4716 }
4717 }
4718 }
4719
4720 if (packet.m_nTimeStamp > 0
4721 && (r->m_read.flags & (RTMP_READ_GOTKF|RTMP_READ_GOTFLVK)))
4722 {
4723 /* another problem is that the server can actually change from
4724 * 09/08 video/audio packets to an FLV stream or vice versa and
4725 * our keyframe check will prevent us from going along with the
4726 * new stream if we resumed.
4727 *
4728 * in this case set the 'found keyframe' variables to true.
4729 * We assume that if we found one keyframe somewhere and were
4730 * already beyond TS > 0 we have written data to the output
4731 * which means we can accept all forthcoming data including the
4732 * change between 08/09 <-> FLV packets
4733 */
4734 r->m_read.flags |= (RTMP_READ_GOTKF|RTMP_READ_GOTFLVK);
4735 }
4736
4737 /* skip till we find our keyframe
4738 * (seeking might put us somewhere before it)
4739 */
4740 if (!(r->m_read.flags & RTMP_READ_GOTKF) &&
4741 packet.m_packetType != RTMP_PACKET_TYPE_FLASH_VIDEO)
4742 {
4743 RTMP_Log(RTMP_LOGWARNING,
4744 "Stream does not start with requested frame, ignoring data... ");
4745 r->m_read.nIgnoredFrameCounter++;
4746 if (r->m_read.nIgnoredFrameCounter > MAX_IGNORED_FRAMES)
4747 ret = RTMP_READ_ERROR; /* fatal error, couldn't continue stream */
4748 else
4749 ret = RTMP_READ_IGNORE;
4750 break;
4751 }
4752 /* ok, do the same for FLV streams */
4753 if (!(r->m_read.flags & RTMP_READ_GOTFLVK) &&
4754 packet.m_packetType == RTMP_PACKET_TYPE_FLASH_VIDEO)
4755 {
4756 RTMP_Log(RTMP_LOGWARNING,
4757 "Stream does not start with requested FLV frame, ignoring data... ");
4758 r->m_read.nIgnoredFlvFrameCounter++;
4759 if (r->m_read.nIgnoredFlvFrameCounter > MAX_IGNORED_FRAMES)
4760 ret = RTMP_READ_ERROR;
4761 else
4762 ret = RTMP_READ_IGNORE;
4763 break;
4764 }
4765
4766 /* we have to ignore the 0ms frames since these are the first
4767 * keyframes; we've got these so don't mess around with multiple
4768 * copies sent by the server to us! (if the keyframe is found at a
4769 * later position there is only one copy and it will be ignored by
4770 * the preceding if clause)
4771 */
4772 if (!(r->m_read.flags & RTMP_READ_NO_IGNORE) &&
4773 packet.m_packetType != RTMP_PACKET_TYPE_FLASH_VIDEO)
4774 {
4775 /* exclude type RTMP_PACKET_TYPE_FLASH_VIDEO since it can
4776 * contain several FLV packets
4777 */
4778 if (packet.m_nTimeStamp == 0)
4779 {
4780 ret = RTMP_READ_IGNORE;
4781 break;
4782 }
4783 else
4784 {
4785 /* stop ignoring packets */
4786 r->m_read.flags |= RTMP_READ_NO_IGNORE;
4787 }
4788 }
4789 }
4790
4791 /* calculate packet size and allocate slop buffer if necessary */
4792 size = nPacketLen +
4793 ((packet.m_packetType == RTMP_PACKET_TYPE_AUDIO
4794 || packet.m_packetType == RTMP_PACKET_TYPE_VIDEO
4795 || packet.m_packetType == RTMP_PACKET_TYPE_INFO) ? 11 : 0) +
4796 (packet.m_packetType != RTMP_PACKET_TYPE_FLASH_VIDEO ? 4 : 0);
4797
4798 if (size + 4 > buflen)
4799 {
4800 /* the extra 4 is for the case of an FLV stream without a last
4801 * prevTagSize (we need extra 4 bytes to append it) */
4802 r->m_read.buf = malloc(size + 4);
4803 if (r->m_read.buf == 0)
4804 {
4805 RTMP_Log(RTMP_LOGERROR, "Couldn't allocate memory!");
4806 ret = RTMP_READ_ERROR; /* fatal error */
4807 break;
4808 }
4809 recopy = TRUE;
4810 ptr = r->m_read.buf;
4811 }
4812 else
4813 {
4814 ptr = buf;
4815 }
4816 pend = ptr + size + 4;
4817
4818 /* use to return timestamp of last processed packet */
4819
4820 /* audio (0x08), video (0x09) or metadata (0x12) packets :
4821 * construct 11 byte header then add rtmp packet's data */
4822 if (packet.m_packetType == RTMP_PACKET_TYPE_AUDIO
4823 || packet.m_packetType == RTMP_PACKET_TYPE_VIDEO
4824 || packet.m_packetType == RTMP_PACKET_TYPE_INFO)
4825 {
4826 nTimeStamp = r->m_read.nResumeTS + packet.m_nTimeStamp;
4827 prevTagSize = 11 + nPacketLen;
4828
4829 *ptr = packet.m_packetType;
4830 ptr++;
4831 ptr = AMF_EncodeInt24(ptr, pend, nPacketLen);
4832
4833 #if 0
4834 if(packet.m_packetType == RTMP_PACKET_TYPE_VIDEO) {
4835
4836 /* H264 fix: */
4837 if((packetBody[0] & 0x0f) == 7) { /* CodecId = H264 */
4838 uint8_t packetType = *(packetBody+1);
4839
4840 uint32_t ts = AMF_DecodeInt24(packetBody+2); /* composition time */
4841 int32_t cts = (ts+0xff800000)^0xff800000;
4842 RTMP_Log(RTMP_LOGDEBUG, "cts : %d\n", cts);
4843
4844 nTimeStamp -= cts;
4845 /* get rid of the composition time */
4846 CRTMP::EncodeInt24(packetBody+2, 0);
4847 }
4848 RTMP_Log(RTMP_LOGDEBUG, "VIDEO: nTimeStamp: 0x%08X (%d)\n", nTimeStamp, nTimeStamp);
4849 }
4850 #endif
4851
4852 ptr = AMF_EncodeInt24(ptr, pend, nTimeStamp);
4853 *ptr = (char)((nTimeStamp & 0xFF000000) >> 24);
4854 ptr++;
4855
4856 /* stream id */
4857 ptr = AMF_EncodeInt24(ptr, pend, 0);
4858 }
4859
4860 memcpy(ptr, packetBody, nPacketLen);
4861 len = nPacketLen;
4862
4863 /* correct tagSize and obtain timestamp if we have an FLV stream */
4864 if (packet.m_packetType == RTMP_PACKET_TYPE_FLASH_VIDEO)
4865 {
4866 unsigned int pos = 0;
4867 int delta;
4868
4869 /* grab first timestamp and see if it needs fixing */
4870 nTimeStamp = AMF_DecodeInt24(packetBody + 4);
4871 nTimeStamp |= (packetBody[7] << 24);
4872 delta = packet.m_nTimeStamp - nTimeStamp + r->m_read.nResumeTS;
4873
4874 while (pos + 11 < nPacketLen)
4875 {
4876 /* size without header (11) and without prevTagSize (4) */
4877 uint32_t dataSize = AMF_DecodeInt24(packetBody + pos + 1);
4878 nTimeStamp = AMF_DecodeInt24(packetBody + pos + 4);
4879 nTimeStamp |= (packetBody[pos + 7] << 24);
4880
4881 if (delta)
4882 {
4883 nTimeStamp += delta;
4884 AMF_EncodeInt24(ptr+pos+4, pend, nTimeStamp);
4885 ptr[pos+7] = nTimeStamp>>24;
4886 }
4887
4888 /* set data type */
4889 r->m_read.dataType |= (((*(packetBody + pos) == 0x08) << 2) |
4890 (*(packetBody + pos) == 0x09));
4891
4892 if (pos + 11 + dataSize + 4 > nPacketLen)
4893 {
4894 if (pos + 11 + dataSize > nPacketLen)
4895 {
4896 RTMP_Log(RTMP_LOGERROR,
4897 "Wrong data size (%u), stream corrupted, aborting!",
4898 dataSize);
4899 ret = RTMP_READ_ERROR;
4900 break;
4901 }
4902 RTMP_Log(RTMP_LOGWARNING, "No tagSize found, appending!");
4903
4904 /* we have to append a last tagSize! */
4905 prevTagSize = dataSize + 11;
4906 AMF_EncodeInt32(ptr + pos + 11 + dataSize, pend,
4907 prevTagSize);
4908 size += 4;
4909 len += 4;
4910 }
4911 else
4912 {
4913 prevTagSize =
4914 AMF_DecodeInt32(packetBody + pos + 11 + dataSize);
4915
4916 #ifdef _DEBUG
4917 RTMP_Log(RTMP_LOGDEBUG,
4918 "FLV Packet: type %02X, dataSize: %lu, tagSize: %lu, timeStamp: %lu ms",
4919 (unsigned char)packetBody[pos], dataSize, prevTagSize,
4920 nTimeStamp);
4921 #endif
4922
4923 if (prevTagSize != (dataSize + 11))
4924 {
4925 #ifdef _DEBUG
4926 RTMP_Log(RTMP_LOGWARNING,
4927 "Tag and data size are not consitent, writing tag size according to dataSize+11: %d",
4928 dataSize + 11);
4929 #endif
4930
4931 prevTagSize = dataSize + 11;
4932 AMF_EncodeInt32(ptr + pos + 11 + dataSize, pend,
4933 prevTagSize);
4934 }
4935 }
4936
4937 pos += prevTagSize + 4; /*(11+dataSize+4); */
4938 }
4939 }
4940 ptr += len;
4941
4942 if (packet.m_packetType != RTMP_PACKET_TYPE_FLASH_VIDEO)
4943 {
4944 /* FLV tag packets contain their own prevTagSize */
4945 AMF_EncodeInt32(ptr, pend, prevTagSize);
4946 }
4947
4948 /* In non-live this nTimeStamp can contain an absolute TS.
4949 * Update ext timestamp with this absolute offset in non-live mode
4950 * otherwise report the relative one
4951 */
4952 /* 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); */
4953 r->m_read.timestamp = (r->Link.lFlags & RTMP_LF_LIVE) ? packet.m_nTimeStamp : nTimeStamp;
4954
4955 ret = size;
4956 break;
4957 }
4958
4959 if (rtnGetNextMediaPacket)
4960 RTMPPacket_Free(&packet);
4961
4962 if (recopy)
4963 {
4964 len = ret > buflen ? buflen : ret;
4965 memcpy(buf, r->m_read.buf, len);
4966 r->m_read.bufpos = r->m_read.buf + len;
4967 r->m_read.buflen = ret - len;
4968 }
4969 return ret;
4970 }
4971
4972 static const char flvHeader[] = { 'F', 'L', 'V', 0x01,
4973 0x00, /* 0x04 == audio, 0x01 == video */
4974 0x00, 0x00, 0x00, 0x09,
4975 0x00, 0x00, 0x00, 0x00
4976 };
4977
4978 #define HEADERBUF (128*1024)
4979 int
4980 RTMP_Read(RTMP *r, char *buf, int size)
4981 {
4982 int nRead = 0, total = 0;
4983
4984 /* can't continue */
4985 fail:
4986 switch (r->m_read.status) {
4987 case RTMP_READ_EOF:
4988 case RTMP_READ_COMPLETE:
4989 return 0;
4990 case RTMP_READ_ERROR: /* corrupted stream, resume failed */
4991 SetSockError(EINVAL);
4992 return -1;
4993 default:
4994 break;
4995 }
4996
4997 /* first time thru */
4998 if (!(r->m_read.flags & RTMP_READ_HEADER))
4999 {
5000 if (!(r->m_read.flags & RTMP_READ_RESUME))
5001 {
5002 char *mybuf = malloc(HEADERBUF), *end = mybuf + HEADERBUF;
5003 int cnt = 0;
5004 r->m_read.buf = mybuf;
5005 r->m_read.buflen = HEADERBUF;
5006
5007 memcpy(mybuf, flvHeader, sizeof(flvHeader));
5008 r->m_read.buf += sizeof(flvHeader);
5009 r->m_read.buflen -= sizeof(flvHeader);
5010 cnt += sizeof(flvHeader);
5011
5012 while (r->m_read.timestamp == 0)
5013 {
5014 nRead = Read_1_Packet(r, r->m_read.buf, r->m_read.buflen);
5015 if (nRead < 0)
5016 {
5017 free(mybuf);
5018 r->m_read.buf = NULL;
5019 r->m_read.buflen = 0;
5020 r->m_read.status = nRead;
5021 goto fail;
5022 }
5023 /* buffer overflow, fix buffer and give up */
5024 if (r->m_read.buf < mybuf || r->m_read.buf > end) {
5025 mybuf = realloc(mybuf, cnt + nRead);
5026 memcpy(mybuf+cnt, r->m_read.buf, nRead);
5027 free(r->m_read.buf);
5028 r->m_read.buf = mybuf+cnt+nRead;
5029 break;
5030 }
5031 cnt += nRead;
5032 r->m_read.buf += nRead;
5033 r->m_read.buflen -= nRead;
5034 if (r->m_read.dataType == 5)
5035 break;
5036 }
5037 mybuf[4] = r->m_read.dataType;
5038 r->m_read.buflen = r->m_read.buf - mybuf;
5039 r->m_read.buf = mybuf;
5040 r->m_read.bufpos = mybuf;
5041 }
5042 r->m_read.flags |= RTMP_READ_HEADER;
5043 }
5044
5045 if ((r->m_read.flags & RTMP_READ_SEEKING) && r->m_read.buf)
5046 {
5047 /* drop whatever's here */
5048 free(r->m_read.buf);
5049 r->m_read.buf = NULL;
5050 r->m_read.bufpos = NULL;
5051 r->m_read.buflen = 0;
5052 }
5053
5054 /* If there's leftover data buffered, use it up */
5055 if (r->m_read.buf)
5056 {
5057 nRead = r->m_read.buflen;
5058 if (nRead > size)
5059 nRead = size;
5060 memcpy(buf, r->m_read.bufpos, nRead);
5061 r->m_read.buflen -= nRead;
5062 if (!r->m_read.buflen)
5063 {
5064 free(r->m_read.buf);
5065 r->m_read.buf = NULL;
5066 r->m_read.bufpos = NULL;
5067 }
5068 else
5069 {
5070 r->m_read.bufpos += nRead;
5071 }
5072 buf += nRead;
5073 total += nRead;
5074 size -= nRead;
5075 }
5076
5077 while (size > 0 && (nRead = Read_1_Packet(r, buf, size)) >= 0)
5078 {
5079 if (!nRead) continue;
5080 buf += nRead;
5081 total += nRead;
5082 size -= nRead;
5083 break;
5084 }
5085 if (nRead < 0)
5086 r->m_read.status = nRead;
5087
5088 if (size < 0)
5089 total += size;
5090 return total;
5091 }
5092
5093 static const AVal av_setDataFrame = AVC("@setDataFrame");
5094
5095 int
5096 RTMP_Write(RTMP *r, const char *buf, int size)
5097 {
5098 RTMPPacket *pkt = &r->m_write;
5099 char *pend, *enc;
5100 int s2 = size, ret, num;
5101
5102 pkt->m_nChannel = 0x04; /* source channel */
5103 pkt->m_nInfoField2 = r->m_stream_id;
5104
5105 while (s2)
5106 {
5107 if (!pkt->m_nBytesRead)
5108 {
5109 if (size < 11) {
5110 /* FLV pkt too small */
5111 return 0;
5112 }
5113
5114 if (buf[0] == 'F' && buf[1] == 'L' && buf[2] == 'V')
5115 {
5116 buf += 13;
5117 s2 -= 13;
5118 }
5119
5120 pkt->m_packetType = *buf++;
5121 pkt->m_nBodySize = AMF_DecodeInt24(buf);
5122 buf += 3;
5123 pkt->m_nTimeStamp = AMF_DecodeInt24(buf);
5124 buf += 3;
5125 pkt->m_nTimeStamp |= *buf++ << 24;
5126 buf += 3;
5127 s2 -= 11;
5128
5129 if (((pkt->m_packetType == RTMP_PACKET_TYPE_AUDIO
5130 || pkt->m_packetType == RTMP_PACKET_TYPE_VIDEO) &&
5131 !pkt->m_nTimeStamp) || pkt->m_packetType == RTMP_PACKET_TYPE_INFO)
5132 {
5133 pkt->m_headerType = RTMP_PACKET_SIZE_LARGE;
5134 if (pkt->m_packetType == RTMP_PACKET_TYPE_INFO)
5135 pkt->m_nBodySize += 16;
5136 }
5137 else
5138 {
5139 pkt->m_headerType = RTMP_PACKET_SIZE_MEDIUM;
5140 }
5141
5142 if (!RTMPPacket_Alloc(pkt, pkt->m_nBodySize))
5143 {
5144 RTMP_Log(RTMP_LOGDEBUG, "%s, failed to allocate packet", __FUNCTION__);
5145 return FALSE;
5146 }
5147 enc = pkt->m_body;
5148 pend = enc + pkt->m_nBodySize;
5149 if (pkt->m_packetType == RTMP_PACKET_TYPE_INFO)
5150 {
5151 enc = AMF_EncodeString(enc, pend, &av_setDataFrame);
5152 pkt->m_nBytesRead = enc - pkt->m_body;
5153 }
5154 }
5155 else
5156 {
5157 enc = pkt->m_body + pkt->m_nBytesRead;
5158 }
5159 num = pkt->m_nBodySize - pkt->m_nBytesRead;
5160 if (num > s2)
5161 num = s2;
5162 memcpy(enc, buf, num);
5163 pkt->m_nBytesRead += num;
5164 s2 -= num;
5165 buf += num;
5166 if (pkt->m_nBytesRead == pkt->m_nBodySize)
5167 {
5168 ret = RTMP_SendPacket(r, pkt, FALSE);
5169 RTMPPacket_Free(pkt);
5170 pkt->m_nBytesRead = 0;
5171 if (!ret)
5172 return -1;
5173 buf += 4;
5174 s2 -= 4;
5175 if (s2 < 0)
5176 break;
5177 }
5178 }
5179 return size+s2;
5180 }