Daodan/MSVC/Flatline_Net.c

#include "Flatline.h"
#include "Flatline_Server.h"


#define TRACK_PACKETS

/*thread */int UDPServer_Socket = 0;


bool NetUDPServer_Listen(uint16_t port, bool (*packet_callback)(char* data, int datalen, int from))
{
        sockaddr_in address;    
        UDPServer_Socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        
        if (UDPServer_Socket < 0)
        {
                DDrConsole_PrintF("could not create socket");
                return false;
        }
        

        memset(&address, 0, sizeof(sockaddr_in));
        address.sin_family = AF_INET;
        address.sin_addr.s_addr = htonl(INADDR_ANY);
        address.sin_port = htons(port);
        
        if (bind(UDPServer_Socket, (sockaddr*)&address, sizeof(sockaddr_in)) < 0)
        {
                DDrConsole_PrintF("could not bind port %d", port);
                closesocket(UDPServer_Socket);
                return false;
        }
        else {


                char data[65537] = {0};
        
                sockaddr_in from;
                int recvlen;
                FLrServer_Initialize();
                for (;;)
                {
                        int fromlen = sizeof(sockaddr_in);
                        memset(&from, 0, sizeof(sockaddr_in));
                        recvlen = recvfrom(UDPServer_Socket, data, 65537 - 1, 0, (sockaddr*)&from, (void*)&fromlen);

                        if (!packet_callback(data, recvlen, ntohl(from.sin_addr.s_addr)))
                                break; 
                }
                closesocket(UDPServer_Socket);
                return true;
        }
}

bool NetUDPServer_Send(sockaddr* address, flatline_packet* data, int datalen)
{
        //DDrConsole_PrintF("Sending data size %u to %s on socket %i", datalen, inet_ntoa( ((sockaddr_in*)address)->sin_addr ), UDPServer_Socket);
        //data->FLATLINE = *(int*)"FLATLINE";
        return NetUDPSocket_Send(UDPServer_Socket, address, data, datalen);
}

int client_sock = 0;
sockaddr_in client_address;

int NetUDPSocket_Create(uint16_t port)
{
        int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        sockaddr_in address;    
                unsigned long nonBlocking = 1;
        if (sock < 0)
        {
                DDrConsole_PrintF("could not create socket");
                return -1;
        }
        

        memset(&client_address, 0, sizeof(sockaddr_in));
        address.sin_family = AF_INET;
        address.sin_addr.s_addr = htonl(INADDR_ANY);
        address.sin_port =  htons(port);
        
        if (bind(sock, (sockaddr*)&address, sizeof(sockaddr_in)) < 0)
        {
                DDrConsole_PrintF("could not bind port %d", port);
                return false;
        }
        

        if (ioctlsocket(sock, FIONBIO, &nonBlocking))
        {
                DDrConsole_PrintF("failed to set non-blocking socket");
                return false;
        }
        client_sock = sock;
        client_address = address;
        return sock;
}

int NetTCPSocket_Create(uint16_t port)
{
        int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        sockaddr_in address;
                unsigned long nonBlocking = 1;

        if (sock < 0)
        {
                DDrConsole_PrintF("could not create socket");
                return -1;
        }
        

        memset(&client_address, 0, sizeof(sockaddr_in));
        address.sin_family = AF_INET;
        address.sin_addr.s_addr = htonl(INADDR_ANY);
        address.sin_port =  htons(port);
        
        if (bind(sock, (sockaddr*)&address, sizeof(sockaddr_in)) < 0)
        {
                DDrConsole_PrintF("could not bind port %d", port);
                return false;
        }
        

        if (ioctlsocket(sock, FIONBIO, &nonBlocking))
        {
                DDrConsole_PrintF("failed to set non-blocking socket");
                return false;
        }
        client_sock = sock;
        client_address = address;
        return sock;
}


void NetUDPSocket_Close(int socket)
{
        closesocket(socket);
}

int NetUDPSocket_Send(int socket, const sockaddr* address, flatline_packet* data, int datalen)
{
        //currently only protects against duplicate packets.
        int addr_size;
#ifdef TRACK_PACKETS
        static uint32_t packet_index = 0;
        packet_index = (packet_index + 1);
        data->packet_index = packet_index;
#endif
        //data->FLATLINE = *(int*)"FLATLINE";
        switch (address->sa_family)
        {
                case AF_INET:
                        addr_size = sizeof(sockaddr_in);
                        break;
                case AF_INET6:
                        addr_size = sizeof(sockaddr_in6);
                        break;
                default:
                        addr_size = sizeof(sockaddr_storage);
        }
        return sendto(socket, data, datalen, 0, address, addr_size);
}

#ifdef TRACK_PACKETS
uint32_t last_packet = -1;
#endif

bool NetUDPSocket_Recieve(int socket, sockaddr_storage* address, char* data, uint16_t* datalen)
{
        int address_size = sizeof(sockaddr_storage);
        uint32_t msg_size = recvfrom(socket, data, 1400, 0, (SOCKADDR *)address, &address_size);
        if (msg_size == 0)
                return false;
        else if (msg_size == SOCKET_ERROR) {
                int errorno = WSAGetLastError();
                if (errorno == WSAEWOULDBLOCK) return false; //no packets.
                else {
                        //DDrConsole_PrintF("Packet type %i", ((flatline_packet*)data)->id);
                        NetCatchError();
                        return false;
                }
        }       
        /*
#ifdef TRACK_PACKETS
        if(client_connected && !server_started) {
                uint32_t index_mkr = ((flatline_packet*)(data))->packet_index;
                //fancy way of checking if index_mkr is on one side of the max size of an int and last_packet is on the other
                if( ((index_mkr - last_packet < 0x80000000) && (index_mkr > last_packet))
                //if it is, subtract half the size of an int from each. ^_^
                        || ((index_mkr - 0x80000000) > (last_packet - 0x80000000) ) )
                {
                        return false;
                }
                else {
                        last_packet = index_mkr;
                }
        }
        
#endif
        */

        *datalen = msg_size;                            
        return true;
        
}


DWORD WINAPI StartServer(void* lol){
        if(NetPlatform_Initalize() && FlatlineInitialize())
        {
                FLrServer_Run();
        }
        return 0;
} 

DWORD WINAPI StartClient(void* lol){
        //NetPlatform_Initalize();
        if(FlatlineInitialize())
        {
                FLrClient_Run((flatline_packet*)lol);
        }
        return 0;
} 
void NetCatchError(){
        char Message[1024];
        int errorno = WSAGetLastError();
        if(errno == WSAEWOULDBLOCK) {
                return;
        }
#ifdef WIN32

        FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS |
                FORMAT_MESSAGE_MAX_WIDTH_MASK, NULL, errorno,
                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                (LPSTR) Message, 1024, NULL);
        DDrConsole_Print(Message);
#endif

}
Revision:	584
Committed:	Mon Jan 24 06:45:07 2011 UTC (14 years, 8 months ago) by gumby
Content type:	text/x-csrc
File size:	5762 byte(s)
Log Message:	Almost working rework
#	Content
1	#include "Flatline.h"
2	#include "Flatline_Server.h"
3
4
5	#define TRACK_PACKETS
6
7	/thread /int UDPServer_Socket = 0;
8
9
10
11
12	bool NetUDPServer_Listen(uint16_t port, bool (packet_callback)(char data, int datalen, int from))
13	{
14	sockaddr_in address;
15	UDPServer_Socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
16
17	if (UDPServer_Socket < 0)
18	{
19	DDrConsole_PrintF("could not create socket");
20	return false;
21	}
22
23
24	memset(&address, 0, sizeof(sockaddr_in));
25	address.sin_family = AF_INET;
26	address.sin_addr.s_addr = htonl(INADDR_ANY);
27	address.sin_port = htons(port);
28
29	if (bind(UDPServer_Socket, (sockaddr*)&address, sizeof(sockaddr_in)) < 0)
30	{
31	DDrConsole_PrintF("could not bind port %d", port);
32	closesocket(UDPServer_Socket);
33	return false;
34	}
35	else {
36
37
38	char data[65537] = {0};
39
40	sockaddr_in from;
41	int recvlen;
42	FLrServer_Initialize();
43	for (;;)
44	{
45	int fromlen = sizeof(sockaddr_in);
46	memset(&from, 0, sizeof(sockaddr_in));
47	recvlen = recvfrom(UDPServer_Socket, data, 65537 - 1, 0, (sockaddr)&from, (void)&fromlen);
48
49	if (!packet_callback(data, recvlen, ntohl(from.sin_addr.s_addr)))
50	break;
51	}
52	closesocket(UDPServer_Socket);
53	return true;
54	}
55	}
56
57	bool NetUDPServer_Send(sockaddr* address, flatline_packet* data, int datalen)
58	{
59	//DDrConsole_PrintF("Sending data size %u to %s on socket %i", datalen, inet_ntoa( ((sockaddr_in*)address)->sin_addr ), UDPServer_Socket);
60	//data->FLATLINE = (int)"FLATLINE";
61	return NetUDPSocket_Send(UDPServer_Socket, address, data, datalen);
62	}
63
64	int client_sock = 0;
65	sockaddr_in client_address;
66
67	int NetUDPSocket_Create(uint16_t port)
68	{
69	int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
70	sockaddr_in address;
71	unsigned long nonBlocking = 1;
72	if (sock < 0)
73	{
74	DDrConsole_PrintF("could not create socket");
75	return -1;
76	}
77
78
79	memset(&client_address, 0, sizeof(sockaddr_in));
80	address.sin_family = AF_INET;
81	address.sin_addr.s_addr = htonl(INADDR_ANY);
82	address.sin_port = htons(port);
83
84	if (bind(sock, (sockaddr*)&address, sizeof(sockaddr_in)) < 0)
85	{
86	DDrConsole_PrintF("could not bind port %d", port);
87	return false;
88	}
89
90
91	if (ioctlsocket(sock, FIONBIO, &nonBlocking))
92	{
93	DDrConsole_PrintF("failed to set non-blocking socket");
94	return false;
95	}
96	client_sock = sock;
97	client_address = address;
98	return sock;
99	}
100
101	int NetTCPSocket_Create(uint16_t port)
102	{
103	int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
104	sockaddr_in address;
105	unsigned long nonBlocking = 1;
106
107	if (sock < 0)
108	{
109	DDrConsole_PrintF("could not create socket");
110	return -1;
111	}
112
113
114	memset(&client_address, 0, sizeof(sockaddr_in));
115	address.sin_family = AF_INET;
116	address.sin_addr.s_addr = htonl(INADDR_ANY);
117	address.sin_port = htons(port);
118
119	if (bind(sock, (sockaddr*)&address, sizeof(sockaddr_in)) < 0)
120	{
121	DDrConsole_PrintF("could not bind port %d", port);
122	return false;
123	}
124
125
126	if (ioctlsocket(sock, FIONBIO, &nonBlocking))
127	{
128	DDrConsole_PrintF("failed to set non-blocking socket");
129	return false;
130	}
131	client_sock = sock;
132	client_address = address;
133	return sock;
134	}
135
136
137	void NetUDPSocket_Close(int socket)
138	{
139	closesocket(socket);
140	}
141
142	int NetUDPSocket_Send(int socket, const sockaddr* address, flatline_packet* data, int datalen)
143	{
144	//currently only protects against duplicate packets.
145	int addr_size;
146	#ifdef TRACK_PACKETS
147	static uint32_t packet_index = 0;
148	packet_index = (packet_index + 1);
149	data->packet_index = packet_index;
150	#endif
151	//data->FLATLINE = (int)"FLATLINE";
152	switch (address->sa_family)
153	{
154	case AF_INET:
155	addr_size = sizeof(sockaddr_in);
156	break;
157	case AF_INET6:
158	addr_size = sizeof(sockaddr_in6);
159	break;
160	default:
161	addr_size = sizeof(sockaddr_storage);
162	}
163	return sendto(socket, data, datalen, 0, address, addr_size);
164	}
165
166	#ifdef TRACK_PACKETS
167	uint32_t last_packet = -1;
168	#endif
169
170	bool NetUDPSocket_Recieve(int socket, sockaddr_storage* address, char* data, uint16_t* datalen)
171	{
172	int address_size = sizeof(sockaddr_storage);
173	uint32_t msg_size = recvfrom(socket, data, 1400, 0, (SOCKADDR *)address, &address_size);
174	if (msg_size == 0)
175	return false;
176	else if (msg_size == SOCKET_ERROR) {
177	int errorno = WSAGetLastError();
178	if (errorno == WSAEWOULDBLOCK) return false; //no packets.
179	else {
180	//DDrConsole_PrintF("Packet type %i", ((flatline_packet*)data)->id);
181	NetCatchError();
182	return false;
183	}
184	}
185	/*
186	#ifdef TRACK_PACKETS
187	if(client_connected && !server_started) {
188	uint32_t index_mkr = ((flatline_packet*)(data))->packet_index;
189	//fancy way of checking if index_mkr is on one side of the max size of an int and last_packet is on the other
190	if( ((index_mkr - last_packet < 0x80000000) && (index_mkr > last_packet))
191	//if it is, subtract half the size of an int from each. ^_^
192	\|\| ((index_mkr - 0x80000000) > (last_packet - 0x80000000) ) )
193	{
194	return false;
195	}
196	else {
197	last_packet = index_mkr;
198	}
199	}
200
201	#endif
202	*/
203
204	*datalen = msg_size;
205	return true;
206
207	}
208
209
210
211	DWORD WINAPI StartServer(void* lol){
212	if(NetPlatform_Initalize() && FlatlineInitialize())
213	{
214	FLrServer_Run();
215	}
216	return 0;
217	}
218
219	DWORD WINAPI StartClient(void* lol){
220	//NetPlatform_Initalize();
221	if(FlatlineInitialize())
222	{
223	FLrClient_Run((flatline_packet*)lol);
224	}
225	return 0;
226	}
227	void NetCatchError(){
228	char Message[1024];
229	int errorno = WSAGetLastError();
230	if(errno == WSAEWOULDBLOCK) {
231	return;
232	}
233	#ifdef WIN32
234
235	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM \| FORMAT_MESSAGE_IGNORE_INSERTS \|
236	FORMAT_MESSAGE_MAX_WIDTH_MASK, NULL, errorno,
237	MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
238	(LPSTR) Message, 1024, NULL);
239	DDrConsole_Print(Message);
240	#endif
241
242	}