/** * Grab random data from file and feed them to the specified routine. * * @param path pathname where random data are expected * @param rfd random filling routine to feed data * @param len amount of random bytes to read * * @return the amount of bytes fed if OK, a short count or -1 on error, * with errno set. */ ssize_t frand_restore(const char *path, feed_fn_t rfd, size_t len) { char buf[256]; int fd; ssize_t bytes_read = 0; fd = file_open_missing(path, O_RDONLY); if (-1 == fd) return -1; while (len != 0) { size_t n = MIN(len, sizeof buf); ssize_t r; r = read(fd, buf, n); if (-1 == r) break; bytes_read += r; (*rfd)(buf, r); if (UNSIGNED(r) != n) break; len -= n; } ZERO(buf); /* Leave no memory trail */ close(fd); return bytes_read; }
/** * Initialize RX dumping. * * @return TRUE if initialized. */ static gboolean dump_initialize(struct dump *dump) { char *pathname; if (dump->initialized) return TRUE; pathname = make_pathname(settings_config_dir(), dump->filename); dump->fd = file_open_missing(pathname, O_WRONLY | O_APPEND | O_NONBLOCK); HFREE_NULL(pathname); /* * If the dump "file" is actually a named pipe, we'd block quickly * if there was no reader. So set the file as non-blocking and * we'll disable dumping as soon as we can't write all the data * we want. */ if (dump->fd < 0) { g_warning("can't open %s -- disabling dumping", dump->filename); dump_disable(dump); return FALSE; } fd_set_nonblocking(dump->fd); dump->slist = slist_new(); dump->fill = 0; dump->initialized = TRUE; return TRUE; }
static int tth_cache_file_open(const struct tth *tth) { char *pathname; int fd; g_return_val_if_fail(tth, -1); pathname = tth_cache_pathname(tth); fd = file_open_missing(pathname, O_RDONLY); HFREE_NULL(pathname); return fd; }
/** * Open and parse the first line of a given file as the ASCII representation * of an unsigned 64-bit integer. * * @param path file path * @param missing whether file may be missing (to shut up warnings) * @param errptr if non-NULL, filled with error number (0 means OK) * * @return the value we parsed on the first line, 0 otherwise. * * @note * The ``errptr'' parameter needs to be used to distinguish between * a file containing "0" and a file which could not be parsed correctly. */ guint64 filehead_uint64(const char *path, gboolean missing, int *errptr) { int fd; guint64 value; char data[FILEHEAD_LINE_MAXLEN + 1]; ssize_t r; int error; fd = missing ? file_open_missing(path, O_RDONLY) : file_open(path, O_RDONLY, 0); if (-1 == fd) goto error; r = read(fd, data, sizeof data - 1); /* reserve one byte for NUL */ if ((ssize_t) -1 == r) goto error_close; g_assert(r >= 0 && UNSIGNED(r) < sizeof data); fd_close(&fd); data[r] = '\0'; value = parse_uint64(data, NULL, 10, &error); if (error) { errno = error; goto error; } if (errptr != NULL) *errptr = 0; return value; error_close: fd_close(&fd); error: if (errptr != NULL) *errptr = errno; return 0; }