#include "Include/comandi.h"
#include <signal.h>
#include <pthread.h>
#include "common.h"
#include "lista.h"
#include "../../../Fat/Src/Include/fat.h"
#include "../../../Fat/Src/Include/list.h"
#include "../../../Fat/Src/Include/make_dir.h"
#include "../../../Fat/Src/Include/open_fat.h"
#include "../../../Fat/Src/Include/write_fat.h"
#include "../../../Fat/Src/Include/read_fat.h"
#include "../../../Fat/Src/Include/sfaterror.h"
Vai al codice sorgente di questo file.
Funzioni | |
static int | msg_mkdir (message_t *msg) |
static int | msg_ls (message_t *msg) |
static int | msg_mkfile (message_t *msg) |
static int | msg_fread (message_t *msg) |
static int | msg_fwrite (message_t *msg) |
void * | thread_servernte (void *sk) |
This program is free software; you can redistribuite it and/or modify it under the terms of the GNU/General Pubblic License as published the Free software Foundation; either version 2 of the License, or (at your opinion) any later version.
Definizione nel file comandi.c.
static int msg_mkdir | ( | message_t * | msg | ) | [static] |
Gestisce l'esecuzione del messaggio di creazione directory inviato dal client, eseguendo la funzione "fat_mkdir" della libreria sfat e controllando il valore di ritorno della funzione. A seconda del valore di ritorno della funzione "fat_mkdir", verra', in caso di errore, invocata la funzione "sfaterror" della libreria sfat.
Altrimenti la funzione creera' un messaggio di type "MSG_OK", con buffer nullo e lenght 0.
Un mutex posto sulla chiamata della funzione "fat_mkdir", assicura che non si verifichino problemi di race condiction.
msg | puntatore alla struttura messagge_t |
Definizione alla linea 183 del file comandi.c.
00183 { 00184 extern FILE * fs; 00185 extern struct fat_ctrl f_ctrl; 00186 extern pthread_mutex_t filesystem; 00187 int ret_val=0; 00188 00189 pthread_mutex_lock(&filesystem); 00190 ret_val = fat_mkdir(fs, &f_ctrl, msg->buffer); 00191 pthread_mutex_unlock(&filesystem); 00192 00193 if (msg->buffer) free(msg->buffer); 00194 msg->length = 0; 00195 msg->buffer = NULL; 00196 if (ret_val){ 00197 sfaterror(ret_val); 00198 msg->type = MSG_ERROR; 00199 }else msg->type = MSG_OK; 00200 00201 return ret_val; 00202 }
static int msg_ls | ( | message_t * | msg | ) | [static] |
Gestisce l'esecuzione del messaggio di listing directory inviato dal client, eseguendo la funzione "fat_ls" della libreria sfat e controllando il valore di ritorno della funzione. A seconda del valore di ritorno della funzione "fat_ls", verra', in caso di errore, invocata la funzione "sfaterror" della libreria sfat.
Altrimenti la funzione creera' un messaggio di type "MSG_OK".
Il buffer sara' una stringa che e' la lista delle subdirectory e dei file contenuti all'interno di in una cartella di cui si e' richiesto la list.
Lenght sara' pari alla lunghezza di questa stringa.
Un mutex posto sulla chiamata della funzione "fat_ls", assicura che non si verifichino problemi di race condiction.
msg | puntatore alla struttura messagge_t |
Definizione alla linea 204 del file comandi.c.
00204 { 00205 extern FILE * fs; 00206 extern struct fat_ctrl f_ctrl; 00207 extern pthread_mutex_t filesystem; 00208 char *list=NULL; 00209 int ret_val=0; 00210 00211 pthread_mutex_lock(&filesystem); 00212 ret_val = fat_ls(fs, &f_ctrl, msg->buffer, &list); 00213 pthread_mutex_unlock(&filesystem); 00214 00215 if (msg->buffer) free(msg->buffer); 00216 if (ret_val){ 00217 if (list) free(list); 00218 sfaterror(ret_val); 00219 msg->type = MSG_ERROR; 00220 msg->length = 0; 00221 msg->buffer = NULL; 00222 }else{ 00223 msg->type = MSG_OK; 00224 msg->length = strlen(list); 00225 msg->buffer = list; 00226 } 00227 return ret_val; 00228 }
static int msg_mkfile | ( | message_t * | msg | ) | [static] |
Gestisce l'esecuzione del messaggio di creazione file inviato dal client, eseguendo la funzione "fat_open" della libreria sfat e controllando il valore di ritorno della funzione. A seconda del valore di ritorno della funzione "fat_open", verra', in caso di errore, invocata la funzione "sfaterror" della libreria sfat.
Altrimenti la funzione creera' un messaggio di type "MSG_OK", con buffer nullo e lenght 0.
Un mutex posto sulla chiamata della funzione "fat_ls", assicura che non si verifichino problemi di race condiction.
msg | puntatore alla struttura messagge_t |
Definizione alla linea 230 del file comandi.c.
00230 { 00231 extern FILE * fs; 00232 extern struct fat_ctrl f_ctrl; 00233 extern pthread_mutex_t filesystem; 00234 int ret_val=0; 00235 00236 pthread_mutex_lock(&filesystem); 00237 ret_val = fat_open(fs, &f_ctrl, msg->buffer); 00238 pthread_mutex_unlock(&filesystem); 00239 00240 if (msg->buffer) free(msg->buffer); 00241 msg->length = 0; 00242 msg->buffer = NULL; 00243 if (ret_val){ 00244 sfaterror(ret_val); 00245 msg->type = MSG_ERROR; 00246 }else msg->type = MSG_OK; 00247 00248 return ret_val; 00249 }
static int msg_fread | ( | message_t * | msg | ) | [static] |
Gestisce l'esecuzione del messaggio di creazione file inviato dal client, eseguendo la funzione "fat_read" della libreria sfat e controllando il valore di ritorno della funzione.
La funzione si occupa anche di interpretare il buffer del messaggio ricevuto dal server, scindendolo in tre parti:
A seconda del valore di ritorno della funzione "fat_read", verra', in caso di errore, invocata la funzione "sfaterror" della libreria sfat.
Altrimenti la funzione creera' un messaggio di type "MSG_OK", il buffer sara' una stringa contenente i dati letti dal file, mentre lenght sara' la lunghezza di questa stringa.
Un mutex posto sulla chiamata della funzione "fat_ls", assicura che non si verifichino problemi di race condiction.
msg | puntatore alla struttura messagge_t |
Definizione alla linea 251 del file comandi.c.
00251 { 00252 extern FILE * fs; 00253 extern struct fat_ctrl f_ctrl; 00254 extern pthread_mutex_t filesystem; 00255 int start=0, data_len=0, ret_val=0; 00256 char *data=NULL, *path=NULL, *temp=NULL; 00257 00258 /* Memorizzo l'indirizzo di partenza */ 00259 memcpy(&start, msg->buffer, sizeof(int)); 00260 /* Memorizzo la path del file da leggere */ 00261 path = msg->buffer + sizeof(int) + 1; 00262 /* Memorizzo la dimensione dei dati da leggere */ 00263 temp = path + strlen(path) + 1; 00264 memcpy(&data_len, temp, sizeof(int)); 00265 /* Alloco la memoria per i dati da leggere, 00266 * "+ 1" perche' termino la stringa */ 00267 data = calloc(data_len+1, sizeof(char)); 00268 00269 pthread_mutex_lock(&filesystem); 00270 ret_val = fat_read(fs, &f_ctrl, path, start, data_len, data); 00271 pthread_mutex_unlock(&filesystem); 00272 00273 if (msg->buffer) free(msg->buffer); 00274 if (ret_val<0){ 00275 if (data) free(data); 00276 sfaterror(ret_val); 00277 msg->type = MSG_ERROR; 00278 msg->length = 0; 00279 msg->buffer = NULL; 00280 }else{ 00281 msg->type = MSG_OK; 00282 msg->length = strlen(data); 00283 msg->buffer = data; 00284 } 00285 return ret_val; 00286 }
static int msg_fwrite | ( | message_t * | msg | ) | [static] |
Gestisce l'esecuzione del messaggio di scrittura su file inviato dal client, eseguendo la funzione "fat_write" della libreria sfat e controllando il valore di ritorno della funzione.
La funzione si occupa anche di interpretare il buffer del messaggio ricevuto dal server, scindendolo in due pezzi, la path del file in cui scrivere e "data", ovvero i dati che bisogna scrivere nel file stesso.
A seconda del valore di ritorno della funzione "fat_write", verra', in caso di errore, invocata la funzione "sfaterror" della libreria sfat.
Altrimenti la funzione creera' un messaggio di type "MSG_OK", con buffer nullo e lenght 0.
Un mutex posto sulla chiamata della funzione "fat_ls", assicura che non si verifichino problemi di race condiction.
msg | puntatore alla struttura messagge_t |
Definizione alla linea 288 del file comandi.c.
00288 { 00289 extern FILE * fs; 00290 extern struct fat_ctrl f_ctrl; 00291 extern pthread_mutex_t filesystem; 00292 int ret_val=0, data_len=0; 00293 char *path=NULL, *data=NULL; 00294 00295 path = msg->buffer; 00296 data = strchr(msg->buffer, '\0') + 1; 00297 data_len = strlen(data); 00298 00299 pthread_mutex_lock(&filesystem); 00300 ret_val = fat_write(fs, &f_ctrl, path, data, data_len); 00301 pthread_mutex_unlock(&filesystem); 00302 00303 if (msg->buffer) free(msg->buffer); 00304 msg->length = 0; 00305 msg->buffer = NULL; 00306 if (ret_val){ 00307 sfaterror(ret_val); 00308 msg->type = MSG_ERROR; 00309 }else msg->type = MSG_OK; 00310 00311 return ret_val; 00312 }
void* thread_servernte | ( | void * | ) |
Thread delegato all'esecuzione dei messaggi mandati dai client
Definizione alla linea 125 del file comandi.c.
00125 { 00126 extern struct lista my_socket; 00127 extern pthread_mutex_t lock; 00128 extern pthread_cond_t wait_me; 00129 extern int num_threads; 00130 sigset_t set; 00131 channel_t sk_cl; 00132 message_t msg; 00133 int recive_val=0; 00134 00135 sk_cl = *(int *)sk; 00136 msg.buffer = NULL; 00137 00138 /* Blocco i segnali */ 00139 if (sigfillset(&set) == -1){ 00140 errore(__FILE__,__LINE__,"Server: error sigfillset",errno); 00141 return 0; 00142 } 00143 if (pthread_sigmask(SIG_SETMASK, &set, NULL) != 0) { 00144 errore(__FILE__,__LINE__,"Server: pthread_sigmask error 'sigsetmask'",errno); 00145 return 0; 00146 } 00147 00148 while (recive_val!=SEOF){ 00149 if ((recive_val = receiveMessage(sk_cl, &msg)) == -1) break; 00150 else if (recive_val != SEOF){ /* !SIGPIPE */ 00151 switch(msg.type){ 00152 case MSG_MKDIR: 00153 msg_mkdir(&msg); 00154 break; 00155 case MSG_LS: 00156 msg_ls(&msg); 00157 break; 00158 case MSG_MKFILE: 00159 msg_mkfile(&msg); 00160 break; 00161 case MSG_FREAD: 00162 msg_fread(&msg); 00163 break; 00164 case MSG_FWRITE: 00165 msg_fwrite(&msg); 00166 break; 00167 } 00168 if (sendMessage(sk_cl, &msg) == -1) break; 00169 } 00170 } 00171 /* Chiudo il socket di comunicazione tra client e server */ 00172 closeSocket(sk_cl); 00173 /* Rimuovo il thread dalla lista dei thread */ 00174 pthread_mutex_lock(&lock); 00175 num_threads--; 00176 rimuovi(sk_cl, &my_socket); 00177 pthread_mutex_unlock(&lock); 00178 pthread_cond_signal(&wait_me); 00179 00180 return 0; 00181 }