comandi.c

Vai alla documentazione di questo file.
00001 
00012 #include "Include/comandi.h"
00013 
00014 /* Funzioni ad uso e consumo della sola funzione 'thread_servente' */
00015 
00033 static int msg_mkdir(message_t *msg);
00034 
00054 static int msg_ls(message_t *msg);
00055 
00073 static int msg_mkfile(message_t *msg);
00074 
00099 static int msg_fread(message_t *msg);
00100 
00123 static int msg_fwrite(message_t *msg);
00124 
00125 void *thread_servernte(void * sk){
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 }
00182 
00183 static int msg_mkdir(message_t *msg){
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 }
00203 
00204 static int msg_ls(message_t *msg){
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 }
00229 
00230 static int msg_mkfile(message_t *msg){
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 }
00250 
00251 static int msg_fread(message_t *msg){
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 }
00287 
00288 static int msg_fwrite(message_t *msg){
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 }
00313 
Generato il Fri Jan 28 22:16:29 2011 per SFAT: Simplified File Allocation Table Project da  doxygen 1.6.3