END_TEST
START_TEST(test_add_connection)
{
fail_unless(add_connection(-1, ToServerDIS, 0, 0, PBS_SOCK_INET, accept_conn, 0) == PBSE_BAD_PARAMETER);
fail_unless(add_connection(PBS_NET_MAX_CONNECTIONS, ToServerDIS, 0, 0, PBS_SOCK_INET, accept_conn, 0) == PBSE_BAD_PARAMETER);
}
static ConnCacheEntry *
internal_get (int32_t cell,
uint32_t host,
uint16_t port,
uint16_t service,
int (*probe)(struct rx_connection *),
CredCacheEntry *ce)
{
ConnCacheEntry *e;
ConnCacheEntry key;
#if 0
if (connected_mode == DISCONNECTED)
return NULL;
#endif
key.host = host;
key.port = port;
key.service = service;
key.cred = ce->cred;
key.securityindex = ce->securityindex;
e = (ConnCacheEntry *)hashtabsearch (connhtab, (void *)&key);
if (e == NULL) {
ConnCacheEntry *parent = NULL;
if (ce->securityindex || ce->cred) {
key.cred = 0;
key.securityindex = 0;
parent = (ConnCacheEntry *)hashtabsearch (connhtab, (void *)&key);
if (parent == NULL) {
parent = add_connection (cell, host, port, service,
probe, NULL);
}
++parent->refcount;
}
e = add_connection (cell, host, port, service, probe, ce);
if (parent != NULL)
e->parent = parent;
}
/*
* Since we only probe the parent entry (ie noauth), we make sure
* the status from the parent entry is pushed down to the
* children.
*/
if(e->parent != NULL) {
e->flags.alivep = e->parent->flags.alivep;
}
return e;
}
/*
* Resolve the entry in servers with index ind, adding connections to the list
* *conns. Connections are added for each of socktype1 and (if not zero)
* socktype2. message and udpbufp are used to initialize the connections; see
* add_connection above. If no addresses are available for an entry but no
* internal name resolution failure occurs, return 0 without adding any new
* connections.
*/
static krb5_error_code
resolve_server(krb5_context context, const struct serverlist *servers,
size_t ind, int socktype1, int socktype2,
const krb5_data *message, char **udpbufp,
struct conn_state **conns)
{
krb5_error_code retval;
struct server_entry *entry = &servers->servers[ind];
struct addrinfo *addrs, *a, hint, ai;
int err, result;
char portbuf[64];
/* Skip any stray entries of socktypes we don't want. */
if (entry->socktype != 0 && entry->socktype != socktype1 &&
entry->socktype != socktype2)
return 0;
if (entry->hostname == NULL) {
ai.ai_socktype = entry->socktype;
ai.ai_family = entry->family;
ai.ai_addrlen = entry->addrlen;
ai.ai_addr = (struct sockaddr *)&entry->addr;
return add_connection(conns, &ai, ind, message, udpbufp);
}
memset(&hint, 0, sizeof(hint));
hint.ai_family = entry->family;
hint.ai_socktype = (entry->socktype != 0) ? entry->socktype : socktype1;
#ifdef AI_NUMERICSERV
hint.ai_flags = AI_NUMERICSERV;
#endif
result = snprintf(portbuf, sizeof(portbuf), "%d", ntohs(entry->port));
if (SNPRINTF_OVERFLOW(result, sizeof(portbuf)))
return EINVAL;
TRACE_SENDTO_KDC_RESOLVING(context, entry->hostname);
err = getaddrinfo(entry->hostname, portbuf, &hint, &addrs);
if (err)
return translate_ai_error(err);
/* Add each address with the preferred socktype. */
retval = 0;
for (a = addrs; a != 0 && retval == 0; a = a->ai_next)
retval = add_connection(conns, a, ind, message, udpbufp);
if (retval == 0 && entry->socktype == 0 && socktype2 != 0) {
/* Add each address again with the non-preferred socktype. */
for (a = addrs; a != 0 && retval == 0; a = a->ai_next) {
a->ai_socktype = socktype2;
retval = add_connection(conns, a, ind, message, udpbufp);
}
}
freeaddrinfo(addrs);
return retval;
}
int
main (int argc, char *argv[])
{
NMClient *client;
GMainLoop *loop;
GError *error = NULL;
#if !GLIB_CHECK_VERSION (2, 35, 0)
/* Initialize GType system */
g_type_init ();
#endif
loop = g_main_loop_new (NULL, FALSE);
/* Connect to NetworkManager */
client = nm_client_new (NULL, &error);
if (!client) {
g_message ("Error: Could not connect to NetworkManager: %s.", error->message);
g_error_free (error);
return 1;
}
/* Ask NM to add the new connection */
add_connection (client, loop, "__Test connection__");
/* Wait for the connection to be added */
g_main_loop_run (loop);
/* Clean up */
g_object_unref (client);
return 0;
}
int
main (int argc, char *argv[])
{
NMRemoteSettings *settings;
GMainLoop *loop;
GError *error = NULL;
#if !GLIB_CHECK_VERSION (2, 35, 0)
/* Initialize GType system */
g_type_init ();
#endif
loop = g_main_loop_new (NULL, FALSE);
/* Create our proxy for NetworkManager's settings service */
settings = nm_remote_settings_new (NULL, &error);
if (!settings) {
g_message ("Error: Could not get system settings: %s.", error->message);
g_error_free (error);
return 1;
}
/* Ask the settings service to add the new connection */
if (add_connection (settings, loop, "__Test connection__")) {
/* Wait for the connection to be added */
g_main_loop_run (loop);
} else
g_print ("Error adding connection to NetworkManager\n");
/* Clean up */
g_object_unref (settings);
return 0;
}
void accept_cb(EV_P_ struct ev_io *w, int revent)
{
client_t *client = (client_t *) w->data;
drizzle_con_st *dc = (drizzle_con_st *) malloc(sizeof(drizzle_con_st));
drizzle_return_t ret;
int fd;
connection_t *con;
dbgin();
/* Manually set connection to ready */
drizzle_con_add_options(client->dc, DRIZZLE_CON_IO_READY);
drizzle_con_accept(client->drizzle, dc, &ret);
if (ret != DRIZZLE_RETURN_OK)
{
if (ret == DRIZZLE_RETURN_IO_WAIT) {
printf("io_wait\n");
return;
}
printf("drizzle_con_accpet error:%s\n", drizzle_error(client->drizzle));
return;
}
fd = drizzle_con_fd(dc);
printf("Accepted. fd:%d\n", fd);
con = (connection_t *) calloc(1, sizeof(connection_t));
con->fd = fd;
con->client = client;
con->dc = dc;
add_connection(client, con);
}
err_t http_cache_lookup (const char *name, struct http_conn *cs)
{
struct http_cache_entry *e;
assert(cs != NULL);
e = find_cacheline(name);
if (e->valid == 1) {
/* fresh matching cache-entry found */
DEBUGPRINT ("%d: Fresh cache-entry, returning page [%s]\n",
cs->request_no, name);
trigger_callback (cs, e);
return ERR_OK;
} /* end if: valid cacheline */
/* data not in cache */
/* add this connection to the list of waiting on cacheline */
add_connection (e, cs);
/* Check if no-one is loading the data */
if (e->loading == 0 ) {
e->loading = 1;
DEBUGPRINT ("%d: starting the page loading\n", cs->request_no);
async_load_cache_entry(e);
} /* end if: no-one else is loading the data */
else {
DEBUGPRINT ("%d: someone else is loading the page, so just waiting\n",
cs->request_no);
}
return ERR_OK;
} /* end function: http_cache_lookup */
/*
* An outgoing connection has become ready to write to. Start polling for
* incoming packets.
*/
static void
outgoing_connection(int fd, short revents, void *arg)
{
struct node *node = arg;
assert(fd == node->connecting_fd);
node->connecting_fd = -1;
if (revents & POLLERR) {
int socket_error;
socklen_t len;
remove_poll_callback(&cbs, fd);
len = sizeof(socket_error);
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &socket_error, &len) == -1)
fail(NULL);
close(fd);
if (socket_error != ECONNREFUSED) {
errno = socket_error;
fail(NULL);
}
} else {
update_poll_callback(&cbs, fd, POLLIN, proto_read, node);
add_connection(fd, node);
}
}
int main (int argc, char *argv[])
{
DBusGConnection *bus;
NMRemoteSettings *settings;
GMainLoop *loop;
/* Initialize GType system */
g_type_init ();
loop = g_main_loop_new (NULL, FALSE);
/* Get system bus */
bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL);
/* Create our proxy for NetworkManager's settings service */
settings = nm_remote_settings_new (bus);
/* Ask the settings service to add the new connection */
if (add_connection (settings, loop, "__Test connection__")) {
/* Wait for the connection to be added */
g_main_loop_run (loop);
} else
g_print ("Error adding connection to NetworkManager\n");
/* Clean up */
g_object_unref (settings);
dbus_g_connection_unref (bus);
return 0;
}
static inline void obs_encoder_start_internal(obs_encoder_t *encoder,
void (*new_packet)(void *param, struct encoder_packet *packet),
void *param)
{
struct encoder_callback cb = {false, new_packet, param};
bool first = false;
if (!encoder->context.data)
return;
pthread_mutex_lock(&encoder->callbacks_mutex);
first = (encoder->callbacks.num == 0);
size_t idx = get_callback_idx(encoder, new_packet, param);
if (idx == DARRAY_INVALID)
da_push_back(encoder->callbacks, &cb);
pthread_mutex_unlock(&encoder->callbacks_mutex);
if (first) {
encoder->cur_pts = 0;
add_connection(encoder);
}
}
int on_channel(int epoll_fd, int fd)
{
channel ch;
if(recv_fd(fd, &ch) == L_HTTP_FAIL) {
printf("receive fd fail\n");
return L_HTTP_FAIL;
}
switch(ch.cmd) {
case HTTP_COMMAND_TRANS_FD:
return add_connection(epoll_fd, ch.fd);
case HTTP_COMMAND_RESTART:
break;
case HTTP_COMMAND_EXIT:
syslog(LOG_INFO, "proc:%d receive shutdown cmd", getpid());
worker_shutdown(epoll_fd);
break;
default:
printf("unknown cmd type\n");
return L_HTTP_FAIL;
}
return L_HTTP_SUCCESS;
}
static gboolean connection_added(DBusConnection *conn, DBusMessage *message,
void *user_data)
{
DBusMessageIter iter, properties;
const char *path;
const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING
DBUS_TYPE_ARRAY_AS_STRING
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
if (dbus_message_has_signature(message, signature) == FALSE) {
connman_error("vpn ConnectionAdded signature \"%s\" does not "
"match expected \"%s\"",
dbus_message_get_signature(message), signature);
return TRUE;
}
DBG("");
if (dbus_message_iter_init(message, &iter) == FALSE)
return TRUE;
dbus_message_iter_get_basic(&iter, &path);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &properties);
add_connection(path, &properties, user_data);
return TRUE;
}
int
main (int argc, char *argv[])
{
GDBusProxy *proxy;
GError *error = NULL;
#if !GLIB_CHECK_VERSION (2, 35, 0)
/* Initialize GType system */
g_type_init ();
#endif
/* Create a D-Bus proxy; NM_DBUS_* defined in nm-dbus-interface.h */
proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
NM_DBUS_SERVICE,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
NULL, &error);
if (!proxy) {
g_dbus_error_strip_remote_error (error);
g_print ("Could not create NetworkManager D-Bus proxy: %s\n", error->message);
g_error_free (error);
return 1;
}
/* Add a connection */
add_connection (proxy, "__Test connection__");
g_object_unref (proxy);
return 0;
}
int main(int argc, char** argv) {
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
perror("socket()");
exit(-1);
}
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
if (bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1) {
perror("bind()");
exit(-1);
}
if (listen(sockfd, PENDING) == -1) {
perror("listen()");
exit(-1);
}
memset(connections, 0, sizeof(struct client *) * MAXCONN);
for(;;) {
int newfd = accept(sockfd, NULL, NULL);
add_connection(newfd);
}
}
unsigned agent_impl::connect(const char* ipaddr, unsigned short port,
int32_t timeout_millis, unsigned short local_port)
{
connection_ptr new_conn(new connection(*this, get_io_service(), net_callback_));
add_connection(new_conn);
new_conn->async_connect(ipaddr, port, timeout_millis, local_port);
return new_conn->get_id();
}
connection_ptr Engine::open_connection(std::string host, int port)
{
std::string port_str = boost::lexical_cast<std::string>(port);
int fd = SocketUtils::socket_connection_new(host.c_str(), port_str.c_str(), 0);
if (fd < 0) return connection_ptr();
SocketUtils::make_socket_non_blocking(fd);
connection_ptr conn = add_connection(fd);
return conn;
}
/*****************************************************************
***************************I/O***********************************
*****************************************************************/
void read_graph() {
int line;
int orig_id, dest_id;
scanf("%d %d", &V, &E);
graph = create_graph(V);
for (line = 0; line < E; line++) {
scanf("%d %d", &orig_id, &dest_id);
add_connection(graph, orig_id, dest_id);
add_connection(graph, dest_id, orig_id);
graph->vertexs[orig_id]->edges->anti_parallel =
graph->vertexs[dest_id]->edges;
graph->vertexs[dest_id]->edges->anti_parallel =
graph->vertexs[orig_id]->edges;
}
}
main(int argc, char *argv[])
{
int len;
err_t err = NULL;
char *infile;
char *conn_name;
int lineno=0;
struct starter_config *cfg = NULL;
struct starter_conn *conn = NULL;
//EF_PROTECT_FREE=1;
progname = argv[0];
leak_detective = 1;
if(argc < 4) {
fprintf(stderr, "Usage: %s <cfgrootdir> <cfgfile> <conn-name>.. \n", progname);
exit(10);
}
/* argv[1] == "-r" */
tool_init_log();
//init_fake_vendorid();
rootdir[0]='\0';
strlcat(rootdir, argv[1], sizeof(rootdir));
starter_use_log(1, 1, 1);
cfg = confread_load(argv[2], &err, FALSE, NULL,FALSE);
argv+=3;
argc-=3;
/* load all conns marked as auto=add or better */
for(conn = cfg->conns.tqh_first;
conn != NULL;
conn = conn->link.tqe_next)
{
for(; argc>0; argc--, argv++) {
conn_name = *argv;
printf("processing conn: %s\n", conn_name);
if(strcasecmp(conn->name, conn_name)==0) {
struct whack_message msg1;
if(starter_whack_build_basic_conn(cfg, &msg1, conn)==0) {
add_connection(&msg1);
}
}
}
}
confread_free(cfg);
report_leaks();
tool_close_log();
exit(0);
}
bool Slot::connect(Slot *slot) {
if (slot == NULL) return false;
// outlet --> inlet
if (add_connection(slot)) {
// two way connection
slot->add_connection(this);
return true;
}
return false;
}
ConnectionResult DronecodeSDKImpl::add_serial_connection(const std::string &dev_path, int baudrate)
{
auto new_conn = std::make_shared<SerialConnection>(
std::bind(&DronecodeSDKImpl::receive_message, this, std::placeholders::_1),
dev_path,
baudrate);
ConnectionResult ret = new_conn->start();
if (ret == ConnectionResult::SUCCESS) {
add_connection(new_conn);
}
return ret;
}
ConnectionResult DronecodeSDKImpl::add_tcp_connection(const std::string &remote_ip, int remote_port)
{
auto new_conn = std::make_shared<TcpConnection>(
std::bind(&DronecodeSDKImpl::receive_message, this, std::placeholders::_1),
remote_ip,
remote_port);
ConnectionResult ret = new_conn->start();
if (ret == ConnectionResult::SUCCESS) {
add_connection(new_conn);
}
return ret;
}
static void
accept_ssld(rb_fde_t *F, struct sockaddr *addr, struct sockaddr *laddr, struct Listener *listener)
{
ssl_ctl_t *ctl;
rb_fde_t *xF[2];
if(rb_socketpair(AF_UNIX, SOCK_STREAM, 0, &xF[0], &xF[1], "Incoming ssld Connection") == -1) {
ilog_error("creating SSL/TLS socket pairs");
rb_close(F);
return;
}
ctl = start_ssld_accept(F, xF[1], rb_get_fd(xF[0])); /* this will close F for us */
add_connection(listener, xF[0], addr, laddr, ctl);
}
void
Local::Heap::common_add (PresentityPtr presentity)
{
gmref_ptr<Ekiga::PresenceCore> presence_core = core.get ("presence-core");
// Add the presentity to this Heap
add_presentity (presentity);
// Fetch presence
presence_core->fetch_presence (presentity->get_uri ());
// Connect the Local::Presentity signals.
add_connection (presentity, presentity->trigger_saving.connect (sigc::mem_fun (this, &Local::Heap::save)));
}
int read_problem(t_graph graph) {
int n_crit_nodes, crit_node_id;
scanf("%d", &n_crit_nodes);
if (n_crit_nodes < 2) {
return 0;
}
while (n_crit_nodes > 0) {
scanf("%d", &crit_node_id);
graph->vertexs[crit_node_id]->is_critical = TRUE;
add_connection(graph, crit_node_id, V);
add_connection(graph, V, crit_node_id);
graph->vertexs[crit_node_id]->edges->anti_parallel =
graph->vertexs[V]->edges;
graph->vertexs[V]->edges->anti_parallel =
graph->vertexs[crit_node_id]->edges;
n_crit_nodes--;
}
return -1;
}
void
Local::Heap::common_add (PresentityPtr presentity)
{
boost::shared_ptr<Ekiga::PresenceCore> pcore = presence_core.lock ();
// Add the presentity to this Heap
add_presentity (presentity);
// Fetch presence
if (pcore)
pcore->fetch_presence (presentity->get_uri ());
// Connect the Local::Presentity signals.
add_connection (presentity, presentity->trigger_saving.connect (boost::bind (&Local::Heap::save, this)));
}
bool test_connections(){
web_context * ctx = alloc0(sizeof(web_context));
for(int i = 0; i < 100; i++){
char namebuf[100];
sprintf(namebuf, "__test%i", i);
add_connection(ctx, namebuf, "aa", "bb");
}
ASSERT(get_connection_by_name(ctx, "__test1"));
remove_connection(ctx, "__test1");
//ASSERT(get_connection_by_name(ctx, "__test1") == NULL);
//ASSERT(get_connection_by_name(ctx, "__test14")->connection == (udpc_connection *) 14);
dealloc(ctx->active_connections);
dealloc(ctx);
return true;
}
/*-----------------------------------------------------------------*
* open each of the appropriate /dev/input/event* files for input */
void open_input(void)
{
char *filename = NULL;
glob_t globbuf;
unsigned i;
int fd;
struct connection c;
int had_some_success = 0;
char evname[256];
/* get all the matching event filenames */
glob(INPUT_LAYER_FS, 0, NULL, &globbuf);
/* for each event file */
for (i = 0; i < globbuf.gl_pathc; ++i)
{
filename = globbuf.gl_pathv[i];
fd = open(filename, O_RDONLY | O_NONBLOCK);
if (fd >= 0) {
/* get this event file's name */
strcpy(evname, "Unknown");
ioctl(fd, EVIOCGNAME(sizeof(evname)), evname);
printf("%s (%s) opened successfully\n", filename, evname);
had_some_success = 1;
/* add a connection to the list */
c.fd = fd;
c.process = process_input;
add_connection(&c);
}
else
{
if (had_some_success == 1)
continue;
int errno2 = errno;
printf("open for %s failed: %s (%d)\n",
filename, strerror(errno2), errno2);
if (errno2 == EACCES)
printf(" (try running as root)\n");
if (errno2 == ENOENT)
printf(" (input layer driver may not be present)\n");
}
}
globfree(&globbuf);
}
static void
accept_callback(rb_fde_t *F, int status, struct sockaddr *addr, rb_socklen_t addrlen, void *data)
{
struct Listener *listener = data;
struct rb_sockaddr_storage lip;
unsigned int locallen = sizeof(struct rb_sockaddr_storage);
ServerStats.is_ac++;
if(getsockname(rb_get_fd(F), (struct sockaddr *) &lip, &locallen) < 0)
{
/* this can fail if the connection disappeared in the meantime */
rb_close(F);
return;
}
add_connection(listener, F, addr, (struct sockaddr *)&lip);
}
/*
* We have a new incoming connection. Accept the connection and start polling
* for incoming packets.
*/
static void
incoming_connection(int fd, short revents, void *arg)
{
struct sockaddr sa;
socklen_t sa_len;
int client_fd;
struct node *node;
for(;;) {
sa_len = sizeof(sa);
client_fd = accept4(fd, &sa, &sa_len, SOCK_NONBLOCK);
if (client_fd == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK)
return;
fail(NULL);
}
node = sockaddr_to_node(&sa, sa_len);
if (!node) {
char hbuf[NI_MAXHOST];
int g;
g = getnameinfo(&sa, sa_len, hbuf, sizeof(hbuf), NULL, 0,
NI_NUMERICHOST);
if (g) {
fprintf(stderr, "%s\n", gai_strerror(g));
exit(1);
}
fprintf(stderr, "Could not determine node-id for node at %s\n",
hbuf);
close(client_fd);
} else {
if (node->connecting_fd != -1) {
close(node->connecting_fd);
remove_poll_callback(&cbs, node->connecting_fd);
node->connecting_fd = -1;
}
add_poll_callback(&cbs, client_fd, POLLIN, proto_read, node);
add_connection(client_fd, node);
}
}
}
void load_available_con(web_context * ctx){
dirscan dir = scan_directories("shareinfo");
for(size_t i = 0; i < dir.cnt; i++){
char * f = dir.files[i];
logd("File: %s\n", f);
char fname[100];
sprintf(fname, "shareinfo/%s", f);
void * buffer = read_file_to_string(fname);
void * bufptr = buffer;
char * dir = udpc_unpack_string(&bufptr);
char * name = udpc_unpack_string(&bufptr);
char * service = udpc_unpack_string(&bufptr);
if(NULL != get_connection_by_name(ctx, name)){
dealloc(buffer);
continue;
}
logd(" %s %s %s \n", dir, name, service);
add_connection(ctx, name, service, dir);
dealloc(buffer);
}
}