mdb_io_t * mdb_fdio_create_path(const char *path[], const char *fname, int flags, mode_t mode) { int fd; char buf[MAXPATHLEN]; if (path != NULL && strchr(fname, '/') == NULL) { int i; for (fd = -1, i = 0; path[i] != NULL; i++) { (void) mdb_iob_snprintf(buf, MAXPATHLEN, "%s/%s", path[i], fname); if (access(buf, F_OK) == 0) { fd = open64(buf, flags, mode); fname = buf; break; } } if (fd == -1) (void) set_errno(ENOENT); } else fd = open64(fname, flags, mode); if (fd >= 0) return (mdb_fdio_create_named(fd, fname)); return (NULL); }
/* * Open file on local machine. */ static int openLocalFile( SamrftImpl_t *rftd, char *filename, int oflag, SamrftCreateAttr_t *creat) { int rc = -1; rftd->fd = -1; if (creat != NULL) { rftd->fd = open64(filename, oflag, creat->mode & S_IAMB); } else { rftd->fd = open64(filename, oflag); } if (rftd->fd >= 0) { rc = 0; /* open okay */ if (creat != NULL) { /* * If creating a file on an NFS mount point, daemon * does not have permission to change the ownership. * Ignore chown errors. */ (void) chown(filename, creat->uid, creat->gid); } } return (rc); }
STATIC int openredirect(union node *redir) { char *fname; int f; switch (redir->nfile.type) { case NFROM: fname = redir->nfile.expfname; if ((f = open64(fname, O_RDONLY)) < 0) goto eopen; break; case NFROMTO: fname = redir->nfile.expfname; if ((f = open64(fname, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0) goto ecreate; break; case NTO: /* Take care of noclobber mode. */ if (Cflag) { fname = redir->nfile.expfname; if ((f = noclobberopen(fname)) < 0) goto ecreate; break; } /* FALLTHROUGH */ case NCLOBBER: fname = redir->nfile.expfname; if ((f = open64(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0) goto ecreate; break; case NAPPEND: fname = redir->nfile.expfname; if ((f = open64(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0) goto ecreate; break; default: #ifdef DEBUG abort(); #endif /* Fall through to eliminate warning. */ case NTOFD: case NFROMFD: f = -1; break; case NHERE: case NXHERE: f = openhere(redir); break; } return f; ecreate: sh_error("cannot create %s: %s", fname, errmsg(errno, E_CREAT)); eopen: sh_error("cannot open %s: %s", fname, errmsg(errno, E_OPEN)); }
static int dofhelper_open() { int fd; if ((fd = open64(devname, O_RDWR)) < 0) { // Optimize next calls devname = olddevname; if ((fd = open64(devname, O_RDWR)) < 0) { return -1; } } return fd; }
static TACommandVerdict open64_fifo_cmd(TAThread thread,TAInputStream stream) { char* path; int oflag; int is_not_null; int mode; int res; // Prepare path = readString(&stream); oflag = readOpenFlags(&stream); if (startsWith_TAInputStream(&stream,"null:")) { is_not_null = 0; verifyType_TAInputStream(&stream,"null"); } else { is_not_null = 1; mode = readFilePermissions(&stream); } BEFORE_BLOCKED_TARGET_OPERATION(thread); writeString(thread,"Ok"); sendResponse(thread); errno = 0; START_TARGET_OPERATION(thread); // Execute if (is_not_null) { res = open64(path,oflag,mode); } else { res = open64(path,oflag); } END_TARGET_OPERATION(thread); writeDeferredReaction(thread, "open_fifo_return"); // Response writeInt(thread,res); writeInt(thread,errno); sendResponse(thread); return taDefaultVerdict; }
void git_get_blob(CCS sha1, CCS path) { CCS blob; int fd, ret, i; uint64_t fsize; struct stat64 stbuf; z_stream stream; unsigned char cprsbuf[4096], *fdata, *p; blob = git_path_to_blob(sha1); if ((fd = open64(blob, O_RDONLY|O_BINARY)) == -1) { putil_syserr(2, blob); } if (fstat64(fd, &stbuf)) { close(fd); putil_syserr(2, blob); } fsize = stbuf.st_size; fdata = util_map_file(blob, fd, 0, fsize); close(fd); if ((fd = open64(path, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0775)) == -1) { putil_syserr(2, path); } memset(&stream, 0, sizeof(stream)); stream.next_in = fdata; stream.avail_in = (uInt)fsize; if (inflateInit(&stream) != Z_OK) { putil_die("inflateInit()"); } for (i = 0, ret = Z_OK; ret != Z_STREAM_END; i++) { stream.avail_out = sizeof(cprsbuf); stream.next_out = cprsbuf; ret = inflate(&stream, Z_NO_FLUSH); if (i == 0) { p = (unsigned char *)strchr((char *)cprsbuf, '\0') + 1; } else { p = cprsbuf; } if (util_write_all(fd, p, stream.next_out - p) < 0) { putil_syserr(2, blob); } } if (inflateEnd(&stream) != Z_OK) { putil_die("inflateEnd(): %s", stream.msg ? stream.msg : "failed"); } close(fd); util_unmap_file(fdata, fsize); }
// ======================================================= QWORD CImageDisk::getPartitionSize(const char *szDevice) // [Main-Thread] { QWORD qwSize; long lSize; int fdDevice; showDebug(1, "begin\n"); qwSize = 0; #ifdef HAVE_OPEN64 fdDevice = open64(szDevice, O_RDONLY); #else fdDevice = open(szDevice, O_RDONLY); #endif if (fdDevice < 0) THROW( ERR_ERRNO, errno); #ifdef OS_LINUX if (!ioctl(fdDevice, BLKGETSIZE, &lSize)) { qwSize = ((QWORD) 512) * ((QWORD) lSize); } else THROW( ERR_ERRNO, errno); #endif if (::close(fdDevice)) THROW( ERR_ERRNO, errno); return qwSize; }
/* Lookup the latest process contract */ static ctid_t get_active_process_contract_id(void) { int stat_fd; ctid_t ctid = -1; ct_stathdl_t stathdl; if ((stat_fd = open64(CT_LATEST, O_RDONLY)) == -1) { error("%s: Error opening 'latest' process " "contract: %s", __func__, strerror(errno)); return -1; } if (ct_status_read(stat_fd, CTD_COMMON, &stathdl) != 0) { error("%s: Error reading process contract " "status: %s", __func__, strerror(errno)); goto out; } if ((ctid = ct_status_get_id(stathdl)) < 0) { error("%s: Error getting process contract id: %s", __func__, strerror(errno)); goto out; } ct_status_free(stathdl); out: close(stat_fd); return ctid; }
MemMappedFile::MemMappedFile(int objSize, int nrObj, int memSize, const char *fileN, bool isWr) { isWritable = isWr; pageSize = sysconf(_SC_PAGE_SIZE); objectSize = objSize; totNrObjects = nrObj; firstObject = 0; memBlockSize = (memSize/pageSize + 1) * pageSize; nrObjects = memBlockSize / objectSize - 1; assert(nrObjects > 1); FILE *memFile = fopen64(fileN, "wb"); char tmp = 1; int written = 0; int writeSize = pageSize*100; while(written < objectSize * totNrObjects + memBlockSize) { fseek(memFile, writeSize-1, SEEK_CUR); fwrite(&tmp,1,1,memFile); written += writeSize; } fclose(memFile); fileDescriptor = open64(fileN, O_RDWR); assert(fileDescriptor >= 0); memoryPool = (char*) mmap(0, memBlockSize, PROT_READ | PROT_WRITE, MAP_SHARED, fileDescriptor, 0); assert(memoryPool != (caddr_t) - 1); }
int xfs_test(char *devname) { struct xfs_sb sb; int fd; if ((fd=open64(devname, O_RDONLY|O_LARGEFILE))<0) { msgprintf(MSG_DEBUG1, "open64(%s) failed\n", devname); return false; } memset(&sb, 0, sizeof(sb)); if (read(fd, &sb, sizeof(sb))!=sizeof(sb)) { close(fd); msgprintf(MSG_DEBUG1, "read failed\n"); return false; } // ---- check it's an XFS file system if (be32_to_cpu(sb.sb_magicnum) != XFS_SB_MAGIC) { close(fd); msgprintf(MSG_DEBUG1, "(be32_to_cpu(sb.sb_magicnum)=%.8x) != (XFS_SB_MAGIC=%.8x)\n", be32_to_cpu(sb.sb_magicnum), XFS_SB_MAGIC); return false; } close(fd); return true; }
extern jlong file_open(JNIEnv *env, const char *filename, int open_flags, int flag) { int fd; int rc; int access_type; /* Determine access: */ if (flag & 0x01 == 1) access_type = ( O_RDWR | O_CREAT ); else access_type = ( O_RDONLY ); /* Add flags requested by caller: */ access_type |= open_flags; /* Open the file: */ fd = open64(filename, (access_type), 0666); if ( fd == -1 ) { PTOD1("error: %d", errno); PTOD1("file_open(), open %s failed", filename); return -1; } return fd; }
/*ARGSUSED*/ int vn_open(char *path, enum uio_seg x1, int flags, int mode, vnode_t **vpp, enum create x2, mode_t x3) { int fd; int old_umask = 0; struct stat64 st; if (!(flags & FCREAT) && stat64(path, &st) == -1) return (errno); if (flags & FCREAT) old_umask = umask(0); if (!(flags & FCREAT) && S_ISBLK(st.st_mode)) { flags |= O_DIRECT; /* O_EXCL can't be passed for hot spares : they can be shared * between pools */ /* if (flags & FWRITE) flags |= O_EXCL; */ } /* * The construct 'flags - FREAD' conveniently maps combinations of * FREAD and FWRITE to the corresponding O_RDONLY, O_WRONLY, and O_RDWR. */ fd = open64(path, flags - FREAD, mode); if (flags & FCREAT) (void) umask(old_umask); if (fd == -1) return (errno); return vn_fromfd(fd, path, flags, vpp, B_FALSE); }
static void dtrace_dof_fini(void) { #if illumos int fd; if ((fd = open64(devnamep, O_RDWR)) < 0) { dprintf(1, "failed to open helper device %s", devnamep); return; } if ((gen = ioctl(fd, DTRACEHIOC_REMOVE, &gen)) == -1) dprintf(1, "DTrace ioctl failed to remove DOF (%d)\n", gen); else dprintf(1, "DTrace ioctl removed DOF (%d)\n", gen); (void) close(fd); #else HANDLE fd; DWORD ret; if ((fd = CreateFile(devnamep, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)) == NULL) { dprintf(1, "failed to open helper device %s", devnamep); return; } if ((gen = DeviceIoControl(fd, DTRACEHIOC_REMOVE, &gen, 0, &gen, 0, &ret, NULL)) == 0) dprintf(1, "DTrace ioctl failed to remove DOF (%d)\n", gen); else dprintf(1, "DTrace ioctl removed DOF (%d)\n", gen); #endif }
static inline Dwfl_Error open_elf_file (Elf **elf, int *fd, char **name) { if (*elf == NULL) { /* CBFAIL uses errno if it's set, so clear it first in case we don't set it with an open failure below. */ errno = 0; /* If there was a pre-primed file name left that the callback left behind, try to open that file name. */ if (*fd < 0 && *name != NULL) *fd = TEMP_FAILURE_RETRY (open64 (*name, O_RDONLY)); if (*fd < 0) return CBFAIL; return __libdw_open_file (fd, elf, true, false); } else if (unlikely (elf_kind (*elf) != ELF_K_ELF)) { elf_end (*elf); *elf = NULL; close (*fd); *fd = -1; return DWFL_E_BADELF; } /* Elf file already open and looks fine. */ return DWFL_E_NOERROR; }
/* * Open a file through the POSIX interface. */ static void *POSIX_Open(char *testFileName, IOR_param_t * param) { int fd_oflag = O_BINARY; int *fd; fd = (int *)malloc(sizeof(int)); if (fd == NULL) ERR("Unable to malloc file descriptor"); if (param->useO_DIRECT == TRUE) set_o_direct_flag(&fd_oflag); fd_oflag |= O_RDWR; *fd = open64(testFileName, fd_oflag); if (*fd < 0) ERR("open64 failed"); #ifdef HAVE_LUSTRE_LUSTRE_USER_H if (param->lustre_ignore_locks) { int lustre_ioctl_flags = LL_FILE_IGNORE_LOCK; if (verbose >= VERBOSE_1) { fprintf(stdout, "** Disabling lustre range locking **\n"); } if (ioctl(*fd, LL_IOC_SETFLAGS, &lustre_ioctl_flags) == -1) ERR("ioctl(LL_IOC_SETFLAGS) failed"); } #endif /* HAVE_LUSTRE_LUSTRE_USER_H */ return ((void *)fd); }
static struct fileStore *ds_open(const char *filename, size_t blockSize, size_t blockCount) { struct fileStore* fs = (struct fileStore*) malloc(sizeof(struct fileStore)); assert(fs); fs->data_file = open64(filename, O_RDWR|O_CREAT, S_IRWXU); fs->used_index = NULL; if(fs->data_file < 0) { perror(""); } if(blockCount < 8) { blockCount = 8; } blockCount = (blockCount / 8) * 8; fs->blockSize = blockSize; fs->newLastBlock = 0; fs->calledFree = 0; fs->blockCount = 0; ds_grow_files(fs, blockCount); assert(!(fs->blockCount % 8)); return fs; }
/* * Common function */ static char * getl_r_common(char *answer, size_t namelen, size_t maxlen) { int uf; off64_t me; struct futmpx ubuf; if ((me = (off64_t)ttyslot()) < 0) return (NULL); if ((uf = open64(UTMPX_FILE, 0)) < 0) return (NULL); (void) lseek64(uf, me * sizeof (ubuf), SEEK_SET); if (read(uf, &ubuf, sizeof (ubuf)) != sizeof (ubuf)) { (void) close(uf); return (NULL); } (void) close(uf); if (ubuf.ut_user[0] == '\0') return (NULL); /* Insufficient buffer size */ if (namelen < strnlen(&ubuf.ut_user[0], maxlen)) { errno = ERANGE; return (NULL); } (void) strncpy(&answer[0], &ubuf.ut_user[0], maxlen); answer[maxlen] = '\0'; return (&answer[0]); }
int jfs_test(char *devname) { struct jfs_superblock sb; int fd; if ((fd=open64(devname, O_RDONLY|O_LARGEFILE))<0) return false; if (lseek(fd, JFS_SUPER1_OFF, SEEK_SET)!=JFS_SUPER1_OFF) { close(fd); return false; } if (read(fd, &sb, sizeof(sb))!=sizeof(sb)) { close(fd); return false; } if (strncmp(sb.s_magic, JFS_MAGIC, strlen(JFS_MAGIC)) != 0) { close(fd); return false; } close(fd); return true; }
int os_open_file(char *file, struct openflags flags, int mode) { int fd, f = 0; if(flags.r && flags.w) f = O_RDWR; else if(flags.r) f = O_RDONLY; else if(flags.w) f = O_WRONLY; else f = 0; if(flags.s) f |= O_SYNC; if(flags.c) f |= O_CREAT; if(flags.t) f |= O_TRUNC; if(flags.e) f |= O_EXCL; fd = open64(file, f, mode); if(fd < 0) return(-errno); if(flags.cl){ if(fcntl(fd, F_SETFD, 1)){ close(fd); return(-errno); } } return(fd); return(fd); }
int os_file_size(char *file, long long *size_out) { struct stat64 buf; if(stat64(file, &buf) == -1){ printk("Couldn't stat \"%s\" : errno = %d\n", file, errno); return(-errno); } if(S_ISBLK(buf.st_mode)){ int fd, blocks; if((fd = open64(file, O_RDONLY)) < 0){ printk("Couldn't open \"%s\", errno = %d\n", file, errno); return(-errno); } if(ioctl(fd, BLKGETSIZE, &blocks) < 0){ printk("Couldn't get the block size of \"%s\", " "errno = %d\n", file, errno); close(fd); return(-errno); } *size_out = ((long long) blocks) * 512; close(fd); return(0); } *size_out = buf.st_size; return(0); }
int main (int argc, char *argv[]) { int fd; off64_t off; if (argc != 3 || strcmp (argv[1], "--help") == 0) { printf ("usage: %s <pathname> <offset>\n", argv[0]); return 1; } fd = open64 (argv[1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); if (fd == -1) { perror ("open64()"); return 1; } off = atoll (argv[2]); if (lseek64 (fd, off, SEEK_SET) == -1) { perror ("lseek64()"); return 1; } if (write (fd, "test", 4) == -1) { perror ("write()"); return 1; } return EXIT_SUCCESS; }
/* Try to open the given file as it is or under the debuginfo directory. */ static int try_kernel_name (Dwfl *dwfl, char **fname, bool try_debug) { if (*fname == NULL) return -1; /* Don't bother trying *FNAME itself here if the path will cause it to be tried because we give its own basename as DEBUGLINK_FILE. */ int fd = ((((dwfl->callbacks->debuginfo_path ? *dwfl->callbacks->debuginfo_path : NULL) ?: DEFAULT_DEBUGINFO_PATH)[0] == ':') ? -1 : TEMP_FAILURE_RETRY (open64 (*fname, O_RDONLY))); if (fd < 0) { Dwfl_Module fakemod = { .dwfl = dwfl }; /* First try the file's unadorned basename as DEBUGLINK_FILE, to look for "vmlinux" files. */ fd = INTUSE(dwfl_standard_find_debuginfo) (&fakemod, NULL, NULL, 0, *fname, basename (*fname), 0, &fakemod.debug.name); if (fd < 0 && try_debug) /* Next, let the call use the default of basename + ".debug", to look for "vmlinux.debug" files. */ fd = INTUSE(dwfl_standard_find_debuginfo) (&fakemod, NULL, NULL, 0, *fname, NULL, 0, &fakemod.debug.name); if (fakemod.debug.name != NULL) { free (*fname); *fname = fakemod.debug.name; } }
void getsb(struct fs *fs, char *file) { fi = open64(file, O_RDWR); if (fi < 0) { fprintf(stderr, "Cannot open "); perror(file); exit(31+3); } if (bread((diskaddr_t)SBLOCK, (char *)fs, SBSIZE)) { fprintf(stderr, "Bad super block "); perror(file); exit(31+4); } if ((fs->fs_magic != FS_MAGIC) && (fs->fs_magic != MTB_UFS_MAGIC)) { fprintf(stderr, "%s: bad magic number\n", file); exit(31+5); } if (fs->fs_magic == FS_MAGIC && (fs->fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 && fs->fs_version != UFS_VERSION_MIN)) { fprintf(stderr, "%s: unrecognized ufs version: %d\n", file, fs->fs_version); exit(31+5); } if (fs->fs_magic == MTB_UFS_MAGIC && (fs->fs_version > MTB_UFS_VERSION_1 || fs->fs_version < MTB_UFS_VERSION_MIN)) { fprintf(stderr, "%s: unrecognized ufs version: %d\n", file, fs->fs_version); exit(31+5); } }
/* Read at most size bytes from the memory of the given thread using the /proc/.../mem entry starting at the given * address. Write results to out. Out must be large enough to hold size bytes. Return bytes written (which is size * or less). */ size_t procfs_mem_read(thread_t * thread, address_t offset, size_t size, void * out) { const char * path = procfs_thread_get_path(thread, "mem"); int fd = -1; ssize_t count = 0; if ((fd = open64(path, O_RDONLY)) == -1) { error("Error opening %s.", path); goto out; } if (lseek64(fd, (off64_t) offset, SEEK_SET) == -1) { error("Error seeking through %s.", path); goto out; } count = read(fd, out, size); if (count != (ssize_t) size) error("Error reading %zu bytes from %s at %lx: %s", size, path, offset, strerror(errno)); out: if (fd >= 0) close(fd); if (count >= 0) return (size_t) count; else return 0; }
int main(int argc, char *argv[]) { int fd; off64_t off; if (argc != 3 || strcmp(argv[1], "--help") == 0) { fprintf(stderr, "Usage: %s pathname offset\n", argv[0]); exit(EXIT_FAILURE); } fd = open64(argv[1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); if (fd == -1) { perror("open64"); exit(EXIT_FAILURE); } off = atoll(argv[2]); if (lseek64(fd, off, SEEK_SET) == -1) { perror("lseek64"); exit(EXIT_FAILURE); } if (write(fd, "test", 4) == -1) { perror("write"); exit(EXIT_FAILURE); } exit(EXIT_SUCCESS); }
int _zexec_init_template(void) { int fd; int err = 0; fd = open64(CTFS_ROOT "/process/template", O_RDWR); if (fd == -1) { return (-1); } /* * zlogin doesn't do anything with the contract. * Deliver no events, don't inherit, and allow it to be orphaned. */ err |= ct_tmpl_set_critical(fd, 0); err |= ct_tmpl_set_informative(fd, 0); err |= ct_pr_tmpl_set_fatal(fd, CT_PR_EV_HWERR); err |= ct_pr_tmpl_set_param(fd, CT_PR_PGRPONLY | CT_PR_REGENT); if (err || ct_tmpl_activate(fd)) { (void) close(fd); return (-1); } return (fd); }
int btrfs_test(char *devname) { struct btrfs_super_block sb; int fd; if ((fd=open64(devname, O_RDONLY|O_LARGEFILE))<0) return false; if (lseek(fd, BTRFS_SUPER_INFO_OFFSET, SEEK_SET)!=BTRFS_SUPER_INFO_OFFSET) { close(fd); return false; } if (read(fd, &sb, sizeof(sb))!=sizeof(sb)) { close(fd); return false; } if (strncmp((char*)&sb.magic, BTRFS_MAGIC, sizeof(sb.magic))!=0) { close(fd); return false; } close(fd); return true; }
static void putdiscq(uid_t uid) { struct fsquot *fsqp; for (fsqp = fsqlist; fsqp; fsqp = fsqp->fsq_next) { if (quotactl(Q_SETQLIM, fsqp->fsq_dev, uid, (caddr_t)&fsqp->fsq_dqb) != 0) { int fd; if ((fd = open64(fsqp->fsq_qfile, O_RDWR)) < 0) { (void) fprintf(stderr, "edquota: "); perror(fsqp->fsq_qfile); continue; } (void) llseek(fd, (offset_t)dqoff(uid), L_SET); if (write(fd, (char *)&fsqp->fsq_dqb, sizeof (struct dqblk)) != sizeof (struct dqblk)) { (void) fprintf(stderr, "edquota: "); perror(fsqp->fsq_qfile); } (void) close(fd); } } }
/* Open libelf FILE->fd and compute the load base of ELF as loaded in MOD. When we return success, FILE->elf and FILE->bias are set up. */ static inline Dwfl_Error open_elf (Dwfl_Module *mod, struct dwfl_file *file) { if (file->elf == NULL) { /* If there was a pre-primed file name left that the callback left behind, try to open that file name. */ if (file->fd < 0 && file->name != NULL) file->fd = TEMP_FAILURE_RETRY (open64 (file->name, O_RDONLY)); if (file->fd < 0) return CBFAIL; file->elf = elf_begin (file->fd, ELF_C_READ_MMAP_PRIVATE, NULL); } if (unlikely (elf_kind (file->elf) != ELF_K_ELF)) { close (file->fd); file->fd = -1; return DWFL_E_BADELF; } GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr (file->elf, &ehdr_mem); if (ehdr == NULL) { elf_error: close (file->fd); file->fd = -1; return DWFL_E (LIBELF, elf_errno ()); } /* The addresses in an ET_EXEC file are absolute. The lowest p_vaddr of the main file can differ from that of the debug file due to prelink. But that doesn't not change addresses that symbols, debuginfo, or sh_addr of any program sections refer to. */ file->bias = 0; if (mod->e_type != ET_EXEC) for (uint_fast16_t i = 0; i < ehdr->e_phnum; ++i) { GElf_Phdr ph_mem; GElf_Phdr *ph = gelf_getphdr (file->elf, i, &ph_mem); if (ph == NULL) goto elf_error; if (ph->p_type == PT_LOAD) { file->bias = ((mod->low_addr & -ph->p_align) - (ph->p_vaddr & -ph->p_align)); break; } } mod->e_type = ehdr->e_type; /* Relocatable Linux kernels are ET_EXEC but act like ET_DYN. */ if (mod->e_type == ET_EXEC && file->bias != 0) mod->e_type = ET_DYN; return DWFL_E_NOERROR; }
int main(void) { fopen("", "r"); fopen64("", "r"); freopen("", "r", NULL); freopen64("", "r", NULL); open("", O_RDONLY); open64("", O_RDONLY); creat("", S_IRWXU); creat64("", S_IRWXU); unlink(""); rename("", ""); #ifdef AT_FUNCTIONS unlinkat(0, "", 0); renameat(0, "", 0, ""); openat(0, "", 0); openat64(0, "", 0); #endif return 0; }