mika/nx-hbmenu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

convert indentation to spaces

Browse Source
This commit is contained in:
Dave Murphy 2018-03-19 14:39:23 +00:00
parent 2ee8c440da
commit 44dea50380
1 changed files with 292 additions and 292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

584
common/netloader.c
View File

@ -53,35 +53,35 @@ unsigned char out[ZLIB_CHUNK];
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
static void netloader_error(const char *func, int err) { static void netloader_error(const char *func, int err) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
char errortext[1024]; char errortext[1024];
sprintf(errortext, "%s: err=%d\n %s\n", func, err, strerror(errno)); sprintf(errortext, "%s: err=%d\n %s\n", func, err, strerror(errno));
menuCreateMsgBox(640,480, errortext); menuCreateMsgBox(640,480, errortext);
netloader_deactivate(); netloader_deactivate();
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
static void netloader_socket_error(const char *func) { static void netloader_socket_error(const char *func) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
int errcode; int errcode;
#ifdef __WIN32__ #ifdef __WIN32__
errcode = WSAGetLastError(); errcode = WSAGetLastError();
#else #else
errcode = errno; errcode = errno;
#endif #endif
netloader_error(func,errcode); netloader_error(func,errcode);
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
void shutdownSocket(int socket) { void shutdownSocket(int socket) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
#ifdef __WIN32__ #ifdef __WIN32__
shutdown (socket, SD_SEND); shutdown (socket, SD_SEND);
closesocket (socket); closesocket (socket);
#else #else
close(socket); close(socket);
#endif #endif
} }
@ -91,23 +91,23 @@ static const char DIRECTORY_PARENT[] = "..";
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
static bool isDirectorySeparator(int c) { static bool isDirectorySeparator(int c) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
return c == DIRECTORY_SEPARATOR_CHAR; return c == DIRECTORY_SEPARATOR_CHAR;
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
static void sanitisePath(char *path) { static void sanitisePath(char *path) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
char *tmpPath = strdup(path); char *tmpPath = strdup(path);
tmpPath[0] = 0; tmpPath[0] = 0;
char *dirStart = path; char *dirStart = path;
char *curPath = tmpPath; char *curPath = tmpPath;
#ifdef _WIN32 #ifdef _WIN32
while(dirStart[0]) { while(dirStart[0]) {
if (dirStart[0] == '/') dirStart[0] =DIRECTORY_SEPARATOR_CHAR; if (dirStart[0] == '/') dirStart[0] =DIRECTORY_SEPARATOR_CHAR;
dirStart++; dirStart++;
} }
#endif #endif
dirStart = path; dirStart = path;
@ -157,139 +157,139 @@ static int set_socket_nonblocking(int sock) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
#ifndef __WIN32__ #ifndef __WIN32__
int flags = fcntl(sock, F_GETFL); int flags = fcntl(sock, F_GETFL);
if(flags == -1) return -1; if(flags == -1) return -1;
int rc = fcntl(sock, F_SETFL, flags | O_NONBLOCK); int rc = fcntl(sock, F_SETFL, flags | O_NONBLOCK);
if(rc != 0) return -1; if(rc != 0) return -1;
#else #else
u_long opt = 1; u_long opt = 1;
ioctlsocket(sock, FIONBIO, &opt); ioctlsocket(sock, FIONBIO, &opt);
#endif #endif
return 0; return 0;
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
static int recvall(int sock, void *buffer, int size, int flags) { static int recvall(int sock, void *buffer, int size, int flags) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
int len, sizeleft = size; int len, sizeleft = size;
while (sizeleft) { while (sizeleft) {
len = recv(sock,buffer,sizeleft,flags); len = recv(sock,buffer,sizeleft,flags);
if (len == 0) { if (len == 0) {
size = 0; size = 0;
break; break;
}; };
if (len != -1) { if (len != -1) {
sizeleft -=len; sizeleft -=len;
buffer +=len; buffer +=len;
} else { } else {
#ifdef _WIN32 #ifdef _WIN32
int errcode = WSAGetLastError(); int errcode = WSAGetLastError();
if (errcode != WSAEWOULDBLOCK) { if (errcode != WSAEWOULDBLOCK) {
netloader_error("win socket error",errcode); netloader_error("win socket error",errcode);
break; break;
} }
#else #else
if ( errno != EWOULDBLOCK && errno != EAGAIN) { if ( errno != EWOULDBLOCK && errno != EAGAIN) {
perror(NULL); perror(NULL);
break; break;
} }
#endif #endif
} }
} }
return size; return size;
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
static int decompress(int sock, FILE *fh, size_t filesize) { static int decompress(int sock, FILE *fh, size_t filesize) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
int ret; int ret;
unsigned have; unsigned have;
z_stream strm; z_stream strm;
size_t chunksize; size_t chunksize;
/* allocate inflate state */ /* allocate inflate state */
strm.zalloc = Z_NULL; strm.zalloc = Z_NULL;
strm.zfree = Z_NULL; strm.zfree = Z_NULL;
strm.opaque = Z_NULL; strm.opaque = Z_NULL;
strm.avail_in = 0; strm.avail_in = 0;
strm.next_in = Z_NULL; strm.next_in = Z_NULL;
ret = inflateInit(&strm); ret = inflateInit(&strm);
if (ret != Z_OK) { if (ret != Z_OK) {
netloader_error("inflateInit failed.",ret); netloader_error("inflateInit failed.",ret);
return ret; return ret;
} }
size_t total = 0; size_t total = 0;
/* decompress until deflate stream ends or end of file */ /* decompress until deflate stream ends or end of file */
do { do {
int len = recvall(sock, &chunksize, 4, 0); int len = recvall(sock, &chunksize, 4, 0);
if (len != 4) { if (len != 4) {
(void)inflateEnd(&strm); (void)inflateEnd(&strm);
netloader_error("Error getting chunk size",len); netloader_error("Error getting chunk size",len);
return Z_DATA_ERROR; return Z_DATA_ERROR;
} }
strm.avail_in = recvall(sock,in,chunksize,0); strm.avail_in = recvall(sock,in,chunksize,0);
if (strm.avail_in == 0) { if (strm.avail_in == 0) {
(void)inflateEnd(&strm); (void)inflateEnd(&strm);
netloader_error("remote closed socket.",0); netloader_error("remote closed socket.",0);
return Z_DATA_ERROR; return Z_DATA_ERROR;
} }
strm.next_in = in; strm.next_in = in;
/* run inflate() on input until output buffer not full */ /* run inflate() on input until output buffer not full */
do { do {
strm.avail_out = ZLIB_CHUNK; strm.avail_out = ZLIB_CHUNK;
strm.next_out = out; strm.next_out = out;
ret = inflate(&strm, Z_NO_FLUSH); ret = inflate(&strm, Z_NO_FLUSH);
switch (ret) { switch (ret) {
case Z_NEED_DICT: case Z_NEED_DICT:
ret = Z_DATA_ERROR; /* and fall through */ ret = Z_DATA_ERROR; /* and fall through */
case Z_DATA_ERROR: case Z_DATA_ERROR:
case Z_MEM_ERROR: case Z_MEM_ERROR:
case Z_STREAM_ERROR: case Z_STREAM_ERROR:
(void)inflateEnd(&strm); (void)inflateEnd(&strm);
netloader_error("inflate error",ret); netloader_error("inflate error",ret);
return ret; return ret;
} }
have = ZLIB_CHUNK - strm.avail_out; have = ZLIB_CHUNK - strm.avail_out;
if (fwrite(out, 1, have, fh) != have || ferror(fh)) { if (fwrite(out, 1, have, fh) != have || ferror(fh)) {
(void)inflateEnd(&strm); (void)inflateEnd(&strm);
netloader_error("file write error",0); netloader_error("file write error",0);
return Z_ERRNO; return Z_ERRNO;
} }
total += have; total += have;
//printf("%zu (%zd%%)",total, (100 * total) / filesize); //printf("%zu (%zd%%)",total, (100 * total) / filesize);
} while (strm.avail_out == 0); } while (strm.avail_out == 0);
/* done when inflate() says it's done */ /* done when inflate() says it's done */
} while (ret != Z_STREAM_END); } while (ret != Z_STREAM_END);
/* clean up and return */ /* clean up and return */
(void)inflateEnd(&strm); (void)inflateEnd(&strm);
return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR; return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
} }
@ -297,279 +297,279 @@ static int decompress(int sock, FILE *fh, size_t filesize) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
int loadnro(menuEntry_s *me, int sock, struct in_addr remote) { int loadnro(menuEntry_s *me, int sock, struct in_addr remote) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
int len, namelen, filelen; int len, namelen, filelen;
char filename[PATH_MAX+1]; char filename[PATH_MAX+1];
len = recvall(sock, &namelen, 4, 0); len = recvall(sock, &namelen, 4, 0);
if (len != 4) { if (len != 4) {
netloader_error("Error getting name length", errno); netloader_error("Error getting name length", errno);
return -1; return -1;
} }
if (namelen >= sizeof(filename)-1) { if (namelen >= sizeof(filename)-1) {
netloader_error("Filename length is too large",errno); netloader_error("Filename length is too large",errno);
return -1; return -1;
} }
len = recvall(sock, filename, namelen, 0); len = recvall(sock, filename, namelen, 0);
if (len != namelen) { if (len != namelen) {
netloader_error("Error getting filename", errno); netloader_error("Error getting filename", errno);
return -1; return -1;
} }
filename[namelen] = 0; filename[namelen] = 0;
len = recvall(sock, &filelen, 4, 0); len = recvall(sock, &filelen, 4, 0);
if (len != 4) { if (len != 4) {
netloader_error("Error getting file length",errno); netloader_error("Error getting file length",errno);
return -1; return -1;
} }
int response = 0; int response = 0;
sanitisePath(filename); sanitisePath(filename);
snprintf(me->path, PATH_MAX, "%s%s%s", menuGetRootPath(), DIRECTORY_SEPARATOR, filename); snprintf(me->path, PATH_MAX, "%s%s%s", menuGetRootPath(), DIRECTORY_SEPARATOR, filename);
// make sure it's terminated // make sure it's terminated
me->path[PATH_MAX] = 0; me->path[PATH_MAX] = 0;
argData_s* ad = &me->args; argData_s* ad = &me->args;
ad->dst = (char*)&ad->buf[1]; ad->dst = (char*)&ad->buf[1];
ad->nxlink_host = remote; ad->nxlink_host = remote;
launchAddArg(ad, me->path); launchAddArg(ad, me->path);
#ifndef _WIN32 #ifndef _WIN32
int fd = open(me->path,O_CREAT|O_WRONLY, ACCESSPERMS); int fd = open(me->path,O_CREAT|O_WRONLY, ACCESSPERMS);
if (fd < 0) { if (fd < 0) {
response = -1; response = -1;
netloader_error("open", errno); netloader_error("open", errno);
} else { } else {
if (ftruncate(fd,filelen) == -1) { if (ftruncate(fd,filelen) == -1) {
response = -2; response = -2;
netloader_error("ftruncate",errno); netloader_error("ftruncate",errno);
} }
close(fd); close(fd);
} }
#endif #endif
FILE *file = NULL; FILE *file = NULL;
if (response == 0) file = fopen(me->path,"wb"); if (response == 0) file = fopen(me->path,"wb");
if(NULL == file) { if(NULL == file) {
perror("file"); perror("file");
response = -1; response = -1;
} }
send(sock,(char *)&response,sizeof(response),0); send(sock,(char *)&response,sizeof(response),0);
if (response == 0 ) { if (response == 0 ) {
//char *writebuffer=malloc(FILE_BUFFER_SIZE); //char *writebuffer=malloc(FILE_BUFFER_SIZE);
//setvbuf(file,writebuffer,_IOFBF, FILE_BUFFER_SIZE); //setvbuf(file,writebuffer,_IOFBF, FILE_BUFFER_SIZE);
//printf("transferring %s\n%d bytes.\n", filename, filelen); //printf("transferring %s\n%d bytes.\n", filename, filelen);
if (decompress(sock,file,filelen)==Z_OK) { if (decompress(sock,file,filelen)==Z_OK) {
int netloaded_cmdlen = 0; int netloaded_cmdlen = 0;
send(sock,(char *)&response,sizeof(response),0); send(sock,(char *)&response,sizeof(response),0);
//printf("\ntransferring command line\n"); //printf("\ntransferring command line\n");
len = recvall(sock,(char*)&netloaded_cmdlen,4,0); len = recvall(sock,(char*)&netloaded_cmdlen,4,0);
len = recvall(sock,me->args.dst, netloaded_cmdlen,0); len = recvall(sock,me->args.dst, netloaded_cmdlen,0);
while(netloaded_cmdlen) { while(netloaded_cmdlen) {
size_t len = strlen(me->args.dst) + 1; size_t len = strlen(me->args.dst) + 1;
ad->dst += len; ad->dst += len;
ad->buf[0]++; ad->buf[0]++;
netloaded_cmdlen -= len; netloaded_cmdlen -= len;
} }
} else { } else {
response = -1; response = -1;
} }
//free(writebuffer); //free(writebuffer);
fflush(file); fflush(file);
fclose(file); fclose(file);
} }
return response; return response;
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
int netloader_activate(void) { int netloader_activate(void) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
struct sockaddr_in serv_addr; struct sockaddr_in serv_addr;
#ifdef __SWITCH__ #ifdef __SWITCH__
socketInitializeDefault(); socketInitializeDefault();
#endif #endif
#ifdef __WIN32__ #ifdef __WIN32__
WSADATA wsa_data; WSADATA wsa_data;
if (WSAStartup (MAKEWORD(2,2), &wsa_data)) { if (WSAStartup (MAKEWORD(2,2), &wsa_data)) {
netloader_error("WSAStartup failed\n",1); netloader_error("WSAStartup failed\n",1);
return 1; return 1;
} }
#endif #endif
memset(&serv_addr, '0', sizeof(serv_addr)); memset(&serv_addr, '0', sizeof(serv_addr));
serv_addr.sin_family = AF_INET; serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(NXLINK_SERVER_PORT); serv_addr.sin_port = htons(NXLINK_SERVER_PORT);
#if PING_ENABLED #if PING_ENABLED
// create udp socket for broadcast ping // create udp socket for broadcast ping
netloader_udpfd = socket(AF_INET, SOCK_DGRAM, 0); netloader_udpfd = socket(AF_INET, SOCK_DGRAM, 0);
if (netloader_udpfd < 0) if (netloader_udpfd < 0)
{ {
netloader_socket_error("udp socket"); netloader_socket_error("udp socket");
return -1; return -1;
} }
if(bind(netloader_udpfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) < 0) { if(bind(netloader_udpfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) < 0) {
netloader_socket_error("bind udp socket"); netloader_socket_error("bind udp socket");
return -1; return -1;
} }
if (set_socket_nonblocking(netloader_udpfd) == -1) if (set_socket_nonblocking(netloader_udpfd) == -1)
{ {
netloader_socket_error("listen fcntl"); netloader_socket_error("listen fcntl");
return -1; return -1;
} }
#endif #endif
// create listening socket on all addresses on NXLINK_SERVER_PORT // create listening socket on all addresses on NXLINK_SERVER_PORT
netloader_listenfd = socket(AF_INET, SOCK_STREAM, 0); netloader_listenfd = socket(AF_INET, SOCK_STREAM, 0);
if(netloader_listenfd < 0) if(netloader_listenfd < 0)
{ {
netloader_socket_error("socket"); netloader_socket_error("socket");
return -1; return -1;
} }
int rc = bind(netloader_listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); int rc = bind(netloader_listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
if(rc != 0) if(rc != 0)
{ {
netloader_socket_error("bind"); netloader_socket_error("bind");
return -1; return -1;
} }
if (set_socket_nonblocking(netloader_listenfd) == -1) if (set_socket_nonblocking(netloader_listenfd) == -1)
{ {
netloader_socket_error("listen fcntl"); netloader_socket_error("listen fcntl");
return -1; return -1;
} }
rc = listen(netloader_listenfd, 10); rc = listen(netloader_listenfd, 10);
if(rc != 0) if(rc != 0)
{ {
netloader_socket_error("listen"); netloader_socket_error("listen");
return -1; return -1;
} }
return 0; return 0;
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
int netloader_deactivate(void) { int netloader_deactivate(void) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// close all remaining sockets and allow mainloop to return to main menu // close all remaining sockets and allow mainloop to return to main menu
if(netloader_listenfd >= 0) if(netloader_listenfd >= 0)
{ {
shutdownSocket(netloader_listenfd); shutdownSocket(netloader_listenfd);
netloader_listenfd = -1; netloader_listenfd = -1;
} }
if(netloader_datafd >= 0) if(netloader_datafd >= 0)
{ {
shutdownSocket(netloader_datafd); shutdownSocket(netloader_datafd);
netloader_datafd = -1; netloader_datafd = -1;
} }
#if PING_ENABLED #if PING_ENABLED
if(netloader_udpfd >= 0) if(netloader_udpfd >= 0)
{ {
shutdownSocket(netloader_udpfd); shutdownSocket(netloader_udpfd);
netloader_udpfd = -1; netloader_udpfd = -1;
} }
#endif #endif
#ifdef __SWITCH__ #ifdef __SWITCH__
socketExit(); socketExit();
#endif #endif
#ifdef __WIN32__ #ifdef __WIN32__
WSACleanup (); WSACleanup ();
#endif #endif
return 0; return 0;
} }
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
int netloader_loop(menuEntry_s *me) { int netloader_loop(menuEntry_s *me) {
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
struct sockaddr_in sa_remote; struct sockaddr_in sa_remote;
#if PING_ENABLED #if PING_ENABLED
char recvbuf[256]; char recvbuf[256];
socklen_t fromlen = sizeof(sa_remote); socklen_t fromlen = sizeof(sa_remote);
int len = recvfrom(netloader_udpfd, recvbuf, sizeof(recvbuf), 0, (struct sockaddr*) &sa_remote, &fromlen); int len = recvfrom(netloader_udpfd, recvbuf, sizeof(recvbuf), 0, (struct sockaddr*) &sa_remote, &fromlen);
if (len!=-1) { if (len!=-1) {
if (strncmp(recvbuf,"nxboot",strlen("nxboot")) == 0) { if (strncmp(recvbuf,"nxboot",strlen("nxboot")) == 0) {
sa_remote.sin_family=AF_INET; sa_remote.sin_family=AF_INET;
sa_remote.sin_port=htons(NXLINK_CLIENT_PORT); sa_remote.sin_port=htons(NXLINK_CLIENT_PORT);
sendto(netloader_udpfd, "bootnx", strlen("bootnx"), 0, (struct sockaddr*) &sa_remote,sizeof(sa_remote)); sendto(netloader_udpfd, "bootnx", strlen("bootnx"), 0, (struct sockaddr*) &sa_remote,sizeof(sa_remote));
} }
} }
#endif #endif
if(netloader_listenfd >= 0 && netloader_datafd < 0) { if(netloader_listenfd >= 0 && netloader_datafd < 0) {
socklen_t addrlen = sizeof(sa_remote); socklen_t addrlen = sizeof(sa_remote);
netloader_datafd = accept(netloader_listenfd, (struct sockaddr*)&sa_remote, &addrlen); netloader_datafd = accept(netloader_listenfd, (struct sockaddr*)&sa_remote, &addrlen);
if(netloader_datafd < 0) if(netloader_datafd < 0)
{ {
#ifdef _WIN32 #ifdef _WIN32
int errcode = WSAGetLastError(); int errcode = WSAGetLastError();
if (errcode != WSAEWOULDBLOCK) { if (errcode != WSAEWOULDBLOCK) {
netloader_error("accept", errcode); netloader_error("accept", errcode);
return -1; return -1;
} }
#else #else
if ( errno != EWOULDBLOCK && errno != EAGAIN) { if ( errno != EWOULDBLOCK && errno != EAGAIN) {
netloader_error("accept", errno); netloader_error("accept", errno);
return -1; return -1;
} }
#endif #endif
} }
else else
{ {
close(netloader_listenfd); close(netloader_listenfd);
netloader_listenfd = -1; netloader_listenfd = -1;
} }
} }
if(netloader_datafd >= 0) if(netloader_datafd >= 0)
{ {
int result = loadnro(me, netloader_datafd,sa_remote.sin_addr); int result = loadnro(me, netloader_datafd,sa_remote.sin_addr);
netloader_deactivate(); netloader_deactivate();
if (result== 0) { if (result== 0) {
return 1; return 1;
} else { } else {
return -1; return -1;
} }
} }
return 0; return 0;
} }