aaru-dps/aaruremote
1
0
Fork 0
mirror of https://github.com/aaru-dps/aaruremote.git synced 2025-12-16 19:24:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use slims for BSD Sockets functions.

Browse Source
This commit is contained in:
Natalia Portillo
2019-10-20 20:47:36 +01:00
parent 318b171262
commit 9889fc743e
4 changed files with 115 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
dicmote.h
View File

@@ -21,6 +21,13 @@
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#ifdef GEKKO
#include <network.h>
#else
#include <netinet/in.h>
#include <sys/socket.h>
#endif
#define DICMOTE_NAME "DiscImageChef Remote Server" #define DICMOTE_NAME "DiscImageChef Remote Server"
#define DICMOTE_VERSION "0.99" #define DICMOTE_VERSION "0.99"
#define DICMOTE_PORT 6666 #define DICMOTE_PORT 6666
@@ -499,5 +506,12 @@ int32_t SendSdhciCommand(int device_fd,
uint32_t* sense); uint32_t* sense);
DicPacketHello* GetHello(); DicPacketHello* GetHello();
int PrintNetworkAddresses(); int PrintNetworkAddresses();
char* PrintIpv4Address(struct in_addr addr);
int32_t NetSocket(uint32_t domain, uint32_t type, uint32_t protocol);
int32_t NetBind(int32_t sockfd, struct sockaddr* addr, socklen_t addrlen);
int32_t NetListen(int32_t sockfd, uint32_t backlog);
int32_t NetAccept(int32_t sockfd, struct sockaddr* addr, socklen_t* addrlen);
int32_t NetRecv(int32_t sockfd, void* buf, int32_t len, uint32_t flags);
int32_t NetWrite(int32_t fd, const void* buf, int32_t size);
int32_t NetClose(int32_t fd);
#endif #endif

152
main.c
View File

@@ -89,7 +89,7 @@ int main()
"Running under %s %s (%s).\n", pkt_server_hello->sysname, pkt_server_hello->release, pkt_server_hello->machine); "Running under %s %s (%s).\n", pkt_server_hello->sysname, pkt_server_hello->release, pkt_server_hello->machine);
printf("Opening socket.\n"); printf("Opening socket.\n");
sock_fd = socket(AF_INET, SOCK_STREAM, 0); sock_fd = NetSocket(AF_INET, SOCK_STREAM, 0);
if(sock_fd < 0) if(sock_fd < 0)
{ {
printf("Error %d opening socket.\n", errno); printf("Error %d opening socket.\n", errno);
@@ -100,10 +100,10 @@ int main()
serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(DICMOTE_PORT); serv_addr.sin_port = htons(DICMOTE_PORT);
if(bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) if(NetBind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
{ {
printf("Error %d binding socket.\n", errno); printf("Error %d binding socket.\n", errno);
close(sock_fd); NetClose(sock_fd);
return 1; return 1;
} }
@@ -115,12 +115,12 @@ int main()
return 1; return 1;
} }
ret = listen(sock_fd, 1); ret = NetListen(sock_fd, 1);
if(ret) if(ret)
{ {
printf("Error %d listening.\n", errno); printf("Error %d listening.\n", errno);
close(sock_fd); NetClose(sock_fd);
return 1; return 1;
} }
@@ -129,7 +129,7 @@ int main()
if(!pkt_nop) if(!pkt_nop)
{ {
printf("Fatal error %d allocating memory.\n", errno); printf("Fatal error %d allocating memory.\n", errno);
close(sock_fd); NetClose(sock_fd);
return 1; return 1;
} }
@@ -146,38 +146,38 @@ int main()
printf("Waiting for a client...\n"); printf("Waiting for a client...\n");
cli_len = sizeof(cli_addr); cli_len = sizeof(cli_addr);
cli_sock = accept(sock_fd, (struct sockaddr*)&cli_addr, &cli_len); cli_sock = NetAccept(sock_fd, (struct sockaddr*)&cli_addr, &cli_len);
if(cli_sock < 0) if(cli_sock < 0)
{ {
printf("Error %d accepting incoming connection.\n", errno); printf("Error %d accepting incoming connection.\n", errno);
close(sock_fd); NetClose(sock_fd);
return 1; return 1;
} }
inet_ntop(AF_INET, &cli_addr.sin_addr, ipv4_address, INET_ADDRSTRLEN); inet_ntop(AF_INET, &cli_addr.sin_addr, ipv4_address, INET_ADDRSTRLEN);
printf("Client %s connected successfully.\n", ipv4_address); printf("Client %s connected successfully.\n", ipv4_address);
write(cli_sock, pkt_server_hello, sizeof(DicPacketHello)); NetWrite(cli_sock, pkt_server_hello, sizeof(DicPacketHello));
pkt_hdr = malloc(sizeof(DicPacketHeader)); pkt_hdr = malloc(sizeof(DicPacketHeader));
if(!pkt_hdr) if(!pkt_hdr)
{ {
printf("Fatal error %d allocating memory.\n", errno); printf("Fatal error %d allocating memory.\n", errno);
close(cli_sock); NetClose(cli_sock);
close(sock_fd); NetClose(sock_fd);
free(pkt_server_hello); free(pkt_server_hello);
return 1; return 1;
} }
recv_size = recv(cli_sock, pkt_hdr, sizeof(DicPacketHeader), MSG_PEEK); recv_size = NetRecv(cli_sock, pkt_hdr, sizeof(DicPacketHeader), MSG_PEEK);
if(recv_size < 0) if(recv_size < 0)
{ {
printf("Error %d reading response from client.\n", errno); printf("Error %d reading response from client.\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -185,7 +185,7 @@ int main()
{ {
printf("Client closed connection.\n"); printf("Client closed connection.\n");
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -193,7 +193,7 @@ int main()
{ {
printf("Received data is not a correct dicremote packet, closing connection...\n"); printf("Received data is not a correct dicremote packet, closing connection...\n");
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -201,7 +201,7 @@ int main()
{ {
printf("Unrecognized packet version, closing connection...\n"); printf("Unrecognized packet version, closing connection...\n");
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -209,7 +209,7 @@ int main()
{ {
printf("Expecting hello packet type, received type %d, closing connection...\n", pkt_hdr->packet_type); printf("Expecting hello packet type, received type %d, closing connection...\n", pkt_hdr->packet_type);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -219,16 +219,16 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv_size = recv(cli_sock, pkt_client_hello, pkt_hdr->len, 0); recv_size = NetRecv(cli_sock, pkt_client_hello, pkt_hdr->len, 0);
if(recv_size != pkt_hdr->len) if(recv_size != pkt_hdr->len)
{ {
printf("Expected %d bytes of packet, got %ld, closing connection...\n", pkt_hdr->len, recv_size); printf("Expected %d bytes of packet, got %ld, closing connection...\n", pkt_hdr->len, recv_size);
close(cli_sock); NetClose(cli_sock);
free(pkt_hdr); free(pkt_hdr);
free(pkt_client_hello); free(pkt_client_hello);
continue; continue;
@@ -255,21 +255,21 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
free(in_buf); free(in_buf);
skip_next_hdr = 0; skip_next_hdr = 0;
} }
recv_size = recv(cli_sock, pkt_hdr, sizeof(DicPacketHeader), MSG_PEEK); recv_size = NetRecv(cli_sock, pkt_hdr, sizeof(DicPacketHeader), MSG_PEEK);
if(recv_size < 0) if(recv_size < 0)
{ {
printf("Error %d reading response from client, closing connection...\n", errno); printf("Error %d reading response from client, closing connection...\n", errno);
close(cli_sock); NetClose(cli_sock);
free(pkt_hdr); free(pkt_hdr);
break; break;
} }
@@ -277,7 +277,7 @@ int main()
if(recv_size == 0) if(recv_size == 0)
{ {
printf("Client closed connection, closing connection...\n"); printf("Client closed connection, closing connection...\n");
close(cli_sock); NetClose(cli_sock);
free(pkt_hdr); free(pkt_hdr);
break; break;
} }
@@ -285,7 +285,7 @@ int main()
if(pkt_hdr->id != DICMOTE_PACKET_ID) if(pkt_hdr->id != DICMOTE_PACKET_ID)
{ {
printf("Received data is not a correct dicremote packet, closing connection...\n"); printf("Received data is not a correct dicremote packet, closing connection...\n");
close(cli_sock); NetClose(cli_sock);
free(pkt_hdr); free(pkt_hdr);
break; break;
} }
@@ -303,7 +303,7 @@ int main()
pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_OOO; pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_OOO;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
strncpy(pkt_nop->reason, "Received hello packet out of order, skipping...", 256); strncpy(pkt_nop->reason, "Received hello packet out of order, skipping...", 256);
write(cli_sock, pkt_nop, sizeof(DicPacketNop)); NetWrite(cli_sock, pkt_nop, sizeof(DicPacketNop));
printf("%s...\n", pkt_nop->reason); printf("%s...\n", pkt_nop->reason);
skip_next_hdr = 1; skip_next_hdr = 1;
continue; continue;
@@ -317,11 +317,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
free(in_buf); free(in_buf);
if(!device_info_list) if(!device_info_list)
@@ -329,7 +329,7 @@ int main()
pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES; pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
strncpy(pkt_nop->reason, "Could not get device list, continuing...", 256); strncpy(pkt_nop->reason, "Could not get device list, continuing...", 256);
write(cli_sock, pkt_nop, sizeof(DicPacketNop)); NetWrite(cli_sock, pkt_nop, sizeof(DicPacketNop));
printf("%s...\n", pkt_nop->reason); printf("%s...\n", pkt_nop->reason);
continue; continue;
} }
@@ -362,7 +362,7 @@ int main()
device_info_list = (struct DeviceInfoList*)in_buf; device_info_list = (struct DeviceInfoList*)in_buf;
FreeDeviceInfoList(device_info_list); FreeDeviceInfoList(device_info_list);
write(cli_sock, pkt_res_devinfo, pkt_res_devinfo->hdr.len); NetWrite(cli_sock, pkt_res_devinfo, pkt_res_devinfo->hdr.len);
free(pkt_res_devinfo); free(pkt_res_devinfo);
continue; continue;
case DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS: case DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS:
@@ -379,7 +379,7 @@ int main()
pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_OOO; pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_OOO;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
strncpy(pkt_nop->reason, "Received response packet?! You should certainly not do that...", 256); strncpy(pkt_nop->reason, "Received response packet?! You should certainly not do that...", 256);
write(cli_sock, pkt_nop, sizeof(DicPacketNop)); NetWrite(cli_sock, pkt_nop, sizeof(DicPacketNop));
printf("%s...\n", pkt_nop->reason); printf("%s...\n", pkt_nop->reason);
skip_next_hdr = 1; skip_next_hdr = 1;
continue; continue;
@@ -390,11 +390,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, pkt_dev_open, pkt_hdr->len, 0); NetRecv(cli_sock, pkt_dev_open, pkt_hdr->len, 0);
device_fd = DeviceOpen(pkt_dev_open->device_path); device_fd = DeviceOpen(pkt_dev_open->device_path);
@@ -402,7 +402,7 @@ int main()
device_fd == -1 ? DICMOTE_PACKET_NOP_REASON_OPEN_ERROR : DICMOTE_PACKET_NOP_REASON_OPEN_OK; device_fd == -1 ? DICMOTE_PACKET_NOP_REASON_OPEN_ERROR : DICMOTE_PACKET_NOP_REASON_OPEN_OK;
pkt_nop->error_no = errno; pkt_nop->error_no = errno;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
write(cli_sock, pkt_nop, sizeof(DicPacketNop)); NetWrite(cli_sock, pkt_nop, sizeof(DicPacketNop));
if(pkt_nop->reason_code == DICMOTE_PACKET_NOP_REASON_OPEN_OK) if(pkt_nop->reason_code == DICMOTE_PACKET_NOP_REASON_OPEN_OK)
strncpy(device_path, pkt_dev_open->device_path, 1024); strncpy(device_path, pkt_dev_open->device_path, 1024);
@@ -417,11 +417,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
free(in_buf); free(in_buf);
pkt_dev_type = malloc(sizeof(DicPacketResGetDeviceType)); pkt_dev_type = malloc(sizeof(DicPacketResGetDeviceType));
@@ -430,7 +430,7 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -442,7 +442,7 @@ int main()
pkt_dev_type->hdr.id = DICMOTE_PACKET_ID; pkt_dev_type->hdr.id = DICMOTE_PACKET_ID;
pkt_dev_type->device_type = GetDeviceType(device_path); pkt_dev_type->device_type = GetDeviceType(device_path);
write(cli_sock, pkt_dev_type, sizeof(DicPacketResGetDeviceType)); NetWrite(cli_sock, pkt_dev_type, sizeof(DicPacketResGetDeviceType));
free(pkt_dev_type); free(pkt_dev_type);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_SCSI: case DICMOTE_PACKET_TYPE_COMMAND_SCSI:
@@ -453,11 +453,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
pkt_cmd_scsi = (DicPacketCmdScsi*)in_buf; pkt_cmd_scsi = (DicPacketCmdScsi*)in_buf;
@@ -490,7 +490,7 @@ int main()
printf("Fatal error %d allocating memory for packet, continuing...\n", errno); printf("Fatal error %d allocating memory for packet, continuing...\n", errno);
free(pkt_hdr); free(pkt_hdr);
free(in_buf); free(in_buf);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -509,7 +509,7 @@ int main()
pkt_res_scsi->sense = sense; pkt_res_scsi->sense = sense;
pkt_res_scsi->error_no = ret; pkt_res_scsi->error_no = ret;
write(cli_sock, pkt_res_scsi, pkt_res_scsi->hdr.len); NetWrite(cli_sock, pkt_res_scsi, pkt_res_scsi->hdr.len);
free(pkt_cmd_scsi); free(pkt_cmd_scsi);
free(pkt_res_scsi); free(pkt_res_scsi);
if(sense_buf) free(sense_buf); if(sense_buf) free(sense_buf);
@@ -522,11 +522,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
free(in_buf); free(in_buf);
pkt_res_sdhci_registers = malloc(sizeof(DicPacketResGetSdhciRegisters)); pkt_res_sdhci_registers = malloc(sizeof(DicPacketResGetSdhciRegisters));
@@ -534,7 +534,7 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -583,7 +583,7 @@ int main()
free(scr); free(scr);
free(ocr); free(ocr);
write(cli_sock, pkt_res_sdhci_registers, pkt_res_sdhci_registers->hdr.len); NetWrite(cli_sock, pkt_res_sdhci_registers, pkt_res_sdhci_registers->hdr.len);
free(pkt_res_sdhci_registers); free(pkt_res_sdhci_registers);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA: case DICMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA:
@@ -594,11 +594,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
free(in_buf); free(in_buf);
pkt_res_usb = malloc(sizeof(DicPacketResGetUsbData)); pkt_res_usb = malloc(sizeof(DicPacketResGetUsbData));
@@ -606,7 +606,7 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -624,7 +624,7 @@ int main()
pkt_res_usb->product, pkt_res_usb->product,
pkt_res_usb->serial); pkt_res_usb->serial);
write(cli_sock, pkt_res_usb, pkt_res_usb->hdr.len); NetWrite(cli_sock, pkt_res_usb, pkt_res_usb->hdr.len);
free(pkt_res_usb); free(pkt_res_usb);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA: case DICMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA:
@@ -635,11 +635,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
free(in_buf); free(in_buf);
pkt_res_firewire = malloc(sizeof(DicPacketResGetFireWireData)); pkt_res_firewire = malloc(sizeof(DicPacketResGetFireWireData));
@@ -647,7 +647,7 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -663,7 +663,7 @@ int main()
pkt_res_firewire->vendor, pkt_res_firewire->vendor,
pkt_res_firewire->model); pkt_res_firewire->model);
write(cli_sock, pkt_res_firewire, pkt_res_firewire->hdr.len); NetWrite(cli_sock, pkt_res_firewire, pkt_res_firewire->hdr.len);
free(pkt_res_firewire); free(pkt_res_firewire);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA: case DICMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA:
@@ -674,11 +674,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
free(in_buf); free(in_buf);
pkt_res_pcmcia = malloc(sizeof(DicPacketResGetPcmciaData)); pkt_res_pcmcia = malloc(sizeof(DicPacketResGetPcmciaData));
@@ -686,7 +686,7 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -698,7 +698,7 @@ int main()
pkt_res_pcmcia->is_pcmcia = pkt_res_pcmcia->is_pcmcia =
GetPcmciaData(device_path, &pkt_res_pcmcia->cis_len, pkt_res_pcmcia->cis); GetPcmciaData(device_path, &pkt_res_pcmcia->cis_len, pkt_res_pcmcia->cis);
write(cli_sock, pkt_res_pcmcia, pkt_res_pcmcia->hdr.len); NetWrite(cli_sock, pkt_res_pcmcia, pkt_res_pcmcia->hdr.len);
free(pkt_res_pcmcia); free(pkt_res_pcmcia);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS: case DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS:
@@ -709,11 +709,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
pkt_cmd_ata_chs = (DicPacketCmdAtaChs*)in_buf; pkt_cmd_ata_chs = (DicPacketCmdAtaChs*)in_buf;
@@ -746,7 +746,7 @@ int main()
printf("Fatal error %d allocating memory for packet, continuing...\n", errno); printf("Fatal error %d allocating memory for packet, continuing...\n", errno);
free(pkt_hdr); free(pkt_hdr);
free(in_buf); free(in_buf);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -764,7 +764,7 @@ int main()
pkt_res_ata_chs->sense = sense; pkt_res_ata_chs->sense = sense;
pkt_res_ata_chs->error_no = ret; pkt_res_ata_chs->error_no = ret;
write(cli_sock, pkt_res_ata_chs, pkt_res_ata_chs->hdr.len); NetWrite(cli_sock, pkt_res_ata_chs, pkt_res_ata_chs->hdr.len);
free(pkt_cmd_ata_chs); free(pkt_cmd_ata_chs);
free(pkt_res_ata_chs); free(pkt_res_ata_chs);
continue; continue;
@@ -776,11 +776,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
pkt_cmd_ata_lba28 = (DicPacketCmdAtaLba28*)in_buf; pkt_cmd_ata_lba28 = (DicPacketCmdAtaLba28*)in_buf;
@@ -813,7 +813,7 @@ int main()
printf("Fatal error %d allocating memory for packet, continuing...\n", errno); printf("Fatal error %d allocating memory for packet, continuing...\n", errno);
free(pkt_hdr); free(pkt_hdr);
free(in_buf); free(in_buf);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -831,7 +831,7 @@ int main()
pkt_res_ata_lba28->sense = sense; pkt_res_ata_lba28->sense = sense;
pkt_res_ata_lba28->error_no = ret; pkt_res_ata_lba28->error_no = ret;
write(cli_sock, pkt_res_ata_lba28, pkt_res_ata_lba28->hdr.len); NetWrite(cli_sock, pkt_res_ata_lba28, pkt_res_ata_lba28->hdr.len);
free(pkt_cmd_ata_lba28); free(pkt_cmd_ata_lba28);
free(pkt_res_ata_lba28); free(pkt_res_ata_lba28);
continue; continue;
@@ -843,11 +843,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
pkt_cmd_ata_lba48 = (DicPacketCmdAtaLba48*)in_buf; pkt_cmd_ata_lba48 = (DicPacketCmdAtaLba48*)in_buf;
@@ -880,7 +880,7 @@ int main()
printf("Fatal error %d allocating memory for packet, continuing...\n", errno); printf("Fatal error %d allocating memory for packet, continuing...\n", errno);
free(pkt_hdr); free(pkt_hdr);
free(in_buf); free(in_buf);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -898,7 +898,7 @@ int main()
pkt_res_ata_lba48->sense = sense; pkt_res_ata_lba48->sense = sense;
pkt_res_ata_lba48->error_no = ret; pkt_res_ata_lba48->error_no = ret;
write(cli_sock, pkt_res_ata_lba48, pkt_res_ata_lba48->hdr.len); NetWrite(cli_sock, pkt_res_ata_lba48, pkt_res_ata_lba48->hdr.len);
free(pkt_cmd_ata_lba48); free(pkt_cmd_ata_lba48);
free(pkt_res_ata_lba48); free(pkt_res_ata_lba48);
continue; continue;
@@ -910,11 +910,11 @@ int main()
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
recv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, pkt_hdr->len, 0);
pkt_cmd_sdhci = (DicPacketCmdSdhci*)in_buf; pkt_cmd_sdhci = (DicPacketCmdSdhci*)in_buf;
@@ -950,7 +950,7 @@ int main()
printf("Fatal error %d allocating memory for packet, continuing...\n", errno); printf("Fatal error %d allocating memory for packet, continuing...\n", errno);
free(pkt_hdr); free(pkt_hdr);
free(in_buf); free(in_buf);
close(cli_sock); NetClose(cli_sock);
continue; continue;
} }
@@ -968,7 +968,7 @@ int main()
pkt_res_sdhci->sense = sense; pkt_res_sdhci->sense = sense;
pkt_res_sdhci->error_no = ret; pkt_res_sdhci->error_no = ret;
write(cli_sock, pkt_res_sdhci, pkt_res_sdhci->hdr.len); NetWrite(cli_sock, pkt_res_sdhci, pkt_res_sdhci->hdr.len);
free(pkt_cmd_sdhci); free(pkt_cmd_sdhci);
free(pkt_res_sdhci); free(pkt_res_sdhci);
continue; continue;
@@ -979,7 +979,7 @@ int main()
256, 256,
"Received unrecognized packet with type %d, skipping...", "Received unrecognized packet with type %d, skipping...",
pkt_hdr->packet_type); pkt_hdr->packet_type);
write(cli_sock, pkt_nop, sizeof(DicPacketNop)); NetWrite(cli_sock, pkt_nop, sizeof(DicPacketNop));
printf("%s...\n", pkt_nop->reason); printf("%s...\n", pkt_nop->reason);
skip_next_hdr = 1; skip_next_hdr = 1;
continue; continue;

12
unix/network.c
View File

@@ -20,6 +20,7 @@
#include <arpa/inet.h> #include <arpa/inet.h>
#include <ifaddrs.h> #include <ifaddrs.h>
#include <stdio.h> #include <stdio.h>
#include <unistd.h>
int PrintNetworkAddresses() int PrintNetworkAddresses()
{ {
@@ -49,4 +50,13 @@ int PrintNetworkAddresses()
freeifaddrs(ifa_start); freeifaddrs(ifa_start);
return 0; return 0;
} }
char* PrintIpv4Address(struct in_addr addr) { return inet_ntoa(addr); }
int32_t NetSocket(uint32_t domain, uint32_t type, uint32_t protocol) { return socket(domain, type, protocol); }
int32_t NetBind(int32_t sockfd, struct sockaddr* addr, socklen_t addrlen) { return bind(sockfd, addr, addrlen); }
int32_t NetListen(int32_t sockfd, uint32_t backlog) { return listen(sockfd, backlog); }
int32_t NetAccept(int32_t sockfd, struct sockaddr* addr, socklen_t* addrlen) { return accept(sockfd, addr, addrlen); }
int32_t NetRecv(int32_t sockfd, void* buf, int32_t len, uint32_t flags) { return recv(sockfd, buf, len, flags); }
int32_t NetWrite(int32_t fd, const void* buf, int32_t size) { return write(fd, buf, size); }
int32_t NetClose(int32_t fd) { return close(fd); }

14
wii/network.c
View File

@@ -23,4 +23,16 @@ int PrintNetworkAddresses()
{ {
// TODO: Implement // TODO: Implement
return -1; return -1;
} }
char* PrintIpv4Address(struct in_addr addr) { return inet_ntoa(addr); }
int32_t NetSocket(uint32_t domain, uint32_t type, uint32_t protocol) { return net_socket(domain, type, protocol); }
int32_t NetBind(int32_t sockfd, struct sockaddr* addr, socklen_t addrlen) { return net_bind(sockfd, addr, addrlen); }
int32_t NetListen(int32_t sockfd, uint32_t backlog) { return net_listen(sockfd, backlog); }
int32_t NetAccept(int32_t sockfd, struct sockaddr* addr, socklen_t* addrlen)
{
return net_accept(sockfd, addr, addrlen);
}
int32_t NetRecv(int32_t sockfd, void* buf, int32_t len, uint32_t flags) { return net_recv(sockfd, buf, len, flags); }
int32_t NetWrite(int32_t fd, const void* buf, int32_t size) { return net_write(fd, buf, size); }
int32_t NetClose(int32_t fd) { return net_close(fd); }