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;
371 addrsize = sizeof(struct sockaddr_in);
373 bytesin = RECVFROM(Unreliable_socket, (char *)&packet_data, sizeof(udp_packet_header), 0, (struct sockaddr *)&fromaddr, &addrsize, PSNET_TYPE_VALIDATION);
376 DeserializeValidatePacket(packet_data, bytesin, &inpacket);
378 // decrease packet size by 1
382 int wserr=WSAGetLastError();
383 mprintf(("recvfrom() failure. WSAGetLastError() returned %d\n",wserr));
388 FD_SET(Unreliable_socket, &read_fds);
390 //Check to make sure the packets ok
391 if ( (bytesin > 0) && (bytesin == inpacket.len) ) {
392 switch(inpacket.type)
394 case UNT_LOGIN_NO_AUTH:
395 if(ValidState == VALID_STATE_WAITING)
397 ValidState = VALID_STATE_INVALID;
400 case UNT_LOGIN_AUTHENTICATED:
401 if(ValidState == VALID_STATE_WAITING)
403 ValidState = VALID_STATE_VALID;
404 SDL_strlcpy(Psztracker_id, (const char *)&inpacket.data, TRACKER_ID_LEN);
407 // old - this is a Freespace 1 packet type
408 case UNT_VALID_FS_MSN_RSP:
412 // fs2 mission validation response
413 case UNT_VALID_FS2_MSN_RSP:
414 if(MissionValidState == VALID_STATE_WAITING){
415 if(inpacket.code==2){
416 MissionValidState = VALID_STATE_VALID;
418 MissionValidState = VALID_STATE_INVALID;
423 // fs2 squad war validation response
424 case UNT_VALID_SW_MSN_RSP:
425 if(SquadWarValidState == VALID_STATE_WAITING){
427 SDL_assert((bytesin - PACKED_HEADER_ONLY_SIZE) == sizeof(squad_war_response));
428 if((bytesin - PACKED_HEADER_ONLY_SIZE) == sizeof(squad_war_response)){
429 memset(&SquadWarValidateResponse, 0, sizeof(squad_war_response));
430 memcpy(&SquadWarValidateResponse, inpacket.data, sizeof(squad_war_response));
432 // now check to see if we're good
433 if(SquadWarValidateResponse.accepted){
434 SquadWarValidState = VALID_STATE_VALID;
436 SquadWarValidState = VALID_STATE_INVALID;
439 SquadWarValidState = VALID_STATE_INVALID;
444 case UNT_CONTROL_VALIDATION:
452 AckValidServer(inpacket.sig);
456 if(ValidState == VALID_STATE_WAITING)
458 if((timer_get_milliseconds()-ValidFirstSent)>=PILOT_REQ_TIMEOUT)
460 ValidState = VALID_STATE_TIMEOUT;
463 else if((timer_get_milliseconds()-ValidLastSent)>=PILOT_REQ_RESEND_TIME)
466 packet_length = SerializeValidatePacket(&PacketHeader, packet_data);
467 SENDTO(Unreliable_socket, (char *)&packet_data, packet_length, 0, (struct sockaddr *)&rtrackaddr, sizeof(struct sockaddr), PSNET_TYPE_VALIDATION);
468 ValidLastSent = timer_get_milliseconds();
474 //Send an ACK to the server
475 void AckValidServer(unsigned int sig)
477 udp_packet_header ack_pack;
478 ubyte packet_data[sizeof(udp_packet_header)];
479 int packet_length = 0;
481 ack_pack.type = UNT_CONTROL;
483 ack_pack.code = CMD_CLIENT_RECEIVED;
484 ack_pack.len = PACKED_HEADER_ONLY_SIZE;
486 packet_length = SerializeValidatePacket(&ack_pack, packet_data);
487 SDL_assert(packet_length == PACKED_HEADER_ONLY_SIZE);
488 SENDTO(Unreliable_socket, (char *)&packet_data, packet_length, 0, (struct sockaddr *)&rtrackaddr, sizeof(struct sockaddr_in), PSNET_TYPE_VALIDATION);
491 // call with a valid struct to validate a mission
492 // call with NULL to poll
495 // -3 Still waiting (returned if we were waiting for a tracker response and ValidateMission was called with a non-NULL value
496 // -2 Timeout waiting for tracker to respond
498 // 0 Still waiting for response from tracker/Idle
500 int ValidateMission(vmt_validate_mission_req_struct *valid_msn)
502 ubyte packet_data[sizeof(udp_packet_header)];
503 int packet_length = 0;
508 switch(MissionValidState)
510 case VALID_STATE_IDLE:
513 case VALID_STATE_WAITING:
516 case VALID_STATE_VALID:
517 MissionValidState = VALID_STATE_IDLE;
520 case VALID_STATE_INVALID:
521 MissionValidState = VALID_STATE_IDLE;
523 case VALID_STATE_TIMEOUT:
524 MissionValidState = VALID_STATE_IDLE;
531 if(MissionValidState==VALID_STATE_IDLE)
533 //First, flush the input buffer for the socket
535 struct timeval timeout;
541 FD_SET(Unreliable_socket, &read_fds);
543 while(SELECT(Unreliable_socket+1,&read_fds,NULL,NULL,&timeout, PSNET_TYPE_VALIDATION))
546 struct sockaddr_in fromaddr;
548 udp_packet_header inpacket;
549 addrsize = sizeof(struct sockaddr_in);
550 RECVFROM(Unreliable_socket, (char *)&inpacket,sizeof(udp_packet_header),0,(struct sockaddr *)&fromaddr,&addrsize, PSNET_TYPE_VALIDATION);
552 FD_SET(Unreliable_socket, &read_fds);
554 //only send the header, the checksum and the string length plus the null
555 PacketHeader.type = UNT_VALID_FS2_MSN_REQ;
556 PacketHeader.len = (short)(PACKED_HEADER_ONLY_SIZE + sizeof(int)+1+strlen(valid_msn->file_name));
557 memcpy(PacketHeader.data,valid_msn,PacketHeader.len-PACKED_HEADER_ONLY_SIZE);
558 packet_length = SerializeValidatePacket(&PacketHeader, packet_data);
559 SENDTO(Unreliable_socket, (char *)&packet_data, packet_length, 0, (struct sockaddr *)&rtrackaddr, sizeof(struct sockaddr), PSNET_TYPE_VALIDATION);
560 MissionValidState = VALID_STATE_WAITING;
561 MissionValidFirstSent = timer_get_milliseconds();
562 MissionValidLastSent = timer_get_milliseconds();
572 // query the usertracker to validate a squad war match
573 // call with a valid struct to validate a mission
574 // call with NULL to poll
577 // -3 Still waiting (returned if we were waiting for a tracker response and ValidateSquadWae was called with a non-NULL value
578 // -2 Timeout waiting for tracker to respond
580 // 0 Still waiting for response from tracker/Idle
582 int ValidateSquadWar(squad_war_request *sw_req, squad_war_response *sw_resp)
584 ubyte packet_data[sizeof(udp_packet_header)];
585 int packet_length = 0;
589 switch(SquadWarValidState){
590 case VALID_STATE_IDLE:
593 case VALID_STATE_WAITING:
597 // fill in the response
598 case VALID_STATE_VALID:
599 SquadWarValidState = VALID_STATE_IDLE;
601 memcpy(sw_resp, &SquadWarValidateResponse, sizeof(squad_war_response));
605 // fill in the response
606 case VALID_STATE_INVALID:
607 SquadWarValidState = VALID_STATE_IDLE;
609 memcpy(sw_resp, &SquadWarValidateResponse, sizeof(squad_war_response));
613 case VALID_STATE_TIMEOUT:
614 SquadWarValidState = VALID_STATE_IDLE;
619 if(SquadWarValidState==VALID_STATE_IDLE){
620 // First, flush the input buffer for the socket
622 struct timeval timeout;
628 FD_SET(Unreliable_socket, &read_fds);
630 while(SELECT(Unreliable_socket+1,&read_fds,NULL,NULL,&timeout, PSNET_TYPE_VALIDATION)){
632 struct sockaddr_in fromaddr;
634 udp_packet_header inpacket;
635 addrsize = sizeof(struct sockaddr_in);
636 RECVFROM(Unreliable_socket, (char *)&inpacket,sizeof(udp_packet_header),0,(struct sockaddr *)&fromaddr,&addrsize, PSNET_TYPE_VALIDATION);
638 FD_SET(Unreliable_socket, &read_fds);
640 // only send the header, the checksum and the string length plus the null
641 PacketHeader.type = UNT_VALID_SW_MSN_REQ;
642 PacketHeader.len = (short)(PACKED_HEADER_ONLY_SIZE + sizeof(squad_war_request));
643 memcpy(PacketHeader.data, sw_req, PacketHeader.len-PACKED_HEADER_ONLY_SIZE);
644 packet_length = SerializeValidatePacket(&PacketHeader, packet_data);
645 SENDTO(Unreliable_socket, (char *)&packet_data, packet_length, 0, (struct sockaddr *)&rtrackaddr, sizeof(struct sockaddr), PSNET_TYPE_VALIDATION);
646 SquadWarValidState = VALID_STATE_WAITING;
647 SquadWarFirstSent = timer_get_milliseconds();
648 SquadWarLastSent = timer_get_milliseconds();