static void* reconn_fun(void* arg){
conn_t* conn;
queue_t* q = &g_ctx.reconn_q;
rval_t rval;
int times = 1;
while(1){
conn = list_entry(deque(q), conn_t, reconn_link);
assert(conn->conn_state == CONNECTING);
assert(conn->conn_type == ACTIVE);
debug_info("start reconn conn[%d], fd[%d],%s \n",
conn->id, conn->sockfd, dump_addr(conn->addr));
rval = re_connect(conn);
if(success(rval)){
debug_info("reconn conn[%d], fd[%d] success! \n", conn->id, conn->sockfd);
set_conn_state(conn, CONNECTED);
add_event(conn);
}else{
debug_warn("reconn conn[%d], fd[%d] failed! errno[%d]\n",
conn->id, conn->sockfd, rval.err);
enque(q, &conn->reconn_link); //continue reconn
}
sleep(times);
}
}
static void *recv_data_thread(void *arg)
{
YN_real_handle_t *handle = (YN_real_handle_t *)arg;
stFrameDataInfo frame;
while (handle->stop == 0) {
if (YN_GetVideo(handle->realplay_id, &frame) == -1) {
YN_StopVideo(handle->realplay_id);
YN_Logout(handle->login_id);
if (re_connect(handle) == -1)
break;
continue;
}
handle->cbk((unsigned long)handle, 0, frame.pData,
frame.DataSize, handle->param);
YN_RealseVideo(frame);
}
if (handle->realplay_id)
YN_StopVideo(handle->realplay_id);
if (handle->login_id)
YN_Logout(handle->login_id);
free(handle);
return NULL;
}
void connection::do_read()
{
std::lock_guard<std::mutex> lock(_mutex);
if (_stopped) return;
auto self = shared_from_this();
_sock.async_read_some(asio::buffer(_read_buf), [this, self](const asio::error_code& ec, size_t bytes_transferred) {
if (ec) {
if (ec == asio::error::operation_aborted) {
return;
}
if (ec.value() != asio::error::eof) {
std::cerr << "read: " << ec.message() << std::endl;
stop();
return;
}
_parser.parse(0, 0);
if (_parser.get_error() == HPE_PAUSED) {
_requests_num++;
if (_response.get_status_code() >= 400) {
_error_code_num++;
}
_response = http_response();
re_connect();
return;
}
stop();
return;
}
_bytes_received += bytes_transferred;
_read_buf[bytes_transferred] = 0;
size_t bytes_parsed = 0;
size_t bytes_left = bytes_transferred;
for (;;) {
size_t now_bytes_parsed = _parser.parse(_read_buf + bytes_parsed, bytes_left);
auto error = _parser.get_error();
if (error != HPE_OK && error != HPE_PAUSED) {
std::cerr << _parser.get_error_name() << std::endl;
stop();
return;
}
if (error == HPE_OK) { //not enough data, read again
break;
}
//paused, must one message complete
++_requests_num;
if (_response.get_status_code() >= 400) {
++_error_code_num;
}
end_request();
//std::cout << _response.to_string() << std::endl;
_response = http_response();
_parser.set_paused(false);
if (now_bytes_parsed < bytes_left) { //still left message
//bytes_parsed += now_bytes_parsed;
//bytes_left -= now_bytes_parsed;
//continue;
std::cerr << "no pipeline support yet!" << std::endl;
stop();
return;
}
if (_parser.is_keep_alive()) {
start_request();
do_write();
}
else {
re_connect();
}
return;
}
do_read();
});
}
