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; }