external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

For #913, Service support complex error.

Browse source
This commit is contained in:
winlin 2018-01-01 11:41:15 +08:00
parent 15aea686c3
commit aebbbadf42
7 changed files with 151 additions and 208 deletions
Download patch file Download diff file Expand all files Collapse all files

24
trunk/src/protocol/srs_http_stack.cpp
View file

@ -3028,9 +3028,9 @@ SrsHttpUri::~SrsHttpUri()
{
}
int SrsHttpUri::initialize(string _url)
srs_error_t SrsHttpUri::initialize(string _url)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
schema = host = path = query = "";
@ -3038,12 +3038,9 @@ int SrsHttpUri::initialize(string _url)
const char* purl = url.c_str();
http_parser_url hp_u;
if((ret = http_parser_parse_url(purl, url.length(), 0, &hp_u)) != 0){
int code = ret;
ret = ERROR_HTTP_PARSE_URI;
srs_error("parse url %s failed, code=%d, ret=%d", purl, code, ret);
return ret;
int r0;
if((r0 = http_parser_parse_url(purl, url.length(), 0, &hp_u)) != 0){
return srs_error_new(ERROR_HTTP_PARSE_URI, "parse url %s failed, code=%d", purl, r0);
}
std::string field = get_uri_field(url, &hp_u, UF_SCHEMA);
@ -3062,12 +3059,9 @@ int SrsHttpUri::initialize(string _url)
}
path = get_uri_field(url, &hp_u, UF_PATH);
srs_info("parse url %s success", purl);
query = get_uri_field(url, &hp_u, UF_QUERY);
srs_info("parse query %s success", query.c_str());
return ret;
return err;
}
string SrsHttpUri::get_url()
@ -3106,12 +3100,6 @@ string SrsHttpUri::get_uri_field(string uri, http_parser_url* hp_u, http_parser_
return "";
}
srs_verbose("uri field matched, off=%d, len=%d, value=%.*s",
hp_u->field_data[field].off,
hp_u->field_data[field].len,
hp_u->field_data[field].len,
uri.c_str() + hp_u->field_data[field].off);
int offset = hp_u->field_data[field].off;
int len = hp_u->field_data[field].len;

2
trunk/src/protocol/srs_http_stack.hpp
View file

@ -900,7 +900,7 @@ public:
/**
* initialize the http uri.
*/
virtual int initialize(std::string _url);
virtual srs_error_t initialize(std::string _url);
public:
virtual std::string get_url();
virtual std::string get_schema();

26
trunk/src/service/srs_service_http_client.cpp
View file

@ -55,14 +55,13 @@ SrsHttpClient::~SrsHttpClient()
// TODO: FIXME: use ms for timeout.
srs_error_t SrsHttpClient::initialize(string h, int p, int64_t tm)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
srs_freep(parser);
parser = new SrsHttpParser();
if ((ret = parser->initialize(HTTP_RESPONSE, false)) != ERROR_SUCCESS) {
return srs_error_new(ret, "http: init parser");
if ((err = parser->initialize(HTTP_RESPONSE, false)) != srs_success) {
return srs_error_wrap(err, "http: init parser");
}
// Always disconnect the transport.
@ -97,7 +96,6 @@ srs_error_t SrsHttpClient::post(string path, string req, ISrsHttpMessage** ppmsg
{
*ppmsg = NULL;
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// always set the content length.
@ -119,15 +117,15 @@ srs_error_t SrsHttpClient::post(string path, string req, ISrsHttpMessage** ppmsg
ss << SRS_HTTP_CRLF << req;
std::string data = ss.str();
if ((ret = transport->write((void*)data.c_str(), data.length(), NULL)) != ERROR_SUCCESS) {
if ((err = transport->write((void*)data.c_str(), data.length(), NULL)) != srs_success) {
// Disconnect the transport when channel error, reconnect for next operation.
disconnect();
return srs_error_new(ret, "http: write");
return srs_error_wrap(err, "http: write");
}
ISrsHttpMessage* msg = NULL;
if ((ret = parser->parse_message(transport, NULL, &msg)) != ERROR_SUCCESS) {
return srs_error_new(ret, "http: parse response");
if ((err = parser->parse_message(transport, NULL, &msg)) != srs_success) {
return srs_error_wrap(err, "http: parse response");
}
srs_assert(msg);
@ -136,7 +134,6 @@ srs_error_t SrsHttpClient::post(string path, string req, ISrsHttpMessage** ppmsg
} else {
srs_freep(msg);
}
srs_info("parse http post response success.");
return err;
}
@ -145,7 +142,6 @@ srs_error_t SrsHttpClient::get(string path, string req, ISrsHttpMessage** ppmsg)
{
*ppmsg = NULL;
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// always set the content length.
@ -167,15 +163,15 @@ srs_error_t SrsHttpClient::get(string path, string req, ISrsHttpMessage** ppmsg)
ss << SRS_HTTP_CRLF << req;
std::string data = ss.str();
if ((ret = transport->write((void*)data.c_str(), data.length(), NULL)) != ERROR_SUCCESS) {
if ((err = transport->write((void*)data.c_str(), data.length(), NULL)) != srs_success) {
// Disconnect the transport when channel error, reconnect for next operation.
disconnect();
return srs_error_new(ret, "http: write");
return srs_error_wrap(err, "http: write");
}
ISrsHttpMessage* msg = NULL;
if ((ret = parser->parse_message(transport, NULL, &msg)) != ERROR_SUCCESS) {
return srs_error_new(ret, "http: parse response");
if ((err = parser->parse_message(transport, NULL, &msg)) != srs_success) {
return srs_error_wrap(err, "http: parse response");
}
srs_assert(msg);
@ -184,7 +180,6 @@ srs_error_t SrsHttpClient::get(string path, string req, ISrsHttpMessage** ppmsg)
} else {
srs_freep(msg);
}
srs_info("parse http get response success.");
return err;
}
@ -228,7 +223,6 @@ srs_error_t SrsHttpClient::connect()
disconnect();
return srs_error_wrap(err, "http: tcp connect %s:%d to=%d", host.c_str(), port, (int)timeout);
}
srs_info("connect to server success. server=%s, port=%d", host.c_str(), port);
// Set the recv/send timeout in ms.
transport->set_recv_timeout(timeout);

190
trunk/src/service/srs_service_http_conn.cpp
View file

@ -46,9 +46,9 @@ SrsHttpParser::~SrsHttpParser()
srs_freep(buffer);
}
int SrsHttpParser::initialize(enum http_parser_type type, bool allow_jsonp)
srs_error_t SrsHttpParser::initialize(enum http_parser_type type, bool allow_jsonp)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
jsonp = allow_jsonp;
@ -65,14 +65,14 @@ int SrsHttpParser::initialize(enum http_parser_type type, bool allow_jsonp)
// callback object ptr.
parser.data = (void*)this;
return ret;
return err;
}
int SrsHttpParser::parse_message(ISrsProtocolReaderWriter* io, SrsConnection* conn, ISrsHttpMessage** ppmsg)
srs_error_t SrsHttpParser::parse_message(ISrsProtocolReaderWriter* io, SrsConnection* conn, ISrsHttpMessage** ppmsg)
{
*ppmsg = NULL;
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// reset request data.
field_name = "";
@ -85,32 +85,28 @@ int SrsHttpParser::parse_message(ISrsProtocolReaderWriter* io, SrsConnection* co
header_parsed = 0;
// do parse
if ((ret = parse_message_imp(io)) != ERROR_SUCCESS) {
if (!srs_is_client_gracefully_close(ret)) {
srs_error("parse http msg failed. ret=%d", ret);
}
return ret;
if ((err = parse_message_imp(io)) != srs_success) {
return srs_error_wrap(err, "parse message");
}
// create msg
SrsHttpMessage* msg = new SrsHttpMessage(io, conn);
// initalize http msg, parse url.
if ((ret = msg->update(url, jsonp, &header, buffer, headers)) != ERROR_SUCCESS) {
srs_error("initialize http msg failed. ret=%d", ret);
if ((err = msg->update(url, jsonp, &header, buffer, headers)) != srs_success) {
srs_freep(msg);
return ret;
return srs_error_wrap(err, "update message");
}
// parse ok, return the msg.
*ppmsg = msg;
return ret;
return err;
}
int SrsHttpParser::parse_message_imp(ISrsProtocolReaderWriter* io)
srs_error_t SrsHttpParser::parse_message_imp(ISrsProtocolReaderWriter* io)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
while (true) {
ssize_t nparsed = 0;
@ -142,11 +138,8 @@ int SrsHttpParser::parse_message_imp(ISrsProtocolReaderWriter* io)
// when nothing parsed, read more to parse.
if (nparsed == 0) {
// when requires more, only grow 1bytes, but the buffer will cache more.
if ((ret = buffer->grow(io, buffer->size() + 1)) != ERROR_SUCCESS) {
if (!srs_is_client_gracefully_close(ret)) {
srs_error("read body from server failed. ret=%d", ret);
}
return ret;
if ((err = buffer->grow(io, buffer->size() + 1)) != srs_success) {
return srs_error_wrap(err, "grow buffer");
}
}
}
@ -156,7 +149,7 @@ int SrsHttpParser::parse_message_imp(ISrsProtocolReaderWriter* io)
headers.push_back(std::make_pair(field_name, field_value));
}
return ret;
return err;
}
int SrsHttpParser::on_message_begin(http_parser* parser)
@ -280,9 +273,9 @@ SrsHttpMessage::~SrsHttpMessage()
srs_freepa(_http_ts_send_buffer);
}
int SrsHttpMessage::update(string url, bool allow_jsonp, http_parser* header, SrsFastStream* body, vector<SrsHttpHeaderField>& headers)
srs_error_t SrsHttpMessage::update(string url, bool allow_jsonp, http_parser* header, SrsFastStream* body, vector<SrsHttpHeaderField>& headers)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
_url = url;
_header = *header;
@ -296,8 +289,8 @@ int SrsHttpMessage::update(string url, bool allow_jsonp, http_parser* header, Sr
keep_alive = http_should_keep_alive(header);
// set the buffer.
if ((ret = _body->initialize(body)) != ERROR_SUCCESS) {
return ret;
if ((err = _body->initialize(body)) != srs_success) {
return srs_error_wrap(err, "init body");
}
// parse uri from url.
@ -311,8 +304,8 @@ int SrsHttpMessage::update(string url, bool allow_jsonp, http_parser* header, Sr
// parse uri to schema/server:port/path?query
std::string uri = "http://" + host + _url;
if ((ret = _uri->initialize(uri)) != ERROR_SUCCESS) {
return ret;
if ((err = _uri->initialize(uri)) != srs_success) {
return srs_error_wrap(err, "init uri");
}
// parse ext.
@ -331,7 +324,7 @@ int SrsHttpMessage::update(string url, bool allow_jsonp, http_parser* header, Sr
}
}
return ret;
return err;
}
SrsConnection* SrsHttpMessage::connection()
@ -480,28 +473,26 @@ int SrsHttpMessage::parse_rest_id(string pattern)
return -1;
}
int SrsHttpMessage::enter_infinite_chunked()
srs_error_t SrsHttpMessage::enter_infinite_chunked()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (infinite_chunked) {
return ret;
return err;
}
if (is_chunked() || content_length() != -1) {
ret = ERROR_HTTP_DATA_INVALID;
srs_error("infinite chunkted not supported in specified codec. ret=%d", ret);
return ret;
return srs_error_new(ERROR_HTTP_DATA_INVALID, "not infinited chunked");
}
infinite_chunked = true;
return ret;
return err;
}
int SrsHttpMessage::body_read_all(string& body)
srs_error_t SrsHttpMessage::body_read_all(string& body)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// cache to read.
char* buf = new char[SRS_HTTP_READ_CACHE_BYTES];
@ -510,8 +501,8 @@ int SrsHttpMessage::body_read_all(string& body)
// whatever, read util EOF.
while (!_body->eof()) {
int nb_read = 0;
if ((ret = _body->read(buf, SRS_HTTP_READ_CACHE_BYTES, &nb_read)) != ERROR_SUCCESS) {
return ret;
if ((err = _body->read(buf, SRS_HTTP_READ_CACHE_BYTES, &nb_read)) != srs_success) {
return srs_error_wrap(err, "read body");
}
if (nb_read > 0) {
@ -519,7 +510,7 @@ int SrsHttpMessage::body_read_all(string& body)
}
}
return ret;
return err;
}
ISrsHttpResponseReader* SrsHttpMessage::body_reader()
@ -633,7 +624,7 @@ SrsHttpResponseWriter::~SrsHttpResponseWriter()
srs_freepa(iovss_cache);
}
int SrsHttpResponseWriter::final_request()
srs_error_t SrsHttpResponseWriter::final_request()
{
// write the header data in memory.
if (!header_wrote) {
@ -657,9 +648,9 @@ SrsHttpHeader* SrsHttpResponseWriter::header()
return hdr;
}
int SrsHttpResponseWriter::write(char* data, int size)
srs_error_t SrsHttpResponseWriter::write(char* data, int size)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// write the header data in memory.
if (!header_wrote) {
@ -667,22 +658,19 @@ int SrsHttpResponseWriter::write(char* data, int size)
}
// whatever header is wrote, we should try to send header.
if ((ret = send_header(data, size)) != ERROR_SUCCESS) {
srs_error("http: send header failed. ret=%d", ret);
return ret;
if ((err = send_header(data, size)) != srs_success) {
return srs_error_wrap(err, "send header");
}
// check the bytes send and content length.
written += size;
if (content_length != -1 && written > content_length) {
ret = ERROR_HTTP_CONTENT_LENGTH;
srs_error("http: exceed content length. ret=%d", ret);
return ret;
return srs_error_new(ERROR_HTTP_CONTENT_LENGTH, "overflow writen=%d, max=%d", (int)written, (int)content_length);
}
// ignore NULL content.
if (!data) {
return ret;
return err;
}
// directly send with content length
@ -704,16 +692,16 @@ int SrsHttpResponseWriter::write(char* data, int size)
iovs[3].iov_len = 2;
ssize_t nwrite;
if ((ret = skt->writev(iovs, 4, &nwrite)) != ERROR_SUCCESS) {
return ret;
if ((err = skt->writev(iovs, 4, &nwrite)) != srs_success) {
return srs_error_wrap(err, "write chunk");
}
return ret;
return err;
}
int SrsHttpResponseWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite)
srs_error_t SrsHttpResponseWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// when header not ready, or not chunked, send one by one.
if (!header_wrote || content_length != -1) {
@ -721,8 +709,8 @@ int SrsHttpResponseWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite
for (int i = 0; i < iovcnt; i++) {
const iovec* piovc = iov + i;
nwrite += piovc->iov_len;
if ((ret = write((char*)piovc->iov_base, (int)piovc->iov_len)) != ERROR_SUCCESS) {
return ret;
if ((err = write((char*)piovc->iov_base, (int)piovc->iov_len)) != srs_success) {
return srs_error_wrap(err, "writev");
}
}
@ -730,12 +718,12 @@ int SrsHttpResponseWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite
*pnwrite = nwrite;
}
return ret;
return err;
}
// ignore NULL content.
if (iovcnt <= 0) {
return ret;
return err;
}
// send in chunked encoding.
@ -784,15 +772,15 @@ int SrsHttpResponseWriter::writev(const iovec* iov, int iovcnt, ssize_t* pnwrite
// sendout all ioves.
ssize_t nwrite;
if ((ret = srs_write_large_iovs(skt, iovss, nb_iovss, &nwrite)) != ERROR_SUCCESS) {
return ret;
if ((err = srs_write_large_iovs(skt, iovss, nb_iovss, &nwrite)) != srs_success) {
return srs_error_wrap(err, "writev large iovs");
}
if (pnwrite) {
*pnwrite = nwrite;
}
return ret;
return err;
}
void SrsHttpResponseWriter::write_header(int code)
@ -809,12 +797,12 @@ void SrsHttpResponseWriter::write_header(int code)
content_length = hdr->content_length();
}
int SrsHttpResponseWriter::send_header(char* data, int size)
srs_error_t SrsHttpResponseWriter::send_header(char* data, int size)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (header_sent) {
return ret;
return err;
}
header_sent = true;
@ -868,16 +856,16 @@ SrsHttpResponseReader::~SrsHttpResponseReader()
{
}
int SrsHttpResponseReader::initialize(SrsFastStream* body)
srs_error_t SrsHttpResponseReader::initialize(SrsFastStream* body)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
nb_chunk = 0;
nb_left_chunk = 0;
nb_total_read = 0;
buffer = body;
return ret;
return err;
}
bool SrsHttpResponseReader::eof()
@ -885,14 +873,12 @@ bool SrsHttpResponseReader::eof()
return is_eof;
}
int SrsHttpResponseReader::read(char* data, int nb_data, int* nb_read)
srs_error_t SrsHttpResponseReader::read(char* data, int nb_data, int* nb_read)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (is_eof) {
ret = ERROR_HTTP_RESPONSE_EOF;
srs_error("http: response EOF. ret=%d", ret);
return ret;
return srs_error_new(ERROR_HTTP_RESPONSE_EOF, "EOF");
}
// chunked encoding.
@ -905,7 +891,7 @@ int SrsHttpResponseReader::read(char* data, int nb_data, int* nb_read)
int max = (int)owner->content_length() - (int)nb_total_read;
if (max <= 0) {
is_eof = true;
return ret;
return err;
}
// change the max to read.
@ -923,12 +909,12 @@ int SrsHttpResponseReader::read(char* data, int nb_data, int* nb_read)
// we think there is no data left.
is_eof = true;
return ret;
return err;
}
int SrsHttpResponseReader::read_chunked(char* data, int nb_data, int* nb_read)
srs_error_t SrsHttpResponseReader::read_chunked(char* data, int nb_data, int* nb_read)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// when no bytes left in chunk,
// parse the chunk length first.
@ -943,9 +929,7 @@ int SrsHttpResponseReader::read_chunked(char* data, int nb_data, int* nb_read)
if (p[0] == SRS_HTTP_CR && p[1] == SRS_HTTP_LF) {
// invalid chunk, ignore.
if (p == start) {
ret = ERROR_HTTP_INVALID_CHUNK_HEADER;
srs_error("chunk header start with CRLF. ret=%d", ret);
return ret;
return srs_error_new(ERROR_HTTP_INVALID_CHUNK_HEADER, "chunk header");
}
length = (int)(p - start + 2);
at = buffer->read_slice(length);
@ -959,11 +943,8 @@ int SrsHttpResponseReader::read_chunked(char* data, int nb_data, int* nb_read)
}
// when empty, only grow 1bytes, but the buffer will cache more.
if ((ret = buffer->grow(skt, buffer->size() + 1)) != ERROR_SUCCESS) {
if (!srs_is_client_gracefully_close(ret)) {
srs_error("read body from server failed. ret=%d", ret);
}
return ret;
if ((err = buffer->grow(skt, buffer->size() + 1)) != srs_success) {
return srs_error_wrap(err, "grow buffer");
}
}
srs_assert(length >= 3);
@ -975,9 +956,7 @@ int SrsHttpResponseReader::read_chunked(char* data, int nb_data, int* nb_read)
// size is the bytes size, excludes the chunk header and end CRLF.
int ilength = (int)::strtol(at, NULL, 16);
if (ilength < 0) {
ret = ERROR_HTTP_INVALID_CHUNK_HEADER;
srs_error("chunk header negative, length=%d. ret=%d", ilength, ret);
return ret;
return srs_error_new(ERROR_HTTP_INVALID_CHUNK_HEADER, "invalid length=%d", ilength);
}
// all bytes in chunk is left now.
@ -993,45 +972,40 @@ int SrsHttpResponseReader::read_chunked(char* data, int nb_data, int* nb_read)
srs_assert(nb_left_chunk);
int nb_bytes = srs_min(nb_left_chunk, nb_data);
ret = read_specified(data, nb_bytes, &nb_bytes);
err = read_specified(data, nb_bytes, &nb_bytes);
// the nb_bytes used for output already read size of bytes.
if (nb_read) {
*nb_read = nb_bytes;
}
nb_left_chunk -= nb_bytes;
srs_info("http: read %d bytes of chunk", nb_bytes);
// error or still left bytes in chunk, ignore and read in future.
if (nb_left_chunk > 0 || (ret != ERROR_SUCCESS)) {
return ret;
if (err != srs_success) {
return srs_error_wrap(err, "read specified");
}
if (nb_left_chunk > 0) {
return srs_error_new(ERROR_HTTP_INVALID_CHUNK_HEADER, "read specified left=%d", nb_left_chunk);
}
srs_info("http: read total chunk %dB", nb_chunk);
}
// for both the last or not, the CRLF of chunk payload end.
if ((ret = buffer->grow(skt, 2)) != ERROR_SUCCESS) {
if (!srs_is_client_gracefully_close(ret)) {
srs_error("read EOF of chunk from server failed. ret=%d", ret);
}
return ret;
if ((err = buffer->grow(skt, 2)) != srs_success) {
return srs_error_wrap(err, "grow buffer");
}
buffer->read_slice(2);
return ret;
return err;
}
int SrsHttpResponseReader::read_specified(char* data, int nb_data, int* nb_read)
srs_error_t SrsHttpResponseReader::read_specified(char* data, int nb_data, int* nb_read)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if (buffer->size() <= 0) {
// when empty, only grow 1bytes, but the buffer will cache more.
if ((ret = buffer->grow(skt, 1)) != ERROR_SUCCESS) {
if (!srs_is_client_gracefully_close(ret)) {
srs_error("read body from server failed. ret=%d", ret);
}
return ret;
if ((err = buffer->grow(skt, 1)) != srs_success) {
return srs_error_wrap(err, "grow buffer");
}
}
@ -1056,6 +1030,6 @@ int SrsHttpResponseReader::read_specified(char* data, int nb_data, int* nb_read)
}
}
return ret;
return err;
}

28
trunk/src/service/srs_service_http_conn.hpp
View file

@ -69,7 +69,7 @@ public:
* one parser can only parse request or response messages.
* @param allow_jsonp whether allow jsonp parser, which indicates the method in query string.
*/
virtual int initialize(enum http_parser_type type, bool allow_jsonp);
virtual srs_error_t initialize(enum http_parser_type type, bool allow_jsonp);
/**
* always parse a http message,
* that is, the *ppmsg always NOT-NULL when return success.
@ -77,12 +77,12 @@ public:
* @remark, if success, *ppmsg always NOT-NULL, *ppmsg always is_complete().
* @remark user must free the ppmsg if not NULL.
*/
virtual int parse_message(ISrsProtocolReaderWriter* io, SrsConnection* conn, ISrsHttpMessage** ppmsg);
virtual srs_error_t parse_message(ISrsProtocolReaderWriter* io, SrsConnection* conn, ISrsHttpMessage** ppmsg);
private:
/**
* parse the HTTP message to member field: msg.
*/
virtual int parse_message_imp(ISrsProtocolReaderWriter* io);
virtual srs_error_t parse_message_imp(ISrsProtocolReaderWriter* io);
private:
static int on_message_begin(http_parser* parser);
static int on_headers_complete(http_parser* parser);
@ -161,7 +161,7 @@ public:
/**
* set the original messages, then update the message.
*/
virtual int update(std::string url, bool allow_jsonp, http_parser* header, SrsFastStream* body, std::vector<SrsHttpHeaderField>& headers);
virtual srs_error_t update(std::string url, bool allow_jsonp, http_parser* header, SrsFastStream* body, std::vector<SrsHttpHeaderField>& headers);
public:
virtual SrsConnection* connection();
public:
@ -206,13 +206,13 @@ public:
*/
virtual int parse_rest_id(std::string pattern);
public:
virtual int enter_infinite_chunked();
virtual srs_error_t enter_infinite_chunked();
public:
/**
* read body to string.
* @remark for small http body.
*/
virtual int body_read_all(std::string& body);
virtual srs_error_t body_read_all(std::string& body);
/**
* get the body reader, to read one by one.
* @remark when body is very large, or chunked, use this.
@ -281,12 +281,12 @@ public:
SrsHttpResponseWriter(SrsStSocket* io);
virtual ~SrsHttpResponseWriter();
public:
virtual int final_request();
virtual srs_error_t final_request();
virtual SrsHttpHeader* header();
virtual int write(char* data, int size);
virtual int writev(const iovec* iov, int iovcnt, ssize_t* pnwrite);
virtual srs_error_t write(char* data, int size);
virtual srs_error_t writev(const iovec* iov, int iovcnt, ssize_t* pnwrite);
virtual void write_header(int code);
virtual int send_header(char* data, int size);
virtual srs_error_t send_header(char* data, int size);
};
/**
@ -312,14 +312,14 @@ public:
/**
* initialize the response reader with buffer.
*/
virtual int initialize(SrsFastStream* buffer);
virtual srs_error_t initialize(SrsFastStream* buffer);
// interface ISrsHttpResponseReader
public:
virtual bool eof();
virtual int read(char* data, int nb_data, int* nb_read);
virtual srs_error_t read(char* data, int nb_data, int* nb_read);
private:
virtual int read_chunked(char* data, int nb_data, int* nb_read);
virtual int read_specified(char* data, int nb_data, int* nb_read);
virtual srs_error_t read_chunked(char* data, int nb_data, int* nb_read);
virtual srs_error_t read_specified(char* data, int nb_data, int* nb_read);
};
#endif

71
trunk/src/service/srs_service_rtmp_conn.cpp
View file

@ -57,9 +57,8 @@ SrsBasicRtmpClient::~SrsBasicRtmpClient()
srs_freep(kbps);
}
int SrsBasicRtmpClient::connect()
srs_error_t SrsBasicRtmpClient::connect()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
close();
@ -70,30 +69,24 @@ int SrsBasicRtmpClient::connect()
if ((err = transport->connect()) != srs_success) {
close();
// TODO: FIXME: Use error
ret = srs_error_code(err);
srs_freep(err);
return ret;
return srs_error_wrap(err, "connect");
}
client->set_recv_timeout(stream_timeout);
client->set_send_timeout(stream_timeout);
// connect to vhost/app
if ((ret = client->handshake()) != ERROR_SUCCESS) {
srs_error("sdk: handshake with server failed. ret=%d", ret);
return ret;
if ((err = client->handshake()) != srs_success) {
return srs_error_wrap(err, "handshake");
}
if ((ret = connect_app()) != ERROR_SUCCESS) {
srs_error("sdk: connect with server failed. ret=%d", ret);
return ret;
if ((err = connect_app()) != srs_success) {
return srs_error_wrap(err, "connect app");
}
if ((ret = client->create_stream(stream_id)) != ERROR_SUCCESS) {
srs_error("sdk: connect with server failed, stream_id=%d. ret=%d", stream_id, ret);
return ret;
if ((err = client->create_stream(stream_id)) != srs_success) {
return srs_error_wrap(err, "create stream_id=%d", stream_id);
}
return ret;
return err;
}
void SrsBasicRtmpClient::close()
@ -103,14 +96,14 @@ void SrsBasicRtmpClient::close()
srs_freep(transport);
}
int SrsBasicRtmpClient::connect_app()
srs_error_t SrsBasicRtmpClient::connect_app()
{
return do_connect_app(srs_get_public_internet_address(), false);
}
int SrsBasicRtmpClient::do_connect_app(string local_ip, bool debug)
srs_error_t SrsBasicRtmpClient::do_connect_app(string local_ip, bool debug)
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// args of request takes the srs info.
if (req->args == NULL) {
@ -150,40 +143,34 @@ int SrsBasicRtmpClient::do_connect_app(string local_ip, bool debug)
// upnode server identity will show in the connect_app of client.
// @see https://github.com/ossrs/srs/issues/160
// the debug_srs_upnode is config in vhost and default to true.
if ((ret = client->connect_app(req->app, tc_url, req, debug, NULL)) != ERROR_SUCCESS) {
srs_error("sdk: connect with server failed, tcUrl=%s, dsu=%d. ret=%d",
tc_url.c_str(), debug, ret);
return ret;
if ((err = client->connect_app(req->app, tc_url, req, debug, NULL)) != srs_success) {
return srs_error_wrap(err, "connect app tcUrl=%s, debug=%d", tc_url.c_str(), debug);
}
return ret;
return err;
}
int SrsBasicRtmpClient::publish()
srs_error_t SrsBasicRtmpClient::publish()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
// publish.
if ((ret = client->publish(req->stream, stream_id)) != ERROR_SUCCESS) {
srs_error("sdk: publish failed, stream=%s, stream_id=%d. ret=%d",
req->stream.c_str(), stream_id, ret);
return ret;
if ((err = client->publish(req->stream, stream_id)) != srs_success) {
return srs_error_wrap(err, "publish failed, stream=%s, stream_id=%d", req->stream.c_str(), stream_id);
}
return ret;
return err;
}
int SrsBasicRtmpClient::play()
srs_error_t SrsBasicRtmpClient::play()
{
int ret = ERROR_SUCCESS;
srs_error_t err = srs_success;
if ((ret = client->play(req->stream, stream_id)) != ERROR_SUCCESS) {
srs_error("connect with server failed, stream=%s, stream_id=%d. ret=%d",
req->stream.c_str(), stream_id, ret);
return ret;
if ((err = client->play(req->stream, stream_id)) != srs_success) {
return srs_error_wrap(err, "connect with server failed, stream=%s, stream_id=%d", req->stream.c_str(), stream_id);
}
return ret;
return err;
}
void SrsBasicRtmpClient::kbps_sample(const char* label, int64_t age)
@ -219,22 +206,22 @@ int SrsBasicRtmpClient::sid()
return stream_id;
}
int SrsBasicRtmpClient::recv_message(SrsCommonMessage** pmsg)
srs_error_t SrsBasicRtmpClient::recv_message(SrsCommonMessage** pmsg)
{
return client->recv_message(pmsg);
}
int SrsBasicRtmpClient::decode_message(SrsCommonMessage* msg, SrsPacket** ppacket)
srs_error_t SrsBasicRtmpClient::decode_message(SrsCommonMessage* msg, SrsPacket** ppacket)
{
return client->decode_message(msg, ppacket);
}
int SrsBasicRtmpClient::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
srs_error_t SrsBasicRtmpClient::send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs)
{
return client->send_and_free_messages(msgs, nb_msgs, stream_id);
}
int SrsBasicRtmpClient::send_and_free_message(SrsSharedPtrMessage* msg)
srs_error_t SrsBasicRtmpClient::send_and_free_message(SrsSharedPtrMessage* msg)
{
return client->send_and_free_message(msg, stream_id);
}

18
trunk/src/service/srs_service_rtmp_conn.hpp
View file

@ -68,22 +68,22 @@ public:
public:
// Connect, handshake and connect app to RTMP server.
// @remark We always close the transport.
virtual int connect();
virtual srs_error_t connect();
virtual void close();
protected:
virtual int connect_app();
virtual int do_connect_app(std::string local_ip, bool debug);
virtual srs_error_t connect_app();
virtual srs_error_t do_connect_app(std::string local_ip, bool debug);
public:
virtual int publish();
virtual int play();
virtual srs_error_t publish();
virtual srs_error_t play();
virtual void kbps_sample(const char* label, int64_t age);
virtual void kbps_sample(const char* label, int64_t age, int msgs);
virtual int sid();
public:
virtual int recv_message(SrsCommonMessage** pmsg);
virtual int decode_message(SrsCommonMessage* msg, SrsPacket** ppacket);
virtual int send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs);
virtual int send_and_free_message(SrsSharedPtrMessage* msg);
virtual srs_error_t recv_message(SrsCommonMessage** pmsg);
virtual srs_error_t decode_message(SrsCommonMessage* msg, SrsPacket** ppacket);
virtual srs_error_t send_and_free_messages(SrsSharedPtrMessage** msgs, int nb_msgs);
virtual srs_error_t send_and_free_message(SrsSharedPtrMessage* msg);
public:
virtual void set_recv_timeout(int64_t timeout);
};