/******************************************************************************** * * 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; }