summaryrefslogblamecommitdiffstats
path: root/friendfinder/receiver.c
blob: 28018b092cf151b1d871c3ef9c3ad14df30ce2af (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"

static irc_session_t *session;
irc_callbacks_t callbacks;

int _exit = 0;

char sender_name[100];
char own_nickname[100];
char *receiver_server_ip;

int username_length;

struct sender **s_sender;
int s_sender_size;

BF_KEY key;

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

void set_receiver_exit()
{
	_exit = 1;
}

int init_connection_receiver(char* server_ip, char* user)
{
	printf("RECEIVER: initialising connection...\n");	
	
	session = irc_create_session(&callbacks);
	int con = irc_connect(session, 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) == 1)
	{
		printf("RECEIVER: connected...\n");
		
		return 0;
	}
}

void disconnect_receiver(irc_session_t * session, const char * event, const char * origin, const unsigned char ** params, unsigned int count)
{
	irc_disconnect(session);
	//irc_destroy_session(session);
	char *sender_org = (char*) malloc(username_length + 1);

	irc_target_get_nick(origin, sender_name, sizeof(sender_name));
	if (strcmp(sender_name, own_nickname) == 0)
	{	
		irc_disconnect(session);
		//irc_destroy_session(session);

		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 == 1 && strcmp(s_sender[i]->nick, nick) == 0)
		{
			return i;
		}

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

			return i;
		}
	}
}

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

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

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

	if (_sender->lat_first_set == 1 && _sender->lat_second_set == 1)
	{
		memcpy(_sender->lat, _sender->lat_first, sizeof(_sender->lat_first)); //FIXME IM A ANGRY SEGFAULT

		strcat(_sender->lat, _sender->lat_second);//FIXME TOO

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

	//	printf("lat: %s \n", _sender->lat);

	//	_sender->lat[0] = '\0';
	}

	if (_sender->lon_first_set == 1 && _sender->lon_second_set == 1)
	{
		memcpy(_sender->lon, _sender->lon_first, sizeof(_sender->lon_first));//FIXME ALSO PLEASE
	
		strcat(_sender->lon, _sender->lon_second);//FIXME IS THE WORD OF THE HOUR

		_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: %s \n", _sender->lon);

	//	_sender->lat[0] = '\0';
	}
}


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

	draw_user(pos);
}

void get_position(irc_session_t * session, const char * event, const char * origin, const unsigned char ** params, unsigned int count)
{
	unsigned char *decrypted;
	
	char *sender_org = (char*) malloc(username_length + 1);

//	if (_exit == 1)
//		disconnect_receiver();
	
	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(sender_name, "_s") > 0 && strcmp(params[1], "connected") != 0 
		&& strcmp(params[1], "ack") != 0) 
	{
		int pos = get_sender_array_pos(sender_org);

		if (s_sender[pos]->lat_set == 0)
		{
			decrypted = (char*) malloc(sizeof(char) * 5);

			BF_ecb_encrypt(params[1], decrypted, &key, BF_DECRYPT);
			decrypted[strlen(decrypted)] = '\0';

	//		printf("decrypted %s \n", decrypted);

			repair_position(s_sender[pos], decrypted);
			
			free(decrypted);
		}

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

	//		printf("decrypted %s \n", decrypted);

			repair_position(s_sender[pos], decrypted);			

			free(decrypted);
		}

		if(s_sender[pos]->lon_set == 1 && s_sender[pos]->lat_set == 1)// && lon != NULL && lat != NULL)
		{
			double _lat, _lon;
			_lat = atof(s_sender[pos]->lat);
			_lon = atof(s_sender[pos]->lon);
		
			printf("%f %f \n", _lat, _lon);

			printf("char lat: %s char lon: %s \n", s_sender[pos]->lat, s_sender[pos]->lon);
	
			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';
		//	s_sender[pos]->lon = '\0';
		}	
		free(sender_org);

		irc_cmd_msg(session, "#test", "ack");
	}
}

void init_sender_struct(int number)
{
	s_sender = (struct sender(*)[number]) 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) * 9);
		s_sender[i]->lon = (char*) malloc(sizeof(char) * 9);
	
		s_sender[i]->is_init = (int) malloc(sizeof(int));
		s_sender[i]->is_init = 0;

		//s_sender[i]->lat_set = (int) malloc(sizeof(int));
		s_sender[i]->lat_set = 0;
		
		//s_sender[i]->lon_set = (int) malloc(sizeof(int));	
		s_sender[i]->lon_set = 0;


		s_sender[i]->lat_first = (char*) malloc(sizeof(char) * 6);
		s_sender[i]->lat_second = (char*) malloc(sizeof(char) * 6);
	
		s_sender[i]->lon_first = (char*) malloc(sizeof(char) * 6);
		s_sender[i]->lon_second = (char*) malloc(sizeof(char) * 6);

//		s_sender[i]->lat[0] = '\0';
//		s_sender[i]->lon[0] = '\0';

	}
}

void on_connect_receiver(irc_session_t * session, 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(3);		
	
	irc_cmd_join(session, "#test", NULL);	
	irc_cmd_msg(session, "#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;
	callbacks.event_quit = disconnect_receiver;
	
	char username[20];
	sprintf(username, "%s", (char*) user);
	sprintf(own_nickname, "%s", username);	
	username_length = strlen(username);

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

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