static int filesystem_read(const char *path, char *buffer, size_t buffer_size, off_t offset,
struct fuse_file_info *file_info) {
//int retstat = 0;
logging_log("Filesystem", LOGGING_LEVEL_INFO,
"filesystem_read(path=\"%s\", buf=0x%08x, size=%d, offset=%lld, fi=0x%08x)", path,
buffer, buffer_size, offset, file_info);
char *url;
if(filesystem_get_url(path, &url))
return -1;
char *downloader_buffer;
size_t downloader_buffer_size = downloader_file_contents_try_get(url, buffer_size, offset,
FILESYSTEM_READ_TIMEOUT, (void**)&downloader_buffer);
if(!downloader_buffer_size)
return EOF;
size_t to_write = downloader_buffer_size > buffer_size ? buffer_size : downloader_buffer_size;
logging_log("Filesystem", LOGGING_LEVEL_DEBUG, "filesystem_read() - to_write: %lu...", to_write);
memcpy(buffer, downloader_buffer, to_write);
free(downloader_buffer);
return to_write;
}
void downloader_url_lock(char const *url) {
pthread_mutex_lock(downloader_files_mutex);
logging_log("Downloader", LOGGING_LEVEL_INFO, "downloader_lock_url(url=%s)...", url);
char search_result;
downloader_request_t *request = (downloader_request_t*)al_dictionary_get(downloader_files,
&search_result, url);
if(search_result) {
request = downloader_request_construct(url);
request->reference_count = 2;
al_dictionary_insert(downloader_files, url, request);
queue_enqueue(downloader_requests_queue, request);
logging_log("Donwloader", LOGGING_LEVEL_INFO, "Inserted new job into queue...");
pthread_cond_signal(downloader_requests_cond);
} else {
logging_log("Donwloader", LOGGING_LEVEL_INFO, "File already downloaded or downloading...");
pthread_mutex_lock(request->mutex);
request->reference_count++;
logging_log("Donwloader", LOGGING_LEVEL_INFO, "request->reference_count: %lu...",
(unsigned long int)request->reference_count);
pthread_mutex_unlock(request->mutex);
}
pthread_mutex_unlock(downloader_files_mutex);
}
void fg_pcap_go(struct _flow *flow)
{
int rc;
if (!flow->settings.traffic_dump)
return;
if (dumping) {
logging_log(LOG_WARNING, "pcap: dumping already in progress "
"on this host");
return;
}
DEBUG_MSG(LOG_DEBUG, "called fg_pcap_go() for flow %d", flow->id);
dumping = 1;
rc = pthread_create(&flow->pcap_thread, NULL, fg_pcap_work,
(void*)flow);
/* barrier: dump thread is ready (or aborted) */
#ifndef __DARWIN__
pthread_barrier_wait(&pcap_barrier);
#endif /* __DARWIN__ */
if (rc)
logging_log(LOG_WARNING, "Could not start pcap thread: %s",
strerror(errno) );
return;
}
static char filesystem_get_url(char const *path, char **url) {
path_t *path_parsed = path_parse(path);
if(path_parsed->parts_length != 2) {
pthread_mutex_unlock(filesystem_io_mutex);
path_free(path_parsed);
logging_log("Filesystem", LOGGING_LEVEL_WARNING,
"filesystem_get_url() - Invalid path %s...", path);
return -1;
}
pthread_mutex_lock(filesystem_io_mutex);
ALDictionary *results = searcher_get_search_results(path_parsed->parts[0]);
if(results == NULL) {
pthread_mutex_unlock(filesystem_io_mutex);
path_free(path_parsed);
logging_log("Filesystem", LOGGING_LEVEL_WARNING, "Invalid file %s...", path);
return -1;
}
char result;
*url = (char*)al_dictionary_get(results, &result, path_parsed->parts[1]);
pthread_mutex_unlock(filesystem_io_mutex);
if(result) {
logging_log("Filesystem", LOGGING_LEVEL_WARNING,
"filesystem_get_url() - Invalid path %s...", path);
return -1;
} else
logging_log("Filesystem", LOGGING_LEVEL_INFO, "filesystem_get_url() - Url is %s...", *url);
path_free(path_parsed);
return 0;
}
static void sighandler(int sig)
{
int status;
switch (sig) {
case SIGCHLD:
while (waitpid(-1, &status, WNOHANG) > 0)
logging_log(LOG_NOTICE, "child returned (status = %d)",
status);
break;
case SIGHUP:
logging_log(LOG_NOTICE, "got SIGHUP, don't know what to do.");
break;
case SIGALRM:
logging_log(LOG_NOTICE, "Caught SIGALRM. don't know what to do.");
break;
case SIGPIPE:
break;
default:
logging_log(LOG_ALERT, "got signal %d, but don't remember "
"intercepting it, aborting...", sig);
abort();
}
}
static void fuse_destroyed() {
logging_log("Main", LOGGING_LEVEL_INFO,
"*** Got EXIT COMMAND from FUSE, termination sequence initiated...");
logging_log("Main", LOGGING_LEVEL_INFO,
"Terminating all other threads...");
downloader_shutdown();
logging_log("Main", LOGGING_LEVEL_INFO,
"All other threads have terminated, cleaning up...");
http_free();
downloader_free();
searcher_free();
filesystem_free();
providers_free();
configuration_free();
logging_log("Main", LOGGING_LEVEL_INFO,
"Cleanup almost finished, cleaning up the logging subsystem and exiting...");
logging_free();
fclose(stdin);
fclose(stdout);
fclose(stderr);
}
/* This method returns version information of flowgrindd and OS as an xmlrpc struct */
static xmlrpc_value * method_get_version(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(param_array);
UNUSED_ARGUMENT(user_data);
struct utsname buf;
xmlrpc_value *ret = 0;
DEBUG_MSG(LOG_WARNING, "Method get_version called");
if (uname(&buf)) {
logging_log(LOG_WARNING, "uname() failed %s", strerror(errno));
exit(1);
}
ret = xmlrpc_build_value(env, "{s:s,s:i,s:s,s:s}",
"version", FLOWGRIND_VERSION,
"api_version", FLOWGRIND_API_VERSION,
"os_name", buf.sysname,
"os_release", buf.release);
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method get_version failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method get_version successful");
}
return ret;
}
void set_affinity(int cpu)
{
#ifdef __LINUX__
typedef cpu_set_t fg_cpuset;
#elif __FreeBSD__
typedef cpuset_t fg_cpuset;
#endif /* __LINUX__ */
int rc;
int ncpu = sysconf(_SC_NPROCESSORS_ONLN); /* number of cores */
fg_cpuset cpuset; /* define cpu_set bit mask */
/* sanity check */
if (cpu > ncpu) {
logging_log(LOG_WARNING, "CPU binding failed. Given cpu number "
"is higher then the available cores");
return;
}
CPU_ZERO(&cpuset); /* initialize to 0, i.e. no CPUs selected. */
CPU_SET(cpu, &cpuset); /* set bit that represents the given core */
#ifdef __LINUX__
rc = sched_setaffinity(getpid(), sizeof(cpuset), &cpuset);
#elif __FreeBSD__
rc = cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1,
sizeof(cpuset), &cpuset);
#endif /* __LINUX__ */
if (rc)
logging_log(LOG_WARNING, "failed to bind %s (PID %d) to "
"CPU %i\n", progname, getpid(), cpu);
else
DEBUG_MSG(LOG_WARNING, "bind %s (PID %d) to CPU %i\n",
progname, getpid(), cpu);
}
/* creates listen socket for the xmlrpc server */
static int bind_rpc_server(char *bind_addr, unsigned int port) {
int rc;
int fd;
int optval;
struct addrinfo hints, *res, *ressave;
char tmp_port[100];
bzero(&hints, sizeof(struct addrinfo));
hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
sprintf(tmp_port, "%u", port);
if ((rc = getaddrinfo(bind_addr, tmp_port,
&hints, &res)) != 0) {
logging_log(LOG_ALERT, "Failed to find address to bind rpc_server: %s\n",
gai_strerror(rc));
return -1;
}
ressave = res;
/* try to bind the first succeeding socket of
the returned addresses (libxmlrpc only supports one fd)
*/
do {
fd = socket(res->ai_family, res->ai_socktype,
res->ai_protocol);
if (fd < 0)
continue;
/* ignore old client connections in TIME_WAIT */
optval = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
/* Disable Nagle algorithm to reduce latency */
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));
if (bind(fd, res->ai_addr, res->ai_addrlen) == 0)
break;
close(fd);
} while ((res = res->ai_next) != NULL);
if (res == NULL) {
logging_log(LOG_ALERT, "failed to bind RPC listen socket: %s\n", strerror(errno));
freeaddrinfo(ressave);
return -1;
}
return fd;
}
static void _tracker_logRAM(Tracker* tracker, GLogLevelFlags level, SimulationTime interval) {
guint seconds = (guint) (interval / SIMTIME_ONE_SECOND);
guint numptrs = g_hash_table_size(tracker->allocatedLocations);
if(!tracker->didLogRAMHeader) {
tracker->didLogRAMHeader = TRUE;
logging_log(G_LOG_DOMAIN, level, __FILE__, __FUNCTION__, __LINE__,
"[shadow-heartbeat] [ram-header] interval-seconds,alloc-bytes,dealloc-bytes,total-bytes,pointers-count,failfree-count");
}
logging_log(G_LOG_DOMAIN, level, __FILE__, __FUNCTION__, __LINE__,
"[shadow-heartbeat] [ram] %u,%"G_GSIZE_FORMAT",%"G_GSIZE_FORMAT",%"G_GSIZE_FORMAT",%u,%u",
seconds, tracker->allocatedBytesLastInterval, tracker->deallocatedBytesLastInterval,
tracker->allocatedBytesTotal, numptrs, tracker->numFailedFrees);
}
void filesystem_free() {
logging_log("Filesystem", LOGGING_LEVEL_INFO,
"Global destructor of the filesystem subsystem was called, cleaning up...");
pthread_mutex_destroy(filesystem_io_mutex);
free(filesystem_io_mutex);
}
static void downloader_garbage_collect() {
void *reference = NULL;
while(configuration->downloader_size_maximum &&
downloader_files_size > configuration->downloader_size_maximum &&
queue_get_length(downloader_files_free_queue)) {
downloader_request_t *next = (downloader_request_t*)queue_dequeue(
downloader_files_free_queue);
if(reference == next)
break;
else if(reference == NULL)
reference = next;
pthread_mutex_lock(next->mutex);
if(!next->reference_count) {
pthread_mutex_unlock(next->mutex);
downloader_files_size -= next->file->size;
logging_log("Downloader", LOGGING_LEVEL_INFO, "About to free contents saved for %s...",
next->url);
al_dictionary_remove(downloader_files, next->url);
downloader_request_free(next);
reference = NULL;
} else {
pthread_mutex_unlock(next->mutex);
queue_enqueue(downloader_files_free_queue, next);
}
}
}
void fg_pcap_init()
{
/* initalize *alldevs for later use */
#ifdef DEBUG
pcap_if_t *d;
char devdes[200];
#endif /* DEBUG */
if (pcap_findalldevs(&alldevs, errbuf) == -1) {
logging_log(LOG_WARNING,"Error in pcap_findalldevs: %s\n",
errbuf);
return;
}
#ifdef DEBUG
for (d = alldevs; d; d = d->next) {
pcap_addr_t *a;
snprintf(devdes, sizeof(devdes), "%s: ", d->name);
for (a = d->addresses; a; a = a->next) {
char addr[100];
if (!a->addr)
continue;
snprintf(addr, sizeof(addr), "a=%s",
fg_nameinfo(a->addr, sizeof(struct sockaddr)));
strncat(devdes, addr, sizeof(devdes) - strlen(devdes) - 1);
if (a->next)
strncat(devdes, ", ", sizeof(devdes) - strlen(devdes) - 1);
}
DEBUG_MSG(LOG_ERR, "pcap: found pcapable device (%s)", devdes);
}
#endif /* DEBUG*/
pthread_mutex_init(&pcap_mutex, NULL);
#ifndef __DARWIN__
pthread_barrier_init(&pcap_barrier, NULL, 2);
#endif /* __DARWIN__ */
return;
}
void downloader_init() {
logging_log("Donwloader", LOGGING_LEVEL_INFO, "downloader_init()");
configuration = configuration_get();
downloader_requests_queue = queue_construct();
downloader_files_free_queue = queue_construct();
downloader_requests_cond = (pthread_cond_t*)malloc(sizeof(pthread_cond_t));
pthread_cond_init(downloader_requests_cond, NULL);
downloader_files
= al_dictionary_construct((char(*)(const void *, const void *))&string_compare);
downloader_files_size = 0;
downloader_files_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(downloader_files_mutex, NULL);
thread_counter_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(thread_counter_mutex, NULL);
thread_terminating = (pthread_cond_t*)malloc(sizeof(pthread_cond_t));
pthread_cond_init(thread_terminating, NULL);
for(uint8_t i = 0; i < configuration->downloader_threads_number; ++i) {
pthread_t worker_thread;
pthread_create(&worker_thread, NULL, (void *(*)(void *))&downloader_do_work, (void*)NULL);
}
}
void downloader_shutdown() {
logging_log("Downloader", LOGGING_LEVEL_INFO,
"Global shutdown sequence of the downloader subsystem was initiated, terminating threads...");
pthread_mutex_lock(downloader_files_mutex);
pthread_mutex_lock(thread_counter_mutex);
logging_log("Downloader", LOGGING_LEVEL_INFO, "Waiting for all threads to terminate...");
threads *= -1;
pthread_cond_broadcast(downloader_requests_cond);
pthread_mutex_unlock(downloader_files_mutex);
while(threads)
pthread_cond_wait(thread_terminating, thread_counter_mutex);
threads = -1;
pthread_mutex_unlock(thread_counter_mutex);
logging_log("Downloader", LOGGING_LEVEL_INFO, "All threads terminated...");
}
static void run_rpc_server(xmlrpc_env *env, unsigned int port)
{
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
memset(&serverparm, 0, sizeof(serverparm));
registryP = xmlrpc_registry_new(env);
xmlrpc_registry_add_method(env, registryP, NULL, "add_flow_destination", &add_flow_destination, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "add_flow_source", &add_flow_source, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "start_flows", &start_flows, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "get_reports", &method_get_reports, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "stop_flow", &method_stop_flow, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "get_version", &method_get_version, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "get_status", &method_get_status, NULL);
/* In the modern form of the Abyss API, we supply parameters in memory
like a normal API. We select the modern form by setting
config_file_name to NULL:
*/
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.socket_bound = 1;
serverparm.log_file_name = NULL; /*"/tmp/xmlrpc_log";*/
/* Increase HTTP keep-alive duration. Using defaults the amount of
* sockets in TIME_WAIT state would become too high.
*/
serverparm.keepalive_timeout = 60;
serverparm.keepalive_max_conn = 1000;
/* Disable introspection */
serverparm.dont_advertise = 1;
logging_log(LOG_NOTICE, "Running XML-RPC server on port %u", port);
printf("Running XML-RPC server...\n");
serverparm.socket_handle = bind_rpc_server(rpc_bind_addr, port);
xmlrpc_server_abyss(env, &serverparm, XMLRPC_APSIZE(socket_handle));
if (env->fault_occurred) {
logging_log(LOG_ALERT, "XML-RPC Fault: %s (%d)\n",
env->fault_string, env->fault_code);
}
/* xmlrpc_server_abyss() never returns */
}
static int filesystem_releasedir(const char *path, struct fuse_file_info *fi) {
int retstat = 0;
logging_log("Filesystem", LOGGING_LEVEL_INFO, "filesystem_releasedir(path=\"%s\", fi=0x%08x)",
path, fi);
return retstat;
}
void logging_init(config_t *cfg)
{
apr_status_t rv;
if (cfg->errorlog) {
rv = apr_file_open(&cfg->errorlog_fp, cfg->errorlog,
APR_FOPEN_CREATE | APR_FOPEN_WRITE | APR_FOPEN_APPEND,
APR_OS_DEFAULT,
cfg->pool);
if (rv) {
printf("Error opening %s\n",cfg->errorlog);
cfg->loglevel = LOGLEVEL_NONE;
}
logging_log(cfg, LOGLEVEL_ERROR, "Log file Opened");
} else {
cfg->loglevel = LOGLEVEL_NONE;
logging_log(cfg, LOGLEVEL_NOISE, "No Log file specified, disabled logging");
}
}
static void _tracker_logNode(Tracker* tracker, GLogLevelFlags level, SimulationTime interval) {
guint seconds = (guint) (interval / SIMTIME_ONE_SECOND);
gdouble cpuutil = (gdouble)(((gdouble)tracker->processingTimeLastInterval) / ((gdouble)interval));
gdouble avgdelayms = 0.0;
if(tracker->numDelayedLastInterval > 0) {
gdouble delayms = (gdouble) (((gdouble)tracker->delayTimeLastInterval) / ((gdouble)SIMTIME_ONE_MILLISECOND));
avgdelayms = (gdouble) (delayms / ((gdouble) tracker->numDelayedLastInterval));
}
if(!tracker->didLogNodeHeader) {
tracker->didLogNodeHeader = TRUE;
logging_log(G_LOG_DOMAIN, level, __FILE__, __FUNCTION__, __LINE__,
"[shadow-heartbeat] [node-header] "
"interval-seconds,recv-bytes,send-bytes,cpu-percent,delayed-count,avgdelay-milliseconds;"
"inbound-localhost-counters;outbound-localhost-counters;"
"inbound-remote-counters;outbound-remote-counters "
"where counters are: %s", _tracker_getCounterHeaderString()
);
}
gsize totalRecvBytes = _tracker_sumBytes(&tracker->remote.inCounters.bytes);
gsize totalSendBytes = _tracker_sumBytes(&tracker->remote.outCounters.bytes);
gchar* inLocal = _tracker_getCounterString(&tracker->local.inCounters);
gchar* outLocal = _tracker_getCounterString(&tracker->local.outCounters);
gchar* inRemote = _tracker_getCounterString(&tracker->remote.inCounters);
gchar* outRemote = _tracker_getCounterString(&tracker->remote.outCounters);
GString* buffer = g_string_new("[shadow-heartbeat] [node] ");
g_string_append_printf(buffer, "%u,%"G_GSIZE_FORMAT",%"G_GSIZE_FORMAT",%f,%"G_GSIZE_FORMAT",%f;",
seconds, totalRecvBytes, totalSendBytes, cpuutil, tracker->numDelayedLastInterval, avgdelayms);
g_string_append_printf(buffer, "%s;%s;%s;%s", inLocal, outLocal, inRemote, outRemote);
logging_log(G_LOG_DOMAIN, level, __FILE__, __FUNCTION__, __LINE__, "%s", buffer->str);
g_free(inLocal);
g_free(outLocal);
g_free(inRemote);
g_free(outRemote);
g_string_free(buffer, TRUE);
}
static int filesystem_open(const char *path, struct fuse_file_info *file_info) {
logging_log("Filesystem", LOGGING_LEVEL_INFO, "filesystem_open(path\"%s\", fi=0x%08x)", path,
file_info);
char *url;
if(filesystem_get_url(path, &url))
return -1;
downloader_url_lock(url);
return 0;
}
void downloader_url_unlock(char const *url) {
pthread_mutex_lock(downloader_files_mutex);
logging_log("Downloader", LOGGING_LEVEL_INFO, "downloader_unlock_url(url=%s)...", url);
char search_result;
downloader_request_t *request = (downloader_request_t*)al_dictionary_get(downloader_files,
&search_result, url);
if(!search_result) {
pthread_mutex_lock(request->mutex);
if(request->reference_count)
request->reference_count--;
logging_log("Donwloader", LOGGING_LEVEL_INFO, "request->reference_count: %lu...",
(unsigned long int)request->reference_count);
pthread_mutex_unlock(request->mutex);
downloader_garbage_collect();
} else
logging_log("Downloader", LOGGING_LEVEL_ERROR,
"Fatal error: Could not find url to unlock...");
pthread_mutex_unlock(downloader_files_mutex);
}
size_t downloader_file_contents_try_get(char *url, size_t requested_size, off_t offset,
uint16_t time_max, void **data) {
pthread_mutex_lock(downloader_files_mutex);
logging_log(
"Donwloader",
LOGGING_LEVEL_INFO,
"downloader_file_contents_try_get(url=%s, requested_size=%lu, offset=%ld, time_max=%d)...",
url, requested_size, offset, time_max);
char search_result;
downloader_request_t *request = (downloader_request_t*)al_dictionary_get(downloader_files,
&search_result, url);
pthread_mutex_unlock(downloader_files_mutex);
if(search_result) {
logging_log("Downloader", LOGGING_LEVEL_CRITICAL, "Fatal error: Locked url not present...");
return 0;
} else
logging_log("Donwloader", LOGGING_LEVEL_INFO, "File already downloaded or downloading...");
struct timeval tp;
gettimeofday(&tp, NULL);
struct timespec ts;
ts.tv_sec = tp.tv_sec;
ts.tv_nsec = tp.tv_usec * 1000;
ts.tv_sec += time_max;
pthread_mutex_lock(request->mutex);
while(!request->finished && request->file->size < offset + requested_size) {
logging_log("Donwloader", LOGGING_LEVEL_INFO, "request->file->size=%lu",
request->file->size);
if(request->minimum_size <= request->file->size || offset + requested_size
< request->minimum_size)
request->minimum_size = offset + requested_size;
if(pthread_cond_timedwait(request->minimum_size_reached, request->mutex, &ts) == ETIMEDOUT) {
logging_log("Donwloader", LOGGING_LEVEL_INFO, "Request timed out...");
break;
}
}
logging_log("Donwloader", LOGGING_LEVEL_INFO, "Got enough data to copy back...");
size_t to_copy = 0;
if(request->file->size > offset) {
to_copy = (request->file->size - offset) > requested_size ? requested_size
: (request->file->size - offset);
*data = malloc(to_copy);
memcpy(*data, (char*)request->file->contents + offset, to_copy);
}
pthread_mutex_unlock(request->mutex);
return to_copy;
}
static void fuse_initialised() {
logging_init();
musicfs_configuration_t *configuration = configuration_get();
logging_set_destination(configuration->logfile);
logging_set_level(configuration->log_level);
logging_set_timestamp_printed(configuration->log_timestamp_use);
http_init();
providers_init();
// Register built-in providers
skreemr_init();
// Set default search provider
provider_t *provider = providers_find(configuration->provider_name);
if(!provider)
logging_log(MODULE, LOGGING_LEVEL_CRITICAL, "'%s' is not a known search provider.", configuration->provider_name);
else searcher_provider_set(provider);
logging_log(MODULE, LOGGING_LEVEL_INFO, "fuse_initialised()");
downloader_init();
}
static xmlrpc_value * start_flows(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(user_data);
int rc;
xmlrpc_value *ret = 0;
int start_timestamp;
struct _request_start_flows *request = 0;
DEBUG_MSG(LOG_WARNING, "Method start_flows called");
/* Parse our argument array. */
xmlrpc_decompose_value(env, param_array, "({s:i,*})",
/* general settings */
"start_timestamp", &start_timestamp);
if (env->fault_occurred)
goto cleanup;
request = malloc(sizeof(struct _request_start_flows));
request->start_timestamp = start_timestamp;
rc = dispatch_request((struct _request*)request, REQUEST_START_FLOWS);
if (rc == -1) {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR, request->r.error); /* goto cleanup on failure */
}
/* Return our result. */
ret = xmlrpc_build_value(env, "i", 0);
cleanup:
if (request) {
free(request->r.error);
free(request);
}
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method start_flows failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method start_flows successful");
}
return ret;
}
static xmlrpc_value * method_stop_flow(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(user_data);
int rc;
xmlrpc_value *ret = 0;
int flow_id;
struct _request_stop_flow *request = 0;
DEBUG_MSG(LOG_WARNING, "Method stop_flow called");
/* Parse our argument array. */
xmlrpc_decompose_value(env, param_array, "({s:i,*})",
/* flow id */
"flow_id", &flow_id);
if (env->fault_occurred)
goto cleanup;
request = malloc(sizeof(struct _request_stop_flow));
request->flow_id = flow_id;
rc = dispatch_request((struct _request*)request, REQUEST_STOP_FLOW);
if (rc == -1) {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR, request->r.error); /* goto cleanup on failure */
}
/* Return our result. */
ret = xmlrpc_build_value(env, "()");
cleanup:
if (request) {
free(request->r.error);
free(request);
}
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method stop_flow failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method stop_flow successful");
}
return ret;
}
size_t downloader_file_size_try_get(char const *url) {
size_t result = 0;
logging_log("Downloader", LOGGING_LEVEL_INFO, "downloader_file_size_try_get(url=%s)", url);
pthread_mutex_lock(downloader_files_mutex);
char search_result;
downloader_request_t *request = (downloader_request_t*)al_dictionary_get(downloader_files,
&search_result, url);
if(!search_result) {
pthread_mutex_lock(request->mutex);
result = request->file->size;
pthread_mutex_unlock(request->mutex);
}
pthread_mutex_unlock(downloader_files_mutex);
return result;
}
void uninit_flow(struct _flow *flow)
{
DEBUG_MSG(LOG_DEBUG,"uninit_flow() called for flow %d",flow->id);
if (flow->fd != -1)
close(flow->fd);
if (flow->listenfd_data != -1)
close(flow->listenfd_data);
#ifdef HAVE_LIBPCAP
int rc;
if (flow->settings.traffic_dump && flow->pcap_thread) {
rc = pthread_cancel(flow->pcap_thread);
if (rc)
logging_log(LOG_WARNING, "failed to cancel dump "
"thread: %s", strerror(errno));
fg_pcap_cleanup(flow);
}
#endif
free_all(flow->read_block, flow->write_block, flow->addr, flow->error);
free_math_functions(flow);
}
int main(int argc, char *argv[])
{
struct sigaction sa;
xmlrpc_env env;
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
crit("could not ignore SIGPIPE");
sa.sa_handler = sighandler;
sa.sa_flags = 0;
sigemptyset (&sa.sa_mask);
sigaction (SIGHUP, &sa, NULL);
sigaction (SIGALRM, &sa, NULL);
sigaction (SIGCHLD, &sa, NULL);
set_progname(argv[0]);
parse_cmdline(argc, argv);
logging_init();
#ifdef HAVE_LIBPCAP
fg_pcap_init();
#endif /* HAVE_LIBPCAP */
if (log_type == LOGTYPE_SYSLOG) {
/* Need to call daemon() before creating the thread because
* it internally calls fork() which does not copy threads. */
if (daemon(0, 0) == -1)
crit("daemon() failed");
logging_log(LOG_NOTICE, "flowgrindd daemonized");
}
if (cpu >= 0)
set_affinity(cpu);
create_daemon_thread();
xmlrpc_env_init(&env);
run_rpc_server(&env, port);
critx("control should never reach end of main()");
}
/* This method returns the number of flows and if actual test has started */
static xmlrpc_value * method_get_status(xmlrpc_env * const env,
xmlrpc_value * const param_array,
void * const user_data)
{
UNUSED_ARGUMENT(param_array);
UNUSED_ARGUMENT(user_data);
int rc;
xmlrpc_value *ret = 0;
struct _request_get_status *request = 0;
DEBUG_MSG(LOG_WARNING, "Method get_status called");
request = malloc(sizeof(struct _request_get_status));
rc = dispatch_request((struct _request*)request, REQUEST_GET_STATUS);
if (rc == -1) {
XMLRPC_FAIL(env, XMLRPC_INTERNAL_ERROR, request->r.error); /* goto cleanup on failure */
}
/* Return our result. */
ret = xmlrpc_build_value(env, "{s:i,s:i}",
"started", request->started,
"num_flows", request->num_flows);
cleanup:
if (request) {
free(request->r.error);
free(request);
}
if (env->fault_occurred)
logging_log(LOG_WARNING, "Method get_status failed: %s", env->fault_string);
else {
DEBUG_MSG(LOG_WARNING, "Method get_status successful");
}
return ret;
}
int filesystem_init(int fargc, char *fargv[], void(*fuse_initialised)(), void(*fuse_destroyed)()) {
_fuse_initialised = fuse_initialised;
_fuse_destroyed = fuse_destroyed;
struct fuse_operations operations;
for(size_t i = 0; i < sizeof(struct fuse_operations); i++) {
char *ptr = (char*)&operations + i;
*ptr = 0;
}
operations.read = filesystem_read;
operations.open = filesystem_open;
operations.release = filesystem_release;
operations.getattr = filesystem_getattr;
operations.init = __fuse_initialised;
operations.destroy = __fuse_destroyed;
operations.readdir = filesystem_readdir;
operations.opendir = filesystem_opendir;
operations.releasedir = filesystem_releasedir;
logging_log("Filesystem", LOGGING_LEVEL_INFO, "About to call fuse_main()...");
return fuse_main(fargc, fargv, &operations, NULL);
}
