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; }