#include <LibConfig.h>

#include <string.h>

#include <fcntl.h>

#include <sys/syslimits.h>

#ifndef HAVE_GETOPT

char *optarg;

int optind = 1;

getopt(int argc, char **argv, char *args)

{

size_t n;

size_t nlen = strlen(args);

char cmd;

char rv;

if (argv[optind] && *argv[optind] == '-') {

cmd = *(argv[optind] + 1);

for (n = 0; n < nlen; n++) {

if (args[n] == ':')

continue;

if (args[n] == cmd) {

rv = *(argv[optind] + 1);

if (args[n+1] == ':') {

if (*(argv[optind] + 2) != '\0') {

optarg = argv[optind] + 2;

optind += 1;

} else {

optarg = argv[optind + 1];

optind += 2;

}

if (!optarg)

optarg="";

return rv;

} else {

optarg = NULL;

optind += 1;

return rv;

}

}

}

}

return -1;

}

#endif

#define ISPATHSEPARATOR(x) ((x == '/') || (x == '\\'))

#ifdef HAVE_BASENAME

#ifndef PATH_MAX

#define PATH_MAX 5000

#endif

char *

basename(char *path)

{

static char singledot[] = ".";

static char result[PATH_MAX];

char *p, *lastp;

size_t len;

/*

if ((path == NULL) || (*path == '\0'))

return (singledot);

/* Strip trailing slashes, if any. */

lastp = path + strlen(path) - 1;

while (lastp != path && ISPATHSEPARATOR(*lastp))

lastp--;

/* Now find the beginning of this (final) component. */

p = lastp;

while (p != path && !ISPATHSEPARATOR(*(p - 1)))

p--;

/* ...and copy the result into the result buffer. */

len = (lastp - p) + 1 /* last char */;

if (len > (PATH_MAX - 1))

len = PATH_MAX - 1;

memcpy(result, p, len);

result[len] = '\0';

return (result);

}

#endif

#if !defined(HAVE_MKSTEMP) && !defined(WIN32)

mkstemp(char *path)

{

char *start, *trv;

unsigned int pid;

/* To guarantee multiple calls generate unique names even if

static char xtra[2] = "aa";

int xcnt = 0;

pid = getpid();

/* Move to end of path and count trailing X's. */

for (trv = path; *trv; ++trv)

if (*trv == 'X')

xcnt++;

else

xcnt = 0;

/* Use at least one from xtra. Use 2 if more than 6 X's. */

if (*(trv - 1) == 'X')

*--trv = xtra[0];

if (xcnt > 6 && *(trv - 1) == 'X')

*--trv = xtra[1];

/* Set remaining X's to pid digits with 0's to the left. */

while (*--trv == 'X') {

*trv = (pid % 10) + '0';

pid /= 10;

}

/* update xtra for next call. */

if (xtra[0] != 'z')

xtra[0]++;

else {

xtra[0] = 'a';

if (xtra[1] != 'z')

xtra[1]++;

else

xtra[1] = 'a';

}

return open(path, O_CREAT | O_EXCL | O_RDWR, 0600);

}

#endif

#ifdef HAVE_FFS

ffs(int x)

{

int r = 1;

if (!x) return 0;

if (!(x & 0xffff)) { x >>= 16; r += 16; }

if (!(x & 0xff)) { x >>= 8; r += 8; }

if (!(x & 0xf)) { x >>= 4; r += 4; }

if (!(x & 3)) { x >>= 2; r += 2; }

if (!(x & 1)) { x >>= 1; r += 1; }

return r;

}

#endif

#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)

static void

dopr(char *buffer, size_t maxlen, const char *format, va_list args);

static void

fmtstr(char *buffer, size_t *currlen, size_t maxlen, char *value, int flags,

int min, int max);

static void

fmtint(char *buffer, size_t *currlen, size_t maxlen, long value, int base,

int min, int max, int flags);

static void

fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue,

int min, int max, int flags);

static void

dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);

#define DP_S_DEFAULT 0

#define DP_S_FLAGS 1

#define DP_S_MIN 2

#define DP_S_DOT 3

#define DP_S_MAX 4

#define DP_S_MOD 5

#define DP_S_CONV 6

#define DP_S_DONE 7

#define DP_F_MINUS (1 << 0)

#define DP_F_PLUS (1 << 1)

#define DP_F_SPACE (1 << 2)

#define DP_F_NUM (1 << 3)

#define DP_F_ZERO (1 << 4)

#define DP_F_UP (1 << 5)

#define DP_F_UNSIGNED (1 << 6)

#define DP_C_SHORT 1

#define DP_C_LONG 2

#define DP_C_LDOUBLE 3

#define DP_C_LONG_LONG 4

#define char_to_int(p) (p - '0')

#define abs_val(p) (p < 0 ? -p : p)

static void

dopr(char *buffer, size_t maxlen, const char *format, va_list args)

{

char *strvalue, ch;

long value;

long double fvalue;

int min = 0, max = -1, state = DP_S_DEFAULT, flags = 0, cflags = 0;

size_t currlen = 0;

ch = *format++;

while (state != DP_S_DONE) {

if ((ch == '\0') || (currlen >= maxlen))

state = DP_S_DONE;

switch(state) {

case DP_S_DEFAULT:

if (ch == '%')

state = DP_S_FLAGS;

else

dopr_outch(buffer, &currlen, maxlen, ch);

ch = *format++;

break;

case DP_S_FLAGS:

switch (ch) {

case '-':

flags |= DP_F_MINUS;

ch = *format++;

break;

case '+':

flags |= DP_F_PLUS;

ch = *format++;

break;

case ' ':

flags |= DP_F_SPACE;

ch = *format++;

break;

case '#':

flags |= DP_F_NUM;

ch = *format++;

break;

case '0':

flags |= DP_F_ZERO;

ch = *format++;

break;

default:

state = DP_S_MIN;

break;

}

break;

case DP_S_MIN:

if (isdigit((unsigned char)ch)) {

min = 10 * min + char_to_int (ch);

ch = *format++;

} else if (ch == '*') {

min = va_arg (args, int);

ch = *format++;

state = DP_S_DOT;

} else

state = DP_S_DOT;

break;

case DP_S_DOT:

if (ch == '.') {

state = DP_S_MAX;

ch = *format++;

} else

state = DP_S_MOD;

break;

case DP_S_MAX:

if (isdigit((unsigned char)ch)) {

if (max < 0)

max = 0;

max = 10 * max + char_to_int(ch);

ch = *format++;

} else if (ch == '*') {

max = va_arg (args, int);

ch = *format++;

state = DP_S_MOD;

} else

state = DP_S_MOD;

break;

case DP_S_MOD:

switch (ch) {

case 'h':

cflags = DP_C_SHORT;

ch = *format++;

break;

case 'l':

cflags = DP_C_LONG;

ch = *format++;

if (ch == 'l') {

cflags = DP_C_LONG_LONG;

ch = *format++;

}

break;

case 'q':

cflags = DP_C_LONG_LONG;

ch = *format++;

break;

case 'L':

cflags = DP_C_LDOUBLE;

ch = *format++;

break;

default:

break;

}

state = DP_S_CONV;

break;

case DP_S_CONV:

switch (ch) {

case 'd':

case 'i':

if (cflags == DP_C_SHORT)

value = va_arg(args, int);

else if (cflags == DP_C_LONG)

value = va_arg(args, long int);

else if (cflags == DP_C_LONG_LONG)

value = va_arg (args, long long);

else

value = va_arg (args, int);

fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);

break;

case 'o':

flags |= DP_F_UNSIGNED;

if (cflags == DP_C_SHORT)

value = va_arg(args, unsigned int);

else if (cflags == DP_C_LONG)

value = va_arg(args, unsigned long int);

else if (cflags == DP_C_LONG_LONG)

value = va_arg(args, unsigned long long);

else

value = va_arg(args, unsigned int);

fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);

break;

case 'u':

flags |= DP_F_UNSIGNED;

if (cflags == DP_C_SHORT)

value = va_arg(args, unsigned int);

else if (cflags == DP_C_LONG)

value = va_arg(args, unsigned long int);

else if (cflags == DP_C_LONG_LONG)

value = va_arg(args, unsigned long long);

else

value = va_arg(args, unsigned int);

fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);

break;

case 'X':

flags |= DP_F_UP;

case 'x':

flags |= DP_F_UNSIGNED;

if (cflags == DP_C_SHORT)

value = va_arg(args, unsigned int);

else if (cflags == DP_C_LONG)

value = va_arg(args, unsigned long int);

else if (cflags == DP_C_LONG_LONG)

value = va_arg(args, unsigned long long);

else

value = va_arg(args, unsigned int);

fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags);

break;

case 'f':

if (cflags == DP_C_LDOUBLE)

fvalue = va_arg(args, long double);

else

fvalue = va_arg(args, double);

/* um, floating point? */

fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);

break;

case 'E':

flags |= DP_F_UP;

case 'e':

if (cflags == DP_C_LDOUBLE)

fvalue = va_arg(args, long double);

else

fvalue = va_arg(args, double);

break;

case 'G':

flags |= DP_F_UP;

case 'g':

if (cflags == DP_C_LDOUBLE)

fvalue = va_arg(args, long double);

else

fvalue = va_arg(args, double);

break;

case 'c':

dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));

break;

case 's':

strvalue = va_arg(args, char *);

if (max < 0)

max = maxlen; /* ie, no max */

fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);

break;

case 'p':

strvalue = va_arg(args, void *);

fmtint(buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);

break;

case 'n':

if (cflags == DP_C_SHORT) {

short int *num;

num = va_arg(args, short int *);

*num = currlen;

} else if (cflags == DP_C_LONG) {

long int *num;

num = va_arg(args, long int *);

*num = currlen;

} else if (cflags == DP_C_LONG_LONG) {

long long *num;

num = va_arg(args, long long *);

*num = currlen;

} else {

int *num;

num = va_arg(args, int *);

*num = currlen;

}

break;

case '%':

dopr_outch(buffer, &currlen, maxlen, ch);

break;

case 'w': /* not supported yet, treat as next char */

ch = *format++;

break;

default: /* Unknown, skip */

break;

}

ch = *format++;

state = DP_S_DEFAULT;

flags = cflags = min = 0;

max = -1;

break;

case DP_S_DONE:

break;

default: /* hmm? */

break; /* some picky compilers need this */

}

}

if (currlen < maxlen - 1)

buffer[currlen] = '\0';

else

buffer[maxlen - 1] = '\0';

}

static void

fmtstr(char *buffer, size_t *currlen, size_t maxlen,

char *value, int flags, int min, int max)

{

int cnt = 0, padlen, strln; /* amount to pad */

if (value == 0)

value = "<NULL>";

for (strln = 0; value[strln]; ++strln); /* strlen */

padlen = min - strln;

if (padlen < 0)

padlen = 0;

if (flags & DP_F_MINUS)

padlen = -padlen; /* Left Justify */

while ((padlen > 0) && (cnt < max)) {

dopr_outch(buffer, currlen, maxlen, ' ');

--padlen;

++cnt;

}

while (*value && (cnt < max)) {

dopr_outch(buffer, currlen, maxlen, *value++);

++cnt;

}

while ((padlen < 0) && (cnt < max)) {

dopr_outch(buffer, currlen, maxlen, ' ');

++padlen;

++cnt;

}

}

static void

fmtint(char *buffer, size_t *currlen, size_t maxlen,

long value, int base, int min, int max, int flags)

{

unsigned long uvalue;

char convert[20];

int signvalue = 0, place = 0, caps = 0;

int spadlen = 0; /* amount to space pad */

int zpadlen = 0; /* amount to zero pad */

#define PADMAX(x,y) ((x) > (y) ? (x) : (y))

if (max < 0)

max = 0;

uvalue = value;

if (!(flags & DP_F_UNSIGNED)) {

if (value < 0) {

signvalue = '-';

uvalue = -value;

} else if (flags & DP_F_PLUS) /* Do a sign (+/i) */

signvalue = '+';

else if (flags & DP_F_SPACE)

signvalue = ' ';

}

if (flags & DP_F_UP)

caps = 1; /* Should characters be upper case? */

do {

convert[place++] =

(caps ? "0123456789ABCDEF" : "0123456789abcdef")

[uvalue % (unsigned)base];

uvalue = (uvalue / (unsigned)base );

} while (uvalue && (place < 20));

if (place == 20)

place--;

convert[place] = 0;

zpadlen = max - place;

spadlen = min - PADMAX(max, place) - (signvalue ? 1 : 0);

if (zpadlen < 0)

zpadlen = 0;

if (spadlen < 0)

spadlen = 0;

if (flags & DP_F_ZERO) {

zpadlen = PADMAX(zpadlen, spadlen);

spadlen = 0;

}

if (flags & DP_F_MINUS)

spadlen = -spadlen; /* Left Justifty */

/* Spaces */

while (spadlen > 0) {

dopr_outch(buffer, currlen, maxlen, ' ');

--spadlen;

}

/* Sign */

if (signvalue)

dopr_outch(buffer, currlen, maxlen, signvalue);

/* Zeros */

if (zpadlen > 0) {

while (zpadlen > 0) {

dopr_outch(buffer, currlen, maxlen, '0');

--zpadlen;

}

}

/* Digits */

while (place > 0)

dopr_outch(buffer, currlen, maxlen, convert[--place]);

/* Left Justified spaces */

while (spadlen < 0) {

dopr_outch (buffer, currlen, maxlen, ' ');

++spadlen;

}

}

static long double

pow10(int exp)

{

long double result = 1;

while (exp) {

result *= 10;

exp--;

}

return result;

}

static long

round(long double value)

{

long intpart = value;

value -= intpart;

if (value >= 0.5)

intpart++;

return intpart;

}

static void

fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue,

int min, int max, int flags)

{

char iconvert[20], fconvert[20];

int signvalue = 0, iplace = 0, fplace = 0;

int padlen = 0; /* amount to pad */

int zpadlen = 0, caps = 0;

long intpart, fracpart;

long double ufvalue;

/*

if (max < 0)

max = 6;

ufvalue = abs_val(fvalue);

if (fvalue < 0)

signvalue = '-';

else if (flags & DP_F_PLUS) /* Do a sign (+/i) */

signvalue = '+';

else if (flags & DP_F_SPACE)

signvalue = ' ';

intpart = ufvalue;

/*

if (max > 9)

max = 9;

/* We "cheat" by converting the fractional part to integer by

fracpart = round((pow10 (max)) * (ufvalue - intpart));

if (fracpart >= pow10 (max)) {

intpart++;

fracpart -= pow10 (max);

}

/* Convert integer part */

do {

iconvert[iplace++] =

(caps ? "0123456789ABCDEF" : "0123456789abcdef")

[intpart % 10];

intpart = (intpart / 10);

} while(intpart && (iplace < 20));

if (iplace == 20)

iplace--;

iconvert[iplace] = 0;

/* Convert fractional part */

do {

fconvert[fplace++] =

(caps ? "0123456789ABCDEF" : "0123456789abcdef")

[fracpart % 10];

fracpart = (fracpart / 10);

} while(fracpart && (fplace < 20));

if (fplace == 20)

fplace--;

fconvert[fplace] = 0;

/* -1 for decimal point, another -1 if we are printing a sign */

padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);

zpadlen = max - fplace;

if (zpadlen < 0)

zpadlen = 0;

if (padlen < 0)

padlen = 0;

if (flags & DP_F_MINUS)

padlen = -padlen; /* Left Justifty */

if ((flags & DP_F_ZERO) && (padlen > 0)) {

if (signvalue) {

dopr_outch(buffer, currlen, maxlen, signvalue);

--padlen;

signvalue = 0;

}

while (padlen > 0) {

dopr_outch(buffer, currlen, maxlen, '0');

--padlen;

}

}

while (padlen > 0) {

dopr_outch(buffer, currlen, maxlen, ' ');

--padlen;

}

if (signvalue)

dopr_outch(buffer, currlen, maxlen, signvalue);

while (iplace > 0)

dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]);

/*

dopr_outch(buffer, currlen, maxlen, '.');

while (fplace > 0)

dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);

while (zpadlen > 0) {

dopr_outch(buffer, currlen, maxlen, '0');

--zpadlen;

}

while (padlen < 0) {

dopr_outch(buffer, currlen, maxlen, ' ');

++padlen;

}

}

static void

dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)

{

if (*currlen < maxlen)

buffer[(*currlen)++] = c;

}

#endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */

#ifndef HAVE_VSNPRINTF

vsnprintf(char *str, size_t count, const char *fmt, va_list args)

{

str[0] = 0;

dopr(str, count, fmt, args);

return(strlen(str));

}

#endif /* !HAVE_VSNPRINTF */

#ifndef HAVE_SNPRINTF

snprintf(char *str,size_t count,const char *fmt,...)

{

va_list ap;

va_start(ap, fmt);

(void) vsnprintf(str, count, fmt, ap);

va_end(ap);

return(strlen(str));

}

#endif /* !HAVE_SNPRINTF */