/** * Write the given OdcFrame to a ByteStream and send it out * on the established PeerConnection. */ static void peer_odc_send(PeerConnection *conn, OdcFrame *frame) { GaimAccount *account; const char *username; size_t length; ByteStream bs; gaim_debug_info("oscar", "Outgoing ODC frame to %s with " "type=0x%04x, flags=0x%04x, payload length=%u\n", conn->sn, frame->type, frame->flags, frame->payload.len); account = gaim_connection_get_account(conn->od->gc); username = gaim_account_get_username(account); memcpy(frame->sn, username, strlen(username)); memcpy(frame->cookie, conn->cookie, 8); length = 76; byte_stream_new(&bs, length + frame->payload.len); byte_stream_putraw(&bs, conn->magic, 4); byte_stream_put16(&bs, length); byte_stream_put16(&bs, frame->type); byte_stream_put16(&bs, frame->subtype); byte_stream_put16(&bs, 0x0000); byte_stream_putraw(&bs, frame->cookie, 8); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, 0x0000); byte_stream_put32(&bs, frame->payload.len); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, frame->encoding); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, frame->flags); byte_stream_put16(&bs, 0x0000); byte_stream_put16(&bs, 0x0000); byte_stream_putraw(&bs, frame->sn, 32); byte_stream_putraw(&bs, frame->payload.data, frame->payload.len); peer_connection_send(conn, &bs); g_free(bs.data); }
MsnMessage * msn_message_new(MsnMsgType type) { MsnMessage *msg; msg = g_new0(MsnMessage, 1); msg->type = type; #ifdef MSN_DEBUG_MSG gaim_debug_info("msn", "message new (%p)(%d)\n", msg, type); #endif msg->attr_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); msn_message_ref(msg); return msg; }
static void cal_error(MsnCmdProc *cmdproc, MsnTransaction *trans, int error) { int reason = MSN_SB_ERROR_UNKNOWN; if (error == 215) { gaim_debug_info("msn", "Invited user already in switchboard\n"); return; } else if (error == 217) { reason = MSN_SB_ERROR_USER_OFFLINE; } gaim_debug_warning("msn", "cal_error: command %s gave error %i\n", trans->command, error); cal_error_helper(trans, reason); }
static void resolved(gpointer data, gint source, GaimInputCondition cond) { int size; GaimSrvQueryData *query_data = (GaimSrvQueryData*)data; GaimSrvResponse *res; GaimSrvResponse *tmp; int i; GaimSrvCallback cb = query_data->cb; read(source, &size, sizeof(int)); gaim_debug_info("dnssrv","found %d SRV entries\n", size); tmp = res = g_new0(GaimSrvResponse, size); for (i = 0; i < size; i++) { read(source, tmp++, sizeof(GaimSrvResponse)); } cb(res, size, query_data->extradata); gaim_srv_cancel(query_data); }
NMRequest *nm_create_request(const char *cmd, int trans_id, int gmt, nm_response_cb cb, gpointer resp_data, gpointer user_define) { NMRequest *req; if (cmd == NULL) return NULL; req = g_new0(NMRequest, 1); req->cmd = g_strdup(cmd); req->trans_id = trans_id; req->gmt = gmt; req->callback = cb; req->data = resp_data; req->user_define = user_define; req->ref_count = 1; gaim_debug_info("novell", "Creating NMRequest instance, total=%d\n", ++count); return req; }
static gboolean res_main_thread_cb(gpointer data) { GaimSrvResponse *srvres = NULL; int size = 0; GaimSrvQueryData *query_data = data; if(query_data->error_message != NULL) gaim_debug_error("dnssrv", query_data->error_message); else { GaimSrvResponse *srvres_tmp = NULL; GSList *lst = query_data->results; size = g_slist_length(query_data->results); if(query_data->cb) srvres_tmp = srvres = g_new0(GaimSrvResponse, size); while (lst) { if(query_data->cb) memcpy(srvres_tmp++, lst->data, sizeof(GaimSrvResponse)); g_free(lst->data); lst = g_slist_remove(lst, lst->data); } query_data->results = NULL; } gaim_debug_info("dnssrv", "found %d SRV entries\n", size); if(query_data->cb) query_data->cb(srvres, size, query_data->extradata); query_data->resolver = NULL; query_data->handle = 0; gaim_srv_cancel(query_data); return FALSE; }
MsnMessage * msn_message_unref(MsnMessage *msg) { g_return_val_if_fail(msg != NULL, NULL); if (msg->ref_count <= 0) return NULL; msg->ref_count--; #ifdef MSN_DEBUG_MSG gaim_debug_info("msn", "message unref (%p)[%d]\n", msg, msg->ref_count); #endif if (msg->ref_count == 0) { msn_message_destroy(msg); return NULL; } return msg; }
static void jabber_si_xfer_bytestreams_send_connected_cb(gpointer data, gint source, GaimInputCondition cond) { GaimXfer *xfer = data; int acceptfd; gaim_debug_info("jabber", "in jabber_si_xfer_bytestreams_send_connected_cb\n"); acceptfd = accept(source, NULL, 0); if(acceptfd == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) return; else if(acceptfd == -1) { gaim_debug_warning("jabber", "accept: %s\n", strerror(errno)); return; } gaim_input_remove(xfer->watcher); close(source); xfer->watcher = gaim_input_add(acceptfd, GAIM_INPUT_READ, jabber_si_xfer_bytestreams_send_read_cb, xfer); }
void gaim_session_fetch(const char *url, gboolean full, const char *user_agent, gboolean http11, void (*cb) (gpointer, const char *, size_t), void *user_data, GaimUrlSession * session) { int sock; GaimFetchUrlData *gfud; g_return_if_fail(url != NULL); g_return_if_fail(cb != NULL); gaim_debug_info("gaim_session_fetch", "requested to fetch (%s), full=%d, user_agent=(%s), http11=%d\n", url, full, user_agent ? user_agent : "(null)", http11); gfud = g_new0(GaimFetchUrlData, 1); gfud->callback = cb; gfud->user_data = user_data; gfud->url = g_strdup(url); gfud->user_agent = (user_agent != NULL ? g_strdup(user_agent) : NULL); gfud->http11 = http11; gfud->full = full; gfud->session = session; gaim_url_parse(url, &gfud->website.address, &gfud->website.port, &gfud->website.page, &gfud->website.user, &gfud->website.passwd); if ((sock = gaim_proxy_connect(NULL, gfud->website.address, gfud->website.port, session_fetched_cb, gfud)) < 0) { destroy_fetch_url_data(gfud); cb(user_data, g_strdup(_("g003: Error opening connection.\n")), 0); } }
GaimSrvQueryData * gaim_srv_resolve(const char *protocol, const char *transport, const char *domain, GaimSrvCallback cb, gpointer extradata) { char *query; GaimSrvQueryData *query_data; #ifndef _WIN32 int in[2], out[2]; int pid; #else GError* err = NULL; static gboolean initialized = FALSE; #endif query = g_strdup_printf("_%s._%s.%s", protocol, transport, domain); gaim_debug_info("dnssrv","querying SRV record for %s\n", query); #ifndef _WIN32 if(pipe(in) || pipe(out)) { gaim_debug_error("dnssrv", "Could not create pipe\n"); g_free(query); cb(NULL, 0, extradata); return NULL; } pid = fork(); if (pid == -1) { gaim_debug_error("dnssrv", "Could not create process!\n"); cb(NULL, 0, extradata); g_free(query); return NULL; } /* Child */ if (pid == 0) { close(out[0]); close(in[1]); resolve(in[0], out[1]); } close(out[1]); close(in[0]); if (write(in[1], query, strlen(query)+1) < 0) gaim_debug_error("dnssrv", "Could not write to SRV resolver\n"); query_data = g_new0(GaimSrvQueryData, 1); query_data->cb = cb; query_data->extradata = extradata; query_data->handle = gaim_input_add(out[0], GAIM_INPUT_READ, resolved, query_data); g_free(query); return query_data; #else if (!initialized) { MyDnsQuery_UTF8 = (void*) wgaim_find_and_loadproc("dnsapi.dll", "DnsQuery_UTF8"); MyDnsRecordListFree = (void*) wgaim_find_and_loadproc( "dnsapi.dll", "DnsRecordListFree"); initialized = TRUE; } query_data = g_new0(GaimSrvQueryData, 1); query_data->cb = cb; query_data->query = query; query_data->extradata = extradata; if (!MyDnsQuery_UTF8 || !MyDnsRecordListFree) { query_data->error_message = g_strdup_printf("System missing DNS API (Requires W2K+)\n"); /* Asynchronously call the callback since stuff may not expect * the callback to be called before this returns */ query_data->handle = g_idle_add(res_main_thread_cb, query_data); return query_data; } query_data->resolver = g_thread_create(res_thread, query_data, FALSE, &err); if (query_data->resolver == NULL) { query_data->error_message = g_strdup_printf("SRV thread create failure: %s\n", err ? err->message : ""); g_error_free(err); /* Asynchronously call the callback since stuff may not expect * the callback to be called before this returns */ query_data->handle = g_idle_add(res_main_thread_cb, query_data); return query_data; } return query_data; #endif }
static void gaym_set_info(GaimConnection * gc, const char *info) { struct gaym_conn *gaym = gc->proto_data; GaimAccount *account = gaim_connection_get_account(gc); char *hostname = "none"; char *buf, *bioline; int i = 0; char *tmpinfo = NULL; if (info) { tmpinfo = g_strdup(info); for (i = 0; i < strlen(tmpinfo); i++) { if (tmpinfo[i] == '\n') { tmpinfo[i] = ' '; } } tmpinfo = g_strstrip(tmpinfo); } if (gc->away && !tmpinfo) { /** * don't change any bio settings, since this is just * setting an away message */ } else { if (gaym->bio) { g_free(gaym->bio); } if (tmpinfo && strlen(tmpinfo) > 0) { gaim_debug_misc("gaym", "option1, info=%x\n", tmpinfo); /* java client allows MAX_BIO_LEN characters */ gaym->bio = g_strndup(tmpinfo, MAX_BIO_LEN); } else if (gaym->server_bioline && strlen(gaym->server_bioline) > 0) { gaim_debug_misc("gaym", "option2\n"); gaym->bio = gaym_bio_strdup(gaym->server_bioline); } else { gaim_debug_misc("gaym", "option3\n"); gaym->bio = g_strdup("Gaim User"); } gaim_account_set_user_info(account, gaym->bio); gaim_account_set_string(account, "bioline", gaym->bio); gaim_debug_info("gaym", "INFO=%x BIO=%x\n", tmpinfo, gaym->bio); gaim_debug_misc("gaym", "In login_cb, gc->account=%x\n", gc->account); } bioline = g_strdup_printf("%s#%s\xC2\xA0 \xC2\xA0\001%s", gaym->thumbnail ? gaym->thumbnail : "", gc->away ? gc->away : (gaym->bio ? gaym->bio : ""), gaym->server_stats ? gaym->server_stats : ""); buf = gaym_format(gaym, "vvvv:", "USER", gaim_account_get_username(account), hostname, gaym->server, bioline); gaim_debug_misc("gaym", "BIO=%x\n", bioline); if (gaym_send(gaym, buf) < 0) { gaim_connection_error(gc, "Error registering with server"); } if (tmpinfo) { g_free(tmpinfo); } g_free(bioline); g_free(buf); return; }
static void gaym_login_cb(gpointer data, gint source, GaimInputCondition cond) { GaimConnection *gc = data; struct gaym_conn *gaym = gc->proto_data; char hostname[256]; char *buf; const char *username; const char *user_bioline = NULL; char *bioline; char *login_name; if (GAIM_CONNECTION_IS_VALID(gc)) { GList *connections = gaim_connections_get_all(); if (source < 0) { gaim_connection_error(gc, _("Couldn't connect to host")); return; } if (!g_list_find(connections, gc)) { close(source); return; } gaym->fd = source; gaim_debug_misc("gaym", "In login_cb with chat_key=%s\n", gaym->chat_key); if (gaym->chat_key) { buf = gaym_format(gaym, "vv", "PASS", gaym->chat_key); if (gaym_send(gaym, buf) < 0) { gaim_connection_error(gc, "Error sending password"); return; } g_free(buf); } else { gaim_connection_error(gc, _ ("Password wasn't recorded. Report bug.")); return; } gethostname(hostname, sizeof(hostname)); hostname[sizeof(hostname) - 1] = '\0'; username = gaim_account_get_string(gaym->account, "username", ""); user_bioline = g_strdup(gaim_account_get_string (gaym->account, "bioline", "")); gaim_debug_info("gaym", "USER BIOLINE=%x\n", user_bioline); gaim_account_set_user_info(gc->account, user_bioline); gaim_debug_misc("gaym", "In login_cb, user_bioline: %x, gc->account=%x\n", user_bioline, gc->account); login_name = gaym_nick_to_gcom_strdup(gaim_connection_get_display_name(gc)); bioline = g_strdup_printf("%s#%s\xC2\xA0 \xC2\xA0\001%s", gaym->thumbnail, user_bioline ? user_bioline : "", gaym->server_stats ? gaym-> server_stats : ""); buf = gaym_format(gaym, "vn", "NICK", login_name); gaim_debug_misc("gaym", "Command: %s\n", buf); if (gaym_send(gaym, buf) < 0) { gaim_connection_error(gc, "Error sending nickname"); return; } g_free(buf); buf = gaym_format(gaym, "vvvv:", "USER", login_name, hostname, gaym->server, bioline); gaim_debug_misc("gaym", "Command: %s\n", buf); if (gaym_send(gaym, buf) < 0) { gaim_connection_error(gc, "Error registering with server"); return; } g_free(login_name); g_free(buf); const char *server = gaim_account_get_string(gc->account, "server", IRC_DEFAULT_SERVER); char *url = g_strdup_printf ("http://%s/messenger/config.txt?%s", server, gaym->chat_key); char *user_agent = "Mozilla/4.0"; get_spamlist_from_web(); gaim_url_fetch(url, FALSE, user_agent, FALSE, gaym_get_configtxt_cb, gaym); g_free(url); gc->inpa = gaim_input_add(gaym->fd, GAIM_INPUT_READ, gaym_input_cb, gc); } }
void yahoo_process_chat_join(GaimConnection *gc, struct yahoo_packet *pkt) { GaimAccount *account = gaim_connection_get_account(gc); struct yahoo_data *yd = (struct yahoo_data *) gc->proto_data; GaimConversation *c = NULL; GSList *l; GList *members = NULL; GList *roomies = NULL; char *room = NULL; char *topic = NULL; char *someid, *someotherid, *somebase64orhashosomething, *somenegativenumber; if (pkt->status == -1) { /* We can't join */ struct yahoo_pair *pair = pkt->hash->data; gchar const *failed_to_join = _("Failed to join chat"); switch (atoi(pair->value)) { case 0xFFFFFFFA: /* -6 */ gaim_notify_error(gc, NULL, failed_to_join, _("Unknown room")); break; case 0xFFFFFFF1: /* -15 */ gaim_notify_error(gc, NULL, failed_to_join, _("Maybe the room is full")); break; case 0xFFFFFFDD: /* -35 */ gaim_notify_error(gc, NULL, failed_to_join, _("Not available")); break; default: gaim_notify_error(gc, NULL, failed_to_join, _("Unknown error. You may need to logout and wait five minutes before being able to rejoin a chatroom")); } return; } for (l = pkt->hash; l; l = l->next) { struct yahoo_pair *pair = l->data; switch (pair->key) { case 104: room = yahoo_string_decode(gc, pair->value, TRUE); break; case 105: topic = yahoo_string_decode(gc, pair->value, TRUE); break; case 128: someid = pair->value; break; case 108: /* number of joiners */ break; case 129: someotherid = pair->value; break; case 130: somebase64orhashosomething = pair->value; break; case 126: somenegativenumber = pair->value; break; case 13: /* this is 1. maybe its the type of room? (normal, user created, private, etc?) */ break; case 61: /*this looks similar to 130 */ break; /* the previous section was just room info. this next section is info about individual room members, (including us) */ case 109: /* the yahoo id */ members = g_list_append(members, pair->value); break; case 110: /* age */ break; case 141: /* nickname */ break; case 142: /* location */ break; case 113: /* bitmask */ break; } } if (room && yd->chat_name && gaim_utf8_strcasecmp(room, yd->chat_name)) yahoo_chat_leave(gc, room, gaim_connection_get_display_name(gc), FALSE); c = gaim_find_chat(gc, YAHOO_CHAT_ID); if (room && (!c || gaim_conv_chat_has_left(GAIM_CONV_CHAT(c))) && members && ((g_list_length(members) > 1) || !g_ascii_strcasecmp(members->data, gaim_connection_get_display_name(gc)))) { int i; GList *flags = NULL; for (i = 0; i < g_list_length(members); i++) flags = g_list_append(flags, GINT_TO_POINTER(GAIM_CBFLAGS_NONE)); if (c && gaim_conv_chat_has_left(GAIM_CONV_CHAT(c))) { /* this might be a hack, but oh well, it should nicely */ char *tmpmsg; gaim_conversation_set_name(c, room); c = serv_got_joined_chat(gc, YAHOO_CHAT_ID, room); if (topic) gaim_conv_chat_set_topic(GAIM_CONV_CHAT(c), NULL, topic); yd->in_chat = 1; yd->chat_name = g_strdup(room); gaim_conv_chat_add_users(GAIM_CONV_CHAT(c), members, NULL, flags, FALSE); tmpmsg = g_strdup_printf(_("You are now chatting in %s."), room); gaim_conv_chat_write(GAIM_CONV_CHAT(c), "", tmpmsg, GAIM_MESSAGE_SYSTEM, time(NULL)); g_free(tmpmsg); } else { c = serv_got_joined_chat(gc, YAHOO_CHAT_ID, room); if (topic) gaim_conv_chat_set_topic(GAIM_CONV_CHAT(c), NULL, topic); yd->in_chat = 1; yd->chat_name = g_strdup(room); gaim_conv_chat_add_users(GAIM_CONV_CHAT(c), members, NULL, flags, FALSE); } g_list_free(flags); } else if (c) { yahoo_chat_add_users(GAIM_CONV_CHAT(c), members); } if (account->deny && c) { GaimConversationUiOps *ops = gaim_conversation_get_ui_ops(c); for (l = account->deny; l != NULL; l = l->next) { for (roomies = members; roomies; roomies = roomies->next) { if (!gaim_utf8_strcasecmp((char *)l->data, roomies->data)) { gaim_debug_info("yahoo", "Ignoring room member %s in room %s\n" , roomies->data, room ? room : ""); gaim_conv_chat_ignore(GAIM_CONV_CHAT(c),roomies->data); ops->chat_update_user(c, roomies->data); } } } } g_list_free(roomies); g_list_free(members); g_free(room); g_free(topic); }
void yahoo_process_conference_invite(GaimConnection *gc, struct yahoo_packet *pkt) { GSList *l; char *room = NULL; char *who = NULL; char *msg = NULL; GString *members = NULL; GHashTable *components; if (pkt->status == 2) return; /* XXX */ members = g_string_sized_new(512); for (l = pkt->hash; l; l = l->next) { struct yahoo_pair *pair = l->data; switch (pair->key) { case 1: /* us, but we already know who we are */ break; case 57: room = yahoo_string_decode(gc, pair->value, FALSE); break; case 50: /* inviter */ who = pair->value; g_string_append_printf(members, "%s\n", who); break; case 52: /* invitee (me) */ case 53: /* members */ g_string_append_printf(members, "%s\n", pair->value); break; case 58: msg = yahoo_string_decode(gc, pair->value, FALSE); break; case 13: /* ? */ break; } } if (!room) { g_string_free(members, TRUE); return; } components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); g_hash_table_replace(components, g_strdup("room"), room); if (msg) g_hash_table_replace(components, g_strdup("topic"), msg); g_hash_table_replace(components, g_strdup("type"), g_strdup("Conference")); if (members) { g_hash_table_replace(components, g_strdup("members"), g_strdup(members->str)); } if (!yahoo_privacy_check(gc, who) || (gaim_account_get_bool(gaim_connection_get_account(gc), "ignore_invites", FALSE))) { gaim_debug_info("yahoo", "Invite to conference %s from %s has been dropped.\n", room, who); g_string_free(members, TRUE); return; } serv_got_chat_invite(gc, room, who, msg, components); g_string_free(members, TRUE); }
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(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; //First, look for password match="password\" value=\""; temp=strstr(text, match); if(temp) { temp+=strlen(match); temp2=strstr(temp,"\" "); } if(temp && temp2) { pw_hash=g_strndup(temp,(temp2-temp)*sizeof(char)); (gaym->hash_pw=g_strdup(pw_hash)) || (gaym->hash_pw=g_strdup(" ")); g_free(pw_hash); } else { gaim_connection_error( (gaym->account->gc), _("Problem parsing password from web. Report a bug.")); } //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); } //We have established a session. Call session callback. } 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); } }
void msn_switchboard_destroy(MsnSwitchBoard *swboard) { MsnSession *session; MsnMessage *msg; GList *l; #ifdef MSN_DEBUG_SB gaim_debug_info("msn", "switchboard_destroy: swboard(%p)\n", swboard); #endif g_return_if_fail(swboard != NULL); if (swboard->destroying) return; swboard->destroying = TRUE; /* If it linked us is because its looking for trouble */ while (swboard->slplinks != NULL) msn_slplink_destroy(swboard->slplinks->data); /* Destroy the message queue */ while ((msg = g_queue_pop_head(swboard->msg_queue)) != NULL) { if (swboard->error != MSN_SB_ERROR_NONE) { /* The messages could not be sent due to a switchboard error */ msg_error_helper(swboard->cmdproc, msg, MSN_MSG_ERROR_SB); } msn_message_unref(msg); } g_queue_free(swboard->msg_queue); /* msg_error_helper will both remove the msg from ack_list and unref it, so we don't need to do either here */ while ((l = swboard->ack_list) != NULL) msg_error_helper(swboard->cmdproc, l->data, MSN_MSG_ERROR_SB); g_free(swboard->im_user); g_free(swboard->auth_key); g_free(swboard->session_id); for (l = swboard->users; l != NULL; l = l->next) g_free(l->data); session = swboard->session; session->switches = g_list_remove(session->switches, swboard); #if 0 /* This should never happen or we are in trouble. */ if (swboard->servconn != NULL) msn_servconn_destroy(swboard->servconn); #endif swboard->cmdproc->data = NULL; msn_servconn_set_disconnect_cb(swboard->servconn, NULL); msn_servconn_destroy(swboard->servconn); g_free(swboard); }
static void msn_switchboard_add_user(MsnSwitchBoard *swboard, const char *user) { MsnCmdProc *cmdproc; GaimAccount *account; g_return_if_fail(swboard != NULL); cmdproc = swboard->cmdproc; account = cmdproc->session->account; swboard->users = g_list_prepend(swboard->users, g_strdup(user)); swboard->current_users++; swboard->empty = FALSE; #ifdef MSN_DEBUG_CHAT gaim_debug_info("msn", "user=[%s], total=%d\n", user, swboard->current_users); #endif if (!(swboard->flag & MSN_SB_FLAG_IM) && (swboard->conv != NULL)) { /* This is a helper switchboard. */ gaim_debug_error("msn", "switchboard_add_user: conv != NULL\n"); return; } if ((swboard->conv != NULL) && (gaim_conversation_get_type(swboard->conv) == GAIM_CONV_TYPE_CHAT)) { gaim_conv_chat_add_user(GAIM_CONV_CHAT(swboard->conv), user, NULL, GAIM_CBFLAGS_NONE, TRUE); } else if (swboard->current_users > 1 || swboard->total_users > 1) { if (swboard->conv == NULL || gaim_conversation_get_type(swboard->conv) != GAIM_CONV_TYPE_CHAT) { GList *l; #ifdef MSN_DEBUG_CHAT gaim_debug_info("msn", "[chat] Switching to chat.\n"); #endif #if 0 /* this is bad - it causes msn_switchboard_close to be called on the * switchboard we're in the middle of using :( */ if (swboard->conv != NULL) gaim_conversation_destroy(swboard->conv); #endif swboard->chat_id = cmdproc->session->conv_seq++; swboard->flag |= MSN_SB_FLAG_IM; swboard->conv = serv_got_joined_chat(account->gc, swboard->chat_id, "MSN Chat"); for (l = swboard->users; l != NULL; l = l->next) { const char *tmp_user; tmp_user = l->data; #ifdef MSN_DEBUG_CHAT gaim_debug_info("msn", "[chat] Adding [%s].\n", tmp_user); #endif gaim_conv_chat_add_user(GAIM_CONV_CHAT(swboard->conv), tmp_user, NULL, GAIM_CBFLAGS_NONE, TRUE); } #ifdef MSN_DEBUG_CHAT gaim_debug_info("msn", "[chat] We add ourselves.\n"); #endif gaim_conv_chat_add_user(GAIM_CONV_CHAT(swboard->conv), gaim_account_get_username(account), NULL, GAIM_CBFLAGS_NONE, TRUE); g_free(swboard->im_user); swboard->im_user = NULL; } } else if (swboard->conv == NULL) { swboard->conv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, user, account); } else { gaim_debug_warning("msn", "switchboard_add_user: This should not happen!\n"); } }
void gaim_connection_new(GaimAccount *account, gboolean regist, const char *password) { GaimConnection *gc; GaimPlugin *prpl; GaimPluginProtocolInfo *prpl_info; g_return_if_fail(account != NULL); if (!gaim_account_is_disconnected(account)) return; prpl = gaim_find_prpl(gaim_account_get_protocol_id(account)); if (prpl != NULL) prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(prpl); else { gchar *message; message = g_strdup_printf(_("Missing protocol plugin for %s"), gaim_account_get_username(account)); gaim_notify_error(NULL, regist ? _("Registration Error") : _("Connection Error"), message, NULL); g_free(message); return; } if (regist) { if (prpl_info->register_user == NULL) return; } else { if (((password == NULL) || (*password == '\0')) && !(prpl_info->options & OPT_PROTO_NO_PASSWORD) && !(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL)) { gaim_debug_error("connection", "Can not connect to account %s without " "a password.\n", gaim_account_get_username(account)); return; } } gc = g_new0(GaimConnection, 1); GAIM_DBUS_REGISTER_POINTER(gc, GaimConnection); gc->prpl = prpl; if ((password != NULL) && (*password != '\0')) gc->password = g_strdup(password); gaim_connection_set_account(gc, account); gaim_connection_set_state(gc, GAIM_CONNECTING); connections = g_list_append(connections, gc); gaim_account_set_connection(account, gc); gaim_signal_emit(gaim_connections_get_handle(), "signing-on", gc); if (regist) { gaim_debug_info("connection", "Registering. gc = %p\n", gc); /* set this so we don't auto-reconnect after registering */ gc->wants_to_die = TRUE; prpl_info->register_user(account); } else { gaim_debug_info("connection", "Connecting. gc = %p\n", gc); gaim_signal_emit(gaim_accounts_get_handle(), "account-connecting", account); prpl_info->login(account); } }
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); } }
void msn_message_show_readable(MsnMessage *msg, const char *info, gboolean text_body) { GString *str; size_t body_len; const char *body; GList *l; g_return_if_fail(msg != NULL); str = g_string_new(NULL); /* Standard header. */ if (msg->charset == NULL) { g_string_append_printf(str, "MIME-Version: 1.0\r\n" "Content-Type: %s\r\n", msg->content_type); } else { g_string_append_printf(str, "MIME-Version: 1.0\r\n" "Content-Type: %s; charset=%s\r\n", msg->content_type, msg->charset); } for (l = msg->attr_list; l; l = l->next) { char *key; const char *value; key = l->data; value = msn_message_get_attr(msg, key); g_string_append_printf(str, "%s: %s\r\n", key, value); } g_string_append(str, "\r\n"); body = msn_message_get_bin_data(msg, &body_len); if (msg->msnslp_message) { g_string_append_printf(str, "Session ID: %u\r\n", msg->msnslp_header.session_id); g_string_append_printf(str, "ID: %u\r\n", msg->msnslp_header.id); g_string_append_printf(str, "Offset: %" G_GUINT64_FORMAT "\r\n", msg->msnslp_header.offset); g_string_append_printf(str, "Total size: %" G_GUINT64_FORMAT "\r\n", msg->msnslp_header.total_size); g_string_append_printf(str, "Length: %u\r\n", msg->msnslp_header.length); g_string_append_printf(str, "Flags: 0x%x\r\n", msg->msnslp_header.flags); g_string_append_printf(str, "ACK ID: %u\r\n", msg->msnslp_header.ack_id); g_string_append_printf(str, "SUB ID: %u\r\n", msg->msnslp_header.ack_sub_id); g_string_append_printf(str, "ACK Size: %" G_GUINT64_FORMAT "\r\n", msg->msnslp_header.ack_size); #ifdef MSN_DEBUG_SLP_VERBOSE if (body != NULL) { if (text_body) { g_string_append_len(str, body, body_len); if (body[body_len - 1] == '\0') { str->len--; g_string_append(str, " 0x00"); } g_string_append(str, "\r\n"); } else { int i; for (i = 0; i < msg->body_len; i++) { g_string_append_printf(str, "%.2hhX ", body[i]); if ((i % 16) == 15) g_string_append(str, "\r\n"); } g_string_append(str, "\r\n"); } } #endif g_string_append_printf(str, "Footer: %u\r\n", msg->msnslp_footer.value); } else { if (body != NULL) { g_string_append_len(str, body, body_len); g_string_append(str, "\r\n"); } } gaim_debug_info("msn", "Message %s:\n{%s}\n", info, str->str); g_string_free(str, TRUE); }
static void jabber_si_xfer_bytestreams_send_read_again_cb(gpointer data, gint source, GaimInputCondition cond) { GaimXfer *xfer = data; JabberSIXfer *jsx = xfer->data; int i; char buffer[256]; int len; char *dstaddr, *p; unsigned char hashval[20]; const char *host; gaim_debug_info("jabber", "in jabber_si_xfer_bytestreams_send_read_again_cb\n"); if(jsx->rxlen < 5) { gaim_debug_info("jabber", "reading the first 5 bytes\n"); len = read(source, buffer, 5 - jsx->rxlen); if(len < 0 && errno == EAGAIN) return; else if(len <= 0) { gaim_input_remove(xfer->watcher); xfer->watcher = 0; close(source); gaim_xfer_cancel_remote(xfer); return; } jsx->rxqueue = g_realloc(jsx->rxqueue, len + jsx->rxlen); memcpy(jsx->rxqueue + jsx->rxlen, buffer, len); jsx->rxlen += len; return; } else if(jsx->rxqueue[0] != 0x05 || jsx->rxqueue[1] != 0x01 || jsx->rxqueue[3] != 0x03) { gaim_debug_info("jabber", "invalid socks5 stuff\n"); gaim_input_remove(xfer->watcher); xfer->watcher = 0; close(source); gaim_xfer_cancel_remote(xfer); return; } else if(jsx->rxlen - 5 < jsx->rxqueue[4] + 2) { gaim_debug_info("jabber", "reading umpteen more bytes\n"); len = read(source, buffer, jsx->rxqueue[4] + 5 + 2 - jsx->rxlen); if(len < 0 && errno == EAGAIN) return; else if(len <= 0) { gaim_input_remove(xfer->watcher); xfer->watcher = 0; close(source); gaim_xfer_cancel_remote(xfer); return; } jsx->rxqueue = g_realloc(jsx->rxqueue, len + jsx->rxlen); memcpy(jsx->rxqueue + jsx->rxlen, buffer, len); jsx->rxlen += len; } if(jsx->rxlen - 5 < jsx->rxqueue[4] + 2) return; gaim_input_remove(xfer->watcher); xfer->watcher = 0; dstaddr = g_strdup_printf("%s%s@%s/%s%s", jsx->stream_id, jsx->js->user->node, jsx->js->user->domain, jsx->js->user->resource, xfer->who); gaim_cipher_digest_region("sha1", (guchar *)dstaddr, strlen(dstaddr), sizeof(hashval), hashval, NULL); g_free(dstaddr); dstaddr = g_malloc(41); p = dstaddr; for(i=0; i<20; i++, p+=2) snprintf(p, 3, "%02x", hashval[i]); if(jsx->rxqueue[4] != 40 || strncmp(dstaddr, jsx->rxqueue+5, 40) || jsx->rxqueue[45] != 0x00 || jsx->rxqueue[46] != 0x00) { gaim_debug_error("jabber", "someone connected with the wrong info!\n"); close(source); gaim_xfer_cancel_remote(xfer); return; } g_free(jsx->rxqueue); host = gaim_network_get_my_ip(jsx->js->fd); jsx->rxmaxlen = 5 + strlen(host) + 2; jsx->rxqueue = g_malloc(jsx->rxmaxlen); jsx->rxlen = 0; jsx->rxqueue[0] = 0x05; jsx->rxqueue[1] = 0x00; jsx->rxqueue[2] = 0x00; jsx->rxqueue[3] = 0x03; jsx->rxqueue[4] = strlen(host); memcpy(jsx->rxqueue + 5, host, strlen(host)); jsx->rxqueue[5+strlen(host)] = 0x00; jsx->rxqueue[6+strlen(host)] = 0x00; xfer->watcher = gaim_input_add(source, GAIM_INPUT_WRITE, jabber_si_xfer_bytestreams_send_read_again_resp_cb, xfer); jabber_si_xfer_bytestreams_send_read_again_resp_cb(xfer, source, GAIM_INPUT_WRITE); }
/** * This is our callback for the receiving-im-msg signal. * * We return TRUE to block the IM, FALSE to accept the IM */ static gboolean receiving_im_msg_cb(GaimAccount * account, char **sender, char **buffer, int *flags, void *data) { gboolean retval = FALSE; /* assume the sender is allowed */ gboolean found = FALSE; gint pos = -1; char *botmsg = NULL; PendingMessage *pending = NULL; GSList *slist = NULL; GSList *search = NULL; GaimConnection *connection = NULL; /* expire any old entries in pending */ expire_pending_list(); connection = gaim_account_get_connection(account); /* not good, but don't do anything */ if (!connection || !sender) { return retval; } /* if there is already an open conversation, allowed it */ if (gaim_find_conversation_with_account(*sender, account)) { return retval; } /* don't make buddies use the challenge/response system */ if (gaim_find_buddy(account, *sender)) { return retval; } /* don't make permit list members use the challenge/response system */ for (slist = account->permit; slist != NULL; slist = slist->next) { if (!gaim_utf8_strcasecmp (*sender, gaim_normalize(account, (char *) slist->data))) { return retval; } } /* if there is no question or no answer, allow the sender */ const char *question = gaim_prefs_get_string("/plugins/core/bot/challenger/question"); const char *answer = gaim_prefs_get_string("/plugins/core/bot/challenger/answer"); if (!question || !answer) { return retval; } /* blank / null message ... can this even happen? */ if (!*buffer) { return retval; } /* search if this sender is already in pending */ for (search = pending_list; search; search = search->next) { pending = search->data; pos = g_slist_position(pending_list, search); if (protocmp(account, pending) && usercmp(account, pending) && sendercmp(*sender, pending)) { found = TRUE; break; } } if (!found) { /** * its the first time through, save the nick/msg to the * queue and ask the question */ GTimeVal *now = NULL; now = g_new0(GTimeVal, 1); g_get_current_time(now); PendingMessage *newpend = NULL; newpend = g_new0(PendingMessage, 1); newpend->tv_sec = now->tv_sec; newpend->protocol = g_strdup(account->protocol_id); newpend->username = g_strdup(account->username); newpend->sender = g_strdup(*sender); newpend->message = g_strdup(*buffer); pending_list = g_slist_append(pending_list, newpend); botmsg = g_strdup_printf(_ ("Bot Challenger engaged: you are now being ignored! Your message will be delivered if you can correctly answer the following question within %i minutes: %s"), BOT_MAX_MINUTES, question); send_auto_reply(account, *sender, botmsg); g_free(now); g_free(botmsg); retval = TRUE; } else { if (gaim_utf8_strcasecmp(*buffer, answer)) { /** * Sorry, thanks for playing, please try again */ retval = TRUE; } else { botmsg = _ ("Bot Challenger accepted your answer and delivered your original message. You may now speak freely."); send_auto_reply(account, *sender, botmsg); if (gaim_prefs_get_bool ("/plugins/core/bot/challenger/auto_add_permit")) { if (!gaim_privacy_permit_add(account, *sender, FALSE)) { gaim_debug_info("bot-challenger", "Unable to add %s/%s/%s to permit list\n", *sender, pending->username, pending->protocol); } } /** * Free what is currently in the buffer (the correct answer) * and replace it with the user's first message that was * queued, pending the correct answer. I think some other * process is supposed to free the buffer after its sent. */ g_free(*buffer); *buffer = pending->message; /* Clean up everything else except pending->message */ free_pending(search, FALSE); retval = FALSE; /* Don't block this message */ } } debug_pending_list(); return retval; /* returning TRUE will block the IM */ }
static void read_cb(gpointer data, gint source, GaimInputCondition cond) { MsnDirectConn* directconn; char *body; size_t len, body_len; gaim_debug_info("msn", "read_cb: %d, %d\n", source, cond); directconn = data; /* Let's read the length of the data. */ len = read(directconn->fd, &body_len, sizeof(body_len)); if (len <= 0) { /* ERROR */ gaim_debug_error("msn", "error reading\n"); msn_directconn_destroy(directconn); return; } body_len = GUINT32_FROM_LE(body_len); gaim_debug_info("msn", "body_len=%d\n", body_len); if (body_len <= 0) { /* ERROR */ gaim_debug_error("msn", "error reading\n"); msn_directconn_destroy(directconn); return; } body = g_try_malloc(body_len); if (body != NULL) { /* Let's read the data. */ len = read(directconn->fd, body, body_len); gaim_debug_info("msn", "len=%d\n", len); } else { gaim_debug_error("msn", "Failed to allocate memory for read\n"); len = 0; } if (len > 0) { MsnMessage *msg; #ifdef DEBUG_DC str = g_strdup_printf("/home/revo/msntest/r%.4d.bin", directconn->c); FILE *tf = g_fopen(str, "w"); fwrite(body, 1, len, tf); fclose(tf); g_free(str); #endif directconn->c++; msg = msn_message_new_msnslp(); msn_message_parse_slp_body(msg, body, body_len); msn_directconn_process_msg(directconn, msg); } else { /* ERROR */ gaim_debug_error("msn", "error reading\n"); msn_directconn_destroy(directconn); } }
static void gaym_weblogin_step5(GaimUtilFetchUrlData *url_data, gpointer data, const gchar *text, gsize len, const gchar* err) { gaim_debug_misc("weblogin","STEP FIVE BEGINS\n"); GaimUrlSession *session = (GaimUrlSession *) data; struct gaym_conn *gaym = session->gaym; // Get hash from text if (session && GAIM_CONNECTION_IS_VALID(session->account->gc)) { char *bio; char *thumbnail; char *temp = NULL; char *temp2 = NULL; const char *match; const char *result; gaym->server_stats = NULL; gaym->chat_key = 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->chat_key = g_strndup(temp, (temp2 - temp) * sizeof(char))))) { gaim_connection_error((session->account->gc), _ ("Problem parsing password from web. Report a bug.")); return; } gaim_debug_misc("weblogin", "Got hash, temp=%x, temp2=%x, gaym->chat_key=%x\n", temp, temp2, gaym->chat_key); // 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."))); } session->session_cb(gaym->account); } else { gaim_debug_misc("gaym", "Connection was cancelled before step5\n"); gaim_debug_misc("gaym", "gaym->session: %x\n", session); } // We don't need the session info anymore. gaym_session_destroy(session); }
static void jabber_si_xfer_bytestreams_send_read_cb(gpointer data, gint source, GaimInputCondition cond) { GaimXfer *xfer = data; JabberSIXfer *jsx = xfer->data; int i; int len; char buffer[256]; gaim_debug_info("jabber", "in jabber_si_xfer_bytestreams_send_read_cb\n"); xfer->fd = source; if(jsx->rxlen < 2) { gaim_debug_info("jabber", "reading those first two bytes\n"); len = read(source, buffer, 2 - jsx->rxlen); if(len < 0 && errno == EAGAIN) return; else if(len <= 0) { gaim_input_remove(xfer->watcher); xfer->watcher = 0; close(source); gaim_xfer_cancel_remote(xfer); return; } jsx->rxqueue = g_realloc(jsx->rxqueue, len + jsx->rxlen); memcpy(jsx->rxqueue + jsx->rxlen, buffer, len); jsx->rxlen += len; return; } else if(jsx->rxlen - 2 < jsx->rxqueue[1]) { gaim_debug_info("jabber", "reading the next umpteen bytes\n"); len = read(source, buffer, jsx->rxqueue[1] + 2 - jsx->rxlen); if(len < 0 && errno == EAGAIN) return; else if(len <= 0) { gaim_input_remove(xfer->watcher); xfer->watcher = 0; close(source); gaim_xfer_cancel_remote(xfer); return; } jsx->rxqueue = g_realloc(jsx->rxqueue, len + jsx->rxlen); memcpy(jsx->rxqueue + jsx->rxlen, buffer, len); jsx->rxlen += len; } if(jsx->rxlen -2 < jsx->rxqueue[1]) return; gaim_input_remove(xfer->watcher); xfer->watcher = 0; gaim_debug_info("jabber", "checking to make sure we're socks FIVE\n"); if(jsx->rxqueue[0] != 0x05) { close(source); gaim_xfer_cancel_remote(xfer); return; } gaim_debug_info("jabber", "going to test %hhu different methods\n", jsx->rxqueue[1]); for(i=0; i<jsx->rxqueue[1]; i++) { gaim_debug_info("jabber", "testing %hhu\n", jsx->rxqueue[i+2]); if(jsx->rxqueue[i+2] == 0x00) { g_free(jsx->rxqueue); jsx->rxlen = 0; jsx->rxmaxlen = 2; jsx->rxqueue = g_malloc(jsx->rxmaxlen); jsx->rxqueue[0] = 0x05; jsx->rxqueue[1] = 0x00; xfer->watcher = gaim_input_add(source, GAIM_INPUT_WRITE, jabber_si_xfer_bytestreams_send_read_response_cb, xfer); jabber_si_xfer_bytestreams_send_read_response_cb(xfer, source, GAIM_INPUT_WRITE); jsx->rxqueue = NULL; jsx->rxlen = 0; return; } } g_free(jsx->rxqueue); jsx->rxlen = 0; jsx->rxmaxlen = 2; jsx->rxqueue = g_malloc(jsx->rxmaxlen); jsx->rxqueue[0] = 0x05; jsx->rxqueue[1] = 0xFF; xfer->watcher = gaim_input_add(source, GAIM_INPUT_WRITE, jabber_si_xfer_bytestreams_send_read_response_cb, xfer); jabber_si_xfer_bytestreams_send_read_response_cb(xfer, source, GAIM_INPUT_WRITE); }
gboolean gaym_privacy_check(GaimConnection * gc, const char *nick) { /** * returns TRUE if allowed through, FALSE otherwise */ GSList *list; gboolean permitted = FALSE; switch (gc->account->perm_deny) { case 0: gaim_debug_warning("gaym", "Privacy setting was 0. If you can " "reproduce this, please file a bug report.\n"); permitted = TRUE; break; case GAIM_PRIVACY_ALLOW_ALL: permitted = TRUE; break; case GAIM_PRIVACY_DENY_ALL: gaim_debug_info("gaym", "%s blocked data received from %s (GAIM_PRIVACY_DENY_ALL)\n", gc->account->username, nick); break; case GAIM_PRIVACY_ALLOW_USERS: for (list = gc->account->permit; list != NULL; list = list->next) { if (!gaim_utf8_strcasecmp (nick, gaim_normalize(gc->account, (char *) list->data))) { permitted = TRUE; gaim_debug_info("gaym", "%s allowed data received from %s (GAIM_PRIVACY_ALLOW_USERS)\n", gc->account->username, nick); break; } } break; case GAIM_PRIVACY_DENY_USERS: /* seeing we're letting everyone through, except the deny list */ permitted = TRUE; for (list = gc->account->deny; list != NULL; list = list->next) { if (!gaim_utf8_strcasecmp (nick, gaim_normalize(gc->account, (char *) list->data))) { permitted = FALSE; gaim_debug_info("gaym", "%s blocked data received from %s (GAIM_PRIVACY_DENY_USERS)\n", gc->account->username, nick); break; } } break; case GAIM_PRIVACY_ALLOW_BUDDYLIST: if (gaim_find_buddy(gc->account, nick) != NULL) { permitted = TRUE; } else { gaim_debug_info("gaym", "%s blocked data received from %s (GAIM_PRIVACY_ALLOW_BUDDYLIST)\n", gc->account->username, nick); } break; default: gaim_debug_warning("gaym", "Privacy setting was unknown. If you can " "reproduce this, please file a bug report.\n"); permitted = FALSE; break; } /** * don't block/ignore self */ if (!gaim_utf8_strcasecmp(gc->account->username, nick)) { permitted = TRUE; gaim_debug_info("gaym", "declining to block/ignore self\n"); return permitted; } return permitted; }
void gaim_connection_destroy(GaimConnection *gc) { GaimAccount *account; GSList *buddies, *tmp; #if 0 GList *wins; #endif GaimPluginProtocolInfo *prpl_info = NULL; gboolean remove = FALSE; g_return_if_fail(gc != NULL); account = gaim_connection_get_account(gc); gaim_debug_info("connection", "Disconnecting connection %p\n", gc); if (gaim_connection_get_state(gc) != GAIM_CONNECTING) remove = TRUE; gaim_signal_emit(gaim_connections_get_handle(), "signing-off", gc); while (gc->buddy_chats) { GaimConversation *b = gc->buddy_chats->data; gc->buddy_chats = g_slist_remove(gc->buddy_chats, b); gaim_conv_chat_left(GAIM_CONV_CHAT(b)); } update_keepalive(gc, FALSE); gaim_proxy_connect_cancel_with_handle(gc); prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(gc->prpl); if (prpl_info->close) (prpl_info->close)(gc); /* Clear out the proto data that was freed in the prpl close method*/ buddies = gaim_find_buddies(account, NULL); for (tmp = buddies; tmp; tmp = tmp->next) { GaimBuddy *buddy = tmp->data; buddy->proto_data = NULL; } g_slist_free(buddies); connections = g_list_remove(connections, gc); gaim_connection_set_state(gc, GAIM_DISCONNECTED); if (remove) gaim_blist_remove_account(account); gaim_signal_emit(gaim_connections_get_handle(), "signed-off", gc); #if 0 /* see comment later in file on if 0'd same code */ /* * XXX This is a hack! Remove this and replace it with a better event * notification system. */ for (wins = gaim_get_windows(); wins != NULL; wins = wins->next) { GaimConvWindow *win = (GaimConvWindow *)wins->data; gaim_conversation_update(gaim_conv_window_get_conversation_at(win, 0), GAIM_CONV_ACCOUNT_OFFLINE); } #endif gaim_request_close_with_handle(gc); gaim_notify_close_with_handle(gc); gaim_debug_info("connection", "Destroying connection %p\n", gc); gaim_account_set_connection(account, NULL); g_free(gc->password); g_free(gc->display_name); if (gc->disconnect_timeout) gaim_timeout_remove(gc->disconnect_timeout); GAIM_DBUS_UNREGISTER_POINTER(gc); g_free(gc); }