1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
#ifndef __NET_H
#define __NET_H
#ifdef NETWORK_ENABLED
#ifdef SDL_NET_ENABLED
#include <SDL_net.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/param.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <netinet/tcp.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <arpa/inet.h>
#include <sys/poll.h>
#include <signal.h>
#endif
#endif
#ifndef bool
#define bool int
#endif
typedef struct {
#ifdef NETWORK_ENABLED
#ifdef SDL_NET_ENABLED
IPaddress SDL_address;
#else
struct sockaddr sa;
unsigned char inet_ip[4]; /* AF_INET dotted ip */
#endif
#endif
} NetAddr;
#define MAX_MSG_SIZE 1016
#define PACKET_HEADER_SIZE 8
typedef struct {
NetAddr remote_addr;
int fatal_error; /* code red buffer has been flooded */
int idle_since; /* global time stamp when last packet was received (secs) */
int drop_count; /* number of drops */
int dropped_packet_count; /* number of dropped packets */
int good_packet_count; /* number of successfully processed packets */
int incoming_id; /* last incoming remote outgoing_id */
int outgoing_id; /* packet id increased every sent */
int incoming_code_red; /* id of last incoming code red packet. is sent
in the header to let remote know if any code
red packets were dropped */
int outgoing_code_red; /* last outgoing_id of code_red packet if socket
is still waiting for reception acknowledgment. if
packet was delivered successfully this is cleared
to 0 as well as code_red_buf */
int retransmit_code_red_buf; /* retransmit buffer as net_process_header
has received an incoming_code_red less
than outgoing_code_red */
char code_red_buf[MAX_MSG_SIZE];
char code_red_buf_cur_size;
} NetSocket;
extern NetAddr net_local_addr;
extern NetAddr net_sender_addr;
bool net_init( int port );
void net_shutdown( void );
void net_send_packet( NetAddr *to, int len, void *data );
bool net_recv_packet( void ); /* into net_packet from net_sender_addr */
bool net_build_addr( NetAddr *addr, char *host, int port );
bool net_compare_addr( NetAddr *a1, NetAddr *a2 );
char *net_addr_to_string( NetAddr *addr ); /* not allocated but static */
void msg_begin_writing( char *buf, int *cur_size, int max_size );
void msg_write_int8 ( int c );
void msg_write_int16 ( int s );
void msg_write_int32 ( int i );
void msg_write_string( char *str );
void msg_printf ( char *format, ... );
void msg_write ( int len, void *data );
int msg_get_max_size();
bool msg_write_failed(); /* check wether overflow occured */
bool msg_is_connectionless();
void msg_begin_reading(); /* of net_packet, starts at header */
void msg_begin_connectionless_reading(); /* of net_packet, starts after header as useless data */
int msg_read_int8 ( void );
int msg_read_int16( void );
int msg_read_int32( void );
char* msg_read_string( void );
void msg_read( int len, char *buf );
bool msg_read_failed(); /* check wether data couldn't be extracted */
void socket_init( NetSocket *sock, NetAddr *addr );
void socket_reinit( NetSocket *socket ); /* with same address */
void socket_print_stats( NetSocket *sock );
/* transmit a connectionless message */
void net_transmit_connectionless( NetAddr *addr, int len, char *data );
/* transmit CODE_RED/BLUE message and re-transmit dropped CODE_RED messages.
* length 0 messages are not transmitted but re-transmission of CODE_RED messages
* is handled in any case */
#define CODE_BLUE 0
#define CODE_RED 1
void socket_transmit( NetSocket *sock, int code, int len, char *data );
/* update socket by net_packet header if net_sender_addr is socket.remote_addr
* and set read pointer to packet payload. if false is returned packet is
* not parsed. */
bool socket_process_header( NetSocket *sock );
#endif
|
