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