/*! * \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; }