safe_ultostr.c

[詳解]

/*++
/* NAME
/*  safe_ultostr 3
/* SUMMARY
/*  convert unsigned long to safe string
/* SYNOPSIS
/*  #include <safe_ultostr.h>
/*
/*  char    *safe_ultostr(result, ulval, base, padlen, padchar)
/*  VSTRING *result;
/*  unsigned long ulval;
/*  int base;
/*  int padlen;
/*  int padchar;
/*
/*  unsigned long safe_strtoul(start, end, base)
/*  const char *start;
/*  char **end;
/*  int base;
/* DESCRIPTION
/*  The functions in this module perform conversions between
/*  unsigned long values and "safe" alphanumerical strings
/*  (strings with digits, uppercase letters and lowercase
/*  letters, but without the vowels AEIOUaeiou). Specifically,
/*  the characters B-Z represent the numbers 10-30, and b-z
/*  represent 31-51.
/*
/*  safe_ultostr() converts an unsigned long value to a safe
/*  alphanumerical string. This is the reverse of safe_strtoul().
/*
/*  safe_strtoul() implements similar functionality as strtoul()
/*  except that it uses a safe alphanumerical string as input,
/*  and that it supports no signs or 0/0x prefixes.
/*
/*  Arguments:
/* .IP result
/*  Buffer for storage of the result of conversion to string.
/* .IP ulval
/*  Unsigned long value.
/* .IP base
/*  Value between 2 and 52 inclusive.
/* .IP padlen
/* .IP padchar
/*  Left-pad a short result with padchar characters to the
/*  specified length.  Specify padlen=0 to disable padding.
/* .IP start
/*  Pointer to the first character of the string to be converted.
/* .IP end
/*  On return, pointer to the first character not in the input
/*  alphabet, or to the string terminator.
/* DIAGNOSTICS
/*  Fatal: out of memory.
/*
/*  safe_strtoul() returns (0, EINVAL) when no conversion could
/*  be performed, and (ULONG_MAX, ERANGE) in case of overflow.
/* LICENSE
/* .ad
/* .fi
/*  The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/*  Wietse Venema
/*  IBM T.J. Watson Research
/*  P.O. Box 704
/*  Yorktown Heights, NY 10598, USA
/*--*/

/* System library. */

#include <sys_defs.h>
#include <stdlib.h>
#include <limits.h>
#include <errno.h>
#include <ctype.h>

/* Utility library. */

#include <msg.h>
#include <vstring.h>
#include <mymalloc.h>

/* Global library. */

#include <safe_ultostr.h>

/* Application-specific. */

#define STR vstring_str
#define END vstring_end
#define SWAP(type, a, b) { type temp; temp = a; a = b; b = temp; }

static unsigned char safe_chars[] =
"0123456789BCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz";

#define SAFE_MAX_BASE   (sizeof(safe_chars) - 1)
#define SAFE_MIN_BASE   (2)

/* safe_ultostr - convert unsigned long to safe alphanumerical string */

char   *safe_ultostr(VSTRING *buf, unsigned long ulval, int base,
                     int padlen, int padchar)
{
    const char *myname = "safe_ultostr";
    char   *start;
    char   *last;
    int     i;

    /*
     * Sanity check.
     */
    if (base < SAFE_MIN_BASE || base > SAFE_MAX_BASE)
    msg_panic("%s: bad base: %d", myname, base);

    /*
     * First accumulate the result, backwards.
     */
    VSTRING_RESET(buf);
    while (ulval != 0) {
    VSTRING_ADDCH(buf, safe_chars[ulval % base]);
    ulval /= base;
    }
    while (VSTRING_LEN(buf) < padlen)
    VSTRING_ADDCH(buf, padchar);
    VSTRING_TERMINATE(buf);

    /*
     * Then, reverse the result.
     */
    start = STR(buf);
    last = END(buf) - 1;
    for (i = 0; i < VSTRING_LEN(buf) / 2; i++)
    SWAP(int, start[i], last[-i]);
    return (STR(buf));
}

/* safe_strtoul - convert safe alphanumerical string to unsigned long */

unsigned long safe_strtoul(const char *start, char **end, int base)
{
    const char *myname = "safe_strtoul";
    static unsigned char *char_map = 0;
    unsigned char *cp;
    unsigned long sum;
    unsigned long div_limit;
    unsigned long mod_limit;
    int     char_val;

    /*
     * Sanity check.
     */
    if (base < SAFE_MIN_BASE || base > SAFE_MAX_BASE)
    msg_panic("%s: bad base: %d", myname, base);

    /*
     * One-time initialization. Assume 8-bit bytes.
     */
    if (char_map == 0) {
    char_map = (unsigned char *) mymalloc(256);
    for (char_val = 0; char_val < 256; char_val++)
        char_map[char_val] = SAFE_MAX_BASE;
    for (char_val = 0; char_val < SAFE_MAX_BASE; char_val++)
        char_map[safe_chars[char_val]] = char_val;
    }

    /*
     * Per-call initialization.
     */
    sum = 0;
    div_limit = ULONG_MAX / base;
    mod_limit = ULONG_MAX % base;

    /*
     * Skip leading whitespace. We don't implement sign/base prefixes.
     */
    if (end)
    *end = (char *) start;
    while (ISSPACE(*start))
    ++start;

    /*
     * Start the conversion.
     */
    errno = 0;
    for (cp = (unsigned char *) start; (char_val = char_map[*cp]) < base; cp++) {
    /* Return (ULONG_MAX, ERANGE) if the result is too large. */
    if (sum > div_limit
        || (sum == div_limit && char_val > mod_limit)) {
        sum = ULONG_MAX;
        errno = ERANGE;
        /* Skip "valid" characters, per the strtoul() spec. */
        while (char_map[*++cp] < base)
         /* void */ ;
        break;
    }
    sum = sum * base + char_val;
    }
    /* Return (0, EINVAL) after no conversion. Test moved here 20131209. */
    if (cp == (unsigned char *) start)
    errno = EINVAL;
    else if (end)
    *end = (char *) cp;
    return (sum);
}

#ifdef TEST

 /*
  * Proof-of-concept test program. Read a number from stdin, convert to
  * string, and print the result.
  */
#include <stdio.h>          /* sscanf */
#include <vstream.h>
#include <vstring_vstream.h>

int     main(int unused_argc, char **unused_argv)
{
    VSTRING *buf = vstring_alloc(100);
    char   *junk;
    unsigned long ulval;
    int     base;
    char    ch;
    unsigned long ulval2;

#ifdef MISSING_STRTOUL
#define strtoul strtol
#endif

    /*
     * Hard-coded string-to-number test.
     */
    ulval2 = safe_strtoul("  ", &junk, 10);
    if (*junk == 0 || errno != EINVAL)
    msg_warn("input=' ' result=%lu errno=%m", ulval2);

    /*
     * Configurable number-to-string-to-number test.
     */
    while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) {
    ch = 0;
    if (sscanf(STR(buf), "%lu %d%c", &ulval, &base, &ch) != 2 || ch) {
        msg_warn("bad input %s", STR(buf));
    } else {
        (void) safe_ultostr(buf, ulval, base, 5, '0');
        vstream_printf("%lu = %s\n", ulval, STR(buf));
        ulval2 = safe_strtoul(STR(buf), &junk, base);
        if (*junk || (ulval2 == ULONG_MAX && errno == ERANGE))
        msg_warn("%s: %m", STR(buf));
        if (ulval2 != ulval)
        msg_warn("%lu != %lu", ulval2, ulval);
    }
    vstream_fflush(VSTREAM_OUT);
    }
    vstring_free(buf);
    return (0);
}

#endif