PACKAGE_TARNAME = gaim

PACKAGE_VERSION = 1.5.1cvs

PATH_SEPARATOR = :

PERL_MM_PARAMS =

PKG_CONFIG = /usr/bin/pkg-config

PLUGINS_FALSE = #

USE_NLS = yes

USE_NSS_FALSE = #

USE_NSS_TRUE =

USE_TCL_FALSE =

USE_TCL_TRUE = #

USE_TK_FALSE =

enable_dot = yes

enable_doxygen = yes

exec_prefix = ${prefix}

host = powerpc-unknown-linux-gnu

host_alias =

host_cpu = powerpc

mandir = ${prefix}/man

mkdir_p = mkdir -p --

oldincludedir = /usr/include

prefix = /usr/local

program_transform_name = s,x,x,

sbindir = ${exec_prefix}/sbin

// Connect to the mDNS daemon looking for buddies in the LAN

bd->dns_sd_data = bonjour_dns_sd_new();

bd->dns_sd_data->name = (sw_string)gaim_account_get_username(account);

bd->dns_sd_data->first = gaim_account_get_string(account, "first", "Juanjo");

bd->dns_sd_data->last = gaim_account_get_string(account, "last", "");

bd->dns_sd_data->port_p2pj = gaim_account_get_int(account, "port", BONJOUR_DEFAULT_PORT_INT);

bd->dns_sd_data->email = gaim_account_get_string(account, "email", "");

bd->dns_sd_data->account = account;

bonjour_dns_sd_start(bd->dns_sd_data);

GSList* l;

BonjourData* bd = (BonjourData*)connection->proto_data;

// Stop looking for buddies in the LAN

if (connection != NULL) {

bonjour_dns_sd_stop(bd->dns_sd_data);

}

}

// Remove all the bonjour buddies

if(connection != NULL){

buddies = gaim_find_buddies(connection->account, connection->account->username);

void bonjour_set_status(GaimConnection* connection, const char* state, const char* message)

{

char* status_dns_sd = NULL;

if(message) {

stripped = g_strdup(message);

stripped = g_strdup("");

}

if(connection->away){

g_free(connection->away);

}

status_dns_sd = g_strdup("away");

} else if (g_ascii_strcasecmp(state, _("Do Not Disturb")) == 0) {

status_dns_sd = g_strdup("dnd");

}

if (status_dns_sd != NULL) {

sw_int8 value[SW_TEXT_RECORD_MAX_LEN];

sw_uint32 value_length;

sw_discovery_cancel(discovery, oid);

// Get the ip as a string

return SW_OKAY;

}

{

sw_text_record dns_data;

// Fill the data for the service

if(sw_text_record_init(&dns_data) != SW_OKAY){

gaim_debug_error("bonjour", "Unable to initialize the data for the mDNS.");

}

sw_text_record_add_key_and_string_value(dns_data, "port.p2pj", BONJOUR_DEFAULT_PORT);

// Publish the service

gaim_debug_error("bonjour", "Unable to publish or change the status of the _presence._tcp service.");

}

// Free the memory used by temp data

sw_text_record_fina(dns_data);

return 0;

}

{

sw_discovery_oid session_id;

BonjourDnsSd* dns_sd_data = (BonjourDnsSd*)data;

// Advise the daemon that we are waiting for connections

if(sw_discovery_browse(*(dns_sd_data->session), 0, ICHAT_SERVICE, NULL, _browser_reply,

dns_sd_data->account, &session_id) != SW_OKAY){

/**

* Send a new dns-sd packet updating our status.

*/

{

}

/**

// Initilizations of the dns-sd data and session

data->session = malloc(sizeof(sw_discovery));

if(sw_discovery_init(data->session) != SW_OKAY){

}

// Advise the daemon that we are waiting for connections

if(sw_discovery_browse(*(data->session), 0, ICHAT_SERVICE, NULL, _browser_reply,

gaim_debug_error("bonjour", "Unable to get service.");

return;

}

// callback that will handle the dns_sd packets

dns_sd_socket = sw_discovery_socket(*(data->session));

io_channel = g_io_channel_unix_new(dns_sd_socket);

*/

int bonjour_dns_sd_stop(BonjourDnsSd* data)

{

return 0;

}

*/

typedef struct _bonjour_dns_sd{

sw_discovery* session;

GaimAccount* account;

gchar* name;

gchar* txtvers;

gchar* vc;

gchar* jid;

gchar* AIM;

GHashTable* buddies;

}BonjourDnsSd;

/**

* Allocate space for the dns-sd data.

*/

/**

* Send a new dns-sd packet updating our status.

*/

/**

* Advertise our presence within the dns-sd daemon and start browsing for other

gint _connect_to_buddy(GaimBuddy* gb)

{

gint socket_fd;

struct sockaddr_in buddy_address;

// Create a socket and make it non-blocking

buddy_address.sin_port = htons(((BonjourBuddy*)(gb->proto_data))->port_p2pj);

inet_aton(((BonjourBuddy*)(gb->proto_data))->ip, &(buddy_address.sin_addr));

memset(&(buddy_address.sin_zero), '\0', 8);

return socket_fd;

}

} else {

result = g_string_new("1");

}

}

void _jabber_parse_and_write_message_to_ui(char* message, GaimConnection* connection, GaimBuddy* gb)

{

}

body_node = xmlnode_get_child(message_node, "body");

if (body_node != NULL) {

body = xmlnode_get_data(body_node);

} else {

}

html_node = xmlnode_get_child(message_node, "html");

if (html_node != NULL) {

isHTML = TRUE;

html_body_node = xmlnode_get_child(html_node, "body");

if (ichat_balloon_color == NULL) ichat_balloon_color = "#FFFFFF";

body = g_strconcat("<font face='", font_face, "' size='", font_size, "' color='", ichat_text_color,

"' back='", ichat_balloon_color, "'>", html_body, "</font>", NULL);

}

// Send the message to the UI

GaimBuddy* gb = (GaimBuddy*)value;

BonjourBuddy* bb = (BonjourBuddy*)gb->proto_data;

} else {

}

}

// Read chunks of 512 bytes till the end of the data

while ((parcial_message_length = recv(socket, parcial_data, 512, 0)) > 0) {

g_string_append_len(data, parcial_data, parcial_message_length);

total_message_length += parcial_message_length;

return -1;

}

}

*message = data->str;

g_string_free(data, FALSE);

return total_message_length;

}

gint _send_data(gint socket, char* message)

{

gint parcial_sent = 0;

gchar* parcial_message = message;

}

}

}

void _client_socket_handler(gpointer data, gint socket, GaimInputCondition condition)

// Read the data from the socket

if ((message_length = _read_data(socket, &message)) == -1) {

// There have been an error reading from the socket

return;

} else if (message_length == 0) { // The other end has closed the socket

closed_conversation = TRUE;

}

}

// data is the doctype

if (!(bb->conversation->start_step_one)) {

if (g_str_has_prefix(message, DOCTYPE_DECLARATION)){

// If we haven't done it yet, we have to sent the start of the stream to the other buddy

if (!(bb->conversation->stream_started)) {

gaim_debug_error("bonjour", "Unable to start a conversation with %s\n", bb->name);

}

}

// Check that this is not the end of the conversation

if (g_str_has_prefix(message, STREAM_END) || (closed_conversation == TRUE)) {

// Close the socket, clear the watcher and free memory

// Inform the user that the conversation has been closed

conversation = gaim_find_conversation_with_account(gb->name, account);

closed_conv_message = g_strconcat(gb->name, " has closed the conversation.", NULL);

gaim_conversation_write(conversation, NULL, closed_conv_message, GAIM_MESSAGE_SYSTEM, time(NULL));

}

}

void _server_socket_handler(gpointer data, int server_socket, GaimInputCondition condition)

BonjourBuddy* bb = NULL;

char* address_text = NULL;

GaimBuddyList* bl = gaim_get_blist();

//Check that it is a read condition

if (condition != GAIM_INPUT_READ) {

return;

}

if ((client_socket = accept(server_socket, (struct sockaddr *)&their_addr, &sin_size)) == -1) {

return;

}

bb->conversation->buddy_name = g_strdup(gb->name);

bb->conversation->message_id = 1;

// Open a watcher for the client socket

bb->conversation->watcher_id = gaim_input_add(client_socket, GAIM_INPUT_READ,

_client_socket_handler, gb);

int yes = 1;

char* error_message = NULL;

// Open a listening socket for incoming conversations

gaim_debug_error("bonjour", "Cannot get socket\n");

error_message = strerror(errno);

gaim_debug_error("bonjour", "%s\n", error_message);

}

// Make the socket reusable

gaim_debug_error("bonjour", "Cannot make socket reusable\n");

error_message = strerror(errno);

gaim_debug_error("bonjour", "%s\n", error_message);

gaim_connection_error(data->account->gc, "Error setting socket options");

return -1;

}

gaim_debug_error("bonjour", "Cannot bind socket\n");

error_message = strerror(errno);

gaim_debug_error("bonjour", "%s\n", error_message);

return -1;

}

gaim_debug_error("bonjour", "Cannot listen to socket\n");

error_message = strerror(errno);

gaim_debug_error("bonjour", "%s\n", error_message);

return -1;

}

// Open a watcher in the socket we have just opened

data->watcher_id = gaim_input_add(data->socket, GAIM_INPUT_READ, _server_socket_handler, data);

// Check if the stream for the conversation has been started

if (bb->conversation->stream_started == FALSE) {

// Start the stream

gaim_debug_error("bonjour", "Unable to start a conversation\n");

conv_message = g_strdup("Unable to send the message, the conversation couldn't be started.");

conversation = gaim_find_conversation_with_account(bb->name, data->account);

gaim_conversation_write(conversation, NULL, conv_message, GAIM_MESSAGE_SYSTEM, time(NULL));

}

// Send the message

gaim_debug_error("bonjour", "Unable to send the message\n");

conv_message = g_strdup("Unable to send the message.");

conversation = gaim_find_conversation_with_account(bb->name, data->account);

gaim_conversation_write(conversation, NULL, conv_message, GAIM_MESSAGE_SYSTEM, time(NULL));

}

}

void bonjour_jabber_close_conversation(BonjourJabber* data, GaimBuddy* gb)

if (bb->conversation != NULL) {

// Send the end of the stream to the other end of the conversation

// Close the socket and remove the watcher

close(bb->conversation->socket);

// Free all the data related to the conversation

g_free(bb->conversation->buddy_name);

g_free(bb->conversation);

}

}

gb = (GaimBuddy*)l->data;

bb = (BonjourBuddy*)gb->proto_data;

if (bb->conversation != NULL) {

close(bb->conversation->socket);

gaim_input_remove(bb->conversation->watcher_id);

}

#include "account.h"

#define DOCTYPE_DECLARATION "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"

#define STREAM_END "</stream:stream>"

typedef struct _bonjour_jabber{

gint port;

gint socket;