void connection_queue::on_timeout(error_code const& e)
{
mutex_t::scoped_lock l(m_mutex);
INVARIANT_CHECK;
#ifdef TORRENT_DEBUG
function_guard guard_(m_in_timeout_function);
#endif
TORRENT_ASSERT(!e || e == asio::error::operation_aborted);
if (e) return;
ptime next_expire = max_time();
ptime now = time_now_hires() + milliseconds(100);
std::list<entry> timed_out;
for (std::list<entry>::iterator i = m_queue.begin();
!m_queue.empty() && i != m_queue.end();)
{
if (i->connecting && i->expires < now)
{
std::list<entry>::iterator j = i;
++i;
timed_out.splice(timed_out.end(), m_queue, j, i);
--m_num_connecting;
continue;
}
if (i->expires < next_expire)
next_expire = i->expires;
++i;
}
// we don't want to call the timeout callback while we're locked
// since that is a recepie for dead-locks
l.unlock();
for (std::list<entry>::iterator i = timed_out.begin()
, end(timed_out.end()); i != end; ++i)
{
#ifndef BOOST_NO_EXCEPTIONS
try {
#endif
i->on_timeout();
#ifndef BOOST_NO_EXCEPTIONS
} catch (std::exception&) {}
#endif
}
l.lock();
if (next_expire < max_time())
{
error_code ec;
m_timer.expires_at(next_expire, ec);
m_timer.async_wait(boost::bind(&connection_queue::on_timeout, this, _1));
}
try_connect(l);
}
static void
reconnect( void *user_data ) {
UNUSED( user_data );
bool ret = try_connect();
if ( ret == false ) {
error( "Failed to reconnect." );
clear_connection();
}
}
MiracBroker::MiracBroker(const std::string& peer_address, const std::string& peer_port, uint timeout):
peer_address_(peer_address),
peer_port_(peer_port),
connect_timeout_(timeout)
{
network_source_ptr_ = this;
connection_source_ptr_ = this;
connect_timer_ = g_timer_new();
try_connect();
}
static void try_connect_frm(Fl_Widget* o, void* userdata) {
auto ptr = ((ConnectWindowImpl*)userdata);
std::string host = ptr->bInput->value();
ptr->connectbtn->label("Connecting . . .");
ptr->bInput->deactivate();
ptr->connectbtn->deactivate();
std::thread th([host, ptr]() { try_connect(host, ptr); });
th.detach();
}
/* This is a timer handler to reconnect to a peer after a period of time elapsed.
*/
static void timer_reconnect(void *arg){
void try_connect(struct file_info *fi);
struct file_info *fi;
for (fi = file_info; fi != 0; fi = fi->next) {
if (fi->type != FI_FREE && fi->uid == arg) {
printf("reconnecting\n");
try_connect(fi);
return;
}
}
printf("reconnect: entry not found\n");
}
static int cons_init(void)
{
LOG("Vkd Module loaded");
/*Attempt to connect to the server
If the server is down, the module will do nothing
*/
try_connect();
if (atomic_read(&state) == STATE_RUNNING)
register_vkd_console();
return 0;
}
/* see what the status of the UPS is and handle any changes */
static void pollups(utype_t *ups)
{
char status[SMALLBUF];
/* try a reconnect here */
if (!flag_isset(ups->status, ST_CONNECTED))
if (try_connect(ups) != 1)
return;
if (upscli_ssl(&ups->conn) == 1)
upsdebugx(2, "%s: %s [SSL]", __func__, ups->sys);
else
upsdebugx(2, "%s: %s", __func__, ups->sys);
set_alarm();
if (get_var(ups, "status", status, sizeof(status)) == 0) {
clear_alarm();
parse_status(ups, status);
return;
}
/* fallthrough: no communications */
clear_alarm();
/* try to make some of these a little friendlier */
switch (upscli_upserror(&ups->conn)) {
case UPSCLI_ERR_UNKNOWNUPS:
upslogx(LOG_ERR, "Poll UPS [%s] failed - [%s] "
"does not exist on server %s",
ups->sys, ups->upsname, ups->hostname);
break;
default:
upslogx(LOG_ERR, "Poll UPS [%s] failed - %s",
ups->sys, upscli_strerror(&ups->conn));
break;
}
/* throw COMMBAD or NOCOMM as conditions may warrant */
ups_is_gone(ups);
/* if upsclient lost the connection, clean up things on our side */
if (upscli_fd(&ups->conn) == -1) {
drop_connection(ups);
return;
}
}
void do_connect(gchar *cmd, gpointer data)
{
gchar **tab;
tab = wordtab(cmd);
if (count_tab(tab) < 2)
add_text("/server ip port \n", data);
else
{
if (try_connect(tab, data))
add_text("Connected succesfully \n", data);
else
add_text("Error while trying to connect \n", data);
}
free_tab(tab);
}
static void *connect_thread(void *data)
{
struct rtmp_stream *stream = data;
int ret = try_connect(stream);
if (ret != OBS_OUTPUT_SUCCESS) {
obs_output_signal_stop(stream->output, ret);
info("Connection to %s failed: %d", stream->path.array, ret);
}
if (os_event_try(stream->stop_event) == EAGAIN)
pthread_detach(stream->connect_thread);
stream->connecting = false;
return NULL;
}
void connection_queue::done(int ticket)
{
mutex_t::scoped_lock l(m_mutex);
INVARIANT_CHECK;
std::list<entry>::iterator i = std::find_if(m_queue.begin()
, m_queue.end(), boost::bind(&entry::ticket, _1) == ticket);
if (i == m_queue.end())
{
// this might not be here in case on_timeout calls remove
return;
}
if (i->connecting) --m_num_connecting;
m_queue.erase(i);
try_connect();
}
/**
* Try reconnecting to the dht service.
*
* @param cls a `struct GNUNET_DHT_Handle`
* @param tc scheduler context
*/
static void
try_reconnect (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_DHT_Handle *handle = cls;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting with DHT %p\n", handle);
handle->retry_time = GNUNET_TIME_STD_BACKOFF (handle->retry_time);
handle->reconnect_task = NULL;
if (GNUNET_YES != try_connect (handle))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "dht reconnect failed(!)\n");
return;
}
GNUNET_CONTAINER_multihashmap_iterate (handle->active_requests,
&add_request_to_pending, handle);
process_pending_messages (handle);
}
/**
* Initialize the connection with the DHT service.
*
* @param cfg configuration to use
* @param ht_len size of the internal hash table to use for
* processing multiple GET/FIND requests in parallel
* @return handle to the DHT service, or NULL on error
*/
struct GNUNET_DHT_Handle *
GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
unsigned int ht_len)
{
struct GNUNET_DHT_Handle *handle;
handle = GNUNET_new (struct GNUNET_DHT_Handle);
handle->cfg = cfg;
handle->uid_gen =
GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
handle->active_requests = GNUNET_CONTAINER_multihashmap_create (ht_len, GNUNET_YES);
if (GNUNET_NO == try_connect (handle))
{
GNUNET_DHT_disconnect (handle);
return NULL;
}
return handle;
}
int ft_connect(char const *addr, char const *port)
{
struct addrinfo hints;
struct addrinfo *res;
struct protoent *proto;
int fd;
if ((proto = getprotobyname("tcp")) == NULL)
return (-1);
ft_bzero(&hints, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = proto->p_proto;
if (getaddrinfo(addr, port, &hints, &res) != 0)
return (-1);
fd = try_connect(res);
freeaddrinfo(res);
return (fd);
}
static int ctrl_connect(const char *host, const char *port,
struct addrinfo **ai, struct options *opts,
struct callbacks *cb)
{
int ctrl_conn, magic, optval = 1;
ctrl_conn = try_connect(host, port, ai, opts, cb);
if (setsockopt(ctrl_conn, IPPROTO_TCP, TCP_NODELAY, &optval,
sizeof(optval)))
PLOG_ERROR(cb, "setsockopt(TCP_NODELAY)");
while (write(ctrl_conn, control_port_secret, SECRET_SIZE) == -1) {
if (errno == EINTR)
continue;
PLOG_FATAL(cb, "write");
}
/* if authentication passes, server should write back a magic number */
magic = recv_magic(ctrl_conn, cb, __func__);
if (magic != opts->magic)
LOG_FATAL(cb, "magic mismatch: %d != %d", magic, opts->magic);
return ctrl_conn;
}
static void on_getaddr(h2o_hostinfo_getaddr_req_t *getaddr_req, const char *errstr, struct addrinfo *res, void *_req)
{
h2o_socketpool_connect_request_t *req = _req;
assert(getaddr_req == req->getaddr_req);
req->getaddr_req = NULL;
if (errstr != NULL) {
__sync_sub_and_fetch(&req->pool->targets.entries[req->selected_target]->_shared.leased_count, 1);
if (req->remaining_try_count > 0) {
try_connect(req);
return;
}
__sync_sub_and_fetch(&req->pool->_shared.count, 1);
call_connect_cb(req, errstr);
return;
}
struct addrinfo *selected = h2o_hostinfo_select_one(res);
start_connect(req, selected->ai_addr, selected->ai_addrlen);
}
/* try to connect to bg process, and start one if necessary */
static int check_parent(const char *cmd, const char *arg2)
{
int pipefd, lockfd, tries = 0;
for (tries = 0; tries < MAX_TRIES; tries++) {
pipefd = try_connect();
if (pipefd != -1)
return pipefd;
/* timer daemon isn't running */
/* it's not running, so there's nothing to cancel */
if (!strcmp(cmd, "CANCEL") && (arg2 == NULL))
return PARENT_UNNECESSARY;
/* arg2 non-NULL means there is a cancel action available */
/* we need to start the daemon, so try to get the lock */
lockfd = get_lock(lockfn);
if (lockfd != -1) {
start_daemon(lockfd);
return PARENT_STARTED; /* started successfully */
}
/* we didn't get the lock - must be two upsscheds running */
/* blow this away in case we crashed before */
unlink(lockfn);
/* give the other one a chance to start it, then try again */
usleep(250000);
}
upslog_with_errno(LOG_ERR, "Failed to connect to parent and failed to create parent");
exit(EXIT_FAILURE);
}
static void start_connect(h2o_socketpool_connect_request_t *req, struct sockaddr *addr, socklen_t addrlen)
{
struct on_close_data_t *close_data;
req->sock = h2o_socket_connect(req->loop, addr, addrlen, on_connect);
if (req->sock == NULL) {
__sync_sub_and_fetch(&req->pool->targets.entries[req->selected_target]->_shared.leased_count, 1);
if (req->remaining_try_count > 0) {
try_connect(req);
return;
}
__sync_sub_and_fetch(&req->pool->_shared.count, 1);
call_connect_cb(req, "failed to connect to host");
return;
}
close_data = h2o_mem_alloc(sizeof(*close_data));
close_data->pool = req->pool;
close_data->target = req->selected_target;
req->sock->data = req;
req->sock->on_close.cb = on_close;
req->sock->on_close.data = close_data;
}
bool
init_secure_channel( uint32_t ip, uint16_t port, connected_handler connected_callback, disconnected_handler disconnected_callback ) {
assert( !secure_channel_initialized );
connection.ip = ip;
connection.port = port;
connection.fd = -1;
connection.connected_callback = connected_callback;
connection.disconnected_callback = disconnected_callback;
bool ret = try_connect();
if ( ret == false ) {
clear_connection();
return false;
}
send_queue = create_message_queue();
recv_queue = create_message_queue();
secure_channel_initialized = true;
return true;
}
static int connect_or_die()
{
str_t *path;
int sock;
path = get_socket_path();
if (!file_exists(path->data))
run_server_and_wait(path->data);
sock = create_client_socket();
if (sock == -1) {
fprintf(stderr, "Error! Failed to create a client socket: %s\n", path->data);
exit(1);
}
if (-1 == try_connect(sock, (char*)path->data)) {
fprintf(stderr, "Error! Failed to connect to a server at: %s\n", path->data);
exit(1);
}
str_free(path);
return sock;
}
void client::connect(const std::string& hostname, int port)
{
if (_running)
{
return;
}
if (!_encryption->last_error().empty())
{
error(-1, _encryption->last_error());
return;
}
_running = true;
tcp::resolver resolver(_service);
tcp::resolver::query resolver_query(hostname, std::to_string(port));
_endpoint = resolver.resolve(resolver_query);
try_connect();
}
/**
* Try reconnecting to the dht service.
*
* @param cls GNUNET_DHT_Handle
* @param tc scheduler context
*/
static void
try_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_DHT_Handle *handle = cls;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting with DHT %p\n", handle);
handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
if (handle->retry_time.rel_value < GNUNET_CONSTANTS_SERVICE_RETRY.rel_value)
handle->retry_time = GNUNET_CONSTANTS_SERVICE_RETRY;
else
handle->retry_time = GNUNET_TIME_relative_multiply (handle->retry_time, 2);
if (handle->retry_time.rel_value > GNUNET_CONSTANTS_SERVICE_TIMEOUT.rel_value)
handle->retry_time = GNUNET_CONSTANTS_SERVICE_TIMEOUT;
handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
if (GNUNET_YES != try_connect (handle))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "dht reconnect failed(!)\n");
return;
}
GNUNET_CONTAINER_multihashmap_iterate (handle->active_requests,
&add_request_to_pending, handle);
process_pending_messages (handle);
}
int main(int argc, char const* argv[])
{
if (argc<3) perr("Usage: client.exe [address] [port]");
struct addrinfo *plist =
get_addrinfo_list(argv[1],argv[2],SOCK_STREAM);
int fd = try_connect(plist);
if (fd==-1) perr("Cannot connect to host");
freeaddrinfo(plist);
fprintf(stderr,"Enter \"quit\" to terminate process\n");
struct client_mgr_t args1={fd,300.0}, args2={fd,-1.0};
pthread_t tid1,tid2;
pthread_create(&tid1,NULL,client_recvmgr,&args1);
pthread_create(&tid2,NULL,client_sendmgr,&args2);
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
close(fd);
fprintf(stderr,"Disconnected\n");
return 0;
}
static pmix_status_t connect_to_peer(struct pmix_peer_t *peer,
pmix_info_t *info, size_t ninfo)
{
char *evar, **uri, *suri;
char *filename, *nspace=NULL;
pmix_rank_t rank = PMIX_RANK_WILDCARD;
char *p, *p2;
int sd, rc;
size_t n;
char myhost[PMIX_MAXHOSTNAMELEN];
bool system_level = false;
bool system_level_only = false;
pid_t pid = 0;
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"ptl:tcp: connecting to server");
/* see if the connection info is in the info array - if
* so, then that overrides all other options */
/* if I am a client, then we need to look for the appropriate
* connection info in the environment */
if (PMIX_PROC_IS_CLIENT(pmix_globals.mypeer)) {
if (NULL != (evar = getenv("PMIX_SERVER_URI21"))) {
/* we are talking to a v2.1 server */
pmix_client_globals.myserver->proc_type = PMIX_PROC_SERVER | PMIX_PROC_V21;
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"V21 SERVER DETECTED");
/* must use the v21 bfrops module */
pmix_globals.mypeer->nptr->compat.bfrops = pmix_bfrops_base_assign_module("v21");
if (NULL == pmix_globals.mypeer->nptr->compat.bfrops) {
return PMIX_ERR_INIT;
}
} else if (NULL != (evar = getenv("PMIX_SERVER_URI2"))) {
/* we are talking to a v2.0 server */
pmix_client_globals.myserver->proc_type = PMIX_PROC_SERVER | PMIX_PROC_V20;
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"V20 SERVER DETECTED");
/* must use the v20 bfrops module */
pmix_globals.mypeer->nptr->compat.bfrops = pmix_bfrops_base_assign_module("v20");
if (NULL == pmix_globals.mypeer->nptr->compat.bfrops) {
return PMIX_ERR_INIT;
}
} else {
/* not us */
return PMIX_ERR_NOT_SUPPORTED;
}
/* the server will be using the same bfrops as us */
pmix_client_globals.myserver->nptr->compat.bfrops = pmix_globals.mypeer->nptr->compat.bfrops;
/* mark that we are using the V2 protocol */
pmix_globals.mypeer->protocol = PMIX_PROTOCOL_V2;
/* the URI consists of the following elements:
* - server nspace.rank
* - ptl rendezvous URI
*/
uri = pmix_argv_split(evar, ';');
if (2 != pmix_argv_count(uri)) {
PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
pmix_argv_free(uri);
return PMIX_ERR_NOT_SUPPORTED;
}
/* set the server nspace */
p = uri[0];
if (NULL == (p2 = strchr(p, '.'))) {
PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
pmix_argv_free(uri);
return PMIX_ERR_NOT_SUPPORTED;
}
*p2 = '\0';
++p2;
nspace = strdup(p);
rank = strtoull(p2, NULL, 10);
/* save the URI, but do not overwrite what we may have received from
* the info-key directives */
if (NULL == mca_ptl_tcp_component.super.uri) {
mca_ptl_tcp_component.super.uri = strdup(uri[1]);
}
pmix_argv_free(uri);
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"ptl:tcp:client attempt connect to %s",
mca_ptl_tcp_component.super.uri);
/* go ahead and try to connect */
if (PMIX_SUCCESS != (rc = try_connect(&sd))) {
free(nspace);
return rc;
}
goto complete;
}
/* get here if we are a tool - check any provided directives
* to see where they want us to connect to */
if (NULL != info) {
for (n=0; n < ninfo; n++) {
if (0 == strcmp(info[n].key, PMIX_CONNECT_TO_SYSTEM)) {
system_level_only = PMIX_INFO_TRUE(&info[n]);
} else if (0 == strcmp(info[n].key, PMIX_CONNECT_SYSTEM_FIRST)) {
/* try the system-level */
system_level = PMIX_INFO_TRUE(&info[n]);
} else if (0 == strcmp(info[n].key, PMIX_SERVER_PIDINFO)) {
pid = info[n].value.data.pid;
} else if (0 == strcmp(info[n].key, PMIX_SERVER_URI)) {
if (NULL == mca_ptl_tcp_component.super.uri) {
free(mca_ptl_tcp_component.super.uri);
}
mca_ptl_tcp_component.super.uri = strdup(info[n].value.data.string);
} else if (0 == strcmp(info[n].key, PMIX_CONNECT_RETRY_DELAY)) {
mca_ptl_tcp_component.wait_to_connect = info[n].value.data.uint32;
} else if (0 == strcmp(info[n].key, PMIX_CONNECT_MAX_RETRIES)) {
mca_ptl_tcp_component.max_retries = info[n].value.data.uint32;
}
}
}
/* mark that we are using the V2 protocol */
pmix_globals.mypeer->protocol = PMIX_PROTOCOL_V2;
gethostname(myhost, sizeof(myhost));
/* if we were given a URI via MCA param, then look no further */
if (NULL != mca_ptl_tcp_component.super.uri) {
/* if the string starts with "file:", then they are pointing
* us to a file we need to read to get the URI itself */
if (0 == strncmp(mca_ptl_tcp_component.super.uri, "file:", 5)) {
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"ptl:tcp:tool getting connection info from %s",
mca_ptl_tcp_component.super.uri);
nspace = NULL;
rc = parse_uri_file(&mca_ptl_tcp_component.super.uri[5], &suri, &nspace, &rank);
if (PMIX_SUCCESS != rc) {
return PMIX_ERR_UNREACH;
}
free(mca_ptl_tcp_component.super.uri);
mca_ptl_tcp_component.super.uri = suri;
} else {
/* we need to extract the nspace/rank of the server from the string */
p = strchr(mca_ptl_tcp_component.super.uri, ';');
if (NULL == p) {
return PMIX_ERR_BAD_PARAM;
}
*p = '\0';
p++;
suri = strdup(p); // save the uri portion
/* the '.' in the first part of the original string separates
* nspace from rank */
p = strchr(mca_ptl_tcp_component.super.uri, '.');
if (NULL == p) {
free(suri);
return PMIX_ERR_BAD_PARAM;
}
*p = '\0';
p++;
nspace = strdup(mca_ptl_tcp_component.super.uri);
rank = strtoull(p, NULL, 10);
/* now update the URI */
free(mca_ptl_tcp_component.super.uri);
mca_ptl_tcp_component.super.uri = suri;
}
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"ptl:tcp:tool attempt connect using given URI %s",
mca_ptl_tcp_component.super.uri);
/* go ahead and try to connect */
if (PMIX_SUCCESS != (rc = try_connect(&sd))) {
if (NULL != nspace) {
free(nspace);
}
return rc;
}
goto complete;
}
/* if they gave us a pid, then look for it */
if (0 != pid) {
if (0 > asprintf(&filename, "pmix.%s.tool.%d", myhost, pid)) {
return PMIX_ERR_NOMEM;
}
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"ptl:tcp:tool searching for given session server %s",
filename);
nspace = NULL;
rc = df_search(mca_ptl_tcp_component.system_tmpdir,
filename, &sd, &nspace, &rank);
free(filename);
if (PMIX_SUCCESS == rc) {
goto complete;
}
if (NULL != nspace) {
free(nspace);
}
/* since they gave us a specific pid and we couldn't
* connect to it, return an error */
return PMIX_ERR_UNREACH;
}
/* if they asked for system-level, we start there */
if (system_level || system_level_only) {
if (0 > asprintf(&filename, "%s/pmix.sys.%s", mca_ptl_tcp_component.system_tmpdir, myhost)) {
return PMIX_ERR_NOMEM;
}
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"ptl:tcp:tool looking for system server at %s",
filename);
/* try to read the file */
rc = parse_uri_file(filename, &suri, &nspace, &rank);
free(filename);
if (PMIX_SUCCESS == rc) {
mca_ptl_tcp_component.super.uri = suri;
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"ptl:tcp:tool attempt connect to system server at %s",
mca_ptl_tcp_component.super.uri);
/* go ahead and try to connect */
if (PMIX_SUCCESS == try_connect(&sd)) {
goto complete;
}
free(nspace);
}
}
/* we get here if they either didn't ask for a system-level connection,
* or they asked for it and it didn't succeed. If they _only_ wanted
* a system-level connection, then we are done */
if (system_level_only) {
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"ptl:tcp: connecting to system failed");
return PMIX_ERR_UNREACH;
}
/* they didn't give us a pid, so we will search to see what session-level
* tools are available to this user. We will take the first connection
* that succeeds - this is based on the likelihood that there is only
* one session per user on a node */
if (0 > asprintf(&filename, "pmix.%s.tool", myhost)) {
return PMIX_ERR_NOMEM;
}
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"ptl:tcp:tool searching for session server %s",
filename);
nspace = NULL;
rc = df_search(mca_ptl_tcp_component.system_tmpdir,
filename, &sd, &nspace, &rank);
free(filename);
if (PMIX_SUCCESS != rc) {
if (NULL != nspace){
free(nspace);
}
return PMIX_ERR_UNREACH;
}
complete:
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"sock_peer_try_connect: Connection across to server succeeded");
/* do a final bozo check */
if (NULL == nspace || PMIX_RANK_WILDCARD == rank) {
if (NULL != nspace) {
free(nspace);
}
CLOSE_THE_SOCKET(sd);
return PMIX_ERR_UNREACH;
}
/* mark the connection as made */
pmix_globals.connected = true;
pmix_client_globals.myserver->sd = sd;
/* setup the server info */
if (NULL == pmix_client_globals.myserver->info) {
pmix_client_globals.myserver->info = PMIX_NEW(pmix_rank_info_t);
}
if (NULL == pmix_client_globals.myserver->nptr) {
pmix_client_globals.myserver->nptr = PMIX_NEW(pmix_nspace_t);
}
if (NULL == pmix_client_globals.myserver->nptr->nspace) {
pmix_client_globals.myserver->nptr->nspace = nspace;
} else {
free(nspace);
}
if (NULL == pmix_client_globals.myserver->info->pname.nspace) {
pmix_client_globals.myserver->info->pname.nspace = strdup(pmix_client_globals.myserver->nptr->nspace);
}
pmix_client_globals.myserver->info->pname.rank = rank;
pmix_ptl_base_set_nonblocking(sd);
/* setup recv event */
pmix_event_assign(&pmix_client_globals.myserver->recv_event,
pmix_globals.evbase,
pmix_client_globals.myserver->sd,
EV_READ | EV_PERSIST,
pmix_ptl_base_recv_handler, pmix_client_globals.myserver);
pmix_client_globals.myserver->recv_ev_active = true;
PMIX_POST_OBJECT(pmix_client_globals.myserver);
pmix_event_add(&pmix_client_globals.myserver->recv_event, 0);
/* setup send event */
pmix_event_assign(&pmix_client_globals.myserver->send_event,
pmix_globals.evbase,
pmix_client_globals.myserver->sd,
EV_WRITE|EV_PERSIST,
pmix_ptl_base_send_handler, pmix_client_globals.myserver);
pmix_client_globals.myserver->send_ev_active = false;
return PMIX_SUCCESS;
}
/* static C callback wrapper */
gboolean MiracBroker::try_connect (gpointer data_ptr)
{
auto broker = static_cast<MiracBroker*> (data_ptr);
broker->try_connect();
return false;
}
/* called with call locked in W or R with ps->in_lock held */
int dtls(struct packet_stream *ps, const str *s, struct sockaddr_in6 *fsin) {
struct dtls_connection *d;
int ret;
unsigned char buf[0x10000], ctrl[256];
struct msghdr mh;
struct iovec iov;
struct sockaddr_in6 sin;
if (!ps || !ps->sfd)
return 0;
if (!MEDIA_ISSET(ps->media, DTLS))
return 0;
d = &ps->sfd->dtls;
if (s)
__DBG("dtls packet input: len %u %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
s->len,
(unsigned char) s->s[0], (unsigned char) s->s[1], (unsigned char) s->s[2], (unsigned char) s->s[3],
(unsigned char) s->s[4], (unsigned char) s->s[5], (unsigned char) s->s[6], (unsigned char) s->s[7],
(unsigned char) s->s[8], (unsigned char) s->s[9], (unsigned char) s->s[10], (unsigned char) s->s[11],
(unsigned char) s->s[12], (unsigned char) s->s[13], (unsigned char) s->s[14], (unsigned char) s->s[15]);
if (d->connected)
return 0;
if (!d->init || !d->ssl)
return -1;
if (s) {
BIO_write(d->r_bio, s->s, s->len);
/* we understand this as preference of DTLS over SDES */
MEDIA_CLEAR(ps->media, SDES);
}
ret = try_connect(d);
if (ret == -1) {
ilog(LOG_ERROR, "DTLS error on local port %hu", ps->sfd->fd.localport);
/* fatal error */
dtls_connection_cleanup(d);
return 0;
}
else if (ret == 1) {
/* connected! */
if (dtls_setup_crypto(ps, d))
/* XXX ?? */ ;
if (PS_ISSET(ps, RTP) && PS_ISSET(ps, RTCP) && ps->rtcp_sibling
&& MEDIA_ISSET(ps->media, RTCP_MUX))
{
if (dtls_setup_crypto(ps->rtcp_sibling, d))
/* XXX ?? */ ;
}
}
ret = BIO_ctrl_pending(d->w_bio);
if (ret <= 0)
return 0;
if (ret > sizeof(buf)) {
ilog(LOG_ERROR, "BIO buffer overflow");
(void) BIO_reset(d->w_bio);
return 0;
}
ret = BIO_read(d->w_bio, buf, ret);
if (ret <= 0)
return 0;
__DBG("dtls packet output: len %u %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
ret,
buf[0], buf[1], buf[2], buf[3],
buf[4], buf[5], buf[6], buf[7],
buf[8], buf[9], buf[10], buf[11],
buf[12], buf[13], buf[14], buf[15]);
if (!fsin) {
ZERO(sin);
sin.sin6_family = AF_INET6;
sin.sin6_addr = ps->endpoint.ip46;
sin.sin6_port = htons(ps->endpoint.port);
fsin = &sin;
}
ZERO(mh);
mh.msg_control = ctrl;
mh.msg_controllen = sizeof(ctrl);
mh.msg_name = fsin;
mh.msg_namelen = sizeof(*fsin);
mh.msg_iov = &iov;
mh.msg_iovlen = 1;
ZERO(iov);
iov.iov_base = buf;
iov.iov_len = ret;
stream_msg_mh_src(ps, &mh);
sendmsg(ps->sfd->fd.fd, &mh, 0);
return 0;
}
static void
probe_device(snmp_cache_t *device) /* I - Device */
{
char uri[1024], /* Full device URI */
*uriptr, /* Pointer into URI */
*format; /* Format string for device */
device_uri_t *device_uri; /* Current DeviceURI match */
debug_printf("DEBUG: %.3f Probing %s...\n", run_time(), device->addrname);
#ifdef __APPLE__
/*
* If the printer supports Bonjour/mDNS, don't report it from the SNMP backend.
*/
if (!try_connect(&(device->address), device->addrname, 5353))
{
debug_printf("DEBUG: %s supports mDNS, not reporting!\n", device->addrname);
return;
}
#endif /* __APPLE__ */
/*
* Lookup the device in the match table...
*/
for (device_uri = (device_uri_t *)cupsArrayFirst(DeviceURIs);
device_uri;
device_uri = (device_uri_t *)cupsArrayNext(DeviceURIs))
if (device->make_and_model &&
!regexec(&(device_uri->re), device->make_and_model, 0, NULL, 0))
{
/*
* Found a match, add the URIs...
*/
for (format = (char *)cupsArrayFirst(device_uri->uris);
format;
format = (char *)cupsArrayNext(device_uri->uris))
{
for (uriptr = uri; *format && uriptr < (uri + sizeof(uri) - 1);)
if (*format == '%' && format[1] == 's')
{
/*
* Insert hostname/address...
*/
strlcpy(uriptr, device->addrname, sizeof(uri) - (size_t)(uriptr - uri));
uriptr += strlen(uriptr);
format += 2;
}
else
*uriptr++ = *format++;
*uriptr = '\0';
update_cache(device, uri, NULL, NULL);
}
return;
}
/*
* Then try the standard ports...
*/
if (!try_connect(&(device->address), device->addrname, 9100))
{
debug_printf("DEBUG: %s supports AppSocket!\n", device->addrname);
snprintf(uri, sizeof(uri), "socket://%s", device->addrname);
update_cache(device, uri, NULL, NULL);
}
else if (!try_connect(&(device->address), device->addrname, 515))
{
debug_printf("DEBUG: %s supports LPD!\n", device->addrname);
snprintf(uri, sizeof(uri), "lpd://%s/", device->addrname);
update_cache(device, uri, NULL, NULL);
}
}
void connection_queue::on_try_connect()
{
mutex_t::scoped_lock l(m_mutex);
try_connect(l);
}
void connection_queue::on_timeout(error_code const& e)
{
#if defined TORRENT_ASIO_DEBUGGING
complete_async("connection_queue::on_timeout");
#endif
mutex_t::scoped_lock l(m_mutex);
--m_num_timers;
INVARIANT_CHECK;
#ifdef TORRENT_DEBUG
function_guard guard_(m_in_timeout_function);
#endif
TORRENT_ASSERT(!e || e == error::operation_aborted);
// if there was an error, it's most likely operation aborted,
// we should just quit. However, in case there are still connections
// in connecting state, and there are no other timer invocations
// we need to stick around still.
if (e && (m_num_connecting == 0 || m_num_timers > 0)) return;
ptime next_expire = max_time();
ptime now = time_now_hires() + milliseconds(100);
std::list<entry> timed_out;
for (std::list<entry>::iterator i = m_queue.begin();
!m_queue.empty() && i != m_queue.end();)
{
if (i->connecting && i->expires < now)
{
std::list<entry>::iterator j = i;
++i;
timed_out.splice(timed_out.end(), m_queue, j, i);
--m_num_connecting;
continue;
}
if (i->connecting && i->expires < next_expire)
next_expire = i->expires;
++i;
}
// we don't want to call the timeout callback while we're locked
// since that is a recepie for dead-locks
l.unlock();
for (std::list<entry>::iterator i = timed_out.begin()
, end(timed_out.end()); i != end; ++i)
{
TORRENT_ASSERT(i->connecting);
TORRENT_ASSERT(i->ticket != -1);
TORRENT_TRY {
i->on_timeout();
} TORRENT_CATCH(std::exception&) {}
}
l.lock();
if (next_expire < max_time())
{
#if defined TORRENT_ASIO_DEBUGGING
add_outstanding_async("connection_queue::on_timeout");
#endif
error_code ec;
m_timer.expires_at(next_expire, ec);
m_timer.async_wait(boost::bind(&connection_queue::on_timeout, this, _1));
++m_num_timers;
}
try_connect(l);
}
canl_err_code
canl_io_connect(canl_ctx cc, canl_io_handler io, const char *host,
const char *service, int port, gss_OID_set auth_mechs,
int flags, canl_principal *peer, struct timeval *timeout)
{
int err = 0;
io_handler *io_cc = (io_handler*) io;
glb_ctx *glb_cc = (glb_ctx*) cc;
struct _asyn_result ar;
int i = 0, k;
int addr_types[] = {AF_INET, AF_INET6}; //TODO ip versions policy?
int ipver = AF_INET6;
int j = 0, done;
struct canl_mech *mech;
gss_OID oid;
memset(&ar, 0, sizeof(ar));
if (!glb_cc) {
return EINVAL;
}
if (!io_cc)
return set_error(glb_cc, EINVAL, POSIX_ERROR,
"IO handler not initialized");
done = 0;
for (k = 0; k < sizeof(addr_types)/sizeof(*addr_types); k++) {
ipver = addr_types[k];
if (ar.ent) {
free_hostent(ar.ent);
memset(&ar, 0, sizeof(ar));
}
ar.ent = (struct hostent *) calloc (1, sizeof(struct hostent));
if (ar.ent == NULL)
return set_error(cc, ENOMEM, POSIX_ERROR, "Not enough memory");
switch (err = canl_asyn_getservbyname(ipver, &ar, host, NULL)) {
case NETDB_SUCCESS:
err = 0;
break;
case TRY_AGAIN:
err = update_error(glb_cc, ETIMEDOUT, POSIX_ERROR,
" Timeout reached when connecting to (%s)", host);
goto end;
case NETDB_INTERNAL:
err = update_error(glb_cc, errno, POSIX_ERROR,
"Cannot resolve the server hostname (%s)", host);
continue;
default:
err = update_error(glb_cc, err, NETDB_ERROR,
"Cannot resolve the server hostname (%s)", host);
continue;
}
j = 0;
do {
if (auth_mechs == GSS_C_NO_OID_SET || auth_mechs->count == 0)
oid = GSS_C_NO_OID;
else
oid = &auth_mechs->elements[j];
mech = find_mech(oid);
err = 0;
for (i = 0; ar.ent->h_addr_list[i]; i++) {
void *ctx = NULL;
if (err == ETIMEDOUT)
goto end;
err = try_connect(glb_cc, io_cc, ar.ent->h_addr_list[i],
ar.ent->h_addrtype, port, timeout);//TODO timeout
if (err)
continue;
err = mech->client_init(glb_cc, &ctx);
if (err) {
canl_io_close(glb_cc, io_cc);
continue;
}
err = mech->connect(glb_cc, io_cc, ctx, timeout, host);
if (err) {
canl_io_close(glb_cc, io_cc);
mech->finish(glb_cc, ctx);
ctx = NULL;
continue;
}
io_cc->conn_ctx = ctx;
done = 1;
/* If peer != NULL then client certificate is mandatory*/
if (peer) {
err = mech->get_peer(glb_cc, io_cc, ctx, peer);
if (err)
goto end;
}
break;
}
if (err == ETIMEDOUT)
goto end;
j++;
} while (auth_mechs != GSS_C_NO_OID_SET && j < auth_mechs->count && !done);
free_hostent(ar.ent);
ar.ent = NULL;
if (done)
break;
}
if (!done) {
err = ECONNREFUSED;
goto end;
}
err = 0;
end:
if (err) /* XXX: rather invent own error */
err = update_error(glb_cc, ECONNREFUSED, POSIX_ERROR,
"Failed to make network connection to server %s", host);
if (ar.ent != NULL)
free_hostent(ar.ent);
return err;
}
static pmix_status_t df_search(char *dirname, char *prefix,
int *sd, char **nspace,
pmix_rank_t *rank)
{
char *suri, *nsp, *newdir;
pmix_rank_t rk;
pmix_status_t rc;
struct stat buf;
DIR *cur_dirp;
struct dirent *dir_entry;
if (NULL == (cur_dirp = opendir(dirname))) {
return PMIX_ERR_NOT_FOUND;
}
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"pmix:tcp: searching directory %s", dirname);
/* search the entries for something that starts with the provided prefix */
while (NULL != (dir_entry = readdir(cur_dirp))) {
/* ignore the . and .. entries */
if (0 == strcmp(dir_entry->d_name, ".") ||
0 == strcmp(dir_entry->d_name, "..")) {
continue;
}
newdir = pmix_os_path(false, dirname, dir_entry->d_name, NULL);
if (-1 == stat(newdir, &buf)) {
free(newdir);
continue;
}
/* if it is a directory, down search */
if (S_ISDIR(buf.st_mode)) {
rc = df_search(newdir, prefix, sd, nspace, rank);
free(newdir);
if (PMIX_SUCCESS == rc) {
closedir(cur_dirp);
return rc;
}
continue;
}
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"pmix:tcp: checking %s vs %s", dir_entry->d_name, prefix);
/* see if it starts with our prefix */
if (0 == strncmp(dir_entry->d_name, prefix, strlen(prefix))) {
/* try to read this file */
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"pmix:tcp: reading file %s", newdir);
rc = parse_uri_file(newdir, &suri, &nsp, &rk);
if (PMIX_SUCCESS == rc) {
if (NULL != mca_ptl_tcp_component.super.uri) {
free(mca_ptl_tcp_component.super.uri);
}
mca_ptl_tcp_component.super.uri = suri;
/* go ahead and try to connect */
pmix_output_verbose(2, pmix_ptl_base_framework.framework_output,
"pmix:tcp: attempting to connect to %s", suri);
if (PMIX_SUCCESS == try_connect(sd)) {
(*nspace) = nsp;
*rank = rk;
closedir(cur_dirp);
free(newdir);
return PMIX_SUCCESS;
}
free(nsp);
}
}
free(newdir);
}
closedir(cur_dirp);
return PMIX_ERR_NOT_FOUND;
}
