int
ud_init (struct udoc *ud)
{
bin_zero (ud, sizeof (*ud));
if (!ud_oht_init (&ud->ud_parts, sizeof (struct ud_part))) goto FAIL;
if (!ud_oht_init (&ud->ud_link_exts, sizeof (struct ud_ref))) goto FAIL;
if (!ud_oht_init (&ud->ud_refs, sizeof (struct ud_ref))) goto FAIL;
if (!ud_oht_init (&ud->ud_ref_names, sizeof (struct ud_ref))) goto FAIL;
if (!ud_oht_init (&ud->ud_footnotes, sizeof (struct ud_ref))) goto FAIL;
if (!ud_oht_init (&ud->ud_styles, sizeof (struct ud_ref))) goto FAIL;
if (!dstack_init (&ud->ud_errors, 16, sizeof (struct ud_err))) goto FAIL;
if (!token_init (&ud->ud_tok)) goto FAIL;
ud->ud_dirfd_pwd = open_ro (".");
if (ud->ud_dirfd_pwd == -1) goto FAIL;
ud->ud_dirfd_src = -1;
ud->ud_dirfd_out = -1;
ud->ud_main_doc = ud;
ud->ud_cur_doc = ud;
if (!ht_init (&ud->ud_loopchecks)) goto FAIL;
if (!ht_init (&ud->ud_documents)) goto FAIL;
taia_now (&ud->ud_time_start);
return 1;
FAIL:
ud_free (ud);
return 0;
}
int leapsecs_read(void)
{
char fbuf[1024];
struct sstring sstr;
struct stat sb;
struct tai tai;
struct tai *mem = 0;
unsigned long size;
unsigned long ind;
int fd = -1;
/* build path to leapsecs.dat */
sstring_init(&sstr, fbuf, sizeof (fbuf));
sstring_cats(&sstr, leapsecs_dir);
if (sstr.len + sizeof("/leapsecs.dat") >= 1024) {
errno = error_nametoolong;
return -1;
}
sstring_cats(&sstr, "/leapsecs.dat");
sstring_0(&sstr);
/* open leapsecs.dat */
fd = open_ro(sstr.s);
if (fd == -1) {
if (errno != error_noent) return -1;
leapsecs_free();
return 0;
}
if (fstat(fd, &sb) == -1) goto FAIL;
/* map and unpack packed tai structures */
mem = alloc(sb.st_size);
if (!mem) goto FAIL;
size = read(fd, mem, sb.st_size);
if (size != (unsigned long) sb.st_size) { dealloc(mem); goto FAIL; }
size = sb.st_size / sizeof(struct tai);
for (ind = 0; ind < size; ++ind) {
tai_unpack((unsigned char *) &mem[ind], &tai);
mem[ind] = tai;
}
leapsecs_free();
leapsecs_list = (struct tai *) mem;
leapsecs_size = size;
if (fd != -1) close(fd);
return 0;
FAIL:
if (fd != -1) close(fd);
return -1;
}
int
ud_open (struct udoc *ud, const char *fn)
{
char dir[DIR_NAME_MAX];
struct hashtable *doc_hash = &ud->ud_main_doc->ud_documents;
ud_try_sys_jump (ud, str_dup (fn, (char **) &ud->ud_name), OPEN_FAIL, "str_dup");
ud_try_sys_jump (ud, dir_name_r (ud->ud_name, dir, sizeof (dir)), OPEN_FAIL, "dir_name_r");
ud->ud_dirfd_src = open_ro (dir);
ud_try_sys_jump (ud, ud->ud_dirfd_src != -1, OPEN_FAIL, dir);
ud_try_sys_jump (ud, token_open (&ud->ud_tok, fn), OPEN_FAIL, fn);
ud_try_sys_jump (ud, ht_addb (doc_hash, fn, str_len (fn), ud,
sizeof (struct udoc)) >= 0, OPEN_FAIL, "ht_addb");
return 1;
OPEN_FAIL:
close (ud->ud_dirfd_src);
token_close (&ud->ud_tok);
return 0;
}
struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode)
{
struct exfat_dev* dev;
struct stat stbuf;
#ifdef USE_UBLIO
struct ublio_param up;
#endif
dev = malloc(sizeof(struct exfat_dev));
if (dev == NULL)
{
exfat_error("failed to allocate memory for device structure");
return NULL;
}
switch (mode)
{
case EXFAT_MODE_RO:
dev->fd = open_ro(spec);
if (dev->fd == -1)
{
free(dev);
exfat_error("failed to open '%s' in read-only mode: %s", spec,
strerror(errno));
return NULL;
}
dev->mode = EXFAT_MODE_RO;
break;
case EXFAT_MODE_RW:
dev->fd = open_rw(spec);
if (dev->fd == -1)
{
free(dev);
exfat_error("failed to open '%s' in read-write mode: %s", spec,
strerror(errno));
return NULL;
}
dev->mode = EXFAT_MODE_RW;
break;
case EXFAT_MODE_ANY:
dev->fd = open_rw(spec);
if (dev->fd != -1)
{
dev->mode = EXFAT_MODE_RW;
break;
}
dev->fd = open_ro(spec);
if (dev->fd != -1)
{
dev->mode = EXFAT_MODE_RO;
exfat_warn("'%s' is write-protected, mounting read-only", spec);
break;
}
free(dev);
exfat_error("failed to open '%s': %s", spec, strerror(errno));
return NULL;
}
if (fstat(dev->fd, &stbuf) != 0)
{
close(dev->fd);
free(dev);
exfat_error("failed to fstat '%s'", spec);
return NULL;
}
if (!S_ISBLK(stbuf.st_mode) &&
!S_ISCHR(stbuf.st_mode) &&
!S_ISREG(stbuf.st_mode))
{
close(dev->fd);
free(dev);
exfat_error("'%s' is neither a device, nor a regular file", spec);
return NULL;
}
#if defined(__APPLE__)
if (!S_ISREG(stbuf.st_mode))
{
uint32_t block_size = 0;
uint64_t blocks = 0;
if (ioctl(dev->fd, DKIOCGETBLOCKSIZE, &block_size) != 0)
{
close(dev->fd);
free(dev);
exfat_error("failed to get block size");
return NULL;
}
if (ioctl(dev->fd, DKIOCGETBLOCKCOUNT, &blocks) != 0)
{
close(dev->fd);
free(dev);
exfat_error("failed to get blocks count");
return NULL;
}
dev->size = blocks * block_size;
}
else
#elif defined(__OpenBSD__)
if (!S_ISREG(stbuf.st_mode))
{
struct disklabel lab;
struct partition* pp;
char* partition;
if (ioctl(dev->fd, DIOCGDINFO, &lab) == -1)
{
close(dev->fd);
free(dev);
exfat_error("failed to get disklabel");
return NULL;
}
/* Don't need to check that partition letter is valid as we won't get
this far otherwise. */
partition = strchr(spec, '\0') - 1;
pp = &(lab.d_partitions[*partition - 'a']);
dev->size = DL_GETPSIZE(pp) * lab.d_secsize;
if (pp->p_fstype != FS_NTFS)
exfat_warn("partition type is not 0x07 (NTFS/exFAT); "
"you can fix this with fdisk(8)");
}
else
#endif
{
/* works for Linux, FreeBSD, Solaris */
dev->size = exfat_seek(dev, 0, SEEK_END);
if (dev->size <= 0)
{
close(dev->fd);
free(dev);
exfat_error("failed to get size of '%s'", spec);
return NULL;
}
if (exfat_seek(dev, 0, SEEK_SET) == -1)
{
close(dev->fd);
free(dev);
exfat_error("failed to seek to the beginning of '%s'", spec);
return NULL;
}
}
#ifdef USE_UBLIO
memset(&up, 0, sizeof(struct ublio_param));
up.up_blocksize = 256 * 1024;
up.up_items = 64;
up.up_grace = 32;
up.up_priv = &dev->fd;
dev->pos = 0;
dev->ufh = ublio_open(&up);
if (dev->ufh == NULL)
{
close(dev->fd);
free(dev);
exfat_error("failed to initialize ublio");
return NULL;
}
#endif
return dev;
}
struct exfat_dev* exfat_open(const char* spec, enum exfat_mode mode)
{
struct exfat_dev* dev;
struct stat stbuf;
#ifdef USE_UBLIO
struct ublio_param up;
#endif
dev = malloc(sizeof(struct exfat_dev));
if (dev == NULL)
{
exfat_error("failed to allocate memory for device structure");
return NULL;
}
switch (mode)
{
case EXFAT_MODE_RO:
dev->fd = open_ro(spec);
if (dev->fd == -1)
{
free(dev);
exfat_error("failed to open `%s' in read-only mode", spec);
return NULL;
}
dev->mode = EXFAT_MODE_RO;
break;
case EXFAT_MODE_RW:
dev->fd = open_rw(spec);
if (dev->fd == -1)
{
free(dev);
exfat_error("failed to open `%s' in read-write mode", spec);
return NULL;
}
dev->mode = EXFAT_MODE_RW;
break;
case EXFAT_MODE_ANY:
dev->fd = open_rw(spec);
if (dev->fd != -1)
{
dev->mode = EXFAT_MODE_RW;
break;
}
dev->fd = open_ro(spec);
if (dev->fd != -1)
{
dev->mode = EXFAT_MODE_RO;
exfat_warn("`%s' is write-protected, mounting read-only", spec);
break;
}
free(dev);
exfat_error("failed to open `%s'", spec);
return NULL;
}
if (fstat(dev->fd, &stbuf) != 0)
{
close(dev->fd);
free(dev);
exfat_error("failed to fstat `%s'", spec);
return NULL;
}
if (!S_ISBLK(stbuf.st_mode) &&
!S_ISCHR(stbuf.st_mode) &&
!S_ISREG(stbuf.st_mode))
{
close(dev->fd);
free(dev);
exfat_error("`%s' is neither a device, nor a regular file", spec);
return NULL;
}
#ifdef __APPLE__
if (!S_ISREG(stbuf.st_mode))
{
uint32_t block_size = 0;
uint64_t blocks = 0;
if (ioctl(dev->fd, DKIOCGETBLOCKSIZE, &block_size) != 0)
{
close(dev->fd);
free(dev);
exfat_error("failed to get block size");
return NULL;
}
if (ioctl(dev->fd, DKIOCGETBLOCKCOUNT, &blocks) != 0)
{
close(dev->fd);
free(dev);
exfat_error("failed to get blocks count");
return NULL;
}
dev->size = blocks * block_size;
}
else
#endif
{
/* works for Linux, FreeBSD, Solaris */
dev->size = exfat_seek(dev, 0, SEEK_END);
if (dev->size <= 0)
{
close(dev->fd);
free(dev);
exfat_error("failed to get size of `%s'", spec);
return NULL;
}
if (exfat_seek(dev, 0, SEEK_SET) == -1)
{
close(dev->fd);
free(dev);
exfat_error("failed to seek to the beginning of `%s'", spec);
return NULL;
}
}
#ifdef USE_UBLIO
memset(&up, 0, sizeof(struct ublio_param));
up.up_blocksize = 256 * 1024;
up.up_items = 64;
up.up_grace = 32;
up.up_priv = &dev->fd;
dev->pos = 0;
dev->ufh = ublio_open(&up);
if (dev->ufh == NULL)
{
close(dev->fd);
free(dev);
exfat_error("failed to initialize ublio");
return NULL;
}
#endif
return dev;
}
