int s_open(IncomingRequest *inc_request) {
FsResponse response;
FsOpenC data_c = inc_request->request.data.open;
int lock_result;
int server_handler = data_c.server_handler;
if (session_check_if_exist(server_handler) == -1)
{
response.answer= EC_SESSION_TIMED_OUT;
response.data.open.status = -1;
VDP1 ("Session timed out with: %d\n", server_handler);
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
char *file_name = (char *) calloc(data_c.name_len, sizeof(char));
strncpy(file_name, data_c.name, data_c.name_len);
VDP3("Incoming OPEN request: %s, len = %zu (flags: %d)\n", file_name, data_c.name_len, data_c.flags);
if (inc_request->request.data.open.flags == O_RDONLY)
lock_result = session_lock_file(inc_request->request.data.open.server_handler, file_name, FLOCK_SH);
else
lock_result = session_lock_file(inc_request->request.data.open.server_handler, file_name, FLOCK_EX);
if(lock_result < 0) {
/* Nie udalo sie dostac blokady na plik - trzeba powiadomic o tym klienta. */
VDP0("Lock failed, request turned down.\n");
response.data.open.status = -1;
response.answer = EF_FILE_BLOCKED;
} else {
VDP0("Lock accepted, request accepted.\n");
VDP2("Attempting to open %s file in %d mode...\n", file_name, data_c.flags);
int fh = open(file_name, data_c.flags);
if(fh == -1) {
VDP1("File %s cannot be opened.\n", file_name);
session_unlock_file(inc_request->request.data.open.server_handler, lock_result);
response.data.open.status = -1;
response.answer = EF_NOT_FOUND;
response.data.open.fd = -1;
} else {
VDP1("File %s opened successfully. \n", file_name);
status = session_set(inc_request->request.data.open.server_handler, lock_result, fh);
response.data.open.status = lock_result;
response.answer = IF_OK;
response.data.open.fd = lock_result;
}
}
free(file_name);
return sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
}
void
vdp1_fbcr_interlace_set(enum fbcr_interlace_type mode)
{
uint16_t modr;
/* Only NTSC and PAL format is able to have interlace mode. */
modr = MEMORY_READ(16, VDP1(MODR));
if ((modr & 0x0006) == 0x0000)
MEMORY_WRITE(16, VDP1(FBCR), mode);
}
void
vdp1_fbcr_rotate_set(void)
{
uint16_t tvmr;
tvmr = MEMORY_READ(16, VDP1(MODR));
/* Write to memory. */
MEMORY_WRITE(16, VDP1(TVMR), (tvmr & 0x0007) | 0x0002);
}
void
vdp1_fbcr_bpp_set(uint8_t bpp)
{
uint16_t tvmr;
tvmr = MEMORY_READ(16, VDP1(MODR));
/* Write to memory. */
MEMORY_WRITE(16, VDP1(TVMR), (tvmr & 0x7) | ((bpp == 8) ? 1 : 0));
}
void
vdp1_init(void)
{
/* Check if boundaries are correct */
STATIC_ASSERT((VDP1_CMDT_MEMORY_SIZE +
VDP1_GST_MEMORY_SIZE +
VDP1_TEXURE_MEMORY_SIZE +
VDP1_CLUT_MEMORY_SIZE) == VDP1_VRAM_SIZE);
/* Initialize the processor to sane values */
MEMORY_WRITE(16, VDP1(TVMR), 0x0000);
MEMORY_WRITE(16, VDP1(ENDR), 0x0000);
MEMORY_WRITE(16, VDP1(FBCR), 0x0000);
MEMORY_WRITE(16, VDP1(PTMR), 0x0000);
MEMORY_WRITE(16, VDP1(EWDR), 0x0000);
MEMORY_WRITE(16, VDP1(EWLR), 0x0000);
MEMORY_WRITE(16, VDP1(EWRR), (uint16_t)(((320 / 8) << 9) | (223)));
vdp2_tvmd_vblank_in_wait();
/* Stop processing command tables */
uint32_t cmdt_idx;
for (cmdt_idx = 0; cmdt_idx < VDP1_CMDT_COUNT_MAX; cmdt_idx++) {
struct vdp1_cmdt *cmdt;
cmdt = (struct vdp1_cmdt *)CMD_TABLE(cmdt_idx, 0);
cmdt->cmd_ctrl = 0x8000;
}
vdp1_cmdt_list_init();
MEMORY_WRITE(16, VDP1(PTMR), 0x0002);
}
void
vdp1_fbcr_erase_coordinates_set(uint16_t x1, uint16_t y1, uint16_t x3, uint16_t y3, uint16_t color)
{
uint16_t bpp;
uint16_t modr;
/* Obtain the bit depth of the frame buffer. */
modr = MEMORY_READ(16, VDP1(MODR));
bpp = ((modr & 0x0001) == 0x0001) ? 4 : 3;
/* Upper-left coordinates. */
MEMORY_WRITE(16, VDP1(EWLR), ((x1 >> bpp) << 9) | (y1 - 1));
/* Lower-right coordinates. */
MEMORY_WRITE(16, VDP1(EWLR), ((x3 >> bpp) << 9) | (y3 - 1));
MEMORY_WRITE(16, VDP1(EWDR), color);
}
int s_close (IncomingRequest *inc_request)
{
FsResponse response;
FsCloseC data_c = inc_request->request.data.close;
int server_handler = data_c.server_handler;
int fd = data_c.fd;
VDP0 ("Closing operation\n");
if (session_check_if_exist(server_handler) == -1)
{
response.answer= EC_SESSION_TIMED_OUT;
response.data.close.status = -1;
VDP1 ("Session timed out with: %d\n", server_handler);
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
int file = session_get (server_handler, fd);
if (file == -1)
{
response.data.close.status = -1;
VDP0 ("Could not get file descriptor in close\n");
}
else
{
response.data.close.status = close(file);
session_unlock_file(server_handler, fd);
response.answer = IF_OK;
VDP2 ("Closing file with fd: %d with status %d\n", fd, response.data.close.status);
}
return sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
}
int s_write (IncomingRequest *inc_request)
{
FsResponse response;
FsWriteC data_c = inc_request->request.data.write;
int status = 0;
size_t parts_number = data_c.parts_number;
int server_handler = data_c.server_handler;
int fd = data_c.fd;
int part_id = data_c.part_id;
SessionFileBuffer* session_buffer;
if (session_check_if_exist(server_handler) == -1)
{
response.answer= EC_SESSION_TIMED_OUT;
response.data.write.status = -1;
VDP1 ("Session timed out with: %d\n", server_handler);
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
switch (inc_request->request.command)
{
case WRITE:
VDP1("Session %d allowed to receive file\n", server_handler);
session_buffer = session_get_buffer (server_handler, fd);
session_buffer->received_parts = (int*) calloc(parts_number, sizeof(int));
session_buffer->buffer = (char*) calloc(data_c.buffer_len, sizeof(char));
session_buffer->file_size = data_c.buffer_len;
for (int i = 0; i<data_c.buffer_len; i++)
{
char a = '-';
strncpy(session_buffer->buffer+i, &a , 1);
}
response.answer = IF_CONTINUE;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
// errors
return 0;
case WRITE_PACKAGES:
session_buffer = session_get_buffer (server_handler, fd);
if ( session_buffer == NULL )
{
response.answer = EF_ACCESS_ERROR;
break;
}
VDP3("Session %d received part %d/%zu\n", server_handler, part_id, parts_number);
strncpy(session_buffer->buffer + data_c.part_id * BUF_LEN, data_c.buffer, data_c.buffer_len);
int *current_package = session_buffer->received_parts + data_c.part_id;
*current_package = 1;
return 0;
case WRITE_ALL:
session_buffer = session_get_buffer (server_handler, fd);
if (session_buffer == NULL)
{
response.answer = EF_ACCESS_ERROR;
response.data.write.status = -1;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
break;
}
response.answer = IF_OK;
for(int i=0; i<parts_number; ++i)
{
int* current = session_buffer->received_parts + i;
if (*current == 0)
{
response.answer = EF_CORRUPT_PACKAGE;
response.data.write.status = -1;
printf("Corrupt package\n");
break;
}
}
if (response.answer == IF_OK)
{
int file = session_get (server_handler, fd);
if (file == -1)
{
VDP0 ("Could not get file descriptor in write\n");
} else
{
size_t count = write(file, session_buffer->buffer, session_buffer->file_size);
response.data.write.status = count;
if (count <= 0) response.answer = EF_NOT_FOUND;
}
}
if (session_buffer!=NULL) free(session_buffer->received_parts);
if (session_buffer!=NULL) free(session_buffer->buffer);
session_buffer->received_parts = NULL;
session_buffer->buffer = NULL;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
break;
default:
break;
}
return 0;
}
int s_read (IncomingRequest *inc_request)
{
FsResponse response;
FsReadC data_c = inc_request->request.data.read;
int server_handler = data_c.server_handler;
int buffer_len = data_c.buffer_len;
size_t parts = buffer_len/BUF_LEN;
size_t last_part = buffer_len%BUF_LEN;
int i = 0;
int fd = data_c.fd;
void* buf;
off_t offset = 0;
struct stat stat_of_file;
if (session_check_if_exist(server_handler) == -1)
{
response.answer= EC_SESSION_TIMED_OUT;
response.data.read.status = -1;
VDP1 ("Session timed out with: %d\n", server_handler);
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
int file = session_get (server_handler, fd);
if (file == -1)
{
response.data.read.status = -1;
VDP0 ("Could not get file descriptor in read\n");
}
else
{
offset = session_get_offset (server_handler, fd);
status = fstat (file, &stat_of_file);
if (offset < 0 || status < 0)
{
response.answer = EF_NOT_FOUND;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
size_t file_size = stat_of_file.st_size;
size_t size_to_end = file_size - offset;
if (buffer_len > size_to_end)
{
buffer_len = size_to_end;
}
if (buffer_len <= 0)
{
VDP0 ("To small buffer length in read\n");
response.answer = EF_BAD_REQUEST;
response.data.read.status = -1;
response.data.read.buffer_len = buffer_len;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
response.answer = IF_CONTINUE;
response.data.read.buffer_len = buffer_len;
response.data.read.parts_number = parts;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
buf = (char*) malloc(buffer_len);
response.data.read.status = read(file, buf, buffer_len);
parts = buffer_len/BUF_LEN;
last_part = buffer_len%BUF_LEN;
if (response.data.read.status <= 0)
{
free(buf);
response.answer = EF_NOT_FOUND;
VDP0 ("Could not read file in read\n");
response.data.read.status = -1;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
for (i=0; i<parts; i++)
{
strncpy (response.data.read.buffer, buf + i * BUF_LEN, BUF_LEN);
response.data.read.part_id = i;
response.data.read.buffer_len = BUF_LEN;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
}
if (last_part != 0)
{
response.data.read.buffer_len = last_part;
response.data.read.part_id = i;
strncpy (response.data.read.buffer, buf + i * BUF_LEN, last_part);
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
}
free(buf);
usleep(500);
response.answer = IF_OK;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
}
return 0;
}
