コード例 #1
0
int main(int argc, char *argv[])
{

	int  src, dest;
	struct stat64 sbuf, sbuf2;
	time_t copy_time;
	off64_t size=0, total_size;
	size_t buffer_size = DEFAULT_BUFFER; /* transfer buffer size */
	int rc ;
	char filename[MAXPATHLEN],*inpfile, *outfile;
	char formatted_rate[12], formatted_size[12];
	char extraOption[MAXPATHLEN];
	char allocSpaceOption[MAXPATHLEN];
	char *cp ;
	int c;
	int overwrite = 1;
	int isStdin = 0;
	mode_t mode = 0666;
	char *firstP, *lastP;
	unsigned short first_port, last_port;
	int stage = 0;
	int stagetime = 0;
	int unsafeWrite = 0;
	char *stagelocation = NULL;
	int ahead = 0;
	size_t ra_buffer_size = 1048570L;
	int doCheckSum = 1;

	/* for getopt */
	extern char *optarg;
	extern int optind;

	if (argc < 3) {
		usage();
	}

	extraOption[0] = '\0';
	allocSpaceOption[0] = '\0';

	if( getenv("DCACHE_SHOW_PROGRESS") != NULL) {
		is_feedback_enabled = 1;
	}

	/* FIXME removing the DC_LOCAL_CACHE_BUFFER environment
	 * variable vetos dcap's use of the lcb (the local cache).
	 * This is an ugly work-around needed because the current lcb
	 * code gives terrible performance when the client streams
	 * data in large chunks.  Rather than rewrite LCB, we
	 * introduce this as a "temporary" work-around.
	 *
	 * Although clients should tune their software for their
	 * access patterns, this is "impossible" (or at least
	 * unlikely); therefore LCB should be rewritten to provide
	 * better performance in this case.
	 */
	unsetenv("DC_LOCAL_CACHE_BUFFER");

	while( (c = getopt(argc, argv, "Ad:o:h:iX:Pt:l:aB:b:up:T:r:s:w:cC:H")) != EOF) {

		switch(c) {
			case 'd':
				dc_setStrDebugLevel(optarg);
				break;
			case 'o':
				dc_setOpenTimeout(atol(optarg));
				break;
			case 'h':
				dc_setReplyHostName(optarg);
				break;
			case 'i':
				overwrite = 0;
				break;
			case 'P':
				stage = 1;
				break;
			case 't' :
				stagetime = atoi(optarg);
				break;
			case 'l' :
				stagelocation = optarg;
				break;
			case 'B' :
				buffer_size = atol(optarg);
				break;
			case 'a' :
				ahead = 1;
				break;
			case 'b' :
				ra_buffer_size = atol(optarg);
				break;
			case 'X':
				dc_snaprintf(extraOption, sizeof(extraOption), " %s", optarg);
				break;
			case 'u':
				unsafeWrite = 1;
				break;
			case 'p':
				lastP = strchr(optarg, ':');
				if( lastP == NULL ) {
				    first_port = atoi(optarg);
					last_port = first_port;
				}else{
				    firstP = optarg; /*just to be simple */
					lastP[0] = '\0';

				    first_port = atoi(firstP);
					last_port = atoi(lastP +1);

				}

				dc_setCallbackPortRange(first_port, last_port);
				break;
			case 'T':
				dc_setTunnel(optarg);
				break;
			case 'r':
				dc_setTCPReceiveBuffer( atoi(optarg) );
				break;
			case 's':
				dc_setTCPSendBuffer( atoi(optarg) );
				break;
			case 'w':
				dc_setTunnelType(optarg);
				break;
			case 'c':
				doCheckSum = 0;
				break;
			case 'A':
				dc_setClientActive();
				break;
			case 'C':
				dc_setCloseTimeout(atoi(optarg));
				break;
		        case 'H':
				is_feedback_enabled=1;
				break;
			case '?':
				usage();

		}
	}

	if(((argc - optind) != 2) && (!stage)) {
		usage();
	}

#ifndef WIN32
	dcap_signal();
#endif

	inpfile = argv[optind];
	if(stage) {
		dc_setExtraOption(extraOption);
		if ( (rc = dc_stage(inpfile, stagetime, stagelocation)) < 0 ) {
			dc_perror("dc_stage fail");
			rc = -1;
		}
		return rc;
	}

	outfile = argv[optind+1];

#ifndef WIN32
	if(strcmp(inpfile, "-") == 0) {
		isStdin = 1;
		src = fileno(stdin);
		inpfile = strdup("/dev/stdin");
	}

	if(strcmp(outfile, "-") == 0) {
		outfile = strdup("/dev/stdout");
	}
#endif /* WIN32 */

	if(!isStdin) {
		dc_setExtraOption(extraOption);
		rc = dc_stat64(inpfile, &sbuf);
		if ( (rc == 0) && ( S_ISDIR(sbuf.st_mode) || S_ISCHR(sbuf.st_mode)) ) {
			fprintf(stderr,"file %s: Not a regular file\n",inpfile);
			return -1 ;
		}

		if( rc == 0 ) {
			/* if file do not exist it can be a url, and
				dc_open will handle this */
			mode = sbuf.st_mode & 0777;
			/* tell to pool how many bytes we want to write */
#ifdef WIN32
			dc_snaprintf(allocSpaceOption, sizeof(allocSpaceOption),
			             " -alloc-size=%lld", (__int64)sbuf.st_size);
#else
			dc_snaprintf(allocSpaceOption, sizeof(allocSpaceOption),
			             " -alloc-size=%lld", (long long)sbuf.st_size);
#endif
		}
		total_size = sbuf.st_size;
	} else {
		total_size = SIZE_FOR_UNKNOWN_TRANSFER_LENGTH;
	}

	dc_setExtraOption(extraOption);
	if ( dc_stat64( outfile, &sbuf2) == 0 &&  S_ISDIR(sbuf2.st_mode) ) {
		if ( (cp = strrchr(inpfile,PATH_SEPARATOR))  != NULL  ) {
			cp++;
		}else{
			cp = inpfile;
		}
		sprintf(filename, "%s%c%s", outfile, PATH_SEPARATOR, cp);
	}else{
		strcpy(filename,outfile) ;
	}

	dc_setExtraOption(extraOption);
	if((!overwrite) && (dc_access(filename, F_OK) == 0)) {
		fprintf(stderr, "%s: Skipping existing file %s.\n", argv[0], filename);
		return 0;
	}

	errno = 0 ;

	if(!isStdin) {
		dc_setExtraOption(extraOption);
		src = dc_open(inpfile,O_RDONLY | O_BINARY );
		if (src < 0) {
			dc_perror("Can't open source file");
			return -1;
		}
	}

	if(!ahead || (ra_buffer_size <= buffer_size)) {
		dc_noBuffering(src);
	}else{
		dc_setBufferSize(src,ra_buffer_size);
	}

	errno = 0 ;

#ifdef WIN32
	mode = _S_IWRITE ;
#endif /* WIN32 */

	dc_setExtraOption(extraOption);
	dc_setExtraOption(allocSpaceOption);
	dest = dc_open( filename, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, mode|S_IWUSR);
	if (dest < 0) {
		dc_perror("Can't open destination file");
		return -1;
	}

	if(unsafeWrite) {
		dc_unsafeWrite(dest);
	}

	if( ! doCheckSum ) {
		dc_noCheckSum(dest);
	}

	elapsed_transfer_time( ett_set);
	rc = copyfile(src, dest, buffer_size, &size, total_size);

	if (dc_close(src) < 0) {
		perror("Failed to close source file");
		rc = -1;
	}

	if (dc_close(dest) < 0) {
		perror("Failed to close destination file");
		dc_stat64( outfile, &sbuf2);
		mode = sbuf2.st_mode & S_IFMT;
		if (mode == S_IFREG) dc_unlink(outfile);
		rc = -1;
	}

	if (rc != -1 )  {
		copy_time = elapsed_transfer_time(ett_measure);
		dc_bytes_as_size(formatted_size, size);
		fprintf(stderr,"%ld bytes (%s) in %lu seconds", size, formatted_size, copy_time);
		if ( copy_time > 0) {
			dc_bytes_as_size(formatted_rate, (double)size / copy_time);
			fprintf(stderr," (%s/s)\n", formatted_rate);
		}else{
			fprintf(stderr,"\n");
		}
	}else{
		fprintf(stderr,"dccp failed.\n");

		/* remove destination if copy failed */
		dc_stat64( outfile, &sbuf2);
		mode = sbuf2.st_mode & S_IFMT;
		if (mode == S_IFREG) dc_unlink(outfile);
	}

	return rc;
}
コード例 #2
0
ファイル: dcsuck.c プロジェクト: ic-hep/emi3
int main(int argc, char *argv[])
{

	int  src, dest, c;
	struct stat64 sbuf;
	ssize_t data_len;
	int rc;
	char extraOption[MAXPATHLEN];



	if( argc < 3 ) {
		fprintf(stderr,"usage: %s <path in dcache> <local path>\n",argv[0]);
		exit(1);
	}


	extraOption[0] = '\0';

	while( (c = getopt(argc, argv, "Ad:o:h:iX:Pt:l:aB:b:up:T:r:s:w:c")) != EOF) {

		switch(c) {
			case 'd':
				dc_setStrDebugLevel(optarg);
				break;
			case 'X':
				dc_snaprintf(extraOption, sizeof(extraOption),
				             " %s", optarg);
				break;
		}
	}


	rc = dc_stat64(argv[optind], &sbuf);

	if ( (rc == 0) && ( S_ISDIR(sbuf.st_mode) || S_ISCHR(sbuf.st_mode)) ) {
		fprintf(stderr,"file %s: Not a regular file\n",argv[optind]);
		return -1 ;
	}

	rc = 0;
	dc_setExtraOption(extraOption);
	src = dc_open(argv[optind], O_RDONLY );
	if( src < 0 ) {
		dc_perror("Can't open source file");
		return -1;
	}
	dest = dc_open( argv[optind+1], O_WRONLY|O_CREAT|O_TRUNC, (sbuf.st_mode & 0777) | S_IWUSR);
	if( dest < 0 ) {
		dc_perror("Can't open destination file");
		dc_close(src);
		return -2;
	}

	data_len = dc_readTo(src, dest, sbuf.st_size);
	if( data_len != sbuf.st_size) {
		fprintf(stderr,"recived data (%lld) .NE. file size(%lld) \n", data_len, sbuf.st_size);
		rc = -3;
	}

	dc_close(src);
	close(dest);

	return rc;
}