/********************************************************************************
*
* Used to establish a connection
*
********************************************************************************/
apr_status_t stomp_connect(stomp_connection **connection_ref, const char *hostname, int port, apr_pool_t *pool)
{
apr_status_t rc;
int socket_family;
stomp_connection *connection=NULL;
btlogger_trace("stomp_connect");
//
// Allocate the connection and a memory pool for the connection.
//
connection = apr_pcalloc(pool, sizeof(stomp_connection));
if( connection == NULL ) {
btlogger_warn("stomp_connect cannot allocate for pool APR_ENOMEM");
return APR_ENOMEM;
}
#define CHECK_SUCCESS if( rc!=APR_SUCCESS ) { return rc; }
// Look up the remote address
rc = apr_sockaddr_info_get(&connection->remote_sa, hostname, APR_INET, port, 0, pool);
CHECK_SUCCESS;
// Create and Connect the socket.
socket_family = connection->remote_sa->sa.sin.sin_family;
rc = apr_socket_create(&connection->socket, socket_family, SOCK_STREAM, APR_PROTO_TCP, pool);
CHECK_SUCCESS;
rc = apr_socket_connect(connection->socket, connection->remote_sa);
// CHECK_SUCCESS;
if( rc != APR_SUCCESS ) {
apr_status_t rc2 = apr_socket_shutdown(connection->socket, APR_SHUTDOWN_WRITE);
btlogger_debug("from stomp.c (1) closing socket");
rc2 = apr_socket_close(connection->socket);
return rc;
}
// Get the Socket Info
rc = apr_socket_addr_get(&connection->remote_sa, APR_REMOTE, connection->socket);
CHECK_SUCCESS;
// rc = apr_sockaddr_ip_get(&connection->remote_ip, connection->remote_sa);
// CHECK_SUCCESS;
connection->remote_ip = connection->remote_sa->hostname;
rc = apr_socket_addr_get(&connection->local_sa, APR_LOCAL, connection->socket);
CHECK_SUCCESS;
rc = apr_sockaddr_ip_get(&connection->local_ip, connection->local_sa);
CHECK_SUCCESS;
// Set socket options.
// rc = apr_socket_timeout_set( connection->socket, 2*APR_USEC_PER_SEC);
// CHECK_SUCCESS;
#undef CHECK_SUCCESS
*connection_ref = connection;
return rc;
}
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;
}
/*! Start a connect (async) and once done install an event/callback
* associated to the connected socket.
*
* @param csock connecting socket, created by cpe_socket_client_create()
* @param sockaddr address infos, created by cpe_socket_client_create()
* @param timeous_us optional timeout in us to connect. 0 Means no timeout.
* @param callback callback that will be called on the connected socket
* @param context callback argument
* @param pfd_flags poll flags for the connected socket
* @param pool memory pool to use
*/
apr_status_t
cpe_socket_after_connect(
apr_socket_t *csock,
apr_sockaddr_t *sockaddr,
apr_time_t timeout_us,
cpe_callback_t callback,
void *context,
apr_int16_t pfd_flags,
cpe_callback_t one_shot_cb,
void *one_shot_ctx,
apr_pool_t *pool)
{
apr_status_t rv;
cpe_event *event;
cpe_socket_prepare_ctx *ctx;
int nonblock;
/* Enforce contract. */
apr_socket_opt_get(csock, APR_SO_NONBLOCK, &nonblock);
assert(nonblock == 1);
/*
* Setup event/callback for connecting socket.
*/
cpe_log(CPE_DEB, "%s", "creating event for connecting socket");
ctx = apr_palloc(pool, sizeof *ctx);
if (ctx == NULL) {
return APR_EGENERAL;
}
event = cpe_event_fdesc_create(APR_POLL_SOCKET, APR_POLLOUT,
(apr_descriptor) csock, timeout_us, cpe_socket_connect_cb, ctx);
if (event == NULL) {
return APR_EGENERAL;
}
ctx->pc_callback = callback;
ctx->pc_ctx1 = context;
ctx->pc_reqevents = pfd_flags;
ctx->pc_orig_socket = csock;
ctx->pc_event = event;
ctx->pc_one_shot_cb = one_shot_cb;
ctx->pc_one_shot_ctx = one_shot_ctx;
CHECK(cpe_event_add(event));
rv = apr_socket_connect(csock, sockaddr);
if (rv != APR_SUCCESS && ! APR_STATUS_IS_EINPROGRESS(rv)) {
cpe_log(CPE_DEB, "apr_socket_connect %s", cpe_errmsg(rv));
return rv;
}
return APR_SUCCESS;
}
/******************************************************************************
*
* Used to establish a connection
*
********************************************************************************/
APR_DECLARE(apr_status_t) stomp_connect(stomp_connection **connection_ref, const char *hostname, int port, apr_pool_t *pool)
{
apr_status_t rc;
int socket_family;
stomp_connection *connection=NULL;
//
// Allocate the connection and a memory pool for the connection.
//
connection = apr_pcalloc(pool, sizeof(stomp_connection));
if( connection == NULL )
return APR_ENOMEM;
#define CHECK_SUCCESS if( rc!=APR_SUCCESS ) { return rc; }
// Look up the remote address
rc = apr_sockaddr_info_get(&connection->remote_sa, hostname, APR_UNSPEC, port, APR_IPV4_ADDR_OK, pool);
CHECK_SUCCESS;
// Create the socket.
socket_family = connection->remote_sa->sa.sin.sin_family;
rc = apr_socket_create(&connection->socket, socket_family, SOCK_STREAM, APR_PROTO_TCP, pool);
CHECK_SUCCESS;
// Set socket options.
rc = apr_socket_opt_set(connection->socket, APR_SO_NONBLOCK, 1);
CHECK_SUCCESS;
rc = apr_socket_timeout_set(connection->socket, 1 * APR_USEC_PER_SEC);
CHECK_SUCCESS;
// Try connect
rc = apr_socket_connect(connection->socket, connection->remote_sa);
CHECK_SUCCESS;
// Get the Socket Info
rc = apr_socket_addr_get(&connection->remote_sa, APR_REMOTE, connection->socket);
CHECK_SUCCESS;
rc = apr_sockaddr_ip_get(&connection->remote_ip, connection->remote_sa);
CHECK_SUCCESS;
rc = apr_socket_addr_get(&connection->local_sa, APR_LOCAL, connection->socket);
CHECK_SUCCESS;
rc = apr_sockaddr_ip_get(&connection->local_ip, connection->local_sa);
CHECK_SUCCESS;
#undef CHECK_SUCCESS
*connection_ref = connection;
return rc;
} // stomp_connect
/** 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;
}
static int socket_connect(lua_State *L)
{
lua_apr_socket *object;
apr_sockaddr_t *address;
const char *host;
apr_port_t port;
apr_status_t status;
object = socket_check(L, 1, 1);
host = luaL_checkstring(L, 2);
port = luaL_checkinteger(L, 3);
status = apr_sockaddr_info_get(&address, host, object->family, port, 0, object->pool);
if (status == APR_SUCCESS)
status = apr_socket_connect(object->handle, address);
return push_status(L, status);
}
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_LOG_MARK,APT_PRIO_NOTICE,"Established TCP/MRCPv2 Connection %s:%d",
connection->remote_ip.buf,
connection->sockaddr->port);
connection->agent = agent;
connection->it = apt_list_push_back(agent->connection_list,connection);
connection->parser = mrcp_parser_create(agent->resource_factory,connection->pool);
connection->generator = mrcp_generator_create(agent->resource_factory,connection->pool);
return connection;
}
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 apr_status_t
create_client_socket(apr_socket_t **skt,
serv_ctx_t *servctx,
const char *url)
{
apr_sockaddr_t *address;
apr_uri_t uri;
apr_status_t status;
status = apr_uri_parse(servctx->pool, url, &uri);
if (status != APR_SUCCESS)
return status;
status = apr_sockaddr_info_get(&address,
uri.hostname,
APR_UNSPEC,
uri.port,
0,
servctx->pool);
if (status != APR_SUCCESS)
return status;
status = apr_socket_create(skt,
address->family,
SOCK_STREAM,
#if APR_MAJOR_VERSION > 0
APR_PROTO_TCP,
#endif
servctx->pool);
if (status != APR_SUCCESS)
return status;
/* Set the socket to be non-blocking */
status = apr_socket_timeout_set(*skt, 0);
if (status != APR_SUCCESS)
return status;
status = apr_socket_connect(*skt, address);
if (status != APR_SUCCESS && !APR_STATUS_IS_EINPROGRESS(status))
return status;
return APR_SUCCESS;
}
static apr_socket_t* mconnect(request_rec *r)
{
apr_status_t rv;
process_rec *p = r->connection->base_server->process;
if (s != NULL)
return s;
rv = apr_socket_create(&s, APR_INET, SOCK_STREAM, APR_PROTO_TCP, p->pool);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "socket creation failed");
mclose(r);
return NULL;
}
rv = apr_socket_opt_set(s, APR_SO_KEEPALIVE, 1);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "setting socket options");
mclose(r);
return NULL;
}
rv = apr_sockaddr_info_get(&addr, "localhost", APR_INET, 7777, 0, p->pool);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "addr resolution failed");
mclose(r);
return NULL;
}
rv = apr_socket_connect(s, addr);
if (rv != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, "socket connect failed");
mclose(r);
return NULL;
}
return s;
}
bool connect_smtp()
{
// Prepare an soket to talk smtp
apr_status_t status;
status = apr_socket_create(
&gMailSocket,
gSockAddr->sa.sin.sin_family,
SOCK_STREAM,
APR_PROTO_TCP,
gMailPool);
if(ll_apr_warn_status(status)) return false;
status = apr_socket_connect(gMailSocket, gSockAddr);
if(ll_apr_warn_status(status))
{
status = apr_socket_close(gMailSocket);
ll_apr_warn_status(status);
return false;
}
return true;
}
void lfd_connect(apr_socket_t ** pconnect_sock,apr_sockaddr_t * saddr, apr_pool_t * mp)
{
apr_status_t rc;
apr_socket_t * connect_sock;
*pconnect_sock = NULL;
rc = apr_socket_create(&connect_sock, saddr->family, SOCK_STREAM, APR_PROTO_TCP, mp);
if(APR_SUCCESS != rc)
{
lfd_log_apr_err(rc, "apr_socket_create failed");
return;
}
rc = apr_socket_connect(connect_sock, saddr);
if(APR_SUCCESS != rc)
{
lfd_log_err(LFD_ERROR, "apr_socket_connect failed");
apr_socket_close(connect_sock);
return;
}
*pconnect_sock = connect_sock;
}
apr_socket_t *
thrasher_connect(apr_pool_t * pool, webfw2_config_t * config)
{
/*
* generic connect() function using thrasher configuration
* directives
*/
apr_socket_t *sock;
apr_sockaddr_t *sockaddr;
sock = NULL;
if (apr_sockaddr_info_get(&sockaddr,
config->thrasher_host, APR_INET,
config->thrasher_port, 0,
pool) != APR_SUCCESS)
return NULL;
if (apr_socket_create(&sock, sockaddr->family,
SOCK_STREAM, APR_PROTO_TCP, pool) != APR_SUCCESS)
return NULL;
if (apr_socket_timeout_set(sock,
config->thrasher_timeout) != APR_SUCCESS) {
apr_socket_close(sock);
return NULL;
}
if (apr_socket_opt_set(sock, APR_SO_KEEPALIVE, 1) != APR_SUCCESS) {
apr_socket_close(sock);
return NULL;
}
if (apr_socket_connect(sock, sockaddr) != APR_SUCCESS) {
apr_socket_close(sock);
return NULL;
}
return sock;
}
static apr_status_t
open_lisp_socket (lisp_cfg_t * cfg)
{
apr_sockaddr_t * addr;
apr_socket_t * socket;
if ((SERVER_SOCKET (cfg)) != 0)
{
if (SERVER_SOCKET_SAFE_P (cfg))
return (APR_SUCCESS);
RELAY_ERROR (close_lisp_socket (cfg));
}
RELAY_ERROR
(apr_sockaddr_info_get ((&addr), (cfg->server_address), APR_UNSPEC,
(cfg->server_port), 0, socket_pool));
#if (HAVE_APR_1_2_2)
RELAY_ERROR (apr_socket_create ((&socket), AF_INET, SOCK_STREAM, APR_PROTO_TCP, socket_pool));
#else
RELAY_ERROR (apr_socket_create ((&socket), AF_INET, SOCK_STREAM, socket_pool));
#endif
#if (HAVE_APR_1_2_2)
RELAY_ERROR (apr_socket_connect (socket, addr));
#else
RELAY_ERROR (apr_connect (socket, addr));
#endif
{
input_buffer_t * buffer
= (apr_palloc (socket_pool, (sizeof (input_buffer_t))));
(buffer -> start) = (buffer -> data);
(buffer -> end) = (buffer -> data);
RELAY_ERROR (apr_socket_data_set (socket, buffer, "input-buffer", 0));
}
(SERVER_SOCKET (cfg)) = socket;
(SERVER_SOCKET_SAFE_P (cfg)) = 0;
return (APR_SUCCESS);
}
bool LLSocket::blockingConnect(const LLHost& host)
{
if(!mSocket) return false;
apr_sockaddr_t* sa = NULL;
std::string ip_address;
ip_address = host.getIPString();
if(ll_apr_warn_status(apr_sockaddr_info_get(
&sa,
ip_address.c_str(),
APR_UNSPEC,
host.getPort(),
0,
mPool())))
{
return false;
}
setBlocking(1000);
ll_debug_socket("Blocking connect", mSocket);
if(ll_apr_warn_status(apr_socket_connect(mSocket, sa))) return false;
setNonBlocking();
return true;
}
/* output: apr_socket_t, apr_sockaddr_t */
static apr_status_t build_connection (request_rec *r,
const char *hostname,
const apr_int64_t port,
apr_socket_t **ps,
apr_sockaddr_t **psa)
{
apr_status_t rv;
apr_pool_t *rp = r->pool;
rv = apr_sockaddr_info_get (psa, hostname, APR_INET, port, 0, rp);
if (rv != APR_SUCCESS)
return rv;
#if APR_MAJOR_VERSION != 0
rv = apr_socket_create (ps, (*psa)->family,
SOCK_STREAM, APR_PROTO_TCP, rp);
#else
rv = apr_socket_create_ex (ps, (*psa)->family,
SOCK_STREAM, APR_PROTO_TCP, rp);
#endif
if (rv != APR_SUCCESS)
return rv;
rv = apr_socket_connect (*ps, *psa);
return rv;
}
static void test_get_addr(abts_case *tc, void *data)
{
apr_status_t rv;
apr_socket_t *ld, *sd, *cd;
apr_sockaddr_t *sa, *ca;
apr_pool_t *subp;
char *a, *b;
APR_ASSERT_SUCCESS(tc, "create subpool", apr_pool_create(&subp, p));
if ((ld = setup_socket(tc)) != APR_SUCCESS)
return;
APR_ASSERT_SUCCESS(tc,
"get local address of bound socket",
apr_socket_addr_get(&sa, APR_LOCAL, ld));
rv = apr_socket_create(&cd, sa->family, SOCK_STREAM,
APR_PROTO_TCP, subp);
APR_ASSERT_SUCCESS(tc, "create client socket", rv);
APR_ASSERT_SUCCESS(tc, "enable non-block mode",
apr_socket_opt_set(cd, APR_SO_NONBLOCK, 1));
/* It is valid for a connect() on a socket with NONBLOCK set to
* succeed (if the connection can be established synchronously),
* but if it does, this test cannot proceed. */
rv = apr_socket_connect(cd, sa);
if (rv == APR_SUCCESS) {
apr_socket_close(ld);
apr_socket_close(cd);
ABTS_NOT_IMPL(tc, "Cannot test if connect completes "
"synchronously");
return;
}
if (!APR_STATUS_IS_EINPROGRESS(rv)) {
apr_socket_close(ld);
apr_socket_close(cd);
APR_ASSERT_SUCCESS(tc, "connect to listener", rv);
return;
}
APR_ASSERT_SUCCESS(tc, "accept connection",
apr_socket_accept(&sd, ld, subp));
{
/* wait for writability */
apr_pollfd_t pfd;
int n;
pfd.p = p;
pfd.desc_type = APR_POLL_SOCKET;
pfd.reqevents = APR_POLLOUT|APR_POLLHUP;
pfd.desc.s = cd;
pfd.client_data = NULL;
APR_ASSERT_SUCCESS(tc, "poll for connect completion",
apr_poll(&pfd, 1, &n, 5 * APR_USEC_PER_SEC));
}
APR_ASSERT_SUCCESS(tc, "get local address of server socket",
apr_socket_addr_get(&sa, APR_LOCAL, sd));
APR_ASSERT_SUCCESS(tc, "get remote address of client socket",
apr_socket_addr_get(&ca, APR_REMOTE, cd));
/* Test that the pool of the returned sockaddr objects exactly
* match the socket. */
ABTS_PTR_EQUAL(tc, subp, sa->pool);
ABTS_PTR_EQUAL(tc, subp, ca->pool);
/* Check equivalence. */
a = apr_psprintf(p, "%pI fam=%d", sa, sa->family);
b = apr_psprintf(p, "%pI fam=%d", ca, ca->family);
ABTS_STR_EQUAL(tc, a, b);
/* Check pool of returned sockaddr, as above. */
APR_ASSERT_SUCCESS(tc, "get local address of client socket",
apr_socket_addr_get(&sa, APR_LOCAL, cd));
APR_ASSERT_SUCCESS(tc, "get remote address of server socket",
apr_socket_addr_get(&ca, APR_REMOTE, sd));
/* Check equivalence. */
a = apr_psprintf(p, "%pI fam=%d", sa, sa->family);
b = apr_psprintf(p, "%pI fam=%d", ca, ca->family);
ABTS_STR_EQUAL(tc, a, b);
ABTS_PTR_EQUAL(tc, subp, sa->pool);
ABTS_PTR_EQUAL(tc, subp, ca->pool);
apr_socket_close(cd);
apr_socket_close(sd);
apr_socket_close(ld);
apr_pool_destroy(subp);
}
static apr_status_t socket_pipe_create(apr_socket_t **rd, apr_socket_t **wr, apr_pool_t *pool)
{
static int id = 0;
apr_socket_t *ls = NULL;
apr_sockaddr_t *pa = NULL;
apr_sockaddr_t *ca = NULL;
apr_size_t nrd;
int uid[2];
int iid[2];
/* Create the unique socket identifier
* so that we know the connection originated
* from us.
*/
uid[0] = getpid();
uid[1] = id++;
if(apr_socket_create(&ls, AF_INET, SOCK_STREAM, APR_PROTO_TCP, pool) != APR_SUCCESS) {
return apr_get_netos_error();
}
apr_socket_opt_set(ls, APR_SO_REUSEADDR, 1);
if(apr_sockaddr_info_get(&pa,"127.0.0.1",APR_INET,0,0,pool) != APR_SUCCESS) {
apr_socket_close(ls);
return apr_get_netos_error();
}
if(apr_socket_bind(ls, pa) != APR_SUCCESS) {
apr_socket_close(ls);
return apr_get_netos_error();
}
if(apr_socket_addr_get(&ca,APR_LOCAL,ls) != APR_SUCCESS) {
apr_socket_close(ls);
return apr_get_netos_error();
}
if(apr_socket_listen(ls,1) != APR_SUCCESS) {
apr_socket_close(ls);
return apr_get_netos_error();
}
if(apr_socket_create(wr, AF_INET, SOCK_STREAM, APR_PROTO_TCP, pool) != APR_SUCCESS) {
apr_socket_close(ls);
return apr_get_netos_error();
}
apr_socket_opt_set(*wr, APR_SO_REUSEADDR, 1);
if(apr_socket_connect(*wr, ca) != APR_SUCCESS) {
apr_socket_close(ls);
apr_socket_close(*wr);
return apr_get_netos_error();
}
nrd = sizeof(uid);
if(apr_socket_send(*wr, (char *)uid, &nrd) != APR_SUCCESS) {
apr_socket_close(ls);
apr_socket_close(*wr);
return apr_get_netos_error();
}
apr_socket_opt_set(ls, APR_SO_NONBLOCK, 0);
/* Listening socket is blocking by now. The accept should
* return immediatelly because we connected already.
*/
if(apr_socket_accept(rd, ls, pool) != APR_SUCCESS) {
apr_socket_close(ls);
apr_socket_close(*wr);
return apr_get_netos_error();
}
/* Put read side of the pipe to the blocking mode */
apr_socket_opt_set(*rd, APR_SO_NONBLOCK, 0);
for (;;) {
/* Verify the connection by reading the sent identification */
nrd = sizeof(iid);
if(apr_socket_recv(*rd, (char *)iid, &nrd) != APR_SUCCESS) {
apr_socket_close(ls);
apr_socket_close(*wr);
apr_socket_close(*rd);
return apr_get_netos_error();
}
if(nrd == sizeof(iid)) {
if(memcmp(uid, iid, sizeof(uid)) == 0) {
/* Wow, we recived what we sent */
break;
}
}
}
/* We don't need the listening socket any more */
apr_socket_close(ls);
return APR_SUCCESS;
}
int main(int argc, char *argv[])
{
apr_pool_t *p;
apr_socket_t *sock;
apr_status_t rv;
apr_sockaddr_t *remote_sa;
apr_initialize();
atexit(apr_terminate);
apr_pool_create(&p, NULL);
if (argc < 3) {
exit(-1);
}
rv = apr_sockaddr_info_get(&remote_sa, argv[2], APR_UNSPEC, 8021, 0, p);
if (rv != APR_SUCCESS) {
exit(-1);
}
if (apr_socket_create(&sock, remote_sa->family, SOCK_STREAM, 0,
p) != APR_SUCCESS) {
exit(-1);
}
rv = apr_socket_timeout_set(sock, apr_time_from_sec(3));
if (rv) {
exit(-1);
}
apr_socket_connect(sock, remote_sa);
if (!strcmp("read", argv[1])) {
char datarecv[STRLEN];
apr_size_t length = STRLEN;
apr_status_t rv;
memset(datarecv, 0, STRLEN);
rv = apr_socket_recv(sock, datarecv, &length);
apr_socket_close(sock);
if (APR_STATUS_IS_TIMEUP(rv)) {
exit(SOCKET_TIMEOUT);
}
if (strcmp(datarecv, DATASTR)) {
exit(-1);
}
exit((int)length);
}
else if (!strcmp("write", argv[1])
|| !strcmp("write_after_delay", argv[1])) {
apr_size_t length = strlen(DATASTR);
if (!strcmp("write_after_delay", argv[1])) {
apr_sleep(apr_time_from_sec(2));
}
apr_socket_send(sock, DATASTR, &length);
apr_socket_close(sock);
exit((int)length);
}
else if (!strcmp("close", argv[1])) {
apr_socket_close(sock);
exit(0);
}
exit(-1);
}
static void test_get_addr(abts_case *tc, void *data)
{
apr_status_t rv;
apr_socket_t *ld, *sd, *cd;
apr_sockaddr_t *sa, *ca;
char a[128], b[128];
ld = setup_socket(tc);
APR_ASSERT_SUCCESS(tc,
"get local address of bound socket",
apr_socket_addr_get(&sa, APR_LOCAL, ld));
rv = apr_socket_create(&cd, sa->family, SOCK_STREAM,
APR_PROTO_TCP, p);
APR_ASSERT_SUCCESS(tc, "create client socket", rv);
APR_ASSERT_SUCCESS(tc, "enable non-block mode",
apr_socket_opt_set(cd, APR_SO_NONBLOCK, 1));
/* It is valid for a connect() on a socket with NONBLOCK set to
* succeed (if the connection can be established synchronously),
* but if it does, this test cannot proceed. */
rv = apr_socket_connect(cd, sa);
if (rv == APR_SUCCESS) {
apr_socket_close(ld);
apr_socket_close(cd);
ABTS_NOT_IMPL(tc, "Cannot test if connect completes "
"synchronously");
return;
}
if (!APR_STATUS_IS_EINPROGRESS(rv)) {
apr_socket_close(ld);
apr_socket_close(cd);
APR_ASSERT_SUCCESS(tc, "connect to listener", rv);
return;
}
APR_ASSERT_SUCCESS(tc, "accept connection",
apr_socket_accept(&sd, ld, p));
{
/* wait for writability */
apr_pollfd_t pfd;
int n;
pfd.p = p;
pfd.desc_type = APR_POLL_SOCKET;
pfd.reqevents = APR_POLLOUT|APR_POLLHUP;
pfd.desc.s = cd;
pfd.client_data = NULL;
APR_ASSERT_SUCCESS(tc, "poll for connect completion",
apr_poll(&pfd, 1, &n, 5 * APR_USEC_PER_SEC));
}
APR_ASSERT_SUCCESS(tc, "get local address of server socket",
apr_socket_addr_get(&sa, APR_LOCAL, sd));
APR_ASSERT_SUCCESS(tc, "get remote address of client socket",
apr_socket_addr_get(&ca, APR_REMOTE, cd));
apr_snprintf(a, sizeof(a), "%pI", sa);
apr_snprintf(b, sizeof(b), "%pI", ca);
ABTS_STR_EQUAL(tc, a, b);
apr_socket_close(cd);
apr_socket_close(sd);
apr_socket_close(ld);
}
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_poller_task_descriptor_add(agent->task, &connection->sock_pfd) != TRUE) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Add to Pollset %s",connection->id);
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;
APR_RING_INSERT_TAIL(&agent->connection_list,connection,mrcp_connection_t,link);
connection->parser = mrcp_parser_create(agent->resource_factory,connection->pool);
connection->generator = mrcp_generator_create(agent->resource_factory,connection->pool);
connection->tx_buffer_size = agent->tx_buffer_size;
connection->tx_buffer = apr_palloc(connection->pool,connection->tx_buffer_size+1);
connection->rx_buffer_size = agent->rx_buffer_size;
connection->rx_buffer = apr_palloc(connection->pool,connection->rx_buffer_size+1);
apt_text_stream_init(&connection->rx_stream,connection->rx_buffer,connection->rx_buffer_size);
if(apt_log_masking_get() != APT_LOG_MASKING_NONE) {
connection->verbose = FALSE;
mrcp_parser_verbose_set(connection->parser,TRUE);
mrcp_generator_verbose_set(connection->generator,TRUE);
}
return connection;
}
SWITCH_DECLARE(switch_status_t) switch_socket_connect(switch_socket_t *sock, switch_sockaddr_t *sa)
{
return apr_socket_connect(sock, sa);
}
int
cluscom_query( char* host,
int port,
char* input,
int len_in,
char* output,
int len_out,
apr_pool_t* mempool )
{
apr_socket_t* sock;
apr_sockaddr_t* sock_addr;
apr_sockaddr_info_get(&sock_addr, host, APR_INET, port, 0, mempool);
apr_socket_create(&sock, sock_addr->family, SOCK_STREAM, APR_PROTO_TCP, mempool);
apr_socket_opt_set(sock, APR_SO_NONBLOCK, 0);
apr_socket_timeout_set(sock, DEF_SOCKET_TIMEOUT);
apr_socket_opt_set(sock, APR_SO_REUSEADDR, 1);
apr_status_t rv;
char rv_words[100];
rv = apr_socket_connect(sock, sock_addr);
if (rv != APR_SUCCESS)
{
#ifdef FRL_DEBUGGING
apr_strerror(rv, rv_words, 100);
printf("[cluscom_query]: Socket Connect Error: Code: %d - %s\n", rv, rv_words);
#endif
apr_socket_close(sock);
return -1;
}
apr_uint32_t len_in_a = len_in;
rv = apr_socket_send(sock, input, &len_in_a);
if ((rv == APR_SUCCESS)&&(len_in_a == len_in))
{
apr_uint32_t len_out_a = len_out;
apr_socket_timeout_set(sock, DEF_PROCESS_TIMEOUT);
rv = apr_socket_recv(sock, output, &len_out_a);
apr_socket_close(sock);
if ((rv != APR_SUCCESS)||(len_out_a != len_out))
{
#ifdef FRL_DEBUGGING
if (rv != APR_SUCCESS)
{
apr_strerror(rv, rv_words, 100);
printf("[cluscom_query]: Socket Receive Error: Code: %d - %s\n", rv, rv_words);
} else {
printf("[cluscom_query]: Socket Receive Warning: Not Correct Size.\n");
}
#endif
return -1;
}
} else {
#ifdef FRL_DEBUGGING
if (rv != APR_SUCCESS)
{
apr_strerror(rv, rv_words, 100);
printf("[cluscom_query]: Socket Send Error: Code: %d - %s\n", rv, rv_words);
} else {
printf("[cluscom_query]: Socket Send Warning: Not Correct Size.\n");
}
#endif
apr_socket_close(sock);
return -1;
}
return 0;
}
apr_status_t
rainx_http_req(struct req_params_store* rps) {
const dav_resource* resource = rps->resource;
char* remote_uri = rps->service_address;
char* req_type = rps->req_type;
char* header = rps->header;
char* data = rps->data_to_send;
int data_length = rps->data_to_send_size;
char** reply = &(rps->reply);
apr_pool_t *local_pool = rps->pool;
dav_rainx_server_conf *server_conf = resource_get_server_config(resource);
if (NULL == resource || NULL == remote_uri ||
NULL == req_type || NULL == server_conf) {
DAV_ERROR_POOL(local_pool, APR_EINVAL, "One of these params is wrong: "
"remote_uri=%p, req_type=%p, server_conf=%p"
" (__FILE__:__LINE__)",
remote_uri, req_type, server_conf);
return APR_EINVAL;
}
const gboolean is_get = (0 == g_strcmp0(req_type, "GET"));
/* Isolating Rawx IP and port */
char *temp_remote_uri = apr_pstrdup(local_pool, remote_uri);
char* last;
char* full_remote_url = apr_strtok(temp_remote_uri, "/", &last);
char* content_hexid = apr_pstrdup(local_pool, remote_uri + strlen(full_remote_url));
char* remote_ip = NULL;
char* scope_id = NULL;
apr_port_t remote_port;
apr_parse_addr_port(&remote_ip, &scope_id, &remote_port, full_remote_url, local_pool);
/* ------- */
/* Preparing the socket */
apr_socket_t* sock;
apr_sockaddr_t* sockaddr;
apr_status_t status;
if ((status = apr_sockaddr_info_get(&sockaddr, remote_ip, APR_INET, remote_port, 0, local_pool)) != APR_SUCCESS) {
DAV_DEBUG_REQ(resource->info->request, 0, "unable to connect to the rawx %s", full_remote_url);
return status;
}
if ((status = apr_socket_create(&sock, sockaddr->family, SOCK_STREAM, APR_PROTO_TCP, local_pool)) != APR_SUCCESS) {
DAV_DEBUG_REQ(resource->info->request, 0, "unable to create a socket to the rawx %s", full_remote_url);
return status;
}
if ((status = apr_socket_timeout_set(sock, server_conf->socket_timeout)) != APR_SUCCESS) {
DAV_DEBUG_REQ(resource->info->request, 0, "unable to set timeout for the socket to the rawx %s", full_remote_url);
return status;
}
if ((status = apr_socket_connect(sock, sockaddr)) != APR_SUCCESS) {
DAV_DEBUG_REQ(resource->info->request, 0, "unable to establish the connection to the rawx %s", full_remote_url);
return status;
}
/* ------- */
/* Forging the message */
char* forged_header = apr_psprintf(local_pool, "%s %s HTTP/1.1\nHost: %s", req_type, content_hexid, full_remote_url);
if (header)
forged_header = apr_psprintf(local_pool, "%s\n%s", forged_header, header);
if (data)
forged_header = apr_psprintf(local_pool, "%s\nContent-Length: %d\n\n", forged_header, data_length);
else
forged_header = apr_psprintf(local_pool, "%s\n\n", forged_header);
/* ------- */
/* Sending the message */
int remaining_to_send = strlen(forged_header);
char* ptr_start = forged_header;
apr_size_t send_buffer_size;
while (remaining_to_send > 0) {
if (remaining_to_send < REQUEST_BUFFER_SIZE)
send_buffer_size = (apr_size_t)remaining_to_send;
else
send_buffer_size = REQUEST_BUFFER_SIZE;
if ((status = apr_socket_send(sock, ptr_start, &send_buffer_size)) != APR_SUCCESS) {
DAV_DEBUG_REQ(resource->info->request, 0, "failed to send the %s request to the rawx %s", req_type, full_remote_url);
apr_status_t status_sav = status;
apr_socket_close(sock);
return status_sav;
}
remaining_to_send -= send_buffer_size;
ptr_start = ptr_start + send_buffer_size;
}
if (NULL != data) {
remaining_to_send = data_length;
ptr_start = data;
while (remaining_to_send > 0) {
if (remaining_to_send < REQUEST_BUFFER_SIZE)
send_buffer_size = (apr_size_t)remaining_to_send;
else
send_buffer_size = REQUEST_BUFFER_SIZE;
if ((status = apr_socket_send(sock, ptr_start, &send_buffer_size)) != APR_SUCCESS) {
DAV_DEBUG_REQ(resource->info->request, 0, "failed to send the %s request to the rawx %s", req_type, full_remote_url);
apr_status_t status_sav = status;
apr_socket_close(sock);
return status_sav;
}
remaining_to_send -= send_buffer_size;
ptr_start = ptr_start + send_buffer_size;
}
}
if (is_get) {
/* This avoids a ~5s delay in the communication */
apr_socket_shutdown(sock, APR_SHUTDOWN_WRITE);
}
DAV_DEBUG_REQ(resource->info->request, 0, "%s request to the rawx %s sent for the content %s", req_type, full_remote_url, content_hexid);
/* ------ */
/* Getting the reply */
char* reply_ptr = *reply;
apr_size_t total_size;
if (!is_get)
total_size = REPLY_BUFFER_SIZE; // PUT or DELETE
else
total_size = MAX_REPLY_HEADER_SIZE + data_length; // GET
apr_size_t reply_size = (apr_size_t)total_size;
apr_size_t total_replied_size;
do {
status = apr_socket_recv(sock, reply_ptr, &reply_size);
reply_ptr += reply_size;
total_replied_size = reply_ptr - *reply;
/* Leave when OK, or error != timeout, or buffer full */
if (status == APR_EOF || (status == APR_SUCCESS && !is_get) ||
(reply_size == 0) ||
total_replied_size >= total_size) {
break;
}
/* Take care of overflows! */
reply_size = total_size - total_replied_size;
} while (total_replied_size < total_size);
/* ------- */
apr_socket_close(sock);
return status;
}
/* Send the OCSP request serialized into BIO 'request' to the
* responder at given server given by URI. Returns socket object or
* NULL on error. */
static apr_socket_t *send_request(BIO *request, const apr_uri_t *uri,
apr_interval_time_t timeout,
conn_rec *c, apr_pool_t *p,
const apr_uri_t *proxy_uri)
{
apr_status_t rv;
apr_sockaddr_t *sa;
apr_socket_t *sd;
char buf[HUGE_STRING_LEN];
int len;
const apr_uri_t *next_hop_uri;
if (proxy_uri) {
next_hop_uri = proxy_uri;
}
else {
next_hop_uri = uri;
}
rv = apr_sockaddr_info_get(&sa, next_hop_uri->hostname, APR_UNSPEC,
next_hop_uri->port, 0, p);
if (rv) {
ap_log_cerror(APLOG_MARK, APLOG_ERR, rv, c, APLOGNO(01972)
"could not resolve address of %s %s",
proxy_uri ? "proxy" : "OCSP responder",
next_hop_uri->hostinfo);
return NULL;
}
/* establish a connection to the OCSP responder */
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c, APLOGNO(01973)
"connecting to %s '%s'",
proxy_uri ? "proxy" : "OCSP responder",
uri->hostinfo);
/* Cycle through address until a connect() succeeds. */
for (; sa; sa = sa->next) {
rv = apr_socket_create(&sd, sa->family, SOCK_STREAM, APR_PROTO_TCP, p);
if (rv == APR_SUCCESS) {
apr_socket_timeout_set(sd, timeout);
rv = apr_socket_connect(sd, sa);
if (rv == APR_SUCCESS) {
break;
}
apr_socket_close(sd);
}
}
if (sa == NULL) {
ap_log_cerror(APLOG_MARK, APLOG_ERR, rv, c, APLOGNO(01974)
"could not connect to %s '%s'",
proxy_uri ? "proxy" : "OCSP responder",
next_hop_uri->hostinfo);
return NULL;
}
/* send the request and get a response */
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c, APLOGNO(01975)
"sending request to OCSP responder");
while ((len = BIO_read(request, buf, sizeof buf)) > 0) {
char *wbuf = buf;
apr_size_t remain = len;
do {
apr_size_t wlen = remain;
rv = apr_socket_send(sd, wbuf, &wlen);
wbuf += remain;
remain -= wlen;
} while (rv == APR_SUCCESS && remain > 0);
if (rv) {
apr_socket_close(sd);
ap_log_cerror(APLOG_MARK, APLOG_ERR, rv, c, APLOGNO(01976)
"failed to send request to OCSP responder '%s'",
uri->hostinfo);
return NULL;
}
}
return sd;
}
apr_status_t jxr_connect_socket(jaxer_connection * ac)
{
apr_status_t rv;
apr_socket_t *sock = 0;
jaxer_worker *aworker = ac->worker;
apr_sockaddr_t *remote_sa = aworker->remote_sa;
apr_pool_t *p = ac->worker->pool;
ap_log_perror(APLOG_MARK, APLOG_ZDEBUG, 0, p, "in jxr_connect-socket");
if (ac->sock)
{
if ((rv=apr_socket_close(ac->sock)) != APR_SUCCESS)
{
ap_log_perror(APLOG_MARK, APLOG_WARNING, rv, p,
"mod_jaxer: faied to close socket: return code=%d", rv);
// return rv;
}
ac->sock = 0;
}
#ifdef _APACHE20
rv = apr_socket_create_ex(&sock, APR_INET, SOCK_STREAM, APR_PROTO_TCP, p);
#else
rv = apr_socket_create(&sock, APR_INET, SOCK_STREAM, APR_PROTO_TCP, p);
#endif
ap_log_perror(APLOG_MARK, APLOG_ZDEBUG, 0, p, "in jxr_connect-socket: apr_socket_create returned %d", rv);
if (rv != APR_SUCCESS)
{
ap_log_perror(APLOG_MARK, APLOG_WARNING, rv, p,
"mod_jaxer: faied to create socket: return code=%d", rv);
return rv;
}
/*
* The options for the sockets
*/
#if 0
// KEEPALIVE
rv = apr_socket_opt_set(sock, APR_SO_KEEPALIVE, 1);
if (rv != APR_SUCCESS)
{
compat_log_rerror(APLOG_MARK, APLOG_WARNING, rv, r,
"mod_jaxer: apr_socket_opt_set failed to set keep alive: return code=%d", rv);
return rv;
}
// APR_SO_LINGER?
rv = apr_socket_opt_set(sock, APR_SO_LINGER, 0);
if (rv != APR_SUCCESS)
{
compat_log_rerror(APLOG_MARK, APLOG_WARNING, rv, r,
"mod_jaxer: apr_socket_opt_set failed to set keep alive: return code=%d", rv);
return rv;
}
//TIME OUT
rv = apr_socket_timeout_set(sock, apr_time_from_sec(3));
if (rv != APR_SUCCESS)
{
compat_log_rerror(APLOG_MARK, APLOG_WARNING, rv, r,
"mod_jaxer: apr_socket_opt_set failed to set timeout: return code=%d", rv);
return rv;
}
#endif
// Block first
rv = apr_socket_opt_set(sock, APR_SO_NONBLOCK, 0);
ap_log_perror(APLOG_MARK, APLOG_ZDEBUG, 0, p, "apr_socket_opt_set return %d", rv);
if (rv != APR_SUCCESS)
{
ap_log_perror(APLOG_MARK, APLOG_WARNING, rv, p,
"mod_jaxer: apr_socket_opt_set failed to set blocking: return code=%d", rv);
return rv;
}
rv = apr_socket_connect(sock, remote_sa);
ap_log_perror(APLOG_MARK, APLOG_ZDEBUG, 0, p, "apr_socket_connect return %d", rv);
ap_log_perror(APLOG_MARK, APLOG_ZDEBUG, 0, p, "sa: hostname=%s servername=%s port=%d family=%d salen=%d",
remote_sa->hostname,
remote_sa->servname,
remote_sa->port,
remote_sa->family,
remote_sa->salen
);
if (APR_STATUS_IS_EAGAIN(rv))
{
fprintf(stderr, "EAGAIN\n");
}else if (APR_STATUS_IS_EINPROGRESS(rv))
{
fprintf(stderr, "EEINPROGRESS\n");
}
if (rv != APR_SUCCESS)
{
ap_log_perror(APLOG_MARK, APLOG_WARNING, rv, p,
"mod_jaxer: apr_socket_connect failed: return code=%d", rv);
return rv;
}
ac->sock = sock;
return rv;
}
void * CALLBACK mosquitto_on_connect(const WebSocketServer *server)
{
MosquittoData *dib = NULL;
apr_sockaddr_t *sa;
if ((server != NULL) && (server->version == WEBSOCKET_SERVER_VERSION_1)) {
/* Get access to the request_rec strucure for this connection */
request_rec *r = server->request(server);
if (r != NULL) {
apr_pool_t *pool = NULL;
size_t i, count = server->protocol_count(server);
/* Only support "mqtt" */
for (i = 0; i < count; i++) {
const char *protocol = server->protocol_index(server, i);
if ((protocol != NULL) &&
(strncmp(protocol, "mqtt",4) == 0)) {
/* If the client can speak the protocol, set it in the response */
server->protocol_set(server, protocol);
break;
}
}
/* If the protocol negotiation worked, create a new memory pool */
if ((i < count) &&
(apr_pool_create(&pool, r->pool) == APR_SUCCESS)) {
/* Allocate memory to hold mosquitto state */
if ((dib = (MosquittoData *) apr_palloc(pool, sizeof(MosquittoData))) != NULL) {
apr_thread_t *thread = NULL;
apr_threadattr_t *thread_attr = NULL;
dib->server = server;
dib->pool = pool;
dib->thread = NULL;
dib->counter = 0;
dib->active = 1;
request_rec *r = server->request(server);
mosquitto_cfg* dir = ap_get_module_config(r->per_dir_config, &mod_websocket_mosquitto) ;
int rv = apr_sockaddr_info_get(&sa,dir->broker,APR_UNSPEC,atoi(dir->port),APR_IPV6_ADDR_OK ,pool);
if (rv)
ap_log_error(APLOG_MARK, APLOG_CRIT,0,NULL,"apr_sockaddr_info_get failed #%x",rv);
else
ap_log_error(APLOG_MARK, APLOG_DEBUG,0,NULL,"Address family %s",sa->family == APR_INET6 ? "IPv6" : "IPv4");
rv = apr_socket_create(&dib->sockfd,sa->family, SOCK_STREAM, APR_PROTO_TCP,pool);
if (rv) ap_log_error(APLOG_MARK, APLOG_CRIT,0,NULL,"apr_socket_create failed #%x",rv);
rv = apr_socket_connect(dib->sockfd,sa);
if (rv) ap_log_error(APLOG_MARK, APLOG_CRIT,0,NULL,"apr_socket_connect failed #%x",rv);
/* Create a non-detached thread that will perform the work */
if ((apr_threadattr_create(&thread_attr, pool) == APR_SUCCESS) &&
(apr_threadattr_detach_set(thread_attr, 0) == APR_SUCCESS) &&
(apr_thread_create(&thread, thread_attr, mosquitto_run, dib, pool) == APR_SUCCESS)) {
dib->thread = thread;
/* Success */
pool = NULL;
} else {
dib = NULL;
}
}
if (pool != NULL) {
apr_pool_destroy(pool);
}
}
}
}
return dib;
}
/* This function connects to the server and sends enough data to
* ensure the child wakes up and processes a new connection. This
* permits the MPM to skip the poll when there is only one listening
* socket, because it provides a alternate way to unblock an accept()
* when the pod is used. */
static apr_status_t dummy_connection(ap_pod_t *pod)
{
const char *data;
apr_status_t rv;
apr_socket_t *sock;
apr_pool_t *p;
apr_size_t len;
ap_listen_rec *lp;
/* create a temporary pool for the socket. pconf stays around too long */
rv = apr_pool_create(&p, pod->p);
if (rv != APR_SUCCESS) {
return rv;
}
/* If possible, find a listener which is configured for
* plain-HTTP, not SSL; using an SSL port would either be
* expensive to do correctly (performing a complete SSL handshake)
* or cause log spam by doing incorrectly (simply sending EOF). */
lp = ap_listeners;
while (lp && lp->protocol && strcasecmp(lp->protocol, "http") != 0) {
lp = lp->next;
}
if (!lp) {
lp = ap_listeners;
}
rv = apr_socket_create(&sock, lp->bind_addr->family, SOCK_STREAM, 0, p);
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf, APLOGNO(00054)
"get socket to connect to listener");
apr_pool_destroy(p);
return rv;
}
/* on some platforms (e.g., FreeBSD), the kernel won't accept many
* queued connections before it starts blocking local connects...
* we need to keep from blocking too long and instead return an error,
* because the MPM won't want to hold up a graceful restart for a
* long time
*/
rv = apr_socket_timeout_set(sock, apr_time_from_sec(3));
if (rv != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_WARNING, rv, ap_server_conf, APLOGNO(00055)
"set timeout on socket to connect to listener");
apr_socket_close(sock);
apr_pool_destroy(p);
return rv;
}
rv = apr_socket_connect(sock, lp->bind_addr);
if (rv != APR_SUCCESS) {
int log_level = APLOG_WARNING;
if (APR_STATUS_IS_TIMEUP(rv)) {
/* probably some server processes bailed out already and there
* is nobody around to call accept and clear out the kernel
* connection queue; usually this is not worth logging
*/
log_level = APLOG_DEBUG;
}
ap_log_error(APLOG_MARK, log_level, rv, ap_server_conf, APLOGNO(00056)
"connect to listener on %pI", lp->bind_addr);
apr_pool_destroy(p);
return rv;
}
if (lp->protocol && strcasecmp(lp->protocol, "https") == 0) {
/* Send a TLS 1.0 close_notify alert. This is perhaps the
* "least wrong" way to open and cleanly terminate an SSL
* connection. It should "work" without noisy error logs if
* the server actually expects SSLv3/TLSv1. With
* SSLv23_server_method() OpenSSL's SSL_accept() fails
* ungracefully on receipt of this message, since it requires
* an 11-byte ClientHello message and this is too short. */
static const unsigned char tls10_close_notify[7] = {
'\x15', /* TLSPlainText.type = Alert (21) */
'\x03', '\x01', /* TLSPlainText.version = {3, 1} */
'\x00', '\x02', /* TLSPlainText.length = 2 */
'\x01', /* Alert.level = warning (1) */
'\x00' /* Alert.description = close_notify (0) */
};
data = (const char *)tls10_close_notify;
len = sizeof(tls10_close_notify);
}
else /* ... XXX other request types here? */ {
/* Create an HTTP request string. We include a User-Agent so
* that adminstrators can track down the cause of the
* odd-looking requests in their logs. A complete request is
* used since kernel-level filtering may require that much
* data before returning from accept(). */
data = apr_pstrcat(p, "OPTIONS * HTTP/1.0\r\nUser-Agent: ",
ap_get_server_description(),
" (internal dummy connection)\r\n\r\n", NULL);
len = strlen(data);
}
apr_socket_send(sock, data, &len);
apr_socket_close(sock);
apr_pool_destroy(p);
return rv;
}
static apr_socket_t *
create_net_client(apr_pool_t *context, int type, char *host, apr_port_t port, const char *interface, char *bind_address, int bind_hostname)
{
apr_sockaddr_t *localsa = NULL;
apr_sockaddr_t *remotesa = NULL;
apr_socket_t *sock = NULL;
apr_status_t status;
int family = APR_UNSPEC;
char _bind_address[APRMAXHOSTLEN+1];
status = apr_sockaddr_info_get(&remotesa, host, APR_UNSPEC, port, 0, context);
if(status!= APR_SUCCESS)
{
return NULL;
}
/* Get local address, if needed */
switch(bind_hostname)
{
case 0:
if(bind_address != NULL)
status = apr_sockaddr_info_get(&localsa, bind_address, APR_UNSPEC, 0, 0, context);
break;
case 1:
status = apr_gethostname(_bind_address, APRMAXHOSTLEN, context);
if(status!= APR_SUCCESS)
{
return NULL;
}
status = apr_sockaddr_info_get(&localsa, _bind_address, APR_UNSPEC, 0, 0, context);
break;
default:
return NULL;
}
if(status!= APR_SUCCESS)
{
return NULL;
}
family = remotesa->sa.sin.sin_family;
/* Created the socket */
status = apr_socket_create(&sock, family, type, 0, context);
if(status != APR_SUCCESS)
{
return NULL;
}
if (interface != NULL)
{
mcast_emit_on_if(context, sock, host, port, interface);
}
/* Bind if necessary */
if(localsa != NULL)
{
status = apr_socket_bind(sock, localsa);
if(status != APR_SUCCESS)
{
return NULL;
}
}
/* Connect the socket to the address */
status = apr_socket_connect(sock, remotesa);
if(status != APR_SUCCESS)
{
apr_socket_close(sock);
return NULL;
}
return sock;
}
