Pidgin and Finch: The Pimpin' Penguin IM Clients That're Good for the Soul

version 2.11.0:

libpurple:

Added:

g_hash_table_insert(ui_info, "client_type", "console");

/*

*/

/*

* This is the client key for "Pidgin." It is owned by the AIM

* don't use this for other applications. You can just not

* specify a distid and libpurple will use a default.

*/

g_hash_table_insert(ui_info, "prpl-icq-distid", GINT_TO_POINTER(1552));

}

*/

#define SIZE 256

struct _node

{

struct _node *next[SIZE];

g_free, NULL);

pointer_icon_cache = g_hash_table_new(g_direct_hash, g_direct_equal);

purple_signal_connect(purple_imgstore_get_handle(), "image-deleting",

purple_buddy_icons_get_handle(),

}

}

void

purple_certificate_verify (PurpleCertificateVerifier *verifier,

const gchar *subject_name, GList *cert_chain,

return fpr;

}

gchar *

purple_certificate_get_unique_id(PurpleCertificate *crt)

{

static void

x509_singleuse_start_verify (PurpleCertificateVerificationRequest *vrq)

{

gchar *cn;

const gchar *cn_match;

PurpleCertificate *crt = (PurpleCertificate *) vrq->cert_chain->data;

/* Get the cert Common Name */

cn = purple_certificate_get_subject_name(crt);

/* Make messages */

primary = g_strdup_printf(_("%s has presented the following certificate for just-this-once use:"), vrq->subject_name);

/* Make a semi-pretty display */

purple_request_accept_cancel(

vrq->cb_data, /* TODO: Find what the handle ought to be */

_("Single-use Certificate Verification"),

primary,

0, /* Accept by default */

NULL, /* No account */

NULL, /* No other user */

g_free(cn);

g_free(primary);

g_free(secondary);

}

static void

return;

}

/* TODO: This is not an elegant way to compare certs */

if (!memcmp(peer_fpr->data, cached_fpr->data, peer_fpr->len)) {

purple_debug_info("certificate/x509/tls_cached",

"Peer cert matched cached\n");

if (ca_crt != NULL) {

GByteArray *failing_fpr;

GByteArray *ca_fpr;

if (byte_arrays_equal(failing_fpr, ca_fpr)) {

purple_debug_info("certificate/x509/tls_cached",

"Full chain verification failed (probably a bad "

* If the fingerprints don't match, we'll fall back to checking the

* signature.

*/

for (cur = ca_crts; cur; cur = cur->next) {

ca_crt = cur->data;

if ( byte_arrays_equal(last_fpr, ca_fpr) ||

purple_certificate_signed_by(end_crt, ca_crt) )

void

purple_certificate_display_x509(PurpleCertificate *crt)

{

gchar *cn, *issuer_id;

time_t activation, expiration;

gchar *activ_str, *expir_str;

gboolean self_signed;

/* Get the cert Common Name */

/* TODO: Will break on CA certs */

"Expiration date: %s\n"),

cn ? cn : "(null)",

self_signed ? _("(self-signed)") : (issuer_id ? issuer_id : "(null)"),

activ_str ? activ_str : "(null)",

expir_str ? expir_str : "(null)");

/* Make a semi-pretty display */

if (self_signed) {

purple_notify_info(NULL, /* TODO: Find what the handle ought to be */

_("Certificate Information"),

"",

} else {

purple_request_action(NULL, /* TODO: Find what the handle ought to be */

_("Certificate Information"), _("Certificate Information"),

issuer_id, 2,

_("View Issuer Certificate"), PURPLE_CALLBACK(display_x509_issuer),

_("Close"), PURPLE_CALLBACK(g_free));

g_free(cn);

g_free(issuer_id);

g_free(secondary);

g_free(activ_str);

g_free(expir_str);

}

void purple_certificate_add_ca_search_path(const char *path)

*/

void (* verify_cert)(PurpleCertificateVerificationRequest *vrq, PurpleCertificateInvalidityFlags *flags);

};

/** A set of operations used to provide logic for verifying a Certificate's

* authenticity.

*

* Retrieves the certificate public key fingerprint using SHA1.

*

* @param crt Certificate instance

* @see purple_base16_encode_chunked()

*/

GByteArray *

/**

* Get a unique identifier for the certificate

PURPLE_MESSAGE_NOTIFY = 0x2000, /**< Message is a notification */

PURPLE_MESSAGE_NO_LINKIFY = 0x4000, /**< Message should not be auto-

linkified @since 2.1.0 */

} PurpleMessageFlags;

/**

*/

#define DBUS_EXPORT

/*

Here we include the list of #PURPLE_DBUS_DECLARE_TYPE statements for

OUTPUT:

RETVAL

void

purple_certificate_verify(verifier, subject_name, cert_chain, cb, cb_data)

Purple::Certificate::Verifier verifier

}

static GByteArray *

{

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

gnutls_x509_crt_t crt_dat;

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

/* Extract the fingerprint */

g_return_val_if_fail(

hashbuf, &tmpsz),

NULL);

return hash;

}

static gchar *

x509_cert_dn (PurpleCertificate *crt)

{

NULL,

NULL,

};

static PurpleSslOps ssl_ops =

}

static GByteArray *

{

CERTCertificate *crt_dat;

SECItem *derCert; /* DER representation of the cert */

SECStatus st;

derCert = &(crt_dat->derCert);

/* Make a hash! */

/* glib leaves the size as 0 by default */

derCert->data, derCert->len);

/* Check for errors */

if (st != SECSuccess) {

purple_debug_error("nss/x509",

"Error: hashing failed!\n");

return NULL;

}

}

static gchar *

x509_importcerts_from_file, /* Multiple certificate import function */

x509_register_trusted_tls_cert, /* Register a certificate as trusted for TLS */

x509_verify_cert, /* Verify that the specified cert chain is trusted */

};

static PurpleSslOps ssl_ops =

if(check_if_blocked(pb))

return;

if (xmlnode_get_child(packet, "si") != NULL || xmlnode_get_child(packet, "error") != NULL)

xep_si_parse(gc, packet, pb);

int id = 0;

PurpleConnection *gc = purple_account_get_connection(irc->account);

const char *mech_list = NULL;

if (strncmp(args[2], "sasl ", 6))

return;

}

irc->sasl_mechs = g_string_new(mech_list);

irc_auth_start_cyrus(irc);

}

static int

rtf_pop_state(NMRtfContext *ctx)

{

GSList *link_old;

save_old = ctx->saved->data;

link_old = ctx->saved;

ctx->saved = g_slist_remove_link(ctx->saved, link_old);

g_slist_free_1(link_old);

}

/*

static int

rtf_apply_property(NMRtfContext *ctx, NMRtfProperty prop, int val)

{

/* Need to flush any temporary data before a property change*/

rtf_flush_data(ctx);

case NMRTF_PROP_FONT_IDX:

ctx->chp.font_idx = val;

break;

break;

default:

return NMRTF_BAD_TABLE;

}

/*

return start_oscar_session_urls[od->icq ? 1 : 0];

}

static const char *get_client_key(OscarData *od)

{

return oscar_get_ui_info_string(

od->icq ? "prpl-icq-clientkey" : "prpl-aim-clientkey",

}

static gchar *generate_error_message(xmlnode *resp, const char *url)

const gchar *encryption_type = purple_account_get_string(account, "encryption", OSCAR_DEFAULT_ENCRYPTION);

/*

*/

query_string = g_strdup_printf("a=%s"

"&distId=%d"

"&ts=%" PURPLE_TIME_T_MODIFIER

"&useTLS=%d",

purple_url_encode(token),

get_client_key(od),

hosttime,

strcmp(encryption_type, OSCAR_NO_ENCRYPTION) != 0 ? 1 : 0);

return url;

}

static const char *get_client_key(OscarData *od)

{

return oscar_get_ui_info_string(

od->icq ? "prpl-icq-clientkey" : "prpl-aim-clientkey",

}

static void

#define AIM_DEFAULT_KDC_SERVER "kdc.uas.aol.com"

#define AIM_DEFAULT_KDC_PORT 443

#define OSCAR_DEFAULT_LOGIN_PORT 5190

#define OSCAR_OPPORTUNISTIC_ENCRYPTION "opportunistic_encryption"

if (!packet_len)

return (ZERR_EOF);

/* Ignore obviously non-Zephyr packets. */

zvlen = sizeof(ZVERSIONHDR) - 1;

PurpleSslErrorFunction error_func,

void *data)

{

}

PurpleSslConnection *

gsc->connect_cb = func;

gsc->error_cb = error_func;

gsc->fd = fd;

/* TODO: Move this elsewhere */

gsc->verifier = purple_certificate_find_verifier("x509","tls_cached");

/**************************************************************************

* Base64 Functions

**************************************************************************/

static const char xdigits[] =

"0123456789abcdef";