static apt_bool_t mrcp_server_agent_listen_socket_create(mrcp_connection_agent_t *agent)
{
apr_status_t status;
if(!agent->sockaddr) {
return FALSE;
}
/* create listening socket */
status = apr_socket_create(&agent->listen_sock, agent->sockaddr->family, SOCK_STREAM, APR_PROTO_TCP, agent->pool);
if(status != APR_SUCCESS) {
return FALSE;
}
apr_socket_opt_set(agent->listen_sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(agent->listen_sock, -1);
apr_socket_opt_set(agent->listen_sock, APR_SO_REUSEADDR, 1);
status = apr_socket_bind(agent->listen_sock, agent->sockaddr);
if(status != APR_SUCCESS) {
apr_socket_close(agent->listen_sock);
agent->listen_sock = NULL;
return FALSE;
}
status = apr_socket_listen(agent->listen_sock, SOMAXCONN);
if(status != APR_SUCCESS) {
apr_socket_close(agent->listen_sock);
agent->listen_sock = NULL;
return FALSE;
}
return TRUE;
}
void server_bind_listen(server_t *svr) {
apr_sockaddr_info_get(&svr->comm->sa, NULL, APR_INET,
svr->comm->port, 0, svr->comm->mp);
/*
apr_socket_create(&r->s, r->sa->family, SOCK_DGRAM, APR_PROTO_UDP, r->pl_recv);
*/
apr_socket_create(&svr->comm->s, svr->comm->sa->family,
SOCK_STREAM, APR_PROTO_TCP, svr->comm->mp);
apr_socket_opt_set(svr->comm->s, APR_SO_NONBLOCK, 1);
apr_socket_timeout_set(svr->comm->s, -1);
/* this is useful for a server(socket listening) process */
apr_socket_opt_set(svr->comm->s, APR_SO_REUSEADDR, 1);
apr_socket_opt_set(svr->comm->s, APR_TCP_NODELAY, 1);
apr_status_t status = APR_SUCCESS;
status = apr_socket_bind(svr->comm->s, svr->comm->sa);
if (status != APR_SUCCESS) {
LOG_ERROR("cannot bind.");
printf("%s", apr_strerror(status, malloc(100), 100));
SAFE_ASSERT(status == APR_SUCCESS);
}
status = apr_socket_listen(svr->comm->s, 30000); // This is important!
if (status != APR_SUCCESS) {
LOG_ERROR("cannot listen.");
printf("%s", apr_strerror(status, malloc(100), 100));
SAFE_ASSERT(status == APR_SUCCESS);
}
LOG_INFO("successfuly bind and listen on port %d.", svr->comm->port);
}
int sock_bind(net_sock_t *nsock, char *address, int port)
{
int err;
network_sock_t *sock = (network_sock_t *)nsock;
if (sock == NULL) return(1);
log_printf(10, "sock_bind: host=%s:%d\n", address, port);
// err = apr_sockaddr_info_get(&(sock->sa), address, APR_INET, port, APR_IPV4_ADDR_OK, sock->mpool);
err = apr_sockaddr_info_get(&(sock->sa), address, APR_INET, port, 0, sock->mpool);
//log_printf(10, "sock_bind: apr_sockaddr_info_get=%d APR_SUCCESS=%d\n", err, APR_SUCCESS);
if (err != APR_SUCCESS) return(err);
err = apr_socket_create(&(sock->fd), APR_INET, SOCK_STREAM, APR_PROTO_TCP, sock->mpool);
//log_printf(10, "sock_bind: apr_socket_create=%d APR_SUCCESS=%d\n", err, APR_SUCCESS);
if (err != APR_SUCCESS) return(err);
apr_socket_opt_set(sock->fd, APR_SO_NONBLOCK, 1);
apr_socket_opt_set(sock->fd, APR_SO_REUSEADDR, 1);
//log_printf(10, "sock_bind: apr_socket_opt_set=%d APR_SUCCESS=%d\n", err, APR_SUCCESS);
if (sock->tcpsize > 0) {
apr_socket_opt_set(sock->fd, APR_SO_SNDBUF, sock->tcpsize);
apr_socket_opt_set(sock->fd, APR_SO_RCVBUF, sock->tcpsize);
}
err = apr_socket_bind(sock->fd, sock->sa);
log_printf(10, "sock_bind: apr_socket_bind=%d APR_SUCCESS=%d\n", err, APR_SUCCESS);
return(err);
}
/**
* Create a listening socket, and listen it.
*/
static apr_status_t do_listen(apr_socket_t **sock, apr_pool_t *mp, int port)
{
apr_status_t rv;
apr_socket_t *s;
apr_sockaddr_t *sa;
rv = apr_sockaddr_info_get(&sa, NULL, APR_INET, port, 0, mp);
if (rv != APR_SUCCESS) {
return rv;
}
rv = apr_socket_create(&s, sa->family, SOCK_STREAM, APR_PROTO_TCP, mp);
if (rv != APR_SUCCESS) {
return rv;
}
/* it is a good idea to specify socket options explicitly.
* in this case, we make a blocking socket as the listening socket */
apr_socket_opt_set(s, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(s, 100);
apr_socket_opt_set(s, APR_SO_REUSEADDR, 1);/* this is useful for a server(socket listening) process */
rv = apr_socket_bind(s, sa);
if (rv != APR_SUCCESS) {
return rv;
}
rv = apr_socket_listen(s, DEF_SOCKET_BACKLOG);
if (rv != APR_SUCCESS) {
return rv;
}
*sock = s;
return rv;
}
static apr_socket_t* mpf_socket_create(apr_sockaddr_t **l_sockaddr, const char *ip, apr_port_t port, apr_pool_t *pool)
{
apr_socket_t *socket = NULL;
*l_sockaddr = NULL;
apr_sockaddr_info_get(
l_sockaddr,
ip,
APR_INET,
port,
0,
pool);
if(!*l_sockaddr) {
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Failed to Get Sockaddr %s:%hu",ip,port);
return NULL;
}
if(apr_socket_create(&socket,(*l_sockaddr)->family,SOCK_DGRAM,0,pool) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Failed to Create Socket %s:%hu", ip,port);
return NULL;
}
apr_socket_opt_set(socket,APR_SO_NONBLOCK,1);
apr_socket_timeout_set(socket,0);
apr_socket_opt_set(socket,APR_SO_REUSEADDR,1);
if(apr_socket_bind(socket,*l_sockaddr) != APR_SUCCESS) {
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Failed to Bind Socket to %s:%hu", ip,port);
apr_socket_close(socket);
return NULL;
}
return socket;
}
static apr_socket_t* create_listen_sock(apr_pool_t *mp, unsigned short channel)
{
apr_status_t rv;
apr_socket_t *s;
apr_sockaddr_t *sa;
rv = apr_sockaddr_info_get(&sa, NULL, APR_INET, DEF_LISTEN_PORT+channel, 0, mp); // Create apr_sockaddr_t from hostname, address family, and port.
if (rv != APR_SUCCESS)
return NULL;
rv = apr_socket_create(&s, sa->family, SOCK_STREAM, APR_PROTO_TCP, mp); //CREATE A SOCKET
if (rv != APR_SUCCESS)
return NULL;
/* non-blocking socket */
apr_socket_opt_set(s, APR_SO_NONBLOCK, 1); //Setup socket options for the specified socke
apr_socket_timeout_set(s, 0); //Setup socket timeout for the specified socket
apr_socket_opt_set(s, APR_SO_REUSEADDR, 1);/* this is useful for a server(socket listening) process */
rv = apr_socket_bind(s, sa); //Bind the socket to its associated port
if (rv != APR_SUCCESS)
return NULL;
rv = apr_socket_listen(s, DEF_SOCKET_BACKLOG); //Listen to a bound socket for connections.
if (rv != APR_SUCCESS)
return NULL;
return s;
}
static void corkable(CuTest *tc)
{
#if !APR_HAVE_CORKABLE_TCP
CuNotImpl(tc, "TCP isn't corkable");
#else
apr_status_t rv;
apr_int32_t ck;
rv = apr_socket_opt_set(sock, APR_TCP_NODELAY, 1);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_socket_opt_get(sock, APR_TCP_NODELAY, &ck);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, 1, ck);
rv = apr_socket_opt_set(sock, APR_TCP_NOPUSH, 1);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_socket_opt_get(sock, APR_TCP_NOPUSH, &ck);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, 1, ck);
rv = apr_socket_opt_get(sock, APR_TCP_NODELAY, &ck);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, 0, ck);
rv = apr_socket_opt_set(sock, APR_TCP_NOPUSH, 0);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
rv = apr_socket_opt_get(sock, APR_TCP_NODELAY, &ck);
CuAssertIntEquals(tc, APR_SUCCESS, rv);
CuAssertIntEquals(tc, 1, ck);
#endif
}
apr_status_t jxr_get_request_if_any(jaxer_connection *ac, char** pbuf)
{
apr_status_t rv = APR_SUCCESS;
request_rec *r = ac->request;
server_rec *main_server = r->server;
apr_socket_t *sock = ac->sock;
struct timeval tv;
fd_set fdread;
int rc;
*pbuf = 0;
rv = apr_socket_opt_set(sock, APR_SO_NONBLOCK, 1);
if (rv != APR_SUCCESS)
{
compat_log_rerror(APLOG_MARK, APLOG_WARNING, rv, r, "mod_jaxer: turn on non-blocking failed");
ac->has_error = 1;
return rv;
}
tv.tv_sec = 0;
tv.tv_usec = 0;
FD_ZERO(&fdread);
FD_SET(((partial_apr_socket_t*)sock)->socketdes, &fdread);
rc = select(1+ (int)((partial_apr_socket_t*)sock)->socketdes, &fdread, NULL, NULL, &tv);
if (rc < 0)
{
compat_log_rerror(APLOG_MARK, APLOG_WARNING, rc, r, "mod_jaxer: socket select failed");
ac->has_error = 1;
return rc;
}
/* turn off non-blocking */
rv = apr_socket_opt_set(sock, APR_SO_NONBLOCK, 0);
if (rv != APR_SUCCESS)
{
compat_log_rerror(APLOG_MARK, APLOG_WARNING, rv, r, "mod_jaxer: turn off non-blocking failed");
return rv;
}
/* return if nothing */
if (rc == 0)
return rv;
/*
* Since we have only one socket, we know we have data for reading if we are here.
* read a message
*/
if ((rv=jxr_receive_message(ac, (unsigned char **)pbuf)) != APR_SUCCESS)
{
compat_log_rerror(APLOG_MARK, APLOG_WARNING, rv, r, "mod_jaxer: receive message failed");
return rv;
}
return rv;
}
/** Wrapper for socketpair. */
int kdsock_comm_new_socketpair(apr_pool_t *pool1, kdsock_comm **comm1,
apr_pool_t *pool2, kdsock_comm **comm2,
int auto_shutdown) {
int fd[2] = {-1, -1};
/* Create a pair of socket for communicating with the child. */
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0) {
KERROR_SET(_server_, 0, "failed to create child communication socket");
return -1;
}
/* Circumvent a kernel 2.6.22 bug. Check if the file descriptors
were actually set to something. */
if (fd[0] == -1 || fd[1] == -1) {
KERROR_SET(_server_, 0, "socketpair returned no file descriptors");
return -1;
}
/* Create the communication objects. */
*comm1 = kdsock_comm_new(pool1, fd[0], auto_shutdown);
*comm2 = kdsock_comm_new(pool2, fd[1], auto_shutdown);
apr_socket_opt_set((*comm1)->apr_sock, APR_SO_NONBLOCK, 1);
apr_socket_opt_set((*comm2)->apr_sock, APR_SO_NONBLOCK, 1);
return 0;
}
void LLSocket::setOptions()
{
LLMemType m1(LLMemType::MTYPE_IO_TCP);
// set up the socket options
ll_apr_warn_status(apr_socket_timeout_set(mSocket, 0));
ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_SNDBUF, LL_SEND_BUFFER_SIZE));
ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_RCVBUF, LL_RECV_BUFFER_SIZE));
}
static mrcp_connection_t* mrcp_client_agent_connection_create(mrcp_connection_agent_t *agent, mrcp_control_descriptor_t *descriptor)
{
char *local_ip = NULL;
char *remote_ip = NULL;
mrcp_connection_t *connection = mrcp_connection_create();
apr_sockaddr_info_get(&connection->r_sockaddr,descriptor->ip.buf,APR_INET,descriptor->port,0,connection->pool);
if(!connection->r_sockaddr) {
mrcp_connection_destroy(connection);
return NULL;
}
if(apr_socket_create(&connection->sock,connection->r_sockaddr->family,SOCK_STREAM,APR_PROTO_TCP,connection->pool) != APR_SUCCESS) {
mrcp_connection_destroy(connection);
return NULL;
}
apr_socket_opt_set(connection->sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(connection->sock, -1);
apr_socket_opt_set(connection->sock, APR_SO_REUSEADDR, 1);
if(apr_socket_connect(connection->sock, connection->r_sockaddr) != APR_SUCCESS) {
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return NULL;
}
if(apr_socket_addr_get(&connection->l_sockaddr,APR_LOCAL,connection->sock) != APR_SUCCESS) {
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return NULL;
}
apr_sockaddr_ip_get(&local_ip,connection->l_sockaddr);
apr_sockaddr_ip_get(&remote_ip,connection->r_sockaddr);
connection->id = apr_psprintf(connection->pool,"%s:%hu <-> %s:%hu",
local_ip,connection->l_sockaddr->port,
remote_ip,connection->r_sockaddr->port);
memset(&connection->sock_pfd,0,sizeof(apr_pollfd_t));
connection->sock_pfd.desc_type = APR_POLL_SOCKET;
connection->sock_pfd.reqevents = APR_POLLIN;
connection->sock_pfd.desc.s = connection->sock;
connection->sock_pfd.client_data = connection;
if(apt_pollset_add(agent->pollset, &connection->sock_pfd) != TRUE) {
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return NULL;
}
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Established TCP/MRCPv2 Connection %s",connection->id);
connection->agent = agent;
connection->it = apt_list_push_back(agent->connection_list,connection,connection->pool);
connection->parser = mrcp_parser_create(agent->resource_factory,connection->pool);
connection->generator = mrcp_generator_create(agent->resource_factory,connection->pool);
return connection;
}
void LLSocket::setNonBlocking()
{
// set up the socket options
ll_apr_warn_status(apr_socket_timeout_set(mSocket, 0));
ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_NONBLOCK, 1));
ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_SNDBUF, LL_SEND_BUFFER_SIZE));
ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_RCVBUF, LL_RECV_BUFFER_SIZE));
}
/**
* do_listen -- create a listen socket
*/
apr_status_t do_listen(apr_pollset_t *pollset, apr_hash_t *ht,
apr_pool_t *mp, const char *param)
{
apr_status_t rv;
apr_socket_t *s;
apr_sockaddr_t *sa;
char **ptr;
int port;
ptr = str_split_char(param, ":");
if (ptr == NULL) {
fprintf(stderr, "Get Null param!\n");
return APR_EINVAL;
}
// then convert param
port = atoi(ptr[1]);
if (port < 0)
return APR_EINVAL;
rv = apr_sockaddr_info_get(&sa, ptr[0], APR_INET, port, 0, mp);
if (rv != APR_SUCCESS) {
return rv;
}
rv = apr_socket_create(&s, sa->family, SOCK_STREAM, APR_PROTO_TCP, mp);
if (rv != APR_SUCCESS) {
return rv;
}
/* non-blocking socket */
apr_socket_opt_set(s, APR_SO_NONBLOCK, 1);
apr_socket_timeout_set(s, 0);
apr_socket_opt_set(s, APR_SO_REUSEADDR, 1);/* this is useful for a
* server(socket listening) process */
rv = apr_socket_bind(s, sa);
if (rv != APR_SUCCESS) {
return rv;
}
rv = apr_socket_listen(s, DEF_SOCKET_BACKLOG);
if (rv != APR_SUCCESS) {
return rv;
}
// Then.., add it to hash table, listen and connect socket
// against a different val, so we can distinguish in the
// pollset
apr_hash_set(ht, s, APR_HASH_KEY_STRING, "S"); // server
// Then.., if everything is OK, add it to the pollset
apr_pollfd_t pfd = {mp, APR_POLL_SOCKET, APR_POLLIN, 0, {NULL}, NULL};
pfd.desc.s = s;
apr_pollset_add(pollset, &pfd);
free(ptr);
return APR_SUCCESS;
}
/**
* Connect to the remote host
*/
static apr_status_t tcp_proxy_do_tcp_connect(request_rec * r,
TcpProxyData * tpd,
apr_pool_t * mp)
{
apr_sockaddr_t *sa;
apr_socket_t *s;
apr_status_t rv;
APACHELOG(APLOG_DEBUG, r,
"tcp_proxy_do_tcp_connect: connect to host %s port %s",
tpd->host, tpd->port);
int port = atoi(tpd->port);
rv = apr_sockaddr_info_get(&sa, tpd->host, APR_INET, port, 0, mp);
if (rv != APR_SUCCESS) {
return rv;
}
if (!port) {
rv = apr_getservbyname(sa, tpd->port);
if (rv != APR_SUCCESS) {
return rv;
}
}
rv = apr_socket_create(&s, sa->family, SOCK_STREAM, APR_PROTO_TCP, mp);
if (rv != APR_SUCCESS) {
return rv;
}
/* it is a good idea to specify socket options explicitly.
* in this case, we make a blocking socket with timeout. */
apr_socket_opt_set(s, APR_SO_NONBLOCK, 0);
apr_socket_opt_set(s, APR_SO_KEEPALIVE, 1);
if (tpd->timeout)
apr_socket_timeout_set(s,
((apr_interval_time_t) tpd->timeout) *
APR_USEC_PER_SEC);
rv = apr_socket_connect(s, sa);
if (rv != APR_SUCCESS) {
return rv;
}
/* see the tutorial about the reason why we have to specify options again */
apr_socket_opt_set(s, APR_SO_NONBLOCK, 0);
apr_socket_opt_set(s, APR_SO_KEEPALIVE, 1);
if (tpd->timeout)
apr_socket_timeout_set(s,
((apr_interval_time_t) tpd->timeout) *
APR_USEC_PER_SEC);
tpd->tcpsocket = s;
return APR_SUCCESS;
}
static void im_ssl_listen(nx_module_t *module)
{
nx_im_ssl_conf_t *imconf;
nx_exception_t e;
imconf = (nx_im_ssl_conf_t *) module->config;
try
{
if ( imconf->listensock == NULL )
{
apr_sockaddr_t *sa;
CHECKERR_MSG(apr_socket_create(&(imconf->listensock), APR_INET, SOCK_STREAM,
APR_PROTO_TCP, module->input.pool),
"couldn't create tcp socket");
CHECKERR_MSG(apr_sockaddr_info_get(&sa, imconf->host, APR_INET, imconf->port,
0, module->input.pool),
"apr_sockaddr_info failed for %s:%d", imconf->host, imconf->port);
CHECKERR_MSG(apr_socket_opt_set(imconf->listensock, APR_SO_NONBLOCK, 1),
"couldn't set SO_NONBLOCK on listen socket");
CHECKERR_MSG(apr_socket_timeout_set(imconf->listensock, 0),
"couldn't set socket timeout on listen socket");
CHECKERR_MSG(apr_socket_opt_set(imconf->listensock, APR_SO_REUSEADDR, 1),
"couldn't set SO_REUSEADDR on listen socket");
CHECKERR_MSG(apr_socket_opt_set(imconf->listensock, APR_TCP_NODELAY, 1),
"couldn't set TCP_NODELAY on listen socket");
CHECKERR_MSG(apr_socket_bind(imconf->listensock, sa),
"couldn't bind ssl socket to %s:%d", imconf->host, imconf->port);
}
else
{
log_debug("ssl socket already initialized");
}
CHECKERR_MSG(apr_socket_listen(imconf->listensock, SOMAXCONN),
"couldn't listen to ssl socket on %s:%d",
imconf->host, imconf->port);
nx_module_pollset_add_socket(module, imconf->listensock, APR_POLLIN | APR_POLLHUP);
}
catch(e)
{
if ( imconf->listensock != NULL )
{
apr_socket_close(imconf->listensock);
imconf->listensock = NULL;
}
apr_pool_clear(module->input.pool);
rethrow(e);
}
}
void client_connect(client_t *cli) {
LOG_DEBUG("connecting to server %s %d", cli->comm->ip, cli->comm->port);
apr_status_t status = APR_SUCCESS;
status = apr_sockaddr_info_get(&cli->comm->sa, cli->comm->ip, APR_INET,
cli->comm->port, 0, cli->comm->mp);
SAFE_ASSERT(status == APR_SUCCESS);
status = apr_socket_create(&cli->comm->s, cli->comm->sa->family,
SOCK_STREAM, APR_PROTO_TCP, cli->comm->mp);
SAFE_ASSERT(status == APR_SUCCESS);
status = apr_socket_opt_set(cli->comm->s, APR_TCP_NODELAY, 1);
SAFE_ASSERT(status == APR_SUCCESS);
while (1) {
// repeatedly retry
LOG_TRACE("TCP CLIENT TRYING TO CONNECT.");
status = apr_socket_connect(cli->comm->s, cli->comm->sa);
if (status == APR_SUCCESS /*|| status == APR_EINPROGRESS */) {
break;
} else if (status == APR_ECONNREFUSED) {
LOG_DEBUG("client connect refused, maybe the server is not ready yet");
} else if (status == APR_EINVAL) {
LOG_ERROR("client connect error, invalid argument. ip: %s, port: %d",
cli->comm->ip, cli->comm->port);
SAFE_ASSERT(0);
} else {
LOG_ERROR("client connect error:%s", apr_strerror(status, (char*)malloc(100), 100));
SAFE_ASSERT(0);
}
apr_sleep(50 * 1000);
}
LOG_INFO("connected socket on remote addr %s, port %d", cli->comm->ip, cli->comm->port);
status = apr_socket_opt_set(cli->comm->s, APR_SO_NONBLOCK, 1);
SAFE_ASSERT(status == APR_SUCCESS);
// add to epoll
// context_t *ctx = c->ctx;
// while (ctx->ps == NULL) {
// // not inited yet, just wait.
// }
//
apr_pollfd_t pfd = {cli->comm->mp, APR_POLL_SOCKET, APR_POLLIN, 0, {NULL}, NULL};
pfd.desc.s = cli->comm->s;
pfd.client_data = cli->pjob;
cli->pjob->pfd = pfd;
poll_mgr_add_job(cli->pjob->mgr, cli->pjob);
// status = apr_pollset_add(pollset_, &ctx->pfd);
// status = apr_pollset_add(ctx->ps, &ctx->pfd);
// SAFE_ASSERT(status == APR_SUCCESS);
}
/** Create connection */
static apt_bool_t rtsp_client_connect(rtsp_client_t *client, rtsp_client_connection_t *connection, const char *ip, apr_port_t port)
{
char *local_ip = NULL;
char *remote_ip = NULL;
apr_sockaddr_t *l_sockaddr = NULL;
apr_sockaddr_t *r_sockaddr = NULL;
if(apr_sockaddr_info_get(&r_sockaddr,ip,APR_INET,port,0,connection->pool) != APR_SUCCESS) {
return FALSE;
}
if(apr_socket_create(&connection->sock,r_sockaddr->family,SOCK_STREAM,APR_PROTO_TCP,connection->pool) != APR_SUCCESS) {
return FALSE;
}
apr_socket_opt_set(connection->sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(connection->sock, -1);
apr_socket_opt_set(connection->sock, APR_SO_REUSEADDR, 1);
if(apr_socket_connect(connection->sock,r_sockaddr) != APR_SUCCESS) {
apr_socket_close(connection->sock);
connection->sock = NULL;
return FALSE;
}
if(apr_socket_addr_get(&l_sockaddr,APR_LOCAL,connection->sock) != APR_SUCCESS) {
apr_socket_close(connection->sock);
connection->sock = NULL;
return FALSE;
}
apr_sockaddr_ip_get(&local_ip,l_sockaddr);
apr_sockaddr_ip_get(&remote_ip,r_sockaddr);
connection->id = apr_psprintf(connection->pool,"%s:%hu <-> %s:%hu",
local_ip,l_sockaddr->port,
remote_ip,r_sockaddr->port);
memset(&connection->sock_pfd,0,sizeof(apr_pollfd_t));
connection->sock_pfd.desc_type = APR_POLL_SOCKET;
connection->sock_pfd.reqevents = APR_POLLIN;
connection->sock_pfd.desc.s = connection->sock;
connection->sock_pfd.client_data = connection;
if(apt_poller_task_descriptor_add(client->task,&connection->sock_pfd) != TRUE) {
apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Add to Pollset %s",connection->id);
apr_socket_close(connection->sock);
connection->sock = NULL;
return FALSE;
}
apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Established RTSP Connection %s",connection->id);
return TRUE;
}
static int do_accept(serv_ctx_t *serv_ctx, apr_pollset_t *pollset, apr_socket_t *lsock, apr_pool_t *mp)
{
apr_socket_t *ns;/* accepted socket */
apr_status_t rv = apr_socket_accept(&ns, lsock, mp);
if (rv == APR_SUCCESS)
{
//serv_ctx_t *serv_ctx = apr_palloc(mp, sizeof(serv_ctx_t));
serv_ctx->up_buf_level = 0;
serv_ctx->down_buf_level = 0;
serv_ctx->channel_state = connected;
apr_pollfd_t pfd = { mp, APR_POLL_SOCKET, APR_POLLIN|APR_POLLOUT|APR_POLLHUP, 0, { NULL }, serv_ctx };
pfd.desc.s = ns;
serv_ctx->mp = mp;
/* non-blocking socket. We can't expect that @ns inherits non-blocking mode from @lsock */
apr_socket_opt_set(ns, APR_SO_NONBLOCK, 1); //Setup socket options for the specified socket
apr_socket_timeout_set(ns, 0);
apr_pollset_add(pollset, &pfd); //Add a socket or file descriptor to a pollset
//printf("connected client to channel %d\n", serv_ctx->channel_number);
}
return TRUE;
}
int do_accept(apr_pollset_t *pollset, apr_socket_t *lsock, apr_pool_t *mp)
{
apr_socket_t *ns;/* accepted socket */
apr_status_t rv;
rv = apr_socket_accept(&ns, lsock, mp);
if (rv == APR_SUCCESS) {
serv_ctx_t *serv_ctx = apr_palloc(mp, sizeof(serv_ctx_t));
apr_pollfd_t pfd = { mp, APR_POLL_SOCKET, APR_POLLIN, 0, { NULL }, serv_ctx };
pfd.desc.s = ns;
/* at first, we expect requests, so we poll APR_POLLIN event */
serv_ctx->status = SERV_RECV_REQUEST;
serv_ctx->cb_func = recv_req_cb;
serv_ctx->recv.is_firstline = TRUE;
serv_ctx->mp = mp;
/**
* non-blocking socket. We can't expect that @ns
* inherits non-blocking mode from @lsock
*/
apr_socket_opt_set(ns, APR_SO_NONBLOCK, 1);
apr_socket_timeout_set(ns, 0);
apr_pollset_add(pollset, &pfd);
}
return TRUE;
}
static void* APR_THREAD_FUNC test_server_run(apr_thread_t *thd, void *data) {
server_thread_data * server_data = (server_thread_data*)data;
apr_status_t rv;
apr_pool_t *mp;
apr_socket_t *s;/* listening socket */
apr_pool_create(&mp, NULL);
rv = do_listen(&s, mp, server_data->port);
if (rv != APR_SUCCESS) {
char errbuf[256];
apr_strerror(rv, errbuf, sizeof(errbuf));
printf("test server error listening: %d, %s\n", rv, errbuf);
apr_pool_destroy(mp);
apr_thread_exit(thd, rv);
return;
}
server_data->handle->test_server_running = 1;
while (server_data->handle->test_server_running == 1) {
apr_socket_t *ns;/* accepted socket */
//printf("A");
rv = apr_socket_accept(&ns, s, mp);
if(rv == 11) {
//printf(".");
} else {
//printf("B");
if (rv != APR_SUCCESS) {
char errbuf[256];
apr_strerror(rv, errbuf, sizeof(errbuf));
printf("test server error accepting: %d, %s\n", rv, errbuf);
apr_pool_destroy(mp);
apr_thread_exit(thd, rv);
return;
}
/* it is a good idea to specify socket options for the newly accepted socket explicitly */
apr_socket_opt_set(ns, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(ns, 5000);
rv = server_data->request_process_callback(ns, mp, server_data);
apr_socket_close(ns);
if (rv != APR_SUCCESS) {
char errbuf[256];
apr_strerror(rv, errbuf, sizeof(errbuf));
printf("test server error processing: %d, %s\n", rv, errbuf);
apr_pool_destroy(mp);
apr_thread_exit(thd, rv);
return;
}
}
}
//printf("apr_pool_destroy\n");
apr_pool_destroy(mp);
//printf("apr_thread_exit\n");
apr_thread_exit(thd, APR_SUCCESS);
//printf("return\n");
return NULL;
}
apr_status_t sspdy_connect(apr_socket_t **skt,
const char *hostname, apr_port_t port,
apr_pool_t *pool)
{
apr_sockaddr_t *host_address = NULL;
apr_status_t status;
STATUSERR(apr_sockaddr_info_get(&host_address, hostname,
APR_UNSPEC, port, 0, pool));
STATUSERR(apr_socket_create(skt, host_address->family,
SOCK_STREAM, APR_PROTO_TCP, pool));
STATUSERR(apr_socket_timeout_set(*skt, 0));
STATUSERR(apr_socket_opt_set(*skt, APR_TCP_NODELAY, 1));
status = apr_socket_connect(*skt, host_address);
if (status != APR_SUCCESS) {
if (!APR_STATUS_IS_EINPROGRESS(status))
return status;
}
return APR_SUCCESS;
}
/** Create connection */
APT_DECLARE(apt_net_client_connection_t*) apt_net_client_connect(apt_net_client_task_t *task, const char *ip, apr_port_t port)
{
apr_sockaddr_t *sockaddr;
apt_net_client_connection_t *connection;
apr_pool_t *pool;
if(apr_pool_create(&pool,NULL) != APR_SUCCESS) {
return NULL;
}
connection = apr_palloc(pool,sizeof(apt_net_client_connection_t));
connection->pool = pool;
connection->obj = NULL;
connection->sock = NULL;
if(apr_sockaddr_info_get(&sockaddr,ip,APR_INET,port,0,connection->pool) != APR_SUCCESS) {
apr_pool_destroy(pool);
return NULL;
}
if(apr_socket_create(&connection->sock,sockaddr->family,SOCK_STREAM,APR_PROTO_TCP,connection->pool) != APR_SUCCESS) {
apr_pool_destroy(pool);
return NULL;
}
apr_socket_opt_set(connection->sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(connection->sock, -1);
apr_socket_opt_set(connection->sock, APR_SO_REUSEADDR, 1);
if(apr_socket_connect(connection->sock,sockaddr) != APR_SUCCESS) {
apr_socket_close(connection->sock);
apr_pool_destroy(pool);
return NULL;
}
connection->sock_pfd.desc_type = APR_POLL_SOCKET;
connection->sock_pfd.reqevents = APR_POLLIN;
connection->sock_pfd.desc.s = connection->sock;
connection->sock_pfd.client_data = connection;
if(apt_pollset_add(task->pollset,&connection->sock_pfd) != TRUE) {
apr_socket_close(connection->sock);
apr_pool_destroy(pool);
return NULL;
}
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Established TCP Connection %s:%d",ip,port);
return connection;
}
apr_status_t serf_listener_create(
serf_listener_t **listener,
serf_context_t *ctx,
const char *host,
apr_uint16_t port,
void *accept_baton,
serf_accept_client_t accept,
apr_pool_t *pool)
{
apr_sockaddr_t *sa;
apr_status_t rv;
serf_listener_t *l = apr_palloc(pool, sizeof(*l));
l->ctx = ctx;
l->baton.type = SERF_IO_LISTENER;
l->baton.u.listener = l;
l->accept_func = accept;
l->accept_baton = accept_baton;
apr_pool_create(&l->pool, pool);
rv = apr_sockaddr_info_get(&sa, host, APR_UNSPEC, port, 0, l->pool);
if (rv)
return rv;
rv = apr_socket_create(&l->skt, sa->family,
SOCK_STREAM,
#if APR_MAJOR_VERSION > 0
APR_PROTO_TCP,
#endif
l->pool);
if (rv)
return rv;
rv = apr_socket_opt_set(l->skt, APR_SO_REUSEADDR, 1);
if (rv)
return rv;
rv = apr_socket_bind(l->skt, sa);
if (rv)
return rv;
rv = apr_socket_listen(l->skt, 5);
if (rv)
return rv;
l->desc.desc_type = APR_POLL_SOCKET;
l->desc.desc.s = l->skt;
l->desc.reqevents = APR_POLLIN;
rv = ctx->pollset_add(ctx->pollset_baton,
&l->desc, &l->baton);
if (rv)
return rv;
*listener = l;
return APR_SUCCESS;
}
/** Create listening socket and add it to pollset */
static apt_bool_t mrcp_server_agent_listening_socket_create(mrcp_connection_agent_t *agent)
{
apr_status_t status;
if(!agent->sockaddr) {
return FALSE;
}
/* create listening socket */
status = apr_socket_create(&agent->listen_sock, agent->sockaddr->family, SOCK_STREAM, APR_PROTO_TCP, agent->pool);
if(status != APR_SUCCESS) {
return FALSE;
}
apr_socket_opt_set(agent->listen_sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(agent->listen_sock, -1);
apr_socket_opt_set(agent->listen_sock, APR_SO_REUSEADDR, 1);
status = apr_socket_bind(agent->listen_sock, agent->sockaddr);
if(status != APR_SUCCESS) {
apr_socket_close(agent->listen_sock);
agent->listen_sock = NULL;
return FALSE;
}
status = apr_socket_listen(agent->listen_sock, SOMAXCONN);
if(status != APR_SUCCESS) {
apr_socket_close(agent->listen_sock);
agent->listen_sock = NULL;
return FALSE;
}
/* add listening socket to pollset */
memset(&agent->listen_sock_pfd,0,sizeof(apr_pollfd_t));
agent->listen_sock_pfd.desc_type = APR_POLL_SOCKET;
agent->listen_sock_pfd.reqevents = APR_POLLIN;
agent->listen_sock_pfd.desc.s = agent->listen_sock;
agent->listen_sock_pfd.client_data = agent->listen_sock;
if(apt_poller_task_descriptor_add(agent->task, &agent->listen_sock_pfd) != TRUE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Add Listening Socket to Pollset [%s]",
apt_task_name_get(apt_poller_task_base_get(agent->task)));
apr_socket_close(agent->listen_sock);
agent->listen_sock = NULL;
return FALSE;
}
return TRUE;
}
/** Create listening socket and add it to pollset */
static apt_bool_t rtsp_server_listening_socket_create(rtsp_server_t *server)
{
apr_status_t status;
if(!server->sockaddr) {
return FALSE;
}
/* create listening socket */
status = apr_socket_create(&server->listen_sock, server->sockaddr->family, SOCK_STREAM, APR_PROTO_TCP, server->pool);
if(status != APR_SUCCESS) {
return FALSE;
}
apr_socket_opt_set(server->listen_sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(server->listen_sock, -1);
apr_socket_opt_set(server->listen_sock, APR_SO_REUSEADDR, 1);
status = apr_socket_bind(server->listen_sock, server->sockaddr);
if(status != APR_SUCCESS) {
apr_socket_close(server->listen_sock);
server->listen_sock = NULL;
return FALSE;
}
status = apr_socket_listen(server->listen_sock, SOMAXCONN);
if(status != APR_SUCCESS) {
apr_socket_close(server->listen_sock);
server->listen_sock = NULL;
return FALSE;
}
/* add listening socket to pollset */
memset(&server->listen_sock_pfd,0,sizeof(apr_pollfd_t));
server->listen_sock_pfd.desc_type = APR_POLL_SOCKET;
server->listen_sock_pfd.reqevents = APR_POLLIN;
server->listen_sock_pfd.desc.s = server->listen_sock;
server->listen_sock_pfd.client_data = server->listen_sock;
if(apt_poller_task_descriptor_add(server->task, &server->listen_sock_pfd) != TRUE) {
apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Failed to Add Listening Socket to Pollset");
apr_socket_close(server->listen_sock);
server->listen_sock = NULL;
return FALSE;
}
return TRUE;
}
int sock_connect(net_sock_t *nsock, const char *hostname, int port, Net_timeout_t timeout)
{
int err;
Net_timeout_t tm;
network_sock_t *sock = (network_sock_t *)nsock;
if (sock == NULL) return(-1); //** If NULL exit
if (sock->fd != NULL) apr_socket_close(sock->fd);
sock->fd = NULL;
sock->sa = NULL;
log_printf(0, " sock_connect: hostname=%s:%d to=" TT "\n", hostname, port, timeout);
// err = apr_sockaddr_info_get(&(sock->sa), hostname, APR_INET, port, APR_IPV4_ADDR_OK, sock->mpool);
err = apr_sockaddr_info_get(&(sock->sa), hostname, APR_INET, port, 0, sock->mpool);
//log_printf(0, "sock_connect: apr_sockaddr_info_get: err=%d\n", err);
//if (sock->sa == NULL) log_printf(0, "sock_connect: apr_sockaddr_info_get: sock->sa == NULL\n");
if (err != APR_SUCCESS) return(err);
err = apr_socket_create(&(sock->fd), APR_INET, SOCK_STREAM, APR_PROTO_TCP, sock->mpool);
//log_printf(0, "sock_connect: apr_sockcreate: err=%d\n", err);
if (err != APR_SUCCESS) return(err);
//// apr_socket_opt_set(sock->fd, APR_SO_NONBLCK, 1);
apr_socket_timeout_set(sock->fd, timeout);
if (sock->tcpsize > 0) {
apr_socket_opt_set(sock->fd, APR_SO_SNDBUF, sock->tcpsize);
apr_socket_opt_set(sock->fd, APR_SO_RCVBUF, sock->tcpsize);
}
err = apr_socket_connect(sock->fd, sock->sa);
//log_printf(0, "sock_connect: apr_socket_connect: err=%d\n", err); flush_log();
//** Set a default timeout
set_net_timeout(&tm, 0, SOCK_DEFAULT_TIMEOUT);
apr_socket_timeout_set(sock->fd, tm);
return(err);
}
static mrcp_connection_t* mrcp_client_agent_connection_create(mrcp_connection_agent_t *agent, mrcp_control_descriptor_t *descriptor)
{
mrcp_connection_t *connection = mrcp_connection_create();
connection->remote_ip = descriptor->ip;
apr_sockaddr_info_get(&connection->sockaddr,descriptor->ip.buf,APR_INET,descriptor->port,0,connection->pool);
if(!connection->sockaddr) {
mrcp_connection_destroy(connection);
return NULL;
}
if(apr_socket_create(&connection->sock, connection->sockaddr->family, SOCK_STREAM, APR_PROTO_TCP, connection->pool) != APR_SUCCESS) {
mrcp_connection_destroy(connection);
return NULL;
}
apr_socket_opt_set(connection->sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(connection->sock, -1);
apr_socket_opt_set(connection->sock, APR_SO_REUSEADDR, 1);
if(apr_socket_connect(connection->sock, connection->sockaddr) != APR_SUCCESS) {
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return NULL;
}
connection->sock_pfd.desc_type = APR_POLL_SOCKET;
connection->sock_pfd.reqevents = APR_POLLIN;
connection->sock_pfd.desc.s = connection->sock;
connection->sock_pfd.client_data = connection;
if(apr_pollset_add(agent->pollset, &connection->sock_pfd) != APR_SUCCESS) {
apr_socket_close(connection->sock);
mrcp_connection_destroy(connection);
return NULL;
}
apt_log(APT_PRIO_NOTICE,"Established TCP/MRCPv2 Connection %s:%d",
connection->remote_ip.buf,
connection->sockaddr->port);
connection->it = apt_list_push_back(agent->connection_list,connection);
return connection;
}
LLIODataSocket::LLIODataSocket(
U16 suggested_port,
U16 start_discovery_port,
apr_pool_t* pool) :
mSocket(NULL)
{
if(!pool || (PORT_INVALID == suggested_port)) return;
if(ll_apr_warn_status(apr_socket_create(&mSocket, APR_INET, SOCK_DGRAM, APR_PROTO_UDP, pool))) return;
apr_sockaddr_t* sa = NULL;
if(ll_apr_warn_status(apr_sockaddr_info_get(&sa, APR_ANYADDR, APR_UNSPEC, suggested_port, 0, pool))) return;
apr_status_t status = apr_socket_bind(mSocket, sa);
if((start_discovery_port > 0) && is_addr_in_use(status))
{
const U16 MAX_ATTEMPT_PORTS = 50;
for(U16 attempt_port = start_discovery_port;
attempt_port < (start_discovery_port + MAX_ATTEMPT_PORTS);
++attempt_port)
{
sa->port = attempt_port;
sa->sa.sin.sin_port = htons(attempt_port);
status = apr_socket_bind(mSocket, sa);
if(APR_SUCCESS == status) break;
if(is_addr_in_use(status)) continue;
(void)ll_apr_warn_status(status);
}
}
if(ll_apr_warn_status(status)) return;
if(sa->port)
{
lldebugs << "Bound datagram socket to port: " << sa->port << llendl;
mPort = sa->port;
}
else
{
mPort = LLIOSocket::PORT_EPHEMERAL;
}
// set up the socket options options
ll_apr_warn_status(apr_socket_timeout_set(mSocket, 0));
ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_SNDBUF, LL_SEND_BUFFER_SIZE));
ll_apr_warn_status(apr_socket_opt_set(mSocket, APR_SO_RCVBUF, LL_RECV_BUFFER_SIZE));
}
void handle_server_accept(void* arg) {
server_t *svr = (server_t *) arg;
apr_status_t status = APR_SUCCESS;
apr_socket_t *ns = NULL;
LOG_TRACE("on new connection");
status = apr_socket_accept(&ns, svr->comm->s, svr->comm->mp);
// apr_socket_t *sock_listen = r->com.s;
// LOG_INFO("accept on fd %x", sock_listen->socketdes);
LOG_INFO("accept new connection");
if (status == APR_EMFILE) {
LOG_ERROR("cannot open more file handles, please check system configurations.");
SAFE_ASSERT(0);
} else if (status == APR_ENFILE) {
LOG_ERROR("cannot open more file handles, please check system configurations.");
SAFE_ASSERT(0);
}
if (status != APR_SUCCESS) {
LOG_ERROR("recvr accept error.");
LOG_ERROR("%s", apr_strerror(status, calloc(100, 1), 100));
SAFE_ASSERT(status == APR_SUCCESS);
}
apr_socket_opt_set(ns, APR_SO_NONBLOCK, 1);
apr_socket_opt_set(ns, APR_TCP_NODELAY, 1);
// apr_socket_opt_set(ns, APR_SO_REUSEADDR, 1);
sconn_t *sconn;
sconn_create(&sconn, svr);
apr_pollfd_t pfd = {svr->comm->mp, APR_POLL_SOCKET, APR_POLLIN, 0, {NULL}, NULL};
pfd.desc.s = ns;
pfd.client_data = sconn->pjob;
sconn->pjob->pfd = pfd;
sconn->pjob->mgr = svr->pjob->mgr;
poll_mgr_add_job(sconn->pjob->mgr, sconn->pjob);
}
void LLPluginMessagePipe::setSocketTimeout(apr_interval_time_t timeout_usec)
{
// We never want to sleep forever, so force negative timeouts to become non-blocking.
// according to this page: http://dev.ariel-networks.com/apr/apr-tutorial/html/apr-tutorial-13.html
// blocking/non-blocking with apr sockets is somewhat non-portable.
if(timeout_usec <= 0)
{
// Make the socket non-blocking
apr_socket_opt_set(mSocket->getSocket(), APR_SO_NONBLOCK, 1);
apr_socket_timeout_set(mSocket->getSocket(), 0);
}
else
{
// Make the socket blocking-with-timeout
apr_socket_opt_set(mSocket->getSocket(), APR_SO_NONBLOCK, 1);
apr_socket_timeout_set(mSocket->getSocket(), timeout_usec);
}
}
