1031 lines
28 KiB
C
1031 lines
28 KiB
C
#define _POSIX_C_SOURCE 200809L
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <inttypes.h>
|
|
|
|
#include "conn.h"
|
|
#include "apiFile.h"
|
|
#include "fileQueue.h"
|
|
#include "taglialegna.h"
|
|
|
|
#define MAXLENMESS 512
|
|
#define LOGBUFSIZE 2048
|
|
|
|
#define MEOK "20" /* OK */
|
|
// #define ME "21" /* not used */
|
|
// #define ME "22" /* not used */
|
|
#define MEFP "25" /* file purged */
|
|
|
|
// #define ME "40" /* not used */
|
|
// #define ME "41" /* not used */
|
|
#define MESD "42" /* shutting down */
|
|
#define MENT "45" /* requested file action not taken */
|
|
|
|
#define MESY "50" /* syntax error */
|
|
// #define ME "51" /* not used */
|
|
// #define ME "52" /* not used */
|
|
#define MESE "55" /* server error */
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// helper functions
|
|
|
|
/* send to the client the message m and then errno */
|
|
void serror(char *m, long fd_c, taglia_t *taglia, char *mlog) {
|
|
if(!m) {
|
|
errno = EINVAL;
|
|
m = MESY;
|
|
}
|
|
if(writen(fd_c, m, strnlen(m, MAXLENMESS)) < 0) {
|
|
perror("serror: writen");
|
|
goto _serror_cleanup;
|
|
}
|
|
if(writen(fd_c, &errno, sizeof(errno)) < 0) {
|
|
perror("serror: writen");
|
|
goto _serror_cleanup;
|
|
}
|
|
|
|
if(taglia_write(taglia, mlog) < 0)
|
|
goto _serror_cleanup;
|
|
|
|
return;
|
|
|
|
_serror_cleanup:
|
|
return;
|
|
}
|
|
|
|
/* send to the client the message m */
|
|
void sendMessage(char *m, long fd_c, taglia_t *taglia, char *mlog) {
|
|
if(!m) {
|
|
m = MEOK;
|
|
}
|
|
|
|
if(writen(fd_c, m, strnlen(m, MAXLENMESS)) < 0) {
|
|
perror("sendMessage: writen");
|
|
goto _sendM_cleanup;
|
|
}
|
|
|
|
if(taglia_write(taglia, mlog) < 0)
|
|
goto _sendM_cleanup;
|
|
|
|
return;
|
|
|
|
_sendM_cleanup:
|
|
return;
|
|
}
|
|
|
|
/* send to the client the file f */
|
|
int sendFile(fileT *f, long fd_c, taglia_t *taglia) {
|
|
if(!f || !taglia) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
/* send filepath dimension, then filepath */
|
|
int64_t filepathLength = (int64_t) strnlen(f->filepath, MAXLENMESS)+1;
|
|
if (writen(fd_c, &filepathLength, sizeof(filepathLength)) < 0) {
|
|
perror("sendFile: writen");
|
|
return -1;
|
|
}
|
|
if (writen(fd_c, f->filepath, (size_t) filepathLength) < 0) {
|
|
perror("sendFile: writen");
|
|
return -1;
|
|
}
|
|
/* send file dimension, then file */
|
|
int64_t validLength = (int64_t) f->valid;
|
|
if (writen(fd_c, &validLength, sizeof(validLength)) < 0) {
|
|
perror("sendFile: writen");
|
|
return -1;
|
|
}
|
|
if(validLength != 0) { /* if file has length 0 dont write */
|
|
if (writen(fd_c, f->data, validLength) < 0) {
|
|
perror("sendFile: writen");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
char tmp_log[LOGBUFSIZE];
|
|
int n = 0;
|
|
size_t m = sizeof(tmp_log);
|
|
|
|
n += snprintf(tmp_log+n, m-n, "Inviato file \"%s\", di dimensione %"PRId64" Bytes al client %ld .\n",
|
|
f->filepath,
|
|
validLength,
|
|
fd_c);
|
|
if(taglia_write(taglia, tmp_log) < 0) {
|
|
perror("sendFile: taglia_write");
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* send to the client the message m then the file f */
|
|
void sendMessageFile(char *m, fileT *f, long fd_c, taglia_t *taglia, char *mlog) {
|
|
if(!f) {
|
|
errno = EINVAL;
|
|
char errmlog[2*LOGBUFSIZE] =
|
|
"Errore negli argomenti alla funzione sendMessagefile (fileT == NULL). "
|
|
"Messaggio originale:\n\t";
|
|
strncat(errmlog, mlog, sizeof(errmlog)-strlen(errmlog)-1);
|
|
goto _sendMF_cleanup;
|
|
serror(MESY, fd_c, taglia, errmlog);
|
|
}
|
|
if(!m) {
|
|
m = MEFP;
|
|
}
|
|
|
|
if(writen(fd_c, m, strnlen(m, MAXLENMESS)) < 0) {
|
|
perror("sendMessageFile: writen");
|
|
goto _sendMF_cleanup;
|
|
}
|
|
|
|
int64_t *n = calloc(1, sizeof(*n));
|
|
if(!n) {
|
|
perror("sendMessageFile: calloc");
|
|
goto _sendMF_cleanup;
|
|
}
|
|
*n = 1;
|
|
|
|
if(writen(fd_c, n, sizeof(int64_t)) < 0) {
|
|
perror("sendMessageFile: writen");
|
|
goto _sendMF_cleanup;
|
|
}
|
|
|
|
free(n);
|
|
|
|
if(sendFile(f, fd_c, taglia) < 0) {
|
|
perror("sendMessageFile: sendFile");
|
|
goto _sendMF_cleanup;
|
|
}
|
|
|
|
if(taglia_write(taglia, mlog) < 0) {
|
|
perror("sendMessageFile: taglia_write");
|
|
goto _sendMF_cleanup;
|
|
}
|
|
|
|
return;
|
|
|
|
_sendMF_cleanup:
|
|
return;
|
|
}
|
|
|
|
/* send to the client the message m then n files */
|
|
void sendMessageFileN(char *m, fileT **f, int64_t n, long fd_c, taglia_t *taglia, char *mlog) {
|
|
if(!f) {
|
|
errno = EINVAL;
|
|
char errmlog[2*LOGBUFSIZE] =
|
|
"Errore negli argomenti alla funzione sendMessagefile (fileT == NULL)."
|
|
" Messaggio originale:\n\t";
|
|
strncat(errmlog, mlog, sizeof(errmlog)-strlen(errmlog)-1);
|
|
serror(MESY, fd_c, taglia, errmlog);
|
|
goto _sendMFN_cleanup;
|
|
}
|
|
if(!m) {
|
|
m = MEFP;
|
|
}
|
|
|
|
if(writen(fd_c, m, strnlen(m, MAXLENMESS)) < 0) {
|
|
perror("sendMessageFileN: writen");
|
|
goto _sendMFN_cleanup;
|
|
}
|
|
|
|
if(write(fd_c, &n, sizeof(n)) < 0) {
|
|
perror("sendMessageFileN: writen");
|
|
goto _sendMFN_cleanup;
|
|
}
|
|
|
|
for(int i=0; i<n && (f[i]!=NULL); ++i) {
|
|
if(sendFile(f[i], fd_c, taglia) < 0) {
|
|
perror("sendMessageFileN: sendFile");
|
|
goto _sendMFN_cleanup;
|
|
}
|
|
}
|
|
|
|
if(taglia_write(taglia, mlog) < 0)
|
|
goto _sendMFN_cleanup;
|
|
|
|
return;
|
|
|
|
_sendMFN_cleanup:
|
|
return;
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
void openFile(char *filepath, int flags, queueT *q, long fd_c, taglia_t *taglia) {
|
|
// messaggio da scrivere sul logfile
|
|
char tmp_buf[LOGBUFSIZE];
|
|
int n = 0;
|
|
size_t m = sizeof(tmp_buf);
|
|
|
|
if(!filepath || !q || !taglia) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" e' terminata con errore\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
errno = EINVAL;
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
int found = searchFile(q, filepath); /* search the file in the queue */
|
|
int create = (flags & C_CREATE)?1:0; /* also %2 */
|
|
int lock = (flags & C_LOCK)?1:0; /* also >>1%2 */
|
|
fileT *removed = NULL; /* file that was removed */
|
|
|
|
if(found && create) { /* file found but want to create new file */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" ma il file esiste già\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
errno = EEXIST;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if(!found && !create) { /* file not found but expected */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" ma il file non esiste\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
errno = ENOENT;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if(found && !create) { /* file found */
|
|
if(openFileInQueue(q, filepath, lock, fd_c) == -1) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" e' terminato con errore del server\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
perror("openFile: openFileInQueue");
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" e' terminata con successo\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
sendMessage(MEOK, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if(!found && create) { /* not found and creating new file */
|
|
if(getLen(q) == q->maxLen) { /* capacity miss */
|
|
removed = dequeue(q);
|
|
if(!removed) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" e' terminato con errore\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
perror("openFile: dequeue");
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
/* create new file */
|
|
fileT *f = createFileT(filepath, lock, fd_c, 1);
|
|
|
|
if(!f) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" e' terminato con errore del server\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
perror("openFile: createFileT");
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if(enqueue(q, f) != 0) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" e' terminato con errore del server\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
perror("openFile: enqueue");
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
taglia_update(taglia, q, 1); /* removed only one file */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" ha causato una capacity miss. File espulso \"%s\"\n",
|
|
fd_c,
|
|
flags,
|
|
filepath,
|
|
removed->filepath);
|
|
sendMessageFile(MEFP, removed, fd_c, taglia, tmp_buf);
|
|
destroyFile(removed);
|
|
return;
|
|
}
|
|
|
|
/* no capacity miss */
|
|
fileT *f = createFileT(filepath, lock, fd_c, 1);
|
|
|
|
if(!f) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" e' terminato con errore del server\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
perror("openFile: createFileT");
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if(enqueue(q, f) != 0) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" e' terminato con errore del server\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
perror("openFile: enqueue");
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
/* added a file, the number of files changed so update the log */
|
|
taglia_update(taglia, q, 0);
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una openFile (flags = %x) sul file \"%s\" e' terminato con successo\n",
|
|
fd_c,
|
|
flags,
|
|
filepath);
|
|
sendMessage(MEOK, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
/* unreachable code */
|
|
return;
|
|
}
|
|
|
|
|
|
void readFile(char *filepath, queueT *q, long fd_c, taglia_t *taglia) {
|
|
/* message to write to the logfile */
|
|
char tmp_buf[LOGBUFSIZE];
|
|
int n = 0;
|
|
size_t m = sizeof(tmp_buf);
|
|
|
|
if(!filepath || !q || !taglia) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una readFile sul file \"%s\" e' terminata con errore del server\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = EINVAL;
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
fileT *f = NULL;
|
|
f = find(q, filepath);
|
|
if(!f) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una readFile sul file \"%s\" ma il file non esiste\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = ENOENT;
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if(f->open == 0) { /* file not already open */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una readFile sul file \"%s\" e' terminata con errore, file non aperto\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = EPERM;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
destroyFile(f); /* f is a copy so we need to cleen up */
|
|
return;
|
|
}
|
|
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una readFile sul file \"%s\" di dimensione = %ld e' terminata con successo\n",
|
|
fd_c,
|
|
filepath,
|
|
f->valid);
|
|
sendMessageFile(MEOK, f, fd_c, taglia, tmp_buf);
|
|
destroyFile(f); /* f is a copy so we need to cleen up */
|
|
return;
|
|
}
|
|
|
|
|
|
void readNFiles(int num, queueT *q, long fd_c, taglia_t *taglia) {
|
|
/* message to write to the logfile */
|
|
char tmp_buf[LOGBUFSIZE];
|
|
int n = 0;
|
|
size_t m = sizeof(tmp_buf);
|
|
|
|
if(!q || !taglia) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una readNFile (n = %d) e' terminata con errore\n",
|
|
fd_c,
|
|
num);
|
|
errno = EINVAL;
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
int oldNum = num;
|
|
int64_t ntosend = (num<=0 || num>getLen(q))? getLen(q) : num;
|
|
fileT **toSend = calloc(ntosend, sizeof(fileT *));
|
|
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una readNFile (n = %d) e' terminata con successo. File inviati:\n",
|
|
fd_c,
|
|
num);
|
|
/* extract n files, we dont check if the client can actually modify
|
|
* the files since we add them back immediatly */
|
|
size_t tot = 0;
|
|
for(int i=0;i<ntosend;++i) {
|
|
toSend[i] = dequeue(q);
|
|
if(!toSend[i]) {
|
|
n = 0;
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una readNFiles (n = %d) e' terminato con errore del server\n",
|
|
fd_c,
|
|
oldNum);
|
|
perror("readNFiles: dequeue");
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
int tmp = enqueue(q, toSend[i]);
|
|
if(tmp<0) {
|
|
n = 0;
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una readNFiles (n = %d) e' terminato con errore del server\n",
|
|
fd_c,
|
|
oldNum);
|
|
perror("readNFiles: enqueue");
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
tot += toSend[i]->valid;
|
|
n += snprintf(tmp_buf+n, m-n, "\t%d) \"%s\" dim = %ld\n",
|
|
i,
|
|
toSend[i]->filepath,
|
|
toSend[i]->valid);
|
|
}
|
|
n += snprintf(tmp_buf+n, m-n, "readNFile dimensione totale = %ld\n",
|
|
tot);
|
|
|
|
sendMessageFileN(MEOK, toSend, ntosend, fd_c, taglia, tmp_buf);
|
|
free(toSend);
|
|
return;
|
|
}
|
|
|
|
|
|
void writeFile(char *filepath, size_t size, queueT *q, long fd_c, taglia_t *taglia, int append) {
|
|
/* message to write to the logfile */
|
|
char tmp_buf[LOGBUFSIZE];
|
|
int n = 0;
|
|
size_t m = sizeof(tmp_buf);
|
|
|
|
if(!filepath || !q || !taglia) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\" e' terminata con errore\n",
|
|
fd_c,
|
|
append,
|
|
filepath);
|
|
errno = EINVAL;
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
|
|
/* search the file */
|
|
fileT *f = NULL;
|
|
f = find(q, filepath);
|
|
|
|
if(!f) { /* file is not present */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, e' terminata con errore, file non trovato\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
errno = ENOENT;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
destroyFile(f);
|
|
return;
|
|
}
|
|
|
|
/* file not open || no append and no lock || not the owner of the lock */
|
|
if(!f->open || (!append && !f->O_LOCK) || (f->O_LOCK && f->owner != fd_c)) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, e' terminata con errore, non proprietario del file\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
errno = EPERM;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
destroyFile(f);
|
|
return;
|
|
}
|
|
long trueSizeAdded = 0; /* we may have alredy some space allocated */
|
|
if(append) {
|
|
trueSizeAdded = size - f->size + f->valid;
|
|
} else {
|
|
trueSizeAdded = (size>f->size)? size-f->size : 0;
|
|
}
|
|
destroyFile(f); /* not needed anymore */
|
|
|
|
if(trueSizeAdded > q->maxSize) { /* removing all files would not be enought */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld ma il file e' piu' grande della dimensione massima\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
errno = EFBIG;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if(trueSizeAdded + getSize(q) > q->maxSize) {
|
|
/* writing would be more than capacity */
|
|
fileT **removed = NULL; /* array that may (worst case) hold all files to
|
|
* be sent to the client */
|
|
removed = dequeueN(q, filepath, trueSizeAdded);
|
|
if(!removed) { /* internal error */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, e' terminata con errore del server\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
errno = ENOENT;
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
int ln = 0;
|
|
fileT *tmp = removed[ln];
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, e' terminata con successo, allocando %ld B in memoria. Ha causato una capacity miss e ha fatto espellere i seguenti file:",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size,
|
|
trueSizeAdded);
|
|
while(tmp!=NULL) {
|
|
n += snprintf(tmp_buf+n, m-n, " \"%s\"", tmp->filepath);
|
|
++ln;
|
|
tmp=removed[ln];
|
|
}
|
|
n += snprintf(tmp_buf+n, m-n, "\n");
|
|
taglia_update(taglia, q, ln);
|
|
|
|
sendMessageFileN(MEFP, removed, ln, fd_c, taglia, tmp_buf);
|
|
for(int i=0;i<ln && (removed[i]!=NULL);++i) {
|
|
destroyFile(removed[i]);
|
|
}
|
|
free(removed);
|
|
|
|
/* now we can get the actual file */
|
|
void *content = NULL;
|
|
content = calloc(size, sizeof(char));
|
|
if(!content) {
|
|
perror("writeFile: calloc");
|
|
return;
|
|
}
|
|
if((readn(fd_c, content, size)) == -1) {
|
|
perror("writeFile: readn");
|
|
return;
|
|
}
|
|
|
|
n = 0;
|
|
|
|
if(append) {
|
|
if(appendFileInQueue(q, filepath, content, size, fd_c) == -1) {
|
|
perror("writeFile: appendFileInQueue");
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, errore del server\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
free(content);
|
|
return;
|
|
}
|
|
} else {
|
|
if(writeFileInQueue(q, filepath, content, size, fd_c) == -1) {
|
|
perror("writeFile: writeFileInQueue");
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, errore del server\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
free(content);
|
|
return;
|
|
}
|
|
}
|
|
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, e' terminata con successo\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
sendMessage(MEOK, fd_c, taglia, tmp_buf);
|
|
|
|
taglia_update(taglia, q, 0);
|
|
free(content);
|
|
return;
|
|
}
|
|
/* no dequeue */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, accettata la richiesta.\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
sendMessage(MEOK, fd_c, taglia, tmp_buf);
|
|
/* no reason to remove the file yet */
|
|
void *content = NULL;
|
|
content = calloc(size, sizeof(char));
|
|
if(!content) {
|
|
perror("writeFile: calloc");
|
|
return;
|
|
}
|
|
if(readn(fd_c, content, size) == -1) {
|
|
perror("writeFile: readn");
|
|
return;
|
|
}
|
|
|
|
n = 0;
|
|
|
|
if(append) {
|
|
if(appendFileInQueue(q, filepath, content, size, fd_c) == -1) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, errore del server\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
perror("writeFile: appendFileInQueue");
|
|
free(content);
|
|
return;
|
|
}
|
|
} else {
|
|
if(writeFileInQueue(q, filepath, content, size, fd_c) == -1) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, errore del server\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
perror("writeFile: writeFileInQueue");
|
|
free(content);
|
|
return;
|
|
}
|
|
}
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una writeFile (append = %x) sul file \"%s\", dimensione = %ld, e' terminata con successo\n",
|
|
fd_c,
|
|
append,
|
|
filepath,
|
|
size);
|
|
sendMessage(MEOK, fd_c, taglia, tmp_buf);
|
|
|
|
taglia_update(taglia, q, 0);
|
|
|
|
free(content);
|
|
return;
|
|
}
|
|
|
|
|
|
void lockFile(char *filepath, queueT *q, long fd_c, taglia_t *taglia, pthread_mutex_t *lock, waiting_t **waiting) {
|
|
/* message to write to the logfile */
|
|
char tmp_buf[LOGBUFSIZE];
|
|
int n = 0;
|
|
size_t m = sizeof(tmp_buf);
|
|
|
|
if(!filepath || !q || !taglia || !lock || !waiting) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una lockFile sul file \"%s\" e' terminata con errore.\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = EINVAL;
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
/* search the file to lock */
|
|
fileT *f = NULL;
|
|
f = find(q, filepath);
|
|
if(!f) { /* file is not present */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una lockFile sul file \"%s\" ma risulta assente.\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = ENOENT;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
destroyFile(f);
|
|
return;
|
|
}
|
|
|
|
/* try to lock */
|
|
if (openFileInQueue(q, filepath, 1, fd_c) == -1) {
|
|
/* unable to aquire the lock, wait to be released by inserting into
|
|
* the waiting queue */
|
|
if (errno == EPERM) {
|
|
if (pthread_mutex_lock(lock) == -1) { /* begin ME */
|
|
perror("lockFile: pthread_mutex_lock");
|
|
destroyFile(f);
|
|
return;
|
|
}
|
|
|
|
if (addWaiting(waiting, filepath, fd_c) == -1) {
|
|
perror("lockFile: addWaiting");
|
|
pthread_mutex_unlock(lock);
|
|
destroyFile(f);
|
|
return;
|
|
}
|
|
|
|
if (pthread_mutex_unlock(lock) == -1) { /* end ME */
|
|
perror("lockFile: pthread_mutex_unlock");
|
|
}
|
|
destroyFile(f);
|
|
return;
|
|
}
|
|
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una lockFile sul file \"%s\" e' terminata con errore.\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = ENOLCK;
|
|
serror(MESE, fd_c, taglia, tmp_buf);
|
|
destroyFile(f);
|
|
return;
|
|
}
|
|
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una lockFile sul file \"%s\" e' terminata con successo\n",
|
|
fd_c,
|
|
filepath);
|
|
sendMessage(MEOK, fd_c, taglia, tmp_buf);
|
|
destroyFile(f);
|
|
return;
|
|
}
|
|
|
|
|
|
void unlockFile(char *filepath, queueT *q, long fd_c, taglia_t *taglia, pthread_mutex_t *lock, waiting_t **waiting) {
|
|
/* message to write to the logfile */
|
|
char tmp_buf[LOGBUFSIZE];
|
|
int n = 0;
|
|
size_t m = sizeof(tmp_buf);
|
|
|
|
if(!filepath || !q || !taglia || !lock || !waiting) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una unlockFile sul file \"%s\" e' terminata con errore.\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = EINVAL;
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
/* search the file */
|
|
if(!searchFile(q, filepath)) { /* file does not exist */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una unlockFile sul file \"%s\" ma risulta assente.\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = ENOENT;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if (unlockFileInQueue(q, filepath, fd_c) != 0) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una unlockFile sul file \"%s\" ma non è stata rilasciata la lock.\n",
|
|
fd_c,
|
|
filepath);
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una unlockFile sul file \"%s\" e' terminata con successo\n",
|
|
fd_c,
|
|
filepath);
|
|
sendMessage(MEOK, fd_c, taglia, tmp_buf);
|
|
|
|
/* signal another waiting client that a lock has been released */
|
|
if (pthread_mutex_lock(lock) == -1) { /* begin ME */
|
|
perror("unlockFile: pthread_mutex_lock");
|
|
return;
|
|
}
|
|
|
|
int waked = -1;
|
|
waked = removeFirstWaiting(waiting, filepath);
|
|
|
|
if (waked != -1) {
|
|
/* we lock the file for the other client */
|
|
lockFile(filepath, q, waked, taglia, lock, waiting);
|
|
}
|
|
|
|
if (pthread_mutex_unlock(lock) == -1) { /* end ME */
|
|
perror("unlockFile: pthread_mutex_unlock");
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
void closeFile(char *filepath, queueT *q, long fd_c, taglia_t *taglia, pthread_mutex_t *lock, waiting_t **waiting) {
|
|
/* message to write to the logfile */
|
|
char tmp_buf[LOGBUFSIZE];
|
|
int n = 0;
|
|
size_t m = sizeof(tmp_buf);
|
|
|
|
if(!filepath || !q || !taglia || !lock || !waiting) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una closeFile sul file \"%s\" e' terminata con errore.\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = EINVAL;
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if(!searchFile(q, filepath)) { /* file does not exist */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una closeFile sul file \"%s\" ma risulta assente.\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = ENOENT;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if (closeFileInQueue(q, filepath, fd_c) == -1) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una closeFile sul file \"%s\" e' terminata con errore.\n",
|
|
fd_c,
|
|
filepath);
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una closeFile sul file \"%s\" e' terminata con successo\n",
|
|
fd_c,
|
|
filepath);
|
|
sendMessage(MEOK, fd_c, taglia, tmp_buf);
|
|
|
|
/* signal another waiting client that a lock has been released */
|
|
if (pthread_mutex_lock(lock) == -1) { /* begin ME */
|
|
perror("closeFile: pthread_mutex_lock");
|
|
return;
|
|
}
|
|
|
|
int waked = -1;
|
|
waked = removeFirstWaiting(waiting, filepath);
|
|
|
|
if (waked != -1) {
|
|
/* we lock the file for the other client */
|
|
lockFile(filepath, q, waked, taglia, lock, waiting);
|
|
}
|
|
|
|
if (pthread_mutex_unlock(lock) == -1) { /* end ME */
|
|
perror("closeFile: pthread_mutex_unlock");
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
void removeFile(char *filepath, queueT *q, long fd_c, taglia_t *taglia, pthread_mutex_t *lock, waiting_t **waiting) {
|
|
/* message to write to the logfile */
|
|
char tmp_buf[LOGBUFSIZE];
|
|
int n = 0;
|
|
size_t m = sizeof(tmp_buf);
|
|
|
|
if(!filepath || !q || !taglia || !lock || !waiting) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una removeFile sul file \"%s\" e' terminata con errore.\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = EINVAL;
|
|
serror(MESY, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
/* search for the file to delete */
|
|
if(!searchFile(q, filepath)) { /* file does not exist */
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una removeFile sul file \"%s\" ma risulta assente.\n",
|
|
fd_c,
|
|
filepath);
|
|
errno = ENOENT;
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
if (removeFileFromQueue(q, filepath, fd_c) == -1) {
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una removeFile sul file \"%s\" e' terminata con errore del server.\n",
|
|
fd_c,
|
|
filepath);
|
|
serror(MENT, fd_c, taglia, tmp_buf);
|
|
return;
|
|
}
|
|
|
|
n += snprintf(tmp_buf+n, m-n, "Client %ld ha richiesto una removeFile sul file \"%s\" e' terminata con successo\n",
|
|
fd_c,
|
|
filepath);
|
|
sendMessage(MEOK, fd_c, taglia, tmp_buf);
|
|
|
|
/* signal another waiting client that a lock has been released */
|
|
if (pthread_mutex_lock(lock) == -1) { /* begin ME */
|
|
perror("removeFile: pthread_mutex_lock");
|
|
return;
|
|
}
|
|
|
|
int waked = -1;
|
|
waked = removeFirstWaiting(waiting, filepath);
|
|
|
|
if (waked != -1) {
|
|
/* we lock the file for the other client */
|
|
lockFile(filepath, q, waked, taglia, lock, waiting);
|
|
}
|
|
|
|
if (pthread_mutex_unlock(lock) == -1) { /* end ME */
|
|
perror("removeFile: pthread_mutex_unlock");
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// helper functions for clients waiting locks
|
|
|
|
/* add a client to the waiting list */
|
|
int addWaiting(waiting_t **waiting, char *filepath, int fd_c) {
|
|
if(!waiting || !filepath) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
waiting_t *new = calloc(1, sizeof(waiting_t));
|
|
if (!new) {
|
|
perror("addWaiting: calloc");
|
|
return -1;
|
|
}
|
|
new->file = calloc(MAXLENMESS, sizeof(char));
|
|
if (!new->file) {
|
|
perror("addWaiting: calloc");
|
|
free(new);
|
|
return -1;
|
|
}
|
|
|
|
strncpy(new->file, filepath, strnlen(filepath, MAXLENMESS-1)+1);
|
|
new->fd = fd_c;
|
|
new->next = NULL;
|
|
|
|
/* if the list is empty */
|
|
if(*waiting == NULL) {
|
|
*waiting = new;
|
|
return 0;
|
|
}
|
|
|
|
/* if the list has at least 1 element */
|
|
waiting_t *tail = *waiting;
|
|
while(tail->next) {
|
|
tail = tail->next;
|
|
}
|
|
tail->next = new;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* remove first who is waiting on the lock for the file
|
|
* if no one is waiting for the lock it returns -1 */
|
|
int removeFirstWaiting(waiting_t **waiting, char *filepath) {
|
|
if(!waiting || !filepath) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
/* none waiting */
|
|
if(*waiting == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
waiting_t *curr = *waiting;
|
|
waiting_t *prec = NULL;
|
|
long fd_c = -1;
|
|
|
|
/* first one waiting */
|
|
if (strcmp(curr->file, filepath) == 0) {
|
|
fd_c = curr->fd;
|
|
*waiting = curr->next;
|
|
free(curr->file);
|
|
free(curr);
|
|
|
|
return fd_c;
|
|
}
|
|
|
|
/* more than one waiting */
|
|
while (curr->next) {
|
|
prec = curr;
|
|
curr = curr->next;
|
|
|
|
if (strcmp(curr->file, filepath) == 0) {
|
|
fd_c = curr->fd;
|
|
prec->next = curr->next;
|
|
free(curr->file);
|
|
free(curr);
|
|
|
|
return fd_c;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* free waiting structure */
|
|
void clearWaiting(waiting_t **waiting) {
|
|
if(!waiting) {
|
|
return;
|
|
}
|
|
waiting_t *curr = *waiting;
|
|
waiting_t *next = NULL;
|
|
|
|
while (curr) {
|
|
next = curr->next;
|
|
if(curr->file)
|
|
free(curr->file);
|
|
free(curr);
|
|
curr = next;
|
|
}
|
|
*waiting = NULL;
|
|
return;
|
|
}
|