summaryrefslogblamecommitdiffstats
path: root/friendfinder/receiver.c
blob: 8bf24d324c3fd756ff0f607c8e5aa2aba20fc72c (plain) (tree)
1
2
3
4
5
6
7
8
9



                   
                         

                             
                      
                      
                     
                      
 
                                       
                          
 
                                            
                         
 
                    
                      



                         

           






                        




                                 




                                 
                                                         
 
                                                                
        

                                                                                                     

                     
                                                                      
 
                         

         
                                                    
         
                                                   
                
                         


         
                          
 
                                       

                                              
 




                                               
        

                                           
 

                                           
                

                                                
 

                                              
        

                                              
 
                                  
         
        
                       
        
                                              

 



                                               
                                                                                         
                 


                                                        


                                 
                                                                                           
                 




                                 







































                                                                             



                                                                      
                                                                         

                                             

         
                                     
         
                                                                          

                                              

         
                                     
         
                                                                         

                                             

         
                                     
         
                                                                          
                                              
                                            



                                                                        
                                                                                     
                                                          
 
                                     




                                              



                                                                        
                                                                                        
                                                          
 
                                     




                                              
         
 
                                                   













                                                                 
                                              

 
                                                
 
                                                                                  
 











                                                     
                       

 
                                                                                                                                               
 
                                 

                                        
                                                               
                                                                             

                                                        
                                                                        
                                            
 
                                                                      


                                                          
                                                                                                                                        
         
                                                           
                
                                                
                 

                                                                                                                
 
                                                                                                   

                                                                                      
                                                            
                        

                                                                  
                                                          
 
                                               
                                        
                 

                                                     
                 

                                                                                                
                
                                                                                                   

                                                                                      

                                                            

                                                                                        
                                                          
 
                                               
                                        
                 
 
                                                                              
                 
                                          

                                                        
                
                                                   


                                                                                             
        
                                                                        
                         
                                                                                                       

                         
                                                                        
                         
                                                                                                       

                         

                                                   




                                                     

                                 
                                        

         
 
 
                                       
 

                                           

                                                                                   

                                                                         
 




                                                                                      









                                          
                                                                                
                            
 




                                           
                                                                      






                                    
 
 
                                          
 

                                              
                                                                                

                                                                        
                                                                         













                                                                            
 
         
                                                   
         
                         
         

 
                                                                                                                                             
 
                                                   
 

                                                                                   
 

                                                        

                                                        
        

                                                                


                        

 
                              
 


                                                 
                                                      
 









                                                  
        
                                           
 
                                                       
         



                                                           



                                                                                
                                                  

                 
        



                                                                                  
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <libircclient.h>

#include "openssl/blowfish.h"
#include "draw_user.h"
#include "read_file.h"
#include "receiver.h"
#include "cryptossl.h"

static irc_session_t *session_receiver;
irc_callbacks_t callbacks;

char *username, *own_nickname, *sender_name;
char *receiver_server_ip;

int username_length;
int _sender_count = 3;

struct sender **s_sender;
int s_sender_size;

BF_KEY key;

int count_ack = 0;
int is_init = 0;
char* sender_base64;

#define CRYPT_LENGTH 10
#define BASE64_LENGTH 60

void receiver_set_ip(char *_ip)
{
	receiver_server_ip = _ip;
}

void set_sender_count(int number)
{
	_sender_count = number;
}

int init_connection_receiver(char* server_ip, char* user)
{
	printf("RECEIVER: initialising connection...\n");	
	
	session_receiver = irc_create_session(&callbacks);
	int con = irc_connect(session_receiver, server_ip, 6666, NULL, user, "receiver", "receiver");
	if (con != 0)
	{
		printf("RECEIVER: connection error-code: %i \n", con);

		return 1;
	}

	if (irc_is_connected(session_receiver) == 1)
	{
		printf("RECEIVER: connected...\n");
		
		return 0;
	}
}

void disconnect_receiver()
{
	//irc_destroy_session(session);
	irc_disconnect(session_receiver);
	irc_destroy_session(session_receiver);

	for (int i = 0; i < s_sender_size; i++)
	{
		free(s_sender[i]->nick);
		free(s_sender[i]->lat);
		free(s_sender[i]->lon);
	
		free(s_sender[i]->is_init);
		free(s_sender[i]->is_init);

		free(s_sender[i]->lat_set);
		free(s_sender[i]->lat_set);
		
		free(s_sender[i]->lon_set);	
		free(s_sender[i]->lon_set);

		free(s_sender[i]->lat_first);
		free(s_sender[i]->lat_second);
	
		free(s_sender[i]->lon_first);
		free(s_sender[i]->lon_second);

		free(s_sender[i]);
	}
	
	free(s_sender);
	
	printf("RECEIVER: disconnected...\n");
}

int get_sender_array_pos(char* nick)
{
	for (int i = 0; i < s_sender_size; i++)
	{
		if (s_sender[i]->is_init == 0)// && strcmp(s_sender[i]->nick, nick) != 0)
		{
			s_sender[i]->is_init = 1;
			strcpy(s_sender[i]->nick, nick);

			return i;
		}

		else if (s_sender[i]->is_init == 1 && strcmp(s_sender[i]->nick, nick) == 0)
		{
			return i;
		}
	}
}

void init_sender_struct(int number)
{
	s_sender = (struct sender**) malloc(sizeof(struct sender) * number);

	s_sender_size = number;	

	for (int i = 0; i <= number; i++)
	{
		s_sender[i] = (struct sender*) malloc(sizeof(struct sender));
		
		s_sender[i]->nick = (char*) malloc(sizeof(char) * 20);

		s_sender[i]->lat = (char*) malloc(sizeof(char) * 10);
		
		s_sender[i]->lon = (char*) malloc(sizeof(char) * 10);
	
		s_sender[i]->lat_first = (char*) malloc(sizeof(char) * 9);
		s_sender[i]->lat_first[0] = '\0';

		s_sender[i]->lat_second = (char*) malloc(sizeof(char) * 9);
		s_sender[i]->lat_second[0] = '\0';
	
		s_sender[i]->lon_first = (char*) malloc(sizeof(char) * 9);
		s_sender[i]->lon_first[0] = '\0';

		s_sender[i]->lon_second = (char*) malloc(sizeof(char) * 9);
		s_sender[i]->lon_second[0] = '\0';

		s_sender[i]->lon_first_set = 0;
		s_sender[i]->lon_second_set = 0;
	
		s_sender[i]->lat_first_set = 0;
		s_sender[i]->lat_second_set = 0;

		s_sender[i]->is_init = 0;
		s_sender[i]->lat_set = 0;
		s_sender[i]->lon_set = 0;
	}
}

void repair_position(struct sender *_sender, unsigned char *decrypted)
{
	if (decrypted[5] == 'a')
	{
		memcpy(_sender->lat_first, decrypted, strlen(decrypted));
		_sender->lat_first[5] = '\0';
		_sender->lat_first_set = 1;
	}
	
	else if (decrypted[4] == 'b')
	{
		memcpy(_sender->lat_second, decrypted, strlen(decrypted));
		_sender->lat_second[4] = '\0';
		_sender->lat_second_set = 1;
	}

	else if (decrypted[5] == 'c')
	{
		memcpy(_sender->lon_first, decrypted, strlen(decrypted));
		_sender->lon_first[5] = '\0';
		_sender->lon_first_set = 1;
	}

	else if (decrypted[3] == 'd')
	{
		memcpy(_sender->lon_second, decrypted, strlen(decrypted));
		_sender->lon_second[3] = '\0';
		_sender->lon_second_set = 1;
	}

	if (_sender->lat_first_set == 1 && _sender->lat_second_set == 1)
	{
		memcpy(_sender->lat, _sender->lat_first, sizeof(_sender->lat_first));
		strcat(_sender->lat, _sender->lat_second);

		_sender->lat_set = 1;
		_sender->lat_first_set = 0;
		_sender->lat_second_set = 0;
	
		_sender->lat_first[0] = '\0';
		_sender->lat_second[0] = '\0';
	}

	if (_sender->lon_first_set == 1 && _sender->lon_second_set == 1)
	{
		memcpy(_sender->lon, _sender->lon_first, sizeof(_sender->lon_first));	
		strcat(_sender->lon, _sender->lon_second);

		_sender->lon_set = 1;
		_sender->lon_first_set = 0;
		_sender->lon_second_set = 0;

		_sender->lon_first[0] = '\0';
		_sender->lon_second[0] = '\0';
	}

/*	printf("lon_set: %i \n", _sender->lon_set);
	printf("lon: %s \n", _sender->lon);
	printf("lat_set: %i \n", _sender->lat_set);	
	printf("lat: %s \n", _sender->lat);
	printf("nick: %s \n", _sender->nick);
	printf("<<<<<<<<<<<>>>>>>>>>>> \n");
	printf("first_lon_set: %i \n", _sender->lon_first_set);
	printf("first_lon: %s \n", _sender->lon_first);
	printf("second_lon_set: %i \n", _sender->lon_second_set);
	printf("second_lon: %s \n", _sender->lon_second);
	printf("<<<<<<<<<<<>>>>>>>>>>> \n");
	printf("first_lat_set: %i \n", _sender->lat_first_set);
	printf("first_lat: %s \n", _sender->lat_first);
	printf("second_lat_set: %i \n", _sender->lat_second_set);
	printf("second_lat: %s \n", _sender->lat_second);
	printf("====================== \n");*/
}

void dump_data(char* lat, char* lon, char* nick)
{
	struct position *pos = (struct position*) malloc(sizeof(struct position));

	pos->lat = (char*) malloc(strlen(lat) + 1);
	pos->lon = (char*) malloc(strlen(lon) + 1);
	pos->nick = (char*) malloc(strlen(nick) + 1);

	memcpy(pos->lat, lat, strlen(lat));
	memcpy(pos->lon, lon, strlen(lon));
	memcpy(pos->nick, nick, strlen(nick));
	
	pos->lat[strlen(lat)] = '\0';
	pos->lon[strlen(lon)] =	'\0';
	pos->nick[strlen(nick)] = '\0';
	
	draw_user(pos);
}

void get_position(irc_session_t * session_receiver, const char * event, const char * origin, const unsigned char ** params, unsigned int count)
{
	unsigned char *decrypted;
	unsigned char *encrypted_base64;

	char *sender_org = (char*) malloc(username_length + 1);
	char *own_sender_nickname = (char*) malloc(strlen(own_nickname) + 3);
	sender_name = (char*) malloc(sizeof(char) * 50);

	memcpy(own_sender_nickname, own_nickname, strlen(own_nickname));
	strcat(own_sender_nickname, "_s\0");

	irc_target_get_nick(origin, sender_name, sizeof(sender_name));
	strncpy(sender_org, sender_name, username_length);
	sender_org[username_length] = '\0';

	if (strcmp(sender_org, own_nickname) != 0 && strcmp(params[1], "connected") != 0 && check_message(params[1], sender_name) == 1) 
	{
		int pos = get_sender_array_pos(sender_org);
		
		if (s_sender[pos]->lat_set == 0)
		{
			encrypted_base64 = (char*) malloc(sizeof(char) * BASE64_LENGTH);			
			decrypted = (char*) malloc(sizeof(char) * 9);

  			from_base64(params[1], strlen(params[1]), encrypted_base64, BASE64_LENGTH);
			BF_ecb_encrypt(encrypted_base64, decrypted, &key, BF_DECRYPT);
		
			decrypted[strlen(decrypted)] = '\0';
			
			repair_position(s_sender[pos], decrypted);
			
			send_acknowledgement(sender_name);

			free(encrypted_base64);
			free(decrypted);
		}

		else if (s_sender[pos]->lon_set == 0)
		{
			encrypted_base64 = (char*) malloc(sizeof(char) * BASE64_LENGTH);	
			decrypted = (char*) malloc(sizeof(char) * 9);
		
  			from_base64(params[1], strlen(params[1]), encrypted_base64, BASE64_LENGTH);
			BF_ecb_encrypt(encrypted_base64, decrypted, &key, BF_DECRYPT);

			decrypted[strlen(decrypted)] = '\0';

			repair_position(s_sender[pos], decrypted);			

			send_acknowledgement(sender_name);

			free(encrypted_base64);
			free(decrypted);
		}

		if(s_sender[pos]->lon_set == 1 && s_sender[pos]->lat_set == 1)
		{
			double _lat, _lon;
			_lat = atof(s_sender[pos]->lat);
			_lon = atof(s_sender[pos]->lon);
		
			printf(" DUMPING DATA \n");
			printf("lat: %s lon: %s \n", s_sender[pos]->lat, s_sender[pos]->lon);
			printf("nick: %s \n", s_sender[pos]->nick);
			printf("=========================================\n");	
	
			if (_lat > _lon && _lat == _lat && _lon == _lon)
			{
				dump_data(s_sender[pos]->lat, s_sender[pos]->lon, s_sender[pos]->nick);
			}
	
			if (_lat < _lon && _lat == _lat && _lon == _lon)
			{
				dump_data(s_sender[pos]->lon, s_sender[pos]->lat, s_sender[pos]->nick);
			}

			s_sender[pos]->lon_set = 0;
			s_sender[pos]->lat_set = 0;
		
			s_sender[pos]->lat[0] = '\0';
			s_sender[pos]->lon[0] = '\0';
		}
	
		free(sender_org);

		pos = NULL;		
	}
}


void send_acknowledgement(char *sender)
{
	if (is_init == 0 && count_ack == 0)
	{
		sender_base64 = (char*) malloc(sizeof(char) * BASE64_LENGTH);
		char* sender_crypted = (char*) malloc(sizeof(char) * CRYPT_LENGTH);

		BF_ecb_encrypt(sender, sender_crypted, &key, BF_ENCRYPT);

		sender_crypted[strlen(sender_crypted)] = '\0';

		to_base64(sender_crypted, CRYPT_LENGTH, sender_base64, BASE64_LENGTH);

		irc_cmd_msg(session_receiver, "#test", sender_base64);
		
		free(sender_crypted);
		is_init = 1;
		count_ack++;

		return;
	}

	if (is_init == 1 && count_ack < 3)
	{
		irc_cmd_msg(session_receiver, "#test", sender_base64);		
		count_ack++;

		return;
	}

	if (is_init == 1 && count_ack == 3)
	{
		irc_cmd_msg(session_receiver, "#test", sender_base64);
		count_ack = 0;
		is_init = 0;

		free(sender_base64);

		return;
	}
}

int check_message(char *msg, char *sender)
{
	if (sender[strlen(sender) - 1] == 's')
	{
		char* ack_base64 = (char*) malloc(sizeof(char) * BASE64_LENGTH);
		char* ack_decrypted = (char*) malloc(sizeof(char) * 20);

		from_base64(msg, strlen(msg), ack_base64, BASE64_LENGTH);
		BF_ecb_encrypt(ack_base64, ack_decrypted, &key, BF_DECRYPT);

		if (strcmp(sender, ack_decrypted) == 0)
		{
			free(ack_base64);
			free(ack_decrypted);	
			return 0;
		}
		else if (strcmp(sender, ack_decrypted) != 0)
		{
			free(ack_base64);
			free(ack_decrypted);	
			return 1;
		}

	}
	else if (sender[strlen(sender) - 1] != 's')
	{
		return 0;
	}
}

void on_connect_receiver(irc_session_t * session_receiver, const char * event, const char * origin, const char ** params, unsigned int count)
{
	printf("RECEIVER: on_connect_receiver \n");

	struct key_data *keyd = (struct key_data*) malloc(sizeof(struct key_data));
	keyd->key = (char*) malloc(sizeof(char) * 300);	

	keyd = read_key();
	BF_set_key(&key, keyd->key_length, keyd->key);	

	init_sender_struct(_sender_count);		
	
	irc_cmd_join(session_receiver, "#test", NULL);	
//	irc_cmd_msg(session_receiver, "#test", "connected"); 	

	free(keyd->key);
	free(keyd);
}

void receiver_main(void *user)
{
	memset(&callbacks, 0, sizeof(callbacks));
	
	callbacks.event_channel = get_position;
	callbacks.event_connect = on_connect_receiver;

	char* _user = (char*) user;
	int len = strlen(_user) + 1;

	username = (char*) malloc(len + 2);
	own_nickname = (char*) malloc(len + 2);	

	memcpy(username, user, len);
	memcpy(own_nickname, user, len);

	own_nickname[strlen(own_nickname)] = '\0';
	
	username_length = strlen(username);

	if (receiver_server_ip != NULL && user != NULL)
	{
		strcat(username, "_r\0");
	
		printf("%s %s \n", username, own_nickname);
		
		if (init_connection_receiver(receiver_server_ip, username) == 0)
		{
			printf("RECEIVER: connection succesfull...\n");

			irc_run(session_receiver);
		}
	}
	
	else
	{
		printf("RECEIVER: error ip not set! Receiver can't be started\n");
	}
}