summaryrefslogblamecommitdiffstats
path: root/friendfinder/msg_sender.c
blob: a770169ed874f2f523f90111d0b9c5e8ff1f305b (plain) (tree)
































































































































































































































































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

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

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

static irc_session_t *session;
irc_callbacks_t callbacks;

char* nick;
char* send_to;
char* received_msg;
char* msg_to_send;

irc_dcc_t dccid;
irc_dcc_t buddy_dccid;

BF_KEY key;

int run_session = 0;
int message_available = 0;

int init_connection(char* server_ip, char* user)
{
	printf("initialising connection...\n");

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

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

void disconnect()
{
	printf("disconnected...\n");
	irc_disconnect(session);
	irc_destroy_session(session);
}

void set_txt_msg(char *msg)
{
	if (msg != NULL)
	{
		printf("input msg_sender: %s \n", msg);
		send_message(session, msg);
	}
}

void dump_message(char *msg)
{
	received_msg = msg;
}

void dcc_recv_callback (irc_session_t * session, irc_dcc_t id, int status, void * ctx, const char * data, unsigned int length)
{

	if( run_session = 0)
	{
		irc_run(session);
		run_session = 1;
	}

	switch (status)
	{
	case LIBIRC_ERR_CLOSED:
		printf ("DCC %d: chat closed\n", id);
		break;

	case 0:
		if ( data == NULL )
		{
			printf ("DCC %d: chat connected\n", id);
			send_message(session, "im here");
		}
		else 
		{
			char *decrypted_msg = (char*) malloc(sizeof(data));
		
			BF_ecb_encrypt(data, decrypted_msg, &key, BF_DECRYPT);
			
			show_message(decrypted_msg);
			printf("incoming message:	%s \n", decrypted_msg);
		}
		break;

	default:
		printf ("DCC %d: error %s\n", id, irc_strerror(status));
		break;
	}
	irc_cmd_quit(session, "dcc_recv_callback: 99");
}

int i = 0;

void send_message(irc_session_t *session, char *msg)
{
//	printf("your message %i = test 	\n", i);
	
	//char msg[64];
	if (msg != NULL)
	{
		char crypted_msg[64];

		printf("send_message: %s \n", msg);
	
		BF_ecb_encrypt(msg, crypted_msg, &key, BF_ENCRYPT);	

		if ( run_session == 0)
		{
			irc_run(session);	
			run_session = 1;
		}

		irc_dcc_msg(session, buddy_dccid, crypted_msg);
		//TODO: irc_cmd_quit an richtiger stelle einbauen und ablaufen checken!!!
		irc_cmd_quit(session, "send_message()");	
	}
	else return;
}

void on_join(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	printf("on_join()\n");

	char sender_name[90];
	
	irc_target_get_nick(origin, sender_name, sizeof(sender_name));
	
	if (strcmp(sender_name, send_to) == 0)
	{	
		printf("Buddy %s joined the channel \n", send_to);
	
		if (irc_dcc_chat(session, NULL, send_to, dcc_recv_callback, &dccid) != 0)
		{
			printf("ddc_chat_init_error \n");
		}

		else 
		{
			printf("dcc_chat_init_success \n");
			printf("dccid %d \n", dccid);

			char _dccid[2];
			sprintf(_dccid, "%d", dccid);
			irc_cmd_msg(session, "#msg", _dccid);
		}
	}
	//irc_cmd_quit(session, "on_join");
}

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

	BF_set_key(&key, 5, "abcde");	
}

void on_channel(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	printf("on_channel()\n");
	if (strcmp(params[1], "connected") != 0)
	{
		buddy_dccid = atoi(params[1]);
		printf("buddy_dccid: %d \n", buddy_dccid);
	}
//	irc_cmd_quit(session, "continue");
}
void on_dcc_req(irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count)
{
	printf("on_dcc_req()\n");
	if(irc_dcc_accept (session, 1, 0, dcc_recv_callback) != 0)
	{
		printf("ddc_chat_decline \n");
	}

	else
	{
		printf("dcc_chat_accepted \n");
	}
//	irc_cmd_quit(session, "continue");
}


void msg_main_loop(char *sender, char *receiver)
{
	memset(&callbacks, 0, sizeof(callbacks));

	callbacks.event_connect = on_connect;
	callbacks.event_join = on_join;
	callbacks.event_dcc_chat_req = on_dcc_req;
	callbacks.event_channel = on_channel;

	nick = sender;
	send_to = receiver;

 	if (init_connection("127.0.0.1", sender) == 0)
	{	
		printf("connection succesfull\n");
	}
} 

void msg_run_irc()
{
	if (run_session == 0)
	{
		irc_run(session);
		run_session = 1;
	}
}

void msg_stop_irc()
{
	irc_cmd_quit(session, "paused");
}

/*
int main (int argc, char **argv)
{
        memset(&callbacks, 0, sizeof(callbacks));

	callbacks.event_connect = on_connect;
	callbacks.event_join = on_join;
	callbacks.event_dcc_chat_req = on_dcc_req;
	callbacks.event_channel = on_channel;

	nick = argv[1];
	send_to = argv[2];

 	if (init_connection("127.0.0.1", argv[1]) == 0)
	{
		int ses = irc_run(session);

		return 0;
	}

	else 
	{
		printf("aborting...\n");
		return 1;
	}
}*/