static void
test_disconnect_equal()
{
boost::signals2::signal<void ()> s0;
connections[0] = s0.connect(remove_connection(0));
connections[1] = s0.connect(remove_connection(1));
connections[2] = s0.connect(remove_connection(2));
connections[3] = s0.connect(remove_connection(3));
std::cout << "Deleting 2" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "0123");
#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
connections[2].disconnect();
#else
s0.disconnect(remove_connection(2));
#endif
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "013");
}
static void
ifcfg_dir_changed (GFileMonitor *monitor,
GFile *file,
GFile *other_file,
GFileMonitorEvent event_type,
gpointer user_data)
{
SettingsPluginIfcfg *plugin = SETTINGS_PLUGIN_IFCFG (user_data);
char *path, *ifcfg_path;
NMIfcfgConnection *connection;
path = g_file_get_path (file);
ifcfg_path = utils_detect_ifcfg_path (path, FALSE);
_LOGD ("ifcfg_dir_changed(%s) = %d // %s", path, event_type, ifcfg_path ? ifcfg_path : "(none)");
if (ifcfg_path) {
connection = find_by_path (plugin, ifcfg_path);
switch (event_type) {
case G_FILE_MONITOR_EVENT_DELETED:
if (connection)
remove_connection (plugin, connection);
break;
case G_FILE_MONITOR_EVENT_CREATED:
case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
/* Update or new */
update_connection (plugin, NULL, ifcfg_path, connection, TRUE, NULL, NULL);
break;
default:
break;
}
g_free (ifcfg_path);
}
g_free (path);
}
void obs_encoder_stop(obs_encoder_t *encoder,
void (*new_packet)(void *param, struct encoder_packet *packet),
void *param)
{
bool last = false;
size_t idx;
if (!encoder) return;
pthread_mutex_lock(&encoder->callbacks_mutex);
idx = get_callback_idx(encoder, new_packet, param);
if (idx != DARRAY_INVALID) {
da_erase(encoder->callbacks, idx);
last = (encoder->callbacks.num == 0);
}
pthread_mutex_unlock(&encoder->callbacks_mutex);
if (last) {
remove_connection(encoder);
if (encoder->destroy_on_stop)
obs_encoder_actually_destroy(encoder);
}
}
static inline bool obs_encoder_stop_internal(obs_encoder_t *encoder,
void (*new_packet)(void *param, struct encoder_packet *packet),
void *param)
{
bool last = false;
size_t idx;
pthread_mutex_lock(&encoder->callbacks_mutex);
idx = get_callback_idx(encoder, new_packet, param);
if (idx != DARRAY_INVALID) {
da_erase(encoder->callbacks, idx);
last = (encoder->callbacks.num == 0);
}
pthread_mutex_unlock(&encoder->callbacks_mutex);
if (last) {
remove_connection(encoder);
encoder->initialized = false;
if (encoder->destroy_on_stop) {
pthread_mutex_unlock(&encoder->init_mutex);
obs_encoder_actually_destroy(encoder);
return true;
}
}
return false;
}
static void full_stop(struct obs_encoder *encoder)
{
if (encoder) {
pthread_mutex_lock(&encoder->callbacks_mutex);
da_free(encoder->callbacks);
remove_connection(encoder);
pthread_mutex_unlock(&encoder->callbacks_mutex);
}
}
void server_manager::stop()
{
if(free_) {
SDLNet_TCP_Close(server_socket);
remove_connection(connection_);
server_socket = 0;
free_ = false;
}
}
static void
test_bloodbath()
{
boost::signals2::signal<void ()> s0;
connections[0] = s0.connect(remove_connection(0, 1));
connections[1] = s0.connect(remove_connection(1, 1));
connections[2] = s0.connect(remove_connection(2, 0));
connections[3] = s0.connect(remove_connection(3, 2));
std::cout << "0 removes 1, 2 removes 0, 3 removes 2" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "023");
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "3");
}
bool disconnect(connection s)
{
if(s == 0) {
while(sockets.empty() == false) {
assert(sockets.back() != 0);
while(disconnect(sockets.back()) == false) {
SDL_Delay(1);
}
}
return true;
}
if (!is_server()) last_ping = 0;
const connection_map::iterator info = connections.find(s);
if(info != connections.end()) {
if (info->second.sock == server_socket)
{
return true;
}
if (!network_worker_pool::close_socket(info->second.sock)) {
return false;
}
}
bad_sockets.erase(s);
std::deque<network::connection>::iterator dqi = std::find(disconnection_queue.begin(),disconnection_queue.end(),s);
if(dqi != disconnection_queue.end()) {
disconnection_queue.erase(dqi);
}
const sockets_list::iterator i = std::find(sockets.begin(),sockets.end(),s);
if(i != sockets.end()) {
sockets.erase(i);
const TCPsocket sock = get_socket(s);
waiting_sockets.erase(s);
SDLNet_TCP_DelSocket(socket_set,sock);
SDLNet_TCP_Close(sock);
remove_connection(s);
} else {
if(sockets.size() == 1) {
DBG_NW << "valid socket: " << static_cast<int>(*sockets.begin()) << "\n";
}
}
return true;
}
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;
}
/// Destroy an endpoint
~endpoint() {
m_alog->at(log::alevel::DEVEL) << "Endpoint destructor called" << log::endl;
// Tell the memory pool we don't want to be notified about newly freed
// messages any more (because we wont be here)
m_pool->set_callback(NULL);
// Detach any connections that are still alive at this point
boost::lock_guard<boost::recursive_mutex> lock(m_lock);
typename std::set<connection_ptr>::iterator it;
while (!m_connections.empty()) {
remove_connection(*m_connections.begin());
}
m_alog->at(log::alevel::DEVEL) << "Endpoint destructor done" << log::endl;
}
static void
ifcfg_dir_changed (GFileMonitor *monitor,
GFile *file,
GFile *other_file,
GFileMonitorEvent event_type,
gpointer user_data)
{
SCPluginIfcfg *plugin = SC_PLUGIN_IFCFG (user_data);
char *path, *base, *ifcfg_path;
NMIfcfgConnection *connection;
path = g_file_get_path (file);
if (utils_should_ignore_file (path, FALSE)) {
g_free (path);
return;
}
_LOGD ("ifcfg_dir_changed(%s) = %d", path, event_type);
base = g_file_get_basename (file);
if (utils_is_ifcfg_alias_file (base, NULL)) {
/* Alias file changed. Get the base ifcfg file from it */
ifcfg_path = utils_get_ifcfg_from_alias (path);
} else {
/* Given any ifcfg, keys, or routes file, get the ifcfg file path */
ifcfg_path = utils_get_ifcfg_path (path);
}
if (ifcfg_path) {
connection = find_by_path (plugin, ifcfg_path);
switch (event_type) {
case G_FILE_MONITOR_EVENT_DELETED:
if (connection)
remove_connection (plugin, connection);
break;
case G_FILE_MONITOR_EVENT_CREATED:
case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
/* Update or new */
update_connection (plugin, NULL, ifcfg_path, connection, TRUE, NULL, NULL);
break;
default:
break;
}
g_free (ifcfg_path);
}
g_free (path);
g_free (base);
}
static gboolean connection_removed(DBusConnection *conn, DBusMessage *message,
void *user_data)
{
const char *path;
const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
if (dbus_message_has_signature(message, signature) == FALSE) {
connman_error("vpn removed signature \"%s\" does not match "
"expected \"%s\"",
dbus_message_get_signature(message), signature);
return TRUE;
}
dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
remove_connection(conn, path);
return TRUE;
}
static void
test_remove_after()
{
boost::signals2::signal<void ()> s0;
connections[0] = s0.connect(remove_connection(0, 1));
connections[1] = s0.connect(remove_connection(1));
connections[2] = s0.connect(remove_connection(2));
connections[3] = s0.connect(remove_connection(3));
std::cout << "0 removes 1" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "023");
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "023");
s0.disconnect_all_slots();
BOOST_CHECK(s0.empty());
connections[0] = s0.connect(remove_connection(0));
connections[1] = s0.connect(remove_connection(1, 3));
connections[2] = s0.connect(remove_connection(2));
connections[3] = s0.connect(remove_connection(3));
std::cout << "1 removes 3" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "012");
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "012");
}
static void
test_remove_prior()
{
boost::signals2::signal<void ()> s0;
connections[0] = s0.connect(remove_connection(0));
connections[1] = s0.connect(remove_connection(1, 0));
connections[2] = s0.connect(remove_connection(2));
connections[3] = s0.connect(remove_connection(3));
std::cout << "1 removes 0" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "0123");
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "123");
s0.disconnect_all_slots();
BOOST_CHECK(s0.empty());
connections[0] = s0.connect(remove_connection(0));
connections[1] = s0.connect(remove_connection(1));
connections[2] = s0.connect(remove_connection(2));
connections[3] = s0.connect(remove_connection(3, 2));
std::cout << "3 removes 2" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "0123");
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "013");
}
static void
dir_changed (GFileMonitor *monitor,
GFile *file,
GFile *other_file,
GFileMonitorEvent event_type,
gpointer user_data)
{
NMSystemConfigInterface *config = NM_SYSTEM_CONFIG_INTERFACE (user_data);
SCPluginKeyfile *self = SC_PLUGIN_KEYFILE (config);
NMKeyfileConnection *connection;
char *full_path;
gboolean exists;
full_path = g_file_get_path (file);
if (nm_keyfile_plugin_utils_should_ignore_file (full_path)) {
g_free (full_path);
return;
}
exists = g_file_test (full_path, G_FILE_TEST_EXISTS);
nm_log_dbg (LOGD_SETTINGS, "dir_changed(%s) = %d; file %s", full_path, event_type, exists ? "exists" : "does not exist");
connection = find_by_path (self, full_path);
switch (event_type) {
case G_FILE_MONITOR_EVENT_DELETED:
if (!exists && connection)
remove_connection (SC_PLUGIN_KEYFILE (config), connection);
break;
case G_FILE_MONITOR_EVENT_CREATED:
case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
if (exists)
update_connection (SC_PLUGIN_KEYFILE (config), NULL, full_path, connection, TRUE, NULL, NULL);
break;
default:
break;
}
g_free (full_path);
}
void* client_handler(void* arg) {
struct sockaddr_storage clientaddr;
socklen_t clientaddrsize = sizeof clientaddr;
// Accept client connections. Please look at accept() on how to use it.
if(client_id >0 ) {
/* Create another thread to wait for a future connection */
} else {
perror("accept()");
exit(1);
}
printf("New client on socket descriptor %d\n", client_id);
char host[256],port[256];
// Using getnameinfo() get the host and port details about the client.
printf("%s:%s has connected\n", host,port);
add_connection(client_id);
FILE* netin = fdopen(client_id,"r");
while(1) {
// Read the message from client and send it to all listeners.
}
// Send closing message to the client and close the connection.
remove_connection(client_id);
return NULL;
}
void Slot::disconnect(Slot *slot) {
remove_connection(slot);
slot->remove_connection(this);
}
void IPACM_LanToLan::handle_del_lan2lan_connection(ipacm_event_connection* data)
{
IPACMDBG_H("Del lan2lan connection info: IP type: %d, src_v4_addr: 0x%08x, dst_v4_addr: 0x%08x\n", data->iptype, data->src_ipv4_addr, data->dst_ipv4_addr);
IPACMDBG_H("src_v6_addr: 0x%08x%08x%08x%08x, dst_v6_addr: 0x%08x%08x%08x%08x", data->src_ipv6_addr[0], data->src_ipv6_addr[1], data->src_ipv6_addr[2],
data->src_ipv6_addr[3], data->dst_ipv6_addr[0], data->dst_ipv6_addr[1], data->dst_ipv6_addr[2], data->dst_ipv6_addr[3]);
bool res;
uint64_t src_ipv6_addr, dst_ipv6_addr;
client_info* src_client_ptr;
client_info* dst_client_ptr;
if(data->iptype == IPA_IP_v4)
{
if(client_info_v4_.count(data->src_ipv4_addr) == 0
|| client_info_v4_.count(data->dst_ipv4_addr) == 0) //if not found the client
{
IPACMDBG_H("Not found either source or dest client, return.\n");
return;
}
client_info& src_client = client_info_v4_[data->src_ipv4_addr];
client_info& dst_client = client_info_v4_[data->dst_ipv4_addr];
src_client_ptr = &src_client;
dst_client_ptr = &dst_client;
}
else
{
memcpy(&src_ipv6_addr, &(data->src_ipv6_addr[2]), sizeof(uint64_t));
memcpy(&dst_ipv6_addr, &(data->dst_ipv6_addr[2]), sizeof(uint64_t));
if(client_info_v6_.count(src_ipv6_addr) == 0
|| client_info_v6_.count(dst_ipv6_addr) == 0)//if not found the client
{
IPACMDBG_H("Not found either source or dest client, return.\n");
return;
}
client_info& src_client = client_info_v6_[src_ipv6_addr];
client_info& dst_client = client_info_v6_[dst_ipv6_addr];
src_client_ptr = &src_client;
dst_client_ptr = &dst_client;
}
res = remove_connection(src_client_ptr, dst_client_ptr);
if(res && src_client_ptr->is_active && dst_client_ptr->is_active)
{
IPACMDBG_H("Erase link info for both src and dst entries.\n");
erase_offload_link(data->iptype, src_client_ptr, dst_client_ptr);
}
else
{
if(res && src_client_ptr->is_powersave && (dst_client_ptr->is_active || dst_client_ptr->is_powersave))
{
IPACMDBG_H("Erase link info for both src and dst entries due to src powersave.\n");
erase_offload_link(data->iptype, src_client_ptr, dst_client_ptr);
}
if(res && dst_client_ptr->is_powersave && (src_client_ptr->is_active || src_client_ptr->is_powersave))
{
IPACMDBG_H("Erase link info for both src and dst entries due to dst powersave.\n");
erase_offload_link(data->iptype, dst_client_ptr, src_client_ptr);
}
}
//if the src client is not active and not powersave mode, if peer list is empty, remove client entry
if(res && src_client_ptr->is_active == false && src_client_ptr->is_powersave == false && src_client_ptr->peer.size() == 0)
{
IPACMDBG_H("Peer list of src is empty, remove src entry.\n");
if(data->iptype == IPA_IP_v4)
{
client_info_v4_.erase(data->src_ipv4_addr);
}
else
{
client_info_v6_.erase(src_ipv6_addr);
}
}
//if the dst client is not active and not powersave mode, if peer list is empty, remove client entry
if(res && dst_client_ptr->is_active == false && dst_client_ptr->is_powersave == false && dst_client_ptr->peer.size() == 0)
{
IPACMDBG_H("Peer list of dst is empty, remove dst entry.\n");
if(data->iptype == IPA_IP_v4)
{
client_info_v4_.erase(data->dst_ipv4_addr);
}
else
{
client_info_v6_.erase(dst_ipv6_addr);
}
}
return;
}
void ConnectionIOServer::InternalThreadEntry() {
fd_set master_rfds, working_rfds;
fd_set master_wfds, working_wfds;
FD_ZERO(&master_rfds);
FD_ZERO(&master_wfds);
FD_SET(pipefd_[0], &master_rfds);
// Keep track of closed connections
std::vector<int> remove_list;
while (1) {
working_rfds = master_rfds;
working_wfds = master_wfds;
// Determine the maximum file descriptor.
int max_fd = connection_map_.empty() ? pipefd_[0] :
std::max(pipefd_[0], (connection_map_.rbegin())->first);
// Block until there is activity
int activity = select(max_fd + 1, &working_rfds, &working_wfds,
NULL, NULL);
// Check to see if there was an error with select.
if (activity < 0 && errno != EINTR) {
return; // TODO: Improve cleanup on error.
}
// See if there are new items to sockets to add
if (FD_ISSET(pipefd_[0], &working_rfds)) {
if (add_connection(&master_rfds) == -1) {
return; // TODO: Should clean up connections
}
}
// See if any of the connections is ready for read/write
for (std::map<int, Connection*>::iterator it = connection_map_.begin();
it != connection_map_.end(); it++) {
if (FD_ISSET(it->first, &working_wfds)) {
int w_result = it->second->flush_writes();
if (w_result == -1) {
remove_list.push_back(it->first);
continue; // Done with this socket
} else if (w_result == 0) {
// Completely finished flushing the writes for this
// socket. Remove it from the fd_set
FD_CLR(it->first, &master_wfds);
}
}
if (FD_ISSET(it->first, &working_rfds)) {
int r_result = it->second->handle_request();
if (r_result == -1) {
remove_list.push_back(it->first);
continue; // Done with this socket
}
// Check if this socket needs to be added to the wfds.
if (it->second->pending_writes_exist()) {
FD_SET(it->first, &master_wfds);
}
}
}
// Check if there are any connections that need to be removed.
if (!remove_list.empty()) {
for (unsigned i = 0; i < remove_list.size(); ++i) {
remove_connection(remove_list[i], &master_rfds, &master_wfds);
}
remove_list.clear();
}
}
}
void
check_socket(int num)
/* check for new connection, command, connection closed */
{
int fd = -1, avoid_fd = -1, addr_len = sizeof(struct sockaddr_un);
struct sockaddr_un client_addr;
long int buf_int[SOCKET_MSG_LEN];
int read_len = 0;
struct fcrondyn_cl *client = NULL, *prev_client = NULL;
if ( num <= 0 )
/* no socket to check : go directly to the end of that function */
goto final_settings;
debug("Checking socket ...");
if ( FD_ISSET(listen_fd, &read_set) ) {
debug("got new connection ...");
if ((fd = accept(listen_fd, (struct sockaddr *)&client_addr, &addr_len)) == -1) {
error_e("could not accept new connection : isset(listen_fd = %d) = %d",
listen_fd, FD_ISSET(listen_fd, &read_set));
}
else {
fcntl(fd, F_SETFD, 1);
/* set fd to O_NONBLOCK : we do not want fcron to be stopped on error, etc */
if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK) == -1) {
error_e("Could not set fd attribute O_NONBLOCK : connection rejected.");
shutdown(fd, SHUT_RDWR);
close(fd);
}
else {
Alloc(client, fcrondyn_cl);
client->fcl_sock_fd = fd;
/* means : not authenticated yet : */
client->fcl_user = NULL;
client->fcl_cmd = NULL;
/* include new entry in client list */
client->fcl_next = fcrondyn_cl_base;
fcrondyn_cl_base = client;
client->fcl_idle_since = now;
/* to avoid trying to read from it in this call */
avoid_fd = fd;
FD_SET(fd, &master_set);
if ( fd > set_max_fd )
set_max_fd = fd;
fcrondyn_cl_num += 1;
debug("Added connection fd : %d - %d connections", fd, fcrondyn_cl_num);
}
}
}
client = fcrondyn_cl_base;
while ( client != NULL ) {
if (! FD_ISSET(client->fcl_sock_fd, &read_set) || client->fcl_sock_fd==avoid_fd){
/* check if the connection has not been idle for too long ... */
if (client->fcl_user==NULL && now - client->fcl_idle_since > MAX_AUTH_TIME ){
warn("Connection with no auth for more than %ds : closing it.",
MAX_AUTH_TIME);
remove_connection(&client, prev_client);
}
else if ( now - client->fcl_idle_since > MAX_IDLE_TIME ) {
warn("Connection of %s is idle for more than %ds : closing it.",
client->fcl_user, MAX_IDLE_TIME);
remove_connection(&client, prev_client);
}
else {
/* nothing to do on this one ... check the next one */
prev_client = client;
client = client->fcl_next;
}
continue;
}
if ( (read_len = recv(client->fcl_sock_fd, buf_int, sizeof(buf_int), 0)) <= 0 ) {
if (read_len == 0) {
/* connection closed by client */
remove_connection(&client, prev_client);
}
else {
error_e("error recv() from sock fd %d", client->fcl_sock_fd);
prev_client = client;
client = client->fcl_next;
}
}
else {
client->fcl_cmd_len = read_len;
client->fcl_cmd = buf_int;
if ( client->fcl_user == NULL )
/* not authenticated yet */
auth_client(client);
else {
/* we've just read a command ... */
client->fcl_idle_since = now;
exe_cmd(client);
}
prev_client = client;
client = client->fcl_next;
}
}
final_settings:
/* copy master_set in read_set, because read_set is modified by select() */
read_set = master_set;
}
static void
test_remove_self()
{
boost::signals2::signal<void ()> s0;
connections[0] = s0.connect(remove_connection(0));
connections[1] = s0.connect(remove_connection(1));
connections[2] = s0.connect(remove_connection(2, 2));
connections[3] = s0.connect(remove_connection(3));
std::cout << "Deleting 2" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "0123");
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "013");
s0.disconnect_all_slots();
BOOST_CHECK(s0.empty());
connections[0] = s0.connect(remove_connection(0));
connections[1] = s0.connect(remove_connection(1));
connections[2] = s0.connect(remove_connection(2));
connections[3] = s0.connect(remove_connection(3, 3));
std::cout << "Deleting 3" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "0123");
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "012");
s0.disconnect_all_slots();
BOOST_CHECK(s0.num_slots() == 0);
connections[0] = s0.connect(remove_connection(0, 0));
connections[1] = s0.connect(remove_connection(1));
connections[2] = s0.connect(remove_connection(2));
connections[3] = s0.connect(remove_connection(3));
std::cout << "Deleting 0" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "0123");
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "123");
s0.disconnect_all_slots();
BOOST_CHECK(s0.empty());
connections[0] = s0.connect(remove_connection(0, 0));
connections[1] = s0.connect(remove_connection(1, 1));
connections[2] = s0.connect(remove_connection(2, 2));
connections[3] = s0.connect(remove_connection(3, 3));
std::cout << "Mass suicide" << std::endl;
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "0123");
test_output = "";
s0(); std::cout << std::endl;
BOOST_CHECK(test_output == "");
}
/**
* DTLS over SCTP specific listener function. This function is called by @c listenerThread()
*/
void IpfixReceiverDtlsSctpIpV4::run() {
struct sockaddr_in clientAddress;
socklen_t clientAddressLen = sizeof(struct sockaddr_in);
int ret;
int rfd;
struct timespec timeOut;
/* set a 400ms time-out on the pselect */
timeOut.tv_sec = 0L;
timeOut.tv_nsec = 400000000L;
while(!exitFlag) {
fd_set tmpreadfds = readfds;
fd_set tmpwritefds = writefds;
ret = pselect(maxfd + 1, &tmpreadfds, &tmpwritefds, NULL, &timeOut, NULL);
if (ret == 0) {
/* Timeout */
continue;
}
if ((ret == -1) && (errno == EINTR)) {
DPRINTF("select() returned due to signal");
/* There was a signal... ignore */
continue;
}
if (ret < 0) {
msg(MSG_ERROR ,"select() returned with an error: %s",strerror(errno));
THROWEXCEPTION("IpfixReceiverDtlsSctpIpV4: terminating listener thread");
break;
}
DPRINTF("select() returned %d",ret);
// looking for a new client to connect at listen_socket
if (FD_ISSET(listen_socket, &tmpreadfds)){
rfd = accept(listen_socket, (struct sockaddr*)&clientAddress, &clientAddressLen);
if (rfd >= 0){
if ( ! isHostAuthorized(&clientAddress.sin_addr,
sizeof(clientAddress.sin_addr))) {
/* Do not accept connections from unauthorized hosts. */
close(rfd);
} else {
msg(MSG_DEBUG, "IpfixReceiverDtlsSctpIpV4: Client connected from %s:%d, FD=%d", inet_ntoa(clientAddress.sin_addr), ntohs(clientAddress.sin_port), rfd);
DtlsConnectionPtr conn = DtlsConnectionPtr( new DtlsConnection(*this,&clientAddress,rfd));
connections.insert(make_pair(rfd,conn));
update_maxfd();
}
}else{
msg(MSG_ERROR ,"accept() in ipfixReceiver failed");
/* TODO: Don't throw an exception here. */
THROWEXCEPTION("IpfixReceiverDtlsSctpIpV4: unable to accept new connection");
}
}
// check all connected sockets for new available data
for (rfd = 0; rfd <= maxfd; ++rfd) {
if (rfd == listen_socket) continue;
if (FD_ISSET(rfd, &readfds) || FD_ISSET(rfd, &writefds)) {
if (FD_ISSET(rfd, &readfds)) DPRINTF("descriptor %d is ready for reading",rfd);
if (FD_ISSET(rfd, &writefds)) DPRINTF("descriptor %d is ready for writing",rfd);
connections_map::iterator it = connections.find(rfd);
if (it == connections.end()) {
/* This should not happend. */
msg(MSG_ERROR,"Can't find connection for file descriptor.");
FD_CLR(rfd,&readfds);
FD_CLR(rfd,&writefds);
continue;
}
ret = it->second->fdready();
if (ret == 0) {
DPRINTF("fdready() returned 0. Deleting connection.");
remove_connection(rfd);
update_maxfd();
}
}
}
}
msg(MSG_DEBUG, "IpfixReceiverDtlsSctpIpV4: Exiting");
}
/* update_connection:
* @self: the plugin instance
* @source: if %NULL, this re-reads the connection from @full_path
* and updates it. When passing @source, this adds a connection from
* memory.
* @full_path: the filename of the keyfile to be loaded
* @connection: an existing connection that might be updated.
* If given, @connection must be an existing connection that is currently
* owned by the plugin.
* @protect_existing_connection: if %TRUE, and !@connection, we don't allow updating
* an existing connection with the same UUID.
* If %TRUE and @connection, allow updating only if the reload would modify
* @connection (without changing its UUID) or if we would create a new connection.
* In other words, if this paramter is %TRUE, we only allow creating a
* new connection (with an unseen UUID) or updating the passed in @connection
* (whereas the UUID cannot change).
* Note, that this allows for @connection to be replaced by a new connection.
* @protected_connections: (allow-none): if given, we only update an
* existing connection if it is not contained in this hash.
* @error: error in case of failure
*
* Loads a connection from file @full_path. This can both be used to
* load a connection initially or to update an existing connection.
*
* If you pass in an existing connection and the reloaded file happens
* to have a different UUID, the connection is deleted.
* Beware, that means that after the function, you have a dangling pointer
* if the returned connection is different from @connection.
*
* Returns: the updated connection.
* */
static NMKeyfileConnection *
update_connection (SCPluginKeyfile *self,
NMConnection *source,
const char *full_path,
NMKeyfileConnection *connection,
gboolean protect_existing_connection,
GHashTable *protected_connections,
GError **error)
{
SCPluginKeyfilePrivate *priv = SC_PLUGIN_KEYFILE_GET_PRIVATE (self);
NMKeyfileConnection *connection_new;
NMKeyfileConnection *connection_by_uuid;
GError *local = NULL;
const char *uuid;
g_return_val_if_fail (!source || NM_IS_CONNECTION (source), NULL);
g_return_val_if_fail (full_path || source, NULL);
if (full_path)
nm_log_dbg (LOGD_SETTINGS, "keyfile: loading from file \"%s\"...", full_path);
connection_new = nm_keyfile_connection_new (source, full_path, &local);
if (!connection_new) {
/* Error; remove the connection */
if (source)
nm_log_warn (LOGD_SETTINGS, "keyfile: error creating connection %s: %s", nm_connection_get_uuid (source), local->message);
else
nm_log_warn (LOGD_SETTINGS, "keyfile: error loading connection from file %s: %s", full_path, local->message);
if ( connection
&& !protect_existing_connection
&& (!protected_connections || !g_hash_table_contains (protected_connections, connection)))
remove_connection (self, connection);
g_propagate_error (error, local);
return NULL;
}
uuid = nm_connection_get_uuid (NM_CONNECTION (connection_new));
connection_by_uuid = g_hash_table_lookup (priv->connections, uuid);
if ( connection
&& connection != connection_by_uuid) {
if ( (protect_existing_connection && connection_by_uuid != NULL)
|| (protected_connections && g_hash_table_contains (protected_connections, connection))) {
NMKeyfileConnection *conflicting = (protect_existing_connection && connection_by_uuid != NULL) ? connection_by_uuid : connection;
if (source)
nm_log_warn (LOGD_SETTINGS, "keyfile: cannot update protected "NM_KEYFILE_CONNECTION_LOG_FMT" connection due to conflicting UUID %s", NM_KEYFILE_CONNECTION_LOG_ARG (conflicting), uuid);
else
nm_log_warn (LOGD_SETTINGS, "keyfile: cannot load %s due to conflicting UUID for "NM_KEYFILE_CONNECTION_LOG_FMT, full_path, NM_KEYFILE_CONNECTION_LOG_ARG (conflicting));
g_object_unref (connection_new);
g_set_error_literal (error, NM_SETTINGS_ERROR, NM_SETTINGS_ERROR_FAILED,
"Cannot update protected connection due to conflicting UUID");
return NULL;
}
/* The new connection has a different UUID then the original one.
* Remove @connection. */
remove_connection (self, connection);
}
if ( connection_by_uuid
&& ( (!connection && protect_existing_connection)
|| (protected_connections && g_hash_table_contains (protected_connections, connection_by_uuid)))) {
if (source)
nm_log_warn (LOGD_SETTINGS, "keyfile: cannot update connection due to conflicting UUID for "NM_KEYFILE_CONNECTION_LOG_FMT, NM_KEYFILE_CONNECTION_LOG_ARG (connection_by_uuid));
else
nm_log_warn (LOGD_SETTINGS, "keyfile: cannot load %s due to conflicting UUID for "NM_KEYFILE_CONNECTION_LOG_FMT, full_path, NM_KEYFILE_CONNECTION_LOG_ARG (connection_by_uuid));
g_object_unref (connection_new);
g_set_error_literal (error, NM_SETTINGS_ERROR, NM_SETTINGS_ERROR_FAILED,
"Skip updating protected connection during reload");
return NULL;
}
if (connection_by_uuid) {
const char *old_path;
old_path = nm_settings_connection_get_filename (NM_SETTINGS_CONNECTION (connection_by_uuid));
if (nm_connection_compare (NM_CONNECTION (connection_by_uuid),
NM_CONNECTION (connection_new),
NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS |
NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS)) {
/* Nothing to do... except updating the path. */
if (old_path && g_strcmp0 (old_path, full_path) != 0)
nm_log_info (LOGD_SETTINGS, "keyfile: rename \"%s\" to "NM_KEYFILE_CONNECTION_LOG_FMT" without other changes", old_path, NM_KEYFILE_CONNECTION_LOG_ARG (connection_new));
} else {
/* An existing connection changed. */
if (source)
nm_log_info (LOGD_SETTINGS, "keyfile: update "NM_KEYFILE_CONNECTION_LOG_FMT" from %s", NM_KEYFILE_CONNECTION_LOG_ARG (connection_new), NM_KEYFILE_CONNECTION_LOG_PATH (old_path));
else if (!g_strcmp0 (old_path, nm_settings_connection_get_filename (NM_SETTINGS_CONNECTION (connection_new))))
nm_log_info (LOGD_SETTINGS, "keyfile: update "NM_KEYFILE_CONNECTION_LOG_FMT, NM_KEYFILE_CONNECTION_LOG_ARG (connection_new));
else if (old_path)
nm_log_info (LOGD_SETTINGS, "keyfile: rename \"%s\" to "NM_KEYFILE_CONNECTION_LOG_FMT, old_path, NM_KEYFILE_CONNECTION_LOG_ARG (connection_new));
else
nm_log_info (LOGD_SETTINGS, "keyfile: update and persist "NM_KEYFILE_CONNECTION_LOG_FMT, NM_KEYFILE_CONNECTION_LOG_ARG (connection_new));
if (!nm_settings_connection_replace_settings (NM_SETTINGS_CONNECTION (connection_by_uuid),
NM_CONNECTION (connection_new),
FALSE, /* don't set Unsaved */
"keyfile-update",
&local)) {
/* Shouldn't ever get here as 'connection_new' was verified by the reader already
* and the UUID did not change. */
g_assert_not_reached ();
}
g_assert_no_error (local);
}
nm_settings_connection_set_filename (NM_SETTINGS_CONNECTION (connection_by_uuid), full_path);
g_object_unref (connection_new);
return connection_by_uuid;
} else {
if (source)
nm_log_info (LOGD_SETTINGS, "keyfile: add connection "NM_KEYFILE_CONNECTION_LOG_FMT, NM_KEYFILE_CONNECTION_LOG_ARG (connection_new));
else
nm_log_info (LOGD_SETTINGS, "keyfile: new connection "NM_KEYFILE_CONNECTION_LOG_FMT, NM_KEYFILE_CONNECTION_LOG_ARG (connection_new));
g_hash_table_insert (priv->connections, g_strdup (uuid), connection_new);
g_signal_connect (connection_new, NM_SETTINGS_CONNECTION_REMOVED,
G_CALLBACK (connection_removed_cb),
self);
if (!source) {
/* Only raise the signal if we were called without source, i.e. if we read the connection from file.
* Otherwise, we were called by add_connection() which does not expect the signal. */
g_signal_emit_by_name (self, NM_SYSTEM_CONFIG_INTERFACE_CONNECTION_ADDED, connection_new);
}
return connection_new;
}
}
static NMIfcfgConnection *
update_connection (SCPluginIfcfg *self,
NMConnection *source,
const char *full_path,
NMIfcfgConnection *connection,
gboolean protect_existing_connection,
GHashTable *protected_connections,
GError **error)
{
SCPluginIfcfgPrivate *priv = SC_PLUGIN_IFCFG_GET_PRIVATE (self);
NMIfcfgConnection *connection_new;
NMIfcfgConnection *connection_by_uuid;
GError *local = NULL;
const char *new_unmanaged = NULL, *old_unmanaged = NULL;
const char *new_unrecognized = NULL, *old_unrecognized = NULL;
gboolean unmanaged_changed = FALSE, unrecognized_changed = FALSE;
const char *uuid;
g_return_val_if_fail (!source || NM_IS_CONNECTION (source), NULL);
g_return_val_if_fail (full_path || source, NULL);
if (full_path)
_LOGD ("loading from file \"%s\"...", full_path);
/* Create a NMIfcfgConnection instance, either by reading from @full_path or
* based on @source. */
connection_new = nm_ifcfg_connection_new (source, full_path, error);
if (!connection_new) {
/* Unexpected failure. Probably the file is invalid? */
if ( connection
&& !protect_existing_connection
&& (!protected_connections || !g_hash_table_contains (protected_connections, connection)))
remove_connection (self, connection);
return NULL;
}
uuid = nm_connection_get_uuid (NM_CONNECTION (connection_new));
connection_by_uuid = g_hash_table_lookup (priv->connections, uuid);
if ( connection
&& connection != connection_by_uuid) {
if ( (protect_existing_connection && connection_by_uuid != NULL)
|| (protected_connections && g_hash_table_contains (protected_connections, connection))) {
NMIfcfgConnection *conflicting = (protect_existing_connection && connection_by_uuid != NULL) ? connection_by_uuid : connection;
if (source)
_LOGW ("cannot update protected connection "NM_IFCFG_CONNECTION_LOG_FMT" due to conflicting UUID %s", NM_IFCFG_CONNECTION_LOG_ARG (conflicting), uuid);
else
_LOGW ("cannot load %s due to conflicting UUID for "NM_IFCFG_CONNECTION_LOG_FMT, full_path, NM_IFCFG_CONNECTION_LOG_ARG (conflicting));
g_object_unref (connection_new);
g_set_error_literal (error, NM_SETTINGS_ERROR, NM_SETTINGS_ERROR_FAILED,
"Cannot update protected connection due to conflicting UUID");
return NULL;
}
/* The new connection has a different UUID then the original one that we
* are about to update. Remove @connection. */
remove_connection (self, connection);
}
/* Check if the found connection with the same UUID is not protected from updating. */
if ( connection_by_uuid
&& ( (!connection && protect_existing_connection)
|| (protected_connections && g_hash_table_contains (protected_connections, connection_by_uuid)))) {
if (source)
_LOGW ("cannot update connection due to conflicting UUID for "NM_IFCFG_CONNECTION_LOG_FMT, NM_IFCFG_CONNECTION_LOG_ARG (connection_by_uuid));
else
_LOGW ("cannot load %s due to conflicting UUID for "NM_IFCFG_CONNECTION_LOG_FMT, full_path, NM_IFCFG_CONNECTION_LOG_ARG (connection_by_uuid));
g_object_unref (connection_new);
g_set_error_literal (error, NM_SETTINGS_ERROR, NM_SETTINGS_ERROR_FAILED,
"Skip updating protected connection during reload");
return NULL;
}
/* Evaluate unmanaged/unrecognized flags. */
if (connection_by_uuid)
old_unmanaged = nm_ifcfg_connection_get_unmanaged_spec (connection_by_uuid);
new_unmanaged = nm_ifcfg_connection_get_unmanaged_spec (connection_new);
unmanaged_changed = g_strcmp0 (old_unmanaged, new_unmanaged);
if (connection_by_uuid)
old_unrecognized = nm_ifcfg_connection_get_unrecognized_spec (connection_by_uuid);
new_unrecognized = nm_ifcfg_connection_get_unrecognized_spec (connection_new);
unrecognized_changed = g_strcmp0 (old_unrecognized, new_unrecognized);
if (connection_by_uuid) {
const char *old_path;
old_path = nm_settings_connection_get_filename (NM_SETTINGS_CONNECTION (connection_by_uuid));
if ( !unmanaged_changed
&& !unrecognized_changed
&& nm_connection_compare (NM_CONNECTION (connection_by_uuid),
NM_CONNECTION (connection_new),
NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS |
NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS)) {
if (old_path && g_strcmp0 (old_path, full_path) != 0)
_LOGI ("rename \"%s\" to "NM_IFCFG_CONNECTION_LOG_FMT" without other changes", nm_settings_connection_get_filename (NM_SETTINGS_CONNECTION (connection_by_uuid)), NM_IFCFG_CONNECTION_LOG_ARG (connection_new));
} else {
/*******************************************************
* UPDATE
*******************************************************/
if (source)
_LOGI ("update "NM_IFCFG_CONNECTION_LOG_FMT" from %s", NM_IFCFG_CONNECTION_LOG_ARG (connection_new), NM_IFCFG_CONNECTION_LOG_PATH (old_path));
else if (!g_strcmp0 (old_path, nm_settings_connection_get_filename (NM_SETTINGS_CONNECTION (connection_new))))
_LOGI ("update "NM_IFCFG_CONNECTION_LOG_FMT, NM_IFCFG_CONNECTION_LOG_ARG (connection_new));
else if (old_path)
_LOGI ("rename \"%s\" to "NM_IFCFG_CONNECTION_LOG_FMT, old_path, NM_IFCFG_CONNECTION_LOG_ARG (connection_new));
else
_LOGI ("update and persist "NM_IFCFG_CONNECTION_LOG_FMT, NM_IFCFG_CONNECTION_LOG_ARG (connection_new));
g_object_set (connection_by_uuid,
NM_IFCFG_CONNECTION_UNMANAGED_SPEC, new_unmanaged,
NM_IFCFG_CONNECTION_UNRECOGNIZED_SPEC, new_unrecognized,
NULL);
if (!nm_settings_connection_replace_settings (NM_SETTINGS_CONNECTION (connection_by_uuid),
NM_CONNECTION (connection_new),
FALSE, /* don't set Unsaved */
"ifcfg-update",
&local)) {
/* Shouldn't ever get here as 'connection_new' was verified by the reader already
* and the UUID did not change. */
g_assert_not_reached ();
}
g_assert_no_error (local);
if (new_unmanaged || new_unrecognized) {
if (!old_unmanaged && !old_unrecognized) {
g_object_ref (connection_by_uuid);
/* Unexport the connection by telling the settings service it's
* been removed.
*/
nm_settings_connection_signal_remove (NM_SETTINGS_CONNECTION (connection_by_uuid));
/* Remove the path so that claim_connection() doesn't complain later when
* interface gets managed and connection is re-added. */
nm_connection_set_path (NM_CONNECTION (connection_by_uuid), NULL);
/* signal_remove() will end up removing the connection from our hash,
* so add it back now.
*/
g_hash_table_insert (priv->connections,
g_strdup (nm_connection_get_uuid (NM_CONNECTION (connection_by_uuid))),
connection_by_uuid);
}
} else {
if (old_unmanaged /* && !new_unmanaged */) {
_LOGI ("Managing connection "NM_IFCFG_CONNECTION_LOG_FMT" and its device because NM_CONTROLLED was true.",
NM_IFCFG_CONNECTION_LOG_ARG (connection_new));
g_signal_emit_by_name (self, NM_SYSTEM_CONFIG_INTERFACE_CONNECTION_ADDED, connection_by_uuid);
} else if (old_unrecognized /* && !new_unrecognized */) {
_LOGI ("Managing connection "NM_IFCFG_CONNECTION_LOG_FMT" because it is now a recognized type.",
NM_IFCFG_CONNECTION_LOG_ARG (connection_new));
g_signal_emit_by_name (self, NM_SYSTEM_CONFIG_INTERFACE_CONNECTION_ADDED, connection_by_uuid);
}
}
if (unmanaged_changed)
g_signal_emit_by_name (self, NM_SYSTEM_CONFIG_INTERFACE_UNMANAGED_SPECS_CHANGED);
if (unrecognized_changed)
g_signal_emit_by_name (self, NM_SYSTEM_CONFIG_INTERFACE_UNRECOGNIZED_SPECS_CHANGED);
}
nm_settings_connection_set_filename (NM_SETTINGS_CONNECTION (connection_by_uuid), full_path);
g_object_unref (connection_new);
return connection_by_uuid;
} else {
/*******************************************************
* ADD
*******************************************************/
if (source)
_LOGI ("add connection "NM_IFCFG_CONNECTION_LOG_FMT, NM_IFCFG_CONNECTION_LOG_ARG (connection_new));
else
_LOGI ("new connection "NM_IFCFG_CONNECTION_LOG_FMT, NM_IFCFG_CONNECTION_LOG_ARG (connection_new));
g_hash_table_insert (priv->connections, g_strdup (uuid), connection_new);
g_signal_connect (connection_new, NM_SETTINGS_CONNECTION_REMOVED,
G_CALLBACK (connection_removed_cb),
self);
if (nm_ifcfg_connection_get_unmanaged_spec (connection_new)) {
const char *spec;
const char *device_id;
spec = nm_ifcfg_connection_get_unmanaged_spec (connection_new);
device_id = strchr (spec, ':');
if (device_id)
device_id++;
else
device_id = spec;
_LOGW ("Ignoring connection "NM_IFCFG_CONNECTION_LOG_FMT" / device '%s' due to NM_CONTROLLED=no.",
NM_IFCFG_CONNECTION_LOG_ARG (connection_new), device_id);
} else if (nm_ifcfg_connection_get_unrecognized_spec (connection_new))
_LOGW ("Ignoring connection "NM_IFCFG_CONNECTION_LOG_FMT" of unrecognized type.", NM_IFCFG_CONNECTION_LOG_ARG (connection_new));
/* watch changes of ifcfg hardlinks */
g_signal_connect (G_OBJECT (connection_new), "ifcfg-changed",
G_CALLBACK (connection_ifcfg_changed), self);
if (!source) {
/* Only raise the signal if we were called without source, i.e. if we read the connection from file.
* Otherwise, we were called by add_connection() which does not expect the signal. */
if (nm_ifcfg_connection_get_unmanaged_spec (connection_new))
g_signal_emit_by_name (self, NM_SYSTEM_CONFIG_INTERFACE_UNMANAGED_SPECS_CHANGED);
else if (nm_ifcfg_connection_get_unrecognized_spec (connection_new))
g_signal_emit_by_name (self, NM_SYSTEM_CONFIG_INTERFACE_UNRECOGNIZED_SPECS_CHANGED);
else
g_signal_emit_by_name (self, NM_SYSTEM_CONFIG_INTERFACE_CONNECTION_ADDED, connection_new);
}
return connection_new;
}
}
static void
process_message(iscsid_request_t *req, iscsid_response_t **prsp, int *prsp_temp)
{
iscsid_response_t *rsp;
void *p = req->parameter;
*prsp_temp = FALSE;
*prsp = rsp = (iscsid_response_t *)(void *)rsp_buf;
rsp->parameter_length = 0;
rsp->status = ISCSID_STATUS_SUCCESS;
switch (req->request) {
case ISCSID_ADD_TARGET:
if (req->parameter_length < sizeof(iscsid_add_target_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_target((iscsid_add_target_req_t *)p, prsp, prsp_temp);
break;
case ISCSID_ADD_PORTAL:
if (req->parameter_length != sizeof(iscsid_add_portal_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_portal((iscsid_add_portal_req_t *)p, prsp, prsp_temp);
break;
case ISCSID_SET_TARGET_OPTIONS:
if (req->parameter_length != sizeof(iscsid_get_set_target_options_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = set_target_options((iscsid_get_set_target_options_t *)p);
break;
case ISCSID_GET_TARGET_OPTIONS:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = ISCSID_STATUS_NOTIMPL;
break;
case ISCSID_SET_TARGET_AUTHENTICATION:
if (req->parameter_length !=
sizeof(iscsid_set_target_authentication_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = set_target_auth((iscsid_set_target_authentication_req_t *)p);
break;
case ISCSID_SLP_FIND_TARGETS:
rsp->status = ISCSID_STATUS_NOTIMPL;
break;
case ISCSID_REFRESH_TARGETS:
if (req->parameter_length < sizeof(iscsid_refresh_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = refresh_targets((iscsid_refresh_req_t *)p);
break;
case ISCSID_REMOVE_TARGET:
if (req->parameter_length != sizeof(iscsid_list_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = remove_target((iscsid_list_id_t *)p);
break;
case ISCSID_SEARCH_LIST:
if (req->parameter_length != sizeof(iscsid_search_list_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
search_list((iscsid_search_list_req_t *)p, prsp, prsp_temp);
break;
case ISCSID_GET_LIST:
if (req->parameter_length != sizeof(iscsid_get_list_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_list((iscsid_get_list_req_t *)p, prsp, prsp_temp);
break;
case ISCSID_GET_TARGET_INFO:
if (req->parameter_length != sizeof(iscsid_list_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_target_info((iscsid_list_id_t *)p, prsp, prsp_temp);
break;
case ISCSID_GET_PORTAL_INFO:
if (req->parameter_length != sizeof(iscsid_list_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_portal_info((iscsid_list_id_t *)p, prsp, prsp_temp);
break;
#ifndef ISCSI_MINIMAL
case ISCSID_ADD_ISNS_SERVER:
if (req->parameter_length != sizeof(iscsid_add_isns_server_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_isns_server((iscsid_add_isns_server_req_t *)p,
prsp, prsp_temp);
break;
case ISCSID_GET_ISNS_SERVER:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_isns_server((iscsid_sym_id_t *)p, prsp, prsp_temp);
break;
case ISCSID_SLP_FIND_ISNS_SERVERS:
rsp->status = ISCSID_STATUS_NOTIMPL;
break;
case ISCSID_REMOVE_ISNS_SERVER:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = remove_isns_server((iscsid_sym_id_t *)p);
break;
#endif
case ISCSID_ADD_INITIATOR_PORTAL:
if (req->parameter_length != sizeof(iscsid_add_initiator_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_initiator_portal((iscsid_add_initiator_req_t *)p,
prsp, prsp_temp);
break;
case ISCSID_GET_INITIATOR_PORTAL:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_initiator_portal((iscsid_sym_id_t *)p, prsp, prsp_temp);
break;
case ISCSID_REMOVE_INITIATOR_PORTAL:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = remove_initiator_portal((iscsid_sym_id_t *)p);
break;
case ISCSID_LOGIN:
if (req->parameter_length != sizeof(iscsid_login_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
login((iscsid_login_req_t *)p, rsp);
break;
case ISCSID_ADD_CONNECTION:
if (req->parameter_length != sizeof(iscsid_login_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
add_connection((iscsid_login_req_t *)p, rsp);
break;
case ISCSID_LOGOUT:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = logout((iscsid_sym_id_t *)p);
break;
case ISCSID_REMOVE_CONNECTION:
if (req->parameter_length != sizeof(iscsid_remove_connection_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = remove_connection((iscsid_remove_connection_req_t *)p);
break;
case ISCSID_GET_SESSION_LIST:
get_session_list(prsp, prsp_temp);
break;
case ISCSID_GET_CONNECTION_LIST:
if (req->parameter_length != sizeof(iscsid_sym_id_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_connection_list((iscsid_sym_id_t *)p, prsp, prsp_temp);
break;
case ISCSID_GET_CONNECTION_INFO:
if (req->parameter_length != sizeof(iscsid_get_connection_info_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
get_connection_info((iscsid_get_connection_info_req_t *)p,
prsp, prsp_temp);
break;
case ISCSID_SET_NODE_NAME:
if (req->parameter_length != sizeof(iscsid_set_node_name_req_t)) {
rsp->status = ISCSID_STATUS_INVALID_PARAMETER;
break;
}
rsp->status = set_node_name((iscsid_set_node_name_req_t *)p);
break;
case ISCSID_GET_VERSION:
get_version(prsp, prsp_temp);
break;
default:
rsp->status = ISCSID_STATUS_INVALID_REQUEST;
break;
}
}
static void
read_connections (NMSystemConfigInterface *config)
{
SCPluginKeyfile *self = SC_PLUGIN_KEYFILE (config);
SCPluginKeyfilePrivate *priv = SC_PLUGIN_KEYFILE_GET_PRIVATE (self);
GDir *dir;
GError *error = NULL;
const char *item;
GHashTable *alive_connections;
GHashTableIter iter;
NMKeyfileConnection *connection;
GPtrArray *dead_connections = NULL;
guint i;
GPtrArray *filenames;
GHashTable *paths;
dir = g_dir_open (KEYFILE_DIR, 0, &error);
if (!dir) {
nm_log_warn (LOGD_SETTINGS, "keyfile: cannot read directory '%s': (%d) %s",
KEYFILE_DIR,
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
g_clear_error (&error);
return;
}
alive_connections = g_hash_table_new (NULL, NULL);
filenames = g_ptr_array_new_with_free_func (g_free);
while ((item = g_dir_read_name (dir))) {
if (nm_keyfile_plugin_utils_should_ignore_file (item))
continue;
g_ptr_array_add (filenames, g_build_filename (KEYFILE_DIR, item, NULL));
}
g_dir_close (dir);
/* While reloading, we don't replace connections that we already loaded while
* iterating over the files.
*
* To have sensible, reproducible behavior, sort the paths by last modification
* time prefering older files.
*/
paths = _paths_from_connections (priv->connections);
g_ptr_array_sort_with_data (filenames, (GCompareDataFunc) _sort_paths, paths);
g_hash_table_destroy (paths);
for (i = 0; i < filenames->len; i++) {
connection = update_connection (self, NULL, filenames->pdata[i], NULL, FALSE, alive_connections, NULL);
if (connection)
g_hash_table_add (alive_connections, connection);
}
g_ptr_array_free (filenames, TRUE);
g_hash_table_iter_init (&iter, priv->connections);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &connection)) {
if ( !g_hash_table_contains (alive_connections, connection)
&& nm_settings_connection_get_filename (NM_SETTINGS_CONNECTION (connection))) {
if (!dead_connections)
dead_connections = g_ptr_array_new ();
g_ptr_array_add (dead_connections, connection);
}
}
g_hash_table_destroy (alive_connections);
if (dead_connections) {
for (i = 0; i < dead_connections->len; i++)
remove_connection (self, dead_connections->pdata[i]);
g_ptr_array_free (dead_connections, TRUE);
}
}
int server_loop(struct command_context *command_context)
{
struct service *service;
bool poll_ok = true;
/* used in select() */
fd_set read_fds;
int fd_max;
/* used in accept() */
int retval;
#ifndef _WIN32
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
LOG_ERROR("couldn't set SIGPIPE to SIG_IGN");
#endif
while (!shutdown_openocd) {
/* monitor sockets for activity */
fd_max = 0;
FD_ZERO(&read_fds);
/* add service and connection fds to read_fds */
for (service = services; service; service = service->next) {
if (service->fd != -1) {
/* listen for new connections */
FD_SET(service->fd, &read_fds);
if (service->fd > fd_max)
fd_max = service->fd;
}
if (service->connections) {
struct connection *c;
for (c = service->connections; c; c = c->next) {
/* check for activity on the connection */
FD_SET(c->fd, &read_fds);
if (c->fd > fd_max)
fd_max = c->fd;
}
}
}
struct timeval tv;
tv.tv_sec = 0;
if (poll_ok) {
/* we're just polling this iteration, this is faster on embedded
* hosts */
tv.tv_usec = 0;
retval = socket_select(fd_max + 1, &read_fds, NULL, NULL, &tv);
} else {
/* Every 100ms */
tv.tv_usec = 100000;
/* Only while we're sleeping we'll let others run */
openocd_sleep_prelude();
kept_alive();
retval = socket_select(fd_max + 1, &read_fds, NULL, NULL, &tv);
openocd_sleep_postlude();
}
if (retval == -1) {
#ifdef _WIN32
errno = WSAGetLastError();
if (errno == WSAEINTR)
FD_ZERO(&read_fds);
else {
LOG_ERROR("error during select: %s", strerror(errno));
exit(-1);
}
#else
if (errno == EINTR)
FD_ZERO(&read_fds);
else {
LOG_ERROR("error during select: %s", strerror(errno));
exit(-1);
}
#endif
}
if (retval == 0) {
/* We only execute these callbacks when there was nothing to do or we timed
*out */
target_call_timer_callbacks();
process_jim_events(command_context);
FD_ZERO(&read_fds); /* eCos leaves read_fds unchanged in this case! */
/* We timed out/there was nothing to do, timeout rather than poll next time
**/
poll_ok = false;
} else {
/* There was something to do, next time we'll just poll */
poll_ok = true;
}
/* This is a simple back-off algorithm where we immediately
* re-poll if we did something this time around.
*
* This greatly improves performance of DCC.
*/
poll_ok = poll_ok || target_got_message();
for (service = services; service; service = service->next) {
/* handle new connections on listeners */
if ((service->fd != -1)
&& (FD_ISSET(service->fd, &read_fds))) {
if (service->max_connections > 0)
add_connection(service, command_context);
else {
if (service->type == CONNECTION_TCP) {
struct sockaddr_in sin;
socklen_t address_size = sizeof(sin);
int tmp_fd;
tmp_fd = accept(service->fd,
(struct sockaddr *)&service->sin,
&address_size);
close_socket(tmp_fd);
}
LOG_INFO(
"rejected '%s' connection, no more connections allowed",
service->name);
}
}
/* handle activity on connections */
if (service->connections) {
struct connection *c;
for (c = service->connections; c; ) {
if ((FD_ISSET(c->fd, &read_fds)) || c->input_pending) {
retval = service->input(c);
if (retval != ERROR_OK) {
struct connection *next = c->next;
if (service->type == CONNECTION_PIPE) {
/* if connection uses a pipe then
*shutdown openocd on error */
shutdown_openocd = 1;
}
remove_connection(service, c);
LOG_INFO("dropped '%s' connection",
service->name);
c = next;
continue;
}
}
c = c->next;
}
}
}
#ifdef _WIN32
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
if (msg.message == WM_QUIT)
shutdown_openocd = 1;
}
#endif
}
return ERROR_OK;
}
static void
read_connections (SCPluginIfcfg *plugin)
{
SCPluginIfcfgPrivate *priv = SC_PLUGIN_IFCFG_GET_PRIVATE (plugin);
GDir *dir;
GError *err = NULL;
const char *item;
GHashTable *alive_connections;
GHashTableIter iter;
NMIfcfgConnection *connection;
GPtrArray *dead_connections = NULL;
guint i;
GPtrArray *filenames;
GHashTable *paths;
dir = g_dir_open (IFCFG_DIR, 0, &err);
if (!dir) {
_LOGW ("Could not read directory '%s': %s", IFCFG_DIR, err->message);
g_error_free (err);
return;
}
alive_connections = g_hash_table_new (NULL, NULL);
filenames = g_ptr_array_new_with_free_func (g_free);
while ((item = g_dir_read_name (dir))) {
char *full_path;
if (utils_should_ignore_file (item, TRUE))
continue;
if (utils_is_ifcfg_alias_file (item, NULL))
continue;
full_path = g_build_filename (IFCFG_DIR, item, NULL);
if (!utils_get_ifcfg_name (full_path, TRUE))
g_free (full_path);
else
g_ptr_array_add (filenames, full_path);
}
g_dir_close (dir);
/* While reloading, we don't replace connections that we already loaded while
* iterating over the files.
*
* To have sensible, reproducible behavior, sort the paths by last modification
* time prefering older files.
*/
paths = _paths_from_connections (priv->connections);
g_ptr_array_sort_with_data (filenames, (GCompareDataFunc) _sort_paths, paths);
g_hash_table_destroy (paths);
for (i = 0; i < filenames->len; i++) {
connection = update_connection (plugin, NULL, filenames->pdata[i], NULL, FALSE, alive_connections, NULL);
if (connection)
g_hash_table_add (alive_connections, connection);
}
g_ptr_array_free (filenames, TRUE);
g_hash_table_iter_init (&iter, priv->connections);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &connection)) {
if ( !g_hash_table_contains (alive_connections, connection)
&& nm_settings_connection_get_filename (NM_SETTINGS_CONNECTION (connection))) {
if (!dead_connections)
dead_connections = g_ptr_array_new ();
g_ptr_array_add (dead_connections, connection);
}
}
g_hash_table_destroy (alive_connections);
if (dead_connections) {
for (i = 0; i < dead_connections->len; i++)
remove_connection (plugin, dead_connections->pdata[i]);
g_ptr_array_free (dead_connections, TRUE);
}
}
// Point d'entree dans le programme
int main(int argc,char** argv)
{
FILE* transaction_file = fopen(S_LEC,"a+");
fclose(transaction_file);
transaction_file = fopen(S_LEC,"r");
if (transaction_file == NULL) {
fprintf(stderr,"Impossible d'ouvrir le fichier %s\n",S_LEC);
return -1;
}
char line_buffer[256], message[256];
int i, flags;
Connection* connection;
PRIM_PACKET p;
// Recuperation des references au tuyaux
// (respectivement l'ecriture et l'ecoute)
transToNet_pipe = atoi(argv[1]);
netToTrans_pipe = atoi(argv[2]);
// On s'assure que les file descriptors sont en mode 0_NONBLOCK
flags = fcntl(transToNet_pipe,F_GETFL,0);
fcntl(transToNet_pipe,F_SETFL, flags | O_NONBLOCK);
flags = fcntl(netToTrans_pipe,F_GETFL,0);
fcntl(netToTrans_pipe,F_SETFL, flags | O_NONBLOCK);
if (DEBUG) printf("TRANSPORT\nMes fd sont:\n%i,%i\n",netToTrans_pipe,transToNet_pipe);
//ALGO
//--------
//TANT QUE FICHIER_NON_VIDE
//LIRE S_LEC
//REGARDER_TABLE_DE_CONNEXIONS
//SI CONNEXION_EXISTE_PAS
//ENVOYER_CONNECTION_REQ
//ECOUTER_REPONSE
//SI REPONSE_POSITIVE
//CHANGER_ETAT_CONNEXION_TABLE_CONNEXION
//ENVOYER_DATA_REQ
//SINON
//SUPPRIMER_CONNEXION
//FIN SI
//SINON
//ENVOYER_DATA_REQ
//FIN SI
//FIN TANT QUE
//POUR TOUS LES CONNEXION
//SUPPRIMMER_CONNEXION
// Lecture du fichier S_LEC, envoie des requetes et ecoute
// de la reponse.
while(fgets(line_buffer, 256, transaction_file))
{
connection = (Connection*) findConnection(line_buffer[0]);
// La connexion n'existe pas
if (!connection/*==NULL*/) {
// Engager une connexion
connection = (Connection*) add_connection(line_buffer[0],NULL,NULL);
// Creaction d'un paquet contenant la primitive N_CONNECT_req
p.prim = N_CONNECT_req;
// Genere un seed pour une valeur pseudo-aleatoire
// differente par rand()
srand(time(NULL));
p.con_prim_packet.src_addr = (unsigned char) rand(); // Adresses aleatoires pour la source
p.con_prim_packet.dest_addr = (unsigned char) rand(); // et la destination..
p.con_prim_packet.con_number = connection->tcon.con_number;
// Envoie d'un paquet et ecoute de la reponse de ER
writePrimPacketToStdOut(&p,I_AM);
if(sendPacketToInterface(&p,transToNet_pipe) == -1)
return -1;
if (getPacketFromInterface(&p,netToTrans_pipe) == -1)
return -1;
char result[256];
// Action en consequence
switch(p.prim)
{
// CON_PRIM_PACKET reçu => N_CONNECT_conf
case N_CONNECT_conf:
// Ecriture des resutlats dans S_ECR
sprintf(result,"Reception de la primitive N_CONNECT.conf sur la connection %c\n", connection->tcon.con_number);
writeResults(result,S_ECR);
// Confirmation de la connexion
connection->tcon.state = 0x01;
// Construction du paquet de DATA
p.prim = N_DATA_req;
getMessageFromBuffer(line_buffer,message);
strcpy(p.data_prim_packet.transaction,message);
p.data_prim_packet.con_number = connection->tcon.con_number;
// Envoie du paquet a l'ER
writePrimPacketToStdOut(&p,I_AM);
if(sendPacketToInterface(&p,transToNet_pipe) == -1)
return -1;
break;
// REL_PRIM_PACKET reçu => N_DISCONNECT_ind
case N_DISCONNECT_ind:
// Ecriture des resultats dans S_ECR
sprintf(result,"Reception de la primitive N_DISCONNECT.ind pour la connexion %c\n",connection->tcon.con_number);
writeResults(result,S_ECR);
// Retrait de la connexion de la table de connexions
remove_connection(connection->tcon.con_number);
break;
}
}
else {
// Construction du paquet de DATA
p.prim = N_DATA_req;
getMessageFromBuffer(line_buffer,message);
strcpy(p.data_prim_packet.transaction,message);
p.data_prim_packet.con_number = connection->tcon.con_number;
// Envoyer N_DATA.req
writePrimPacketToStdOut(&p,I_AM);
if(sendPacketToInterface(&p,transToNet_pipe) == -1)
return -1;
}
}
// Construction d'un paquet REL_PRIM_PACKET
// et vidage de la table de connexions
p.prim = N_DISCONNECT_req;
connection = first_con_node;
while (connection) {
p.rel_prim_packet.con_number = connection->tcon.con_number;
writePrimPacketToStdOut(&p,I_AM);
if(sendPacketToInterface(&p,transToNet_pipe) == -1)
return -1;
connection = connection->tcon.next;
}
deleteAllConnections();
// Fermeture du fichier S_LEC
fclose(transaction_file);
return 0;
}
