lib/isc/string.c

	string.c revision 935000aa6e2b9d08f363b2e698a258a458a5a7cf
/*
 * Copyright (C) 1999-2001  Internet Software Consortium.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
 * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
 * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/* $Id: string.c,v 1.7 2003/04/10 04:46:27 marka Exp $ */

#include <config.h>

#include <ctype.h>

#include <isc/string.h>

static char digits[] = "0123456789abcdefghijklmnoprstuvwxyz";

isc_uint64_t
isc_string_touint64(char *source, char **end, int base) {
    isc_uint64_t tmp;
    isc_uint64_t overflow;
    char *s = source;
    char *o;
    char c;

    if ((base < 0) || (base == 1) || (base > 36)) {
        *end = source;
        return (0);
    }

    while (*s != 0 && isascii(*s&0xff) && isspace(*s&0xff))
        s++;
    if (*s == '+' /* || *s == '-' */)
        s++;
    if (base == 0) {
        if (*s == '0' && (*(s+1) == 'X' || *(s+1) == 'x')) {
            s += 2;
            base = 16;
        } else if (*s == '0')
            base = 8;
        else
            base = 10;
    }
    if (*s == 0) {
        *end = source;
        return (0);
    }
    overflow = ~0;
    overflow /= base;
    tmp = 0;

    while ((c = *s) != 0) {
        c = tolower(c);
        /* end ? */
        if ((o = strchr(digits, c)) == NULL) {
            *end = s;
            return (tmp);
        }
        /* end ? */
        if ((o - digits) >= base) {
            *end = s;
            return (tmp);
        }
        /* overflow ? */
        if (tmp > overflow) {
            *end = source;
            return (0);
        }
        tmp *= base;
        /* overflow ? */
        if ((tmp + (o - digits)) < tmp) {
            *end = source;
            return (0);
        }
        tmp += o - digits;
        s++;
    }
    *end = s;
    return (tmp);
}

char *
isc_string_separate(char **stringp, const char *delim) {
    char *string = *stringp;
    char *s;
    const char *d;
    char sc, dc;

    if (string == NULL)
        return (NULL);

    for (s = string; (sc = *s) != '\0'; s++)
        for (d = delim; (dc = *d) != '\0'; d++)
            if (sc == dc) {
                *s++ = '\0';
                *stringp = s;
                return (string);
            }
    *stringp = NULL;
    return (string);
}

size_t
strlcpy(char *dst, const char *src, size_t size)
{
    char *d = dst;
    const char *s = src;
    size_t n = size;

    /* Copy as many bytes as will fit */
    if (n != 0 && --n != 0) {
        do {
            if ((*d++ = *s++) == 0)
                break;
        } while (--n != 0);
    }

    /* Not enough room in dst, add NUL and traverse rest of src */
    if (n == 0) {
        if (size != 0)
            *d = '\0';      /* NUL-terminate dst */
        while (*s++)
            ;
    }

    return(s - src - 1);    /* count does not include NUL */
}

size_t
strlcat(char *dst, const char *src, size_t size)
{
    char *d = dst;
    const char *s = src;
    size_t n = size;
    size_t dlen;

    /* Find the end of dst and adjust bytes left but don't go past end */
    while (n-- != 0 && *d != '\0')
        d++;
    dlen = d - dst;
    n = size - dlen;

    if (n == 0)
        return(dlen + strlen(s));
    while (*s != '\0') {
        if (n != 1) {
            *d++ = *s;
            n--;
        }
        s++;
    }
    *d = '\0';

    return(dlen + (s - src));   /* count does not include NUL */
}