source: lib/misc.c @ 9c78519

Last change on this file since 9c78519 was 9c78519, checked in by Wilmer van der Gaast <wilmer@…>, at 2017-04-05T22:38:08Z

Move canohost functions (diff licence) to separate file.

  • Property mode set to 100644
File size: 16.9 KB
RevLine 
[9c78519]1  /********************************************************************\
[b7d3cc34]2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
[0e788f5]4  * Copyright 2002-2012 Wilmer van der Gaast and others                *
[b7d3cc34]5  \********************************************************************/
6
7/*
[c88999c]8 * Various utility functions. Some are copied from Gaim to support the
9 * IM-modules, most are from BitlBee.
[b7d3cc34]10 *
11 * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
12 *                          (and possibly other members of the Gaim team)
[0e788f5]13 * Copyright 2002-2012 Wilmer van der Gaast <wilmer@gaast.net>
[b7d3cc34]14 */
15
16/*
17  This program is free software; you can redistribute it and/or modify
18  it under the terms of the GNU General Public License as published by
19  the Free Software Foundation; either version 2 of the License, or
20  (at your option) any later version.
21
22  This program is distributed in the hope that it will be useful,
23  but WITHOUT ANY WARRANTY; without even the implied warranty of
24  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25  GNU General Public License for more details.
26
27  You should have received a copy of the GNU General Public License with
28  the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
[6f10697]29  if not, write to the Free Software Foundation, Inc., 51 Franklin St.,
30  Fifth Floor, Boston, MA  02110-1301  USA
[b7d3cc34]31*/
32
33#define BITLBEE_CORE
34#include "nogaim.h"
[4e8db1c]35#include "base64.h"
[c6ca3ee]36#include "md5.h"
[b7d3cc34]37#include <stdio.h>
38#include <stdlib.h>
39#include <string.h>
[dd8d4c5]40#include <ctype.h>
[b7d3cc34]41#include <glib.h>
42#include <time.h>
43
[36e9f62]44#ifdef HAVE_RESOLV_A
45#include <arpa/nameser.h>
46#include <resolv.h>
47#endif
48
[4cf80bb]49#include "md5.h"
[d52111a]50#include "ssl_client.h"
51
[b7d3cc34]52void strip_linefeed(gchar *text)
53{
54        int i, j;
55        gchar *text2 = g_malloc(strlen(text) + 1);
56
[5ebff60]57        for (i = 0, j = 0; text[i]; i++) {
58                if (text[i] != '\r') {
[b7d3cc34]59                        text2[j++] = text[i];
[5ebff60]60                }
61        }
[b7d3cc34]62        text2[j] = '\0';
63
64        strcpy(text, text2);
65        g_free(text2);
66}
67
68time_t get_time(int year, int month, int day, int hour, int min, int sec)
69{
70        struct tm tm;
71
[613cc55]72        memset(&tm, 0, sizeof(struct tm));
[b7d3cc34]73        tm.tm_year = year - 1900;
74        tm.tm_mon = month - 1;
75        tm.tm_mday = day;
76        tm.tm_hour = hour;
77        tm.tm_min = min;
78        tm.tm_sec = sec >= 0 ? sec : time(NULL) % 60;
[5ebff60]79
[b7d3cc34]80        return mktime(&tm);
81}
82
[5ebff60]83time_t mktime_utc(struct tm *tp)
[2e3a857]84{
85        struct tm utc;
86        time_t res, tres;
[5ebff60]87
[2e3a857]88        tp->tm_isdst = -1;
[5ebff60]89        res = mktime(tp);
[2e3a857]90        /* Problem is, mktime() just gave us the GMT timestamp for the
91           given local time... While the given time WAS NOT local. So
92           we should fix this now.
[5ebff60]93
[2e3a857]94           Now I could choose between messing with environment variables
95           (kludgy) or using timegm() (not portable)... Or doing the
96           following, which I actually prefer...
[5ebff60]97
[2e3a857]98           tzset() may also work but in other places I actually want to
99           use local time.
[5ebff60]100
[2e3a857]101           FFFFFFFFFFFFFFFFFFFFFUUUUUUUUUUUUUUUUUUUU!! */
[5ebff60]102        gmtime_r(&res, &utc);
[2e3a857]103        utc.tm_isdst = -1;
[5ebff60]104        if (utc.tm_hour == tp->tm_hour && utc.tm_min == tp->tm_min) {
[2e3a857]105                /* Sweet! We're in UTC right now... */
106                return res;
[5ebff60]107        }
108
109        tres = mktime(&utc);
[2e3a857]110        res += res - tres;
[5ebff60]111
[2e3a857]112        /* Yes, this is a hack. And it will go wrong around DST changes.
113           BUT this is more likely to be threadsafe than messing with
114           environment variables, and possibly more portable... */
[5ebff60]115
[2e3a857]116        return res;
117}
118
[5ebff60]119typedef struct htmlentity {
[51fdc45]120        char code[7];
121        char is[3];
[b7d3cc34]122} htmlentity_t;
123
[39cc341]124static const htmlentity_t ent[] =
[b7d3cc34]125{
[39cc341]126        { "lt",     "<" },
127        { "gt",     ">" },
128        { "amp",    "&" },
[b52e478]129        { "apos",   "'" },
[39cc341]130        { "quot",   "\"" },
131        { "aacute", "á" },
132        { "eacute", "é" },
133        { "iacute", "é" },
134        { "oacute", "ó" },
135        { "uacute", "ú" },
136        { "agrave", "à" },
137        { "egrave", "è" },
138        { "igrave", "ì" },
139        { "ograve", "ò" },
140        { "ugrave", "ù" },
141        { "acirc",  "â" },
142        { "ecirc",  "ê" },
143        { "icirc",  "î" },
144        { "ocirc",  "ô" },
145        { "ucirc",  "û" },
146        { "auml",   "ä" },
147        { "euml",   "ë" },
148        { "iuml",   "ï" },
149        { "ouml",   "ö" },
150        { "uuml",   "ü" },
151        { "nbsp",   " " },
152        { "",        ""  }
[b7d3cc34]153};
154
[5ebff60]155void strip_html(char *in)
[b7d3cc34]156{
157        char *start = in;
[5ebff60]158        char out[strlen(in) + 1];
[b7d3cc34]159        char *s = out, *cs;
160        int i, matched;
[5a71d9c]161        int taglen;
[5ebff60]162
163        memset(out, 0, sizeof(out));
164
165        while (*in) {
166                if (*in == '<' && (g_ascii_isalpha(*(in + 1)) || *(in + 1) == '/')) {
[b7d3cc34]167                        /* If in points at a < and in+1 points at a letter or a slash, this is probably
168                           a HTML-tag. Try to find a closing > and continue there. If the > can't be
169                           found, assume that it wasn't a HTML-tag after all. */
[5ebff60]170
[b7d3cc34]171                        cs = in;
[5ebff60]172
173                        while (*in && *in != '>') {
174                                in++;
175                        }
176
[be999a5]177                        taglen = in - cs - 1;   /* not <0 because the above loop runs at least once */
[5ebff60]178                        if (*in) {
179                                if (g_strncasecmp(cs + 1, "b", taglen) == 0) {
[5a71d9c]180                                        *(s++) = '\x02';
[5ebff60]181                                } else if (g_strncasecmp(cs + 1, "/b", taglen) == 0) {
[5a71d9c]182                                        *(s++) = '\x02';
[5ebff60]183                                } else if (g_strncasecmp(cs + 1, "i", taglen) == 0) {
[5a71d9c]184                                        *(s++) = '\x1f';
[5ebff60]185                                } else if (g_strncasecmp(cs + 1, "/i", taglen) == 0) {
[5a71d9c]186                                        *(s++) = '\x1f';
[5ebff60]187                                } else if (g_strncasecmp(cs + 1, "br", taglen) == 0) {
[b7d3cc34]188                                        *(s++) = '\n';
[098b430]189                                } else if (g_strncasecmp(cs + 1, "br/", taglen) == 0) {
190                                        *(s++) = '\n';
191                                } else if (g_strncasecmp(cs + 1, "br /", taglen) == 0) {
192                                        *(s++) = '\n';
[5ebff60]193                                }
194                                in++;
195                        } else {
[b7d3cc34]196                                in = cs;
197                                *(s++) = *(in++);
198                        }
[5ebff60]199                } else if (*in == '&') {
[b7d3cc34]200                        cs = ++in;
[5ebff60]201                        while (*in && g_ascii_isalpha(*in)) {
202                                in++;
203                        }
204
205                        if (*in == ';') {
206                                in++;
207                        }
[b7d3cc34]208                        matched = 0;
[5ebff60]209
210                        for (i = 0; *ent[i].code; i++) {
211                                if (g_strncasecmp(ent[i].code, cs, strlen(ent[i].code)) == 0) {
[39cc341]212                                        int j;
[5ebff60]213
214                                        for (j = 0; ent[i].is[j]; j++) {
[39cc341]215                                                *(s++) = ent[i].is[j];
[5ebff60]216                                        }
217
[b7d3cc34]218                                        matched = 1;
219                                        break;
220                                }
[5ebff60]221                        }
[b7d3cc34]222
223                        /* None of the entities were matched, so return the string */
[5ebff60]224                        if (!matched) {
[b7d3cc34]225                                in = cs - 1;
226                                *(s++) = *(in++);
227                        }
[5ebff60]228                } else {
[b7d3cc34]229                        *(s++) = *(in++);
230                }
231        }
[5ebff60]232
233        strcpy(start, out);
[b7d3cc34]234}
235
[5ebff60]236char *escape_html(const char *html)
[b7d3cc34]237{
238        const char *c = html;
239        GString *ret;
240        char *str;
[5ebff60]241
242        if (html == NULL) {
243                return(NULL);
244        }
245
246        ret = g_string_new("");
247
248        while (*c) {
249                switch (*c) {
250                case '&':
251                        ret = g_string_append(ret, "&amp;");
252                        break;
253                case '<':
254                        ret = g_string_append(ret, "&lt;");
255                        break;
256                case '>':
257                        ret = g_string_append(ret, "&gt;");
258                        break;
259                case '"':
260                        ret = g_string_append(ret, "&quot;");
261                        break;
262                default:
263                        ret = g_string_append_c(ret, *c);
[b7d3cc34]264                }
[5ebff60]265                c++;
[b7d3cc34]266        }
[5ebff60]267
[b7d3cc34]268        str = ret->str;
[5ebff60]269        g_string_free(ret, FALSE);
270        return(str);
[b7d3cc34]271}
272
[c88999c]273/* Decode%20a%20file%20name                                             */
[5ebff60]274void http_decode(char *s)
[c88999c]275{
276        char *t;
277        int i, j, k;
[5ebff60]278
279        t = g_new(char, strlen(s) + 1);
280
281        for (i = j = 0; s[i]; i++, j++) {
282                if (s[i] == '%') {
283                        if (sscanf(s + i + 1, "%2x", &k)) {
[c88999c]284                                t[j] = k;
285                                i += 2;
[5ebff60]286                        } else {
[c88999c]287                                *t = 0;
288                                break;
289                        }
[5ebff60]290                } else {
[c88999c]291                        t[j] = s[i];
292                }
293        }
294        t[j] = 0;
[5ebff60]295
296        strcpy(s, t);
297        g_free(t);
[c88999c]298}
299
300/* Warning: This one explodes the string. Worst-cases can make the string 3x its original size! */
[e88fe7da]301/* This function is safe, but make sure you call it safely as well! */
[5ebff60]302void http_encode(char *s)
[c88999c]303{
[5ebff60]304        char t[strlen(s) + 1];
[c88999c]305        int i, j;
[5ebff60]306
307        strcpy(t, s);
308        for (i = j = 0; t[i]; i++, j++) {
[6b13103]309                /* Warning: g_ascii_isalnum() is locale-aware, so don't use it here! */
[5ebff60]310                if ((t[i] >= 'A' && t[i] <= 'Z') ||
311                    (t[i] >= 'a' && t[i] <= 'z') ||
312                    (t[i] >= '0' && t[i] <= '9') ||
313                    strchr("._-~", t[i])) {
[b40e60d]314                        s[j] = t[i];
[5ebff60]315                } else {
316                        sprintf(s + j, "%%%02X", ((unsigned char *) t)[i]);
[b40e60d]317                        j += 2;
[c88999c]318                }
319        }
320        s[j] = 0;
321}
322
[5ebff60]323/* Strip newlines from a string. Modifies the string passed to it. */
324char *strip_newlines(char *source)
[c88999c]325{
[5ebff60]326        int i;
[c88999c]327
[5ebff60]328        for (i = 0; source[i] != '\0'; i++) {
329                if (source[i] == '\n' || source[i] == '\r') {
[c88999c]330                        source[i] = ' ';
[5ebff60]331                }
332        }
333
[c88999c]334        return source;
335}
[2a6ca4f]336
[e27661d]337/* Convert from one charset to another.
[5ebff60]338
[e27661d]339   from_cs, to_cs: Source and destination charsets
340   src, dst: Source and destination strings
341   size: Size if src. 0 == use strlen(). strlen() is not reliable for UNICODE/UTF16 strings though.
342   maxbuf: Maximum number of bytes to write to dst
[5ebff60]343
[e27661d]344   Returns the number of bytes written to maxbuf or -1 on an error.
345*/
[5ebff60]346signed int do_iconv(char *from_cs, char *to_cs, char *src, char *dst, size_t size, size_t maxbuf)
[e27661d]347{
[574af7e]348        GIConv cd;
[e27661d]349        size_t res;
350        size_t inbytesleft, outbytesleft;
351        char *inbuf = src;
352        char *outbuf = dst;
[5ebff60]353
354        cd = g_iconv_open(to_cs, from_cs);
355        if (cd == (GIConv) - 1) {
[f5da476]356                return -1;
[5ebff60]357        }
358
359        inbytesleft = size ? size : strlen(src);
[e27661d]360        outbytesleft = maxbuf - 1;
[5ebff60]361        res = g_iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
[e27661d]362        *outbuf = '\0';
[5ebff60]363        g_iconv_close(cd);
364
365        if (res != 0) {
[f5da476]366                return -1;
[5ebff60]367        } else {
[f5da476]368                return outbuf - dst;
[5ebff60]369        }
[e27661d]370}
371
[5eab298f]372/* A wrapper for /dev/urandom.
373 * If /dev/urandom is not present or not usable, it calls abort()
374 * to prevent bitlbee from working without a decent entropy source */
[5ebff60]375void random_bytes(unsigned char *buf, int count)
[7f49a86]376{
[5eab298f]377        int fd;
[5ebff60]378
379        if (((fd = open("/dev/urandom", O_RDONLY)) == -1) ||
380            (read(fd, buf, count) == -1)) {
381                log_message(LOGLVL_ERROR, "/dev/urandom not present - aborting");
[5eab298f]382                abort();
[7f49a86]383        }
[5eab298f]384
[5ebff60]385        close(fd);
[7f49a86]386}
387
[5ebff60]388int is_bool(char *value)
[5100caa]389{
[5ebff60]390        if (*value == 0) {
[5100caa]391                return 0;
[5ebff60]392        }
393
394        if ((g_strcasecmp(value,
395                          "true") == 0) || (g_strcasecmp(value, "yes") == 0) || (g_strcasecmp(value, "on") == 0)) {
[5100caa]396                return 1;
[5ebff60]397        }
398        if ((g_strcasecmp(value,
399                          "false") == 0) || (g_strcasecmp(value, "no") == 0) || (g_strcasecmp(value, "off") == 0)) {
[5100caa]400                return 1;
[5ebff60]401        }
402
403        while (*value) {
404                if (!g_ascii_isdigit(*value)) {
[5100caa]405                        return 0;
[5ebff60]406                } else {
407                        value++;
408                }
409        }
410
[5100caa]411        return 1;
412}
413
[5ebff60]414int bool2int(char *value)
[5100caa]415{
416        int i;
[5ebff60]417
418        if ((g_strcasecmp(value,
419                          "true") == 0) || (g_strcasecmp(value, "yes") == 0) || (g_strcasecmp(value, "on") == 0)) {
[5100caa]420                return 1;
[5ebff60]421        }
422        if ((g_strcasecmp(value,
423                          "false") == 0) || (g_strcasecmp(value, "no") == 0) || (g_strcasecmp(value, "off") == 0)) {
[5100caa]424                return 0;
[5ebff60]425        }
426
427        if (sscanf(value, "%d", &i) == 1) {
[5100caa]428                return i;
[5ebff60]429        }
430
[5100caa]431        return 0;
432}
[36e9f62]433
[5ebff60]434struct ns_srv_reply **srv_lookup(char *service, char *protocol, char *domain)
435{
[ffdf2e7]436        struct ns_srv_reply **replies = NULL;
[5ebff60]437
[36e9f62]438#ifdef HAVE_RESOLV_A
[ffdf2e7]439        struct ns_srv_reply *reply = NULL;
[36e9f62]440        char name[1024];
441        unsigned char querybuf[1024];
442        const unsigned char *buf;
443        ns_msg nsh;
444        ns_rr rr;
[632627e]445        int n, len, size;
[5ebff60]446
447        g_snprintf(name, sizeof(name), "_%s._%s.%s", service, protocol, domain);
448
449        if ((size = res_query(name, ns_c_in, ns_t_srv, querybuf, sizeof(querybuf))) <= 0) {
[36e9f62]450                return NULL;
[5ebff60]451        }
452
453        if (ns_initparse(querybuf, size, &nsh) != 0) {
[36e9f62]454                return NULL;
[5ebff60]455        }
456
[ffdf2e7]457        n = 0;
[5ebff60]458        while (ns_parserr(&nsh, ns_s_an, n, &rr) == 0) {
[632627e]459                char name[NS_MAXDNAME];
460
[5ebff60]461                if (ns_rr_rdlen(rr) < 7) {
462                        break;
463                }
[632627e]464
[5ebff60]465                buf = ns_rr_rdata(rr);
466
467                if (dn_expand(querybuf, querybuf + size, &buf[6], name, NS_MAXDNAME) == -1) {
[ffdf2e7]468                        break;
[5ebff60]469                }
[632627e]470
471                len = strlen(name) + 1;
[5ebff60]472
473                reply = g_malloc(sizeof(struct ns_srv_reply) + len);
474                memcpy(reply->name, name, len);
475
476                reply->prio = (buf[0] << 8) | buf[1];
477                reply->weight = (buf[2] << 8) | buf[3];
478                reply->port = (buf[4] << 8) | buf[5];
479
480                n++;
481                replies = g_renew(struct ns_srv_reply *, replies, n + 1);
482                replies[n - 1] = reply;
483        }
484        if (replies) {
[ffdf2e7]485                replies[n] = NULL;
[5ebff60]486        }
[36e9f62]487#endif
[5ebff60]488
[ffdf2e7]489        return replies;
490}
491
[5ebff60]492void srv_free(struct ns_srv_reply **srv)
[ffdf2e7]493{
494        int i;
[5ebff60]495
496        if (srv == NULL) {
[ffdf2e7]497                return;
[5ebff60]498        }
499
500        for (i = 0; srv[i]; i++) {
501                g_free(srv[i]);
502        }
503        g_free(srv);
[36e9f62]504}
[d444c09]505
[5ebff60]506char *word_wrap(const char *msg, int line_len)
[d444c09]507{
[5ebff60]508        GString *ret = g_string_sized_new(strlen(msg) + 16);
509
510        while (strlen(msg) > line_len) {
[d444c09]511                int i;
[5ebff60]512
[d444c09]513                /* First try to find out if there's a newline already. Don't
514                   want to add more splits than necessary. */
[5ebff60]515                for (i = line_len; i > 0 && msg[i] != '\n'; i--) {
516                        ;
517                }
518                if (msg[i] == '\n') {
519                        g_string_append_len(ret, msg, i + 1);
[d444c09]520                        msg += i + 1;
521                        continue;
522                }
[5ebff60]523
524                for (i = line_len; i > 0; i--) {
525                        if (msg[i] == '-') {
526                                g_string_append_len(ret, msg, i + 1);
527                                g_string_append_c(ret, '\n');
[d444c09]528                                msg += i + 1;
529                                break;
[5ebff60]530                        } else if (msg[i] == ' ') {
531                                g_string_append_len(ret, msg, i);
532                                g_string_append_c(ret, '\n');
[d444c09]533                                msg += i + 1;
534                                break;
535                        }
536                }
[5ebff60]537                if (i == 0) {
[fca4683]538                        const char *end;
539                        size_t len;
540
541                        g_utf8_validate(msg, line_len, &end);
542
543                        len = (end != msg) ? end - msg : line_len;
544
545                        g_string_append_len(ret, msg, len);
[5ebff60]546                        g_string_append_c(ret, '\n');
[fca4683]547                        msg += len;
[d444c09]548                }
549        }
[5ebff60]550        g_string_append(ret, msg);
551
552        return g_string_free(ret, FALSE);
[d444c09]553}
[d52111a]554
[5ebff60]555gboolean ssl_sockerr_again(void *ssl)
[d52111a]556{
[5ebff60]557        if (ssl) {
[d52111a]558                return ssl_errno == SSL_AGAIN;
[5ebff60]559        } else {
[d52111a]560                return sockerr_again();
[5ebff60]561        }
[d52111a]562}
[4e8db1c]563
564/* Returns values: -1 == Failure (base64-decoded to something unexpected)
565                    0 == Okay
566                    1 == Password doesn't match the hash. */
[5ebff60]567int md5_verify_password(char *password, char *hash)
[4e8db1c]568{
569        md5_byte_t *pass_dec = NULL;
570        md5_byte_t pass_md5[16];
571        md5_state_t md5_state;
[6a78c0e]572        int ret = -1, i;
[5ebff60]573
574        if (base64_decode(hash, &pass_dec) == 21) {
575                md5_init(&md5_state);
576                md5_append(&md5_state, (md5_byte_t *) password, strlen(password));
577                md5_append(&md5_state, (md5_byte_t *) pass_dec + 16, 5);  /* Hmmm, salt! */
578                md5_finish(&md5_state, pass_md5);
579
580                for (i = 0; i < 16; i++) {
581                        if (pass_dec[i] != pass_md5[i]) {
[4e8db1c]582                                ret = 1;
583                                break;
584                        }
585                }
[5ebff60]586
[4e8db1c]587                /* If we reached the end of the loop, it was a match! */
[5ebff60]588                if (i == 16) {
[4e8db1c]589                        ret = 0;
[5ebff60]590                }
[4e8db1c]591        }
[5ebff60]592
593        g_free(pass_dec);
[4e8db1c]594
595        return ret;
596}
[24b8bbb]597
[7b87539]598/* Split commands (root-style, *not* IRC-style). Handles "quoting of"
599   white\ space in 'various ways'. Returns a NULL-terminated static
600   char** so watch out with nested use! Definitely not thread-safe. */
[5ebff60]601char **split_command_parts(char *command, int limit)
[24b8bbb]602{
[5ebff60]603        static char *cmd[IRC_MAX_ARGS + 1];
[24b8bbb]604        char *s, q = 0;
605        int k;
[5ebff60]606
607        memset(cmd, 0, sizeof(cmd));
[24b8bbb]608        cmd[0] = command;
609        k = 1;
[5ebff60]610        for (s = command; *s && k < IRC_MAX_ARGS; s++) {
611                if (*s == ' ' && !q) {
[24b8bbb]612                        *s = 0;
[5ebff60]613                        while (*++s == ' ') {
614                                ;
615                        }
616                        if (k != limit && (*s == '"' || *s == '\'')) {
[24b8bbb]617                                q = *s;
[5ebff60]618                                s++;
[24b8bbb]619                        }
[5ebff60]620                        if (*s) {
[24b8bbb]621                                cmd[k++] = s;
[269580c]622                                if (limit && k > limit) {
623                                        break;
624                                }
[5ebff60]625                                s--;
626                        } else {
[24b8bbb]627                                break;
628                        }
[5ebff60]629                } else if (*s == '\\' && ((!q && s[1]) || (q && q == s[1]))) {
[24b8bbb]630                        char *cpy;
[5ebff60]631
632                        for (cpy = s; *cpy; cpy++) {
[24b8bbb]633                                cpy[0] = cpy[1];
[5ebff60]634                        }
635                } else if (*s == q) {
[24b8bbb]636                        q = *s = 0;
637                }
[269580c]638        }
[5ebff60]639
[89c11e7]640        /* Full zero-padding for easier argc checking. */
[5ebff60]641        while (k <= IRC_MAX_ARGS) {
[89c11e7]642                cmd[k++] = NULL;
[5ebff60]643        }
644
[24b8bbb]645        return cmd;
646}
[9b0ad7e]647
[5ebff60]648char *get_rfc822_header(const char *text, const char *header, int len)
[9b0ad7e]649{
[5ebff60]650        int hlen = strlen(header), i;
[55ccc9a0]651        const char *ret;
[5ebff60]652
653        if (text == NULL) {
[f9789d4]654                return NULL;
[5ebff60]655        }
656
657        if (len == 0) {
658                len = strlen(text);
659        }
660
[9b0ad7e]661        i = 0;
[5ebff60]662        while ((i + hlen) < len) {
[9b0ad7e]663                /* Maybe this is a bit over-commented, but I just hate this part... */
[5ebff60]664                if (g_strncasecmp(text + i, header, hlen) == 0) {
[9b0ad7e]665                        /* Skip to the (probable) end of the header */
666                        i += hlen;
[5ebff60]667
[9b0ad7e]668                        /* Find the first non-[: \t] character */
[5ebff60]669                        while (i < len && (text[i] == ':' || text[i] == ' ' || text[i] == '\t')) {
670                                i++;
671                        }
672
[9b0ad7e]673                        /* Make sure we're still inside the string */
[5ebff60]674                        if (i >= len) {
675                                return(NULL);
676                        }
677
[9b0ad7e]678                        /* Save the position */
679                        ret = text + i;
[5ebff60]680
[9b0ad7e]681                        /* Search for the end of this line */
[5ebff60]682                        while (i < len && text[i] != '\r' && text[i] != '\n') {
683                                i++;
684                        }
685
[9b0ad7e]686                        /* Copy the found data */
[5ebff60]687                        return(g_strndup(ret, text + i - ret));
[9b0ad7e]688                }
[5ebff60]689
[9b0ad7e]690                /* This wasn't the header we were looking for, skip to the next line. */
[5ebff60]691                while (i < len && (text[i] != '\r' && text[i] != '\n')) {
692                        i++;
693                }
694                while (i < len && (text[i] == '\r' || text[i] == '\n')) {
695                        i++;
696                }
697
[9b0ad7e]698                /* End of headers? */
[5ebff60]699                if ((i >= 4 && strncmp(text + i - 4, "\r\n\r\n", 4) == 0) ||
700                    (i >= 2 && (strncmp(text + i - 2, "\n\n", 2) == 0 ||
701                                strncmp(text + i - 2, "\r\r", 2) == 0))) {
[9b0ad7e]702                        break;
703                }
704        }
[5ebff60]705
[f9789d4]706        return NULL;
[9b0ad7e]707}
[fed4f76]708
709/* Takes a string, truncates it where it's safe, returns the new length */
[5ebff60]710int truncate_utf8(char *string, int maxlen)
[fed4f76]711{
712        char *end;
[5ebff60]713
714        g_utf8_validate((const gchar *) string, maxlen, (const gchar **) &end);
[fed4f76]715        *end = '\0';
716        return end - string;
717}
[73f0a01]718
719/* Parses a guint64 from string, returns TRUE on success */
720gboolean parse_int64(char *string, int base, guint64 *number)
721{
722        guint64 parsed;
723        char *endptr;
724
725        errno = 0;
726        parsed = g_ascii_strtoull(string, &endptr, base);
727        if (errno || endptr == string || *endptr != '\0') {
728                return FALSE;
729        }
730        *number = parsed;
731        return TRUE;
732}
733
[47ab9a9]734/* Filters all the characters in 'blacklist' replacing them with 'replacement'.
735 * Modifies the string in-place and returns the string itself.
736 * For the opposite, use g_strcanon() */
737char *str_reject_chars(char *string, const char *reject, char replacement)
738{
739        char *c = string;
740
741        while (*c) {
742                c += strcspn(c, reject);
743                if (*c) {
744                        *c = replacement;
745                }
746        }
747
748        return string;
749}
[4466e3e]750
751/* Returns a string that is exactly 'char_len' utf8 characters long (not bytes),
752 * padded to the right with spaces or truncated with the 'ellipsis' parameter
753 * if specified (can be NULL).
754 * Returns a newly allocated string, or NULL on invalid parameters. */
755char *str_pad_and_truncate(const char *string, long char_len, const char *ellipsis)
756{
757        size_t string_len = strlen(string);
758        size_t ellipsis_len = (ellipsis) ? strlen(ellipsis) : 0;
759        long orig_len = g_utf8_strlen(string, -1);
760
761        g_return_val_if_fail(char_len > ellipsis_len, NULL);
762
763        if (orig_len > char_len) {
764                char *ret = g_malloc(string_len + 1);
765                g_utf8_strncpy(ret, string, char_len - ellipsis_len);
766                if (ellipsis) {
767                        g_strlcat(ret, ellipsis, string_len);
768                }
769                return ret;
770        } else if (orig_len < char_len) {
771                return g_strdup_printf("%s%*s", string, (int) (char_len - orig_len), "");
772        } else {
773                return g_strdup(string);
774        }
775}
Note: See TracBrowser for help on using the repository browser.