Added:

* PURPLE_MESSAGE_REMOTE_SEND in PurpleMessageFlags, to specify

messages like _SEND that were sent from another location.

version 2.11.0:

libpurple:

*/

#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)

{

return (scheme->get_times)(crt, activation, expiration);

}

gchar *

purple_certificate_pool_mkpath(PurpleCertificatePool *pool, const gchar *id)

{

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) )

{

/* TODO: If signed_by ever returns a reason, maybe mention

user's poor, leaky eyes. */

valid = TRUE;

g_byte_array_free(ca_fpr, TRUE);

break;

}

g_byte_array_free(ca_fpr, TRUE);

}

if (valid == FALSE)

flags |= PURPLE_CERTIFICATE_INVALID_CHAIN;

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

gboolean

purple_certificate_get_times(PurpleCertificate *crt, time_t *activation, time_t *expiration);

/*@}*/

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

*/

#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)

{

return success;

}

/* X.509 certificate operations provided by this plugin */

static PurpleCertificateScheme x509_gnutls = {

"x509", /* Scheme name */

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);

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;

}

/*

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";