Riferimenti per il file comandi.c

#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)

Descrizione dettagliata

Autore:
Tranchida Giulio, No Matricola 241732
Si dichiara che il contenuto di questo file e', in ogni sua parte, opera originale dell'autore.

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.


Documentazione delle funzioni

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.

Parametri:
msg puntatore alla struttura messagge_t
Restituisce:
ret_val, ovvero il valore ritornato dalla "fat_mkdir".

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.

Parametri:
msg puntatore alla struttura messagge_t
Restituisce:
ret_val, ovvero il valore ritornato dalla "fat_ls".

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.

Parametri:
msg puntatore alla struttura messagge_t
Restituisce:
ret_val, ovvero il valore ritornato dalla "fat_open".

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:

  • l'indirizzo di partenza in cui si inizia a leggere dal file,
  • la path del file da leggere e
  • la dimensione dei dati da leggere.

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.

Parametri:
msg puntatore alla struttura messagge_t
Restituisce:
ret_val, ovvero il valore ritornato dalla "fat_read".

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.

Parametri:
msg puntatore alla struttura messagge_t
Restituisce:
ret_val, ovvero il valore ritornato dalla "fat_write".

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 }

Generato il Fri Jan 28 22:16:29 2011 per SFAT: Simplified File Allocation Table Project da  doxygen 1.6.3