gaim/gaim

This is a temporary fix for the rate limit problems.
oldstatus
2005-10-15, Mark Doliner
649cffd7a416
This is a temporary fix for the rate limit problems.

Cause: Gaim uses the SNAC 0x0004/0x0015 to fetch the away message
of each user in your buddy list. Previously this SNAC was in a
"rate class" that had an extremely lenient rate limit. Gaim would
fetch a new away message at most every 1.3 seconds. AOL recently
moved this SNAC to be in the same rate class as most of the other
SNACs (send IM, add buddy, connect to chat room, etc.) My temporary
fix is to bump this delay to 10 seconds.

We copied this functionality from iChat, and it looks like they
might actually be having the same problem (but I didn't even take
a packet capture to verify). If this is the case, AOL is really
stupid.

Possibly better fixes:
* Use the rate information to delay packets so that we never hit
a rate limit
* There may be a different SNAC that is now more leniently rate
limited. Possibly 0x0002/0x0005 or 0x0004/0x0006.
/*
* @file util.h Utility Functions
* @ingroup core
*
* Gaim is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "internal.h"
#include "conversation.h"
#include "debug.h"
#include "prpl.h"
#include "prefs.h"
#include "util.h"
typedef struct
{
void (*callback)(void *, const char *, size_t);
void *user_data;
struct
{
char *user;
char *passwd;
char *address;
int port;
char *page;
} website;
char *url;
gboolean full;
char *user_agent;
gboolean http11;
int inpa;
gboolean sentreq;
gboolean newline;
gboolean startsaving;
gboolean has_explicit_data_len;
char *webdata;
unsigned long len;
unsigned long data_len;
} GaimFetchUrlData;
static char custom_home_dir[MAXPATHLEN];
static char home_dir[MAXPATHLEN];
/**************************************************************************
* Base16 Functions
**************************************************************************/
unsigned char *
gaim_base16_encode(const unsigned char *data, int length)
{
int i;
unsigned char *ascii = NULL;
g_return_val_if_fail(data != NULL, NULL);
g_return_val_if_fail(length > 0, NULL);
ascii = g_malloc(length * 2 + 1);
for (i = 0; i < length; i++)
snprintf(&ascii[i * 2], 3, "%02hhx", data[i]);
return ascii;
}
int
gaim_base16_decode(const char *ascii, unsigned char **raw)
{
int len, i, accumulator = 0;
unsigned char *data;
g_return_val_if_fail(ascii != NULL, 0);
len = strlen(ascii);
g_return_val_if_fail(strlen(ascii) > 0, 0);
g_return_val_if_fail(len % 2 > 0, 0);
data = g_malloc(len / 2);
for (i = 0; i < len; i++)
{
if ((i % 2) == 0)
accumulator = 0;
else
accumulator <<= 4;
if (isdigit(ascii[i]))
accumulator |= ascii[i] - 48;
else
{
switch(ascii[i])
{
case 'a': case 'A': accumulator |= 10; break;
case 'b': case 'B': accumulator |= 11; break;
case 'c': case 'C': accumulator |= 12; break;
case 'd': case 'D': accumulator |= 13; break;
case 'e': case 'E': accumulator |= 14; break;
case 'f': case 'F': accumulator |= 15; break;
}
}
if (i % 2)
data[(i - 1) / 2] = accumulator;
}
*raw = data;
return (len / 2);
}
/**************************************************************************
* Base64 Functions
**************************************************************************/
static const char alphabet[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789+/";
static const char xdigits[] =
"0123456789abcdef";
unsigned char *
gaim_base64_encode(const unsigned char *in, size_t inlen)
{
char *out, *rv;
g_return_val_if_fail(in != NULL, NULL);
g_return_val_if_fail(inlen > 0, NULL);
rv = out = g_malloc(((inlen/3)+1)*4 + 1);
for (; inlen >= 3; inlen -= 3)
{
*out++ = alphabet[in[0] >> 2];
*out++ = alphabet[((in[0] << 4) & 0x30) | (in[1] >> 4)];
*out++ = alphabet[((in[1] << 2) & 0x3c) | (in[2] >> 6)];
*out++ = alphabet[in[2] & 0x3f];
in += 3;
}
if (inlen > 0)
{
unsigned char fragment;
*out++ = alphabet[in[0] >> 2];
fragment = (in[0] << 4) & 0x30;
if (inlen > 1)
fragment |= in[1] >> 4;
*out++ = alphabet[fragment];
*out++ = (inlen < 2) ? '=' : alphabet[(in[1] << 2) & 0x3c];
*out++ = '=';
}
*out = '\0';
return rv;
}
void
gaim_base64_decode(const char *text, char **data, int *size)
{
char *out = NULL;
char tmp = 0;
const char *c;
gint32 tmp2 = 0;
int len = 0, n = 0;
g_return_if_fail(text != NULL);
g_return_if_fail(data != NULL);
c = text;
while (*c) {
if (*c >= 'A' && *c <= 'Z') {
tmp = *c - 'A';
} else if (*c >= 'a' && *c <= 'z') {
tmp = 26 + (*c - 'a');
} else if (*c >= '0' && *c <= 57) {
tmp = 52 + (*c - '0');
} else if (*c == '+') {
tmp = 62;
} else if (*c == '/') {
tmp = 63;
} else if (*c == '\r' || *c == '\n') {
c++;
continue;
} else if (*c == '=') {
if (n == 3) {
out = g_realloc(out, len + 2);
out[len] = (char)(tmp2 >> 10) & 0xff;
len++;
out[len] = (char)(tmp2 >> 2) & 0xff;
len++;
} else if (n == 2) {
out = g_realloc(out, len + 1);
out[len] = (char)(tmp2 >> 4) & 0xff;
len++;
}
break;
}
tmp2 = ((tmp2 << 6) | (tmp & 0xff));
n++;
if (n == 4) {
out = g_realloc(out, len + 3);
out[len] = (char)((tmp2 >> 16) & 0xff);
len++;
out[len] = (char)((tmp2 >> 8) & 0xff);
len++;
out[len] = (char)(tmp2 & 0xff);
len++;
tmp2 = 0;
n = 0;
}
c++;
}
out = g_realloc(out, len + 1);
out[len] = 0;
*data = out;
if (size)
*size = len;
}
/**************************************************************************
* Quoted Printable Functions (see RFC 1341)
**************************************************************************/
void
gaim_quotedp_decode(const char *str, char **ret_str, int *ret_len)
{
char *n, *new;
const char *end, *p;
n = new = g_malloc(strlen (str) + 1);
end = str + strlen(str);
for (p = str; p < end; p++, n++) {
if (*p == '=') {
if (p[1] == '\r' && p[2] == '\n') { /* 5.1 #5 */
n -= 1;
p += 2;
} else if (p[1] == '\n') { /* fuzzy case for 5.1 #5 */
n -= 1;
p += 1;
} else if (p[1] && p[2]) {
char *nibble1 = strchr(xdigits, tolower(p[1]));
char *nibble2 = strchr(xdigits, tolower(p[2]));
if (nibble1 && nibble2) { /* 5.1 #1 */
*n = ((nibble1 - xdigits) << 4) | (nibble2 - xdigits);
p += 2;
} else { /* This should never happen */
*n = *p;
}
} else { /* This should never happen */
*n = *p;
}
}
else if (*p == '_')
*n = ' ';
else
*n = *p;
}
*n = '\0';
if (ret_len)
*ret_len = n - new;
/* Resize to take less space */
/* new = realloc(new, n - new); */
*ret_str = new;
}
/**************************************************************************
* MIME Functions
**************************************************************************/
char *
gaim_mime_decode_field(const char *str)
{
/*
* This is wing's version, partially based on revo/shx's version
* See RFC2047 [which apparently obsoletes RFC1342]
*/
typedef enum {
state_start, state_equal1, state_question1,
state_charset, state_question2,
state_encoding, state_question3,
state_encoded_text, state_question4, state_equal2 = state_start
} encoded_word_state_t;
encoded_word_state_t state = state_start;
const char *cur, *mark;
const char *charset0 = NULL, *encoding0 = NULL, *encoded_text0 = NULL;
char *n, *new;
/* token can be any CHAR (supposedly ISO8859-1/ISO2022), not just ASCII */
#define token_char_p(c) \
(c != ' ' && !iscntrl(c) && !strchr("()<>@,;:\"/[]?.=", c))
/* But encoded-text must be ASCII; alas, isascii() may not exist */
#define encoded_text_char_p(c) \
((c & 0x80) == 0 && c != '?' && c != ' ' && isgraph(c))
#define RECOVER_MARKED_TEXT strncpy(n, mark, cur - mark + 1); \
n += cur - mark + 1
g_return_val_if_fail(str != NULL, NULL);
/* NOTE: Assuming that we need just strlen(str)+1 *may* be wrong.
* It would be wrong if one byte (in some unknown encoding) could
* expand to >=4 bytes of UTF-8; I don't know if there are such things.
*/
n = new = g_malloc(strlen(str) + 1);
/* Here we will be looking for encoded words and if they seem to be
* valid then decode them.
* They are of this form: =?charset?encoding?text?=
*/
for (cur = str, mark = NULL; *cur; cur += 1) {
switch (state) {
case state_equal1:
if (*cur == '?') {
state = state_question1;
} else {
RECOVER_MARKED_TEXT;
state = state_start;
}
break;
case state_question1:
if (token_char_p(*cur)) {
charset0 = cur;
state = state_charset;
} else { /* This should never happen */
RECOVER_MARKED_TEXT;
state = state_start;
}
break;
case state_charset:
if (*cur == '?') {
state = state_question2;
} else if (!token_char_p(*cur)) { /* This should never happen */
RECOVER_MARKED_TEXT;
state = state_start;
}
break;
case state_question2:
if (token_char_p(*cur)) {
encoding0 = cur;
state = state_encoding;
} else { /* This should never happen */
RECOVER_MARKED_TEXT;
state = state_start;
}
break;
case state_encoding:
if (*cur == '?') {
state = state_question3;
} else if (!token_char_p(*cur)) { /* This should never happen */
RECOVER_MARKED_TEXT;
state = state_start;
}
break;
case state_question3:
if (encoded_text_char_p(*cur)) {
encoded_text0 = cur;
state = state_encoded_text;
} else if (*cur == '?') { /* empty string */
encoded_text0 = cur;
state = state_question4;
} else { /* This should never happen */
RECOVER_MARKED_TEXT;
state = state_start;
}
break;
case state_encoded_text:
if (*cur == '?') {
state = state_question4;
} else if (!encoded_text_char_p(*cur)) {
RECOVER_MARKED_TEXT;
state = state_start;
}
break;
case state_question4:
if (*cur == '=') { /* Got the whole encoded-word */
char *charset = g_strndup(charset0, encoding0 - charset0 - 1);
char *encoding = g_strndup(encoding0, encoded_text0 - encoding0 - 1);
char *encoded_text = g_strndup(encoded_text0, cur - encoded_text0 - 1);
char *decoded = NULL;
int dec_len;
if (g_ascii_strcasecmp(encoding, "Q") == 0)
gaim_quotedp_decode(encoded_text, &decoded, &dec_len);
else if (g_ascii_strcasecmp(encoding, "B") == 0)
gaim_base64_decode(encoded_text, &decoded, &dec_len);
else
decoded = NULL;
if (decoded) {
gsize len;
char *converted = g_convert(decoded, dec_len, "utf-8", charset, NULL, &len, NULL);
if (converted) {
n = strncpy(n, converted, len) + len;
g_free(converted);
}
g_free(decoded);
}
g_free(charset);
g_free(encoding);
g_free(encoded_text);
state = state_equal2; /* Restart the FSM */
} else { /* This should never happen */
RECOVER_MARKED_TEXT;
state = state_start;
}
break;
default:
if (*cur == '=') {
mark = cur;
state = state_equal1;
} else {
/* Some unencoded text. */
*n = *cur;
n += 1;
}
break;
} /* switch */
} /* for */
if (state != state_start) {
RECOVER_MARKED_TEXT;
}
*n = '\0';
return new;
}
/**************************************************************************
* Date/Time Functions
**************************************************************************/
const char *
gaim_date(void)
{
static char date[80];
time_t tme;
time(&tme);
strftime(date, sizeof(date), "%H:%M:%S", localtime(&tme));
return date;
}
const char *
gaim_date_full(void)
{
char *date;
time_t tme;
time(&tme);
date = ctime(&tme);
date[strlen(date) - 1] = '\0';
return date;
}
time_t
gaim_time_build(int year, int month, int day, int hour, int min, int sec)
{
struct tm tm;
tm.tm_year = year - 1900;
tm.tm_mon = month - 1;
tm.tm_mday = day;
tm.tm_hour = hour;
tm.tm_min = min;
tm.tm_sec = sec >= 0 ? sec : time(NULL) % 60;
return mktime(&tm);
}
time_t
gaim_str_to_time(const char *timestamp, gboolean utc)
{
time_t retval = 0;
struct tm *t;
char buf[32];
char *c;
int tzoff = 0;
time(&retval);
t = localtime(&retval);
snprintf(buf, sizeof(buf), "%s", timestamp);
c = buf;
/* 4 digit year */
if (!sscanf(c, "%04d", &t->tm_year)) return 0;
c += 4;
if (*c == '-')
c++;
t->tm_year -= 1900;
/* 2 digit month */
if (!sscanf(c, "%02d", &t->tm_mon)) return 0;
c += 2;
if (*c == '-')
c++;
t->tm_mon -= 1;
/* 2 digit day */
if (!sscanf(c, "%02d", &t->tm_mday)) return 0;
c += 2;
if (*c == 'T' || *c == '.') { /* we have more than a date, keep going */
c++; /* skip the "T" */
/* 2 digit hour */
if (sscanf(c, "%02d:%02d:%02d", &t->tm_hour, &t->tm_min, &t->tm_sec) == 3 ||
sscanf(c, "%02d%02d%02d", &t->tm_hour, &t->tm_min, &t->tm_sec) == 3) {
int tzhrs, tzmins;
c += 8;
if (*c == '.') /* dealing with precision we don't care about */
c += 4;
if ((*c == '+' || *c == '-') &&
sscanf(c+1, "%02d:%02d", &tzhrs, &tzmins)) {
tzoff = tzhrs*60*60 + tzmins*60;
if (*c == '+')
tzoff *= -1;
}
t->tm_isdst = -1;
if (tzoff || utc) {
#ifdef _WIN32
TIME_ZONE_INFORMATION tzi;
DWORD ret;
if ((ret = GetTimeZoneInformation(&tzi))
!= TIME_ZONE_ID_INVALID) {
tzoff -= tzi.Bias * 60;
if (ret == TIME_ZONE_ID_DAYLIGHT) {
tzoff -= tzi.DaylightBias * 60;
}
}
#else
#ifdef HAVE_TM_GMTOFF
tzoff += t->tm_gmtoff;
#else
# ifdef HAVE_TIMEZONE
tzset(); /* making sure */
tzoff -= timezone;
t->tm_isdst = 0; /* I think this might fix it */
# endif
#endif
#endif /* _WIN32 */
}
}
}
retval = mktime(t);
retval += tzoff;
return retval;
}
/**************************************************************************
* Markup Functions
**************************************************************************/
gboolean
gaim_markup_find_tag(const char *needle, const char *haystack,
const char **start, const char **end, GData **attributes)
{
GData *attribs;
const char *cur = haystack;
char *name = NULL;
gboolean found = FALSE;
gboolean in_tag = FALSE;
gboolean in_attr = FALSE;
const char *in_quotes = NULL;
size_t needlelen;
g_return_val_if_fail( needle != NULL, FALSE);
g_return_val_if_fail( *needle != '\0', FALSE);
g_return_val_if_fail( haystack != NULL, FALSE);
g_return_val_if_fail( *haystack != '\0', FALSE);
g_return_val_if_fail( start != NULL, FALSE);
g_return_val_if_fail( end != NULL, FALSE);
g_return_val_if_fail(attributes != NULL, FALSE);
needlelen = strlen(needle);
g_datalist_init(&attribs);
while (*cur && !found) {
if (in_tag) {
if (in_quotes) {
const char *close = cur;
while (*close && *close != *in_quotes)
close++;
/* if we got the close quote, store the value and carry on from *
* after it. if we ran to the end of the string, point to the NULL *
* and we're outta here */
if (*close) {
/* only store a value if we have an attribute name */
if (name) {
size_t len = close - cur;
char *val = g_strndup(cur, len);
g_datalist_set_data_full(&attribs, name, val, g_free);
g_free(name);
name = NULL;
}
in_quotes = NULL;
cur = close + 1;
} else {
cur = close;
}
} else if (in_attr) {
const char *close = cur;
while (*close && *close != '>' && *close != '"' &&
*close != '\'' && *close != ' ' && *close != '=')
close++;
/* if we got the equals, store the name of the attribute. if we got
* the quote, save the attribute and go straight to quote mode.
* otherwise the tag closed or we reached the end of the string,
* so we can get outta here */
switch (*close) {
case '"':
case '\'':
in_quotes = close;
case '=':
{
size_t len = close - cur;
/* don't store a blank attribute name */
if (len) {
if (name)
g_free(name);
name = g_ascii_strdown(cur, len);
}
in_attr = FALSE;
cur = close + 1;
break;
}
case ' ':
case '>':
in_attr = FALSE;
default:
cur = close;
break;
}
} else {
switch (*cur) {
case ' ':
/* swallow extra spaces inside tag */
while (*cur && *cur == ' ') cur++;
in_attr = TRUE;
break;
case '>':
found = TRUE;
*end = cur;
break;
case '"':
case '\'':
in_quotes = cur;
default:
cur++;
break;
}
}
} else {
/* if we hit a < followed by the name of our tag... */
if (*cur == '<' && !g_ascii_strncasecmp(cur + 1, needle, needlelen)) {
*start = cur;
cur = cur + needlelen + 1;
/* if we're pointing at a space or a >, we found the right tag. if *
* we're not, we've found a longer tag, so we need to skip to the *
* >, but not being distracted by >s inside quotes. */
if (*cur == ' ' || *cur == '>') {
in_tag = TRUE;
} else {
while (*cur && *cur != '"' && *cur != '\'' && *cur != '>') {
if (*cur == '"') {
cur++;
while (*cur && *cur != '"')
cur++;
} else if (*cur == '\'') {
cur++;
while (*cur && *cur != '\'')
cur++;
} else {
cur++;
}
}
}
} else {
cur++;
}
}
}
/* clean up any attribute name from a premature termination */
if (name)
g_free(name);
if (found) {
*attributes = attribs;
} else {
*start = NULL;
*end = NULL;
*attributes = NULL;
}
return found;
}
gboolean
gaim_markup_extract_info_field(const char *str, int len, GString *dest,
const char *start_token, int skip,
const char *end_token, char check_value,
const char *no_value_token,
const char *display_name, gboolean is_link,
const char *link_prefix)
{
const char *p, *q;
g_return_val_if_fail(str != NULL, FALSE);
g_return_val_if_fail(dest != NULL, FALSE);
g_return_val_if_fail(start_token != NULL, FALSE);
g_return_val_if_fail(end_token != NULL, FALSE);
g_return_val_if_fail(display_name != NULL, FALSE);
p = strstr(str, start_token);
if (p == NULL)
return FALSE;
p += strlen(start_token) + skip;
if (p >= str + len)
return FALSE;
if (check_value != '\0' && *p == check_value)
return FALSE;
q = strstr(p, end_token);
/* Trim leading blanks */
while (*p != '\n' && g_ascii_isspace(*p)) {
p += 1;
}
/* Trim trailing blanks */
while (q > p && g_ascii_isspace(*(q - 1))) {
q -= 1;
}
/* Don't bother with null strings */
if (p == q)
return FALSE;
if (q != NULL && (!no_value_token ||
(no_value_token && strncmp(p, no_value_token,
strlen(no_value_token)))))
{
g_string_append_printf(dest, _("<b>%s:</b> "), display_name);
if (is_link)
{
g_string_append(dest, "<br><a href=\"");
if (link_prefix)
g_string_append(dest, link_prefix);
g_string_append_len(dest, p, q - p);
g_string_append(dest, "\">");
if (link_prefix)
g_string_append(dest, link_prefix);
g_string_append_len(dest, p, q - p);
g_string_append(dest, "</a>");
}
else
{
g_string_append_len(dest, p, q - p);
}
g_string_append(dest, "<br>\n");
return TRUE;
}
return FALSE;
}
struct gaim_parse_tag {
char *src_tag;
char *dest_tag;
gboolean ignore;
};
#define ALLOW_TAG_ALT(x, y) if(!g_ascii_strncasecmp(c, "<" x " ", strlen("<" x " "))) { \
const char *o = c + strlen("<" x); \
const char *p = NULL, *q = NULL, *r = NULL; \
GString *innards = g_string_new(""); \
while(o && *o) { \
if(!q && (*o == '\"' || *o == '\'') ) { \
q = o; \
} else if(q) { \
if(*o == *q) { \
char *unescaped = g_strndup(q+1, o-q-1); \
char *escaped = g_markup_escape_text(unescaped, -1); \
g_string_append_printf(innards, "%c%s%c", *q, escaped, *q); \
g_free(unescaped); \
g_free(escaped); \
q = NULL; \
} else if(*c == '\\') { \
o++; \
} \
} else if(*o == '<') { \
r = o; \
} else if(*o == '>') { \
p = o; \
break; \
} else { \
innards = g_string_append_c(innards, *o); \
} \
o++; \
} \
if(p && !r) { \
if(*(p-1) != '/') { \
struct gaim_parse_tag *pt = g_new0(struct gaim_parse_tag, 1); \
pt->src_tag = x; \
pt->dest_tag = y; \
tags = g_list_prepend(tags, pt); \
} \
xhtml = g_string_append(xhtml, "<" y); \
c += strlen("<" x ); \
xhtml = g_string_append(xhtml, innards->str); \
xhtml = g_string_append_c(xhtml, '>'); \
c = p + 1; \
} else { \
xhtml = g_string_append(xhtml, "&lt;"); \
plain = g_string_append_c(plain, '<'); \
c++; \
} \
g_string_free(innards, TRUE); \
continue; \
} \
if(!g_ascii_strncasecmp(c, "<" x, strlen("<" x)) && \
(*(c+strlen("<" x)) == '>' || \
!g_ascii_strncasecmp(c+strlen("<" x), "/>", 2))) { \
xhtml = g_string_append(xhtml, "<" y); \
c += strlen("<" x); \
if(*c != '/') { \
struct gaim_parse_tag *pt = g_new0(struct gaim_parse_tag, 1); \
pt->src_tag = x; \
pt->dest_tag = y; \
tags = g_list_prepend(tags, pt); \
xhtml = g_string_append_c(xhtml, '>'); \
} else { \
xhtml = g_string_append(xhtml, "/>");\
} \
c = strchr(c, '>') + 1; \
continue; \
}
#define ALLOW_TAG(x) ALLOW_TAG_ALT(x, x)
void
gaim_markup_html_to_xhtml(const char *html, char **xhtml_out,
char **plain_out)
{
GString *xhtml = g_string_new("");
GString *plain = g_string_new("");
GList *tags = NULL, *tag;
const char *c = html;
while(c && *c) {
if(*c == '<') {
if(*(c+1) == '/') { /* closing tag */
tag = tags;
while(tag) {
struct gaim_parse_tag *pt = tag->data;
if(!g_ascii_strncasecmp((c+2), pt->src_tag, strlen(pt->src_tag)) && *(c+strlen(pt->src_tag)+2) == '>') {
c += strlen(pt->src_tag) + 3;
break;
}
tag = tag->next;
}
if(tag) {
while(tags) {
struct gaim_parse_tag *pt = tags->data;
g_string_append_printf(xhtml, "</%s>", pt->dest_tag);
if(tags == tag)
break;
tags = g_list_remove(tags, pt);
g_free(pt);
}
g_free(tag->data);
tags = g_list_remove(tags, tag->data);
} else {
/* a closing tag we weren't expecting...
* we'll let it slide, if it's really a tag...if it's
* just a </ we'll escape it properly */
const char *end = c+2;
while(*end && g_ascii_isalpha(*end))
end++;
if(*end == '>') {
c = end+1;
} else {
xhtml = g_string_append(xhtml, "&lt;");
plain = g_string_append_c(plain, '<');
c++;
}
}
} else { /* opening tag */
ALLOW_TAG("a");
ALLOW_TAG_ALT("b", "strong");
ALLOW_TAG("blockquote");
ALLOW_TAG_ALT("bold", "strong");
ALLOW_TAG("cite");
ALLOW_TAG("div");
ALLOW_TAG("em");
ALLOW_TAG("h1");
ALLOW_TAG("h2");
ALLOW_TAG("h3");
ALLOW_TAG("h4");
ALLOW_TAG("h5");
ALLOW_TAG("h6");
/* we only allow html to start the message */
if(c == html)
ALLOW_TAG("html");
ALLOW_TAG_ALT("i", "em");
ALLOW_TAG_ALT("italic", "em");
ALLOW_TAG("li");
ALLOW_TAG("ol");
ALLOW_TAG("p");
ALLOW_TAG("pre");
ALLOW_TAG("q");
ALLOW_TAG("span");
ALLOW_TAG("strong");
ALLOW_TAG("ul");
/* we skip <HR> because it's not legal in XHTML-IM. However,
* we still want to send something sensible, so we put a
* linebreak in its place. <BR> also needs special handling
* because putting a </BR> to close it would just be dumb. */
if((!g_ascii_strncasecmp(c, "<br", 3)
|| !g_ascii_strncasecmp(c, "<hr", 3))
&& (*(c+3) == '>' ||
!g_ascii_strncasecmp(c+3, "/>", 2) ||
!g_ascii_strncasecmp(c+3, " />", 3))) {
c = strchr(c, '>') + 1;
xhtml = g_string_append(xhtml, "<br/>");
if(*c != '\n')
plain = g_string_append_c(plain, '\n');
continue;
}
if(!g_ascii_strncasecmp(c, "<u>", 3) || !g_ascii_strncasecmp(c, "<underline>", strlen("<underline>"))) {
struct gaim_parse_tag *pt = g_new0(struct gaim_parse_tag, 1);
pt->src_tag = *(c+2) == '>' ? "u" : "underline";
pt->dest_tag = "span";
tags = g_list_prepend(tags, pt);
c = strchr(c, '>') + 1;
xhtml = g_string_append(xhtml, "<span style='text-decoration: underline;'>");
continue;
}
if(!g_ascii_strncasecmp(c, "<s>", 3) || !g_ascii_strncasecmp(c, "<strike>", strlen("<strike>"))) {
struct gaim_parse_tag *pt = g_new0(struct gaim_parse_tag, 1);
pt->src_tag = *(c+2) == '>' ? "s" : "strike";
pt->dest_tag = "span";
tags = g_list_prepend(tags, pt);
c = strchr(c, '>') + 1;
xhtml = g_string_append(xhtml, "<span style='text-decoration: line-through;'>");
continue;
}
if(!g_ascii_strncasecmp(c, "<sub>", 5)) {
struct gaim_parse_tag *pt = g_new0(struct gaim_parse_tag, 1);
pt->src_tag = "sub";
pt->dest_tag = "span";
tags = g_list_prepend(tags, pt);
c = strchr(c, '>') + 1;
xhtml = g_string_append(xhtml, "<span style='vertical-align:sub;'>");
continue;
}
if(!g_ascii_strncasecmp(c, "<sup>", 5)) {
struct gaim_parse_tag *pt = g_new0(struct gaim_parse_tag, 1);
pt->src_tag = "sup";
pt->dest_tag = "span";
tags = g_list_prepend(tags, pt);
c = strchr(c, '>') + 1;
xhtml = g_string_append(xhtml, "<span style='vertical-align:super;'>");
continue;
}
if(!g_ascii_strncasecmp(c, "<font", 5) && (*(c+5) == '>' || *(c+5) == ' ')) {
const char *p = c;
GString *style = g_string_new("");
struct gaim_parse_tag *pt;
while(*p && *p != '>') {
if(!g_ascii_strncasecmp(p, "back=", strlen("back="))) {
const char *q = p + strlen("back=");
GString *color = g_string_new("");
if(*q == '\'' || *q == '\"')
q++;
while(*q && *q != '\"' && *q != '\'' && *q != ' ') {
color = g_string_append_c(color, *q);
q++;
}
g_string_append_printf(style, "background: %s; ", color->str);
g_string_free(color, TRUE);
p = q;
} else if(!g_ascii_strncasecmp(p, "color=", strlen("color="))) {
const char *q = p + strlen("color=");
GString *color = g_string_new("");
if(*q == '\'' || *q == '\"')
q++;
while(*q && *q != '\"' && *q != '\'' && *q != ' ') {
color = g_string_append_c(color, *q);
q++;
}
g_string_append_printf(style, "color: %s; ", color->str);
g_string_free(color, TRUE);
p = q;
} else if(!g_ascii_strncasecmp(p, "face=", strlen("face="))) {
const char *q = p + strlen("face=");
gboolean space_allowed = FALSE;
GString *face = g_string_new("");
if(*q == '\'' || *q == '\"') {
space_allowed = TRUE;
q++;
}
while(*q && *q != '\"' && *q != '\'' && (space_allowed || *q != ' ')) {
face = g_string_append_c(face, *q);
q++;
}
g_string_append_printf(style, "font-family: %s; ", face->str);
g_string_free(face, TRUE);
p = q;
} else if(!g_ascii_strncasecmp(p, "size=", strlen("size="))) {
const char *q = p + strlen("size=");
int sz;
const char *size = "medium";
if(*q == '\'' || *q == '\"')
q++;
sz = atoi(q);
switch (sz)
{
case 1:
size = "xx-small";
break;
case 2:
size = "x-small";
break;
case 3:
size = "small";
break;
case 4:
size = "medium";
break;
case 5:
size = "large";
break;
case 6:
size = "x-large";
break;
case 7:
size = "xx-large";
break;
default:
break;
}
g_string_append_printf(style, "font-size: %s; ", size);
p = q;
}
p++;
}
if ((c = strchr(c, '>')) != NULL)
c++;
else
c = p;
pt = g_new0(struct gaim_parse_tag, 1);
pt->src_tag = "font";
pt->dest_tag = "span";
tags = g_list_prepend(tags, pt);
if(style->len)
g_string_append_printf(xhtml, "<span style='%s'>", style->str);
else
pt->ignore = TRUE;
g_string_free(style, TRUE);
continue;
}
if(!g_ascii_strncasecmp(c, "<body ", 6)) {
const char *p = c;
gboolean did_something = FALSE;
while(*p && *p != '>') {
if(!g_ascii_strncasecmp(p, "bgcolor=", strlen("bgcolor="))) {
const char *q = p + strlen("bgcolor=");
struct gaim_parse_tag *pt = g_new0(struct gaim_parse_tag, 1);
GString *color = g_string_new("");
if(*q == '\'' || *q == '\"')
q++;
while(*q && *q != '\"' && *q != '\'' && *q != ' ') {
color = g_string_append_c(color, *q);
q++;
}
g_string_append_printf(xhtml, "<span style='background: %s;'>", color->str);
g_string_free(color, TRUE);
if ((c = strchr(c, '>')) != NULL)
c++;
else
c = p;
pt->src_tag = "body";
pt->dest_tag = "span";
tags = g_list_prepend(tags, pt);
did_something = TRUE;
break;
}
p++;
}
if(did_something) continue;
}
/* this has to come after the special case for bgcolor */
ALLOW_TAG("body");
if(!g_ascii_strncasecmp(c, "<!--", strlen("<!--"))) {
char *p = strstr(c + strlen("<!--"), "-->");
if(p) {
xhtml = g_string_append(xhtml, "<!--");
c += strlen("<!--");
continue;
}
}
xhtml = g_string_append(xhtml, "&lt;");
plain = g_string_append_c(plain, '<');
c++;
}
} else if(*c == '&') {
char buf[7];
char *pln;
int len = 1;
guint pound;
if(!g_ascii_strncasecmp(c, "&amp;", 5)) {
pln = "&";
len = 5;
} else if(!g_ascii_strncasecmp(c, "&lt;", 4)) {
pln = "<";
len = 4;
} else if(!g_ascii_strncasecmp(c, "&gt;", 4)) {
pln = ">";
len = 4;
} else if(!g_ascii_strncasecmp(c, "&nbsp;", 6)) {
pln = " ";
len = 6;
} else if(!g_ascii_strncasecmp(c, "&copy;", 6)) {
pln = "©";
len = 6;
} else if(!g_ascii_strncasecmp(c, "&quot;", 6)) {
pln = "\"";
len = 6;
} else if(!g_ascii_strncasecmp(c, "&reg;", 5)) {
pln = "®";
len = 5;
} else if(!g_ascii_strncasecmp(c, "&apos;", 6)) {
pln = "\'";
len = 6;
} else if(*(c+1) == '#' && (sscanf(c, "&#%u;", &pound) == 1) &&
pound != 0 && *(c+3+(gint)log10(pound)) == ';') {
int buflen = g_unichar_to_utf8((gunichar)pound, buf);
buf[buflen] = '\0';
pln = buf;
len = 2;
while(isdigit((gint) c [len])) len++;
if(c [len] == ';') len++;
} else {
len = 1;
g_snprintf(buf, sizeof(buf), "%c", *c);
pln = buf;
}
xhtml = g_string_append_len(xhtml, c, len);
plain = g_string_append(plain, pln);
c += len;
} else {
xhtml = g_string_append_c(xhtml, *c);
plain = g_string_append_c(plain, *c);
c++;
}
}
tag = tags;
while(tag) {
struct gaim_parse_tag *pt = tag->data;
if(!pt->ignore)
g_string_append_printf(xhtml, "</%s>", pt->dest_tag);
tag = tag->next;
}
g_list_free(tags);
if(xhtml_out)
*xhtml_out = g_strdup(xhtml->str);
if(plain_out)
*plain_out = g_strdup(plain->str);
g_string_free(xhtml, TRUE);
g_string_free(plain, TRUE);
}
/* The following are probably reasonable changes:
* - \n should be converted to a normal space
* - in addition to <br>, <p> and <div> etc. should also be converted into \n
* - We want to turn </td>#whitespace<td> sequences into a single tab
* - We want to turn <td> into a single tab (for msn profile "parsing")
* - We want to turn </tr>#whitespace<tr> sequences into a single \n
* - <script>...</script> and <style>...</style> should be completely removed
*/
char *
gaim_markup_strip_html(const char *str)
{
int i, j, k;
gboolean visible = TRUE;
gboolean closing_td_p = FALSE;
gchar *str2;
const gchar *cdata_close_tag = NULL;
if(!str)
return NULL;
str2 = g_strdup(str);
for (i = 0, j = 0; str2[i]; i++)
{
if (str2[i] == '<')
{
if (cdata_close_tag)
{
/* Note: Don't even assume any other tag is a tag in CDATA */
if (strncasecmp(str2 + i, cdata_close_tag,
strlen(cdata_close_tag)) == 0)
{
i += strlen(cdata_close_tag) - 1;
cdata_close_tag = NULL;
}
continue;
}
else if (strncasecmp(str2 + i, "<td", 3) == 0 && closing_td_p)
{
str2[j++] = '\t';
visible = TRUE;
}
else if (strncasecmp(str2 + i, "</td>", 5) == 0)
{
closing_td_p = TRUE;
visible = FALSE;
}
else
{
closing_td_p = FALSE;
visible = TRUE;
}
k = i + 1;
if(g_ascii_isspace(str2[k]))
visible = TRUE;
else if (str2[k])
{
/* Scan until we end the tag either implicitly (closed start
* tag) or explicitly, using a sloppy method (i.e., < or >
* inside quoted attributes will screw us up)
*/
while (str2[k] && str2[k] != '<' && str2[k] != '>')
{
k++;
}
/* Check for tags which should be mapped to newline */
if (strncasecmp(str2 + i, "<p>", 3) == 0
|| strncasecmp(str2 + i, "<tr", 3) == 0
|| strncasecmp(str2 + i, "<br", 3) == 0
|| strncasecmp(str2 + i, "<li", 3) == 0
|| strncasecmp(str2 + i, "<div", 4) == 0
|| strncasecmp(str2 + i, "</table>", 8) == 0)
{
str2[j++] = '\n';
}
/* Check for tags which begin CDATA and need to be closed */
#if 0 /* FIXME.. option is end tag optional, we can't handle this right now */
else if (strncasecmp(str2 + i, "<option", 7) == 0)
{
/* FIXME: We should not do this if the OPTION is SELECT'd */
cdata_close_tag = "</option>";
}
#endif
else if (strncasecmp(str2 + i, "<script", 7) == 0)
{
cdata_close_tag = "</script>";
}
else if (strncasecmp(str2 + i, "<style", 6) == 0)
{
cdata_close_tag = "</style>";
}
/* Update the index and continue checking after the tag */
i = (str2[k] == '<' || str2[k] == '\0')? k - 1: k;
continue;
}
}
else if (cdata_close_tag)
{
continue;
}
else if (!g_ascii_isspace(str2[i]))
{
visible = TRUE;
}
/* XXX: This sucks. We need to be un-escaping all entities, which
* includes these, as well as the &#num; ones */
if (str2[i] == '&' && strncasecmp(str2 + i, "&quot;", 6) == 0)
{
str2[j++] = '\"';
i = i + 5;
continue;
}
if (str2[i] == '&' && strncasecmp(str2 + i, "&amp;", 5) == 0)
{
str2[j++] = '&';
i = i + 4;
continue;
}
if (str2[i] == '&' && strncasecmp(str2 + i, "&lt;", 4) == 0)
{
str2[j++] = '<';
i = i + 3;
continue;
}
if (str2[i] == '&' && strncasecmp(str2 + i, "&gt;", 4) == 0)
{
str2[j++] = '>';
i = i + 3;
continue;
}
if (str2[i] == '&' && strncasecmp(str2 + i, "&apos;", 6) == 0)
{
str2[j++] = '\'';
i = i + 5;
continue;
}
if (visible)
str2[j++] = g_ascii_isspace(str2[i])? ' ': str2[i];
}
str2[j] = '\0';
return str2;
}
static gboolean
badchar(char c)
{
switch (c) {
case ' ':
case ',':
case '\0':
case '\n':
case '<':
case '>':
case '"':
case '\'':
return TRUE;
default:
return FALSE;
}
}
static gboolean
badentity(const char *c)
{
if (!g_ascii_strncasecmp(c, "&lt;", 4) ||
!g_ascii_strncasecmp(c, "&gt;", 4) ||
!g_ascii_strncasecmp(c, "&quot;", 6)) {
return TRUE;
}
return FALSE;
}
char *
gaim_markup_linkify(const char *text)
{
const char *c, *t, *q = NULL;
char *tmp, *tmpurlbuf, *url_buf;
gunichar g;
gboolean inside_html = FALSE;
int inside_paren = 0;
GString *ret = g_string_new("");
/* Assumes you have a buffer able to carry at least BUF_LEN * 2 bytes */
c = text;
while (*c) {
if(*c == '(' && !inside_html) {
inside_paren++;
ret = g_string_append_c(ret, *c);
c++;
}
if(inside_html) {
if(*c == '>') {
inside_html = FALSE;
} else if(!q && (*c == '\"' || *c == '\'')) {
q = c;
} else if(q) {
if(*c == *q)
q = NULL;
}
} else if(*c == '<') {
inside_html = TRUE;
if (!g_ascii_strncasecmp(c, "<A", 2)) {
while (1) {
if (!g_ascii_strncasecmp(c, "/A>", 3)) {
inside_html = FALSE;
break;
}
ret = g_string_append_c(ret, *c);
c++;
if (!(*c))
break;
}
}
} else if ((*c=='h') && (!g_ascii_strncasecmp(c, "http://", 7) ||
(!g_ascii_strncasecmp(c, "https://", 8)))) {
t = c;
while (1) {
if (badchar(*t) || badentity(t)) {
if (*(t) == ',' && (*(t + 1) != ' ')) {
t++;
continue;
}
if (*(t - 1) == '.')
t--;
if ((*(t - 1) == ')' && (inside_paren > 0))) {
t--;
}
url_buf = g_strndup(c, t - c);
tmpurlbuf = gaim_unescape_html(url_buf);
g_string_append_printf(ret, "<A HREF=\"%s\">%s</A>",
tmpurlbuf, url_buf);
g_free(url_buf);
g_free(tmpurlbuf);
c = t;
break;
}
if (!t)
break;
t++;
}
} else if (!g_ascii_strncasecmp(c, "www.", 4)) {
if (c[4] != '.') {
t = c;
while (1) {
if (badchar(*t) || badentity(t)) {
if (t - c == 4) {
break;
}
if (*(t) == ',' && (*(t + 1) != ' ')) {
t++;
continue;
}
if (*(t - 1) == '.')
t--;
if ((*(t - 1) == ')' && (inside_paren > 0))) {
t--;
}
url_buf = g_strndup(c, t - c);
tmpurlbuf = gaim_unescape_html(url_buf);
g_string_append_printf(ret,
"<A HREF=\"http://%s\">%s</A>", tmpurlbuf,
url_buf);
g_free(url_buf);
g_free(tmpurlbuf);
c = t;
break;
}
if (!t)
break;
t++;
}
}
} else if (!g_ascii_strncasecmp(c, "ftp://", 6)) {
t = c;
while (1) {
if (badchar(*t) || badentity(t)) {
if (*(t - 1) == '.')
t--;
if ((*(t - 1) == ')' && (inside_paren > 0))) {
t--;
}
url_buf = g_strndup(c, t - c);
tmpurlbuf = gaim_unescape_html(url_buf);
g_string_append_printf(ret, "<A HREF=\"%s\">%s</A>",
tmpurlbuf, url_buf);
g_free(url_buf);
g_free(tmpurlbuf);
c = t;
break;
}
if (!t)
break;
t++;
}
} else if (!g_ascii_strncasecmp(c, "ftp.", 4)) {
if (c[4] != '.') {
t = c;
while (1) {
if (badchar(*t) || badentity(t)) {
if (t - c == 4) {
break;
}
if (*(t - 1) == '.')
t--;
if ((*(t - 1) == ')' && (inside_paren > 0))) {
t--;
}
url_buf = g_strndup(c, t - c);
tmpurlbuf = gaim_unescape_html(url_buf);
g_string_append_printf(ret,
"<A HREF=\"ftp://%s\">%s</A>", tmpurlbuf,
url_buf);
g_free(url_buf);
g_free(tmpurlbuf);
c = t;
break;
}
if (!t)
break;
t++;
}
}
} else if (!g_ascii_strncasecmp(c, "mailto:", 7)) {
t = c;
while (1) {
if (badchar(*t) || badentity(t)) {
if (*(t - 1) == '.')
t--;
url_buf = g_strndup(c, t - c);
tmpurlbuf = gaim_unescape_html(url_buf);
g_string_append_printf(ret, "<A HREF=\"%s\">%s</A>",
tmpurlbuf, url_buf);
g_free(url_buf);
g_free(tmpurlbuf);
c = t;
break;
}
if (!t)
break;
t++;
}
} else if (c != text && (*c == '@')) {
int flag;
GString *gurl_buf = NULL;
const char illegal_chars[] = "!@#$%^&*()[]{}/|\\<>\":;\r\n \0";
if (strchr(illegal_chars,*(c - 1)) || strchr(illegal_chars, *(c + 1)))
flag = 0;
else {
flag = 1;
gurl_buf = g_string_new("");
}
t = c;
while (flag) {
/* iterate backwards grabbing the local part of an email address */
g = g_utf8_get_char(t);
if (badchar(*t) || (g >= 127) || (*t == '(') ||
((*t == ';') && ((t > (text+2) && (!g_ascii_strncasecmp(t - 3, "&lt;", 4) ||
!g_ascii_strncasecmp(t - 3, "&gt;", 4))) ||
(t > (text+4) && (!g_ascii_strncasecmp(t - 5, "&quot;", 6)))))) {
/* local part will already be part of ret, strip it out */
ret = g_string_truncate(ret, ret->len - (c - t));
ret = g_string_append_unichar(ret, g);
break;
} else {
g_string_prepend_unichar(gurl_buf, g);
t = g_utf8_find_prev_char(text, t);
if (t < text) {
ret = g_string_assign(ret, "");
break;
}
}
}
t = g_utf8_find_next_char(c, NULL);
while (flag) {
/* iterate forwards grabbing the domain part of an email address */
g = g_utf8_get_char(t);
if (badchar(*t) || (g >= 127) || (*t == ')') || badentity(t)) {
char *d;
url_buf = g_string_free(gurl_buf, FALSE);
/* strip off trailing periods */
if (strlen(url_buf) > 0) {
for (d = url_buf + strlen(url_buf) - 1; *d == '.'; d--, t--)
*d = '\0';
}
tmpurlbuf = gaim_unescape_html(url_buf);
if (gaim_email_is_valid(tmpurlbuf)) {
g_string_append_printf(ret, "<A HREF=\"mailto:%s\">%s</A>",
tmpurlbuf, url_buf);
} else {
g_string_append(ret, url_buf);
}
g_free(url_buf);
g_free(tmpurlbuf);
c = t;
break;
} else {
g_string_append_unichar(gurl_buf, g);
t = g_utf8_find_next_char(t, NULL);
}
}
}
if(*c == ')' && !inside_html) {
inside_paren--;
ret = g_string_append_c(ret, *c);
c++;
}
if (*c == 0)
break;
ret = g_string_append_c(ret, *c);
c++;
}
tmp = ret->str;
g_string_free(ret, FALSE);
return tmp;
}
char *
gaim_escape_html(const char *html) {
const char *c = html;
GString *ret;
if (html == NULL)
return NULL;
ret = g_string_new("");
while (*c) {
switch (*c) {
case '&':
ret = g_string_append(ret, "&amp;");
break;
case '<':
ret = g_string_append(ret, "&lt;");
break;
case '>':
ret = g_string_append(ret, "&gt;");
break;
case '"':
ret = g_string_append(ret, "&quot;");
break;
default:
ret = g_string_append_c(ret, *c);
}
c++;
}
return g_string_free(ret, FALSE);
}
char *
gaim_unescape_html(const char *html) {
char *unescaped = NULL;
if (html != NULL) {
const char *c = html;
GString *ret = g_string_new("");
while (*c) {
if (!strncmp(c, "&amp;", 5)) {
ret = g_string_append_c(ret, '&');
c += 5;
} else if (!strncmp(c, "&lt;", 4)) {
ret = g_string_append_c(ret, '<');
c += 4;
} else if (!strncmp(c, "&gt;", 4)) {
ret = g_string_append_c(ret, '>');
c += 4;
} else if (!strncmp(c, "&quot;", 6)) {
ret = g_string_append_c(ret, '"');
c += 6;
} else if (!strncmp(c, "&apos;", 6)) {
ret = g_string_append_c(ret, '\'');
c += 6;
} else if (!strncmp(c, "<br>", 4)) {
ret = g_string_append_c(ret, '\n');
c += 4;
} else {
ret = g_string_append_c(ret, *c);
c++;
}
}
unescaped = ret->str;
g_string_free(ret, FALSE);
}
return unescaped;
}
char *
gaim_markup_slice(const char *str, guint x, guint y)
{
GString *ret;
GQueue *q;
guint z = 0;
gboolean appended = FALSE;
gunichar c;
char *tag;
g_return_val_if_fail(x <= y, NULL);
if (x == y)
return g_strdup("");
ret = g_string_new("");
q = g_queue_new();
while (*str && (z < y)) {
c = g_utf8_get_char(str);
if (c == '<') {
char *end = strchr(str, '>');
if (!end) {
g_string_free(ret, TRUE);
while ((tag = g_queue_pop_head(q)))
g_free(tag);
g_queue_free(q);
return NULL;
}
if (!g_ascii_strncasecmp(str, "<img ", 5)) {
z += strlen("[Image]");
} else if (!g_ascii_strncasecmp(str, "<br", 3)) {
z += 1;
} else if (!g_ascii_strncasecmp(str, "<hr>", 4)) {
z += strlen("\n---\n");
} else if (!g_ascii_strncasecmp(str, "</", 2)) {
/* pop stack */
char *tmp;
tmp = g_queue_pop_head(q);
if (tmp)
g_free(tmp);
/* z += 0; */
} else {
/* push it unto the stack */
char *tmp;
tmp = g_strndup(str, end - str + 1);
g_queue_push_head(q, tmp);
/* z += 0; */
}
if (z == x && !appended) {
GList *l = q->tail;
while (l) {
tag = l->data;
g_string_append(ret, tag);
l = l->prev;
}
appended = TRUE;
} else if (z >= x) {
g_string_append_len(ret, str, end - str + 1);
}
str = end;
} else if (c == '&') {
char *end = strchr(str, ';');
if (!end) {
g_string_free(ret, TRUE);
while ((tag = g_queue_pop_head(q)))
g_free(tag);
g_queue_free(q);
return NULL;
}
if (z >= x)
g_string_append_len(ret, str, end - str + 1);
z++;
str = end;
} else {
if (z >= x)
g_string_append_unichar(ret, c);
z++;
}
str = g_utf8_next_char(str);
}
while ((tag = g_queue_pop_head(q))) {
char *name;
name = gaim_markup_get_tag_name(tag);
g_string_append_printf(ret, "</%s>", name);
g_free(name);
g_free(tag);
}
g_queue_free(q);
return g_string_free(ret, FALSE);
}
char *
gaim_markup_get_tag_name(const char *tag)
{
int i;
g_return_val_if_fail(tag != NULL, NULL);
g_return_val_if_fail(*tag == '<', NULL);
for (i = 1; tag[i]; i++)
if (tag[i] == '>' || tag[i] == ' ' || tag[i] == '/')
break;
return g_strndup(tag, i);
}
/**************************************************************************
* Path/Filename Functions
**************************************************************************/
const char *
gaim_home_dir(void)
{
#ifndef _WIN32
if(g_get_home_dir())
return g_get_home_dir();
else
return NULL;
#else
return wgaim_data_dir();
#endif
}
/* returns a string of the form ~/.gaim, where ~ is replaced by the user's home
* dir. Note that there is no trailing slash after .gaim. */
char *
gaim_user_dir(void)
{
if (custom_home_dir != NULL && strlen(custom_home_dir) > 0) {
strcpy ((char*) &home_dir, (char*) &custom_home_dir);
} else {
const gchar *hd = gaim_home_dir();
if (hd) {
g_strlcpy((char*) &home_dir, hd, sizeof(home_dir));
g_strlcat((char*) &home_dir, G_DIR_SEPARATOR_S ".gaim",
sizeof(home_dir));
}
}
return home_dir;
}
void set_gaim_user_dir(const char *dir)
{
if (dir != NULL && strlen(dir) > 0) {
g_strlcpy((char*) &custom_home_dir, dir,
sizeof(custom_home_dir));
}
}
int gaim_build_dir (const char *path, int mode)
{
char *dir, **components, delim[] = { G_DIR_SEPARATOR, '\0' };
int cur, len;
g_return_val_if_fail(path != NULL, -1);
dir = g_new0(char, strlen(path) + 1);
components = g_strsplit(path, delim, -1);
len = 0;
for (cur = 0; components[cur] != NULL; cur++) {
/* If you don't know what you're doing on both
* win32 and *NIX, stay the hell away from this code */
if(cur > 1)
dir[len++] = G_DIR_SEPARATOR;
strcpy(dir + len, components[cur]);
len += strlen(components[cur]);
if(cur == 0)
dir[len++] = G_DIR_SEPARATOR;
if(g_file_test(dir, G_FILE_TEST_IS_DIR)) {
continue;
#ifdef _WIN32
/* allow us to create subdirs on UNC paths
* (\\machinename\path\to\blah)
* g_file_test() doesn't work on "\\machinename" */
} else if (cur == 2 && dir[0] == '\\' && dir[1] == '\\'
&& components[cur + 1] != NULL) {
continue;
#endif
} else if(g_file_test(dir, G_FILE_TEST_EXISTS)) {
gaim_debug_warning("build_dir", "bad path: %s\n", path);
g_strfreev(components);
g_free(dir);
return -1;
}
if (g_mkdir(dir, mode) < 0) {
gaim_debug_warning("build_dir", "mkdir: %s\n", strerror(errno));
g_strfreev(components);
g_free(dir);
return -1;
}
}
g_strfreev(components);
g_free(dir);
return 0;
}
/*
* Like mkstemp() but returns a file pointer, uses a pre-set template,
* uses the semantics of tempnam() for the directory to use and allocates
* the space for the filepath.
*
* Caller is responsible for closing the file and removing it when done,
* as well as freeing the space pointed-to by "path" with g_free().
*
* Returns NULL on failure and cleans up after itself if so.
*/
static const char *gaim_mkstemp_templ = {"gaimXXXXXX"};
FILE *
gaim_mkstemp(char **fpath)
{
const gchar *tmpdir;
#ifndef _WIN32
int fd;
#endif
FILE *fp = NULL;
g_return_val_if_fail(fpath != NULL, NULL);
if((tmpdir = (gchar*)g_get_tmp_dir()) != NULL) {
if((*fpath = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", tmpdir, gaim_mkstemp_templ)) != NULL) {
#ifdef _WIN32
char* result = _mktemp( *fpath );
if( result == NULL )
gaim_debug(GAIM_DEBUG_ERROR, "gaim_mkstemp",
"Problem creating the template\n");
else
{
if( (fp = g_fopen( result, "w+" )) == NULL ) {
gaim_debug(GAIM_DEBUG_ERROR, "gaim_mkstemp",
"Couldn't fopen() %s\n", result);
}
}
#else
if((fd = mkstemp(*fpath)) == -1) {
gaim_debug(GAIM_DEBUG_ERROR, "gaim_mkstemp",
"Couldn't make \"%s\", error: %d\n",
*fpath, errno);
} else {
if((fp = fdopen(fd, "r+")) == NULL) {
close(fd);
gaim_debug(GAIM_DEBUG_ERROR, "gaim_mkstemp",
"Couldn't fdopen(), error: %d\n", errno);
}
}
#endif
if(!fp) {
g_free(*fpath);
*fpath = NULL;
}
}
} else {
gaim_debug(GAIM_DEBUG_ERROR, "gaim_mkstemp",
"g_get_tmp_dir() failed!");
}
return fp;
}
gboolean
gaim_program_is_valid(const char *program)
{
GError *error = NULL;
char **argv;
gchar *progname;
gboolean is_valid = FALSE;
g_return_val_if_fail(program != NULL, FALSE);
g_return_val_if_fail(*program != '\0', FALSE);
if (!g_shell_parse_argv(program, NULL, &argv, &error)) {
gaim_debug(GAIM_DEBUG_ERROR, "program_is_valid",
"Could not parse program '%s': %s\n",
program, error->message);
g_error_free(error);
return FALSE;
}
if (argv == NULL) {
return FALSE;
}
progname = g_find_program_in_path(argv[0]);
is_valid = (progname != NULL);
g_strfreev(argv);
g_free(progname);
return is_valid;
}
char *
gaim_fd_get_ip(int fd)
{
struct sockaddr addr;
socklen_t namelen = sizeof(addr);
g_return_val_if_fail(fd != 0, NULL);
if (getsockname(fd, &addr, &namelen))
return NULL;
return g_strdup(inet_ntoa(((struct sockaddr_in *)&addr)->sin_addr));
}
/**************************************************************************
* String Functions
**************************************************************************/
const char *
gaim_normalize(const GaimAccount *account, const char *str)
{
GaimPlugin *prpl = NULL;
GaimPluginProtocolInfo *prpl_info = NULL;
const char *ret = NULL;
if(account)
prpl = gaim_find_prpl(gaim_account_get_protocol_id(account));
if(prpl)
prpl_info = GAIM_PLUGIN_PROTOCOL_INFO(prpl);
if(prpl_info && prpl_info->normalize)
ret = prpl_info->normalize(account, str);
if(!ret)
{
static char buf[BUF_LEN];
char *tmp;
tmp = g_utf8_normalize(str, -1, G_NORMALIZE_DEFAULT);
g_snprintf(buf, sizeof(buf), "%s", tmp);
g_free(tmp);
ret = buf;
}
return ret;
}
/*
* You probably don't want to call this directly, it is
* mainly for use as a PRPL callback function. See the
* comments in util.h.
*/
const char *
gaim_normalize_nocase(const GaimAccount *account, const char *str)
{
static char buf[BUF_LEN];
char *tmp1, *tmp2;
g_return_val_if_fail(str != NULL, NULL);
tmp1 = g_utf8_strdown(str, -1);
tmp2 = g_utf8_normalize(tmp1, -1, G_NORMALIZE_DEFAULT);
g_snprintf(buf, sizeof(buf), "%s", tmp2);
g_free(tmp2);
g_free(tmp1);
return buf;
}
gchar *
gaim_str_sub_away_formatters(const char *str, const char *name)
{
char *c;
GString *cpy;
time_t t;
struct tm *tme;
char tmp[20];
g_return_val_if_fail(str != NULL, NULL);
g_return_val_if_fail(name != NULL, NULL);
/* Create an empty GString that is hopefully big enough for most messages */
cpy = g_string_sized_new(1024);
t = time(NULL);
tme = localtime(&t);
c = (char *)str;
while (*c) {
switch (*c) {
case '%':
if (*(c + 1)) {
switch (*(c + 1)) {
case 'n':
/* append name */
g_string_append(cpy, name);
c++;
break;
case 'd':
/* append date */
strftime(tmp, 20, "%m/%d/%Y", tme);
g_string_append(cpy, tmp);
c++;
break;
case 't':
/* append time */
strftime(tmp, 20, "%I:%M:%S %p", tme);
g_string_append(cpy, tmp);
c++;
break;
default:
g_string_append_c(cpy, *c);
}
} else {
g_string_append_c(cpy, *c);
}
break;
default:
g_string_append_c(cpy, *c);
}
c++;
}
return g_string_free(cpy, FALSE);
}
gchar *
gaim_strdup_withhtml(const gchar *src)
{
gulong destsize, i, j;
gchar *dest;
g_return_val_if_fail(src != NULL, NULL);
/* New length is (length of src) + (number of \n's * 3) + 1 */
for (i = 0, j = 0; src[i] != '\0'; i++)
if (src[i] == '\n')
j++;
destsize = i + (j * 3) + 1;
dest = g_malloc(destsize);
/* Copy stuff, ignoring \r's, because they are dumb */
for (i = 0, j = 0; src[i] != '\0'; i++) {
if (src[i] == '\n') {
strcpy(&dest[j], "<BR>");
j += 4;
} else if (src[i] != '\r')
dest[j++] = src[i];
}
dest[destsize-1] = '\0';
return dest;
}
gboolean
gaim_str_has_prefix(const char *s, const char *p)
{
if (!strncmp(s, p, strlen(p)))
return TRUE;
return FALSE;
}
gboolean
gaim_str_has_suffix(const char *s, const char *x)
{
int off = strlen(s) - strlen(x);
if (off >= 0 && !strcmp(s + off, x))
return TRUE;
return FALSE;
}
char *
gaim_str_add_cr(const char *text)
{
char *ret = NULL;
int count = 0, j;
guint i;
g_return_val_if_fail(text != NULL, NULL);
if (text[0] == '\n')
count++;
for (i = 1; i < strlen(text); i++)
if (text[i] == '\n' && text[i - 1] != '\r')
count++;
if (count == 0)
return g_strdup(text);
ret = g_malloc0(strlen(text) + count + 1);
i = 0; j = 0;
if (text[i] == '\n')
ret[j++] = '\r';
ret[j++] = text[i++];
for (; i < strlen(text); i++) {
if (text[i] == '\n' && text[i - 1] != '\r')
ret[j++] = '\r';
ret[j++] = text[i];
}
gaim_debug_misc("gaim_str_add_cr", "got: %s, leaving with %s\n",
text, ret);
return ret;
}
void
gaim_str_strip_cr(char *text)
{
int i, j;
char *text2;
g_return_if_fail(text != NULL);
text2 = g_malloc(strlen(text) + 1);
for (i = 0, j = 0; text[i]; i++)
if (text[i] != '\r')
text2[j++] = text[i];
text2[j] = '\0';
strcpy(text, text2);
g_free(text2);
}
gchar *
gaim_strreplace(const char *string, const char *delimiter,
const char *replacement)
{
gchar **split;
gchar *ret;
g_return_val_if_fail(string != NULL, NULL);
g_return_val_if_fail(delimiter != NULL, NULL);
g_return_val_if_fail(replacement != NULL, NULL);
split = g_strsplit(string, delimiter, 0);
ret = g_strjoinv(replacement, split);
g_strfreev(split);
return ret;
}
gchar *
gaim_strcasereplace(const char *string, const char *delimiter,
const char *replacement)
{
gchar *ret;
int length_del, length_rep, i, j;
g_return_val_if_fail(string != NULL, NULL);
g_return_val_if_fail(delimiter != NULL, NULL);
g_return_val_if_fail(replacement != NULL, NULL);
length_del = strlen(delimiter);
length_rep = strlen(replacement);
/* Count how many times the delimiter appears */
i = 0; /* position in the source string */
j = 0; /* number of occurrences of "delimiter" */
while (string[i] != '\0') {
if (!strncasecmp(&string[i], delimiter, length_del)) {
i += length_del;
j += length_rep;
} else {
i++;
j++;
}
}
ret = g_malloc(j+1);
i = 0; /* position in the source string */
j = 0; /* position in the destination string */
while (string[i] != '\0') {
if (!strncasecmp(&string[i], delimiter, length_del)) {
strncpy(&ret[j], replacement, length_rep);
i += length_del;
j += length_rep;
} else {
ret[j] = string[i];
i++;
j++;
}
}
ret[j] = '\0';
return ret;
}
const char *
gaim_strcasestr(const char *haystack, const char *needle)
{
size_t hlen, nlen;
const char *tmp, *ret;
g_return_val_if_fail(haystack != NULL, NULL);
g_return_val_if_fail(needle != NULL, NULL);
hlen = strlen(haystack);
nlen = strlen(needle);
tmp = haystack,
ret = NULL;
g_return_val_if_fail(hlen > 0, NULL);
g_return_val_if_fail(nlen > 0, NULL);
while (*tmp && !ret) {
if (!g_ascii_strncasecmp(needle, tmp, nlen))
ret = tmp;
else
tmp++;
}
return ret;
}
char *
gaim_str_size_to_units(size_t size)
{
static const char *size_str[4] = { "bytes", "KB", "MB", "GB" };
float size_mag;
int size_index = 0;
if (size == -1) {
return g_strdup(_("Calculating..."));
}
else if (size == 0) {
return g_strdup(_("Unknown."));
}
else {
size_mag = (float)size;
while ((size_index < 3) && (size_mag > 1024)) {
size_mag /= 1024;
size_index++;
}
if (size_index == 0) {
return g_strdup_printf("%zd %s", size, size_str[size_index]);
} else {
return g_strdup_printf("%.2f %s", size_mag, size_str[size_index]);
}
}
}
char *
gaim_str_seconds_to_string(guint secs)
{
GString *gstr;
const char *prefix = "";
guint days, hrs, mins;
gstr = g_string_new("");
if (secs < 60)
{
g_string_append_printf(gstr, "%d %s", secs,
ngettext("second", "seconds", secs));
return g_string_free(gstr, FALSE);
}
days = secs / (60 * 60 * 24);
secs = secs % (60 * 60 * 24);
hrs = secs / (60 * 60);
secs = secs % (60 * 60);
mins = secs / 60;
secs = secs % 60;
if (days > 0)
{
g_string_append_printf(gstr, "%d %s", days,
ngettext("day", "days", days));
prefix = ", ";
}
if (hrs > 0)
{
g_string_append_printf(gstr, "%s%d %s", prefix, hrs,
ngettext("hour", "hours", hrs));
prefix = ", ";
}
if (mins > 0)
{
g_string_append_printf(gstr, "%s%d %s", prefix, mins,
ngettext("minute", "minutes", mins));
}
return g_string_free(gstr, FALSE);
}
char *
gaim_str_binary_to_ascii(const unsigned char *binary, guint len)
{
GString *ret;
guint i;
g_return_val_if_fail(len > 0, NULL);
ret = g_string_sized_new(len);
for (i = 0; i < len; i++)
if (binary[i] < 32 || binary[i] > 126)
g_string_append_printf(ret, "\\x%02hhx", binary[i]);
else if (binary[i] == '\\')
g_string_append(ret, "\\\\");
else
g_string_append_c(ret, binary[i]);
return g_string_free(ret, FALSE);
}
/**************************************************************************
* URI/URL Functions
**************************************************************************/
gboolean
gaim_url_parse(const char *url, char **ret_host, int *ret_port,
char **ret_path, char **ret_user, char **ret_passwd)
{
char scan_info[255];
char port_str[6];
int f;
const char *at, *slash;
const char *turl;
char host[256], path[256], user[256], passwd[256];
int port = 0;
/* hyphen at end includes it in control set */
static char addr_ctrl[] = "A-Za-z0-9.-";
static char port_ctrl[] = "0-9";
static char page_ctrl[] = "A-Za-z0-9.~_/:*!@&%%?=+^-";
static char user_ctrl[] = "A-Za-z0-9.~_/*!&%%?=+^-";
static char passwd_ctrl[] = "A-Za-z0-9.~_/*!&%%?=+^-";
g_return_val_if_fail(url != NULL, FALSE);
if ((turl = strstr(url, "http://")) != NULL ||
(turl = strstr(url, "HTTP://")) != NULL)
{
turl += 7;
url = turl;
}
/* parse out authentication information if supplied */
/* Only care about @ char BEFORE the first / */
at = strchr(url, '@');
slash = strchr(url, '/');
if ((at != NULL) &&
(((slash != NULL) && (strlen(at) > strlen(slash))) ||
(slash == NULL))) {
g_snprintf(scan_info, sizeof(scan_info),
"%%255[%s]:%%255[%s]^@", user_ctrl, passwd_ctrl);
f = sscanf(url, scan_info, user, passwd);
if (f ==1 ) {
/* No passwd, possibly just username supplied */
g_snprintf(scan_info, sizeof(scan_info),
"%%255[%s]^@", user_ctrl);
f = sscanf(url, scan_info, user);
*passwd = '\0';
}
url = at+1; /* move pointer after the @ char */
} else {
*user = '\0';
*passwd = '\0';
}
g_snprintf(scan_info, sizeof(scan_info),
"%%255[%s]:%%5[%s]/%%255[%s]", addr_ctrl, port_ctrl, page_ctrl);
f = sscanf(url, scan_info, host, port_str, path);
if (f == 1)
{
g_snprintf(scan_info, sizeof(scan_info),
"%%255[%s]/%%255[%s]",
addr_ctrl, page_ctrl);
f = sscanf(url, scan_info, host, path);
g_snprintf(port_str, sizeof(port_str), "80");
}
if (f == 1)
*path = '\0';
sscanf(port_str, "%d", &port);
if (ret_host != NULL) *ret_host = g_strdup(host);
if (ret_port != NULL) *ret_port = port;
if (ret_path != NULL) *ret_path = g_strdup(path);
if (ret_user != NULL) *ret_user = g_strdup(user);
if (ret_passwd != NULL) *ret_passwd = g_strdup(passwd);
return TRUE;
}
static void
destroy_fetch_url_data(GaimFetchUrlData *gfud)
{
if (gfud->webdata != NULL) g_free(gfud->webdata);
if (gfud->url != NULL) g_free(gfud->url);
if (gfud->user_agent != NULL) g_free(gfud->user_agent);
if (gfud->website.address != NULL) g_free(gfud->website.address);
if (gfud->website.page != NULL) g_free(gfud->website.page);
if (gfud->website.user != NULL) g_free(gfud->website.user);
if (gfud->website.passwd != NULL) g_free(gfud->website.passwd);
g_free(gfud);
}
static gboolean
parse_redirect(const char *data, size_t data_len, gint sock,
GaimFetchUrlData *gfud)
{
gchar *s;
if ((s = g_strstr_len(data, data_len, "Location: ")) != NULL)
{
gchar *new_url, *temp_url, *end;
gboolean full;
int len;
s += strlen("Location: ");
end = strchr(s, '\r');
/* Just in case :) */
if (end == NULL)
end = strchr(s, '\n');
if (end == NULL)
return FALSE;
len = end - s;
new_url = g_malloc(len + 1);
strncpy(new_url, s, len);
new_url[len] = '\0';
full = gfud->full;
if (*new_url == '/' || g_strstr_len(new_url, len, "://") == NULL)
{
temp_url = new_url;
new_url = g_strdup_printf("%s:%d%s", gfud->website.address,
gfud->website.port, temp_url);
g_free(temp_url);
full = FALSE;
}
/* Close the existing stuff. */
gaim_input_remove(gfud->inpa);
close(sock);
gaim_debug_info("gaim_url_fetch", "Redirecting to %s\n", new_url);
/* Try again, with this new location. */
gaim_url_fetch(new_url, full, gfud->user_agent, gfud->http11,
gfud->callback, gfud->user_data);
/* Free up. */
g_free(new_url);
destroy_fetch_url_data(gfud);
return TRUE;
}
return FALSE;
}
static size_t
parse_content_len(const char *data, size_t data_len)
{
size_t content_len = 0;
const char *p = NULL;
/* This is still technically wrong, since headers are case-insensitive
* [RFC 2616, section 4.2], though this ought to catch the normal case.
* Note: data is _not_ nul-terminated.
*/
if (data_len > 16) {
p = strncmp(data, "Content-Length: ", 16) == 0? data: NULL;
if (!p) {
p = g_strstr_len(data, data_len, "\nContent-Length: ");
if (p)
p += 1;
}
}
/* If we can find a Content-Length header at all, try to sscanf it.
* Response headers should end with at least \r\n, so sscanf is safe,
* if we make sure that there is indeed a \n in our header.
*/
if (p && g_strstr_len(p, data_len - (p - data), "\n")) {
sscanf(p, "Content-Length: %zu", &content_len);
gaim_debug_misc("parse_content_len", "parsed %u\n", content_len);
}
return content_len;
}
static void
url_fetched_cb(gpointer url_data, gint sock, GaimInputCondition cond)
{
GaimFetchUrlData *gfud = url_data;
char data;
gboolean got_eof = FALSE;
if (sock == -1)
{
gfud->callback(gfud->user_data, NULL, 0);
destroy_fetch_url_data(gfud);
return;
}
if (!gfud->sentreq)
{
char buf[1024];
if (gfud->user_agent)
{
/* Host header is not forbidden in HTTP/1.0 requests, and HTTP/1.1
* clients must know how to handle the "chunked" transfer encoding.
* Gaim doesn't know how to handle "chunked", so should always send
* the Host header regardless, to get around some observed problems
*/
g_snprintf(buf, sizeof(buf),
"GET %s%s HTTP/%s\r\n"
"User-Agent: %s\r\n"
"Host: %s\r\n\r\n",
(gfud->full ? "" : "/"),
(gfud->full ? gfud->url : gfud->website.page),
(gfud->http11 ? "1.1" : "1.0"),
gfud->user_agent, gfud->website.address);
}
else
{
g_snprintf(buf, sizeof(buf),
"GET %s%s HTTP/%s\r\n"
"Host: %s\r\n\r\n",
(gfud->full ? "" : "/"),
(gfud->full ? gfud->url : gfud->website.page),
(gfud->http11 ? "1.1" : "1.0"),
gfud->website.address);
}
gaim_debug_misc("gaim_url_fetch", "Request: %s\n", buf);
write(sock, buf, strlen(buf));
fcntl(sock, F_SETFL, O_NONBLOCK);
gfud->sentreq = TRUE;
gfud->inpa = gaim_input_add(sock, GAIM_INPUT_READ,
url_fetched_cb, url_data);
gfud->data_len = 4096;
gfud->webdata = g_malloc(gfud->data_len);
return;
}
/* Read in data, one byte at a time */
if (read(sock, &data, 1) > 0 || errno == EWOULDBLOCK)
{
if (errno == EWOULDBLOCK)
{
errno = 0;
return;
}
gfud->len++;
/* If we've filled up our buffer then make it bigger */
if (gfud->len == gfud->data_len)
{
gfud->data_len += (gfud->data_len) / 2;
gfud->webdata = g_realloc(gfud->webdata, gfud->data_len);
}
gfud->webdata[gfud->len - 1] = data;
gfud->webdata[gfud->len] = '\0';
if (!gfud->startsaving)
{
if (data == '\r')
return;
if (data == '\n')
{
if (gfud->newline)
{
size_t content_len;
gfud->startsaving = TRUE;
gaim_debug_misc("gaim_url_fetch", "Response headers: '%*.*s'\n", gfud->len, gfud->len, gfud->webdata);
/* See if we can find a redirect. */
if (parse_redirect(gfud->webdata, gfud->len, sock, gfud))
return;
/* No redirect. See if we can find a content length. */
content_len = parse_content_len(gfud->webdata, gfud->len);
if (content_len == 0)
{
/* We'll stick with an initial 8192 */
content_len = 8192;
}
else
{
gfud->has_explicit_data_len = TRUE;
}
/* Out with the old... */
gfud->len = 0;
g_free(gfud->webdata);
gfud->webdata = NULL;
/* In with the new. */
gfud->data_len = content_len;
gfud->webdata = g_try_malloc(gfud->data_len);
if (gfud->webdata == NULL) {
gaim_debug_error("gaim_url_fetch", "Failed to allocate %u bytes: %s\n", gfud->data_len, strerror(errno));
gaim_input_remove(gfud->inpa);
close(sock);
gfud->callback(gfud->user_data, NULL, 0);
destroy_fetch_url_data(gfud);
}
}
else
gfud->newline = TRUE;
return;
}
gfud->newline = FALSE;
}
else if (gfud->has_explicit_data_len && gfud->len == gfud->data_len)
{
got_eof = TRUE;
}
}
else if (errno != ETIMEDOUT)
{
got_eof = TRUE;
}
else
{
gaim_input_remove(gfud->inpa);
close(sock);
gfud->callback(gfud->user_data, NULL, 0);
destroy_fetch_url_data(gfud);
}
if (got_eof) {
gfud->webdata = g_realloc(gfud->webdata, gfud->len + 1);
gfud->webdata[gfud->len] = 0;
/* gaim_debug_misc("gaim_url_fetch", "Received: '%s'\n", gfud->webdata); */
gaim_input_remove(gfud->inpa);
close(sock);
gfud->callback(gfud->user_data, gfud->webdata, gfud->len);
destroy_fetch_url_data(gfud);
}
}
void
gaim_url_fetch(const char *url, gboolean full,
const char *user_agent, gboolean http11,
void (*cb)(gpointer, const char *, size_t),
void *user_data)
{
int sock;
GaimFetchUrlData *gfud;
g_return_if_fail(url != NULL);
g_return_if_fail(cb != NULL);
gaim_debug_info("gaim_url_fetch",
"requested to fetch (%s), full=%d, user_agent=(%s), http11=%d\n",
url, full, user_agent?user_agent:"(null)", http11);
gfud = g_new0(GaimFetchUrlData, 1);
gfud->callback = cb;
gfud->user_data = user_data;
gfud->url = g_strdup(url);
gfud->user_agent = (user_agent != NULL ? g_strdup(user_agent) : NULL);
gfud->http11 = http11;
gfud->full = full;
gaim_url_parse(url, &gfud->website.address, &gfud->website.port,
&gfud->website.page, &gfud->website.user, &gfud->website.passwd);
if ((sock = gaim_proxy_connect(NULL, gfud->website.address,
gfud->website.port, url_fetched_cb,
gfud)) < 0)
{
destroy_fetch_url_data(gfud);
cb(user_data, g_strdup(_("g003: Error opening connection.\n")), 0);
}
}
const char *
gaim_url_decode(const char *str)
{
static char buf[BUF_LEN];
guint i, j = 0;
char *bum;
char hex[3];
g_return_val_if_fail(str != NULL, NULL);
/*
* XXX - This check could be removed and buf could be made
* dynamically allocated, but this is easier.
*/
if (strlen(str) >= BUF_LEN)
return NULL;
for (i = 0; i < strlen(str); i++) {
if (str[i] != '%')
buf[j++] = str[i];
else {
strncpy(hex, str + ++i, 2);
hex[2] = '\0';
/* i is pointing to the start of the number */
i++;
/*
* Now it's at the end and at the start of the for loop
* will be at the next character.
*/
buf[j++] = strtol(hex, NULL, 16);
}
}
buf[j] = '\0';
if (!g_utf8_validate(buf, -1, (const char **)&bum))
*bum = '\0';
return buf;
}
const char *
gaim_url_encode(const char *str)
{
const char *iter;
static char buf[BUF_LEN];
char utf_char[6];
guint i, j = 0;
g_return_val_if_fail(str != NULL, NULL);
g_return_val_if_fail(g_utf8_validate(str, -1, NULL), NULL);
iter = str;
for (; *iter && j < (BUF_LEN - 1) ; iter = g_utf8_next_char(iter)) {
gunichar c = g_utf8_get_char(iter);
/* If the character is an ASCII character and is alphanumeric
* no need to escape */
if (c < 128 && isalnum(c)) {
buf[j++] = c;
} else {
int bytes = g_unichar_to_utf8(c, utf_char);
for (i = 0; i < bytes; i++) {
if (j > (BUF_LEN - 4))
break;
sprintf(buf + j, "%%%02x", utf_char[i] & 0xff);
j += 3;
}
}
}
buf[j] = '\0';
return buf;
}
/* Originally lifted from
* http://www.oreillynet.com/pub/a/network/excerpt/spcookbook_chap03/index3.html
* ... and slightly modified to be a bit more rfc822 compliant
* ... and modified a bit more to make domain checking rfc1035 compliant
* with the exception permitted in rfc1101 for domains to start with digit
* but not completely checking to avoid conflicts with IP addresses
*/
gboolean
gaim_email_is_valid(const char *address)
{
const char *c, *domain;
static char *rfc822_specials = "()<>@,;:\\\"[]";
/* first we validate the name portion (name@domain) (rfc822)*/
for (c = address; *c; c++) {
if (*c == '\"' && (c == address || *(c - 1) == '.' || *(c - 1) == '\"')) {
while (*++c) {
if (*c == '\\') {
if (*c++ && *c < 127 && *c != '\n' && *c != '\r') continue;
else return FALSE;
}
if (*c == '\"') break;
if (*c < ' ' || *c >= 127) return FALSE;
}
if (!*c++) return FALSE;
if (*c == '@') break;
if (*c != '.') return FALSE;
continue;
}
if (*c == '@') break;
if (*c <= ' ' || *c >= 127) return FALSE;
if (strchr(rfc822_specials, *c)) return FALSE;
}
/* strictly we should return false if (*(c - 1) == '.') too, but I think
* we should permit user.@domain type addresses - they do work :) */
if (c == address) return FALSE;
/* next we validate the domain portion (name@domain) (rfc1035 & rfc1011) */
if (!*(domain = ++c)) return FALSE;
do {
if (*c == '.' && (c == domain || *(c - 1) == '.' || *(c - 1) == '-'))
return FALSE;
if (*c == '-' && *(c - 1) == '.') return FALSE;
if ((*c < '0' && *c != '-' && *c != '.') || (*c > '9' && *c < 'A') ||
(*c > 'Z' && *c < 'a') || (*c > 'z')) return FALSE;
} while (*++c);
if (*(c - 1) == '-') return FALSE;
return ((c - domain) > 3 ? TRUE : FALSE);
}
/** Stolen from gnome_uri_list_extract_uris **/
GList* gaim_uri_list_extract_uris (const gchar* uri_list) {
const gchar *p, *q;
gchar *retval;
GList *result = NULL;
g_return_val_if_fail (uri_list != NULL, NULL);
p = uri_list;
/* We don't actually try to validate the URI according to RFC
* 2396, or even check for allowed characters - we just ignore
* comments and trim whitespace off the ends. We also
* allow LF delimination as well as the specified CRLF.
*/
while (p) {
if (*p != '#') {
while (isspace(*p))
p++;
q = p;
while (*q && (*q != '\n') && (*q != '\r'))
q++;
if (q > p) {
q--;
while (q > p && isspace(*q))
q--;
retval = (gchar*)g_malloc (q - p + 2);
strncpy (retval, p, q - p + 1);
retval[q - p + 1] = '\0';
result = g_list_prepend (result, retval);
}
}
p = strchr (p, '\n');
if (p)
p++;
}
return g_list_reverse (result);
}
/** Stolen from gaim_uri_list_extract_filenames **/
GList* gaim_uri_list_extract_filenames (const gchar* uri_list) {
GList *tmp_list, *node, *result;
g_return_val_if_fail (uri_list != NULL, NULL);
result = gaim_uri_list_extract_uris (uri_list);
tmp_list = result;
while (tmp_list) {
gchar *s = (gchar*)tmp_list->data;
node = tmp_list;
tmp_list = tmp_list->next;
if (!strncmp (s, "file:", 5)) {
node->data = g_filename_from_uri (s, NULL, NULL);
/* not sure if this fallback is useful at all */
if (!node->data) node->data = g_strdup (s+5);
} else {
result = g_list_remove_link(result, node);
g_list_free_1 (node);
}
g_free (s);
}
return result;
}
/**************************************************************************
* UTF8 String Functions
**************************************************************************/
gchar *
gaim_utf8_try_convert(const char *str)
{
gsize converted;
gchar *utf8;
g_return_val_if_fail(str != NULL, NULL);
if (g_utf8_validate(str, -1, NULL)) {
return g_strdup(str);
}
utf8 = g_locale_to_utf8(str, -1, &converted, NULL, NULL);
if (utf8 != NULL)
return utf8;
utf8 = g_convert(str, -1, "UTF-8", "ISO-8859-15", &converted, NULL, NULL);
if ((utf8 != NULL) && (converted == strlen(str)))
return utf8;
if (utf8 != NULL)
g_free(utf8);
return NULL;
}
#define utf8_first(x) ((x & 0x80) == 0 || (x & 0xe0) == 0xc0 \
|| (x & 0xf0) == 0xe0 || (x & 0xf8) == 0xf)
gchar *
gaim_utf8_salvage(const char *str)
{
GString *workstr;
const char *end;
g_return_val_if_fail(str != NULL, NULL);
workstr = g_string_sized_new(strlen(str));
do {
g_utf8_validate(str, -1, &end);
workstr = g_string_append_len(workstr, str, end - str);
str = end;
if (*str == '\0')
break;
do {
workstr = g_string_append_c(workstr, '?');
str++;
} while (!utf8_first(*str));
} while (*str != '\0');
return g_string_free(workstr, FALSE);
}
char *
gaim_utf8_ncr_decode(const char *in)
{
GString *out = g_string_new("");
int i;
g_return_val_if_fail(in != NULL, NULL);
g_return_val_if_fail(g_utf8_validate(in, -1, NULL), NULL);
for (i = 0; in[i]; i += 1) {
gboolean ncr_found_p = FALSE;
if (in[i] == '&' && in[i + 1] == '#' && isdigit(in[i + 2])) {
gunichar wc;
int j;
for (wc = 0, j = i + 2; isdigit(in[j]); j += 1) {
wc *= 10;
wc += in[j] - '0';
}
if (in[j] == ';') { /* Technically not completely correct */
g_string_append_unichar(out, wc);
i = j;
ncr_found_p = TRUE;
}
}
if (!ncr_found_p) {
g_string_append_c(out, in[i]);
}
}
return g_string_free(out, FALSE);
}
int
gaim_utf8_strcasecmp(const char *a, const char *b)
{
char *a_norm = NULL;
char *b_norm = NULL;
int ret = -1;
if(!a && b)
return -1;
else if(!b && a)
return 1;
else if(!a && !b)
return 0;
if(!g_utf8_validate(a, -1, NULL) || !g_utf8_validate(b, -1, NULL))
{
gaim_debug_error("gaim_utf8_strcasecmp",
"One or both parameters are invalid UTF8\n");
return ret;
}
a_norm = g_utf8_casefold(a, -1);
b_norm = g_utf8_casefold(b, -1);
ret = g_utf8_collate(a_norm, b_norm);
g_free(a_norm);
g_free(b_norm);
return ret;
}
gboolean gaim_message_meify(char *message, size_t len)
{
char *c;
gboolean inside_html = FALSE;
g_return_val_if_fail(message != NULL, FALSE);
if(len == -1)
len = strlen(message);
for (c = message; *c; c++, len--) {
if(inside_html) {
if(*c == '>')
inside_html = FALSE;
} else {
if(*c == '<')
inside_html = TRUE;
else
break;
}
}
if(*c && !g_ascii_strncasecmp(c, "/me ", 4)) {
memmove(c, c+4, len-3);
return TRUE;
}
return FALSE;
}
char *gaim_text_strip_mnemonic(const char *in)
{
char *out;
char *a;
char *a0;
const char *b;
g_return_val_if_fail(in != NULL, NULL);
out = g_malloc(strlen(in)+1);
a = out;
b = in;
a0 = a; /* The last non-space char seen so far, or the first char */
while(*b) {
if(*b == '_') {
if(a > out && b > in && *(b-1) == '(' && *(b+1) && !(*(b+1) & 0x80) && *(b+2) == ')') {
/* Detected CJK style shortcut (Bug 875311) */
a = a0; /* undo the left parenthesis */
b += 3; /* and skip the whole mess */
} else if(*(b+1) == '_') {
*(a++) = '_';
b += 2;
a0 = a;
} else {
b++;
}
/* We don't want to corrupt the middle of UTF-8 characters */
} else if (!(*b & 0x80)) { /* other 1-byte char */
if (*b != ' ')
a0 = a;
*(a++) = *(b++);
} else {
/* Multibyte utf8 char, don't look for _ inside these */
int n = 0;
int i;
if ((*b & 0xe0) == 0xc0) {
n = 2;
} else if ((*b & 0xf0) == 0xe0) {
n = 3;
} else if ((*b & 0xf8) == 0xf0) {
n = 4;
} else if ((*b & 0xfc) == 0xf8) {
n = 5;
} else if ((*b & 0xfe) == 0xfc) {
n = 6;
} else { /* Illegal utf8 */
n = 1;
}
a0 = a; /* unless we want to delete CJK spaces too */
for (i = 0; i < n && *b; i += 1) {
*(a++) = *(b++);
}
}
}
*a = '\0';
return out;
}
const char* gaim_unescape_filename(const char *escaped) {
return gaim_url_decode(escaped);
}
/* this is almost identical to gaim_url_encode (hence gaim_url_decode
* being used above), but we want to keep certain characters unescaped
* for compat reasons */
const char *
gaim_escape_filename(const char *str)
{
const char *iter;
static char buf[BUF_LEN];
char utf_char[6];
guint i, j = 0;
g_return_val_if_fail(str != NULL, NULL);
g_return_val_if_fail(g_utf8_validate(str, -1, NULL), NULL);
iter = str;
for (; *iter && j < (BUF_LEN - 1) ; iter = g_utf8_next_char(iter)) {
gunichar c = g_utf8_get_char(iter);
/* If the character is an ASCII character and is alphanumeric,
* or one of the specified values, no need to escape */
if (c < 128 && (isalnum(c) || c == '@' || c == '-' ||
c == '_' || c == '.' || c == '#')) {
buf[j++] = c;
} else {
int bytes = g_unichar_to_utf8(c, utf_char);
for (i = 0; i < bytes; i++) {
if (j > (BUF_LEN - 4))
break;
sprintf(buf + j, "%%%02x", utf_char[i] & 0xff);
j += 3;
}
}
}
buf[j] = '\0';
return buf;
}