"-Wdeclaration-after-statement" \

"-Wendif-labels" \

"-Werror-implicit-function-declaration" \

"-Wformat-security" \

"-Werror=format-security" \

"-Winit-self" \

va_list actions)

{

GntWidget *window, *box, *button, *focus = NULL;

window = setup_request_window(title, primary, secondary, PURPLE_REQUEST_ACTION);

g_object_set_data(G_OBJECT(button), "activate-id", GINT_TO_POINTER(i));

g_signal_connect(G_OBJECT(button), "activate", G_CALLBACK(request_action_cb), window);

focus = button;

}

{

return (hascolors ? COLOR_PAIR(pair) :

((pair == GNT_COLOR_NORMAL || pair == GNT_COLOR_HIGHLIGHT_D ||

}

int gnt_color_add_pair(int fg, int bg)

show_suggest_dropdown(GntEntry *entry)

{

char *suggest = NULL;

int offset = 0, x, y;

int count = 0;

GList *iter;

for (str = text; *str; str = next)

{

next = g_utf8_find_next_char(str, NULL);

len = next - str;

if (entry->max && g_utf8_pointer_to_offset(entry->start, entry->end) >= entry->max)

continue;

{

/* This will cause the buffer to grow */

char *tmp = g_strdup(entry->start);

{

g_return_if_fail(entry->history != NULL); /* Need to set_history_length first */

return;

entry->history = g_list_first(entry->history);

g_free(entry->history->data);

menu->selected = g_list_length(menu->list) - 1;

} else if (strcmp(text, GNT_KEY_RIGHT) == 0) {

menu->selected++;

menu->selected = 0;

} else if (strcmp(text, GNT_KEY_ENTER) == 0 ||

strcmp(text, GNT_KEY_DOWN) == 0) {

gsize c;

for (i = 1; i < MAX_WORKSPACES; ++i) {

GntWS *ws;

gchar **titles;

char group[32];

GntTextFormatFlags flags, const char *tagname)

{

GntWidget *widget = GNT_WIDGET(view);

const char *start, *end;

GList *list = view->list;

GntTextLine *line;

if (pos < 0) {

wid = g_list_last(wm->cws->list)->data;

pos = g_list_length(wm->cws->list) - 1;

wid = wm->cws->list->data;

pos = 0;

} else

GList *l;

g_return_if_fail(account != NULL);

index = g_list_index(accounts, account);

{

/* 8k is a bit excessive, will tweak later. */

guchar digest[BUF_LEN * 4];

g_return_val_if_fail(context, FALSE);

g_return_val_if_fail(digest_s, FALSE);

}

static void grow_circ_buffer(PurpleCircBuffer *buf, gsize len) {

g_return_if_fail(buf != NULL);

* pointer, we need to shift the data */

if (in_offset < out_offset

|| (in_offset == out_offset && buf->bufused > 0)) {

/* If we couldn't fit the wrapped read buffer

* at the end */

void purple_circ_buffer_append(PurpleCircBuffer *buf, gconstpointer src, gsize len) {

g_return_if_fail(buf != NULL);

* One copy from inptr to the end of the buffer, and the

* second copy from the start of the buffer to the end of src. */

if (buf->inptr >= buf->outptr)

else

len_stored = len;

buf->outptr += len;

buf->bufused -= len;

/* wrap to the start if we're at the end */

buf->outptr = buf->buffer;

return TRUE;

ssize_t written;

written = write(fd, buf, count);

if (written < 0)

fprintf(stderr, "dns[%d]: Error writing data to "

"parent: %s\n", getpid(), strerror(errno));

purple_dnsquery_resolver_destroy(resolver);

return FALSE;

}

purple_debug_error("dns", "Tried to write %" G_GSSIZE_FORMAT

" bytes to child but only wrote %" G_GSSIZE_FORMAT "\n",

sizeof(dns_params), rc);

res->content = g_new0(gchar, len);

red = read(source, res->content, len);

purple_debug_error("dnssrv","unable to read txt "

"response: %s\n", g_strerror(errno));

size = 0;

{ PURPLE_XFER_STATUS_CANCEL_LOCAL, "cancelled locally" },

{ PURPLE_XFER_STATUS_CANCEL_REMOTE, "cancelled remotely" }

};

for (i = 0; i < G_N_ELEMENTS(type_names); ++i)

if (type_names[i].type == type)

r = -1;

}

/*

* We managed to read the entire buffer. This means our this

* network is fast and our buffer is too small, so make it

else

wc = fwrite(buffer, 1, r, xfer->dest_fp);

purple_debug_error("filetransfer", "Unable to write whole buffer.\n");

purple_xfer_cancel_local(xfer);

g_free(buffer);

that case buffer doesn't belong to us. */

g_free(buffer);

return;

/*

* We managed to write the entire buffer. This means our

* network is fast and our buffer is too small, so make it

we need to do this to allow them to override when using non-standard

TURN modes, like Google f.ex. */

gboolean got_turn_from_prpl = FALSE;

session = get_session(self, sess_id);

GHashTable *users)

{

PurpleConvChat *chat;

struct joinpart_key key;

time_t *last_said;

SV *callback;

SV *data;

PurplePlugin *plugin;

} PurplePerlTimeoutHandler;

SV *callback;

SV *data;

PurplePlugin *plugin;

} PurplePerlPrefsHandler;

static void

notify_emails_cb(char **subjects, char **froms, char **tos, char **urls, guint count) {

for(i=0; i<count && i<5; i++) {

if(subjects[i]==NULL || froms[i]==NULL || tos[i]==NULL || urls[i]==NULL) continue;

i, subjects[i], froms[i], tos[i], urls[i]);

}

}

const gnutls_datum_t *cert_list;

unsigned int cert_list_size = 0;

gnutls_session_t session=gnutls_data->session;

cert_list =

gnutls_certificate_get_peers(session, &cert_list_size);

};

struct tcl_cmd_handler {

Tcl_Obj *cmd;

Tcl_Interp *interp;

PurpleStringref *type;

void *value;

static const char prefix[] = "purple-";

if (strlen(bytes) < prefixlen

|| strncmp(bytes, prefix, prefixlen)

|| (ptr = strchr(bytes, ':')) == NULL

goto badobject;

/* Bad Ethan */

/* Send the end of the stream to the other end of the conversation */

if (bconv->sent_stream_start == FULLY_SENT) {

size_t len = strlen(STREAM_END);

purple_debug_error("bonjour",

"bonjour_jabber_close_conversation: "

"couldn't send data\n");

do {

end = strpbrk(cur, "\002\003\007\017\026\037");

cur = end ? end : cur + strlen(cur);

switch (*cur) {

static const JabberScramHash *mech_to_hash(const char *mech)

{

g_return_val_if_fail(mech != NULL && *mech != '\0', NULL);

tmp);

g_free(tmp);

return;

if (ret < 0)

ret = 0;

if (conn->writeh == 0)

*/

jabber_send_raw(js, buf, len);

}

void jabber_send_signal_cb(PurpleConnection *pc, xmlnode **packet,

const char *

jabber_buddy_state_get_name(const JabberBuddyState state)

{

for (i = 0; i < G_N_ELEMENTS(jabber_statuses); ++i)

if (jabber_statuses[i].state == state)

return _(jabber_statuses[i].readable);

JabberBuddyState

jabber_buddy_status_id_get_state(const char *id)

{

if (!id)

return JABBER_BUDDY_STATE_UNKNOWN;

JabberBuddyState jabber_buddy_show_get_state(const char *id)

{

g_return_val_if_fail(id != NULL, JABBER_BUDDY_STATE_UNKNOWN);

const char *

jabber_buddy_state_get_show(JabberBuddyState state)

{

for (i = 0; i < G_N_ELEMENTS(jabber_statuses); ++i)

if (state == jabber_statuses[i].state)

return jabber_statuses[i].show;

const char *

jabber_buddy_state_get_status_id(JabberBuddyState state)

{

for (i = 0; i < G_N_ELEMENTS(jabber_statuses); ++i)

if (state == jabber_statuses[i].state)

return jabber_statuses[i].status_id;

static void jabber_oob_xfer_request_send(gpointer data, gint source, PurpleInputCondition cond) {

PurpleXfer *xfer = data;

JabberOOBXfer *jox = xfer->data;

len = write(xfer->fd, jox->write_buffer + jox->written_len,

total_len - jox->written_len);

static JabberPresenceType

str_to_presence_type(const char *type)

{

if (type == NULL)

return JABBER_PRESENCE_AVAILABLE;

close(source);

purple_xfer_cancel_remote(xfer);

return;

/* Upper-bound of 257 (jsx->rxlen = 5, jsx->rxqueue[4] = 0xFF) */

unsigned short to_read = jsx->rxqueue[4] + 2 - (jsx->rxlen - 5);

purple_debug_info("jabber", "reading %u bytes for DST.ADDR + port num (trying to read %hu now)\n",

}

/* Have we not read all of DST.ADDR and the following 2-byte port number? */

return;

purple_input_remove(xfer->watcher);

memcpy(jsx->rxqueue + jsx->rxlen, buffer, len);

jsx->rxlen += len;

return;

/* Has a maximum value of 255 (jsx->rxlen = 2, jsx->rxqueue[1] = 0xFF) */

unsigned short to_read = jsx->rxqueue[1] - (jsx->rxlen - 2);

purple_debug_info("jabber", "reading %u bytes for auth methods (trying to read %hu now)\n",

}

/* Have we not read all the auth. method bytes? */

return;

purple_input_remove(xfer->watcher);

if (cmd->params != NULL)

{

for (c = 0; cmd->params[c] && cmd->params[c][0]; c++);

cmd->param_count = c;

char *command;

char **params;

guint ref_count;

dc->progress = TRUE;

dc->msg_pos += bytes_sent;

if (p->sent_cb != NULL)

p->sent_cb(p);

}

/* Wait for the whole packet to arrive */

return;

switch (msn_dc_process_packet(dc, packet_length)) {

}

g_memmove(dc->in_buffer, dc->in_buffer + 4 + packet_length, dc->in_pos - packet_length - 4);

}

msn_history_add(MsnHistory *history, MsnTransaction *trans)

{

GQueue *queue;

g_return_if_fail(history != NULL);

g_return_if_fail(trans != NULL);

if ((s = purple_strcasestr(header, "Content-Length: ")) != NULL)

{

s += strlen("Content-Length: ");

return FALSE;

}

{

if (res < 0)

res = 0;

body = msn_message_get_bin_data(msg, &body_len);

{

memcpy(n, body, body_len);

n += body_len;

msn_nexus_new(MsnSession *session)

{

MsnNexus *nexus;

nexus = g_new0(MsnNexus, 1);

nexus->session = session;

void

msn_nexus_destroy(MsnNexus *nexus)

{

for (i = 0; i < nexus->token_len; i++) {

g_hash_table_destroy(nexus->tokens[i].token);

g_free(nexus->tokens[i].secret);

return FALSE;

id = atol(id_str + 7) - 1; /* 'Compact#' or 'PPToken#' */

return FALSE; /* Where did this come from? */

}

char *password_xml;

GString *domains;

char *request;

MsnSoapMessage *soap;

domains = g_string_new(NULL);

for (i = 0; i < nexus->token_len; i++) {

g_string_append_printf(domains, MSN_SSO_RST_TEMPLATE,

ticket_domains[i][SSO_VALID_TICKET_DOMAIN],

ticket_domains[i][SSO_VALID_TICKET_POLICY] != NULL ?

ticket_domains[i][SSO_VALID_TICKET_POLICY] :

char *cipher;

char *secret;

MsnTicketToken *tokens;

};

void msn_nexus_connect(MsnNexus *nexus);

MsnTransaction *trans;

PurpleAccount *account;

gboolean protocol_supported = FALSE;

size_t i;

session = cmdproc->session;

header->opcode = msn_pop8(wire);

header->message_len = msn_pop16be(wire);

header->base_id = msn_pop32be(wire);

/* Invalid header and data length */

len = 0;

break;

char *data_header_wire = NULL;

if (header->header_tlv != NULL)

else

header->header_len = 0;

if (header->data_tlv != NULL)

else

header->data_header_len = 0;

if (ret < 0 && errno == EAGAIN)

ret = 0;

if (servconn->tx_handler == 0)

servconn->tx_handler = purple_input_add(

servconn->fd, PURPLE_INPUT_WRITE,

if (servconn->payload_len)

{

/* The payload is still not complete. */

break;

{

MsnSlpMessagePart *part;

MsnP2PInfo *info;

size_t len = 0;

guint64 offset;

|| (offset + part->size) > slpmsg->size

|| msn_p2p_info_get_offset(slpmsg->p2p_info) != offset) {

purple_debug_error("msn",

g_return_if_reached();

} else {

memcpy(slpmsg->buffer + offset, part->buffer, part->size);

* This is the size of buffer, unless this is an outgoing file transfer,

* in which case this is the size of the file.

*/

GList *parts; /**< A list with the SlpMsgParts */

{

MsnSlpMessage *slpmsg;

guint64 offset;

slpmsg = data;

}

char *

{

char *buf;

char *tmp;

for (; list; list = g_slist_next(list)) {

msn_tlv_t *tlv = (msn_tlv_t *)list->data;

buf = g_realloc(buf, total_len + 256);

bytes_left += 256;

total_len += 256;

int msn_tlvlist_count(GSList *list);

size_t msn_tlvlist_size(GSList *list);

gboolean msn_tlvlist_equal(GSList *one, GSList *two);

void msn_tlvlist_free(GSList *list);

int msn_tlvlist_add_raw(GSList **list, const guint8 type, const guint8 length, const char *value);

void

msn_transaction_set_payload(MsnTransaction *trans,

{

g_return_if_fail(trans != NULL);

g_return_if_fail(payload != NULL);

void msn_transaction_queue_cmd(MsnTransaction *trans, MsnCommand *cmd);

void msn_transaction_unqueue_cmd(MsnTransaction *trans, MsnCmdProc *cmdproc);

void msn_transaction_set_payload(MsnTransaction *trans,

void msn_transaction_set_data(MsnTransaction *trans, void *data);

void msn_transaction_set_data_free(MsnTransaction *trans, GDestroyNotify fn);

void msn_transaction_set_saveable(MsnTransaction *trans, gboolean saveable);

lid = msim_msg_get_integer(msg, "lid");

/* Unsolicited messages */

return msim_process_server_info(session, msg);

return msim_web_challenge(session, msg);

}

}

purple_debug_info("msim", "msim_send_raw: writing <%s>\n", msg);

len = strlen(msg);

}

static GHashTable *

l = purple_accounts_get_all();

while (l) {

if (purple_account_is_connected(l->data) &&

account = l->data;

break;

}

return FALSE;

}

{

/*

* Some of this info will be available on the buddy list if the

session->show_only_to_list ? 1 : 0,

session->privacy_mode & 1),

NULL);

/* TODO: same as above, but for MySpace info. */

}

g_free(bs->data);

}

{

return bs->len - bs->offset;

}

int byte_stream_advance(ByteStream *bs, int n)

{

g_return_val_if_fail(byte_stream_curpos(bs) + n >= 0, 0);

bs->offset += n;

return n;

{ 0x0020, "ICQ-MDir" },

{ 0x0029, "Facebook" },

};

for (i = 0; i < G_N_ELEMENTS(type_strings); i++) {

if (type_strings[i].type == type) {

return type_strings[i].string;

buf = g_strdup_printf("GET " AIMHASHDATA "?offset=%ld&len=%ld&modname=%s HTTP/1.0\n\n",

pos->offset, pos->len, pos->modname ? pos->modname : "");

result = send(pos->fd, buf, strlen(buf), 0);

g_free(buf);

g_free(pos->modname);

pos->inpa = purple_input_add(pos->fd, PURPLE_INPUT_READ, damn_you, pos);

PurpleConnection *gc = od->gc;

PurpleAccount *account = purple_connection_get_account(gc);

char *host; int port;

FlapConnection *newconn;

va_list ap;

struct aim_authresp_info *info;

int id;

PurpleConnection *gc;

PurpleConversation *conv;

};

/*

int byte_stream_new(ByteStream *bs, size_t len);

int byte_stream_init(ByteStream *bs, guint8 *data, size_t len);

void byte_stream_destroy(ByteStream *bs);

int byte_stream_curpos(ByteStream *bs);

int byte_stream_setpos(ByteStream *bs, size_t off);

void byte_stream_rewind(ByteStream *bs);

*/

int aim_tlvlist_write(ByteStream *bs, GSList **list)

{

GSList *cur;

aim_tlv_t *tlv;

N_("Queue full"),

N_("Not while on AOL")

};

const char *oscar_get_msgerr_reason(size_t reason)

{

char filename[512], filename2[512], *fingerprint = NULL, *tmp;

SilcUInt32 len;

SilcHash hash;

if (!success) {

/* The user did not trust the public key. */

silcpurple_chat_ulimit_cb(SilcPurpleChatInput s, const char *limit)

{

SilcChannelEntry channel;

channel = silc_client_get_channel(s->sg->client, s->sg->conn,

(char *)s->channel);

if (!channel)

return;

if (limit)

if (!limit || !(*limit) || *limit == '0') {

if (limit && ulimit == channel->user_limit) {

SilcPurplePrvgrp prv;

for (l = sg->grps; l; l = l->next)

break;

if (!l)

return;

/* Find channel by id */

silc_hash_table_list(conn->local_entry->channels, &htl);

while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {

found = TRUE;

break;

}

SilcChannelEntry channel;

for (l = sg->grps; l; l = l->next)

break;

if (!l)

return;

/* Find channel by id */

silc_hash_table_list(conn->local_entry->channels, &htl);

while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {

found = TRUE;

break;

}

/* Leave from private groups on this channel as well */

for (l = sg->grps; l; l = l->next)

prv = l->data;

silc_client_del_channel_private_key(client, conn,

chu->channel,

SilcPurplePrvgrp prv;

for (l = sg->grps; l; l = l->next)

break;

if (!l) {

g_free(tmp);

/* Find channel by id */

silc_hash_table_list(conn->local_entry->channels, &htl);

while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {

found = TRUE;

break;

}

SilcPurplePrvgrp prv;

for (l = sg->grps; l; l = l->next)

break;

if (!l)

return;

/* Find channel by id */

silc_hash_table_list(conn->local_entry->channels, &htl);

while (silc_hash_table_get(&htl, NULL, (void *)&chu)) {

found = TRUE;

break;

}

SilcNotifyType notify;

PurpleBuddy *b;

SilcDList list;

va_start(va, type);

memset(buf, 0, sizeof(buf));

if (public_key) {

GSList *buddies;

const char *f;

pk = silc_pkcs_public_key_encode(public_key, &pk_len);

if (!pk)

SilcVerifyPublicKey completion, void *context)

{

PurpleConnection *gc = client->application;

char file[256], filename[256], filename2[256], *ipf, *hostf = NULL;

char *fingerprint, *babbleprint;

struct passwd *pw;

static void yahoo_p2p_write_pkt(gint source, struct yahoo_packet *pkt)

{

size_t pkt_len;

guchar *raw_packet;

/*build the raw packet and send it to the host*/

pkt_len = yahoo_packet_build(pkt, 0, 0, 0, &raw_packet);

purple_debug_warning("yahoo","p2p: couldn't write to the source\n");

g_free(raw_packet);

}

YAHOO_STATUS_WEBLOGIN = 0x5a55aa55,

YAHOO_STATUS_OFFLINE = 0x5a55aa56, /* don't ask */

YAHOO_STATUS_TYPING = 0x16,

};

/*

size_t x_len;

xmlnode *html, *cur;

GString *cdata = g_string_new(NULL);

gboolean no_more_gt_brackets = FALSE;

const char *match;

gchar *xmlstr1, *xmlstr2, *esc;

GSList *tags = NULL;

size_t src_len;

GString *dest;

char *esc;

gboolean no_more_gt_brackets = FALSE;

static guint calculate_length(const gchar *l, size_t len)

{

for (i = 0; i < len; i++) {

if (!g_ascii_isdigit(l[i]))

char key[64];

const guchar *delimiter;

gboolean accept;

struct yahoo_pair *pair;

while (pos + 1 < len)

return ret;

}

if (yd->txhandler == 0)

yd->txhandler = purple_input_add(yd->fd, PURPLE_INPUT_WRITE,

yahoo_packet_send_can_write, yd);

struct yahoo_packet {

guint16 service;

guint32 id;

GSList *hash;

};

return;

}

d->pos += wrote;

purple_debug_misc("yahoo", "Finished uploading buddy icon.\n");

purple_input_remove(d->watcher);

/* Clean out the sent buffer and reuse it to read the result */

while (1) {

YchtPkt *pkt;

int pos = 0;

guint service;

guint version;

gint status;

#include "internal.h"

Code_t ZReadAscii(ptr, len, field, num)

char *ptr;

#define max(a,b) ((a > b) ? (a) : (b))

#endif

return(0); /* var is not the var in

bfr ==> no match */

if (ZCompareUID(uid, &qptr->uid) && qptr->kind == kind)

return (qptr);

next = qptr->next;

Z_RemQueue(qptr);

qptr = next;

}

Code_t Z_FormatRawHeader(notice, buffer, buffer_len, len, cstart, cend)

ZNotice_t *notice;

char *buffer;

int *len;

char **cstart, **cend;

{

Code_t Z_AddNoticeToEntry __P((struct _Z_InputQ*, ZNotice_t*, int));

Code_t Z_FormatAuthHeader __P((ZNotice_t *, char *, int, int *, Z_AuthProc));

Code_t Z_FormatHeader __P((ZNotice_t *, char *, int, int *, Z_AuthProc));

int*, char **, char **));

Code_t Z_ReadEnqueue __P((void));

Code_t Z_ReadWait __P((void));

static char* zephyr_tzc_escape_msg(const char *message)

{

char *newmsg;

if (message && (strlen(message) > 0)) {

char* zephyr_tzc_deescape_str(const char *message)

{

char *newmsg;

if (message && (strlen(message) > 0)) {

purple_proxy_connect_data_disconnect(connect_data, g_strerror(errno));

return;

}

connect_data->written_len += ret;

return;

}

if (p != NULL) {

*p = '\0';

headers_len = (p - (char *)connect_data->read_buffer) + 4;

headers_len = len;

else

return;

}

static gboolean

{

if(connect_data->read_len < len) {

if(connect_data->read_buf_len < len) {

static GList *garray_int_to_glist(GArray *array)

{

GList *list = NULL;

for (i = 0; i < array->len; i++)

list = g_list_append(list, GINT_TO_POINTER(g_array_index(array,gint,i)));

static GSList *garray_int_to_gslist(GArray *array)

{

GSList *list = NULL;

for (i = 0; i < array->len; i++)

list = g_slist_append(list, GINT_TO_POINTER(g_array_index(array,gint,i)));

sc->retry++;

if (sendto(sc->fd, sc->packet, sc->packetsize, 0,

(struct sockaddr *)&(sc->addr), sizeof(struct sockaddr_in)) !=

{

purple_debug_warning("stun", "sendto failed\n");

return FALSE;

struct stun_conn *sc = data;

char buffer[65536];

char *tmp;

struct in_addr in;

struct stun_attrib *attrib;

struct stun_header *hdr;

}

buffer[len] = '\0';

purple_debug_warning("stun", "got invalid response\n");

return;

}

hdr = (struct stun_header*) buffer;

purple_debug_warning("stun", "got incomplete response\n");

return;

}

if(sendto(sc->fd, &hdr_data, sizeof(struct stun_header), 0,

(struct sockaddr *)&(sc->addr),

nattype.status = PURPLE_STUN_STATUS_UNKNOWN;

nattype.lookup_time = time(NULL);

do_callbacks();

const char *path, *start = strstr(baseURL, "://");

start = start ? start + 3 : baseURL;

path = strchr(start, '/');

controlURL = g_strdup_printf("%.*s%s", (int)length, baseURL, tmp);

} else {

controlURL = g_strdup_printf("%s%s", baseURL, tmp);

totalSize = strlen(sendMessage);

do {

sentSuccess = TRUE;

break;

}

gchar *

purple_base16_encode(const guchar *data, gsize len)

{

gchar *ascii = NULL;

g_return_val_if_fail(data != NULL, NULL);

guchar *

purple_base16_decode(const char *str, gsize *ret_len)

{

guchar *data;

g_return_val_if_fail(str != NULL, NULL);

gchar *

purple_base16_encode_chunked(const guchar *data, gsize len)

{

gchar *ascii = NULL;

g_return_val_if_fail(data != NULL, NULL);

* address the link was pointing to. */

else if (href != NULL && g_ascii_strncasecmp(str2 + i, "</a>", 4) == 0)

{

size_t hrlen = strlen(href);

/* Only insert the href if it's different from the CDATA. */

strncmp(str2 + href_st, href, hrlen)) &&

strncmp(str2 + href_st, href + 7, hrlen - 7)))

{

str2[j++] = ' ';

* It causes TOCTOU coverity warning (against g_rename below),

* but it's not a threat for us.

*/

{

purple_debug_error("util", "Error writing data to file %s: "

"Incomplete file written; is your disk "

float size_mag;

int size_index = 0;

return g_strdup(_("Calculating..."));

}

else if (size == 0) {

return;

}

strncpy(proto, uri, len);

proto[len] = '\0';

}

gfud->request_written += len;

return;

/* We're done writing our request, now start reading the response */

buf[j++] = c;

} else {

int bytes = g_unichar_to_utf8(c, utf_char);

if (j > (BUF_LEN - 4))

break;

if (i >= sizeof(utf_char)) {

while ((p = strstr(start, pin)) != NULL) {

prev_char = g_utf8_find_prev_char(hay, p);

if (prev_char) {

before = g_utf8_get_char(prev_char);

}

("!g_unichar_isalnum()" is not a valid way to determine word

boundaries, but it is the only reasonable thing to do here),

and isn't the '&' from a "&amp;" or some such entity*/

ret = TRUE;

break;

}

buf[j++] = c;

} else {

int bytes = g_unichar_to_utf8(c, utf_char);

if (j > (BUF_LEN - 4))

break;

if (i >= sizeof(utf_char)) {

g_return_if_fail(data != NULL);

g_return_if_fail(size != 0);

child = new_node(NULL, XMLNODE_TYPE_DATA);

g_return_val_if_fail(str != NULL, NULL);

xpd = g_new0(struct _xmlnode_parser_data, 1);

if (xmlSAXUserParseMemory(&xmlnode_parser_libxml, xpd, str, real_size) < 0) {

static const char *item_factory_translate_func (const char *path, gpointer func_data);

gboolean pidgin_conv_has_focus(PurpleConversation *conv);

static GdkColor* generate_nick_colors(guint *numcolors, GdkColor background);

static GtkTextTag *get_buddy_tag(PurpleConversation *conv, const char *who, PurpleMessageFlags flag, gboolean create);

static void pidgin_conv_update_fields(PurpleConversation *conv, PidginConvFields fields);

static void focus_out_from_menubar(GtkWidget *wid, PidginWindow *win);

while (purple_utf8_strcasecmp(tmp, *partial)) {

(*partial)[*most_matched] = '\0';

tmp[*most_matched] = '\0';

(*most_matched)--;

}

/* Algorithm from http://www.w3.org/TR/AERT#color-contrast */

static gboolean

{

gulong fg_brightness;

gulong bg_brightness;

gtk_tree_model_get(m, iter, 0, &text, 1, &level, -1);

regex_match(win, text);

g_free(text);

PurpleDebugLevel level;

gtk_tree_model_get(m, iter, 0, &text, 1, &level, -1);

gtk_imhtml_append_text(GTK_IMHTML(win->text), text, 0);

g_free(text);

gtk_tree_model_get(model, iter, 0, &text, 1, &level, -1);

if(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(win->filter))) {

regex_match(win, text);

} else {

item = gtk_check_menu_item_new_with_mnemonic(text[i]);

g_object_set_data(G_OBJECT(item), "user_data", GINT_TO_POINTER(value[i]));

g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(toolbar_icon_pref_changed), toolbar);

gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);

gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

}

{

GtkWidget *table;

GtkWidget *label;

struct

{

GtkIMHtmlClass *klass;

GList *iter;

GtkIMHtmlProtocol *proto = NULL;

klass = g_type_class_ref(GTK_TYPE_IMHTML);

for (iter = klass->protocols; iter; iter = iter->next) {

GList *icons = NULL;

GdkPixbuf *icon = NULL;

char *icon_path;

struct {

const char *dir;

const char *filename;

static struct

{

const char *text;

} const menu_entries[] =

{

select_account_cb(GtkWidget *dropdown, PurpleAccount *account,

PidginPrivacyDialog *dialog)

{

dialog->account = account;

for (i = 0; i < menu_entry_count; i++) {

gtk_combo_box_set_active(GTK_COMBO_BOX(dialog->type_menu), i);

break;

}

static void

type_changed_cb(GtkComboBox *combo, PidginPrivacyDialog *dialog)

{

dialog->account->perm_deny = new_type;

serv_set_permit_deny(purple_account_get_connection(dialog->account));

GtkWidget *button;

GtkWidget *dropdown;

GtkWidget *label;

dialog = g_new0(PidginPrivacyDialog, 1);

gtk_combo_box_append_text(GTK_COMBO_BOX(dialog->type_menu),

_(menu_entries[i].text));

}

gtk_combo_box_set_active(GTK_COMBO_BOX(dialog->type_menu), selected);

else

value = gtk_entry_get_text(GTK_ENTRY(data->u.input.entry));

((PurpleRequestInputCb)data->cbs[id])(data->user_data, value);

else if (data->cbs[1] != NULL)

((PurpleRequestInputCb)data->cbs[1])(data->user_data, value);

{

generic_response_start(data);

((PurpleRequestActionCb)data->cbs[id])(data->user_data, id);

purple_request_close(PURPLE_REQUEST_INPUT, data);

generic_response_start(data);

while (group) {

if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(group->data))) {

((PurpleRequestChoiceCb)data->cbs[id])(data->user_data, GPOINTER_TO_INT(g_object_get_data(G_OBJECT(group->data), "choice_id")));

void **buttons;

char *label_text;

char *primary_esc, *secondary_esc;

data = g_new0(PidginRequestData, 1);

data->type = PURPLE_REQUEST_ACTION;

pidgin_status_box_finalize(GObject *obj)

{

PidginStatusBox *statusbox = PIDGIN_STATUS_BOX(obj);

purple_signals_disconnect_by_handle(statusbox);

purple_prefs_disconnect_by_handle(statusbox);

/* This is a special case because Primitives for the token_status_account are actually

* saved statuses with substatuses for the enabled accounts */

if (status_box->token_status_account && purple_savedstatus_is_transient(saved_status)

{

char *name;

const char *acct_status_name = purple_status_get_name(

cache_pixbufs(PidginStatusBox *status_box)

{

GtkIconSize icon_size;

g_object_set(G_OBJECT(status_box->icon_rend), "xpad", 3, NULL);

icon_size = gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL);

}

while (*i) {

char l[64];

char *next;

while (*i && !isspace(*i) && li < sizeof(l) - 1) {

if (*i == '\\' && *(i+1) != '\0')

i++;

/* coverity[tainted_data] */

next = g_utf8_next_char(i);

break;

}

while (i != next)

{

gboolean sensitivity;

gpointer element;

for (i=0; i < data->len; i++) {

element = g_ptr_array_index(data,i);

pidgin_stock_load_status_icon_theme(PidginStatusIconTheme *theme)

{

GtkIconFactory *icon_factory;

GtkIconSet *normal;

GtkIconSet *translucent = NULL;

GtkWidget *win;

pidgin_stock_load_stock_icon_theme(PidginStockIconTheme *theme)

{

GtkIconFactory *icon_factory;

GtkWidget *win;

if (theme != NULL) {

static GString *

make_gtkrc_string(void)

{

gchar *prefbase = NULL;

GString *style_string = g_string_new("");

{

GtkWidget *vbox = NULL, *hbox = NULL, *check = NULL;

GtkSizeGroup *labelsg = NULL;

vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);

labelsg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);

{

GtkWidget *vbox = NULL, *hbox = NULL, *check = NULL, *widget = NULL;

GtkSizeGroup *labelsg = NULL;

vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);

labelsg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);

* the size group not the whole thing, which isn't what I want. */

GtkWidget *vbox = NULL, *hbox = NULL, *check = NULL, *widget = NULL;

GtkSizeGroup *labelsg = NULL;

vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_CAT_SPACE);

labelsg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);

static void

purplerc_init(PurplePlugin *plugin)

{

purple_prefs_add_none("/plugins");

purple_prefs_add_none("/plugins/gtk");

gchar *ret;

bytes = g_unichar_to_utf8(g_unichar_toupper(g_utf8_get_char(word)), buf);

ret = g_strconcat(buf, g_utf8_offset_to_pointer(lower, 1), NULL);

g_free(lower);

return;

}

{

if (pos == len)

return 0;

GHashTable *hashes;

char bad[82] = "";

char good[256] = "";

gsize size;

gboolean complete = TRUE;

gboolean case_sensitive = FALSE;

!(pspec = gst_property_probe_get_property(probe, "device"))) {

purple_debug_info("vvconfig", "'%s' - no device\n", element_name);

} else {

GValueArray *array;

/* Set autoprobe[-fps] to FALSE to avoid delays when probing. */