strings.c

Go to the documentation of this file.

/*
 ** Copyright (C) 2008 INL
 ** Written by Sebastien Tricaud <s.tricaud@inl.fr>
 ** INL http://www.inl.fr/
 **
 ** $Id: strings.c 4847 2008-06-13 14:48:31Z regit $
 **
 ** 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, version 3 of the License.
 **
 ** 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 <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <ctype.h>         /* isspace() */

#include <nubase.h>

int secure_snprintf(char *buffer, size_t buffer_size,
                         char *format, ...)
{
        va_list args;
        int ret;
        va_start(args, format);
#ifdef DEBUG_ENABLE
        memset(buffer, 0, buffer_size);
#else
        buffer[0] = 0;
#endif
        ret = vsnprintf(buffer, buffer_size, format, args);
        va_end(args);
        buffer[buffer_size - 1] = '\0';
        if (0 <= ret && ret <= ((int) buffer_size - 1))
                return TRUE;
        else
                return FALSE;
}

char *str_extract_until(char *str, int c)
{
        unsigned int i;

        char *newstr;
        char *last_str;

        size_t last_size;
        size_t str_size;
        size_t newstr_size;

        last_str = strrchr(str, c);
        if ( ! last_str ) return NULL;
        last_size = strlen(last_str);
        str_size = strlen(str);
        newstr_size = str_size - last_size;
        newstr = malloc(newstr_size + 2);
        if ( ! newstr ) return NULL;

        for (i=0;i<newstr_size;i++) {
                newstr[i] = *str++;
        }

        newstr[i] = c;
        newstr[i+1] = '\0';

        return newstr;

}

int str_to_long(const char *text, long *value)
{
        char *err = NULL;
        long longvalue;

        /* skip spaces */
        while (isspace(*text))
                text++;

        /* call strtol */
        longvalue = strtol(text, &err, 10);
        if (err == NULL || *err != 0)
                return 0;
        *value = longvalue;
        return 1;
}

int str_to_ulong(const char *text, unsigned long *value)
{
        char *err = NULL;
        unsigned long ulongvalue;

        /* skip spaces */
        while (isspace(*text))
                text++;

        /* call strtol */
        ulongvalue = strtoul(text, &err, 10);
        if (err == NULL || *err != 0)
                return 0;
        *value = ulongvalue;
        return 1;
}

int str_to_int(const char *text, int *value)
{
        long longvalue;
        if (!str_to_long(text, &longvalue))
                return 0;
        if (longvalue < INT_MIN || INT_MAX < longvalue)
                return 0;
        *value = (int)longvalue;
        return 1;
}

int str_to_uint32(const char *text, uint32_t * value)
{
        unsigned long ulongvalue;
        if (!str_to_ulong(text, &ulongvalue))
                return 0;
        if (4294967295UL < ulongvalue)
                return 0;
        *value = (uint32_t)ulongvalue;
        return 1;
}

char *str_itoa(int i)
{

        char *str;
        int strsize;
        int ret;

        strsize = snprintf(NULL, 0, "%d", i);
        if ( strsize <= 0 ) return strdup("");
        str = malloc(strsize + 1);
        if ( ! str ) return strdup("");
        ret = snprintf(str, strsize + 1, "%d", i);
        if ( ret <= 0 ) return strdup("");

        str[ret] = '\0';

        return str;
}

---