openttd-mini: comparison network.c

equal deleted inserted replaced

-:614bba52258d
+:0a7025304867
 static byte *_transmit_file;
 static size_t _transmit_file_size;
 static FILE *_recv_file;
 typedef struct NetworkGameInfo {
 	char server_name[40];			// name of the game
 	char server_revision[8];	// server game version
 	byte server_lang;					// langid
 	byte players_max;					// max players allowed on server
 	byte players_on;					// current count of players on server
 void CSleep(int milliseconds) {
 #if defined(WIN32)
 Sleep(milliseconds);
 #endif
 #if defined(UNIX)
 #if !defined(__BEOS__) && !defined(__MORPHOS__) && !defined(__AMIGAOS__)
 usleep(milliseconds*1000);
 #endif
 #ifdef __BEOS__
 snooze(milliseconds*1000);
 #endif
 #if defined(__MORPHOS__)
 usleep(milliseconds*1000);
 #endif
 #if defined(__AMIGAOS__) && !defined(__MORPHOS__)
 {
 	ULONG signals;
 	ULONG TimerSigBit = 1 << TimerPort->mp_SigBit;
 	// send IORequest
 	TimerRequest->tr_node.io_Command = TR_ADDREQUEST;
 		ClientState *c	= _clients;
 		rp->packet_type = 5;
 		rp->packet_length = sizeof(rp);
 		SendBytes(c, rp, sizeof(rp));
 		_network_ready_sent = true;
 	}
 }
 static void NetworkAcceptClients()
 {
 	s = socket(AF_INET, SOCK_STREAM, 0);
 	if (s == INVALID_SOCKET) error("socket() failed");
 	b = 1;
 	setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (const char*)&b, sizeof(b));
 	sin.sin_family = AF_INET;
 	sin.sin_addr.s_addr = NetworkResolveHost(hostname);
 	sin.sin_port = htons(port);
 	if (connect(s, (struct sockaddr*) &sin, sizeof(sin)) != 0) {
 	return true;
 }
 void NetworkListen()
 {
 	SOCKET ls;
 	struct sockaddr_in sin;
 	int port;
 	port = _network_server_port;
 	DEBUG(net, 1) ("[NET][TCP] listening on port %d", port);
 	ls = socket(AF_INET, SOCK_STREAM, 0);
 	if (ls == INVALID_SOCKET)
 		error("socket() on listen socket failed");
 	// reuse the socket
 	{
 		int reuse = 1; if (setsockopt(ls, SOL_SOCKET, SO_REUSEADDR, (const char*)&reuse, sizeof(reuse)) == -1)
 			error("setsockopt() on listen socket failed");
 	}
 {
 	ClientState *cs;
 	int n;
 	fd_set read_fd, write_fd;
 	struct timeval tv;
 	FD_ZERO(&read_fd);
 	FD_ZERO(&write_fd);
 	for(cs=_clients;cs->socket != INVALID_SOCKET; cs++) {
 		FD_SET(cs->socket, &read_fd);
 				if (!ready_all) {
 					NetworkReceive();
 					CSleep(5);
 					}
 			}
 			_not_packet = 0;
 			new_max = max(_frame_counter + (int)_network_ahead_frames, _frame_counter_max);
 			DEBUG(net,3) ("net: serv: sync max=%i, seed1=%i, seed2=%i",new_max,_sync_seed_1,_sync_seed_2);
 			sp.packet_length = sizeof(sp);
 			sp.packet_type = 1;
 			sp.frames = new_max - _frame_counter_max;
 			sp.server = _frame_counter_max - _frame_counter;
 			sp.random_seed_1 = TO_LE32(_sync_seed_1);
 		}
 }
 void NetworkShutdown()
 {
 	_networking_server = false;
 	_networking = false;
 	_networking_sync = false;
 	_frame_counter = 0;
 	_frame_counter_max = 0;
 	_frame_counter_srv = 0;
 	if (client) { port = _network_client_port; } else { port = _network_server_port; };
 	DEBUG(net, 1) ("[NET][UDP] listening on port %i", port);
 	udp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 	// this disables network
 	_network_available = !(udp == INVALID_SOCKET);
 	// set nonblocking mode for socket
 	{ unsigned long blocking = 1; ioctlsocket(udp, FIONBIO, &blocking); }
 	sin.sin_family = AF_INET;
 	sin.sin_addr.s_addr = 0;
 	sin.sin_port = htons(port);
 	if (bind(udp, (struct sockaddr*)&sin, sizeof(sin)) != 0)
 		DEBUG(net, 1) ("[NET][UDP] error: bind failed on port %i", port);
 	// enable broadcasting
 	{ unsigned long val=1; setsockopt(udp, SOL_SOCKET, SO_BROADCAST, (char *) &val , sizeof(val)); }
 	// allow reusing
 	{ unsigned long val=1; setsockopt(udp, SOL_SOCKET, SO_REUSEADDR, (char *) &val , sizeof(val)); }
 	if (client) { _udp_client_socket = udp; } else { _udp_server_socket = udp; } ;
 }
 void NetworkUDPClose(bool client) {
 	if (client) {
 		DEBUG(net, 1) ("[NET][UDP] closed listener on port %i", _network_client_port);
 		closesocket(_udp_client_socket);
 		_udp_client_socket = INVALID_SOCKET;
 		} else {
 		DEBUG(net, 1) ("[NET][UDP] closed listener on port %i", _network_server_port);
 	LONG client_len; // for some reason we need a 'LONG' under MorphOS
 #endif
 	int nbytes;
 	struct UDPPacket packet;
 	int packet_len;
 	SOCKET udp;
 	if (client) udp=_udp_client_socket; else udp=_udp_server_socket;
 	packet_len = sizeof(packet);
 	client_len = sizeof(client_addr);
 	nbytes = recvfrom(udp, (char *) &packet, packet_len , 0, (struct sockaddr *) &client_addr, &client_len);
 	if (nbytes>0) {
 		if (packet.command_code==packet.command_check) switch (packet.command_code) {
 		case NET_UDPCMD_SERVERSEARCH:
 			if (!client) {
 				packet.command_check=packet.command_code=NET_UDPCMD_SERVERINFO;
 				memcpy(&packet.data,&_network_game,sizeof(_network_game));
 				packet.data_len=sizeof(_network_game);
 				NetworkGameList * item;
 				item = (NetworkGameList *) NetworkGameListAdd();
 				item -> ip = inet_addr(inet_ntoa(client_addr.sin_addr));
 				item -> port = ntohs(client_addr.sin_port);
 				memcpy(item,&packet.data,packet.data_len);
 			}
 			break;
 		}
 	}
 		out_addr.sin_addr.s_addr = bcaddr;
 		res=sendto(udp,(char *) &packet,sizeof(packet),0,(struct sockaddr *) &out_addr,sizeof(out_addr));
 		if (res==-1) DEBUG(net, 1)("udp: broadcast error: %i",GET_LAST_ERROR());
 		i++;
 	}
 }
 void NetworkUDPSend(bool client, struct sockaddr_in recv,struct UDPPacket packet) {
 	SOCKET udp;
 	if (client) udp=_udp_client_socket; else udp=_udp_server_socket;
 	sendto(udp,(char *) &packet,sizeof(packet),0,(struct sockaddr *) &recv,sizeof(recv));
 }
 bool NetworkUDPSearchGame(const byte ** _network_detected_serverip, unsigned short * _network_detected_serverport) {
 	struct UDPPacket packet;
 	int timeout=3000;
 	NetworkGameListClear();
 	DEBUG(net, 0) ("[NET][UDP] searching server");
 	*_network_detected_serverip = "255.255.255.255";
 	*_network_detected_serverport = 0;
 	packet.command_check=packet.command_code=NET_UDPCMD_SERVERSEARCH;
 	packet.data_len=0;
 	NetworkUDPBroadCast(true, packet);
 	while (timeout>=0) {
 		CSleep(100);
 			*_network_detected_serverip=inet_ntoa(*(struct in_addr *) &item->ip);
 			*_network_detected_serverport=item->port;
 			timeout=-1;
 			DEBUG(net, 0) ("[NET][UDP] server found on %s", *_network_detected_serverip);
 			}
 		}
 	return (*_network_detected_serverport>0);
 }
 // *************************** //
 // * New Network Core System * //
 void NetworkIPListInit() {
 	struct hostent* he = NULL;
 	char hostname[250];
 	uint32 bcaddr;
 	int i=0;
 	gethostname(hostname,250);
 	DEBUG(net, 2) ("[NET][IP] init for host %s", hostname);
 	he=gethostbyname((char *) hostname);
 	if (he == NULL) {
 		he = gethostbyname("localhost");
 		}
 	if (he == NULL) {
 		bcaddr = inet_addr("127.0.0.1");
 		he = gethostbyaddr(inet_ntoa(*(struct in_addr *) &bcaddr), sizeof(bcaddr), AF_INET);
 		}
 	if (he == NULL) {
 		DEBUG(net, 2) ("[NET][IP] cannot resolve %s", hostname);
 	} else {
 		while(he->h_addr_list[i]) {
 			bcaddr = inet_addr(inet_ntoa(*(struct in_addr *) he->h_addr_list[i]));
 			_network_ip_list[i]=bcaddr;
 			DEBUG(net, 2) ("[NET][IP] add %s",inet_ntoa(*(struct in_addr *) he->h_addr_list[i]));
 			i++;
 		}
 	}
 	_network_ip_list[i]=0;
 }
 /* *************************************************** */
 void NetworkCoreInit() {
 	if (WSAStartup(MAKEWORD(2,0), &wsa) != 0) {
 		DEBUG(net, 3) ("[NET][Core] error: WSAStartup failed");
 		_network_available=false;
 		}
 }
 #else
 // [morphos/amigaos] bsd-socket startup
 #if defined(__MORPHOS__) || defined(__AMIGA__)
 {
 	// for usleep() implementation (only required for legacy AmigaOS builds)
 	if ( (TimerPort = CreateMsgPort()) ) {
 		if ( (TimerRequest = (struct timerequest *) CreateIORequest(TimerPort, sizeof(struct timerequest))) ) {
 			if ( OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest *) TimerRequest, 0) == 0 ) {
 				if ( !(TimerBase = TimerRequest->tr_node.io_Device) ) {
 					// free ressources...
 					DEBUG(net, 3) ("[NET][Core] Couldn't initialize timer.");
 					_network_available=false;
 				}
 			}
 		}
 	}
 	#endif
 }
 #else
 // [linux/macos] unix-socket startup
 void NetworkCoreShutdown() {
 DEBUG(net, 3) ("[NET][Core] shutdown()");
 #if defined(__MORPHOS__) || defined(__AMIGA__)
 {
 	// free allocated ressources
 	#if !defined(__MORPHOS__)
 if (TimerBase)    { CloseDevice((struct IORequest *) TimerRequest); }
 if (TimerRequest) { DeleteIORequest(TimerRequest); }
 if (TimerPort)    { DeleteMsgPort(TimerPort); }
 	#endif
 	NetworkInitialize();
 	_networking = NetworkConnect(b, port);
 	if (_networking) {
 		NetworkLobbyShutdown();
 	} else {
 		if (_networking_override)
 			NetworkLobbyShutdown();
 		ShowErrorMessage(-1, STR_NETWORK_ERR_NOCONNECTION,0,0);
 		_switch_mode_errorstr = STR_NETWORK_ERR_NOCONNECTION;
 	}
 	return _networking;
 }
 {
 	/* terminate server */
 	if (_networking_server) {
 		NetworkUDPClose(false);
 		NetworkClose(false);
 		}
 	/* terminate client connection */
 	else if (_networking) {
 		NetworkClose(true);
 		}
 	NetworkShutdown();
 }
 /* *************************************************** */
 // * Network Game List Extensions * //
 // ******************************** //
 void NetworkGameListClear() {
 NetworkGameList * item;
 NetworkGameList * next;
 DEBUG(net, 4) ("[NET][G-List] cleared server list");
 item = _network_game_list;
 while (item != NULL) {
 _network_game_count=0;
 }
 char * NetworkGameListAdd() {
 NetworkGameList * item;
 NetworkGameList * before;
 DEBUG(net, 4) ("[NET][G-List] added server to list");
 item = _network_game_list;
 before = item;
 }
 char * NetworkGameListItem(uint16 index) {
 NetworkGameList * item;
 NetworkGameList * next;
 uint16 cnt = 0;
 item = _network_game_list;
 while ((item != NULL) && (cnt != index)) {
 void NetworkGameFillDefaults() {
 	NetworkGameInfo * game = &_network_game;
 #if defined(WITH_REV)
 	extern char _openttd_revision[];
 #endif
 	DEBUG(net, 4) ("[NET][G-Info] setting defaults");
 	ttd_strlcpy(game->server_name,"OpenTTD Game",13);
 	game->game_password[0]='\0';
 	game->map_name[0]='\0';
 	game->map_width=0;
 	game->map_set=0;
 	game->players_max=8;
 	game->players_on=0;
 	game->server_lang=_dynlang.curr;
 }
 void NetworkGameChangeDate(uint16 newdate) {
 	if (_networking_server) {

changeset 193	0a7025304867
parent 188	30f27b5c1ee5
child 206	7f8c26d8526b