2 * Copyright (C) Volition, Inc. 2005. All rights reserved.
4 * All source code herein is the property of Volition, Inc. You may not sell
5 * or otherwise commercially exploit the source or things you created based on the
11 //Validate tracker user class
15 #include <arpa/inet.h>
16 #include <netinet/in.h>
28 // check structs for size compatibility
29 SDL_COMPILE_TIME_ASSERT(vmt_validate_mission_req_struct, sizeof(vmt_validate_mission_req_struct) == 104);
33 udp_packet_header PacketHeader;
34 validate_id_request *ValidIDReq;
39 struct sockaddr_in rtrackaddr;
47 int MissionValidState;
48 int MissionValidFirstSent;
49 int MissionValidLastSent;
51 // squad war validation
52 int SquadWarValidState;
53 int SquadWarFirstSent;
57 squad_war_response SquadWarValidateResponse;
60 static int SerializeValidatePacket(const udp_packet_header *uph, ubyte *data)
65 PXO_ADD_DATA(uph->type);
66 PXO_ADD_USHORT(uph->len);
67 PXO_ADD_UINT(uph->code);
68 PXO_ADD_USHORT(uph->xcode);
69 PXO_ADD_UINT(uph->sig);
70 PXO_ADD_UINT(uph->security);
73 // no extra data for this
77 case UNT_LOGIN_AUTH_REQUEST: {
78 validate_id_request *id_req = (validate_id_request *)&uph->data;
80 PXO_ADD_DATA(id_req->login);
81 PXO_ADD_DATA(id_req->password);
82 PXO_ADD_DATA(id_req->tracker_id); // junk here, just for size
87 case UNT_VALID_FS2_MSN_REQ: {
88 vmt_validate_mission_req_struct *mis_req = (vmt_validate_mission_req_struct *)&uph->data;
90 PXO_ADD_UINT(mis_req->checksum);
92 memcpy(data+packet_size, mis_req->file_name, strlen(mis_req->file_name));
93 packet_size += strlen(mis_req->file_name);
95 data[packet_size] = '\0';
101 case UNT_VALID_SW_MSN_REQ: {
102 squad_war_request *sw_req = (squad_war_request *)&uph->data;
104 for (i = 0; i < MAX_SQUAD_PLAYERS; i++) {
105 PXO_ADD_INT(sw_req->squad_plr1[i]);
108 for (i = 0; i < MAX_SQUAD_PLAYERS; i++) {
109 PXO_ADD_INT(sw_req->squad_plr2[i]);
112 PXO_ADD_DATA(sw_req->squad_count1);
113 PXO_ADD_DATA(sw_req->squad_count2);
115 PXO_ADD_DATA(sw_req->match_code);
117 PXO_ADD_DATA(sw_req->mission_filename);
118 PXO_ADD_INT(sw_req->mission_checksum);
123 // we shouldn't be sending any other packet types
129 SDL_assert(packet_size >= (int)PACKED_HEADER_ONLY_SIZE);
130 SDL_assert(packet_size == (int)uph->len);
135 static void DeserializeValidatePacket(const ubyte *data, const int data_size, udp_packet_header *uph)
139 memset(uph, 0, sizeof(udp_packet_header));
141 // make sure we received a complete base packet
142 if (data_size < (int)PACKED_HEADER_ONLY_SIZE) {
149 PXO_GET_DATA(uph->type);
150 PXO_GET_USHORT(uph->len);
151 PXO_GET_UINT(uph->code);
152 PXO_GET_USHORT(uph->xcode);
153 PXO_GET_UINT(uph->sig);
154 PXO_GET_UINT(uph->security);
156 // sanity check data size to make sure we reveived all of the expected packet
157 // (not exactly sure what -1 is for, but that's how it is later)
158 if ((int)uph->len-1 > data_size) {
166 // no extra data for these
168 case UNT_CONTROL_VALIDATION:
169 case UNT_LOGIN_NO_AUTH:
170 case UNT_VALID_FS_MSN_RSP:
171 case UNT_VALID_FS2_MSN_RSP:
174 case UNT_LOGIN_AUTHENTICATED: {
175 SDL_strlcpy((char *)uph->data, (const char *)(data+offset), SDL_arraysize(uph->data));
179 case UNT_VALID_SW_MSN_RSP: {
180 squad_war_response *sw_resp = (squad_war_response *)&uph->data;
182 PXO_GET_DATA(sw_resp->reason);
183 PXO_GET_DATA(sw_resp->accepted);
192 //SDL_assert(offset == data_size);
196 int InitValidateClient(void)
198 struct sockaddr_in sockaddr;
202 ValidState = VALID_STATE_IDLE;
204 MissionValidFirstSent = 0;
205 MissionValidLastSent = 0;
206 MissionValidState = VALID_STATE_IDLE;
208 SquadWarFirstSent = 0;
209 SquadWarLastSent = 0;
210 SquadWarValidState = VALID_STATE_IDLE;
213 validsock = socket(AF_INET,SOCK_DGRAM,0);
214 if ( validsock == INVALID_SOCKET )
216 printf("Unable to open a socket.\n");
221 memset( &sockaddr, 0, sizeof(struct sockaddr_in) );
222 sockaddr.sin_family = AF_INET;
223 sockaddr.sin_addr.s_addr = INADDR_ANY;
224 sockaddr.sin_port = 0;
227 if (SOCKET_ERROR==bind(validsock, (struct sockaddr*)&sockaddr, sizeof (sockaddr)))
229 printf("Unable to bind a socket.\n");
230 printf("WSAGetLastError() returned %d.\n",WSAGetLastError());
235 rtrackaddr.sin_family = AF_INET;
236 iaddr = inet_addr( Multi_options_g.user_tracker_ip );
237 if ( iaddr == INADDR_NONE ) {
239 he = gethostbyname( Multi_options_g.user_tracker_ip );
244 // try and resolve by address
245 unsigned int n_order = inet_addr(Multi_user_tracker_ip_address);
246 he = gethostbyaddr((char*)&n_order,4,PF_INET);
253 iaddr = ((in_addr *)(he->h_addr))->s_addr;
256 rtrackaddr.sin_addr.s_addr = iaddr;
257 rtrackaddr.sin_port = htons(REGPORT);
263 //Call with a valid struct to validate a user
264 //Call with NULL to poll
267 // -3 Still waiting (returned if we were waiting for a tracker response and ValidateUser was called with a non-NULL value
268 // -2 Timeout waiting for tracker to respond
270 // 0 Still waiting for response from tracker/Idle
272 int ValidateUser(validate_id_request *valid_id, char *trackerid)
274 ubyte packet_data[sizeof(udp_packet_header)];
275 int packet_length = 0;
282 case VALID_STATE_IDLE:
285 case VALID_STATE_WAITING:
288 case VALID_STATE_VALID:
289 ValidState = VALID_STATE_IDLE;
292 case VALID_STATE_INVALID:
293 ValidState = VALID_STATE_IDLE;
295 case VALID_STATE_TIMEOUT:
296 ValidState = VALID_STATE_IDLE;
303 if(ValidState==VALID_STATE_IDLE)
305 //First, flush the input buffer for the socket
307 struct timeval timeout;
313 FD_SET(Unreliable_socket, &read_fds);
315 while(SELECT(Unreliable_socket+1,&read_fds,NULL,NULL,&timeout, PSNET_TYPE_VALIDATION))
318 struct sockaddr_in fromaddr;
320 udp_packet_header inpacket;
321 addrsize = sizeof(struct sockaddr_in);
322 RECVFROM(Unreliable_socket, (char *)&inpacket,sizeof(udp_packet_header),0,(struct sockaddr *)&fromaddr,&addrsize, PSNET_TYPE_VALIDATION);
324 Psztracker_id = trackerid;
326 //Build the request packet
327 PacketHeader.type = UNT_LOGIN_AUTH_REQUEST;
328 PacketHeader.len = PACKED_HEADER_ONLY_SIZE+sizeof(validate_id_request);
329 ValidIDReq=(validate_id_request *)&PacketHeader.data;
330 SDL_strlcpy(ValidIDReq->login, valid_id->login, SDL_arraysize(ValidIDReq->login));
331 SDL_strlcpy(ValidIDReq->password, valid_id->password, SDL_arraysize(ValidIDReq->password));
333 packet_length = SerializeValidatePacket(&PacketHeader, packet_data);
334 SENDTO(Unreliable_socket, (char *)&packet_data, packet_length, 0, (struct sockaddr *)&rtrackaddr, sizeof(struct sockaddr), PSNET_TYPE_VALIDATION);
335 ValidState = VALID_STATE_WAITING;
336 ValidFirstSent = timer_get_milliseconds();
337 ValidLastSent = timer_get_milliseconds();
351 struct timeval timeout;
352 ubyte packet_data[sizeof(udp_packet_header)];
353 int packet_length = 0;
355 PSNET_TOP_LAYER_PROCESS();
361 FD_SET(Unreliable_socket, &read_fds);
363 if(SELECT(Unreliable_socket+1,&read_fds,NULL,NULL,&timeout, PSNET_TYPE_VALIDATION)){
366 struct sockaddr_in fromaddr;
368 udp_packet_header inpacket;
369 addrsize = sizeof(struct sockaddr_in);
371 bytesin = RECVFROM(Unreliable_socket, (char *)&packet_data, sizeof(udp_packet_header), 0, (struct sockaddr *)&fromaddr, &addrsize, PSNET_TYPE_VALIDATION);
374 DeserializeValidatePacket(packet_data, bytesin, &inpacket);
376 // decrease packet size by 1
380 int wserr=WSAGetLastError();
381 mprintf(("recvfrom() failure. WSAGetLastError() returned %d\n",wserr));
386 FD_SET(Unreliable_socket, &read_fds);
388 //Check to make sure the packets ok
389 if ( (bytesin > 0) && (bytesin == inpacket.len) ) {
390 switch(inpacket.type)
392 case UNT_LOGIN_NO_AUTH:
393 if(ValidState == VALID_STATE_WAITING)
395 ValidState = VALID_STATE_INVALID;
398 case UNT_LOGIN_AUTHENTICATED:
399 if(ValidState == VALID_STATE_WAITING)
401 ValidState = VALID_STATE_VALID;
402 SDL_strlcpy(Psztracker_id, (const char *)&inpacket.data, TRACKER_ID_LEN);
405 // old - this is a Freespace 1 packet type
406 case UNT_VALID_FS_MSN_RSP:
410 // fs2 mission validation response
411 case UNT_VALID_FS2_MSN_RSP:
412 if(MissionValidState == VALID_STATE_WAITING){
413 if(inpacket.code==2){
414 MissionValidState = VALID_STATE_VALID;
416 MissionValidState = VALID_STATE_INVALID;
421 // fs2 squad war validation response
422 case UNT_VALID_SW_MSN_RSP:
423 if(SquadWarValidState == VALID_STATE_WAITING){
425 SDL_assert((bytesin - PACKED_HEADER_ONLY_SIZE) == sizeof(squad_war_response));
426 if((bytesin - PACKED_HEADER_ONLY_SIZE) == sizeof(squad_war_response)){
427 memset(&SquadWarValidateResponse, 0, sizeof(squad_war_response));
428 memcpy(&SquadWarValidateResponse, inpacket.data, sizeof(squad_war_response));
430 // now check to see if we're good
431 if(SquadWarValidateResponse.accepted){
432 SquadWarValidState = VALID_STATE_VALID;
434 SquadWarValidState = VALID_STATE_INVALID;
437 SquadWarValidState = VALID_STATE_INVALID;
442 case UNT_CONTROL_VALIDATION:
450 AckValidServer(inpacket.sig);
454 if(ValidState == VALID_STATE_WAITING)
456 if((timer_get_milliseconds()-ValidFirstSent)>=PILOT_REQ_TIMEOUT)
458 ValidState = VALID_STATE_TIMEOUT;
461 else if((timer_get_milliseconds()-ValidLastSent)>=PILOT_REQ_RESEND_TIME)
464 packet_length = SerializeValidatePacket(&PacketHeader, packet_data);
465 SENDTO(Unreliable_socket, (char *)&packet_data, packet_length, 0, (struct sockaddr *)&rtrackaddr, sizeof(struct sockaddr), PSNET_TYPE_VALIDATION);
466 ValidLastSent = timer_get_milliseconds();
472 //Send an ACK to the server
473 void AckValidServer(unsigned int sig)
475 udp_packet_header ack_pack;
476 ubyte packet_data[sizeof(udp_packet_header)];
477 int packet_length = 0;
479 ack_pack.type = UNT_CONTROL;
481 ack_pack.code = CMD_CLIENT_RECEIVED;
482 ack_pack.len = PACKED_HEADER_ONLY_SIZE;
484 packet_length = SerializeValidatePacket(&ack_pack, packet_data);
485 SDL_assert(packet_length == PACKED_HEADER_ONLY_SIZE);
486 SENDTO(Unreliable_socket, (char *)&packet_data, packet_length, 0, (struct sockaddr *)&rtrackaddr, sizeof(struct sockaddr_in), PSNET_TYPE_VALIDATION);
489 // call with a valid struct to validate a mission
490 // call with NULL to poll
493 // -3 Still waiting (returned if we were waiting for a tracker response and ValidateMission was called with a non-NULL value
494 // -2 Timeout waiting for tracker to respond
496 // 0 Still waiting for response from tracker/Idle
498 int ValidateMission(vmt_validate_mission_req_struct *valid_msn)
500 ubyte packet_data[sizeof(udp_packet_header)];
501 int packet_length = 0;
506 switch(MissionValidState)
508 case VALID_STATE_IDLE:
511 case VALID_STATE_WAITING:
514 case VALID_STATE_VALID:
515 MissionValidState = VALID_STATE_IDLE;
518 case VALID_STATE_INVALID:
519 MissionValidState = VALID_STATE_IDLE;
521 case VALID_STATE_TIMEOUT:
522 MissionValidState = VALID_STATE_IDLE;
529 if(MissionValidState==VALID_STATE_IDLE)
531 //First, flush the input buffer for the socket
533 struct timeval timeout;
539 FD_SET(Unreliable_socket, &read_fds);
541 while(SELECT(Unreliable_socket+1,&read_fds,NULL,NULL,&timeout, PSNET_TYPE_VALIDATION))
544 struct sockaddr_in fromaddr;
546 udp_packet_header inpacket;
547 addrsize = sizeof(struct sockaddr_in);
548 RECVFROM(Unreliable_socket, (char *)&inpacket,sizeof(udp_packet_header),0,(struct sockaddr *)&fromaddr,&addrsize, PSNET_TYPE_VALIDATION);
550 FD_SET(Unreliable_socket, &read_fds);
552 //only send the header, the checksum and the string length plus the null
553 PacketHeader.type = UNT_VALID_FS2_MSN_REQ;
554 PacketHeader.len = (short)(PACKED_HEADER_ONLY_SIZE + sizeof(int)+1+strlen(valid_msn->file_name));
555 memcpy(PacketHeader.data,valid_msn,PacketHeader.len-PACKED_HEADER_ONLY_SIZE);
556 packet_length = SerializeValidatePacket(&PacketHeader, packet_data);
557 SENDTO(Unreliable_socket, (char *)&packet_data, packet_length, 0, (struct sockaddr *)&rtrackaddr, sizeof(struct sockaddr), PSNET_TYPE_VALIDATION);
558 MissionValidState = VALID_STATE_WAITING;
559 MissionValidFirstSent = timer_get_milliseconds();
560 MissionValidLastSent = timer_get_milliseconds();
570 // query the usertracker to validate a squad war match
571 // call with a valid struct to validate a mission
572 // call with NULL to poll
575 // -3 Still waiting (returned if we were waiting for a tracker response and ValidateSquadWae was called with a non-NULL value
576 // -2 Timeout waiting for tracker to respond
578 // 0 Still waiting for response from tracker/Idle
580 int ValidateSquadWar(squad_war_request *sw_req, squad_war_response *sw_resp)
582 ubyte packet_data[sizeof(udp_packet_header)];
583 int packet_length = 0;
587 switch(SquadWarValidState){
588 case VALID_STATE_IDLE:
591 case VALID_STATE_WAITING:
595 // fill in the response
596 case VALID_STATE_VALID:
597 SquadWarValidState = VALID_STATE_IDLE;
599 memcpy(sw_resp, &SquadWarValidateResponse, sizeof(squad_war_response));
603 // fill in the response
604 case VALID_STATE_INVALID:
605 SquadWarValidState = VALID_STATE_IDLE;
607 memcpy(sw_resp, &SquadWarValidateResponse, sizeof(squad_war_response));
611 case VALID_STATE_TIMEOUT:
612 SquadWarValidState = VALID_STATE_IDLE;
617 if(SquadWarValidState==VALID_STATE_IDLE){
618 // First, flush the input buffer for the socket
620 struct timeval timeout;
626 FD_SET(Unreliable_socket, &read_fds);
628 while(SELECT(Unreliable_socket+1,&read_fds,NULL,NULL,&timeout, PSNET_TYPE_VALIDATION)){
630 struct sockaddr_in fromaddr;
632 udp_packet_header inpacket;
633 addrsize = sizeof(struct sockaddr_in);
634 RECVFROM(Unreliable_socket, (char *)&inpacket,sizeof(udp_packet_header),0,(struct sockaddr *)&fromaddr,&addrsize, PSNET_TYPE_VALIDATION);
636 FD_SET(Unreliable_socket, &read_fds);
638 // only send the header, the checksum and the string length plus the null
639 PacketHeader.type = UNT_VALID_SW_MSN_REQ;
640 PacketHeader.len = (short)(PACKED_HEADER_ONLY_SIZE + sizeof(squad_war_request));
641 memcpy(PacketHeader.data, sw_req, PacketHeader.len-PACKED_HEADER_ONLY_SIZE);
642 packet_length = SerializeValidatePacket(&PacketHeader, packet_data);
643 SENDTO(Unreliable_socket, (char *)&packet_data, packet_length, 0, (struct sockaddr *)&rtrackaddr, sizeof(struct sockaddr), PSNET_TYPE_VALIDATION);
644 SquadWarValidState = VALID_STATE_WAITING;
645 SquadWarFirstSent = timer_get_milliseconds();
646 SquadWarLastSent = timer_get_milliseconds();