bool gfapi_device::d_truncate(DCR *dcr) { struct stat st; if (m_gfd) { if (glfs_ftruncate(m_gfd, 0) != 0) { berrno be; Mmsg2(errmsg, _("Unable to truncate device %s. ERR=%s\n"), print_name(), be.bstrerror()); Emsg0(M_FATAL, 0, errmsg); return false; } /* * Check for a successful glfs_truncate() and issue work-around when truncation doesn't work. * * 1. close file * 2. delete file * 3. open new file with same mode * 4. change ownership to original */ if (glfs_fstat(m_gfd, &st) != 0) { berrno be; Mmsg2(errmsg, _("Unable to stat device %s. ERR=%s\n"), print_name(), be.bstrerror()); return false; } if (st.st_size != 0) { /* glfs_truncate() didn't work */ glfs_close(m_gfd); glfs_unlink(m_glfs, getVolCatName()); set_mode(CREATE_READ_WRITE); /* * Recreate the file -- of course, empty */ m_gfd = glfs_creat(m_glfs, getVolCatName(), oflags, st.st_mode); if (!m_gfd) { berrno be; dev_errno = errno; Mmsg2(errmsg, _("Could not reopen: %s, ERR=%s\n"), getVolCatName(), be.bstrerror()); Emsg0(M_FATAL, 0, errmsg); return false; } /* * Reset proper owner */ glfs_chown(m_glfs, getVolCatName(), st.st_uid, st.st_gid); } } return true; }
int main(int argc, char *argv[]) { int ret = -1; int flags = O_RDWR | O_SYNC; glfs_t *fs = NULL; glfs_fd_t *fd = NULL; char *volname = NULL; char *logfile = NULL; const char *filename = "file_tmp"; struct glfs_object *object = NULL; acl_t acl = NULL; struct stat sb; if (argc != 3) { fprintf(stderr, "Invalid argument\n"); return 1; } volname = argv[1]; logfile = argv[2]; fs = glfs_new(volname); if (!fs) VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out); ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out); ret = glfs_set_logging(fs, logfile, 7); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out); ret = glfs_init(fs); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out); fd = glfs_creat(fs, filename, flags, 0044); if (fd == NULL) { ret = -1; VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out); } glfs_close(fd); object = glfs_h_lookupat(fs, NULL, filename, NULL, 0); if (object == NULL) { ret = -1; VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", ret, out); } ret = glfs_chown(fs, filename, 99, 99); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_chown", ret, out); ret = glfs_setfsuid(99); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsuid", ret, out); ret = glfs_setfsgid(99); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsgid", ret, out); acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS); if (acl == NULL) { ret = -1; VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out); } ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl); VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out); out: glfs_setfsuid(0); glfs_setfsgid(0); if (object) glfs_h_close(object); if (fs) glfs_fini(fs); return ret; }
int glfs_java_chown(glfs_t *glfs, const char *path, unsigned int uid, unsigned int gid){ return glfs_chown (glfs, path, uid, gid); }