asprintfpatch

asprintfpatch.patch

diff --git a/src/conky.cc b/src/conky.cc
index 6522ce1..07625cf 100644
--- a/src/conky.cc
+++ b/src/conky.cc
@@ -129,6 +129,549 @@
 #include <microhttpd.h>
 #endif
 
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <ctype.h>
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+
+
+
+#define ALLOC_CHUNK 2048
+#define ALLOC_SECURITY_MARGIN 1024   /* big value because some platforms have very big 'G' exponent */
+#if ALLOC_CHUNK < ALLOC_SECURITY_MARGIN
+#    error  !!! ALLOC_CHUNK < ALLOC_SECURITY_MARGIN !!!
+#endif
+/* note: to have some interest, ALLOC_CHUNK should be much greater than ALLOC_SECURITY_MARGIN */
+
+/*
+ *  To save a lot of push/pop, every variable are stored into this
+ *  structure, which is passed among nearly every sub-functions.
+ */
+typedef struct {
+    const char * src_string;        /* current position into intput string */
+    char *       buffer_base;       /* output buffer */
+    char *       dest_string;       /* current position into output string */
+    size_t       buffer_len;        /* length of output buffer */
+    size_t       real_len;          /* real current length of output text */
+    size_t       pseudo_len;        /* total length of output text if it were not limited in size */
+    size_t       maxlen;
+    va_list      vargs;             /* pointer to current position into vargs */
+    char *       sprintf_string;
+    FILE *       fprintf_file;
+} xprintf_struct;
+
+/*
+ *  Realloc buffer if needed
+ *  Return value:  0 = ok
+ *               EOF = not enought memory
+ */
+static int realloc_buff(xprintf_struct *s, size_t len)
+{
+    char * ptr;
+    
+    if (len + ALLOC_SECURITY_MARGIN + s->real_len > s->buffer_len) {
+        len += s->real_len + ALLOC_CHUNK;
+        ptr = (char *)realloc((void *)(s->buffer_base), len);
+        if (ptr == NULL) {
+            s->buffer_base = NULL;
+            return EOF;
+        }
+        
+        s->dest_string = ptr + (size_t)(s->dest_string - s->buffer_base);
+        s->buffer_base = ptr;
+        s->buffer_len = len;
+        
+        (s->buffer_base)[s->buffer_len - 1] = 1; /* overflow marker */
+    }
+    
+    return 0;
+}
+
+/*
+ *  Prints 'usual' characters    up to next '%'
+ *                            or up to end of text
+ */
+static int usual_char(xprintf_struct * s)
+{
+    size_t len;
+    
+    len = strcspn(s->src_string, "%");     /* reachs the next '%' or end of input string */
+    /* note: 'len' is never 0 because the presence of '%' */
+    /* or end-of-line is checked in the calling function  */
+    
+    if (realloc_buff(s,len) == EOF)
+        return EOF;
+    
+    memcpy(s->dest_string, s->src_string, len);
+    s->src_string += len;
+    s->dest_string += len;
+    s->real_len += len;
+    s->pseudo_len += len;
+    
+    return 0;
+}
+
+/*
+ *  Return value: 0 = ok
+ *                EOF = error
+ */
+static int print_it(xprintf_struct *s, size_t approx_len,
+                    const char *format_string, ...)
+{
+    va_list varg;
+    int vsprintf_len;
+    size_t len;
+    
+    if (realloc_buff(s,approx_len) == EOF)
+        return EOF;
+    
+    va_start(varg, format_string);
+    vsprintf_len = vsprintf(s->dest_string, format_string, varg);
+    va_end(varg);
+    
+    /* Check for overflow */
+    assert((s->buffer_base)[s->buffer_len - 1] == 1);
+    
+    if (vsprintf_len == EOF) /* must be done *after* overflow-check */
+        return EOF;
+    
+    s->pseudo_len += vsprintf_len;
+    len = strlen(s->dest_string);
+    s->real_len += len;
+    s->dest_string += len;
+    
+    return 0;
+}
+
+/*
+ *  Prints a string (%s)
+ *  We need special handling because:
+ *     a: the length of the string is unknown
+ *     b: when .prec is used, we must not access any extra byte of the
+ *        string (of course, if the original sprintf() does... what the
+ *        hell, not my problem)
+ *
+ *  Return value: 0 = ok
+ *                EOF = error
+ */
+static int type_s(xprintf_struct *s, int width, int prec,
+                  const char *format_string, const char *arg_string)
+{
+    size_t string_len;
+    
+    if (arg_string == NULL)
+        return print_it(s, (size_t)6, "(null)", 0);
+    
+    /* hand-made strlen() whitch stops when 'prec' is reached. */
+    /* if 'prec' is -1 then it is never reached. */
+    string_len = 0;
+    while (arg_string[string_len] != 0 && (size_t)prec != string_len)
+        string_len++;
+    
+    if (width != -1 && string_len < (size_t)width)
+        string_len = (size_t)width;
+    
+    return print_it(s, string_len, format_string, arg_string);
+}
+
+/*
+ *  Read a serie of digits. Stop when non-digit is found.
+ *  Return value: the value read (between 0 and 32767).
+ *  Note: no checks are made against overflow. If the string contain a big
+ *  number, then the return value won't be what we want (but, in this case,
+ *  the programmer don't know whatr he wants, then no problem).
+ */
+static int getint(const char **string)
+{
+    int i = 0;
+    
+    while (isdigit((unsigned char)**string) != 0) {
+        i = i * 10 + (**string - '0');
+        (*string)++;
+    }
+    
+    if (i < 0 || i > 32767)
+        i = 32767; /* if we have i==-10 this is not because the number is */
+    /* negative; this is because the number is big */
+    return i;
+}
+
+/*
+ *  Read a part of the format string. A part is 'usual characters' (ie "blabla")
+ *  or '%%' escape sequence (to print a single '%') or any combination of
+ *  format specifier (ie "%i" or "%10.2d").
+ *  After the current part is managed, the function returns to caller with
+ *  everything ready to manage the following part.
+ *  The caller must ensure than the string is not empty, i.e. the first byte
+ *  is not zero.
+ *
+ *  Return value:  0 = ok
+ *                 EOF = error
+ */
+static int dispatch(xprintf_struct *s)
+{
+    const char *initial_ptr;
+    char format_string[24]; /* max length may be something like  "% +-#032768.32768Ld" */
+    char *format_ptr;
+    int flag_plus, flag_minus, flag_space, flag_sharp, flag_zero;
+    int width, prec, modifier, approx_width;
+    char type;
+    /* most of those variables are here to rewrite the format string */
+    
+#define SRCTXT  (s->src_string)
+#define DESTTXT (s->dest_string)
+    
+    /* incoherent format string. Characters after the '%' will be printed with the next call */
+#define INCOHERENT()         do {SRCTXT=initial_ptr; return 0;} while (0)     /* do/while to avoid */
+#define INCOHERENT_TEST()    do {if(*SRCTXT==0)   INCOHERENT();} while (0)    /* a null statement  */
+    
+    /* 'normal' text */
+    if (*SRCTXT != '%')
+        return usual_char(s);
+    
+    /* we then have a '%' */
+    SRCTXT++;
+    /* don't check for end-of-string ; this is done later */
+    
+    /* '%%' escape sequence */
+    if (*SRCTXT == '%') {
+        if (realloc_buff(s, (size_t)1) == EOF) /* because we can have "%%%%%%%%..." */
+            return EOF;
+        *DESTTXT = '%';
+        DESTTXT++;
+        SRCTXT++;
+        (s->real_len)++;
+        (s->pseudo_len)++;
+        return 0;
+    }
+    
+    /* '%' managing */
+    initial_ptr = SRCTXT;   /* save current pointer in case of incorrect */
+    /* 'decoding'. Points just after the '%' so the '%' */
+    /* won't be printed in any case, as required. */
+    
+    /* flag */
+    flag_plus = flag_minus = flag_space = flag_sharp = flag_zero = 0;
+    
+    for (;; SRCTXT++) {
+        if (*SRCTXT == ' ')
+            flag_space = 1;
+        else if (*SRCTXT == '+')
+            flag_plus = 1;
+        else if (*SRCTXT == '-')
+            flag_minus = 1;
+        else if (*SRCTXT == '#')
+            flag_sharp = 1;
+        else if (*SRCTXT == '0')
+            flag_zero = 1;
+        else
+            break;
+    }
+    
+    INCOHERENT_TEST();    /* here is the first test for end of string */
+    
+    /* width */
+    if (*SRCTXT == '*') {         /* width given by next argument */
+        SRCTXT++;
+        width = va_arg(s->vargs, int);
+        if ((size_t)width > 0x3fffU) /* 'size_t' to check against negative values too */
+            width = 0x3fff;
+    } else if (isdigit((unsigned char)*SRCTXT)) /* width given as ASCII number */
+        width = getint(&SRCTXT);
+    else
+        width = -1;                 /* no width specified */
+    
+    INCOHERENT_TEST();
+    
+    /* .prec */
+    if (*SRCTXT == '.') {
+        SRCTXT++;
+        if (*SRCTXT == '*') {       /* .prec given by next argument */
+            SRCTXT++;
+            prec = va_arg(s->vargs, int);
+            if ((size_t)prec >= 0x3fffU) /* 'size_t' to check against negative values too */
+                prec = 0x3fff;
+        } else {                    /* .prec given as ASCII number */
+            if (isdigit((unsigned char)*SRCTXT) == 0)
+                INCOHERENT();
+            prec = getint(&SRCTXT);
+        }
+        INCOHERENT_TEST();
+    } else
+        prec = -1;                  /* no .prec specified */
+    
+    /* modifier */
+    if (*SRCTXT == 'L' || *SRCTXT == 'h' || *SRCTXT == 'l') {
+        modifier = *SRCTXT;
+        SRCTXT++;
+        if (modifier=='l' && *SRCTXT=='l') {
+            SRCTXT++;
+            modifier = 'L';  /* 'll' == 'L'      long long == long double */
+        } /* only for compatibility ; not portable */
+        INCOHERENT_TEST();
+    } else
+        modifier = -1;              /* no modifier specified */
+    
+    /* type */
+    type = *SRCTXT;
+    if (strchr("diouxXfegEGcspn",type) == NULL)
+        INCOHERENT();               /* unknown type */
+    SRCTXT++;
+    
+    /* rewrite format-string */
+    format_string[0] = '%';
+    format_ptr = &(format_string[1]);
+    
+    if (flag_plus) {
+        *format_ptr = '+';
+        format_ptr++;
+    }
+    if (flag_minus) {
+        *format_ptr = '-';
+        format_ptr++;
+    }
+    if (flag_space) {
+        *format_ptr = ' ';
+        format_ptr++;
+    }
+    if (flag_sharp) {
+        *format_ptr = '#';
+        format_ptr++;
+    }
+    if (flag_zero) {
+        *format_ptr = '0';
+        format_ptr++;
+    } /* '0' *must* be the last one */
+    
+    if (width != -1) {
+        sprintf(format_ptr, "%i", width);
+        format_ptr += strlen(format_ptr);
+    }
+    
+    if (prec != -1) {
+        *format_ptr = '.';
+        format_ptr++;
+        sprintf(format_ptr, "%i", prec);
+        format_ptr += strlen(format_ptr);
+    }
+    
+    if (modifier != -1) {
+        if (modifier == 'L' && strchr("diouxX",type) != NULL) {
+            *format_ptr = 'l';
+            format_ptr++;
+            *format_ptr = 'l';
+            format_ptr++;
+        } else {
+            *format_ptr = modifier;
+            format_ptr++;
+        }
+    }
+    
+    *format_ptr = type;
+    format_ptr++;
+    *format_ptr = 0;
+    
+    /* vague approximation of minimal length if width or prec are specified */
+    approx_width = width + prec;
+    if (approx_width < 0) /* because width == -1 and/or prec == -1 */
+        approx_width = 0;
+    
+    switch (type) {
+            /* int */
+        case 'd':
+        case 'i':
+        case 'o':
+        case 'u':
+        case 'x':
+        case 'X':
+            switch (modifier) {
+                case -1 :
+                    return print_it(s, (size_t)approx_width, format_string, va_arg(s->vargs, int));
+                case 'L':
+                    return print_it(s, (size_t)approx_width, format_string, va_arg(s->vargs, long long int));
+                case 'l':
+                    return print_it(s, (size_t)approx_width, format_string, va_arg(s->vargs, long int));
+                case 'h':
+                    return print_it(s, (size_t)approx_width, format_string, va_arg(s->vargs, int));
+                    /* 'int' instead of 'short int' because default promotion is 'int' */
+                default:
+                    INCOHERENT();
+            }
+            
+            /* char */
+        case 'c':
+            if (modifier != -1)
+                INCOHERENT();
+            return print_it(s, (size_t)approx_width, format_string, va_arg(s->vargs, int));
+            /* 'int' instead of 'char' because default promotion is 'int' */
+            
+            /* math */
+        case 'e':
+        case 'f':
+        case 'g':
+        case 'E':
+        case 'G':
+            switch (modifier) {
+                case -1 : /* because of default promotion, no modifier means 'l' */
+                case 'l':
+                    return print_it(s, (size_t)approx_width, format_string, va_arg(s->vargs, double));
+                case 'L':
+                    return print_it(s, (size_t)approx_width, format_string, va_arg(s->vargs, long double));
+                default:
+                    INCOHERENT();
+            }
+            
+            /* string */
+        case 's':
+            return type_s(s, width, prec, format_string, va_arg(s->vargs, const char*));
+            
+            /* pointer */
+        case 'p':
+            if (modifier == -1)
+                return print_it(s, (size_t)approx_width, format_string, va_arg(s->vargs, void *));
+            INCOHERENT();
+            
+            /* store */
+        case 'n':
+            if (modifier == -1) {
+                int * p;
+                p = va_arg(s->vargs, int *);
+                if (p != NULL) {
+                    *p = s->pseudo_len;
+                    return 0;
+                }
+                return EOF;
+            }
+            INCOHERENT();
+            
+    } /* switch */
+    
+    INCOHERENT();                 /* unknown type */
+    
+#undef INCOHERENT
+#undef INCOHERENT_TEST
+#undef SRCTXT
+#undef DESTTXT
+}
+
+/*
+ *  Return value: number of *virtually* written characters
+ *                EOF = error
+ */
+static int core(xprintf_struct *s)
+{
+    size_t len, save_len;
+    char *dummy_base;
+    
+    /* basic checks */
+    if ((int)(s->maxlen) <= 0) /* 'int' to check against some conversion */
+        return EOF;           /* error for example if value is (int)-10 */
+    s->maxlen--;      /* because initial maxlen counts final 0 */
+    /* note: now 'maxlen' _can_ be zero */
+    
+    if (s->src_string == NULL)
+        s->src_string = "(null)";
+    
+    /* struct init and memory allocation */
+    s->buffer_base = NULL;
+    s->buffer_len = 0;
+    s->real_len = 0;
+    s->pseudo_len = 0;
+    if (realloc_buff(s, (size_t)0) == EOF)
+        return EOF;
+    s->dest_string = s->buffer_base;
+    
+    /* process source string */
+    for (;;) {
+        /* up to end of source string */
+        if (*(s->src_string) == 0) {
+            *(s->dest_string) = 0;    /* final 0 */
+            len = s->real_len + 1;
+            break;
+        }
+        
+        if (dispatch(s) == EOF)
+            goto free_EOF;
+        
+        /* up to end of dest string */
+        if (s->real_len >= s->maxlen) {
+            (s->buffer_base)[s->maxlen] = 0; /* final 0 */
+            len = s->maxlen + 1;
+            break;
+        }
+    }
+    
+    /* for (v)asnprintf */
+    dummy_base = s->buffer_base;
+    save_len = 0;                 /* just to avoid a compiler warning */
+    
+    dummy_base = s->buffer_base + s->real_len;
+    save_len = s->real_len;
+    
+    /* process the remaining of source string to compute 'pseudo_len'. We
+     * overwrite again and again, starting at 'dummy_base' because we don't
+     * need the text, only char count. */
+    while(*(s->src_string) != 0) { /* up to end of source string */
+        s->real_len = 0;
+        s->dest_string = dummy_base;
+        if (dispatch(s) == EOF)
+            goto free_EOF;
+    }
+    
+    s->buffer_base = (char *)realloc((void *)(s->buffer_base), save_len + 1);
+    if (s->buffer_base == NULL)
+        return EOF; /* should rarely happen because we shrink the buffer */
+    return s->pseudo_len;
+    
+free_EOF:
+    if (s->buffer_base != NULL)
+        free(s->buffer_base);
+    return EOF;
+}
+
+int vasprintf(char **ptr, const char *format_string, va_list vargs)
+{
+    xprintf_struct s;
+    int retval;
+    
+    s.src_string = format_string;
+#ifdef va_copy
+    va_copy (s.vargs, vargs);
+#else
+#ifdef __va_copy
+    __va_copy (s.vargs, vargs);
+#else
+    memcpy (&s.vargs, vargs, sizeof (va_list));
+#endif /* __va_copy */
+#endif /* va_copy */
+    s.maxlen = (size_t)INT_MAX;
+    
+    retval = core(&s);
+    va_end(s.vargs);
+    if (retval == EOF) {
+        *ptr = NULL;
+        return EOF;
+    }
+    
+    *ptr = s.buffer_base;
+    return retval;
+}
+int asprintf(char **ptr, const char *fmt, ...)
+{
+    va_list vargs;
+    int retval;
+    
+    va_start(vargs, fmt);
+    retval = vasprintf(ptr, fmt, vargs);
+    va_end(vargs);
+    
+    return retval;
+}
+
 #if defined(__FreeBSD_kernel__)
 #include <bsd/bsd.h>
 #endif