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