static void gaym_clean_channel_members(GaimConversation * conv)
{
g_return_if_fail(conv != NULL);
if (conv->type == GAIM_CONV_CHAT) {
GaimConvChat *chat = gaim_conversation_get_chat_data(conv);
GaimConnection *gc = gaim_conversation_get_gc(conv);
g_return_if_fail(gc != NULL);
struct gaym_conn *gaym = gc->proto_data;
GList *users = gaim_conv_chat_get_users(chat);
gaim_debug_misc("gaym", "got userlist %x length %i\n", users,
g_list_length(users));
g_list_foreach(users, (GFunc) deref_one_user, gaym);
} else if (conv->type == GAIM_CONV_IM) {
gaim_debug_misc("gaym", "removing reference to %s\n", conv->name);
GaimConnection *gc = gaim_conversation_get_gc(conv);
g_return_if_fail(gc != NULL);
struct gaym_conn *gaym = gc->proto_data;
gaym_unreference_channel_member(gaym, conv->name);
}
}
void
gaym_get_chat_key_from_weblogin(GaimAccount * account,
void (*callback) (GaimAccount * account))
{
struct gaym_conn *gaym = account->gc->proto_data;
if (GAIM_CONNECTION_IS_VALID(account->gc)) {
GaimUrlSession *session = g_new0(GaimUrlSession, 1);
session->session_cb = callback;
session->cookies = NULL;
session->account = account;
session->username = g_strdup(account->username);
session->password = g_strdup(account->password);
session->gaym = gaym;
session->cookie_table =
g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
gaim_debug_misc("gaym", "Made session: %x\n", session);
if (GAIM_CONNECTION_IS_VALID
(((GaimUrlSession *) session)->account->gc)) {
// The first step is to establish the initial sesion
// We connect to index.html, and get a few cookie values.
char *url =
g_strdup_printf
("http://www.gay.com/misc/dologin.html?__login_haveForm=1&__login_save=1&__login_member=%s&redir=%%2Findex.html&__login_basepage=%%2Fmisc%%2Fdologin.html&__login_password=%s",
session->username, session->password);
session->hasFormData = TRUE;
gaim_util_fetch_url_request(url, FALSE, NULL, FALSE, NULL, TRUE,
gaym_weblogin_step4, session);
} else {
gaim_debug_misc("gaym", "cancelled before step1\n");
gaim_debug_misc("gaym", "gaym->sessoin: %x\n", session);
gaym_session_destroy(session);
}
}
}
void get_icon_scale_size(GdkPixbuf * icon, GaimBuddyIconSpec * spec,
int *width, int *height)
{
*width = gdk_pixbuf_get_width(icon);
*height = gdk_pixbuf_get_height(icon);
gaim_debug_misc("popups", "current: w: %i, h: %i\n", *width, *height);
/* this should eventually get smarter about preserving the aspect
ratio when scaling, but gimmie a break, I just woke up */
if (spec && spec->scale_rules & GAIM_ICON_SCALE_DISPLAY) {
float spec_aspect =
(float) spec->max_width / (float) spec->max_height;
float icon_aspect = (float) (*width) / (float) (*height);
// icon will hit borders horizontally first
if (icon_aspect > spec_aspect) {
float width_ratio =
(float) (*width) / (float) (spec->max_width);
*height = (float) (*height) / width_ratio;
*width = spec->max_width;
}
if (icon_aspect < spec_aspect) {
float height_ratio =
(float) (*height) / (float) (spec->max_height);
*width = (float) (*width) / height_ratio;
*height = spec->max_height;
}
}
/* and now for some arbitrary sanity checks */
if (*width > 100)
*width = 100;
if (*height > 100)
*height = 100;
gaim_debug_misc("popups", "scaled: w: %i, h: %i\n", *width, *height);
}
char *gaym_bio_strdup(const char *info)
{
char *start = strchr(info, '#');
char *end = 0;
if (start && *start) {
start++;
end = strchr(start, 0x01);
if (!end)
end = strchr(start, 0);
}
#ifdef GAYM_TOKEN
gaim_debug_misc("gaym","end: %x, end-1: %x, end-5: %x\n",end,*(end-1),*(end-5));
if(end-5 >= start)
if(!strncmp((end-5),"\xC2\xA0 \xC2\xA0",5))
end-=5;
#endif
gaim_debug_misc("gaym","end %x, start %x\n",end,start);
if ((end) && (start < end)) {
return g_strdup_printf("%.*s", end - start, start);
} else {
return 0;
}
}
static gint
uri_command(const char *command, gboolean sync)
{
gchar *escaped, *tmp;
GError *error = NULL;
gint ret = 0;
escaped = gaim_escape_html(command);
gaim_debug_misc("gtknotify", "Executing %s\n", escaped);
if (!gaim_program_is_valid(command))
{
tmp = g_strdup_printf(_("The browser command <b>%s</b> is invalid."),
escaped ? escaped : "(none)");
gaim_notify_error(NULL, NULL, _("Unable to open URL"), tmp);
g_free(tmp);
}
else if (sync)
{
gint status;
if (!g_spawn_command_line_sync(command, NULL, NULL, &status, &error))
{
tmp = g_strdup_printf(_("Error launching <b>%s</b>: %s"),
escaped, error->message);
gaim_notify_error(NULL, NULL, _("Unable to open URL"), tmp);
g_free(tmp);
g_error_free(error);
}
else
ret = status;
}
else
{
if (!g_spawn_command_line_async(command, &error))
{
tmp = g_strdup_printf(_("Error launching <b>%s</b>: %s"),
escaped, error->message);
gaim_notify_error(NULL, NULL, _("Unable to open URL"), tmp);
g_free(tmp);
g_error_free(error);
}
}
g_free(escaped);
return ret;
}
static void redo_im_window(GaimConversation * c)
{
gaim_debug_misc("chaticon","GOT CONVERSATION CREATED FOR %s\n",c->name);
if (!g_strrstr(gaim_account_get_protocol_id(c->account), "prpl-gaym"))
return;
if (c && c->type == GAIM_CONV_IM)
add_im_popup_stuff(c);
else if (c->type == GAIM_CONV_CHAT)
{
add_chat_sort_functions(c);
add_chat_popup_stuff(c);
add_chat_icon_stuff(c);
}
}
void chaticon_replace(GaimConversation * conv, const char *name,
GaimConvChatBuddyFlags flags)
{
GaimGtkConversation *gtkconv = GAIM_GTK_CONVERSATION(conv);
GaimGtkChatPane *gtkchat = gtkconv->u.chat;
gboolean valid;
GtkTreeIter iter;
int row_count = 0;
GtkTreeModel *list_store =
gtk_tree_view_get_model(GTK_TREE_VIEW(gtkchat->list));
/* Get the first iter in the list */
valid = gtk_tree_model_get_iter_first(list_store, &iter);
while (valid) {
/* Walk through the list, reading each row */
gchar *str_data;
/* Make sure you terminate calls to gtk_tree_model_get() with a
'-1' value */
gtk_tree_model_get(list_store, &iter,
CHAT_USERS_NAME_COLUMN, &str_data, -1);
/* Do something with the data */
g_print("Row %d: (%s)(%s)\n", row_count, str_data, name);
if (!strcmp(str_data, name)) {
GdkPixbuf *pixbuf =
lookup_cached_thumbnail(conv->account,
gaim_normalize(conv->account,
name));
gaim_debug_misc("chaticon", "Got pixbuf: %x\n");
GtkTreePath *path = gtk_tree_model_get_path(list_store, &iter);
gtk_list_store_set(GTK_LIST_STORE(list_store), &iter, 0,
pixbuf, -1);
gtk_tree_model_row_changed(list_store, path, &iter);
// g_free(pixbuf);
break;
}
row_count++;
valid = gtk_tree_model_iter_next(list_store, &iter);
g_free(str_data);
}
}
void
oscar_data_addhandler(OscarData *od, guint16 family, guint16 subtype, aim_rxcallback_t newhandler, guint16 flags)
{
SnacHandler *snac_handler;
gaim_debug_misc("oscar", "Adding handler for %04x/%04x\n", family, subtype);
snac_handler = g_new0(SnacHandler, 1);
snac_handler->family = family;
snac_handler->subtype = subtype;
snac_handler->flags = flags;
snac_handler->handler = newhandler;
g_hash_table_insert(od->handlerlist,
GUINT_TO_POINTER((family << 16) + subtype),
snac_handler);
}
void yahoo_conf_leave(struct yahoo_data *yd, const char *room, const char *dn, GList *who)
{
struct yahoo_packet *pkt;
GList *w;
gaim_debug_misc("yahoo", "leaving conference %s\n", room);
pkt = yahoo_packet_new(YAHOO_SERVICE_CONFLOGOFF, YAHOO_STATUS_AVAILABLE, 0);
yahoo_packet_hash_str(pkt, 1, dn);
for (w = who; w; w = w->next) {
const char *name = gaim_conv_chat_cb_get_name(w->data);
yahoo_packet_hash_str(pkt, 3, name);
}
yahoo_packet_hash_str(pkt, 57, room);
yahoo_packet_send_and_free(pkt, yd);
}
static void gaim_roomlist_destroy(GaimRoomlist *list)
{
GList *l;
gaim_debug_misc("roomlist", "destroying list %p\n", list);
if (ops && ops->destroy)
ops->destroy(list);
for (l = list->rooms; l; l = l->next) {
GaimRoomlistRoom *r = l->data;
gaim_roomlist_room_destroy(list, r);
}
g_list_free(list->rooms);
g_list_foreach(list->fields, (GFunc)gaim_roomlist_field_destroy, NULL);
g_list_free(list->fields);
g_free(list);
}
/*
* This function is called after the user has selected a file to send.
*/
static void gaym_dccsend_send_init(GaimXfer *xfer) {
struct gaym_xfer_send_data *xd = xfer->data;
GaimConnection *gc = gaim_account_get_connection(gaim_xfer_get_account(xfer));
struct gaym_conn *gaym = gc->proto_data;
int sock;
const char *arg[2];
char *tmp;
struct in_addr addr;
unsigned short int port;
xfer->filename = g_path_get_basename(xfer->local_filename);
/* Create a listening socket */
sock = gaim_network_listen_range(0, 0);
if (sock < 0) {
gaim_notify_error(gc, NULL, _("File Transfer Aborted"),
_("Gaim could not open a listening port."));
gaim_xfer_cancel_local(xfer);
return;
}
xd->fd = sock;
port = gaim_network_get_port_from_fd(sock);
gaim_debug_misc("gaym", "port is %hu\n", port);
/* Monitor the listening socket */
xfer->watcher = gaim_input_add(sock, GAIM_INPUT_READ,
gaym_dccsend_send_connected, xfer);
/* Send the intended recipient the DCC request */
arg[0] = xfer->who;
inet_aton(gaim_network_get_my_ip(gaym->fd), &addr);
arg[1] = tmp = g_strdup_printf("\001DCC SEND \"%s\" %u %hu %zu\001",
xfer->filename, ntohl(addr.s_addr),
port, xfer->size);
gaym_cmd_privmsg(xfer->account->gc->proto_data, "msg", NULL, arg);
g_free(tmp);
}
static gboolean check_for_update(gpointer * conversation,
const gpointer * name, gpointer * data)
{
g_return_val_if_fail(conversation != NULL, TRUE);
g_return_val_if_fail(name != NULL, TRUE);
g_return_val_if_fail(data != NULL, TRUE);
GaimConversation *c = (GaimConversation *) conversation;
char *name_needing_update = (char *) name;
struct fetch_thumbnail_data *d = (struct fetch_thumbnail_data *) data;
gaim_debug_misc("chaticon", "Check for update: %x %s %s %i\n", c, name,
d->who, d->pic_data_len);
g_return_val_if_fail(name_needing_update != NULL, FALSE);
if (!strcmp(d->who, name_needing_update)) {
gaym_gtkconv_update_thumbnail(c, d);
return TRUE;
}
return TRUE;
}
void fetch_thumbnail_cb(void *user_data, const char *pic_data, size_t len)
{
if (!user_data)
return;
struct fetch_thumbnail_data *d = user_data;
if (!pic_data) {
return;
}
if (len && !g_strrstr_len(pic_data, len, "Server Error")) {
char *dir;
if ((dir =
g_build_filename(gaim_user_dir(), "icons", "gaym",
NULL)) != NULL) {
d->pic_data = pic_data;
d->pic_data_len = len;
gaim_build_dir(dir, S_IRUSR | S_IWUSR | S_IXUSR);
char *filename = g_strdup_printf("%s.jpg", d->who);
char *path = g_build_filename(dir, filename, NULL);
FILE *file;
if ((file = g_fopen(path, "wb"))) {
fwrite(pic_data, 1, len, file);
fclose(file);
} else {
gaim_debug_misc("chaticon", "Couldn't write file\n");
}
g_free(filename);
g_free(path);
g_free(dir);
}
} else {
d->pic_data = 0;
d->pic_data_len = 0;
}
g_hash_table_foreach_remove(pending_updates,
(GHRFunc) check_for_update, d);
g_free(d);
}
static void
gaym_weblogin_step4(GaimUtilFetchUrlData *url_data, gpointer data, const gchar *text, gsize len, const gchar* err)
{
GaimUrlSession *session = (GaimUrlSession *) data;
parse_cookies(text, session, len);
gaim_debug_misc("gaym", "Step 4: session: %x\n", session);
if (session && GAIM_CONNECTION_IS_VALID(session->account->gc)) {
// The fourth step is to parse a rand=# value out of the message
// text from
// The previous step.
// We then connect to messenger/applet.html
char url[512];
int nonce;
//char *buf = g_strdup_printf(_("Signon: %s"),
// (session->account->username));
//gaim_connection_update_progress(session->account->gc, buf, 3, 6);
sscanf(text, "?rand=%d", &nonce);
snprintf(url, 512,
"http://www.gay.com/messenger/applet.html?rand=%d",
nonce);
session->hasFormData = TRUE;
gaim_debug_misc("weblogin","About to build url\n");
gchar* request=gaym_build_session_request(url, session);
gaim_debug_misc("weblogin","Requesting: %s\n",request);
gaim_util_fetch_url_request(url, FALSE, NULL, TRUE,
request, TRUE, gaym_weblogin_step5,
session);
gaim_debug_misc("weblogin","applet fetched");
} else {
gaim_debug_misc("gaym", "Connection was cancelled before step4\n");
gaim_debug_misc("gaym", "session: %x\n", session);
gaym_session_destroy(session);
// g_free(gaym->session);
}
}
static void
chat_left_cb(GaimConversation *conv, void *data)
{
gaim_debug_misc("signals test", "chat-left (%s)\n",
gaim_conversation_get_name(conv));
}
static void
buddy_typing_cb(GaimConversation *conv, void *data)
{
gaim_debug_misc("signals test", "buddy-typing (%s)\n",
gaim_conversation_get_name(conv));
}
/**************************************************************************
* Account subsystem signal callbacks
**************************************************************************/
static void
account_connecting_cb(GaimAccount *account, void *data)
{
gaim_debug_misc("signals test", "account-connecting (%s)\n",
gaim_account_get_username(account));
}
static void
deleting_conversation_cb(GaimConversation *conv, void *data)
{
gaim_debug_misc("signals test", "deleting-conversation (%s)\n",
gaim_conversation_get_name(conv));
}
static void
conversation_created_cb(GaimConversation *conv, void *data)
{
gaim_debug_misc("signals test", "conversation-created (%s)\n",
gaim_conversation_get_name(conv));
}
static void
sent_chat_msg_cb(GaimAccount *account, const char *buffer, int id, void *data)
{
gaim_debug_misc("signals test", "sent-chat-msg (%s, %s, %d)\n",
gaim_account_get_username(account), buffer, id);
}
static void
sent_im_msg_cb(GaimAccount *account, const char *recipient, const char *buffer, void *data)
{
gaim_debug_misc("signals test", "sent-im-msg (%s, %s, %s)\n",
gaim_account_get_username(account), recipient, buffer);
}
static void
gaym_weblogin_step5(gpointer session, const char *text, size_t len)
{
struct gaym_conn *gaym = (struct gaym_conn *) session;
// Get hash from text
if (gaym->session && GAIM_CONNECTION_IS_VALID(gaym->account->gc)) {
// char *pw_hash;
char *bio;
char *thumbnail;
char *temp = NULL;
char *temp2 = NULL;
const char *match;
const char *result;
gaym->server_stats=NULL;
gaym->hash_pw=NULL;
gaym->server_bioline=NULL;
gaym->thumbnail=NULL;
// First, look for password
match = "password\" value=\"";
temp = strstr(text, match);
if (temp) {
temp += strlen(match);
temp2 = strstr(temp, "\" ");
}
if (!
(temp && temp2 && temp != temp2
&& (gaym->hash_pw =
g_strndup(temp, (temp2 - temp) * sizeof(char))))) {
gaim_connection_error((gaym->account->gc),
_
("Problem parsing password from web. Report a bug."));
return;
}
gaim_debug_misc("weblogin",
"Got hash, temp=%x, temp2=%x, gaym->hash_pw=%x\n",
temp, temp2, gaym->hash_pw);
// Next, loook for bio
match = "param name=\"bio\" value=\"";
temp = strstr(text, match);
if (temp) {
temp += strlen(match);
temp2 = strstr(temp, "%23");
}
if (temp && temp2) {
thumbnail = g_strndup(temp, (temp2 - temp) * sizeof(char));
result = gaym_url_decode(thumbnail);
(gaym->thumbnail = g_strdup(result))
|| (gaym->thumbnail = g_strdup(" "));
g_free(thumbnail);
// Parse out non thumbnail part of bio.
temp = strstr(temp2, "\"");
if (temp) {
bio = g_strndup(temp2, (temp - temp2) * sizeof(char));
result = gaym_url_decode(bio);
gaim_debug_info("gaym", "Server BIO: %s Thumb: %s\n",
result, gaym->thumbnail);
(gaym->server_bioline = g_strdup(result))
|| (gaym->server_bioline = NULL);
g_free(bio);
//Parse out stats part of bio.
temp2 = strchr(result, (char)0x01);
if(temp2++) {
gaim_debug_misc("gaym", "Stats: %s\n", temp2);
gaym->server_stats = g_strdup(temp2);
}
}
} else {
// gaim_connection_error(
// gaim_account_get_connection(((struct
// gaym_conn*)((GaimUrlSession*)session)->account),
// _("Problem parsing password from web. Report a bug."));
}
gaym->session->session_cb(gaym->account);
} else {
gaim_debug_misc("gaym", "Connection was cancelled before step5\n");
gaim_debug_misc("gaym", "gaym->sessoin: %x\n", gaym->session);
}
}
static void
buddy_idle_cb(GaimBuddy *buddy, void *data)
{
gaim_debug_misc("signals test", "buddy-idle (%s)\n", buddy->name);
}
/**************************************************************************
* Core signal callbacks
**************************************************************************/
static void
quitting_cb(void *data)
{
gaim_debug_misc("signals test", "quitting ()\n");
}
static void
account_set_info_cb(GaimAccount *account, const char *info, void *data)
{
gaim_debug_misc("signals test", "account-set-info (%s, %s)\n",
gaim_account_get_username(account), info);
}
static void
wrote_chat_msg_cb(GaimAccount *account, GaimConversation *conv, const char *buffer, void *data)
{
gaim_debug_misc("signals test", "wrote-chat-msg (%s, %s)\n",
gaim_conversation_get_name(conv), buffer);
}
// This is a modified version of gaim's url_fetched_cb function. It has
// been
// modified to pass cookies during requests. The cookies are set in
// user_data,
// cast as a GaimUrlSession item. Any cookies in the response are added to
//
//
//
//
// this
// structure, as well.
static void
session_fetched_cb(gpointer url_data, gint sock, GaimInputCondition cond)
{
GaimFetchUrlData *gfud = url_data;
char data;
gboolean got_eof = FALSE;
if (sock == -1) {
gfud->callback(gfud->user_data, NULL, 0);
destroy_fetch_url_data(gfud);
return;
}
if (!gfud->sentreq) {
char buf[2048];
if (gfud->session->cookies == NULL)
gfud->session->cookies = g_strdup("");
if (gfud->user_agent) {
/* Host header is not forbidden in HTTP/1.0 requests, and
HTTP/1.1 clients must know how to handle the "chunked"
transfer encoding. Gaim doesn't know how to handle
"chunked", so should always send the Host header
regardless, to get around some observed problems */
g_snprintf(buf, sizeof(buf), "GET %s%s HTTP/%s\r\n" "User-Agent: %s\r\n" "Host: %s\r\n" "Cookie: %s\r\n", // (1)
//
//
//
//
// (see
// above)
(gfud->full ? "" : "/"),
(gfud->full ? gfud->url : gfud->website.page),
(gfud->http11 ? "1.1" : "1.0"),
gfud->user_agent, gfud->website.address,
gfud->session->cookies);
} else {
g_snprintf(buf, sizeof(buf), "GET %s%s HTTP/%s\r\n" "Host: %s\r\n" "Accept-Encoding: identity\r\n" "Cookie: %s\r\n", // (1)
//
//
//
//
// See
// above
(gfud->full ? "" : "/"),
(gfud->full ? gfud->url : gfud->website.page),
(gfud->http11 ? "1.1" : "1.0"),
gfud->website.address, gfud->session->cookies);
}
if (gfud->session->hasFormData)
strcat(buf,
"Content-Type: application/x-www-form-urlencoded\r\n\r\n");
else
strcat(buf, "\r\n");
gaim_debug_misc("gaim_url_fetch", "Request: %s\n", buf);
write(sock, buf, strlen(buf));
fcntl(sock, F_SETFL, O_NONBLOCK);
gfud->sentreq = TRUE;
gfud->inpa = gaim_input_add(sock, GAIM_INPUT_READ,
session_fetched_cb, url_data);
gfud->data_len = 4096;
gfud->webdata = g_malloc(gfud->data_len);
return;
}
if (read(sock, &data, 1) > 0 || errno == EWOULDBLOCK) {
if (errno == EWOULDBLOCK) {
errno = 0;
return;
}
gfud->len++;
if (gfud->len == gfud->data_len + 1) {
gfud->data_len += (gfud->data_len) / 2;
gfud->webdata = g_realloc(gfud->webdata, gfud->data_len);
}
gfud->webdata[gfud->len - 1] = data;
if (!gfud->startsaving) {
if (data == '\r')
return;
if (data == '\n') {
if (gfud->newline) {
size_t content_len;
gfud->startsaving = TRUE;
gaim_debug_misc("gaim_url_fetch",
"Response headers: '%*.*s'\n",
gfud->len, gfud->len, gfud->webdata);
// JBL 10-16-2004: Put cookies into session
gaim_debug(GAIM_DEBUG_MISC, "gaym",
"Parsing cookies...");
parse_cookies(gfud->webdata, gfud->session, gfud->len);
gaim_debug(GAIM_DEBUG_MISC, "gaym",
"Found cookies: %s\n",
(gfud->session->cookies));
gaim_debug_misc("gaim_url_fetch",
"Parsing of cookies successful\n");
/* See if we can find a redirect. */
if (parse_redirect
(gfud->webdata, gfud->len, sock, gfud))
return;
/* No redirect. See if we can find a content length. */
content_len =
parse_content_len(gfud->webdata, gfud->len);
if (content_len == 0) {
/* We'll stick with an initial 8192 */
content_len = 8192;
} else {
gfud->has_explicit_data_len = TRUE;
}
/* Out with the old... */
gfud->len = 0;
g_free(gfud->webdata);
gfud->webdata = NULL;
/* In with the new. */
gfud->data_len = content_len;
gfud->webdata = g_try_malloc(gfud->data_len);
if (gfud->webdata == NULL) {
gaim_debug_error("gaim_url_fetch",
"Failed to allocate %u bytes: %s\n",
gfud->data_len, strerror(errno));
gaim_input_remove(gfud->inpa);
close(sock);
gfud->callback(gfud->user_data, NULL, 0);
destroy_fetch_url_data(gfud);
}
} else
gfud->newline = TRUE;
return;
}
gfud->newline = FALSE;
} else if (gfud->has_explicit_data_len
&& gfud->len == gfud->data_len) {
got_eof = TRUE;
}
} else if (errno != ETIMEDOUT) {
got_eof = TRUE;
} else {
gaim_input_remove(gfud->inpa);
close(sock);
gfud->callback(gfud->user_data, NULL, 0);
destroy_fetch_url_data(gfud);
}
if (got_eof) {
gfud->webdata = g_realloc(gfud->webdata, gfud->len + 1);
gfud->webdata[gfud->len] = 0;
/* gaim_debug_misc("gaim_url_fetch", "Received: '%s'\n",
gfud->webdata); */
gaim_input_remove(gfud->inpa);
close(sock);
gfud->callback(gfud->user_data, gfud->webdata, gfud->len);
destroy_fetch_url_data(gfud);
}
}
static void
signed_off_cb(GaimConnection *gc, void *data)
{
gaim_debug_misc("signals test", "signed-off (%s)\n",
gaim_account_get_username(gaim_connection_get_account(gc)));
}
void synchronize_deny_list(GaimConnection * gc, GHashTable * confighash)
{
char *srvdeny = NULL;
gchar **srvdenylist = NULL;
GSList *list;
gint i = 0;
gboolean needsync = FALSE;
g_return_if_fail(confighash != NULL);
srvdeny =
g_hash_table_lookup(confighash, "connect-list.ignore.members");
if (!srvdeny) {
srvdeny = "";
}
srvdenylist = g_strsplit(srvdeny, ",", -1);
/**
* The nicks come in here as if they came from the IRC server
* so they need to be converted to GayM format
*/
for (i = 0; srvdenylist[i]; i++) {
gcom_nick_to_gaym(srvdenylist[i]);
}
/* Add server deny list from config.txt to local deny list */
for (i = 0; srvdenylist[i]; i++) {
needsync = TRUE;
for (list = gc->account->deny; list != NULL; list = list->next) {
if (!gaim_utf8_strcasecmp
(srvdenylist[i],
gaim_normalize(gc->account, (char *) list->data))) {
needsync = FALSE;
break;
}
}
if (needsync) {
if (!gaim_privacy_deny_add(gc->account, srvdenylist[i], TRUE)) {
gaim_debug_error("gaym",
"Failed to add %s to local deny list from server.\n",
srvdenylist[i]);
} else {
gaim_debug_misc("gaym",
"Added %s to local deny list from server.\n",
srvdenylist[i]);
}
}
}
/* Add local deny list not found in config.txt to server deny list */
for (list = gc->account->deny; list != NULL; list = list->next) {
needsync = TRUE;
for (i = 0; srvdenylist[i]; i++) {
if (!gaim_utf8_strcasecmp
(srvdenylist[i],
gaim_normalize(gc->account, (char *) list->data))) {
needsync = FALSE;
break;
}
}
if (needsync) {
gaym_server_store_deny(gc, (char *) list->data, TRUE);
}
}
g_strfreev(srvdenylist);
return;
}
static void
displayed_im_msg_cb(GaimAccount *account, GaimConversation *conv, const char *buffer, void *data)
{
gaim_debug_misc("signals test", "displayed-im-msg (%s, %s)\n",
gaim_conversation_get_name(conv), buffer);
}
