22 #include <sys/types.h>
23 #include <sys/socket.h>
24 #include <netinet/in.h>
25 #include <sys/select.h>
27 #include <arpa/inet.h>
30 #define WSAGetLastError() (errno)
70 #define NETWORK_CONNECTION_NONE 1
71 #define NETWORK_CONNECTION_DIALUP 2
72 #define NETWORK_CONNECTION_LAN 3
75 #define NETWORK_STATUS_NOT_INITIALIZED 1
76 #define NETWORK_STATUS_NO_WINSOCK 2 // winsock failed to initialize
77 #define NETWORK_STATUS_NO_PROTOCOL 3 // TCP/IP doesn't appear to be loaded
78 #define NETWORK_STATUS_NO_RELIABLE 4
79 #define NETWORK_STATUS_RUNNING 5 // everything should be running
86 #define MAX_TOP_LAYER_PACKET_SIZE 680
90 #define MAX_PACKET_BUFFERS 75
128 #define MAXHOSTNAME 128
130 #define MAX_RECEIVE_BUFSIZE 4096 // 32 K, eh?
131 #define MAX_SEND_RETRIES 20 // number of retries when sending would block
132 #define MAX_LINGER_TIME 0 // in seconds -- when lingering to close a socket
136 #define MAXNETBUFFERS 150 // Maximum network buffers (For between network and upper level functions, which is
138 #define NETRETRYTIME 0.75f // Time after sending before we resend
139 #define MIN_NET_RETRYTIME 0.2f
140 #define NETTIMEOUT 30 // Time after receiving the last packet before we drop that user
141 #define NETHEARTBEATTIME 3 // How often to send a heartbeat
142 #define MAXRELIABLESOCKETS 40 // Max reliable sockets to open at once...
143 #define NETBUFFERSIZE 600 // Max size of a network packet
145 #define RELIABLE_CONNECT_TIME 7 // how long we'll wait for a response when doing a reliable connect
150 #define RNT_ACK 1 // ACK Packet
151 #define RNT_DATA 2 // Data Packet
152 #define RNT_DATA_COMP 3 // Compressed Data Packet
153 #define RNT_REQ_CONN 4 // Requesting a connection
154 #define RNT_DISCONNECT 5 // Disconnecting a connection
155 #define RNT_HEARTBEAT 6 // Heartbeat -- send every NETHEARTBEATTIME
156 #define RNT_I_AM_HERE 7
158 #pragma pack(push, 1)
168 #define RELIABLE_PACKET_HEADER_ONLY_SIZE (sizeof(reliable_header)-NETBUFFERSIZE)
169 #define MAX_PING_HISTORY 10
213 #define CONNECTSEQ 0x142 // Magic number for starting a connection, just so it isn't 0
232 unsigned int psnet_ras_status();
283 l = &Psnet_top_buffers[psnet_type];
317 int SELECT(
int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds,
struct timeval *
timeout,
int psnet_type)
322 if(writefds != NULL){
323 return select(nfds, readfds, writefds, exceptfds, timeout);
331 l = &Psnet_top_buffers[psnet_type];
350 outbuf[0] = (char)psnet_type;
351 memcpy(&outbuf[1], buf, len);
354 return sendto(s, outbuf, len + 1, flags, (
SOCKADDR*)to, tolen);
375 ml_string(
"Network ==> socket not inited in PSNET_TOP_LAYER_PROCESS");
389 if ( select( -1, &rfds, NULL, NULL, &timeout) ==
SOCKET_ERROR ) {
420 from_addr.
port = ntohs( ip_addr.sin_port );
421 memset(from_addr.
addr, 0x00, 6);
423 memcpy(from_addr.
addr, &ip_addr.sin_addr.S_un.S_addr, 4);
425 memcpy(from_addr.
addr, &ip_addr.sin_addr.s_addr, 4);
436 ml_string(
"Socket error on socket_get_data()");
441 int packet_type = packet_read.
data[0];
442 Assertion(((packet_type >= 0) && (packet_type <
PSNET_NUM_TYPES)),
"Invalid packet_type found. Packet type %d does not exist", packet_type);
463 const char *internet_connection;
469 ml_string(
"Skipping psnet_init() because network already running");
476 if ( !
stricmp(internet_connection,
NOX(
"dialup")) ) {
477 ml_string(
"psnet_init() detected dialup connection");
480 }
else if ( !
stricmp(internet_connection,
NOX(
"lan")) ) {
481 ml_string(
"psnet_init() detected lan connection");
485 ml_string(
"psnet_init() detected no connection");
495 if (WSAStartup(0x101, &wsa_data )){
502 if ( (port_num > 1023) && (port_num < USHRT_MAX) ) {
524 rsocket=&Reliable_sockets[j];
532 ml_string(
"No protocol in psnet_init()!");
570 WSACancelBlockingCall();
600 const char *custom_ip = NULL;
604 memset( &Psnet_my_addr, 0,
sizeof(Psnet_my_addr) );
611 switch ( protocol ) {
614 ml_string(
"Network_status != NETWORK_STATUS_RUNNING in NET_TCP in psnet_use_protocol()");
636 if (custom_ip != NULL) {
640 if ( inet_aton(custom_ip, &custom_address.sin_addr) ) {
642 if ( (custom_address.sin_addr.s_addr = inet_addr(custom_ip)) != INADDR_NONE ) {
644 memcpy(&ip_addr.sin_addr, &custom_address.sin_addr,
sizeof(custom_address.sin_addr));
646 ml_printf(
"WARNING => psnet_get_ip() custom IP is invalid: %s", custom_ip);
650 memcpy(Psnet_my_addr.
addr, &ip_addr.sin_addr,
sizeof(ip_addr.sin_addr));
661 Psnet_my_addr.
type = protocol;
709 strcpy( text,
XSTR(
"[no networking]",910) );
715 switch ( address->
type ) {
717 memcpy(&temp_addr.s_addr, address->
addr, 4);
718 strcpy( text, inet_ntoa(temp_addr) );
735 char str[255], *
c, *port;
739 strcpy( text,
XSTR(
"[no networking]",910) );
744 Assert( strlen(text) < 255 );
746 c = strrchr(str,
':');
753 switch ( address->
type ) {
755 addr.s_addr = inet_addr(str);
758 if ( addr.s_addr == INADDR_NONE ) {
759 he = gethostbyname( str );
762 addr.s_addr = ((in_addr *)(he->h_addr))->s_addr;
764 addr.s_addr = INADDR_NONE;
768 memset(address->
addr, 0x00, 6);
769 memcpy(address->
addr, &addr.s_addr, 4);
799 ubyte iaddr[6], *send_data;
802 struct timeval timeout;
808 ml_string(
"Network ==> Socket not inited in psnet_send");
816 memset(iaddr, 0x00, 6);
817 memcpy(iaddr, who_to->
addr, 6);
820 ml_string(
"Network ==> send to address is 0 in psnet_send");
827 ml_printf(
"Network ==> destination port %d invalid in psnet_send", port);
832 send_data = (
ubyte*)data;
836 FD_SET( send_sock, &wfds );
850 if ( !FD_ISSET(send_sock, &wfds ) ){
855 switch ( who_to->
type ) {
857 sockaddr.sin_family = AF_INET;
858 memcpy(&sockaddr.sin_addr.s_addr, iaddr, 4);
859 sockaddr.sin_port = htons(port);
900 ml_string(
"Network ==> Socket not inited in psnet_broadcast");
905 ml_string(
"Cannot broadcast -- returning without doing anything");
909 ubyte broadcast[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
913 switch ( who_to->
type ) {
915 memcpy(who_to->
addr, broadcast, 6);
932 while (
psnet_get( data, &from_addr ) > 0 ) ;
941 struct hostent *host_ent;
945 Assert( strlen(ip_string) < 255 );
947 c = strrchr(str,
':');
952 addr.s_addr = inet_addr(ip_string);
953 if ( addr.s_addr != INADDR_NONE ){
961 host_ent = gethostbyname( ip_string );
984 memcpy(&ack_header.
data,&sig_tmp,
sizeof(
unsigned int));
993 ml_string(
"TCP SENDTO failed in rel_send_ack()");
997 ml_string(
"Unknown protocol type in nw_SendReliable()");
1015 ml_printf(
"Invalid socket id passed to nw_NewCloseSocket() -- %d",*sockp);
1026 if(Reliable_sockets[*sockp].rbuffers[i]){
1027 if(Reliable_sockets[*sockp].rbuffers[i] != NULL){
1028 vm_free(Reliable_sockets[*sockp].rbuffers[i]);
1030 Reliable_sockets[*sockp].
rbuffers[
i] = NULL;
1033 if(Reliable_sockets[*sockp].sbuffers[i]){
1034 if(Reliable_sockets[*sockp].sbuffers[i] != NULL){
1035 vm_free(Reliable_sockets[*sockp].sbuffers[i]);
1037 Reliable_sockets[*sockp].
sbuffers[
i] = NULL;
1049 switch ( Reliable_sockets[*sockp].connection_type ) {
1057 ml_string(
"Unknown protocol type in nw_CloseSocket()!");
1082 ml_printf(
"Invalid socket id passed to psnet_rel_send() -- %d",socketid);
1089 rsocket=&Reliable_sockets[socketid];
1092 ml_printf(
"Can't send packet because of status %d in nw_SendReliable(). socket = %d",rsocket->
status,socketid);
1100 int send_this_packet=1;
1110 memcpy(send_header.
data,data,length);
1116 if (send_this_packet){
1126 ml_string(
"Unknown protocol type in nw_SendReliable()!");
1144 ml_printf(
"PSNET RELIABLE SEND BUFFER OVERRUN. socket = %d",socketid);
1159 ml_printf(
"Invalid socket id passed to nw_NewReceiveReliable() -- %d",socketid);
1162 rsocket = &Reliable_sockets[socketid];
1164 ml_printf(
"Can't receive packet because it isn't connected in nw_ReceiveReliable(). socket = %d",socketid);
1215 switch ( Reliable_sockets[
Serverconn].connection_type ) {
1218 ml_string(
"Unable to use this network connection type in nw_WorkReliable()");
1225 ml_string(
"Unknown protocol type in nw_WorkReliable()!");
1241 int udp_has_data = 0;
1259 memset(&d3_rcv_addr,0,
sizeof(
net_addr));
1260 memset(&rcv_addr,0,
sizeof(
SOCKADDR));
1265 memcpy(d3_rcv_addr.
addr, &tcp_addr->sin_addr.s_addr, 4);
1266 d3_rcv_addr.
port = tcp_addr->sin_port;
1283 if(memcmp(&d3_rcv_addr, &Reliable_sockets[i].m_net_addr,
sizeof(
net_addr)) == 0){
1285 ml_printf(
"Received duplicate connection request. %d",i);
1288 rcv_buff.
type = 0xff;
1294 if(Reliable_sockets[i].status ==
RNF_UNUSED){
1297 memcpy(&Reliable_sockets[i].m_net_addr, &d3_rcv_addr,
sizeof(
net_addr));
1298 memcpy(&Reliable_sockets[i].
addr ,&rcv_addr,
sizeof(
SOCKADDR));
1303 rsocket = &Reliable_sockets[
i];
1305 ml_printf(
"Connect from %s:%d", inet_ntoa(rcvaddr->sin_addr), htons(rcvaddr->sin_port));
1309 if(i==MAXRELIABLESOCKETS){
1311 ml_string(
"Out of incoming reliable connection sockets");
1320 if(memcmp(&d3_rcv_addr,&Reliable_sockets[i].m_net_addr,
sizeof(
net_addr)) == 0){
1321 rsocket=&Reliable_sockets[
i];
1325 if(NULL == rsocket){
1326 ml_string(
"Received reliable data from unconnected client.");
1327 ml_printf(
"Received from %s:%d\n",inet_ntoa(rcvaddr->sin_addr),rcvaddr->sin_port);
1373 sort_ping[
a] = rsocket->
pings[
a];
1376 std::sort(sort_ping, sort_ping + MAX_PING_HISTORY);
1377 rsocket->
mean_ping = ((sort_ping[MAX_PING_HISTORY/2]+sort_ping[(MAX_PING_HISTORY/2)+1]))/2;
1386 unsigned int *acksig = (
unsigned int *)&rcv_buff.
data;
1412 if(seqdelta<0) seqdelta = seqdelta*-1;
1414 ml_string(
"Received reliable packet out of order!");
1440 ml_string(
"Received oversized reliable packet!");
1458 }
while (udp_has_data>0);
1462 rsocket=&Reliable_sockets[j];
1467 ml_printf(
"Reliable (but in limbo) socket (%d) timed out in nw_WorkReliable().",j);
1475 ml_printf(
"Reliable socket (%d) timed out in nw_WorkReliable().",j);
1480 float retry_packet_time;
1518 send_header.
seq = 0;
1532 ml_printf(
"Reliable Socket (%d) timed out in nw_WorkReliable().",j);
1548 return Reliable_sockets[socketid].
status;
1564 ml_string(
"New reliable connection in nw_CheckListenSocket().");
1566 switch ( Reliable_sockets[i].connection_type ){
1569 memset(from_addr, 0x00,
sizeof(
net_addr));
1570 from_addr->
port = ntohs( ip_addr->sin_port );
1573 memcpy(from_addr->
addr, &ip_addr->sin_addr.S_un.S_addr, 4);
1575 memcpy(from_addr->
addr, &ip_addr->sin_addr.s_addr, 4);
1602 float first_sent_req = 0;
1606 struct timeval timeout;
1611 memset(iaddr, 0x00, 6);
1612 memcpy(iaddr, &server_addr->
addr, 6);
1648 memset(&d3_rcv_addr,0,
sizeof(
net_addr));
1650 switch ( server_addr->
type ){
1652 sockaddr.sin_family = AF_INET;
1653 memcpy(&sockaddr.sin_addr.s_addr, iaddr, 4);
1654 sockaddr.sin_port = htons(port);
1660 memcpy(d3_rcv_addr.
addr, &sockaddr.sin_addr.s_addr, 4);
1661 d3_rcv_addr.
port = sockaddr.sin_port;
1667 ml_string(
"Unknown protocol type in nw_ConnectToServer()!");
1681 FD_SET(typeless_sock, &read_fds);
1687 ml_string(
"selected() in psnet_rel_connect_to_server()");
1697 ml_string(
"received data after select in psnet_rel_connect_to_server()");
1699 ml_string(
"about to check ack_header.type");
1701 short *acknum = (
short *)&ack_header.
data;
1708 memcpy(&Reliable_sockets[i].m_net_addr,&d3_rcv_addr,
sizeof(
net_addr));
1710 memcpy(&Reliable_sockets[i].addr,&rcv_addr,
sizeof(
SOCKADDR));
1713 ml_string(
"Successfully connected to server in nw_ConnectToServer().");
1726 ml_string(
"Unable to send packet in nw_ConnectToServer()");
1739 ml_string(
"Out of reliable socket space in nw_ConnectToServer().");
1741 }
else ml_string(
"Received out of sequence ACK in nw_ConnectToServer().");
1742 }
else ml_string(
"Received something that isn't an ACK in nw_ConnectToServer().");
1743 }
else ml_string(
"Received 0 bytes from recvfrom() in nw_ConnectToServer().");
1757 local_address.sin_addr.s_addr = psnet_ras_status();
1758 if(local_address.sin_addr.s_addr == INADDR_NONE){
1759 local_address.sin_addr.s_addr = INADDR_ANY;
1763 #endif // FIXME - always returns INADDR_ANY for LAN
1766 local_address.sin_addr.s_addr = INADDR_ANY;
1769 ml_printf(
"psnet_get_ip() reports IP : %s", inet_ntoa(local_address.sin_addr));
1771 return local_address.sin_addr.s_addr;
1790 if(Reliable_sockets[idx].status !=
RNF_UNUSED){
1840 ml_string(
"WARNING - Buffer overrun in psnet");
1908 int val1,val2,val3,val4;
1912 token = strtok(copy,
".");
1918 if((val1 < 0) || (val1 > 255)){
1924 token = strtok(NULL,
".");
1930 if((val2 < 0) || (val2 > 255)){
1936 token = strtok(NULL,
".");
1942 if((val3 < 0) || (val3 > 255)){
1948 token = strtok(NULL,
"");
1954 if((val4 < 0) || (val4 > 255)){
1960 if((val1 == 0) && (val2 == 0) && (val3 == 0) && (val4 == 0)){
1968 #ifdef _WIN32 // Dial-Up Networking
1973 DWORD (
__stdcall *pRasGetConnectStatus)(HRASCONN hrasconn, LPRASCONNSTATUS lprasconnstatus ) = NULL;
1974 DWORD (
__stdcall *pRasGetProjectionInfo)(HRASCONN hrasconn, RASPROJECTION rasprojection,
LPVOID lpprojection,
LPDWORD lpcb ) = NULL;
1979 unsigned int psnet_ras_status()
1982 unsigned long size, num_connections,
i, valid_connections = 0;
1983 RASCONN rasbuffer[25];
1985 unsigned long rasip=0;
1986 RASPPPIP projection;
1991 ras_handle = LoadLibrary(
"rasapi32.dll" );
1992 if ( ras_handle == NULL ) {
1997 if (!pRasEnumConnections) {
1998 FreeLibrary( ras_handle );
2001 pRasGetConnectStatus = (
DWORD (
__stdcall *)(HRASCONN, LPRASCONNSTATUS))GetProcAddress(ras_handle,
"RasGetConnectStatusA");
2002 if (!pRasGetConnectStatus) {
2003 FreeLibrary( ras_handle );
2006 pRasGetProjectionInfo = (
DWORD (
__stdcall *)(HRASCONN, RASPROJECTION,
LPVOID,
LPDWORD))GetProcAddress(ras_handle,
"RasGetProjectionInfoA");
2007 if (!pRasGetProjectionInfo) {
2008 FreeLibrary( ras_handle );
2012 size =
sizeof(rasbuffer);
2013 rasbuffer[0].dwSize =
sizeof(RASCONN);
2015 rval = pRasEnumConnections( rasbuffer, &size, &num_connections );
2017 FreeLibrary( ras_handle );
2023 if ( num_connections < 1 ) {
2025 FreeLibrary( ras_handle );
2029 ml_printf(
"Found %d connections", num_connections);
2031 for (i = 0; i < num_connections; i++ ) {
2032 RASCONNSTATUS status;
2033 unsigned long dummySize;
2036 if ( !
stricmp(rasbuffer[i].szDeviceType,
"RASDT_Vpn") ) {
2039 valid_connections++;
2043 ml_printf(
"Entry Name: %s", rasbuffer[i].szEntryName);
2044 ml_printf(
"Device Type: %s", rasbuffer[i].szDeviceType);
2045 ml_printf(
"Device Name: %s", rasbuffer[i].szDeviceName);
2048 status.dwSize =
sizeof(RASCONNSTATUS);
2049 rval = pRasGetConnectStatus(rasbuffer[i].hrasconn, &status);
2051 FreeLibrary( ras_handle );
2056 size =
sizeof(projection);
2057 projection.dwSize =
size;
2058 rval = pRasGetProjectionInfo(rasbuffer[i].hrasconn, RASP_PppIp, &projection, &dummySize );
2060 FreeLibrary( ras_handle );
2064 ml_printf(
"IP Address: %s", projection.szIpAddress);
2067 if (!valid_connections) {
2068 FreeLibrary( ras_handle );
2074 FreeLibrary( ras_handle );
2075 rasip = inet_addr(projection.szIpAddress);
2076 if(rasip==INADDR_NONE){
2083 #endif // Dial-Up Networking
2098 if(setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (
LPSTR)&broadcast,
sizeof(broadcast) )){
2108 cursizesize =
sizeof(
int);
2109 getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (
LPSTR)&cursize, &cursizesize);
2110 setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (
LPSTR)&bufsize,
sizeof(bufsize));
2111 getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (
LPSTR)&cursize, &cursizesize);
2112 ml_printf(
"Receive buffer set to %d", cursize);
2115 cursizesize =
sizeof(
int);
2116 getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (
LPSTR)&cursize, &cursizesize);
2117 setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (
LPSTR)&bufsize,
sizeof(bufsize));
2118 getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (
LPSTR)&cursize, &cursizesize);
2119 ml_printf(
"Send buffer set to %d", cursize);
2131 TCP_socket = socket( AF_INET, SOCK_DGRAM, 0 );
2140 sockaddr.sin_family = AF_INET;
2147 ml_printf(
"TCP socket already in use! Another instance running? (Try using the \"-port %i\" cmdline option)",
Psnet_default_port + 1);
reliable_net_rcvbuffer * rbuffers[MAXNETBUFFERS]
#define MIN_NET_RETRYTIME
unsigned short theirsequence
struct network_packet_buffer network_packet_buffer
void psnet_buffer_init(network_packet_buffer_list *l)
int SENDTO(SOCKET s, char *buf, int len, int flags, sockaddr *to, int tolen, int psnet_type)
#define MAX_RECEIVE_BUFSIZE
uint PSNET_SOCKET_RELIABLE
void psnet_mark_received(PSNET_SOCKET_RELIABLE socket)
#define WSAGetLastError()
#define NETWORK_ERROR_CONNECT_TO_ISP
ubyte data[MAX_TOP_LAYER_PACKET_SIZE]
#define NETWORK_ERROR_NO_PROTOCOL
void ml_string(const char *string, int add_time)
void psnet_buffer_packet(network_packet_buffer_list *l, ubyte *data, int length, net_addr *from)
int psnet_rel_send(PSNET_SOCKET_RELIABLE socketid, ubyte *data, int length, int np_index)
#define Assertion(expr, msg,...)
unsigned short rsequence[MAXNETBUFFERS]
int psnet_get(void *data, net_addr *from_addr)
const char * os_config_read_string(const char *section, const char *name, const char *default_value)
#define MAXRELIABLESOCKETS
ushort Psnet_default_port
network_packet_buffer psnet_buffers[MAX_PACKET_BUFFERS]
GLenum GLuint GLenum GLsizei const GLchar * buf
int RECVFROM(SOCKET s, char *buf, int len, int flags, sockaddr *from, int *fromlen, int psnet_type)
int psnet_same(net_addr *a1, net_addr *a2)
int recv_len[MAXNETBUFFERS]
#define PSNET_TYPE_RELIABLE
#define NETWORK_STATUS_NO_PROTOCOL
#define NETWORK_STATUS_RUNNING
typedef int(SCP_EXT_CALLCONV *SCPDLL_PFVERSION)(SCPDLL_Version *)
int psnet_buffer_get_next(network_packet_buffer_list *l, ubyte *data, int *length, net_addr *from)
unsigned short ssequence[MAXNETBUFFERS]
#define MAX_PACKET_BUFFERS
#define NETWORK_CONNECTION_NONE
reliable_socket Reliable_sockets[MAXRELIABLESOCKETS]
void ml_printf(const char *format,...)
int psnet_is_valid_ip_string(char *ip_string, int allow_port)
#define MAX_TOP_LAYER_PACKET_SIZE
#define NETWORK_ERROR_LAN_AND_RAS
GLboolean GLboolean GLboolean GLboolean a
#define NETWORK_STATUS_NO_WINSOCK
#define NETWORK_ERROR_NONE
#define DEFAULT_GAME_PORT
#define PSNET_TYPE_UNRELIABLE
ubyte data[MAX_TOP_LAYER_PACKET_SIZE]
int psnet_send(net_addr *who_to, void *data, int len, int np_index)
#define NETWORK_ERROR_NO_WINSOCK
int psnet_get_network_status()
unsigned short oursequence
int psnet_use_protocol(int protocol)
#define RELIABLE_PACKET_HEADER_ONLY_SIZE
int multi_rate_add(int np_index, char *type, int size)
const char * XSTR(const char *str, int index)
GLbitfield GLuint64 timeout
#define NETWORK_STATUS_NOT_INITIALIZED
float pings[MAX_PING_HISTORY]
ubyte buffer[NETBUFFERSIZE]
int send_len[MAXNETBUFFERS]
void psnet_init(int protocol, int port_num)
void PSNET_TOP_LAYER_PROCESS()
int psnet_broadcast(net_addr *who_to, void *data, int len)
ubyte buffer[NETBUFFERSIZE]
void psnet_socket_options(SOCKET sock)
typedef float(SCP_EXT_CALLCONV *SCPTRACKIR_PFFLOATVOID)()
float timesent[MAXNETBUFFERS]
GLenum GLuint GLsizei bufsize
void psnet_rel_send_ack(SOCKADDR *raddr, unsigned int sig, ubyte link_type, float time_sent)
int psnet_rel_get(PSNET_SOCKET socketid, ubyte *buffer, int max_len)
void psnet_rel_connect_to_server(PSNET_SOCKET *socket, net_addr *server_addr)
int psnet_rel_get_status(PSNET_SOCKET_RELIABLE socketid)
GLenum GLsizei GLenum GLenum const GLvoid * data
#define RELIABLE_CONNECT_TIME
int psnet_is_valid_numeric_ip(char *ip)
int psnet_rel_check_for_listen(net_addr *from_addr)
#define NETWORK_ERROR_NO_TYPE
float last_packet_received
GLenum GLuint GLenum GLsizei length
int SELECT(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout, int psnet_type)
network_packet_buffer_list Psnet_top_buffers[PSNET_NUM_TYPES]
void psnet_string_to_addr(net_addr *address, char *text)
char * psnet_addr_to_string(char *text, net_addr *address)
struct network_packet network_naked_packet
void psnet_rel_close_socket(PSNET_SOCKET_RELIABLE *sockp)
#define NETWORK_CONNECTION_LAN
GLenum const GLvoid * addr
unsigned int num_ping_samples
struct network_packet_buffer_list network_packet_buffer_list
int timer_get_milliseconds()
reliable_net_sendbuffer * sbuffers[MAXNETBUFFERS]
int psnet_init_rel_tcp(int port, int should_listen)
#define NETWORK_CONNECTION_DIALUP