1
0
mirror of https://github.com/solemnwarning/ipxwrapper synced 2024-12-30 16:45:37 +01:00
ipxwrapper/tools/spx-server.c
Daniel Collins 623d2c3df4 Work around some bugs on Windows 98
- Call CreateThread() with non-NULL lpThreadId pointers.

- Ignore InitializeCriticalSectionAndSpinCount() return values.

- Skip log file locking when unimplemented.

- Add missing wsock32.dll entry points.
2024-07-04 21:45:04 +01:00

238 lines
5.2 KiB
C

/* IPXWrapper test tools
* Copyright (C) 2014-2024 Daniel Collins <solemnwarning@solemnwarning.net>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc., 51
* Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <winsock2.h>
#include <windows.h>
#include <wsipx.h>
#include <wsnwlink.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "addr.h"
#include "tools.h"
const int MAX_LISTENERS = 32;
const int MAX_CLIENTS = 32;
const int BUFSIZE = 64;
static void usage(const char *argv0)
{
fprintf(stderr, "Usage: %s\n"
"[-2] [-r] <network number> <node number> <socket number>, ...\n", argv0);
exit(1);
}
static DWORD WINAPI getchar_thread_main(LPVOID lpParameter)
{
getchar();
return 0;
}
int main(int argc, char **argv)
{
setbuf(stdout, NULL);
setbuf(stderr, NULL);
{
WSADATA wsaData;
assert(WSAStartup(MAKEWORD(1,1), &wsaData) == 0);
}
int listeners[MAX_LISTENERS];
int n_listeners = 0;
for(int i = 1; i < argc; i += 3)
{
int protocol = NSPROTO_SPX;
BOOL reuse = FALSE;
while(argv[i][0] == '-')
{
if(strcmp(argv[i], "-2") == 0)
{
protocol = NSPROTO_SPXII;
}
else if(strcmp(argv[i], "-r") == 0)
{
reuse = TRUE;
}
else{
usage(argv[0]);
}
++i;
}
if((argc - i) < 3)
{
usage(argv[0]);
}
int sock = socket(AF_IPX, SOCK_STREAM, protocol);
assert(sock != -1);
assert(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void*)(&reuse), sizeof(reuse)) == 0);
struct sockaddr_ipx bind_addr = read_sockaddr(argv[i], argv[i + 1], argv[i + 2]);
assert(bind(sock, (struct sockaddr*)(&bind_addr), sizeof(bind_addr)) == 0);
assert(listen(sock, 8) == 0);
int addrlen = sizeof(bind_addr);
assert(getsockname(sock, (struct sockaddr*)(&bind_addr), &addrlen) == 0);
assert(bind_addr.sa_family == AF_IPX);
char formatted_addr[IPX_SADDR_SIZE];
ipx_to_string(formatted_addr,
addr32_in(bind_addr.sa_netnum), addr48_in(bind_addr.sa_nodenum), bind_addr.sa_socket);
printf("Bound socket %d to local address: %s\n", sock, formatted_addr);
if(n_listeners == MAX_LISTENERS)
{
fprintf(stderr, "Too many bind addresses given\n");
fprintf(stderr, "Compile with a bigger MAX_LISTENERS\n");
return 1;
}
listeners[n_listeners++] = sock;
}
if(n_listeners == 0)
{
usage(argv[0]);
}
DWORD getchar_thread_id;
HANDLE getchar_thread = CreateThread(NULL, 0, &getchar_thread_main, NULL, 0, &getchar_thread_id);
assert(getchar_thread != NULL);
printf("Ready\n");
int clients[MAX_CLIENTS];
int n_clients = 0;
while(1)
{
fd_set read_fds;
FD_ZERO(&read_fds);
for(int i = 0; i < n_listeners; ++i)
{
FD_SET(listeners[i], &read_fds);
}
for(int i = 0; i < n_clients; ++i)
{
FD_SET(clients[i], &read_fds);
}
struct timeval timeout = {
.tv_sec = 0,
.tv_usec = 100000, /* 1/10th sec */
};
assert(select(n_listeners + n_clients, &read_fds, NULL, NULL, &timeout) >= 0);
if(WaitForSingleObject(getchar_thread, 0) == WAIT_OBJECT_0)
{
/* Input is available on stdin, time to exit. */
break;
}
for(int i = 0; i < n_listeners; ++i)
{
if(FD_ISSET(listeners[i], &read_fds))
{
struct sockaddr_ipx accept_addr;
int addrlen = sizeof(accept_addr);
int newfd = accept(listeners[i], (struct sockaddr*)(&accept_addr), &addrlen);
assert(newfd != -1);
char formatted_addr[IPX_SADDR_SIZE];
ipx_to_string(formatted_addr,
addr32_in(accept_addr.sa_netnum), addr48_in(accept_addr.sa_nodenum), accept_addr.sa_socket);
printf("Accepted new connection on socket %d from %s\n",
newfd, formatted_addr);
if(n_clients < MAX_CLIENTS)
{
clients[n_clients++] = newfd;
}
else{
printf("Closing connection because there are too many sockets\n");
printf("Compile with a bigger MAX_CLIENTS\n");
closesocket(newfd);
}
}
}
for(int i = 0; i < n_clients; ++i)
{
if(FD_ISSET(clients[i], &read_fds))
{
char buf[BUFSIZE];
int len = recv(clients[i], buf, sizeof(buf), 0);
assert(len != -1);
if(len == 0)
{
printf("Read EOF from socket %d, closing\n", clients[i]);
closesocket(clients[i]);
clients[i--] = clients[--n_clients];
}
else{
printf("Read %d bytes from socket %d, returning\n", len, clients[i]);
for(int n = 0; n < len;)
{
int s = send(clients[i], buf + n, len - n, 0);
assert(s != -1);
n += s;
}
}
}
}
}
CloseHandle(getchar_thread);
for(int i = 0; i < n_clients; ++i)
{
closesocket(clients[i]);
}
for(int i = 0; i < n_listeners; ++i)
{
closesocket(listeners[i]);
}
WSACleanup();
return 0;
}