void irc_msg_default(struct irc_conn *irc, const char *name, const char *from, char **args) { char *clean; /* This, too, should be escaped somehow (smarter) */ clean = purple_utf8_salvage(args[0]); purple_debug(PURPLE_DEBUG_INFO, "irc", "Unrecognized message: %s\n", clean); g_free(clean); }
static void irc_parse_error_cb(struct irc_conn *irc, char *input) { char *clean; /* This really should be escaped somehow that you can tell what * the junk was -- but as it is, it can crash glib. */ clean = purple_utf8_salvage(input); purple_debug(PURPLE_DEBUG_WARNING, "irc", "Unrecognized string: %s\n", clean); g_free(clean); }
static char *irc_recv_convert(struct irc_conn *irc, const char *string) { char *utf8 = NULL; const gchar *charset, *enclist; gchar **encodings; gboolean autodetect; int i; enclist = purple_account_get_string(irc->account, "encoding", IRC_DEFAULT_CHARSET); encodings = g_strsplit(enclist, ",", -1); if (encodings[0] == NULL) { g_strfreev(encodings); return purple_utf8_salvage(string); } autodetect = purple_account_get_bool(irc->account, "autodetect_utf8", IRC_DEFAULT_AUTODETECT); if (autodetect && g_utf8_validate(string, -1, NULL)) { return g_strdup(string); } for (i = 0; encodings[i] != NULL; i++) { charset = encodings[i]; while (*charset == ' ') charset++; if (!g_ascii_strcasecmp("UTF-8", charset)) { if (g_utf8_validate(string, -1, NULL)) utf8 = g_strdup(string); } else { utf8 = g_convert(string, -1, "UTF-8", charset, NULL, NULL, NULL); } if (utf8) { g_strfreev(encodings); return utf8; } } g_strfreev(encodings); return purple_utf8_salvage(string); }
int irc_send_len(struct irc_conn *irc, const char *buf, int buflen) { int ret; char *tosend = g_strdup(buf); purple_signal_emit(_irc_plugin, "irc-sending-text", purple_account_get_connection(irc->account), &tosend); if (tosend == NULL) return 0; if (!purple_strequal(tosend, buf)) { buflen = strlen(tosend); } if (purple_debug_is_verbose()) { char *clean = purple_utf8_salvage(tosend); clean = g_strstrip(clean); purple_debug_misc("irc", "<< %s\n", clean); g_free(clean); } /* If we're not buffering writes, try to send immediately */ if (!irc->writeh) ret = do_send(irc, tosend, buflen); else { ret = -1; errno = EAGAIN; } /* purple_debug(PURPLE_DEBUG_MISC, "irc", "sent%s: %s", irc->gsc ? " (ssl)" : "", tosend); */ if (ret <= 0 && errno != EAGAIN) { PurpleConnection *gc = purple_account_get_connection(irc->account); gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"), g_strerror(errno)); purple_connection_error_reason (gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp); g_free(tmp); } else if (ret < buflen) { if (ret < 0) ret = 0; if (!irc->writeh) irc->writeh = purple_input_add( irc->gsc ? irc->gsc->fd : irc->fd, PURPLE_INPUT_WRITE, irc_send_cb, irc); purple_circ_buffer_append(irc->outbuf, tosend + ret, buflen - ret); } g_free(tosend); return ret; }
void msn_message_parse_payload(MsnMessage *msg, const char *payload, size_t payload_len, const char *line_dem,const char *body_dem) { char *tmp_base, *tmp; const char *content_type; char *end; char **elems, **cur, **tokens; g_return_if_fail(payload != NULL); tmp_base = tmp = g_malloc(payload_len + 1); memcpy(tmp_base, payload, payload_len); tmp_base[payload_len] = '\0'; /* Find the end of the headers */ end = strstr(tmp, body_dem); /* TODO? some clients use \r delimiters instead of \r\n, the official client * doesn't send such messages, but does handle receiving them. We'll just * avoid crashing for now */ if (end == NULL) { g_free(tmp_base); g_return_if_reached(); } /* NUL-terminate the end of the headers - it'll get skipped over below */ *end = '\0'; /* Split the headers and parse each one */ elems = g_strsplit(tmp, line_dem, 0); for (cur = elems; *cur != NULL; cur++) { const char *key, *value; /* If this line starts with whitespace, it's been folded from the previous line and won't have ':'. */ if ((**cur == ' ') || (**cur == '\t')) { tokens = g_strsplit(g_strchug(*cur), "=\"", 2); key = tokens[0]; value = tokens[1]; /* The only one I care about is 'boundary' (which is folded from the key 'Content-Type'), so only process that. */ if (!strcmp(key, "boundary") && value) { char *end = strchr(value, '\"'); if (end) { *end = '\0'; msn_message_set_header(msg, key, value); } } g_strfreev(tokens); continue; } tokens = g_strsplit(*cur, ": ", 2); key = tokens[0]; value = tokens[1]; if (!strcmp(key, "MIME-Version")) { /* Ignore MIME-Version header */ } else if (!strcmp(key, "Content-Type")) { char *charset, *c; if (value && (c = strchr(value, ';')) != NULL) { if ((charset = strchr(c, '=')) != NULL) { charset++; msn_message_set_charset(msg, charset); } *c = '\0'; } msn_message_set_content_type(msg, value); } else { msn_message_set_header(msg, key, value); } g_strfreev(tokens); } g_strfreev(elems); /* Proceed to the end of the "\r\n\r\n" */ tmp = end + strlen(body_dem); /* Now we *should* be at the body. */ content_type = msn_message_get_content_type(msg); if (payload_len - (tmp - tmp_base) > 0) { msg->body_len = payload_len - (tmp - tmp_base); g_free(msg->body); msg->body = g_malloc(msg->body_len + 1); memcpy(msg->body, tmp, msg->body_len); msg->body[msg->body_len] = '\0'; } if (msg->body && content_type && purple_str_has_prefix(content_type, "text/")) { char *body = NULL; if (msg->charset == NULL || g_str_equal(msg->charset, "UTF-8")) { /* Charset is UTF-8 */ if (!g_utf8_validate(msg->body, msg->body_len, NULL)) { purple_debug_warning("msn", "Message contains invalid " "UTF-8. Attempting to salvage.\n"); body = purple_utf8_salvage(msg->body); payload_len = strlen(body); } } else { /* Charset is something other than UTF-8 */ GError *err = NULL; body = g_convert(msg->body, msg->body_len, "UTF-8", msg->charset, NULL, &payload_len, &err); if (!body || err) { purple_debug_warning("msn", "Unable to convert message from " "%s to UTF-8: %s\n", msg->charset, err ? err->message : "Unknown error"); if (err) g_error_free(err); /* Fallback to ISO-8859-1 */ g_free(body); body = g_convert(msg->body, msg->body_len, "UTF-8", "ISO-8859-1", NULL, &payload_len, NULL); if (!body) { g_free(msg->body); msg->body = NULL; msg->body_len = 0; } } } if (body) { g_free(msg->body); msg->body = body; msg->body_len = payload_len; msn_message_set_charset(msg, "UTF-8"); } } g_free(tmp_base); }
/** * Someone else wants to establish a peer connection with us. */ void peer_connection_got_proposition(OscarData *od, const gchar *bn, const gchar *message, IcbmArgsCh2 *args) { PurpleConnection *gc; PurpleAccount *account; PeerConnection *conn; gchar *buf; gc = od->gc; account = purple_connection_get_account(gc); /* * If we have a connection with this same cookie then they are * probably just telling us they weren't able to connect to us * and we should try connecting to them, instead. Or they want * to go through a proxy. */ conn = peer_connection_find_by_cookie(od, bn, args->cookie); if ((conn != NULL) && (conn->type == args->type)) { purple_debug_info("oscar", "Remote user wants to try a " "different connection method\n"); g_free(conn->proxyip); g_free(conn->clientip); g_free(conn->verifiedip); if (args->use_proxy) conn->proxyip = g_strdup(args->proxyip); else conn->proxyip = NULL; conn->verifiedip = g_strdup(args->verifiedip); conn->clientip = g_strdup(args->clientip); conn->port = args->port; conn->use_proxy |= args->use_proxy; conn->lastrequestnumber++; peer_connection_trynext(conn); return; } /* If this is a direct IM, then close any existing session */ if (args->type == OSCAR_CAPABILITY_DIRECTIM) { conn = peer_connection_find_by_type(od, bn, args->type); if (conn != NULL) { /* Close the old direct IM and start a new one */ purple_debug_info("oscar", "Received new direct IM request " "from %s. Destroying old connection.\n", bn); peer_connection_destroy(conn, OSCAR_DISCONNECT_REMOTE_CLOSED, NULL); } } /* Check for proper arguments */ if (args->type == OSCAR_CAPABILITY_SENDFILE) { if ((args->info.sendfile.filename == NULL) || (args->info.sendfile.totsize == 0) || (args->info.sendfile.totfiles == 0)) { purple_debug_warning("oscar", "%s tried to send you a file with incomplete " "information.\n", bn); return; } } conn = peer_connection_new(od, args->type, bn); memcpy(conn->cookie, args->cookie, 8); if (args->use_proxy) conn->proxyip = g_strdup(args->proxyip); conn->clientip = g_strdup(args->clientip); conn->verifiedip = g_strdup(args->verifiedip); conn->port = args->port; conn->use_proxy |= args->use_proxy; conn->lastrequestnumber++; if (args->type == OSCAR_CAPABILITY_DIRECTIM) { buf = g_strdup_printf(_("%s has just asked to directly connect to %s"), bn, purple_account_get_username(account)); purple_request_action(conn, NULL, buf, _("This requires a direct connection between " "the two computers and is necessary for IM " "Images. Because your IP address will be " "revealed, this may be considered a privacy " "risk."), PURPLE_DEFAULT_ACTION_NONE, account, bn, NULL, conn, 2, _("C_onnect"), G_CALLBACK(peer_connection_got_proposition_yes_cb), _("Cancel"), G_CALLBACK(peer_connection_got_proposition_no_cb)); } else if (args->type == OSCAR_CAPABILITY_SENDFILE) { gchar *filename; conn->xfer = purple_xfer_new(account, PURPLE_XFER_RECEIVE, bn); if (conn->xfer) { conn->xfer->data = conn; purple_xfer_ref(conn->xfer); purple_xfer_set_size(conn->xfer, args->info.sendfile.totsize); /* Set the file name */ if (g_utf8_validate(args->info.sendfile.filename, -1, NULL)) filename = g_strdup(args->info.sendfile.filename); else filename = purple_utf8_salvage(args->info.sendfile.filename); if (args->info.sendfile.subtype == AIM_OFT_SUBTYPE_SEND_DIR) { /* * If they are sending us a directory then the last character * of the file name will be an asterisk. We don't want to * save stuff to a directory named "*" so we remove the * asterisk from the file name. */ char *tmp = strrchr(filename, '\\'); if ((tmp != NULL) && (tmp[1] == '*')) tmp[0] = '\0'; } purple_xfer_set_filename(conn->xfer, filename); g_free(filename); /* * Set the message, unless this is the dummy message from an * ICQ client or an empty message from an AIM client. * TODO: Maybe we should strip HTML and then see if strlen>0? */ if ((message != NULL) && (g_ascii_strncasecmp(message, "<ICQ_COOL_FT>", 13) != 0) && (g_ascii_strcasecmp(message, "<HTML>") != 0)) { purple_xfer_set_message(conn->xfer, message); } /* Setup our I/O op functions */ purple_xfer_set_init_fnc(conn->xfer, peer_oft_recvcb_init); purple_xfer_set_end_fnc(conn->xfer, peer_oft_recvcb_end); purple_xfer_set_request_denied_fnc(conn->xfer, peer_oft_cb_generic_cancel); purple_xfer_set_cancel_recv_fnc(conn->xfer, peer_oft_cb_generic_cancel); purple_xfer_set_ack_fnc(conn->xfer, peer_oft_recvcb_ack_recv); /* Now perform the request */ purple_xfer_request(conn->xfer); } } }
static void fb_got_notifications_cb(FacebookAccount *fba, gchar *url_text, gsize len, gpointer userdata) { gchar *salvaged; time_t last_fetch_time; time_t time_of_message; time_t newest_message = 0; xmlnode *channel;//VOXOX - CJC - 2009.07.06 xmlnode *rss_root;//VOXOX - CJC - 2009.07.06 xmlnode *item;//VOXOX - CJC - 2009.07.06 xmlnode *link;//VOXOX - CJC - 2009.07.06 xmlnode *title;//VOXOX - CJC - 2009.07.06 gchar *tmp; gchar month_string[4], weekday[4]; guint year, month, day, hour, minute, second; long timezone; gchar *subject, *url; month_string[3] = weekday[3] = '\0'; year = month = day = hour = minute = second = 0; if (!url_text || !len) return; last_fetch_time = purple_account_get_int(fba->account, "facebook_notifications_last_fetch", 0); /* purple_debug_info("facebook", "last fetch time: %zu\n", last_fetch_time); */ salvaged = purple_utf8_salvage(url_text); rss_root = xmlnode_from_str(salvaged, -1); g_free(salvaged); if (rss_root == NULL) { purple_debug_error("facebook", "Could not load RSS file\n"); return; } channel = xmlnode_get_child(rss_root, "channel"); if (channel == NULL) { purple_debug_warning("facebook", "Invalid RSS feed\n"); xmlnode_free(rss_root); return; } item = xmlnode_get_child(channel, "item"); if (item == NULL) { purple_debug_info("facebook", "No new notifications\n"); } for (; item != NULL; item = xmlnode_get_next_twin(item)) { xmlnode *pubDate = xmlnode_get_child(item, "pubDate"); if (!pubDate) continue; tmp = xmlnode_get_data_unescaped(pubDate); /* rss times are in Thu, 19 Jun 2008 15:51:25 -1100 format */ sscanf(tmp, "%3s, %2u %3s %4u %2u:%2u:%2u %5ld", (char*)&weekday, &day, (char*)&month_string, &year, &hour, &minute, &second, &timezone); if (g_str_equal(month_string, "Jan")) month = 0; else if (g_str_equal(month_string, "Feb")) month = 1; else if (g_str_equal(month_string, "Mar")) month = 2; else if (g_str_equal(month_string, "Apr")) month = 3; else if (g_str_equal(month_string, "May")) month = 4; else if (g_str_equal(month_string, "Jun")) month = 5; else if (g_str_equal(month_string, "Jul")) month = 6; else if (g_str_equal(month_string, "Aug")) month = 7; else if (g_str_equal(month_string, "Sep")) month = 8; else if (g_str_equal(month_string, "Oct")) month = 9; else if (g_str_equal(month_string, "Nov")) month = 10; else if (g_str_equal(month_string, "Dec")) month = 11; g_free(tmp); /* try using pidgin's functions */ tmp = g_strdup_printf("%04u%02u%02uT%02u%02u%02u%05ld", year, month, day, hour, minute, second, timezone); time_of_message = purple_str_to_time(tmp, FALSE, NULL, NULL, NULL); g_free(tmp); if (time_of_message <= 0) { /* there's no cross-platform, portable way of converting string to time which doesn't need a new version of glib, so just cheat */ time_of_message = second + 60*minute + 3600*hour + 86400*day + 2592000*month + 31536000*(year-1970); } if (time_of_message > newest_message) { /* we'll keep the newest message to save */ newest_message = time_of_message; } if (time_of_message <= last_fetch_time) { /* fortunatly, rss messages are ordered from newest to oldest */ /* so if this message is older than the last one, ignore rest */ break; } link = xmlnode_get_child(item, "link"); if (link) { url = xmlnode_get_data_unescaped(link); } else { url = g_strdup(""); } title = xmlnode_get_child(item, "title"); if (title) { subject = xmlnode_get_data_unescaped(title); } else { subject = g_strdup(""); } purple_notify_email(fba->pc, subject, NULL, fba->account->username, url, NULL, NULL); g_free(subject); g_free(url); } xmlnode_free(rss_root); if (newest_message > last_fetch_time) { /* update the last fetched time if we had newer messages */ purple_account_set_int(fba->account, "facebook_notifications_last_fetch", newest_message); } }
/*Post the Offline Instant Message to User Conversation*/ static void msn_oim_report_to_user(MsnOimRecvData *rdata, const char *msg_str) { MsnMessage *message; const char *date; const char *from; const char *boundary; char *decode_msg = NULL, *clean_msg = NULL; gsize body_len; char **tokens; char *passport = NULL; time_t stamp; const char *charset = NULL; message = msn_message_new(MSN_MSG_UNKNOWN); msn_message_parse_payload(message, msg_str, strlen(msg_str), MSG_OIM_LINE_DEM, MSG_OIM_BODY_DEM); purple_debug_info("msn", "oim body:{%s}\n", message->body); boundary = msn_message_get_header_value(message, "boundary"); if (boundary != NULL) { char *bounds; char **part; bounds = g_strdup_printf("--%s" MSG_OIM_LINE_DEM, boundary); tokens = g_strsplit(message->body, bounds, 0); /* tokens+1 to skip the "This is a multipart message..." text */ for (part = tokens+1; *part != NULL; part++) { MsnMessage *multipart; const char *type; multipart = msn_message_new(MSN_MSG_UNKNOWN); msn_message_parse_payload(multipart, *part, strlen(*part), MSG_OIM_LINE_DEM, MSG_OIM_BODY_DEM); type = msn_message_get_content_type(multipart); if (type && !strcmp(type, "text/plain")) { decode_msg = (char *)purple_base64_decode(multipart->body, &body_len); charset = msn_message_get_charset(multipart); msn_message_unref(multipart); break; } msn_message_unref(multipart); } g_strfreev(tokens); g_free(bounds); if (decode_msg == NULL) { purple_debug_error("msn", "Couldn't find text/plain OIM message.\n"); msn_message_unref(message); return; } } else { decode_msg = (char *)purple_base64_decode(message->body, &body_len); charset = msn_message_get_charset(message); } if (charset && !((g_ascii_strncasecmp(charset, "UTF-8", 5) == 0) || (g_ascii_strncasecmp(charset, "UTF8", 4) == 0))) { clean_msg = g_convert(decode_msg, body_len, "UTF-8", charset, NULL, NULL, NULL); if (!clean_msg) { char *clean = purple_utf8_salvage(decode_msg); purple_debug_error("msn", "Failed to convert charset from %s to UTF-8 for OIM message: %s\n", charset, clean); clean_msg = g_strdup_printf(_("%s (There was an error receiving this message. " "Converting the encoding from %s to UTF-8 failed.)"), clean, charset); g_free(clean); } g_free(decode_msg); } else if (!g_utf8_validate(decode_msg, body_len, NULL)) { char *clean = purple_utf8_salvage(decode_msg); purple_debug_error("msn", "Received an OIM message that is not UTF-8," " and no encoding specified: %s\n", clean); if (charset) { clean_msg = g_strdup_printf(_("%s (There was an error receiving this message." " The charset was %s, but it was not valid UTF-8.)"), clean, charset); } else { clean_msg = g_strdup_printf(_("%s (There was an error receiving this message." " The charset was missing, but it was not valid UTF-8.)"), clean); } g_free(clean); g_free(decode_msg); } else { clean_msg = decode_msg; } from = msn_message_get_header_value(message, "X-OIM-originatingSource"); /* Match number to user's mobile number, FROM is a phone number if the other side pages you using your phone number */ if (from && !strncmp(from, "tel:+", 5)) { MsnUser *user = msn_userlist_find_user_with_mobile_phone( rdata->oim->session->userlist, from + 4); if (user && user->passport) passport = g_strdup(user->passport); } if (passport == NULL) { char *start, *end; from = msn_message_get_header_value(message, "From"); tokens = g_strsplit(from, " ", 2); if (tokens[1] != NULL) from = (const char *)tokens[1]; start = strchr(from, '<'); if (start != NULL) { start++; end = strchr(from, '>'); if (end != NULL) passport = g_strndup(start, end - start); } if (passport == NULL) passport = g_strdup(_("Unknown")); g_strfreev(tokens); } date = msn_message_get_header_value(message, "Date"); stamp = msn_oim_parse_timestamp(date); purple_debug_info("msn", "oim Date:{%s},passport{%s}\n", date, passport); purple_serv_got_im(purple_account_get_connection(rdata->oim->session->account), passport, clean_msg, 0, stamp); /*Now get the oim message ID from the oim_list. * and append to read list to prepare for deleting the Offline Message when sign out */ msn_oim_post_delete_msg(rdata); g_free(passport); g_free(clean_msg); msn_message_unref(message); }
static void purple_fbapi_request_fetch_cb(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text, gsize len, const gchar *error_message) { PurpleFbApiCall *apicall; xmlnode *response; PurpleConnectionError error = PURPLE_CONNECTION_ERROR_OTHER_ERROR; char *error_message2 = NULL; apicall = user_data; if (error_message != NULL) { /* Request failed */ if (apicall->attempt_number < MAX_CONNECTION_ATTEMPTS) { /* Retry! */ apicall->url_data = purple_util_fetch_url_request(API_URL, TRUE, NULL, FALSE, apicall->request, FALSE, purple_fbapi_request_fetch_cb, apicall); apicall->attempt_number++; return; } response = NULL; error_message2 = g_strdup(error_message); error = PURPLE_CONNECTION_ERROR_NETWORK_ERROR; } else if (url_text != NULL && len > 0) { /* Parse the response as XML */ response = xmlnode_from_str(url_text, len); if (response == NULL) { gchar *salvaged; if (g_utf8_validate(url_text, len, NULL)) { salvaged = g_strdup(url_text); } else { /* Facebook responded with invalid UTF-8. Bastards. */ purple_debug_error("fbapi", "Response is not valid UTF-8\n"); salvaged = purple_utf8_salvage(url_text); } purple_fbapi_xml_salvage(salvaged); response = xmlnode_from_str(salvaged, -1); g_free(salvaged); } if (response == NULL) { purple_debug_error("fbapi", "Could not parse response as XML: %*s\n", (int)len, url_text); error_message2 = g_strdup(_("Invalid response from server")); } else if (g_str_equal(response->name, "error_response")) { /* * The response is an error message, in the standard format * for errors from API calls. */ xmlnode *tmp; char *tmpstr; tmp = xmlnode_get_child(response, "error_code"); if (tmp != NULL) { tmpstr = xmlnode_get_data_unescaped(tmp); if (tmpstr != NULL && strcmp(tmpstr, "293") == 0) { error_message2 = g_strdup(_("Need chat permission")); error = PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED; } g_free(tmpstr); } if (error_message2 == NULL) { error = PURPLE_CONNECTION_ERROR_OTHER_ERROR; tmp = xmlnode_get_child(response, "error_msg"); if (tmp != NULL) error_message2 = xmlnode_get_data_unescaped(tmp); } if (error_message2 == NULL) error_message2 = g_strdup(_("Unknown")); } else { error_message2 = NULL; } } else { /* Response body was empty */ response = NULL; error_message2 = NULL; } if (apicall->attempt_number > 1 || error_message2 != NULL) purple_debug_error("fbapi", "Request '%s' %s after %u attempts: %s\n", apicall->request, error_message == NULL ? "succeeded" : "failed", apicall->attempt_number, error_message2); /* * The request either succeeded or failed the maximum number of * times. In either case, pass control off to the callback * function and let them decide what to do. */ apicall->callback(apicall, apicall->user_data, response, error, error_message2); apicall->url_data = NULL; purple_fbapi_request_destroy(apicall); xmlnode_free(response); g_free(error_message2); }