* PurpleNotifyType. Also, the if() followed by the

* inner switch doesn't make much sense.

*/

int width = -1, height = -1;

char *plain = (char*)secondary;

msg = gnt_text_view_new();

gnt_text_view_set_flag(GNT_TEXT_VIEW(msg), GNT_TEXT_VIEW_TOP_ALIGN | GNT_TEXT_VIEW_NO_SCROLL);

plain = purple_markup_strip_html(secondary);

if (gnt_util_parse_xhtml_to_textview(secondary, GNT_TEXT_VIEW(msg)))

break;

if ((now & A_COLOR) != (old & A_COLOR) ||

(now & A_REVERSE) != (old & A_REVERSE))

{

short fgp, bgp, r, g, b;

struct

{

int r, g, b;

} fg, bg;

if (fgp == -1)

fgp = COLOR_BLACK;

if (bgp == -1)

fgp = bgp;

bgp = tmp;

}

fg.r = r; fg.b = b; fg.g = g;

bg.r = r; bg.b = b; bg.g = g;

#define ADJUST(x) (x = x * 255 / 1000)

ADJUST(fg.r);

{

static GntWidget *clip;

gchar *text;

if (clip) {

gnt_widget_destroy(clip);

clip = NULL;

return TRUE;

}

text = gnt_get_clipboard_string();

clip = gnt_hwindow_new(FALSE);

GNT_WIDGET_SET_FLAGS(clip, GNT_WIDGET_TRANSIENT);

chat_components_foreach(gpointer key, gpointer value, gpointer user_data)

{

HV *hv = user_data;

}

MODULE = Purple::BuddyList PACKAGE = Purple PREFIX = purple_

Purple::Certificate::Verifier verifier

const gchar* subject_name

AV* cert_chain

SV *cb_data

PREINIT:

GList *l = NULL;

static void markup_find_tag_foreach(GQuark key_id, char *data, HV *hv) {

const char *key = NULL;

key = g_quark_to_string(key_id);

}

MODULE = Purple::Util PACKAGE = Purple::Util PREFIX = purple_

stash = gv_stashpv(stash_name, 1);

hv = newHV();

return sv_bless(newRV_noinc((SV *)hv), stash);

}

typedef struct

{

guint handshake_handler;

guint handshake_timer;

} PurpleSslGnutlsData;

g_list_free(peers);

{

unsigned int cert_list_size = 0;

int i;

cert_list =

gchar tbuf[256];

gsize tsz=sizeof(tbuf);

gchar * tasc = NULL;

gnutls_x509_crt_init(&cert);

gnutls_x509_crt_import (cert, &cert_list[i],

/* Forward declarations are fun! */

static PurpleCertificate *

/* indeed! */

static gboolean

x509_certificate_signed_by(PurpleCertificate * crt,

GList * peer_certs = NULL;

/* List of raw certificates as given by GnuTLS */

unsigned int cert_list_size = 0;

unsigned int i;

/** Refcounted GnuTLS certificate data instance */

typedef struct {

gint refcount;

} x509_crtdata_t;

/** Helper functions for reference counting */

/** Helper macro to retrieve the GnuTLS crt_t from a PurpleCertificate */

#define X509_GET_GNUTLS_DATA(pcrt) ( ((x509_crtdata_t *) (pcrt->data))->crt)

*

* @param dt Datum to transform

* @param mode GnuTLS certificate format specifier (GNUTLS_X509_FMT_PEM for

* @return A newly allocated Certificate structure of the x509_gnutls scheme

*/

static PurpleCertificate *

{

/* Internal certificate data structure */

x509_crtdata_t *certdat;

PurpleCertificate *crt; /* Certificate being constructed */

gchar *buf; /* Used to load the raw file data */

gsize buf_sz; /* Size of the above */

purple_debug_info("gnutls",

"Attempting to load X.509 certificate from %s\n",

gchar *begin, *end;

GSList *crts = NULL;

gsize buf_sz; /* Size of the above */

purple_debug_info("gnutls",

"Attempting to load X.509 certificates from %s\n",

static gboolean

x509_export_certificate(const gchar *filename, PurpleCertificate *crt)

{

int ret;

gchar * out_buf; /* Data to output */

size_t out_size; /* Output size */

x509_certificate_signed_by(PurpleCertificate * crt,

PurpleCertificate * issuer)

{

unsigned int verify; /* used to store result from GnuTLS verifier */

int ret;

gchar *crt_id = NULL;

{

size_t hashlen = 20; /* SHA1 hashes are 20 bytes */

size_t tmpsz = hashlen; /* Throw-away variable for GnuTLS to stomp on*/

GByteArray *hash; /**< Final hash container */

guchar hashbuf[hashlen]; /**< Temporary buffer to contain hash */

static gchar *

x509_cert_dn (PurpleCertificate *crt)

{

gchar *dn = NULL;

size_t dn_size;

static gchar *

x509_issuer_dn (PurpleCertificate *crt)

{

gchar *dn = NULL;

size_t dn_size;

static gchar *

x509_common_name (PurpleCertificate *crt)

{

gchar *cn = NULL;

size_t cn_size;

int ret;

static gboolean

x509_check_name (PurpleCertificate *crt, const gchar *name)

{

g_return_val_if_fail(crt, FALSE);

g_return_val_if_fail(crt->scheme == &x509_gnutls, FALSE);

static gboolean

x509_times (PurpleCertificate *crt, time_t *activation, time_t *expiration)

{

/* GnuTLS time functions return this on error */

const time_t errval = (time_t) (-1);

gboolean success = TRUE;

static GByteArray *

x509_get_der_data(PurpleCertificate *crt)

{

GByteArray *data;

size_t len;

int ret;

xmlnode *body_node, *html_node, *events_node;

PurpleConnection *gc = purple_account_get_connection(purple_buddy_get_account(pb));

gchar *body = NULL;

body_node = xmlnode_get_child(message_node, "body");

html_node = xmlnode_get_child(message_node, "html");

events_node = xmlnode_get_child_with_namespace(message_node, "x", "jabber:x:event");

if (events_node != NULL) {

if (xmlnode_get_child(events_node, "composing") != NULL)

composing_event = TRUE;

if (xmlnode_get_child(events_node, "id") != NULL) {

/* The user is just typing */

/* TODO: Deal with typing notification */

"password", G_TYPE_STRING, password,

"relay-type", G_TYPE_STRING, relay_type,

NULL);

if (turn_setup) {

memset(&value, 0, sizeof(GValue));

g_value_init(&value, GST_TYPE_STRUCTURE);

MsimMessage *body;

guint rid;

/* \persistr\\cmd\258\dsn\9\uid\204084363\lid\14\rid\369\body\UserName=TheAlbinoRhino1.Code=0\final\ */

purple_debug_info("msim","username_is_set made\n");

cmd = msim_msg_get_integer(userinfo, "cmd");

dsn = msim_msg_get_integer(userinfo, "dsn");

lid = msim_msg_get_integer(userinfo, "lid");

body = msim_msg_get_dictionary(userinfo, "body");

errmsg = _("An error occurred while trying to set the username. "

{

FlapConnection *conn;

FlapFrame *frame;

int len;

if (!od || !(conn = flap_connection_getbytype_all(od, SNAC_FAMILY_AUTH)) || !securid)

frame = flap_frame_new(od, 0x02, 10+2+len);

aim_putsnac(&frame->data, SNAC_FAMILY_AUTH, SNAC_SUBTYPE_AUTH_SECURID_RESPONSE, 0);

byte_stream_put16(&frame->data, len);

{

int ret = 0;

aim_rxcallback_t userfunc;

if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))

ret = userfunc(od, conn, frame);

int ret = 0;

aim_rxcallback_t userfunc;

char *bn;

guint8 iconcsumtype, iconcsumlen, *iconcsum, *icon;

bn = byte_stream_getstr(bs, byte_stream_get8(bs));

g_free(bn);

return 1;

}

iconcsumtype = byte_stream_get8(bs);

iconcsumlen = byte_stream_get8(bs);

iconcsum = byte_stream_getraw(bs, iconcsumlen);

* 2 Exchange creation allowed

*

*/

/*

* Type 0x00d6: Character Set (First Time)

*/

static int msgack(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)

{

guchar *cookie;

char *bn;

int ret = 0;

cookie = byte_stream_getraw(bs, 8);

bn = byte_stream_getstr(bs, byte_stream_get8(bs));

purple_debug_info("oscar", "Sent message to %s.\n", bn);

/*

* My instance number.

*/

} else if (type == 0x0019) {

/*

/* This is frivolous. (Thank you SmarterChild.) */

vercount = byte_stream_bytes_left(bs)/4;

versions = byte_stream_getraw(bs, byte_stream_bytes_left(bs));

g_free(versions);

PurpleAccount *account = purple_connection_get_account(gc);

char *buf;

va_list ap;

aim_userinfo_t *userinfo;

va_start(ap, fr);

userinfo = va_arg(ap, aim_userinfo_t *);

nummissed = (guint16)va_arg(ap, unsigned int);

reason = (guint16)va_arg(ap, unsigned int);

PurpleConnection *gc = od->gc;

va_list ap;

char *bn;

guint16 iconcsumlen, iconlen;

va_start(ap, fr);

bn = va_arg(ap, char *);

iconcsum = va_arg(ap, guint8 *);

iconcsumlen = va_arg(ap, int);

icon = va_arg(ap, guint8 *);

gchar *text;

va_list ap;

char *msg, *url;

va_start(ap, fr);

msg = va_arg(ap, char *);

url = va_arg(ap, char *);

va_end(ap);

text = g_strdup_printf("%s<br><a href=\"%s\">%s</a>", msg, url, url);

guint32 tmp;

PurpleStoredImage *img;

va_list ap;

guint16 deny_entry_type = aim_ssi_getdenyentrytype(od);

gc = od->gc;

account = purple_connection_get_account(gc);

va_start(ap, fr);

va_end(ap);

/* Don't attempt to re-request our buddy list later */

static int purple_ssi_authgiven(OscarData *od, FlapConnection *conn, FlapFrame *fr, ...) {

PurpleConnection *gc = od->gc;

va_list ap;

gchar *dialog_msg, *nombre;

struct name_data *data;

PurpleBuddy *buddy;

va_start(ap, fr);

bn = va_arg(ap, char *);

va_end(ap);

purple_debug_info("oscar",

static void mw_session_io_close(struct mwSession *session) {

struct mwPurplePluginData *pd;

pd = mwSession_getClientData(session);

g_return_if_fail(pd != NULL);

if(pd->outpa) {

purple_input_remove(pd->outpa);

pd->outpa = 0;

static void blist_node_menu_cb(PurpleBlistNode *node,

GList **menu, struct mwPurplePluginData *pd) {

const char *owner;

PurpleAccount *acct;

PurpleMenuAction *act;

/* we only want groups */

if(! PURPLE_BLIST_NODE_IS_GROUP(node)) return;

acct = purple_connection_get_account(pd->gc);

g_return_if_fail(acct != NULL);

#if 0

/* if there's anyone in the group for this acct, offer to invite

them all to a conference */

if(purple_group_on_account(group, acct)) {

act = purple_menu_action_new(_("Invite Group to Conference..."),

PURPLE_CALLBACK(blist_menu_group_invite),

static void mw_conf_peer_joined(struct mwConference *conf,

struct mwLoginInfo *peer) {

PurpleConvChat *g_conf;

const char *n = mwConference_getName(conf);

DEBUG_INFO("%s joined conf %s\n", NSTR(peer->user_id), NSTR(n));

g_conf = mwConference_getClientData(conf);

g_return_if_fail(g_conf != NULL);

static void mw_conf_peer_parted(struct mwConference *conf,

struct mwLoginInfo *peer) {

PurpleConvChat *g_conf;

const char *n = mwConference_getName(conf);

DEBUG_INFO("%s left conf %s\n", NSTR(peer->user_id), NSTR(n));

g_conf = mwConference_getClientData(conf);

g_return_if_fail(g_conf != NULL);

static void mw_place_peerJoined(struct mwPlace *place,

const struct mwIdBlock *peer) {

PurpleConversation *gconf;

const char *n = mwPlace_getName(place);

DEBUG_INFO("%s joined place %s\n", NSTR(peer->user), NSTR(n));

gconf = mwPlace_getClientData(place);

g_return_if_fail(gconf != NULL);

static void mw_place_peerParted(struct mwPlace *place,

const struct mwIdBlock *peer) {

PurpleConversation *gconf;

const char *n = mwPlace_getName(place);

DEBUG_INFO("%s left place %s\n", NSTR(peer->user), NSTR(n));

gconf = mwPlace_getClientData(place);

g_return_if_fail(gconf != NULL);

const char *filename;

gsize filesize;

FILE *fp;

struct mwIdBlock idb = { NULL, NULL };

pd = purple_connection_get_protocol_data(gc);

srvc = pd->srvc_ft;

filename = purple_xfer_get_local_filename(xfer);

filesize = purple_xfer_get_size(xfer);

purple_xfer_update_progress(xfer);

filename, g_strerror(errno));

purple_xfer_error(purple_xfer_get_type(xfer), acct, purple_xfer_get_remote_user(xfer), msg);

g_free(msg);

return;

}

fclose(fp);

purple_xfer_set_protocol_data(xfer, ft);

mwFileTransfer_offer(ft);

}

struct yahoo_auth_data *auth_data = user_data;

PurpleConnection *gc = auth_data->gc;

YahooData *yd = purple_connection_get_protocol_data(gc);

purple_debug_info("yahoo","Authentication: In yahoo_auth16_stage2\n");

default:

/* if we have everything we need, why not try to login irrespective of response */

if((crumb != NULL) && (yd->cookie_y != NULL) && (yd->cookie_t != NULL)) {

try_login_on_error = TRUE;

break;

}

error_reason = g_strdup(_("Unknown error"));

static void yahoo_process_auth(PurpleConnection *gc, struct yahoo_packet *pkt)

{

char *seed = NULL;

GSList *l = pkt->hash;

int m = 0;

gchar *buf;

struct yahoo_pair *pair = l->data;

if (pair->key == 94)

seed = pair->value;

if (pair->key == 13)

m = atoi(pair->value);

l = l->next;

PurpleBuddy *b;

GSList *l;

gchar *who = NULL;

gchar buf[BUF_LONG];

gboolean ignore = TRUE;

gint status = 0;

case 0:

who = pair->value;

break;

case 13:

/* 1 == ignore, 2 == unignore */

ignore = (strtol(pair->value, NULL, 10) == 1);

char *message = NULL;

char *command = NULL;

char *imv = NULL;

/* Get all the necessary values from this new packet */

while(l != NULL)

imv = pair->value;

break;

case 64: /* Not sure, but it does vary with initialization of Doodle */

break;

}

void yahoo_process_filetransfer(PurpleConnection *gc, struct yahoo_packet *pkt)

{

char *from = NULL;

char *msg = NULL;

char *url = NULL;

char *imv = NULL;

PurpleXfer *xfer;

YahooData *yd;

struct yahoo_xfer_data *xfer_data;

case 4:

from = pair->value;

break;

break;

case 14:

msg = pair->value;

case 20:

url = pair->value;

break;

break;

case 27:

filename = pair->value;

void yahoo_process_filetrans_15(PurpleConnection *gc, struct yahoo_packet *pkt)

{

char *from = NULL;

char *imv = NULL;

long val_222 = 0L;

PurpleXfer *xfer;

case 4:

from = pair->value;

break;

break;

case 265:

xfer_peer_idstring = pair->value;

void yahoo_process_filetrans_info_15(PurpleConnection *gc, struct yahoo_packet *pkt)

{

char *url = NULL;

long val_249 = 0;

long val_66 = 0;

PurpleXfer *xfer;

YahooData *yd;

struct yahoo_xfer_data *xfer_data;

char *xfer_peer_idstring = NULL;

char *xfer_idstring_for_relay = NULL;

GSList *l;

struct yahoo_pair *pair = l->data;

switch (pair->key) {

break;

break;

case 265:

xfer_peer_idstring = pair->value;

break;

break;

case 66:

val_66 = strtol(pair->value, NULL, 10);

{

YahooData *yd;

GSList *l = pkt->hash;

gboolean got_icon_info = FALSE, send_icon_info = FALSE;

char *url = NULL;

int checksum = 0;

case 4:

who = pair->value;

break;

break;

case 13: {

int tmp;

GList *roomies = NULL;

char *room = NULL;

char *topic = NULL;

if (pkt->status == -1) {

/* We can't join */

g_free(topic);

topic = yahoo_string_decode(gc, pair->value, TRUE);

break;

break;

case 108: /* number of joiners */

break;

break;

break;

break;

case 13: /* this is 1. maybe its the type of room? (normal, user created, private, etc?) */

break;

Z_debug ("ZParseNotice: bad packet from %s/%d (line %d)",

inet_ntoa (notice->z_uid.zuid_addr.s_addr),

notice->z_port, lineno);

#endif

#else

badpkt:

int len;

char *stripped_sender;

int signature_length = strlen(notice.z_message);

PurpleMessageFlags flags = 0;

gchar *tmpescape;

/* Need to deal with 0 length messages to handle typing notification (OPCODE) ping messages */

/* One field zephyrs would have caused purple to crash */

if ( (notice.z_message_len == 0) || (signature_length >= notice.z_message_len - 1)) {

len = 0;

purple_debug_info("zephyr","message_size %d %d %d\n",len,notice.z_message_len,signature_length);

buf3 = g_strdup("");

while (select(zephyr->fromtzc[ZEPHYR_FD_READ] + 1, &rfds, NULL, NULL, &tv)) {

selected = 1;

bufcur++;

if ((bufcur - buf) > (bufsize - 1)) {

if ((buf = realloc(buf, bufsize * 2)) == NULL) {

FD_SET(zephyr->fromtzc[ZEPHYR_FD_READ], &rfds);

while (select_status > 0 &&

select(zephyr->fromtzc[ZEPHYR_FD_READ] + 1, &rfds, NULL, NULL, &tv) > 0) {

bufcur++;

if ((bufcur - buf) > (bufsize - 1)) {

if ((buf = realloc(buf, bufsize * 2)) == NULL) {

major = strtol(p, &p, 10);

error = (major == 0) || (*p != '.');

if(!error) {

p++;

error = (*p != ' ');

if(!error) {

p++;

status = strtol(p, &p, 10);

error = (*p != ' ');

}

}

}

#if !GTK_CHECK_VERSION(3,2,0)

#define GTK_FONT_CHOOSER GTK_FONT_SELECTION_DIALOG

#define gtk_font_chooser_get_font gtk_font_selection_dialog_get_font_name

#define gtk_font_chooser_set_font gtk_font_selection_dialog_set_font_name

#if !GTK_CHECK_VERSION(3,0,0)

#define gdk_x11_window_get_xid GDK_WINDOW_XWINDOW

pidgin_conv_theme_init(GTypeInstance *instance,

gpointer klass)

{

PidginConvThemePrivate *priv;

priv = PIDGIN_CONV_THEME_GET_PRIVATE(instance);

}

static void

static void gtk_imhtml_class_init (GtkIMHtmlClass *klass)

{

GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;

GObjectClass *gobject_class;

gobject_class = (GObjectClass*) klass;

parent_class = g_type_class_ref(GTK_TYPE_TEXT_VIEW);

TRUE, G_PARAM_READABLE));

#if 0

binding_set = gtk_binding_set_by_class (parent_class);

gtk_binding_entry_add_signal (binding_set, GDK_KEY_b, GDK_CONTROL_MASK, "format_function_toggle", 1, G_TYPE_INT, GTK_IMHTML_BOLD);

gtk_binding_entry_add_signal (binding_set, GDK_KEY_i, GDK_CONTROL_MASK, "format_function_toggle", 1, G_TYPE_INT, GTK_IMHTML_ITALIC);

GtkWidget *dd;

GtkWidget *label;

GtkWidget *button;

GtkWidget *menu;

GtkSizeGroup *sg;

gtk_size_group_add_widget(sg, dd);

gtk_misc_set_alignment(GTK_MISC(dd), 0, 0.5);

_("_Minutes before becoming idle:"), "/purple/away/mins_before_away",

1, 24 * 60, sg);

{

PidginRequestData *data;

GtkWidget *filesel;

const gchar *current_folder;

gboolean folder_set = FALSE;

data = g_new0(PidginRequestData, 1);

data->type = PURPLE_REQUEST_FILE;

NULL);

gtk_dialog_set_default_response(GTK_DIALOG(filesel), GTK_RESPONSE_ACCEPT);

if (savedialog) {

current_folder = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/filelocations/last_save_folder");

} else {

current_folder = purple_prefs_get_path(PIDGIN_PREFS_ROOT "/filelocations/last_open_folder");

}

if ((filename == NULL || *filename == '\0' || !g_file_test(filename, G_FILE_TEST_EXISTS)) &&

(current_folder != NULL) && (*current_folder != '\0')) {

folder_set = gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filesel), current_folder);

}

if (!folder_set && (filename == NULL || *filename == '\0' || !g_file_test(filename, G_FILE_TEST_EXISTS))) {

char *my_documents = wpurple_get_special_folder(CSIDL_PERSONAL);