From c8b79bf686113c3418d8d65ff0a1920da2b409bc Mon Sep 17 00:00:00 2001 From: Micah Anderson Date: Thu, 14 Nov 2013 16:35:32 -0500 Subject: initial commit --- scrypt-1.1.6/lib/util/memlimit.c | 343 ++++++++++++++++++++++++++++++++++++++ scrypt-1.1.6/lib/util/memlimit.h | 42 +++++ scrypt-1.1.6/lib/util/readpass.h | 45 +++++ scrypt-1.1.6/lib/util/sysendian.h | 140 ++++++++++++++++ scrypt-1.1.6/lib/util/warn.c | 75 +++++++++ scrypt-1.1.6/lib/util/warn.h | 13 ++ 6 files changed, 658 insertions(+) create mode 100644 scrypt-1.1.6/lib/util/memlimit.c create mode 100644 scrypt-1.1.6/lib/util/memlimit.h create mode 100644 scrypt-1.1.6/lib/util/readpass.h create mode 100644 scrypt-1.1.6/lib/util/sysendian.h create mode 100644 scrypt-1.1.6/lib/util/warn.c create mode 100644 scrypt-1.1.6/lib/util/warn.h (limited to 'scrypt-1.1.6/lib/util') diff --git a/scrypt-1.1.6/lib/util/memlimit.c b/scrypt-1.1.6/lib/util/memlimit.c new file mode 100644 index 0000000..6268163 --- /dev/null +++ b/scrypt-1.1.6/lib/util/memlimit.c @@ -0,0 +1,343 @@ +/*- + * Copyright 2009 Colin Percival + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file was originally written by Colin Percival as part of the Tarsnap + * online backup system. + */ +#include "scrypt_platform.h" + +#include + +#ifndef _WIN32 +#include +#endif + +#ifdef _WIN32 +#define _WIN32_WINNT 0x0502 +#include +#include +#endif + +#ifdef HAVE_SYS_PARAM_H +#include +#endif +#ifdef HAVE_SYSCTL_HW_USERMEM +#include +#endif +#ifdef HAVE_SYS_SYSINFO_H +#include +#endif + +#include +#include +#include +#include + +#ifdef DEBUG +#include +#endif + +#include "memlimit.h" + +#ifdef HAVE_SYSCTL_HW_USERMEM +static int +memlimit_sysctl_hw_usermem(size_t * memlimit) +{ + int mib[2]; + uint8_t usermembuf[8]; + size_t usermemlen = 8; + uint64_t usermem; + + /* Ask the kernel how much RAM we have. */ + mib[0] = CTL_HW; + mib[1] = HW_USERMEM; + if (sysctl(mib, 2, usermembuf, &usermemlen, NULL, 0)) + return (1); + + /* + * Parse as either a uint64_t or a uint32_t based on the length of + * output the kernel reports having copied out. It appears that all + * systems providing a sysctl interface for reading integers copy + * them out as system-endian values, so we don't need to worry about + * parsing them. + */ + if (usermemlen == sizeof(uint64_t)) + usermem = *(uint64_t *)usermembuf; + else if (usermemlen == sizeof(uint32_t)) + usermem = *(uint32_t *)usermembuf; + else + return (1); + + /* Return the sysctl value, but clamp to SIZE_MAX if necessary. */ +#if UINT64_MAX > SIZE_MAX + if (usermem > SIZE_MAX) + *memlimit = SIZE_MAX; + else + *memlimit = usermem; +#else + *memlimit = usermem; +#endif + + /* Success! */ + return (0); +} +#endif + +/* If we don't HAVE_STRUCT_SYSINFO, we can't use sysinfo. */ +#ifndef HAVE_STRUCT_SYSINFO +#undef HAVE_SYSINFO +#endif + +/* If we don't HAVE_STRUCT_SYSINFO_TOTALRAM, we can't use sysinfo. */ +#ifndef HAVE_STRUCT_SYSINFO_TOTALRAM +#undef HAVE_SYSINFO +#endif + +#ifdef HAVE_SYSINFO +static int +memlimit_sysinfo(size_t * memlimit) +{ + struct sysinfo info; + uint64_t totalmem; + + /* Get information from the kernel. */ + if (sysinfo(&info)) + return (1); + totalmem = info.totalram; + + /* If we're on a modern kernel, adjust based on mem_unit. */ +#ifdef HAVE_STRUCT_SYSINFO_MEM_UNIT + totalmem = totalmem * info.mem_unit; +#endif + + /* Return the value, but clamp to SIZE_MAX if necessary. */ +#if UINT64_MAX > SIZE_MAX + if (totalmem > SIZE_MAX) + *memlimit = SIZE_MAX; + else + *memlimit = totalmem; +#else + *memlimit = totalmem; +#endif + + /* Success! */ + return (0); +} +#endif /* HAVE_SYSINFO */ + +#ifndef _WIN32 +static int +memlimit_rlimit(size_t * memlimit) +{ + struct rlimit rl; + uint64_t memrlimit; + + /* Find the least of... */ + memrlimit = (uint64_t)(-1); + + /* ... RLIMIT_AS... */ +#ifdef RLIMIT_AS + if (getrlimit(RLIMIT_AS, &rl)) + return (1); + if ((rl.rlim_cur != RLIM_INFINITY) && + ((uint64_t)rl.rlim_cur < memrlimit)) + memrlimit = rl.rlim_cur; +#endif + + /* ... RLIMIT_DATA... */ + if (getrlimit(RLIMIT_DATA, &rl)) + return (1); + if ((rl.rlim_cur != RLIM_INFINITY) && + ((uint64_t)rl.rlim_cur < memrlimit)) + memrlimit = rl.rlim_cur; + + /* ... and RLIMIT_RSS. */ +#ifdef RLIMIT_RSS + if (getrlimit(RLIMIT_RSS, &rl)) + return (1); + if ((rl.rlim_cur != RLIM_INFINITY) && + ((uint64_t)rl.rlim_cur < memrlimit)) + memrlimit = rl.rlim_cur; +#endif + + /* Return the value, but clamp to SIZE_MAX if necessary. */ +#if UINT64_MAX > SIZE_MAX + if (memrlimit > SIZE_MAX) + *memlimit = SIZE_MAX; + else + *memlimit = memrlimit; +#else + *memlimit = memrlimit; +#endif + + /* Success! */ + return (0); +} +#endif + +#ifdef _SC_PHYS_PAGES + +/* Some systems define _SC_PAGESIZE instead of _SC_PAGE_SIZE. */ +#ifndef _SC_PAGE_SIZE +#define _SC_PAGE_SIZE _SC_PAGESIZE +#endif + +static int +memlimit_sysconf(size_t * memlimit) +{ + long pagesize; + long physpages; + uint64_t totalmem; + + /* Set errno to 0 in order to distinguish "no limit" from "error". */ + errno = 0; + + /* Read the two limits. */ + if (((pagesize = sysconf(_SC_PAGE_SIZE)) == -1) || + ((physpages = sysconf(_SC_PHYS_PAGES)) == -1)) { + /* Did an error occur? */ + if (errno != 0) + return (1); + + /* If not, there is no limit. */ + totalmem = (uint64_t)(-1); + } else { + /* Compute the limit. */ + totalmem = (uint64_t)(pagesize) * (uint64_t)(physpages); + } + + /* Return the value, but clamp to SIZE_MAX if necessary. */ +#if UINT64_MAX > SIZE_MAX + if (totalmem > SIZE_MAX) + *memlimit = SIZE_MAX; + else + *memlimit = totalmem; +#else + *memlimit = totalmem; +#endif + + /* Success! */ + return (0); +} +#endif + +#ifdef _WIN32 +static int +memlimit_windows(size_t * memlimit) +{ + MEMORYSTATUSEX state; + state.dwLength = sizeof(state); + + if(!GlobalMemoryStatusEx (&state)) + return (1); + + + *memlimit = state.ullTotalPhys; + return (0); + +} +#endif + +int +memtouse(size_t maxmem, double maxmemfrac, size_t * memlimit) +{ + size_t sysctl_memlimit, sysinfo_memlimit, rlimit_memlimit; + size_t sysconf_memlimit; + size_t memlimit_min; + size_t memavail; + size_t windows_memlimit; + + /* Get memory limits. */ +#ifdef HAVE_SYSCTL_HW_USERMEM + if (memlimit_sysctl_hw_usermem(&sysctl_memlimit)) + return (1); +#else + sysctl_memlimit = (size_t)(-1); +#endif +#ifdef HAVE_SYSINFO + if (memlimit_sysinfo(&sysinfo_memlimit)) + return (1); +#else + sysinfo_memlimit = (size_t)(-1); +#endif +#ifndef _WIN32 + if (memlimit_rlimit(&rlimit_memlimit)) + return (1); +#else + rlimit_memlimit=(size_t)(-1); +#endif +#ifdef _SC_PHYS_PAGES + if (memlimit_sysconf(&sysconf_memlimit)) + return (1); +#else + sysconf_memlimit = (size_t)(-1); +#endif +#ifdef _WIN32 + if (memlimit_windows(&windows_memlimit)) + return (1); +#else + windows_memlimit=(size_t)(-1); +#endif + +#ifdef DEBUG + fprintf(stderr, "Memory limits are %u %u %u %u %u\n", + sysctl_memlimit, sysinfo_memlimit, rlimit_memlimit, + sysconf_memlimit, windows_memlimit); +#endif + + /* Find the smallest of them. */ + memlimit_min = (size_t)(-1); + if (memlimit_min > sysctl_memlimit) + memlimit_min = sysctl_memlimit; + if (memlimit_min > sysinfo_memlimit) + memlimit_min = sysinfo_memlimit; + if (memlimit_min > rlimit_memlimit) + memlimit_min = rlimit_memlimit; + if (memlimit_min > sysconf_memlimit) + memlimit_min = sysconf_memlimit; + if (memlimit_min > windows_memlimit) + memlimit_min = windows_memlimit; + + /* Only use the specified fraction of the available memory. */ + if ((maxmemfrac > 0.5) || (maxmemfrac == 0.0)) + maxmemfrac = 0.5; + memavail = maxmemfrac * memlimit_min; + + /* Don't use more than the specified maximum. */ + if ((maxmem > 0) && (memavail > maxmem)) + memavail = maxmem; + + /* But always allow at least 1 MiB. */ + if (memavail < 1048576) + memavail = 1048576; + +#ifdef DEBUG + fprintf(stderr, "Allowing up to %u memory to be used\n", memavail); +#endif + + /* Return limit via the provided pointer. */ + *memlimit = memavail; + return (0); +} diff --git a/scrypt-1.1.6/lib/util/memlimit.h b/scrypt-1.1.6/lib/util/memlimit.h new file mode 100644 index 0000000..d3b4891 --- /dev/null +++ b/scrypt-1.1.6/lib/util/memlimit.h @@ -0,0 +1,42 @@ +/*- + * Copyright 2009 Colin Percival + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file was originally written by Colin Percival as part of the Tarsnap + * online backup system. + */ +#ifndef _MEMLIMIT_H_ +#define _MEMLIMIT_H_ + +#include + +/** + * memtouse(maxmem, maxmemfrac, memlimit): + * Examine the system and return via memlimit the amount of RAM which should + * be used -- the specified fraction of the available RAM, but no more than + * maxmem, and no less than 1MiB. + */ +int memtouse(size_t, double, size_t *); + +#endif /* !_MEMLIMIT_H_ */ diff --git a/scrypt-1.1.6/lib/util/readpass.h b/scrypt-1.1.6/lib/util/readpass.h new file mode 100644 index 0000000..da57278 --- /dev/null +++ b/scrypt-1.1.6/lib/util/readpass.h @@ -0,0 +1,45 @@ +/*- + * Copyright 2009 Colin Percival + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file was originally written by Colin Percival as part of the Tarsnap + * online backup system. + */ +#ifndef _READPASS_H_ +#define _READPASS_H_ + +/** + * tarsnap_getpass(passwd, prompt, confirmprompt, devtty) + * If ${devtty} is non-zero, read a password from /dev/tty if possible; if + * not, read from stdin. If reading from a tty (either /dev/tty or stdin), + * disable echo and prompt the user by printing ${prompt} to stderr. If + * ${confirmprompt} is non-NULL, read a second password (prompting if a + * terminal is being used) and repeat until the user enters the same password + * twice. Return the password as a malloced NUL-terminated string via + * ${passwd}. The obscure name is to avoid namespace collisions due to the + * getpass / readpass / readpassphrase / etc. functions in various libraries. + */ +int tarsnap_readpass(char **, const char *, const char *, int); + +#endif /* !_READPASS_H_ */ diff --git a/scrypt-1.1.6/lib/util/sysendian.h b/scrypt-1.1.6/lib/util/sysendian.h new file mode 100644 index 0000000..62ef31a --- /dev/null +++ b/scrypt-1.1.6/lib/util/sysendian.h @@ -0,0 +1,140 @@ +/*- + * Copyright 2007-2009 Colin Percival + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file was originally written by Colin Percival as part of the Tarsnap + * online backup system. + */ +#ifndef _SYSENDIAN_H_ +#define _SYSENDIAN_H_ + +#include "scrypt_platform.h" + +/* If we don't have be64enc, the we have isn't usable. */ +#if !HAVE_DECL_BE64ENC +#undef HAVE_SYS_ENDIAN_H +#endif + +#ifdef HAVE_SYS_ENDIAN_H + +#include + +#else + +#include + +static inline uint32_t +be32dec(const void *pp) +{ + const uint8_t *p = (uint8_t const *)pp; + + return ((uint32_t)(p[3]) + ((uint32_t)(p[2]) << 8) + + ((uint32_t)(p[1]) << 16) + ((uint32_t)(p[0]) << 24)); +} + +static inline void +be32enc(void *pp, uint32_t x) +{ + uint8_t * p = (uint8_t *)pp; + + p[3] = x & 0xff; + p[2] = (x >> 8) & 0xff; + p[1] = (x >> 16) & 0xff; + p[0] = (x >> 24) & 0xff; +} + +static inline uint64_t +be64dec(const void *pp) +{ + const uint8_t *p = (uint8_t const *)pp; + + return ((uint64_t)(p[7]) + ((uint64_t)(p[6]) << 8) + + ((uint64_t)(p[5]) << 16) + ((uint64_t)(p[4]) << 24) + + ((uint64_t)(p[3]) << 32) + ((uint64_t)(p[2]) << 40) + + ((uint64_t)(p[1]) << 48) + ((uint64_t)(p[0]) << 56)); +} + +static inline void +be64enc(void *pp, uint64_t x) +{ + uint8_t * p = (uint8_t *)pp; + + p[7] = x & 0xff; + p[6] = (x >> 8) & 0xff; + p[5] = (x >> 16) & 0xff; + p[4] = (x >> 24) & 0xff; + p[3] = (x >> 32) & 0xff; + p[2] = (x >> 40) & 0xff; + p[1] = (x >> 48) & 0xff; + p[0] = (x >> 56) & 0xff; +} + +static inline uint32_t +le32dec(const void *pp) +{ + const uint8_t *p = (uint8_t const *)pp; + + return ((uint32_t)(p[0]) + ((uint32_t)(p[1]) << 8) + + ((uint32_t)(p[2]) << 16) + ((uint32_t)(p[3]) << 24)); +} + +static inline void +le32enc(void *pp, uint32_t x) +{ + uint8_t * p = (uint8_t *)pp; + + p[0] = x & 0xff; + p[1] = (x >> 8) & 0xff; + p[2] = (x >> 16) & 0xff; + p[3] = (x >> 24) & 0xff; +} + +static inline uint64_t +le64dec(const void *pp) +{ + const uint8_t *p = (uint8_t const *)pp; + + return ((uint64_t)(p[0]) + ((uint64_t)(p[1]) << 8) + + ((uint64_t)(p[2]) << 16) + ((uint64_t)(p[3]) << 24) + + ((uint64_t)(p[4]) << 32) + ((uint64_t)(p[5]) << 40) + + ((uint64_t)(p[6]) << 48) + ((uint64_t)(p[7]) << 56)); +} + +static inline void +le64enc(void *pp, uint64_t x) +{ + uint8_t * p = (uint8_t *)pp; + + p[0] = x & 0xff; + p[1] = (x >> 8) & 0xff; + p[2] = (x >> 16) & 0xff; + p[3] = (x >> 24) & 0xff; + p[4] = (x >> 32) & 0xff; + p[5] = (x >> 40) & 0xff; + p[6] = (x >> 48) & 0xff; + p[7] = (x >> 56) & 0xff; +} +#endif /* !HAVE_SYS_ENDIAN_H */ + +#endif /* !_SYSENDIAN_H_ */ diff --git a/scrypt-1.1.6/lib/util/warn.c b/scrypt-1.1.6/lib/util/warn.c new file mode 100644 index 0000000..504f935 --- /dev/null +++ b/scrypt-1.1.6/lib/util/warn.c @@ -0,0 +1,75 @@ +/*- + * Copyright 2009 Colin Percival + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file was originally written by Colin Percival as part of the Tarsnap + * online backup system. + */ +#include "scrypt_platform.h" + +#ifdef HAVE_ERR_H +/* + * Everything is provided through err.h and the associated library, so we + * don't need to do anything here. + */ +#else +#include +#include +#include +#include + +#include "warn.h" + +const char * warn_progname = "(null)"; + +void +warn(const char * fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + fprintf(stderr, "%s", warn_progname); + if (fmt != NULL) { + fprintf(stderr, ": "); + vfprintf(stderr, fmt, ap); + } + fprintf(stderr, ": %s\n", strerror(errno)); + va_end(ap); +} + +void +warnx(const char * fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + fprintf(stderr, "%s", warn_progname); + if (fmt != NULL) { + fprintf(stderr, ": "); + vfprintf(stderr, fmt, ap); + } + fprintf(stderr, "\n"); + va_end(ap); +} +#endif diff --git a/scrypt-1.1.6/lib/util/warn.h b/scrypt-1.1.6/lib/util/warn.h new file mode 100644 index 0000000..262d24b --- /dev/null +++ b/scrypt-1.1.6/lib/util/warn.h @@ -0,0 +1,13 @@ +#ifndef _WARN_H_ +#define _WARN_H_ + +#ifdef HAVE_ERR_H +#include +#else +#define NEED_WARN_PROGNAME +const char * warn_progname; +void warn(const char *, ...); +void warnx(const char *, ...); +#endif + +#endif /* !_WARN_H_ */ -- cgit v1.2.3