struct randread_source *
randread_new (char const *name, size_t bytes_bound)
{
if (bytes_bound == 0)
return simple_new (NULL, NULL);
else
{
FILE *source = NULL;
struct randread_source *s;
if (name)
if (! (source = fopen_safer (name, "rb")))
return NULL;
s = simple_new (source, name);
if (source)
setvbuf (source, s->buf.c, _IOFBF, MIN (sizeof s->buf.c, bytes_bound));
else
{
s->buf.isaac.buffered = 0;
get_nonce (s->buf.isaac.state.m, sizeof s->buf.isaac.state.m,
bytes_bound);
isaac_seed (&s->buf.isaac.state);
}
return s;
}
}
FILE *
xfopen (const char *name, const char *mode)
{
FILE *ptr;
ptr = fopen_safer (name, mode);
if (!ptr)
error (EXIT_FAILURE, get_errno (), _("cannot open file `%s'"), name);
return ptr;
}
FILE *
xfopen (const char *name, const char *mode)
{
FILE *ptr;
ptr = fopen_safer (name, mode);
if (!ptr)
error (EXIT_FAILURE, get_errno (),
_("%s: cannot open"), quotearg_colon (name));
return ptr;
}
FILE *
sharefile_fopen (sharefile_handle h, const char *filename)
{
struct sharefile *p = h;
struct SharefileEntry *new_entry;
new_entry = malloc (sizeof (struct SharefileEntry));
if (!new_entry)
return NULL;
new_entry->name = strdup (filename);
if (NULL == new_entry->name)
{
free (new_entry);
return NULL;
}
if (NULL == (new_entry->fp = fopen_safer (filename, p->mode)))
{
free (new_entry);
return NULL;
}
else
{
struct stat st;
const int fd = fileno (new_entry->fp);
assert (fd >= 0);
set_cloexec_flag (fd, true);
if (fstat (fd, &st) < 0)
{
entry_free (new_entry);
return NULL;
}
else
{
void *existing;
new_entry->device = st.st_dev;
new_entry->inode = st.st_ino;
existing = hash_lookup (p->table, new_entry);
if (existing) /* We have previously opened that file. */
{
entry_free (new_entry); /* don't need new_entry. */
return ((const struct SharefileEntry*)existing)->fp;
}
else /* We didn't open it already */
{
if (hash_insert (p->table, new_entry))
{
return new_entry->fp;
}
else /* failed to insert in hashtable. */
{
const int save_errno = errno;
entry_free (new_entry);
errno = save_errno;
return NULL;
}
}
}
}
}
