Пример #1
0
int do_pwrite(long fd, const char *buffer, int length, int offset)
{
	if(do_chirp) {
		return chirp_reli_pwrite((struct chirp_file *) fd, buffer, length, offset, stoptime);
	} else {
		return full_pwrite(fd, buffer, length, offset);
	}
}
Пример #2
0
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;
}
Пример #3
0
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;
}
Пример #4
0
INT64_T chirp_global_pwrite(struct chirp_file * file, const void *buffer, INT64_T length, INT64_T offset, time_t stoptime)
{
	return chirp_reli_pwrite(file, buffer, length, offset, stoptime);
}