diff options
Diffstat (limited to 'lib/util')
| -rw-r--r-- | lib/util/memlimit.c | 302 | ||||
| -rw-r--r-- | lib/util/memlimit.h | 42 | ||||
| -rw-r--r-- | lib/util/readpass.c | 143 | ||||
| -rw-r--r-- | lib/util/readpass.h | 45 | ||||
| -rw-r--r-- | lib/util/sysendian.h | 140 | ||||
| -rw-r--r-- | lib/util/warn.c | 75 | ||||
| -rw-r--r-- | lib/util/warn.h | 13 |
7 files changed, 760 insertions, 0 deletions
diff --git a/lib/util/memlimit.c b/lib/util/memlimit.c new file mode 100644 index 0000000..8303f5c --- /dev/null +++ b/lib/util/memlimit.c @@ -0,0 +1,302 @@ +/*- + * 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 <sys/types.h> +#include <sys/resource.h> + +#ifdef HAVE_SYS_PARAM_H +#include <sys/param.h> +#endif +#ifdef HAVE_SYSCTL_HW_USERMEM +#include <sys/sysctl.h> +#endif +#ifdef HAVE_SYS_SYSINFO_H +#include <sys/sysinfo.h> +#endif + +#include <errno.h> +#include <stddef.h> +#include <stdint.h> +#include <unistd.h> + +#ifdef DEBUG +#include <stdio.h> +#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 */ + +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); +} + +#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 + +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; + + /* 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 + if (memlimit_rlimit(&rlimit_memlimit)) + return (1); +#ifdef _SC_PHYS_PAGES + if (memlimit_sysconf(&sysconf_memlimit)) + return (1); +#else + sysconf_memlimit = (size_t)(-1); +#endif + +#ifdef DEBUG + fprintf(stderr, "Memory limits are %zu %zu %zu %zu\n", + sysctl_memlimit, sysinfo_memlimit, rlimit_memlimit, + sysconf_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; + + /* 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 %zu memory to be used\n", memavail); +#endif + + /* Return limit via the provided pointer. */ + *memlimit = memavail; + return (0); +} diff --git a/lib/util/memlimit.h b/lib/util/memlimit.h new file mode 100644 index 0000000..d3b4891 --- /dev/null +++ b/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 <stddef.h> + +/** + * 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/lib/util/readpass.c b/lib/util/readpass.c new file mode 100644 index 0000000..91f77e0 --- /dev/null +++ b/lib/util/readpass.c @@ -0,0 +1,143 @@ +/*- + * 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. + */ +#include "scrypt_platform.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <termios.h> +#include <unistd.h> + +#include "warn.h" + +#include "readpass.h" + +#define MAXPASSLEN 2048 + +/** + * 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 ** passwd, const char * prompt, + const char * confirmprompt, int devtty) +{ + FILE * readfrom; + char passbuf[MAXPASSLEN]; + char confpassbuf[MAXPASSLEN]; + struct termios term, term_old; + int usingtty; + + /* + * If devtty != 0, try to open /dev/tty; if that fails, or if devtty + * is zero, we'll read the password from stdin instead. + */ + if ((devtty == 0) || ((readfrom = fopen("/dev/tty", "r")) == NULL)) + readfrom = stdin; + + /* If we're reading from a terminal, try to disable echo. */ + if ((usingtty = isatty(fileno(readfrom))) != 0) { + if (tcgetattr(fileno(readfrom), &term_old)) { + warn("Cannot read terminal settings"); + goto err1; + } + memcpy(&term, &term_old, sizeof(struct termios)); + term.c_lflag = (term.c_lflag & ~ECHO) | ECHONL; + if (tcsetattr(fileno(readfrom), TCSANOW, &term)) { + warn("Cannot set terminal settings"); + goto err1; + } + } + +retry: + /* If we have a terminal, prompt the user to enter the password. */ + if (usingtty) + fprintf(stderr, "%s: ", prompt); + + /* Read the password. */ + if (fgets(passbuf, MAXPASSLEN, readfrom) == NULL) { + warn("Cannot read password"); + goto err2; + } + + /* Confirm the password if necessary. */ + if (confirmprompt != NULL) { + if (usingtty) + fprintf(stderr, "%s: ", confirmprompt); + if (fgets(confpassbuf, MAXPASSLEN, readfrom) == NULL) { + warn("Cannot read password"); + goto err2; + } + if (strcmp(passbuf, confpassbuf)) { + fprintf(stderr, + "Passwords mismatch, please try again\n"); + goto retry; + } + } + + /* Terminate the string at the first "\r" or "\n" (if any). */ + passbuf[strcspn(passbuf, "\r\n")] = '\0'; + + /* If we changed terminal settings, reset them. */ + if (usingtty) + tcsetattr(fileno(readfrom), TCSANOW, &term_old); + + /* Close /dev/tty if we opened it. */ + if (readfrom != stdin) + fclose(readfrom); + + /* Copy the password out. */ + if ((*passwd = strdup(passbuf)) == NULL) { + warn("Cannot allocate memory"); + goto err1; + } + + /* Zero any stored passwords. */ + memset(passbuf, 0, MAXPASSLEN); + memset(confpassbuf, 0, MAXPASSLEN); + + /* Success! */ + return (0); + +err2: + /* Reset terminal settings if necessary. */ + if (usingtty) + tcsetattr(fileno(readfrom), TCSAFLUSH, &term_old); +err1: + /* Close /dev/tty if we opened it. */ + if (readfrom != stdin) + fclose(readfrom); + + /* Failure! */ + return (-1); +} diff --git a/lib/util/readpass.h b/lib/util/readpass.h new file mode 100644 index 0000000..da57278 --- /dev/null +++ b/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/lib/util/sysendian.h b/lib/util/sysendian.h new file mode 100644 index 0000000..62ef31a --- /dev/null +++ b/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 <sys/endian.h> we have isn't usable. */ +#if !HAVE_DECL_BE64ENC +#undef HAVE_SYS_ENDIAN_H +#endif + +#ifdef HAVE_SYS_ENDIAN_H + +#include <sys/endian.h> + +#else + +#include <stdint.h> + +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/lib/util/warn.c b/lib/util/warn.c new file mode 100644 index 0000000..504f935 --- /dev/null +++ b/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 <errno.h> +#include <stdarg.h> +#include <stdio.h> +#include <string.h> + +#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/lib/util/warn.h b/lib/util/warn.h new file mode 100644 index 0000000..262d24b --- /dev/null +++ b/lib/util/warn.h @@ -0,0 +1,13 @@ +#ifndef _WARN_H_ +#define _WARN_H_ + +#ifdef HAVE_ERR_H +#include <err.h> +#else +#define NEED_WARN_PROGNAME +const char * warn_progname; +void warn(const char *, ...); +void warnx(const char *, ...); +#endif + +#endif /* !_WARN_H_ */ |