// PEZZO DEL READER INCRIMINATO =============================================================

/* Prendo un file descriptor da cui leggere */
            source = fdpop();
            printf("Reader: Reading from %d\n", source);

            /* Leggo un message_t da quel file descriptor */
            if (acquireFdMutex(source) < 0) perror("fdMutex");
            read_out = readMsg(source, &msg);
            if (releaseFdMutex(source) < 0) perror("fdMutex");

            if (read_out < 0) { perror("readMsg");}
            else if (read_out == 0) { printf("Reader: client connesso sul fd %d caduto\n", source); freeReq(req); }


// DICHIARAZIONE DELLA READMSG ===============================================================
int readHeader(long connfd, message_hdr_t *hdr) {
    int rd;
    /* Leggo dal file descriptor l'header */
    rd = readn(connfd, hdr, sizeof(message_hdr_t));
    if (rd < 0) errno = EIO;

    return rd;
}

int readData(long fd, message_data_t *data) {
    int rd1, rd2;

    /* Leggo l'header del contenuto del messaggio */
    rd1 = readn(fd, &(data->hdr), sizeof(message_data_hdr_t));
    if (rd1 < 0) errno = EIO;
    if (rd1 <= 0) return rd1;

    /* Leggo il contenuto del messaggio */
    rd2 = readn(fd, data->buf, data->hdr.len);
    if (rd2 < 0) errno = EIO;
    if (rd2 <= 0) return rd2;

    return rd1 + rd2;
}

int readMsg(long fd, message_t *msg) {
    int rd1, rd2;

    /* Leggo l'header del messaggio */
    rd1 = readHeader(fd, &(msg->hdr));
    if (rd1 < 0) errno = EIO;
    if (rd1 <= 0) return rd1;

    /* Leggo il campo data del messaggio */
    rd2 = readData(fd, &(msg->data));
    if (rd2 < 0) errno = EIO;
    if (rd2 <= 0) return rd2;

    return rd1 + rd2;
}

// STRUTTURA DEL MESSAGE_T ==================================================================================
/**
 *  @struct header
 *  @brief header del messaggio
 *
 *  @var op tipo di operazione richiesta al server
 *  @var sender nickname del mittente
 */
typedef struct {
    op_t     op;
    char sender[MAX_NAME_LENGTH+1];
} message_hdr_t;

/**
 *  @struct header
 *  @brief header della parte dati
 *
 *  @var receiver nickname del ricevente
 *  @var len lunghezza del buffer dati
 */
typedef struct {
    char receiver[MAX_NAME_LENGTH+1];
    unsigned int   len;
} message_data_hdr_t;

/**
 *  @struct data
 *  @brief body del messaggio
 *
 *  @var hdr header della parte dati
 *  @var buf buffer dati
 */
typedef struct {
    message_data_hdr_t  hdr;
    char               *buf;
} message_data_t;

/**
 *  @struct messaggio
 *  @brief tipo del messaggio
 *
 *  @var hdr header
 *  @var data dati
 */
typedef struct {
    message_hdr_t  hdr;
    message_data_t data;
} message_t;

// FUNZIONE READN ==========================================================================
/**
 * @function readn
 * @brief Legge da un file descriptor fd
 *
 * @param fd File descriptor da cui leggere
 * @param buf Buffer in cui scrivere
 * @param size Lunghezza del messaggio da leggere
 *
 * @return la lunghezza del messaggio letto, -1 se errore
 */
static inline int readn(long fd, void *buf, size_t size) {
    size_t left = size;
    int r;
    char *bufptr = (char*)buf;
    while(left>0) {
    if ((r=read((int)fd ,bufptr,left)) == -1) {
        if (errno == EINTR) continue;
        return -1;
    }
    if (r == 0) return 0;   // gestione chiusura socket
        left    -= r;
    bufptr  += r;
    }
    return size;
}