diff options
Diffstat (limited to 'third_party/heimdal/lib/roken/dumpdata.c')
| -rw-r--r-- | third_party/heimdal/lib/roken/dumpdata.c | 249 |
1 files changed, 249 insertions, 0 deletions
diff --git a/third_party/heimdal/lib/roken/dumpdata.c b/third_party/heimdal/lib/roken/dumpdata.c new file mode 100644 index 0000000..a8b3efe --- /dev/null +++ b/third_party/heimdal/lib/roken/dumpdata.c @@ -0,0 +1,249 @@ +/* + * Copyright (c) 2005 Kungliga Tekniska Högskolan + * (Royal Institute of Technology, Stockholm, Sweden). + * 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. + * + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE 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 INSTITUTE 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 <config.h> + +#include "roken.h" + +/* + * Write datablob to a filename, don't care about errors. + */ + +ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL +rk_dumpdata (const char *filename, const void *buf, size_t size) +{ + int fd; + + fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0640); + if (fd < 0) + return; + net_write(fd, buf, size); + close(fd); +} + +/* For not-regular files */ +static int +undump_not_file(int fd, char **out, size_t *size, int nul_terminate) +{ + size_t lim = 10 * 1024 * 1024; + size_t bufsz = 0; + size_t sz = 0; + char *buf = NULL; + char *tmp; + + *out = NULL; + if (size && *size != 0 && *size < lim) + lim = *size; + if (size) + *size = 0; + + /* + * We can't use net_read() if we're on WIN32 because that really wants a + * socket FD, which is in a distinct FD namespace from those returned by + * open() on Windows. + */ + do { + ssize_t bytes; + + if (sz == bufsz) { + if (bufsz == 0) + bufsz = 1024; + else + bufsz += bufsz >> 1; + + tmp = realloc(buf, bufsz); + if (tmp == NULL) { + free(buf); + return ENOMEM; + } + buf = tmp; + } + + bytes = read(fd, buf + sz, bufsz - sz); + if (bytes == 0) + break; + if (bytes < 0 && + (errno == EAGAIN || errno == EWOULDBLOCK)) + continue; + if (bytes < 0) { + free(buf); + return errno; + } + sz += bytes; + } while (sz < lim); + + *out = buf; + if (size) + *size = sz; + + if (!nul_terminate) + return 0; + + if (bufsz > sz) { + buf[sz] = '\0'; + return 0; + } + + *out = tmp = realloc(buf, bufsz + 1); + if (tmp == NULL) { + free(buf); + return ENOMEM; + } + buf = tmp; + buf[sz] = '\0'; + return 0; +} + +/* + * Read all data from a file, care about errors. + * + * If `*size' is not zero and the file is not a regular file, then up to that + * many bytes will be read. + * + * Returns zero on success or a system error code on failure. + */ + +ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL +rk_undumpdata(const char *filename, void **buf, size_t *size) +{ + struct stat sb; + int fd, ret; + ssize_t sret; + + *buf = NULL; + + fd = open(filename, O_RDONLY, 0); + if (fd < 0) + return errno; + if (fstat(fd, &sb) != 0){ + ret = errno; + goto out; + } + if (!S_ISREG(sb.st_mode)) { + char *char_buf; + + ret = undump_not_file(fd, &char_buf, size, 0); + (void) close(fd); + *buf = char_buf; + return ret; + } + + if (sb.st_size < 0) + sb.st_size = 0; + *buf = malloc(sb.st_size); + if (*buf == NULL) { + ret = ENOMEM; + goto out; + } + *size = sb.st_size; + + sret = read(fd, *buf, *size); + if (sret < 0) + ret = errno; + else if (sret != (ssize_t)*size) + ret = EINVAL; + else + ret = 0; + + out: + if (ret) { + free(*buf); + *buf = NULL; + } + close(fd); + return ret; +} + +/* + * Read all text from a file. + * + * Outputs a C string. It is up to the caller to check for embedded NULs. + * The number of bytes read will be stored in `*size' if `size' is not NULL. + * + * If `size' is not NULL and `*size' is not zero and the file is not a regular + * file, then up to that many bytes will be read. + * + * Returns zero on success or a system error code on failure. + */ + +ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL +rk_undumptext(const char *filename, char **out, size_t *size) +{ + struct stat sb; + int fd, ret; + ssize_t sret; + char *buf; + + *out = NULL; + + fd = open(filename, O_RDONLY, 0); + if (fd < 0) + return errno; + if (fstat(fd, &sb) != 0) { + (void) close(fd); + return errno; + } + if (!S_ISREG(sb.st_mode)) { + ret = undump_not_file(fd, out, size, 1); + (void) close(fd); + return ret; + } + + if (sb.st_size < 0) + sb.st_size = 0; + buf = malloc(sb.st_size + 1); + if (buf == NULL) { + ret = ENOMEM; + goto out; + } + if (size) + *size = sb.st_size; + + sret = read(fd, buf, sb.st_size); + if (sret < 0) + ret = errno; + else if (sret != (ssize_t)sb.st_size) + ret = EINVAL; + else + ret = 0; + +out: + if (ret) { + free(buf); + } else { + buf[sb.st_size] = '\0'; + *out = buf; + } + close(fd); + return ret; +} |