/*

* Copyright (C) 2005-2008 Team XBMC

* http://www.xbmc.org

* Copyright (C) 2008-2009 Andrej Stepanchuk

* Copyright (C) 2009-2010 Howard Chu

*

* This file is part of librtmp.

*

* librtmp is free software; you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as

* published by the Free Software Foundation; either version 2.1,

* or (at your option) any later version.

*

* librtmp is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with librtmp see the file COPYING. If not, write to

* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

* Boston, MA 02110-1301, USA.

* http://www.gnu.org/copyleft/lgpl.html

*/

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include "rtmp_sys.h"

#include "log.h"

#ifdef CRYPTO

#ifdef USE_POLARSSL

#include <polarssl/havege.h>

#elif defined(USE_GNUTLS)

#include <gnutls/gnutls.h>

#else /* USE_OPENSSL */

#include <openssl/ssl.h>

#include <openssl/rc4.h>

#endif

TLS_CTX RTMP_TLS_ctx;

#endif

#define RTMP_SIG_SIZE 1536

#define RTMP_LARGE_HEADER_SIZE 12

static const int packetSize[] = { 12, 8, 4, 1 };

int RTMP_ctrlC;

const char RTMPProtocolStrings[][7] = {

"RTMP",

"RTMPT",

"RTMPE",

"RTMPTE",

"RTMPS",

"RTMPTS",

"",

"",

"RTMFP"

};

const char RTMPProtocolStringsLower[][7] = {

"rtmp",

"rtmpt",

"rtmpe",

"rtmpte",

"rtmps",

"rtmpts",

"",

"",

"rtmfp"

};

static const char *RTMPT_cmds[] = {

"open",

"send",

"idle",

"close"

};

typedef enum {

RTMPT_OPEN=0, RTMPT_SEND, RTMPT_IDLE, RTMPT_CLOSE

} RTMPTCmd;

static int DumpMetaData(AMFObject *obj);

static int HandShake(RTMP *r, int FP9HandShake);

static int SocksNegotiate(RTMP *r);

static int SendConnectPacket(RTMP *r, RTMPPacket *cp);

static int SendCheckBW(RTMP *r);

static int SendCheckBWResult(RTMP *r, double txn);

static int SendDeleteStream(RTMP *r, double dStreamId);

static int SendFCSubscribe(RTMP *r, AVal *subscribepath);

static int SendPlay(RTMP *r);

static int SendBytesReceived(RTMP *r);

#if 0 /* unused */

static int SendBGHasStream(RTMP *r, double dId, AVal *playpath);

#endif

static int HandleInvoke(RTMP *r, const char *body, unsigned int nBodySize);

static int HandleMetadata(RTMP *r, char *body, unsigned int len);

static void HandleChangeChunkSize(RTMP *r, const RTMPPacket *packet);

static void HandleAudio(RTMP *r, const RTMPPacket *packet);

static void HandleVideo(RTMP *r, const RTMPPacket *packet);

static void HandleCtrl(RTMP *r, const RTMPPacket *packet);

static void HandleServerBW(RTMP *r, const RTMPPacket *packet);

static void HandleClientBW(RTMP *r, const RTMPPacket *packet);

static int ReadN(RTMP *r, char *buffer, int n);

static int WriteN(RTMP *r, const char *buffer, int n);

static void DecodeTEA(AVal *key, AVal *text);

static int HTTP_Post(RTMP *r, RTMPTCmd cmd, const char *buf, int len);

static int HTTP_read(RTMP *r, int fill);

#ifndef _WIN32

static int clk_tck;

#endif

#ifdef CRYPTO

#include "handshake.h"

#endif

uint32_t

RTMP_GetTime()

{

#ifdef _DEBUG

return 0;

#elif defined(_WIN32)

return timeGetTime();

#else

struct tms t;

if (!clk_tck) clk_tck = sysconf(_SC_CLK_TCK);

return times(&t) * 1000 / clk_tck;

#endif

}

void

RTMP_UserInterrupt()

{

RTMP_ctrlC = TRUE;

}

void

RTMPPacket_Reset(RTMPPacket *p)

{

p->m_headerType = 0;

p->m_packetType = 0;

p->m_nChannel = 0;

p->m_nTimeStamp = 0;

p->m_nInfoField2 = 0;

p->m_hasAbsTimestamp = FALSE;

p->m_nBodySize = 0;

p->m_nBytesRead = 0;

}

int

RTMPPacket_Alloc(RTMPPacket *p, int nSize)

{

char *ptr = calloc(1, nSize + RTMP_MAX_HEADER_SIZE);

if (!ptr)

return FALSE;

p->m_body = ptr + RTMP_MAX_HEADER_SIZE;

p->m_nBytesRead = 0;

return TRUE;

}

void

RTMPPacket_Free(RTMPPacket *p)

{

if (p->m_body)

{

free(p->m_body - RTMP_MAX_HEADER_SIZE);

p->m_body = NULL;

}

}

void

RTMPPacket_Dump(RTMPPacket *p)

{

RTMP_Log(RTMP_LOGDEBUG,

"RTMP PACKET: packet type: 0x%02x. channel: 0x%02x. info 1: %d info 2: %d. Body size: %lu. body: 0x%02x",

p->m_packetType, p->m_nChannel, p->m_nTimeStamp, p->m_nInfoField2,

p->m_nBodySize, p->m_body ? (unsigned char)p->m_body[0] : 0);

}

int

RTMP_LibVersion()

{

return RTMP_LIB_VERSION;

}

void

RTMP_TLS_Init()

{

#ifdef CRYPTO

#ifdef USE_POLARSSL

/* Do this regardless of NO_SSL, we use havege for rtmpe too */

RTMP_TLS_ctx = calloc(1,sizeof(struct tls_ctx));

havege_init(&RTMP_TLS_ctx->hs);

#elif defined(USE_GNUTLS) && !defined(NO_SSL)

/* Technically we need to initialize libgcrypt ourselves if

* we're not going to call gnutls_global_init(). Ignoring this

* for now.

*/

gnutls_global_init();

RTMP_TLS_ctx = malloc(sizeof(struct tls_ctx));

gnutls_certificate_allocate_credentials(&RTMP_TLS_ctx->cred);

gnutls_priority_init(&RTMP_TLS_ctx->prios, "NORMAL", NULL);

gnutls_certificate_set_x509_trust_file(RTMP_TLS_ctx->cred,

"ca.pem", GNUTLS_X509_FMT_PEM);

#elif !defined(NO_SSL) /* USE_OPENSSL */

/* libcrypto doesn't need anything special */

SSL_load_error_strings();

SSL_library_init();

OpenSSL_add_all_digests();

RTMP_TLS_ctx = SSL_CTX_new(SSLv23_method());

SSL_CTX_set_options(RTMP_TLS_ctx, SSL_OP_ALL);

SSL_CTX_set_default_verify_paths(RTMP_TLS_ctx);

#endif

#endif

}

RTMP *

RTMP_Alloc()

{

return calloc(1, sizeof(RTMP));

}

void

RTMP_Free(RTMP *r)

{

free(r);

}

void

RTMP_Init(RTMP *r)

{

#ifdef CRYPTO

if (!RTMP_TLS_ctx)

RTMP_TLS_Init();

#endif

memset(r, 0, sizeof(RTMP));

r->m_sb.sb_socket = -1;

r->m_inChunkSize = RTMP_DEFAULT_CHUNKSIZE;

r->m_outChunkSize = RTMP_DEFAULT_CHUNKSIZE;

r->m_nBufferMS = 30000;

r->m_nClientBW = 2500000;

r->m_nClientBW2 = 2;

r->m_nServerBW = 2500000;

r->m_fAudioCodecs = 3191.0;

r->m_fVideoCodecs = 252.0;

r->Link.timeout = 30;

r->Link.swfAge = 30;

}

void

RTMP_EnableWrite(RTMP *r)

{

r->Link.protocol |= RTMP_FEATURE_WRITE;

}

double

RTMP_GetDuration(RTMP *r)

{

return r->m_fDuration;

}

int

RTMP_IsConnected(RTMP *r)

{

return r->m_sb.sb_socket != -1;

}

int

RTMP_Socket(RTMP *r)

{

return r->m_sb.sb_socket;

}

int

RTMP_IsTimedout(RTMP *r)

{

return r->m_sb.sb_timedout;

}

void

RTMP_SetBufferMS(RTMP *r, int size)

{

r->m_nBufferMS = size;

}

void

RTMP_UpdateBufferMS(RTMP *r)

{

RTMP_SendCtrl(r, 3, r->m_stream_id, r->m_nBufferMS);

}

#undef OSS

#ifdef _WIN32

#define OSS "WIN"

#elif defined(__sun__)

#define OSS "SOL"

#elif defined(__APPLE__)

#define OSS "MAC"

#elif defined(__linux__)

#define OSS "LNX"

#else

#define OSS "GNU"

#endif

#define DEF_VERSTR OSS " 10,0,32,18"

static const char DEFAULT_FLASH_VER[] = DEF_VERSTR;

const AVal RTMP_DefaultFlashVer =

{ (char *)DEFAULT_FLASH_VER, sizeof(DEFAULT_FLASH_VER) - 1 };

void

RTMP_SetupStream(RTMP *r,

int protocol,

AVal *host,

unsigned int port,

AVal *sockshost,

AVal *playpath,

AVal *tcUrl,

AVal *swfUrl,

AVal *pageUrl,

AVal *app,

AVal *auth,

AVal *swfSHA256Hash,

uint32_t swfSize,

AVal *flashVer,

AVal *subscribepath,

int dStart,

int dStop, int bLiveStream, long int timeout)

{

RTMP_Log(RTMP_LOGDEBUG, "Protocol : %s", RTMPProtocolStrings[protocol&7]);

RTMP_Log(RTMP_LOGDEBUG, "Hostname : %.*s", host->av_len, host->av_val);

RTMP_Log(RTMP_LOGDEBUG, "Port : %d", port);

RTMP_Log(RTMP_LOGDEBUG, "Playpath : %s", playpath->av_val);

if (tcUrl && tcUrl->av_val)

RTMP_Log(RTMP_LOGDEBUG, "tcUrl : %s", tcUrl->av_val);

if (swfUrl && swfUrl->av_val)

RTMP_Log(RTMP_LOGDEBUG, "swfUrl : %s", swfUrl->av_val);

if (pageUrl && pageUrl->av_val)

RTMP_Log(RTMP_LOGDEBUG, "pageUrl : %s", pageUrl->av_val);

if (app && app->av_val)

RTMP_Log(RTMP_LOGDEBUG, "app : %.*s", app->av_len, app->av_val);

if (auth && auth->av_val)

RTMP_Log(RTMP_LOGDEBUG, "auth : %s", auth->av_val);

if (subscribepath && subscribepath->av_val)

RTMP_Log(RTMP_LOGDEBUG, "subscribepath : %s", subscribepath->av_val);

if (flashVer && flashVer->av_val)

RTMP_Log(RTMP_LOGDEBUG, "flashVer : %s", flashVer->av_val);

if (dStart > 0)

RTMP_Log(RTMP_LOGDEBUG, "StartTime : %d msec", dStart);

if (dStop > 0)

RTMP_Log(RTMP_LOGDEBUG, "StopTime : %d msec", dStop);

RTMP_Log(RTMP_LOGDEBUG, "live : %s", bLiveStream ? "yes" : "no");

RTMP_Log(RTMP_LOGDEBUG, "timeout : %d sec", timeout);

#ifdef CRYPTO

if (swfSHA256Hash != NULL && swfSize > 0)

{

memcpy(r->Link.SWFHash, swfSHA256Hash->av_val, sizeof(r->Link.SWFHash));

r->Link.SWFSize = swfSize;

RTMP_Log(RTMP_LOGDEBUG, "SWFSHA256:");

RTMP_LogHex(RTMP_LOGDEBUG, r->Link.SWFHash, sizeof(r->Link.SWFHash));

RTMP_Log(RTMP_LOGDEBUG, "SWFSize : %lu", r->Link.SWFSize);

}

else

{

r->Link.SWFSize = 0;

}

#endif

if (sockshost->av_len)

{

const char *socksport = strchr(sockshost->av_val, ':');

char *hostname = strdup(sockshost->av_val);

if (socksport)

hostname[socksport - sockshost->av_val] = '\0';

r->Link.sockshost.av_val = hostname;

r->Link.sockshost.av_len = strlen(hostname);

r->Link.socksport = socksport ? atoi(socksport + 1) : 1080;

RTMP_Log(RTMP_LOGDEBUG, "Connecting via SOCKS proxy: %s:%d", r->Link.sockshost.av_val,

r->Link.socksport);

}

else

{

r->Link.sockshost.av_val = NULL;

r->Link.sockshost.av_len = 0;

r->Link.socksport = 0;

}

if (tcUrl && tcUrl->av_len)

r->Link.tcUrl = *tcUrl;

if (swfUrl && swfUrl->av_len)

r->Link.swfUrl = *swfUrl;

if (pageUrl && pageUrl->av_len)

r->Link.pageUrl = *pageUrl;

if (app && app->av_len)

r->Link.app = *app;

if (auth && auth->av_len)

{

r->Link.auth = *auth;

r->Link.lFlags |= RTMP_LF_AUTH;

}

if (flashVer && flashVer->av_len)

r->Link.flashVer = *flashVer;

else

r->Link.flashVer = RTMP_DefaultFlashVer;

if (subscribepath && subscribepath->av_len)

r->Link.subscribepath = *subscribepath;

r->Link.seekTime = dStart;

r->Link.stopTime = dStop;

if (bLiveStream)

r->Link.lFlags |= RTMP_LF_LIVE;

r->Link.timeout = timeout;

r->Link.protocol = protocol;

r->Link.hostname = *host;

r->Link.port = port;

r->Link.playpath = *playpath;

if (r->Link.port == 0)

{

if (protocol & RTMP_FEATURE_SSL)

r->Link.port = 443;

else if (protocol & RTMP_FEATURE_HTTP)

r->Link.port = 80;

else

r->Link.port = 1935;

}

}

enum { OPT_STR=0, OPT_INT, OPT_BOOL, OPT_CONN };

static const char *optinfo[] = {

"string", "integer", "boolean", "AMF" };

#define OFF(x) offsetof(struct RTMP,x)

static struct urlopt {

AVal name;

off_t off;

int otype;

int omisc;

char *use;

} options[] = {

{ AVC("socks"), OFF(Link.sockshost), OPT_STR, 0,

"Use the specified SOCKS proxy" },

{ AVC("app"), OFF(Link.app), OPT_STR, 0,

"Name of target app on server" },

{ AVC("tcUrl"), OFF(Link.tcUrl), OPT_STR, 0,

"URL to played stream" },

{ AVC("pageUrl"), OFF(Link.pageUrl), OPT_STR, 0,

"URL of played media's web page" },

{ AVC("swfUrl"), OFF(Link.swfUrl), OPT_STR, 0,

"URL to player SWF file" },

{ AVC("flashver"), OFF(Link.flashVer), OPT_STR, 0,

"Flash version string (default " DEF_VERSTR ")" },

{ AVC("conn"), OFF(Link.extras), OPT_CONN, 0,

"Append arbitrary AMF data to Connect message" },

{ AVC("playpath"), OFF(Link.playpath), OPT_STR, 0,

"Path to target media on server" },

{ AVC("playlist"), OFF(Link.lFlags), OPT_BOOL, RTMP_LF_PLST,

"Set playlist before play command" },

{ AVC("live"), OFF(Link.lFlags), OPT_BOOL, RTMP_LF_LIVE,

"Stream is live, no seeking possible" },

{ AVC("subscribe"), OFF(Link.subscribepath), OPT_STR, 0,

"Stream to subscribe to" },

{ AVC("token"), OFF(Link.token), OPT_STR, 0,

"Key for SecureToken response" },

{ AVC("swfVfy"), OFF(Link.lFlags), OPT_BOOL, RTMP_LF_SWFV,

"Perform SWF Verification" },

{ AVC("swfAge"), OFF(Link.swfAge), OPT_INT, 0,

"Number of days to use cached SWF hash" },

{ AVC("start"), OFF(Link.seekTime), OPT_INT, 0,

"Stream start position in milliseconds" },

{ AVC("stop"), OFF(Link.stopTime), OPT_INT, 0,

"Stream stop position in milliseconds" },

{ AVC("buffer"), OFF(m_nBufferMS), OPT_INT, 0,

"Buffer time in milliseconds" },

{ AVC("timeout"), OFF(Link.timeout), OPT_INT, 0,

"Session timeout in seconds" },

{ {NULL,0}, 0, 0}

};

static const AVal truth[] = {

AVC("1"),

AVC("on"),

AVC("yes"),

AVC("true"),

{0,0}

};

static void RTMP_OptUsage()

{

int i;

RTMP_Log(RTMP_LOGERROR, "Valid RTMP options are:\n");

for (i=0; options[i].name.av_len; i++) {

RTMP_Log(RTMP_LOGERROR, "%10s %-7s %s\n", options[i].name.av_val,

optinfo[options[i].otype], options[i].use);

}

}

static int

parseAMF(AMFObject *obj, AVal *av, int *depth)

{

AMFObjectProperty prop = {{0,0}};

int i;

char *p, *arg = av->av_val;

if (arg[1] == ':')

{

p = (char *)arg+2;

switch(arg[0])

{

case 'B':

prop.p_type = AMF_BOOLEAN;

prop.p_vu.p_number = atoi(p);

break;

case 'S':

prop.p_type = AMF_STRING;

prop.p_vu.p_aval.av_val = p;

prop.p_vu.p_aval.av_len = av->av_len - (p-arg);

break;

case 'N':

prop.p_type = AMF_NUMBER;

prop.p_vu.p_number = strtod(p, NULL);

break;

case 'Z':

prop.p_type = AMF_NULL;

break;

case 'O':

i = atoi(p);

if (i)

{

prop.p_type = AMF_OBJECT;

}

else

{

(*depth)--;

return 0;

}

break;

default:

return -1;

}

}

else if (arg[2] == ':' && arg[0] == 'N')

{

p = strchr(arg+3, ':');

if (!p || !*depth)

return -1;

prop.p_name.av_val = (char *)arg+3;

prop.p_name.av_len = p - (arg+3);

p++;

switch(arg[1])

{

case 'B':

prop.p_type = AMF_BOOLEAN;

prop.p_vu.p_number = atoi(p);

break;

case 'S':

prop.p_type = AMF_STRING;

prop.p_vu.p_aval.av_val = p;

prop.p_vu.p_aval.av_len = av->av_len - (p-arg);

break;

case 'N':

prop.p_type = AMF_NUMBER;

prop.p_vu.p_number = strtod(p, NULL);

break;

case 'O':

prop.p_type = AMF_OBJECT;

break;

default:

return -1;

}

}

else

return -1;

if (*depth)

{

AMFObject *o2;

for (i=0; i<*depth; i++)

{

o2 = &obj->o_props[obj->o_num-1].p_vu.p_object;

obj = o2;

}

}

AMF_AddProp(obj, &prop);

if (prop.p_type == AMF_OBJECT)

(*depth)++;

return 0;

}

int RTMP_SetOpt(RTMP *r, const AVal *opt, AVal *arg)

{

int i;

void *v;

for (i=0; options[i].name.av_len; i++) {

if (opt->av_len != options[i].name.av_len) continue;

if (strcasecmp(opt->av_val, options[i].name.av_val)) continue;

v = (char *)r + options[i].off;

switch(options[i].otype) {

case OPT_STR: {

AVal *aptr = v;

*aptr = *arg; }

break;

case OPT_INT: {

long l = strtol(arg->av_val, NULL, 0);

*(int *)v = l; }

break;

case OPT_BOOL: {

int j, fl;

fl = *(int *)v;

for (j=0; truth[j].av_len; j++) {

if (arg->av_len != truth[j].av_len) continue;

if (strcasecmp(arg->av_val, truth[j].av_val)) continue;

fl |= options[i].omisc; break; }

*(int *)v = fl;

}

break;

case OPT_CONN:

if (parseAMF(&r->Link.extras, arg, &r->Link.edepth))

return FALSE;

break;

}

break;

}

if (!options[i].name.av_len) {

RTMP_Log(RTMP_LOGERROR, "Unknown option %s", opt->av_val);

RTMP_OptUsage();

return FALSE;

}

return TRUE;

}

int RTMP_SetupURL(RTMP *r, char *url)

{

AVal opt, arg;

char *p1, *p2, *ptr = strchr(url, ' ');

int ret, len;

unsigned int port = 0;

if (ptr)

*ptr = '\0';

len = strlen(url);

ret = RTMP_ParseURL(url, &r->Link.protocol, &r->Link.hostname,

&port, &r->Link.playpath0, &r->Link.app);

if (!ret)

return ret;

r->Link.port = port;

r->Link.playpath = r->Link.playpath0;

while (ptr) {

*ptr++ = '\0';

p1 = ptr;

p2 = strchr(p1, '=');

if (!p2)

break;

opt.av_val = p1;

opt.av_len = p2 - p1;

*p2++ = '\0';

arg.av_val = p2;

ptr = strchr(p2, ' ');

if (ptr) {

*ptr = '\0';

arg.av_len = ptr - p2;

/* skip repeated spaces */

while(ptr[1] == ' ')

*ptr++ = '\0';

} else {

arg.av_len = strlen(p2);

}

/* unescape */

port = arg.av_len;

for (p1=p2; port >0;) {

if (*p1 == '\\') {

unsigned int c;

if (port < 3)

return FALSE;

sscanf(p1+1, "%02x", &c);

*p2++ = c;

port -= 3;

p1 += 3;

} else {

*p2++ = *p1++;

port--;

}

}

arg.av_len = p2 - arg.av_val;

ret = RTMP_SetOpt(r, &opt, &arg);

if (!ret)

return ret;

}

if (!r->Link.tcUrl.av_len)

{

r->Link.tcUrl.av_val = url;

if (r->Link.app.av_len)

{

if (r->Link.app.av_val < url + len)

{

/* if app is part of original url, just use it */

r->Link.tcUrl.av_len = r->Link.app.av_len + (r->Link.app.av_val - url);

}

else

{

len = r->Link.hostname.av_len + r->Link.app.av_len +

sizeof("rtmpte://:65535/");

r->Link.tcUrl.av_val = malloc(len);

r->Link.tcUrl.av_len = snprintf(r->Link.tcUrl.av_val, len,

"%s://%.*s:%d/%.*s",

RTMPProtocolStringsLower[r->Link.protocol],

r->Link.hostname.av_len, r->Link.hostname.av_val,

r->Link.port,

r->Link.app.av_len, r->Link.app.av_val);

r->Link.lFlags |= RTMP_LF_FTCU;

}

}

else

{

r->Link.tcUrl.av_len = strlen(url);

}

}

#ifdef CRYPTO

if ((r->Link.lFlags & RTMP_LF_SWFV) && r->Link.swfUrl.av_len)

RTMP_HashSWF(r->Link.swfUrl.av_val, &r->Link.SWFSize,

(unsigned char *)r->Link.SWFHash, r->Link.swfAge);

#endif

if (r->Link.port == 0)

{

if (r->Link.protocol & RTMP_FEATURE_SSL)

r->Link.port = 443;

else if (r->Link.protocol & RTMP_FEATURE_HTTP)

r->Link.port = 80;

else

r->Link.port = 1935;

}

return TRUE;

}

static int

add_addr_info(struct sockaddr_in *service, AVal *host, int port)

{

char *hostname;

int ret = TRUE;

if (host->av_val[host->av_len])

{

hostname = malloc(host->av_len+1);

memcpy(hostname, host->av_val, host->av_len);

hostname[host->av_len] = '\0';

}

else

{

hostname = host->av_val;

}

service->sin_addr.s_addr = inet_addr(hostname);

if (service->sin_addr.s_addr == INADDR_NONE)

{

struct hostent *host = gethostbyname(hostname);

if (host == NULL || host->h_addr == NULL)

{

RTMP_Log(RTMP_LOGERROR, "Problem accessing the DNS. (addr: %s)", hostname);

ret = FALSE;

goto finish;

}

service->sin_addr = *(struct in_addr *)host->h_addr;

}

service->sin_port = htons(port);

finish:

if (hostname != host->av_val)

free(hostname);

return ret;

}

int

RTMP_Connect0(RTMP *r, struct sockaddr * service)

{

int on = 1;

r->m_sb.sb_timedout = FALSE;

r->m_pausing = 0;

r->m_fDuration = 0.0;

r->m_sb.sb_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

if (r->m_sb.sb_socket != -1)

{

SET_RCVTIMEO(tv, r->Link.timeout);

if (setsockopt

(r->m_sb.sb_socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(tv)))

{

RTMP_Log(RTMP_LOGERROR, "%s, Setting socket timeout to %ds failed!",

__FUNCTION__, r->Link.timeout);

}

if (connect(r->m_sb.sb_socket, service, sizeof(struct sockaddr)) < 0)

{

int err = GetSockError();

RTMP_Log(RTMP_LOGERROR, "%s, failed to connect socket. %d (%s)",

__FUNCTION__, err, strerror(err));

RTMP_Close(r);

return FALSE;

}

if (r->Link.socksport)

{

RTMP_Log(RTMP_LOGDEBUG, "%s ... SOCKS negotiation", __FUNCTION__);

if (!SocksNegotiate(r))

{

RTMP_Log(RTMP_LOGERROR, "%s, SOCKS negotiation failed.", __FUNCTION__);

RTMP_Close(r);

return FALSE;

}

}

}

else

{

RTMP_Log(RTMP_LOGERROR, "%s, failed to create socket. Error: %d", __FUNCTION__,

GetSockError());

return FALSE;

}

/* set timeout */

{

SET_RCVTIMEO(tv, r->Link.timeout);

if (setsockopt

(r->m_sb.sb_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)))

{

RTMP_Log(RTMP_LOGERROR, "%s, Setting socket timeout to %ds failed!",

__FUNCTION__, r->Link.timeout);

}

}

setsockopt(r->m_sb.sb_socket, IPPROTO_TCP, TCP_NODELAY, (char *) &on, sizeof(on));

return TRUE;

}

int

RTMP_Connect1(RTMP *r, RTMPPacket *cp)

{

if (r->Link.protocol & RTMP_FEATURE_SSL)

{

#if defined(CRYPTO) && !defined(NO_SSL)

TLS_client(RTMP_TLS_ctx, r->m_sb.sb_ssl);

TLS_setfd(r->m_sb.sb_ssl, r->m_sb.sb_socket);

if (TLS_connect(r->m_sb.sb_ssl) < 0)

{

RTMP_Log(RTMP_LOGERROR, "%s, TLS_Connect failed", __FUNCTION__);

RTMP_Close(r);

return FALSE;

}

#else

RTMP_Log(RTMP_LOGERROR, "%s, no SSL/TLS support", __FUNCTION__);

RTMP_Close(r);

return FALSE;

#endif

}

if (r->Link.protocol & RTMP_FEATURE_HTTP)

{

r->m_msgCounter = 1;

r->m_clientID.av_val = NULL;

r->m_clientID.av_len = 0;

HTTP_Post(r, RTMPT_OPEN, "", 1);

HTTP_read(r, 1);

r->m_msgCounter = 0;

}

RTMP_Log(RTMP_LOGDEBUG, "%s, ... connected, handshaking", __FUNCTION__);

if (!HandShake(r, TRUE))

{

RTMP_Log(RTMP_LOGERROR, "%s, handshake failed.", __FUNCTION__);

RTMP_Close(r);

return FALSE;

}

RTMP_Log(RTMP_LOGDEBUG, "%s, handshaked", __FUNCTION__);

if (!SendConnectPacket(r, cp))

{

RTMP_Log(RTMP_LOGERROR, "%s, RTMP connect failed.", __FUNCTION__);

RTMP_Close(r);

return FALSE;

}

return TRUE;

}

int

RTMP_Connect(RTMP *r, RTMPPacket *cp)

{

struct sockaddr_in service;

if (!r->Link.hostname.av_len)

return FALSE;

memset(&service, 0, sizeof(struct sockaddr_in));

service.sin_family = AF_INET;

if (r->Link.socksport)

{

/* Connect via SOCKS */

if (!add_addr_info(&service, &r->Link.sockshost, r->Link.socksport))

return FALSE;

}

else

{

/* Connect directly */

if (!add_addr_info(&service, &r->Link.hostname, r->Link.port))

return FALSE;

}

if (!RTMP_Connect0(r, (struct sockaddr *)&service))

return FALSE;

r->m_bSendCounter = TRUE;

return RTMP_Connect1(r, cp);

}

static int

SocksNegotiate(RTMP *r)

{

unsigned long addr;

struct sockaddr_in service;

memset(&service, 0, sizeof(struct sockaddr_in));

add_addr_info(&service, &r->Link.hostname, r->Link.port);

addr = htonl(service.sin_addr.s_addr);

{

char packet[] = {

4, 1, /* SOCKS 4, connect */

(r->Link.port >> 8) & 0xFF,

(r->Link.port) & 0xFF,

(char)(addr >> 24) & 0xFF, (char)(addr >> 16) & 0xFF,

(char)(addr >> 8) & 0xFF, (char)addr & 0xFF,

0

}; /* NULL terminate */

WriteN(r, packet, sizeof packet);

if (ReadN(r, packet, 8) != 8)

return FALSE;

if (packet[0] == 0 && packet[1] == 90)

{

return TRUE;

}

else

{

RTMP_Log(RTMP_LOGERROR, "%s, SOCKS returned error code %d", packet[1]);

return FALSE;

}

}

}

int

RTMP_ConnectStream(RTMP *r, int seekTime)

{

RTMPPacket packet = { 0 };

/* seekTime was already set by SetupStream / SetupURL.

* This is only needed by ReconnectStream.

*/

if (seekTime > 0)

r->Link.seekTime = seekTime;

r->m_mediaChannel = 0;

while (!r->m_bPlaying && RTMP_IsConnected(r) && RTMP_ReadPacket(r, &packet))

{

if (RTMPPacket_IsReady(&packet))

{

if (!packet.m_nBodySize)

continue;

if ((packet.m_packetType == RTMP_PACKET_TYPE_AUDIO) ||

(packet.m_packetType == RTMP_PACKET_TYPE_VIDEO) ||

(packet.m_packetType == RTMP_PACKET_TYPE_INFO))

{

RTMP_Log(RTMP_LOGWARNING, "Received FLV packet before play()! Ignoring.");