/*!
* \brief Envia informacoes pro cliente conectado.
* \param[in] socket_id Descritor do socket da conexao.
* \param[in] head Ponteiro para o primeiro item da lista de requisicoes.
* \return Retorna 0 caso tenha recebido o fim da requisicao ou -1 caso nao.
*/
int request_read(const int socket_id,
struct request_file **head,
struct manager_io **manager,
long speed_limit)
{
int buf_size = calc_buf_size(speed_limit);
struct request_file *request = NULL;
struct request_io request_thread;
request = search_request_file(socket_id, head);
if (request == NULL)
return ERROR;
if (check_if_transf_end(request) == SUCCESS)
return ENDED_DOWNLOAD;
if (send_header_to_client(&request, speed_limit)
|| request->sended_last_pack == 1)
return ERROR;
memset(&request_thread, 0, sizeof(struct request_io));
prepare_request_io(request, &request_thread, buf_size);
pthread_mutex_lock(&mutex);
enqueue_request_io(manager, &request_thread);
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);
return ERROR;
}
/*!
* \brief Envia header pro cliente conectado.
* \param[in] socket_id Descritor do socket da conexao.
* \param[in] head Ponteiro para o primeiro item da lista de requisicoes.
* \return Retorna 0 caso tenha recebido o fim da requisicao ou -1 caso nao.
*/
static int send_header_to_client(struct request_file **r, long speed_limit)
{
const int bufin_size = calc_buf_size(speed_limit);
int send_size = 0, nbytes = 0;
struct request_file *request = *r;
if (request->header == NULL)
request->header = make_header(request);
if ((unsigned)request->header_size_sended >= strlen(request->header))
return SUCCESS;
send_size = strlen(request->header) - request->header_size_sended;
send_size = (send_size > bufin_size) ? bufin_size : send_size;
if (check_speed_limit(request, speed_limit))
return ERROR;
nbytes = send(request->socket_id,
request->header + request->header_size_sended,
send_size,
MSG_NOSIGNAL);
if (nbytes > 0)
request->header_size_sended += nbytes;
return SUCCESS;
}
static int run_program(struct opts_t *opts)
{
uint8_t *t;
uint8_t *x;
const size_t c = calc_buf_size(opts->dos_version);
x = t = (uint8_t*)malloc(c);
catalog_track_out(opts->dos_version,opts->catalog_track,opts->used_sectors,opts->volume,&x);
assert(x == t+c);
if (opts->hex)
{
put_buffer_hex(t,c);
}
else
{
put_buffer_raw(t,c);
}
free(t);
return EXIT_SUCCESS;
}
/*!
* \brief Checa se foi transferido todo o arquivo alvo.
* \param[in] request Estrutura com informacoes da requisicao.
* \return 0 caso tenha transfeido ate o fim.
* \return -1 caso ainda tenha dados para serem transferidos.
*/
int check_speed_limit(struct request_file* request, long speed_limit)
{
calc_if_sec_had_pass(&request);
if (request->transf_last_sec + calc_buf_size(speed_limit) <= speed_limit)
return SUCCESS;
return ERROR;
}
/*!
* \brief Recebe a requisicao do cliente conectado.
* \param[in] socket_id Descritor do socket da conexao.
* \param[in] head Ponteiro para o primeiro item da lista de requisicoes.
* \return 0 caso tenha recebido o fim da requisicao
* \return -1 caso nao tenha recebido o fim da requisicao.
*/
int receive_request_from_client(const int socket_id,
struct request_file **head,
struct manager_io **manager,
long speed_limit)
{
int bufin_size = calc_buf_size(speed_limit);
char bufin[bufin_size + 1];
int nbytes = 0;
int received_size = 0;
struct request_file *request = NULL;
request = search_request_file(socket_id, head);
if (request == NULL)
request = add_request_file(socket_id, head);
memset(bufin, 0, bufin_size + 1);
if (check_speed_limit(request,speed_limit))
return ERROR;
nbytes = recv(socket_id, bufin, bufin_size, 0);
if (nbytes <= 0)
return ENDED_DOWNLOAD_UNCOMPLETED;
request->transf_last_sec += nbytes;
if (request->request == NULL)
request->request = (char *) calloc(REQUEST_SIZE, sizeof(char));
received_size = strlen(request->request);
if ((received_size + nbytes < REQUEST_SIZE)
|| (received_size > REQUEST_SIZE && received_size + nbytes < REQUEST_MAX))
memcpy(request->request + received_size, bufin, nbytes);
else if (received_size <= REQUEST_SIZE)
{
request->request = realloc(request->request, REQUEST_MAX);
memcpy(request->request + received_size, bufin, nbytes);
}
else if (received_size)
{
request->status = INTERNAL_ERROR;
set_std_response(request);
return READY_TO_SEND;
}
request->request[received_size + nbytes] = '\0';
return get_info_after_end_request(request, manager);
}
int receive_from_client(const int socket_id,
struct request_file **head,
struct manager_io **manager,
long speed_limit)
{
int buf_size = calc_buf_size(speed_limit);
int nbytes = 0;
struct request_file *request = NULL;
struct request_io request_thread;
request = search_request_file(socket_id, head);
if (request == NULL || find_end_request(request->request) == NULL)
return receive_request_from_client(socket_id, head, manager, speed_limit);
if (check_if_transf_end(request) == SUCCESS)
return ENDED_UPLOAD;
if (check_speed_limit(request, speed_limit) || request->sended_last_pack)
return ERROR;
memset(request->buffer, 0, buf_size);
buf_size = (buf_size > (request->file_size - request->transferred_size)) ?
(request->file_size - request->transferred_size) : buf_size ;
nbytes = recv(request->socket_id, request->buffer, buf_size, 0);
if (nbytes <= 0)
return ENDED_UPLOAD_UNCOMPLETED;
prepare_request_io(request, &request_thread, nbytes);
pthread_mutex_lock(&mutex);
enqueue_request_io(manager, &request_thread);
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);
return READY_TO_RECEIVE;
}
