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







                             
                
                      



                              
                      
                
              
                  
              

                
                          


           

                                                
                                                           
        
                                                 

                                                 
                                                                                


                                           
                                                      





                         
                                                                        



                         
                            
 

                                     
                                                        

 
                                       

                              


                                                                                    





                                                  
        




                                                                                            
        
 
                                
         

                                              

         
                               
         
                                 
                
                                              
                 



                                                                                       


                                                                         
                                 
                                                                
                                         
                                                                                               

                                         
                                                        
                         
                                                                                 
                                
                                                                                                       
 




                                                                                                    


                            
         




                                                           



                                         





                                             
        
                                          
                                  
                                                 

 
                           
 
                                           
         



                                                                                            
                                                              
 
 

                                                                 
                                                                        

                                                            
                 







                                                                                                   
                 








                                                                   



                    


                                                                                                                           
                                


                                                                
                                                        



                                                                                                                           
                                                         

                                                                      
 








                                                        
                                                                             
                                                 

                 

 
                                   



                                                 

                                             
                                                                        


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

#include "libircclient.h"
#include "openssl/blowfish.h"

#include "msg_sender.h"
#include "gui.h"
#include "read_file.h"

static irc_session_t *session;
irc_callbacks_t callbacks;

char sender_name[100];
char* nick_from;
char* send_to;
char* msg_to_send;
char msg[300];

irc_dcc_t dccid;
irc_dcc_t buddy_dccid = 1;

BF_KEY key;

int init_connection(char* server_ip, char* user)
{
	printf("MSG_SENDER: initialising connection...\n");
	
//	msg = (char*) malloc(sizeof(char) * 300);

	session = irc_create_session(&callbacks);
	int con = irc_connect(session, server_ip, 6666, NULL, user, user, user);
	
	if (irc_is_connected(session) == 1)
	{
		printf("MSG_SENDER: connected... \n");
		return 0;
	
	}

	if (con != 0)
	{
		printf("MSG_SENDER: connection error-code: %i \n", con);
		return 1;
	}
}

void disconnect_msg_sender()
{
	irc_disconnect(session);
	irc_destroy_session(session);
	printf("MSG_SENDER: disconnected...\n");	
}

struct msg_part* prepare_msg(char *msg)
{
	int len = strlen(msg);
	int len_used = 0;

	struct msg_part *msg_p = (struct msg_part*) malloc(sizeof(struct msg_part));
	
	if (len % 6 != 0)
		msg_p->part_count = len / 6;

	if (len % 6 == 0)
		msg_p->part_count = (len / 6) - 1;
	
	int inc_part_count = msg_p->part_count + 1;
	msg_p->msg_parts = (char(*)[inc_part_count]) malloc(sizeof(char*) * inc_part_count);

	char *message = (char*) malloc(len + 1);
	memcpy(message, msg, len + 1);
	

	if (len <= 6 && len > 0)
	{
		msg_p->msg_parts[0] = message;
		return msg_p;
	}
	
	if (len > 6 && len > 0)
	{
		int i = 0, n = 0;
		
		while (i <= msg_p->part_count)
		{
			if (i < msg_p->part_count)
			{
				msg_p->msg_parts[i] = (char*) malloc(sizeof(char) * 8);

				strncpy(msg_p->msg_parts[i], message, 6);
				msg_p->msg_parts[7] = '\0';
				for (int j = 0; j < 6; j++)
				{
					if (len - len_used >= 6)
					{
						*(message + j) = *(message + len_used + j + 6);
					}
				}
				len_used = len_used + 6;
			}
			else if (i == msg_p->part_count && (len - len_used) != 0)
			{	
				msg_p->msg_parts[i] = (char*) malloc(sizeof(char) * (len - len_used)); 

				if ((len - len_used) < 6)
					strncpy(msg_p->msg_parts[i], message, (len - len_used) + 1);

				if ((len - len_used) == 6)
					strncpy(msg_p->msg_parts[i], message, (len - len_used) + 1);
			}
			i++;
		}
	}
	for (int i = 0; i <= msg_p->part_count; i++)
	{
		printf("%i %s \n", i, msg_p->msg_parts[i]);
	}
	return msg_p;
}

void repair_msg(char* inc_msg, char *msg)
{
	int len = strlen(inc_msg);
	printf("repair_msg len: %i \n", len);
	printf("repair_msg: %s \n", msg);
		
	if (strcmp(inc_msg, "//c//") != 0)
		strcat(msg, inc_msg);
	
	if (strcmp(inc_msg, "//c//") == 0)
		show_message(msg);
		printf("repair_msg: %s \n", msg);
}

void set_txt_msg(char *msg)
{
	if (msg != NULL && session != NULL)
	{
		struct msg_part *msg_p = (struct msg_part*) malloc(sizeof(struct msg_part));
		msg_p = prepare_msg(msg);
		send_message(session, msg_p);
	}
	else printf("MSG_SENDER: session not initialized \n");
}

void send_message(irc_session_t *session, struct msg_part *msg_p)
{
	if (msg_p->msg_parts != NULL && strlen(msg_p->msg_parts[0]) > 0)
	{
		for (int i = 0; i <= msg_p->part_count; i++)
		{
			char *crypted_msg = (char*) malloc(sizeof(char) * 8);
			
			if (msg_p->msg_parts[i] != NULL)
			{
				BF_ecb_encrypt(msg_p->msg_parts[i], crypted_msg, &key, BF_ENCRYPT);
				irc_cmd_msg(session, "#msg", crypted_msg);
				free(crypted_msg);
			}
		}
		char* eof = "//c//";

		char *crypted_eof = (char*) malloc(sizeof(char));
		BF_ecb_encrypt(eof, crypted_eof, &key, BF_ENCRYPT);
		irc_cmd_msg(session, "#msg", crypted_eof);
		free(crypted_eof);

		free(msg_p);

	}
	else return;
}


void on_connect(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	char *_key = read_key();
	irc_cmd_join(session, "#msg", NULL);	
	irc_cmd_msg(session, "#msg", "connected"); 		

	BF_set_key(&key, strlen(_key) - 1, _key);	
}

void on_channel(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	char *inc_msg = (char*) malloc(sizeof(char) * 8);

	irc_target_get_nick(origin, sender_name, sizeof(sender_name));

	if (nick_from = sender_name)
	{ 
		if (strcmp(params[1], "connected") == 0)
		{
			return;
		}	
		
		else
		{
			BF_ecb_encrypt(params[1], inc_msg, &key, BF_DECRYPT);
			repair_msg(inc_msg, msg);
		}
	}
}

void msg_main_loop(void *nicknames)
{
	memset(&callbacks, 0, sizeof(callbacks));

	callbacks.event_connect = on_connect;
	callbacks.event_channel = on_channel;

	struct nick *nicks = (struct nick*) malloc(sizeof(struct nick));
	nicks = (struct nick*) nicknames;
	nick_from = nicks->from;
	send_to = nicks->to;

 	if (init_connection("127.0.0.1", nick_from) == 0)
	{	
		printf("MSG_SENDER: connection succesfull\n");

		irc_run(session);
	}
}