void recursive_add_files(char* dir_path, struct queue_head* file_queue){
fprintf(stderr,"Reading directory path %s\n",dir_path);
DIR* dir = opendir(dir_path);
struct dirent * f;
while((f = readdir(dir))!=NULL){
if(strcmp(".",f->d_name) == 0 || strcmp("..",f->d_name) == 0 || f->d_name[0] == '.')
continue;
char path[MAX_FILE_NAME];
int len = snprintf(path,sizeof(path)-1,"%s/%s",dir_path,f->d_name);
path[len]='\0';
if(f->d_type == DT_DIR) {
recursive_add_files(path,file_queue);
continue;
}
if(!DT_REG == f->d_type){
continue;
}
char* file_path = strndup(path,MAX_FILE_NAME);
struct queue* node = queue_create_node(file_path,strlen(file_path)+1);
queue_prepend(file_queue,node);
}
closedir(dir);
}
int minisocket_receive(minisocket_t *socket, char *msg, int max_len, minisocket_error *error) {
if (socket == NULL || msg == NULL || max_len < 0) {
*error = SOCKET_INVALIDPARAMS;
return -1;
}
if (socket->state == CLOSED) {
*error = SOCKET_RECEIVEERROR;
return -1;
}
if (max_len == 0) {
return 0;
}
int received = 0;
while (!received) {
semaphore_P(socket->datagrams_ready);
network_interrupt_arg_t *interrupt_message = NULL;
interrupt_level_t old_level = set_interrupt_level(DISABLED);
queue_dequeue(socket->incoming_data, (void **) &interrupt_message);
set_interrupt_level(old_level);
if (interrupt_message != NULL) {
mini_header_reliable_t* received_header = (mini_header_reliable_t *) interrupt_message->buffer;
network_address_t temp_address;
unpack_address(received_header->source_address, temp_address);
if (socket->remote_port_number == unpack_unsigned_short(received_header->source_port) &&
network_compare_network_addresses(socket->remote_address, temp_address) != 0 &&
received_header->message_type == MSG_ACK && interrupt_message->size > sizeof(mini_header_reliable_t)) {
//same address, same ports, right message
received = 1;
int data_left = interrupt_message->size - sizeof(mini_header_reliable_t) - socket->next_read;
interrupt_level_t old_level = set_interrupt_level(DISABLED);
if (data_left <= max_len) {
memcpy(msg, interrupt_message->buffer + sizeof(mini_header_reliable_t) + socket->next_read, data_left);
socket->next_read = 0;
free(interrupt_message);
set_interrupt_level(old_level); // must protect global data field next_read
return data_left;
}
else {
memcpy(msg, interrupt_message->buffer + sizeof(mini_header_reliable_t) + socket->next_read, max_len);
socket->next_read += max_len;
queue_prepend(socket->incoming_data, interrupt_message); //ack works as well when there is data
semaphore_V(socket->datagrams_ready); //another message in queue, V semaphore
set_interrupt_level(old_level);
return max_len;
}
}
else {
free(interrupt_message);
}
}
}
return -1;
}
struct queue* find_file_paths(void* obj, int id, void* priv, struct queue_head* in_q,struct queue_head* file_queue)
{
char* read_from = priv;
// add files to file_queue
if(strcmp(read_from,"-") == 0) { // read a list of files from stdin
char* filename = NULL;
size_t sz = 1024;
while(getline(&filename,&sz,stdin) > 0 ) {
int l = strlen(filename);
// printf("file [%s] last char[%c]\n",filename,filename[l-1]);
//Remove new line
if(filename[l-1] == '\n') {
filename[l-1] = '\0';
}
char* f = strdup(filename);
int fl = strlen(f);
struct queue* node = queue_create_node(f,fl+1);
queue_prepend(file_queue,node);
}
} else{
struct stat file_info;
if(stat(read_from,&file_info)!=0) {
fprintf(stderr, "Couldnt locate file %s\n",read_from);
perror("fstat");
return NULL;
}
if(S_ISDIR(file_info.st_mode)){
recursive_add_files(read_from,file_queue);
} else { //regular file
struct queue* node = queue_create_node(read_from,strlen(read_from)+1);
queue_prepend(file_queue,node);
}
}
// we are done filling this queue
queue_mark_finish_filling(file_queue);
return NULL;
}
/*
* Return the first item from the highest level that is not higher
* than the specified level - just like dequeue, with the exception
* that the item remains in the queue.
* Return 0 (success) and the dequeued item if the multilevel queue is
* valid and nonempty.
* Return -1 (failure) and NULL if the multilevel queue is invalid or
* empty.
*/
int multilevel_queue_peak(multilevel_queue_t obj, int level, any_t* item_p) {
any_t item = NULL;
int ret = queue_dequeue(obj->levels[level], &item);
while ( (level < (obj->num - 1)) && -1 == ret ) {
level++;
ret = queue_dequeue(obj->levels[level], &item);
}
if ( ret != -1 ) {
queue_prepend(obj->levels[level], item);
*item_p = item;
}
return ret;
}
/****************************************************************
Key press for source
*****************************************************************/
static gboolean src_key_press_callback(GtkWidget *w, GdkEventKey *ev,
gpointer data)
{
struct worklist_data *ptr;
ptr = data;
if (!gtk_widget_is_sensitive(ptr->dst_view)) {
return FALSE;
}
if ((ev->state & GDK_SHIFT_MASK) && ev->keyval == GDK_KEY_Insert) {
queue_prepend(ptr);
return TRUE;
} else if (ev->keyval == GDK_KEY_Insert) {
queue_append(ptr);
return TRUE;
} else {
return FALSE;
}
}
void interrupt_handler(void* arg)
{
// disable interrupts
interrupt_level_t prev_int_level = set_interrupt_level(DISABLED);
int context_switch_ret;
alarm_t next_alarm;
ticks++;
// Trigger any alarms that need to be triggered
if (queue_length(alarm_queue) > 0)
{
do
{
next_alarm = NULL; // not necessary, but included for clarity
queue_dequeue(alarm_queue, (void**) &next_alarm);
if (next_alarm != NULL)
{
if (next_alarm->tick_time <= ticks)
{
//minithread_fork((proc_t) next_alarm->func, next_alarm->arg);
(next_alarm->func)(next_alarm->arg);
free(next_alarm);
}
else
{
queue_prepend(alarm_queue, next_alarm);
}
}
} while (next_alarm != NULL && next_alarm->tick_time <= ticks);
}
// If our time at this level of the multilevel queue is up
if (--ticks_until_next_level == 0)
{
// Recalculate the current level
current_level = (current_level + 1 ) % 4;
// Set the length of time we have to spend at the next level
switch (current_level)
{
case 0:
ticks_until_next_level = 80;
break;
case 1:
ticks_until_next_level = 40;
break;
case 2:
ticks_until_next_level = 24;
break;
case 3:
ticks_until_next_level = 16;
break;
}
}
// If the running thread has exceeded its allocated quanta
if (--ticks_until_switch == 0)
{
// Decrement (or really increment) its priority, if its not lowest yet
if (running->priority < 3)
{
running->priority++;
}
// Attempt a context switch - add to ready queue, can switch to idle
context_switch_ret = minithread_context_switch(1, 1);
if (context_switch_ret == -1) // Check if the next thread is "running"
{
// If so, no need to context switch
ticks_until_switch = minithread_get_priority_quanta(running->priority);
}
}
// set interrupts back to previous value
set_interrupt_level(prev_int_level);
}
queue_t
*read_rbfsum2 (char *buffer)
{
queue_t *list = NULL;
char *tmp = buffer;
char *name;
char *start, *end;
char *file_line;
char *line;
rbfsum_t rb;
unsigned int id;
station_data_t *data;
while (*tmp)
{
file_line = get_line (tmp);
if (!file_line)
{
tmp = next_line (tmp);
continue;
}
if (*file_line == '/')
{
start = strrchr (file_line, '/');
start++;
end = strrchr (start, '.');
if (!end)
{
tmp = next_line (tmp);
continue;
}
name = xstrndup (start + 1, end - start - 1);
free (file_line);
tmp = next_line (tmp);
if (*tmp == '\0')
{
free (name);
break;
}
tmp = next_line (tmp);
if (*tmp == '\0')
{
free (name);
break;
}
data = malloc (sizeof(station_data_t));
data->name = name;
id = 0;
while ((line = get_line (tmp)))
{
if (parse_data (line, &rb))
{
memcpy (&data->rs[id], &rb, sizeof(rb));
id++;
}
free (line);
tmp = next_line (tmp);
}
data->ndata = id;
list = queue_prepend (list, data);
}
tmp = next_line (tmp);
}
list = queue_sort (list, comp_func);
return list;
}
int main(){
int counter;
int arraya[5] = {1,2,3,4,5};
int arrayb[] = {3,4,5};
int arrayc[] = {2,4,5};
int* inty = malloc(sizeof(int *));
int** item1 = malloc(sizeof(int **));
int** item2 = malloc(sizeof(int **));
int iny = 3;
queue_t queue = queue_new();
printf("prepend prior\n");
queue_prepend(queue, &iny);
printf("prepend post\n");
int inty1 = 2;
queue_prepend(queue, &inty1);
printf("prepend post\n");
int inty2 = 1;
queue_prepend(queue, &inty2);
int inty3 = 4;
queue_append(queue, &inty3);
printf("prepend post\n");
int inty4 = inty3+1;
queue_append(queue, &inty4);
if (test(queue,arraya,5) == 0){
printf("test 1 PASSED\n");
}
else {
printf("test 1 FAILED\n");
}
queue_dequeue(queue,(void **)item1);
queue_dequeue(queue,(void **)item2);
if (test(queue,arrayb,3) == 0 && **item1 == 1 && **item2 == 2){
printf("test 2 PASSED\n");
}
else {
printf("test 2 FAILED\n");
}
queue_prepend(queue, &inty1);
*inty = 0;
queue_iterate(queue,iter_tester,(void *)inty);
if (*inty == 14){
printf("test 3 PASSED\n");
}
else{
printf("test 3 FAILED, total = %i\n",*inty);
}
queue_delete(queue, &iny);
if (test(queue,arrayc,3) == 0){
printf("test 4 PASSED\n");
}
else {
printf("test 4 FAILED\n");
}
queue_t q = queue_new();
for(counter=0;counter<100;counter++){
printf("Index %i\n",counter);
queue_append(q,&counter);
}
if (q->length = 100){
printf("test 5 PASSED\n");
}
else {
printf("test 5 FAILED\n");
}
queue_free(q);
queue_free(queue);
free(inty);
free(item1);
free(item2);
}
int minisocket_receive(minisocket_t *socket, char *msg, int max_len, minisocket_error *error)
{
if (socket->socket_state == CLOSED || socket->socket_state == CLOSING) {
*error=SOCKET_RECEIVEERROR;
return 0;
}
if (socket->socket_state != OPEN || !msg) {
*error = SOCKET_INVALIDPARAMS;
return -1;
}
if(max_len == 0)
{
*error = SOCKET_NOERROR;
return 0;
}
semaphore_P(socket->send_receive_mutex);
semaphore_P(socket->data_ready);
if (socket->socket_state == CLOSED || socket->socket_state == CLOSING) {
*error=SOCKET_RECEIVEERROR;
return 0;
}
network_interrupt_arg_t *arg;
queue_dequeue(socket->data, (void **) &arg);
int msg_len = arg->size - sizeof(mini_header_reliable_t);
assert(msg_len > 0);
int copy_len = ( msg_len > max_len) ? max_len : msg_len;
for(int i=0;i<copy_len;i++)
{
msg[i] = arg->buffer[sizeof(mini_header_reliable_t) + i];
}
//If the packet contained more data than the buffer could take, then enqueue the packet with the remaining message again
if(copy_len > max_len)
{
mini_header_reliable_t *h = (mini_header_reliable_t *) malloc(sizeof(mini_header_reliable_t));
if(!h)
{
*error = SOCKET_OUTOFMEMORY;
semaphore_V(socket->send_receive_mutex);
return -1;
}
mini_header_reliable_t *header = (mini_header_reliable_t *) arg->buffer;
//Update the sequence number in the header
unsigned int seq_no = unpack_unsigned_int(header->seq_number);
pack_unsigned_int(header->seq_number, seq_no + max_len);
//Copy the remaining message to the start of the message space in the buffer
memcpy(arg->buffer + sizeof(mini_header_reliable_t), arg->buffer + sizeof(mini_header_reliable_t) + max_len, msg_len - max_len);
//Set the packet size to its correct length
arg->size = msg_len + sizeof(mini_header_reliable_t);
//Prepend the packet in the data queue
queue_prepend(socket->data, &arg);
}
semaphore_V(socket->send_receive_mutex);
return copy_len;
}
