/* Debug Helpers */
inline void flex_debug_out(flex_t flex){
log_success("BEGIN DEBUG");
log_warn("index length -[%ld]", flex->index_length);
log_warn("data length --[%ld]", flex->last_data_size);
log_warn("num super ----[%ld]", flex->num_super_blocks);
log_warn("userstuff ----[%ld, %ld]", flex->num_user_elements_inserted, flex->usable_data_blocks);
log_warn("index --------[%ld, %ld]", flex->last_index_occup, flex->index_length);
log_warn("super --------[%ld, %ld]", flex->last_super_occup, flex->last_super_size);
log_success("END DEBUG");
}
int command_list_db(int argc, char **argv, int optind, int flags) {
struct DBItem dbi = DBITEM_NULL;
struct DBItem *e = NULL;
char *p = NULL;
int do_free_p = 0;
int i = 0;
for(i = optind; i < argc; ++i) {
DBITEM_SET_NULL(dbi);
e = NULL;
if(access(argv[i], F_OK | R_OK) != 0 || DB_read(argv[i], &dbi) != 0) {
log_failure(argv[i], "doesn't exist or isn't a valid database");
continue;
}
if(dbi.kbuf == NULL) {
log_info(argv[i], "is empty");
continue;
}
e = &dbi;
do {
p = e->kbuf;
if(flags & USE_REALPATH)
p = get_realpath((const char*) e->kbuf, &do_free_p);
log_success(argv[i], "%s -> %08X", p, e->crc);
if(do_free_p == 1) {
free(p);
do_free_p = 0;
}
} while((e = e->next) != NULL);
if(dbi.next != NULL)
DB_item_free(dbi.next);
}
return EXIT_SUCCESS;
}
struct daemon *
daemon_remove (struct daemon *l, struct daemon *d) {
struct daemon *tmp;
/* FIXME: if we daemon_remove a non-existing daemon, I think we're
screwed */
pthread_mutex_lock (&nb_daemons.lock);
log_success (log_file, "DAEMON--");
--nb_daemons.count;
pthread_mutex_unlock (&nb_daemons.lock);
if (!l)
return NULL;
for (tmp = l; tmp != d; tmp = tmp->next);
/* This was the last element */
if (tmp->prev == NULL && tmp->next == NULL) {
return NULL;
}
/* Was the first element */
if (!tmp->prev) {
tmp->next->prev = NULL;
return tmp->next;
}
tmp->prev->next = tmp->next;
return l;
}
int command_check_hexstring(int argc, char **argv, int optind,
int flags) {
int ret = EXIT_SUCCESS;
int i = optind-1;
uint32_t strcrc, crc;
long int cast;
if(flags & CALC_PRINT_NUMERICAL)
cast = (uint32_t) strtol(hexarg, NULL, 10);
else
cast = (uint32_t) strtol(hexarg, NULL, 16);
if((cast == LONG_MIN || cast == LONG_MAX) &&
errno == ERANGE)
cast = 0;
strcrc = (uint32_t) cast;
while(argv[++i]) {
if(check_access_flags_v(argv[i], F_OK | R_OK, 1) != 0) {
log_failure(argv[i], "not accessible, not a file or doesn't exist");
ret = EXIT_FAILURE;
continue;
}
if((crc = compute_crc32(argv[i])) == strcrc)
log_success(argv[i], "match");
else
log_failure(argv[i], "mismatch: %08X is really %08X", strcrc, crc);
}
return ret;
}
void *
handle_daemon (void *arg) {
struct daemon *d;
struct daemon_request *tmp;
d = (struct daemon *)arg;
if (!d)
goto out;
sem_wait (&daemons_lock);
daemons = daemon_add (daemons, d);
sem_post (&daemons_lock);
if (!daemons) {
daemon_free (d);
goto out;
}
log_success (log_file, "BEGIN daemon %s", d->addr);
handle_requests (d);
log_success (log_file, "END daemon %s", d->addr);
sem_wait (&daemons_lock);
daemons = daemon_remove (daemons, d);
sem_post (&daemons_lock);
/* Let's clean all remaining requests for this daemon */
sem_wait (&d->req_lock);
for (tmp = d->requests; tmp; tmp = tmp->next) {
/* Either it's been assigned to a thread in the pool */
if (tmp->assigned)
pool_kill (tmp->pool, tmp->tid);
/* Or it's still in the queue */
else
pool_flush_by_arg (tmp->pool, tmp);
daemon_request_free (tmp);
}
sem_post (&d->req_lock);
daemon_free (d);
out:
sem_wait (&nb_daemons.lock);
--nb_daemons.count;
sem_post (&nb_daemons.lock);
return NULL;
}
int logWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: log_success(); break;
case 1: appendText((*reinterpret_cast< const char*(*)>(_a[1]))); break;
case 2: crossClicked(); break;
default: ;
}
_id -= 3;
}
return _id;
}
struct daemon *
daemon_add (struct daemon *l, struct daemon *d) {
pthread_mutex_lock (&nb_daemons.lock);
log_success (log_file, "DAEMON++");
++nb_daemons.count;
pthread_mutex_unlock (&nb_daemons.lock);
if (!d) {
return l;
}
if (!l) {
return d;
}
d->prev = NULL;
d->next = l;
l->prev = d;
return d;
}
int command_check(int argc, char **argv, int optind, int flags) {
int ret = EXIT_SUCCESS;
int i = optind-1;
int ci, ti;
uint32_t compcrc, matchcrc;
char *string;
char results[9];
regmatch_t rmatch;
regex_t regex;
while(argv[++i]) {
if(check_access_flags_v(argv[i], F_OK | R_OK, 1) != 0) {
log_info(argv[i], "Inaccessbile file, skipping.");
continue;
}
string = get_basename((char*)argv[i]);
compile_regex(®ex, crcregex, REG_ICASE);
switch(regexec((const regex_t*) ®ex, string, 1, &rmatch, 0)) {
case 0:
for(ci = rmatch.rm_so, ti = 0; ci < rmatch.rm_eo; ++ci)
results[ti++] = string[ci];
results[ti] = '\0';
break;
case REG_NOMATCH:
log_info(argv[i], "Does not contain a hexstring, ignoring.");
continue;
}
regfree(®ex);
compcrc = compute_crc32(argv[i]);
matchcrc = (uint32_t) strtol(results, NULL, 16);
if(compcrc == matchcrc)
log_success(argv[i], "OK");
else {
log_failure(argv[i], "Mismatch: %08X is really %08X", matchcrc, compcrc);
ret = EXIT_FAILURE;
}
} /* while */
return ret;
}
void*
daemon_request_ready (void* arg) {
struct daemon_request *r;
// Parse elements
char *key, *delay, *ip, *port, *proto, *begin, *end;
/* cmd version: */
int argc;
char **argv;
int dl_sock;
struct sockaddr_in dl_addr;
struct file_cache *file;
int local_file;
int nb_received;
file_size_t nb_received_sum;
char buffer[BUFFSIZE];
int nb_written;
char *full_path;
char error_buffer[BUFFSIZE];
r = (struct daemon_request *) arg;
if (!r)
return NULL;
/*
* cmd is supposedly:
* ready KEY DELAY IP PORT PROTOCOL BEGINNING END
*/
argv = cmd_to_argc_argv (r->cmd, &argc);
if (argc < 8) {
cmd_free (argv);
sprintf (error_buffer,
"error %s: Invalid number of arguments",
__FUNCTION__);
daemon_send (r->daemon, error_buffer);
return NULL;
}
key = argv[1];
delay = argv[2];
ip = argv[3];
port = argv[4];
proto = argv[5];
begin = argv[6];
end = argv[7];
/* TODO&FIXME: We should use all above arguments */
if ((dl_sock = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
log_failure (log_file, "daemon_request_ready (): socket () failed");
return NULL;
}
dl_addr.sin_family = AF_INET;
if (inet_pton (AF_INET, ip, &dl_addr.sin_addr) < 1) {
log_failure (log_file, "dr_ready: inet_pton () failed");
return NULL;
}
// TODO: Verifications on port
dl_addr.sin_port = htons (atoi (port));
file = file_cache_get_by_key (file_cache, key);
if (!file) {
log_failure (log_file, "dr_ready: file_cache_get_by_key () failed");
return NULL;
}
// TODO: Check if we actually asked for that file
// TODO: Check if file already exists
/* + 2 for '/' and '\0' */
full_path = (char *)malloc ((strlen (prefs->shared_folder)
+ strlen (file->filename)
+ 2) * sizeof (char));
sprintf (full_path, "%s/%s", prefs->shared_folder, file->filename);
// FIXME: We should not truncate the file when downloading it by blocks
local_file = open (full_path,
O_WRONLY | O_TRUNC | O_CREAT,
(mode_t)0644);
//free (full_path);
if (local_file < 0) {
log_failure (log_file,
"dr_ready: open () failed, error: %s",
strerror (errno));
return NULL;
}
if (connect (dl_sock, (struct sockaddr *)&dl_addr, sizeof (dl_addr)) < 0) {
log_failure (log_file,
"dr_ready: connect () failed, error: %s",
strerror (errno));
return NULL;
}
/*
* Downloading the file
*/
/* Let's upload the download queue */
struct dl_file *f;
f = dl_file_new (full_path, file->size);
if (!f) {
log_failure (log_file, "struct dl_file is NULL :(");
goto out;
}
sem_wait (&downloads_lock);
downloads = dl_file_add (downloads, f);
if (!downloads) {
log_failure (log_file,
"Could not add the file to the download queue\n");
goto out;
}
sem_post (&downloads_lock);
nb_received_sum = 0;
// FIXME: nb_received_sum should be compared to end - begin
sleep (2);
while (nb_received_sum < file->size) {
log_failure (log_file,
"DBG %d %d",
nb_received_sum,
file->size);
nb_received = recv (dl_sock, buffer, BUFFSIZE, 0);
if (nb_received < 0) {
log_failure (log_file,
"dr_ready: recv () failed");
return NULL;
}
nb_received_sum += nb_received;
while (nb_received) {
nb_written = write (local_file, buffer, nb_received);
if (nb_written < 0) {
log_failure (log_file,
"dr_ready: write () failed");
return NULL;
}
nb_received -= nb_written;
}
}
/*
* Releasing the file from the download queue
*/
sem_wait (&downloads_lock);
downloads = dl_file_remove (downloads, f);
dl_file_free (f);
sem_post (&downloads_lock);
log_success (log_file,
"dr_ready: Received block completely %s",
full_path);
close (dl_sock);
close (local_file);
out:
if (full_path)
free (full_path);
if (argv)
cmd_free (argv);
return NULL;
}
static void
server_stop (int sig) {
struct client *c;
struct daemon *d;
pool_destroy (slow_pool);
pool_destroy (fast_pool);
pool_destroy (clients_pool);
pool_destroy (daemons_pool);
(void) sig;
log_failure (log_file, "Ok, received a signal");
sleep (2);
sem_destroy (&clients_lock);
sem_destroy (&daemons_lock);
sem_destroy (&file_cache_lock);
sem_destroy (&downloads_lock);
if (clients) {
while (clients) {
c = clients->next;
client_free (clients);
clients = c;
}
log_success (log_file,
"%s : all clients have been freed",
__func__);
}
if (daemons) {
while (daemons) {
d = daemons->next;
daemon_send (daemons, "quit\n");
daemon_free (daemons);
daemons = d;
}
log_success (log_file,
"%s : all daemons have been freed",
__func__);
}
if (file_cache) {
file_cache_free (file_cache);
log_success (log_file,
"%s : file cache has been freed",
__func__);
}
if (unlink (prefs->lock_file) < 0)
if (log_file)
log_failure (log_file, "Could not destroy the lock file");
if (prefs) {
conf_free (prefs);
log_success (log_file,
"%s : Preferences have been freed.",
__func__);
}
if (log_file) {
log_success (log_file, "Stopping server, waiting for SIGKILL");
fclose (log_file);
}
exit (EXIT_SUCCESS);
}
static void
start_server (void) {
int client_sd;
int daemon_sd;
int connected_sd;
struct sockaddr_in client_sa;
struct sockaddr_in daemon_sa;
struct sockaddr_in connected_sa;
socklen_t size;
fd_set socket_set;
int nfds;
struct ifreq if_info;
struct sockaddr_in *if_addr;
char addr[INET_ADDRSTRLEN];
struct client *c;
struct daemon *d;
struct parsed_cmd *pcmd = NULL;
char *ident_msg;
int port;
char *colon;
/* Prepare all the threads */
slow_pool = NULL;
fast_pool = NULL;
clients_pool = NULL;
daemons_pool = NULL;
ABORT_IF (!(slow_pool = pool_create (prefs->nb_proc)),
"Unable to create slow_pool")
ABORT_IF (!(fast_pool = pool_create (prefs->nb_proc)),
"Unable to create fast_pool")
ABORT_IF (!(clients_pool = pool_create (prefs->max_clients)),
"Unable to create clients_pool")
ABORT_IF (!(daemons_pool = pool_create (prefs->max_daemons)),
"Unable to create daemons_pool")
/* Create the shared directory if it does not exist already */
ABORT_IF (create_dir (prefs->shared_folder, (mode_t)0755) < 0,
"Unable to create shared directory")
/* Initialize global pointers and their semaphores */
clients = NULL;
ABORT_IF (sem_init (&clients_lock, 0, 1) < 0,
"Unable to sem_init clients_lock")
daemons = NULL;
ABORT_IF (sem_init (&daemons_lock, 0, 1) < 0,
"Unable to sem_init daemons_lock")
file_cache = NULL;
ABORT_IF (sem_init (&file_cache_lock, 0, 1) < 0,
"Unable to sem_init file_cache_lock")
list_client = NULL;
ABORT_IF (sem_init (&list_lock, 0, 1) < 0,
"Unable to sem_init list_lock")
downloads = NULL;
ABORT_IF (sem_init (&downloads_lock, 0, 1) < 0,
"Unable to sem_init download_queue_lock")
client_sa.sin_family = AF_INET;
client_sa.sin_addr.s_addr = INADDR_ANY;
client_sa.sin_port = htons (prefs->client_port);
client_sd = socket_init (&client_sa);
ABORT_IF (client_sd < 0,
"Unable to socket_init client_sd")
daemon_sa.sin_family = AF_INET;
daemon_sa.sin_addr.s_addr = INADDR_ANY;
daemon_sa.sin_port = htons (prefs->daemon_port);
daemon_sd = socket_init (&daemon_sa);
ABORT_IF (daemon_sd < 0,
"Unable to socket_init daemon_sd")
#if 1
/* We get our ip */
memcpy (if_info.ifr_name, prefs->interface, strlen (prefs->interface) + 1);
if (ioctl (daemon_sd, SIOCGIFADDR, &if_info) == -1) {
log_failure (log_file, "Can't get my ip from interface");
log_failure (log_file, "LOL ERRNO : %s\n", strerror (errno));
goto abort;
}
if_addr = (struct sockaddr_in *)&if_info.ifr_addr;
inet_ntop (AF_INET, &if_addr->sin_addr, my_ip, INET_ADDRSTRLEN);
log_success (log_file, "Found my IP : %s", my_ip);
#endif
/* socket_set contains both client_sd and daemon_sd */
FD_ZERO (&socket_set);
size = sizeof (connected_sa);
nfds = NFDS (client_sd, daemon_sd);
for (;;) {
/*
* It is VERY important to FD_SET at each loop, because select
* will FD_UNSET the socket descriptors
*/
FD_SET (client_sd, &socket_set);
FD_SET (daemon_sd, &socket_set);
/* Block until a socket is ready to accept */
if (select (nfds, &socket_set, NULL, NULL, NULL) < 0) {
log_failure (log_file, "main () : select failed");
}
if (FD_ISSET (client_sd, &socket_set)) {
if ((connected_sd = (accept (client_sd,
(struct sockaddr *) &connected_sa,
&size))) < 0) {
log_failure (log_file, "Failed to accept incoming connection.");
break;
}
/* Can we handle this client? */
if (client_count () > prefs->max_clients) {
socket_sendline (connected_sd, " < Too many clients\n");
goto close_socket;
}
/* Then, let's handle him */
if (!inet_ntop (AF_INET, &connected_sa.sin_addr,
addr, INET_ADDRSTRLEN)) {
socket_sendline (connected_sd, " < Oops\n");
goto close_socket;
}
if (!(c = client_new (connected_sd, addr))) {
socket_sendline (connected_sd, " < Sorry pal :(\n");
}
pool_queue (clients_pool, handle_client, c);
}
else if (FD_ISSET (daemon_sd, &socket_set)) {
if ((connected_sd = (accept (daemon_sd,
(struct sockaddr *) &connected_sa,
&size))) < 0) {
log_failure (log_file, "Failed to accept incoming connection.");
break;
}
/* Can we handle this daemon? */
if (daemon_count () > prefs->max_daemons) {
socket_sendline (connected_sd, " < Too many daemons\n");
goto close_socket;
}
/* Let's identify him first */
ident_msg = socket_try_getline (connected_sd,
IDENTIFICATION_TIMEOUT);
if (!ident_msg) {
socket_sendline (connected_sd,
"error: identification timed out\n");
goto close_socket;
}
if (cmd_parse_failed ((pcmd = cmd_parse (ident_msg, NULL)))) {
pcmd = NULL;
goto close_socket;
}
if (pcmd->argc < 2)
goto close_socket;
if (strcmp (pcmd->argv[0], "neighbour") != 0)
goto close_socket;
if (!(colon = strchr (pcmd->argv[1], ':')))
goto close_socket;
port = atoi (colon + 1);
free (ident_msg);
cmd_parse_free (pcmd);
pcmd = NULL;
if (!inet_ntop (AF_INET, &connected_sa.sin_addr,
addr, INET_ADDRSTRLEN)) {
socket_sendline (connected_sd, " < Oops\n");
goto close_socket;
}
/* Now we've got his port, let him go in */
if (!(d = daemon_new (connected_sd, addr, port))) {
socket_sendline (connected_sd, " < Sorry pal :(\n");
goto close_socket;
}
pool_queue (daemons_pool, handle_daemon, d);
}
else {
/* This should never happen : neither client nor daemon!? */
log_failure (log_file, "Unknown connection");
}
continue;
close_socket:
if (pcmd) {
cmd_parse_free (pcmd);
pcmd = NULL;
}
close (connected_sd);
}
abort:
if (slow_pool)
pool_destroy (slow_pool);
if (fast_pool)
pool_destroy (fast_pool);
if (clients_pool)
pool_destroy (clients_pool);
if (daemons_pool)
pool_destroy (daemons_pool);
conf_free (prefs);
exit (EXIT_FAILURE);
}
void daemonize (void) {
int lock;
char str[10];
switch (fork ()) {
case -1:
exit (1);
case 0:
fclose (log_file);
if (prefs)
conf_free (prefs);
exit (0);
break;
default:
break;
}
setsid ();
log_success (log_file, "setsid ok");
close (STDIN_FILENO);
close (STDOUT_FILENO);
close (STDERR_FILENO);
log_success (log_file, "Closed stdin, stdout, stderr.");
umask (027);
log_success (log_file, "Set file permissions to 750.");
lock = open (prefs->lock_file, O_RDWR | O_CREAT, 0640);
if (lock < 0) {
log_failure (log_file,
"Failed to open lock file (%s).",
prefs->lock_file);
}
else
log_success (log_file, "Opened lock file (%s).", prefs->lock_file);
if (lockf (lock, F_TLOCK, 0) < 0) {
log_failure (log_file, "Could not lock %s", prefs->lock_file);
}
sprintf (str, "%d\n", getpid ());
write (lock, str, strlen (str));
if (close (lock) < 0) {
log_failure (log_file,
"Failed to close LOCK_FILE (%s).",
prefs->lock_file);
}
else
log_success (log_file, "Created lock file (%s)", prefs->lock_file);
sigset_t mask;
sigemptyset (&mask);
sigaddset (&mask, SIGCHLD);
sigaddset (&mask, SIGTSTP);
sigaddset (&mask, SIGTTOU);
sigaddset (&mask, SIGTTIN);
sigprocmask (SIG_BLOCK, &mask, NULL);
struct sigaction on_signal;
sigemptyset (&on_signal.sa_mask);
on_signal.sa_flags = 0;
on_signal.sa_handler = signal_handler;
sigaction (SIGHUP, &on_signal, NULL);
on_signal.sa_handler = server_stop;
sigaction (SIGINT, &on_signal, NULL);
sigaction (SIGTERM, &on_signal, NULL);
log_success (log_file, "Signals deferred or handled.");
}
void logWindow::appendText(const char* str){
//PERR("append Text");
logText->append(str);
emit log_success();
}