int do_close(long fd) { if(do_chirp) { return chirp_reli_close((struct chirp_file *) fd, stoptime); } else { return close(fd); } }
void chirp_matrix_close(struct chirp_matrix *a, time_t stoptime) { int i; for(i = 0; i < a->nfiles; i++) chirp_reli_close(a->rfiles[i], stoptime); free(a->bulkio); free(a->rfiles); free(a); }
struct chirp_matrix *chirp_matrix_open(const char *host, const char *path, time_t stoptime) { int result, i; char *line; char *tmp; struct chirp_matrix *matrix; matrix = xxmalloc(sizeof(*matrix)); result = chirp_reli_getfile_buffer(host, path, &line, stoptime); if(result < 0) { debug(D_CHIRP, "matrix: could not create metadata file /chirp/%s/%s: %s\n", host, path, strerror(errno)); return 0; } tmp = strtok(line, SEPCHARS); matrix->width = atoi(tmp); tmp = strtok(NULL, SEPCHARS); matrix->height = atoi(tmp); tmp = strtok(NULL, SEPCHARS); matrix->element_size = atoi(tmp); tmp = strtok(NULL, SEPCHARS); matrix->nhosts = atoi(tmp); tmp = strtok(NULL, SEPCHARS); matrix->nfiles = atoi(tmp); matrix->n_row_per_file = matrix->height / matrix->nfiles; if(matrix->height % matrix->nfiles) matrix->n_row_per_file++; matrix->rfiles = malloc(sizeof(struct chirp_file *) * matrix->nfiles); matrix->bulkio = malloc(sizeof(struct chirp_bulkio) * matrix->nfiles); for(i = 0; i < matrix->nfiles; i++) { char *host = strtok(NULL, SEPCHARS); char *path = strtok(NULL, SEPCHARS); matrix->rfiles[i] = chirp_reli_open(host, path, O_RDWR | O_CREAT, 0755, stoptime); if(!matrix->rfiles[i]) { int j; for(j = 0; j < i; j++) chirp_reli_close(matrix->rfiles[i], stoptime); free(line); return 0; } } free(line); return matrix; }
static INT64_T do_put_one_fifo(const char *hostport, const char *source_file, const char *target_file, int mode, time_t stoptime) { FILE *file; int save_errno; struct chirp_file *cf = 0; INT64_T result; INT64_T offset = 0; file = fopen64(source_file, "r"); if(!file) return -1; cf = chirp_reli_open(hostport, target_file, O_WRONLY|O_CREAT|O_TRUNC, 0600, stoptime); if(cf) { size_t n; char buffer[65536]; while((n = fread(buffer, sizeof(char), 65536, file))) { if(chirp_reli_pwrite(cf, buffer, n, offset, stoptime) < 0) goto fail; offset += n; } if (chirp_reli_close(cf, stoptime) < 0) goto fail; } result = offset; goto out; fail: result = -1; goto out; out: save_errno = errno; fclose(file); errno = save_errno; return result; }
static INT64_T chirp_thirdput_recursive(const char *subject, const char *lpath, const char *hostname, const char *rpath, const char *hostsubject, time_t stoptime) { struct chirp_stat info; INT64_T size = 0, result; char newlpath[CHIRP_PATH_MAX]; char newrpath[CHIRP_PATH_MAX]; int save_errno; int my_target_acl = 0; result = cfs->lstat(lpath, &info); if(result < 0) return result; if(S_ISDIR(info.cst_mode)) { CHIRP_FILE *aclfile; struct chirp_dir *dir; struct chirp_dirent *d; char aclsubject[CHIRP_PATH_MAX]; int aclflags; if(!chirp_acl_check_dir(lpath, subject, CHIRP_ACL_LIST)) return -1; // create the directory, but do not fail if it already exists result = chirp_reli_mkdir(hostname, rpath, 0700, stoptime); if(result < 0 && errno != EEXIST) return result; // set the access control to include the initiator result = chirp_reli_setacl(hostname, rpath, subject, "rwldax", stoptime); if(result < 0 && errno != EACCES) return result; // transfer each of the directory contents recurisvely dir = cfs->opendir(lpath); while((d = cfs->readdir(dir))) { if(!strcmp(d->name, ".")) continue; if(!strcmp(d->name, "..")) continue; if(!strncmp(d->name, ".__", 3)) continue; sprintf(newlpath, "%s/%s", lpath, d->name); sprintf(newrpath, "%s/%s", rpath, d->name); result = chirp_thirdput_recursive(subject, newlpath, hostname, newrpath, hostsubject, stoptime); if(result >= 0) { size += result; } else { result = -1; break; } } save_errno = errno; // finally, set the acl to duplicate the source directory, // but do not take away permissions from me or the initiator cfs->closedir(dir); aclfile = chirp_acl_open(lpath); if(!aclfile) return -1; while(chirp_acl_read(aclfile, aclsubject, &aclflags)) { // wait until the last minute to take away my permissions if(!strcmp(aclsubject, hostsubject)) { my_target_acl = aclflags; } // do not take permissions away from the initiator if(!strcmp(aclsubject, subject)) { continue; } chirp_reli_setacl(hostname, rpath, aclsubject, chirp_acl_flags_to_text(aclflags), stoptime); } chirp_acl_close(aclfile); // after setting everything else, then set my permissions from the ACL chirp_reli_setacl(hostname, rpath, hostsubject, chirp_acl_flags_to_text(my_target_acl), stoptime); errno = save_errno; if(result >= 0) { return size; } else { return -1; } } else if(S_ISLNK(info.cst_mode)) { if(!chirp_acl_check(lpath, subject, CHIRP_ACL_READ)) return -1; result = cfs->readlink(lpath, newlpath, sizeof(newlpath)); if(result < 0) return -1; return chirp_reli_symlink(hostname, newlpath, rpath, stoptime); } else if(S_ISREG(info.cst_mode)) { if(!chirp_acl_check(lpath, subject, CHIRP_ACL_READ)) return -1; int fd = cfs->open(lpath, O_RDONLY, 0); if(fd >= 0) { struct chirp_file *F = chirp_reli_open(hostname, rpath, O_WRONLY|O_CREAT|O_TRUNC, info.cst_mode, stoptime); if(F) { char buffer[65536]; INT64_T offset = 0; INT64_T nread; while ((nread = cfs->pread(fd, buffer, sizeof(buffer), offset)) > 0) { INT64_T nwritten = 0; while (nwritten < nread) { INT64_T nwrite = chirp_reli_pwrite(F, buffer+nwritten, nread-nwritten, offset, stoptime); if (nwrite == -1) { save_errno = errno; cfs->close(fd); chirp_reli_close(F, stoptime); errno = save_errno; return -1; } nwritten += nwrite; offset += nwrite; } } if(nread == -1) offset = -1; save_errno = errno; cfs->close(fd); chirp_reli_close(F, stoptime); errno = save_errno; return offset; } else { save_errno = errno; cfs->close(fd); errno = save_errno; return -1; } } else { return -1; } } else { return 0; } return -1; }
static INT64_T chirp_fs_chirp_close(int fd) { SETUP_FILE chirp_fs_file_table[fd] = 0; return chirp_reli_close(file, STOPTIME); }
INT64_T chirp_global_close(struct chirp_file * file, time_t stoptime) { return chirp_reli_close(file, stoptime); }