xnftp.c

早期freebsd实现

{
	struct timeval start, stop, time;
	FilingSubset1_StoreResults storeresults;
	Filing4_StoreResults storeresults2;
	FilingSubset1_Handle dirhandle;
	FilingSubset1_AttributeSequence attrseq;
	FilingSubset1_Attribute	attrvals[5];

	gettimeofday(&time, (struct timezone *) 0);

	if (dest) {
		getdirhandle(dest, dirhandle);
	} else {
		printf("No remote name specified\n");
		return;
	}

	bytessent= 0;
	alarm(0);

	attrseq.length= 3;
	attrseq.sequence= attrvals;

	if ( filing_subset ) {
		attrvals[0].type= FilingSubset1_pathname;
		StringToAttr(cur_pathname, &attrvals[0]);
	} else {
		attrvals[0].type= FilingSubset1_name;
		StringToAttr(cur_name, &attrvals[0]);
	}
	attrvals[1].type = FilingSubset1_isDirectory;
	BooleanToAttr(TRUE, &attrvals[1]);
	attrvals[2].type = FilingSubset1_type;
	LongCardinalToAttr(FilingSubset1_tDirectory, &attrvals[2]);
	gettimeofday(&start, (struct timezone *)0);
	if ( filing_subset )
		storeresults = FilingSubset1_Store(connected, BDTclosewrite,
					       dirhandle, attrseq,
					       nullControls,
					       BulkData1_immediateSource, session);
	else
		storeresults2 = Filing4_Store(connected, BDTclosewrite,
					       dirhandle, attrseq,
					       nullControls,
					       BulkData1_immediateSource, session);
	alarm(continuetime);
	gettimeofday(&stop, (struct timezone *)0);
	if ( filing_subset )
		freefilehandle(storeresults.file);
	else
		freefilehandle(storeresults2.file);

	freefilehandle(dirhandle);
}

doremovedir(src)
	char *src;
{
	dodelete(src);
}

dostore(src, dest)
	char *src, *dest;
{
	sendrequest("STOR", src, dest);
}

doappend(src, dest)
	char *src, *dest;
{
	NYI();
}

dorename(src, dest)
	char *src, *dest;
{
	Filing4_Handle srchandle, dirhandle;
	Filing4_AttributeSequence attrseq;
	Filing4_Attribute attrvals[1];

	if ( filing_subset ) {
		NotAvailableUnderSubset("Rename function not available");
		return;
	}

	if ( index(dest, '/') != 0 ) {		/* rename across directory */
		docopy("MOVE", src, dest);	/* use move */
		return;
	}

	getdirhandle(src, dirhandle);
	getfilehandle(cur_pathname, srchandle);

	attrseq.length= 1;
	attrseq.sequence= attrvals;

	attrvals[0].type= Filing4_name;
	StringToAttr(dest, &attrvals[0]);

	if (verbose) {
		printf("renaming %s to %s...\n", src, dest);
	}

	alarm(0);
	Filing4_ChangeAttributes(connected, NULL, srchandle, attrseq, session);
	alarm(continuetime);

	freefilehandle(srchandle);
	freefilehandle(dirhandle);
}

docopy(cmd, src, dest)
	char *cmd, *src, *dest;
{
	Filing4_Handle srchandle, srcdirhandle, dirhandle, newhandle;
	Filing4_AttributeSequence attrseq;
	Filing4_Attribute attrvals[1];
	Filing4_AttributeTypeSequence typeseq;
	Filing4_AttributeType attrs[2];
	Filing4_ScopeSequence scopeseq;
	Filing4_Scope scope;
	Filing4_CopyResults copyresults;
	Boolean copy= FALSE;

	if ( filing_subset ) {
		NotAvailableUnderSubset("Copy/Move function not available");
		return;
	}

	if ( strcmp(cmd, "COPY") == 0 )
		copy= TRUE;

	getdirhandle(src, srcdirhandle);
	getfilehandle(cur_pathname, srchandle);
	freefilehandle(srcdirhandle);

	getdirhandle(dest, dirhandle);

	typeseq.length= 2; typeseq.sequence= attrs;
	attrs[0]= Filing4_isDirectory;
	attrs[1]= Filing4_pathname;

	scopeseq.length= 1; scopeseq.sequence= &scope;
	scope.designator= Filing4_filter;
	scope.Filing4_filter_case.designator= Filing4_matches;
	scope.Filing4_filter_case.Filing4_matches_case.attribute.type= Filing4_name;
	StringToAttr(cur_name, &scope.Filing4_filter_case.Filing4_matches_case.attribute);
	ProcEachSeq= isdirproc;
	isdir= FALSE;

	alarm(0);	
	Filing4_List(connected, GetAttributeSequences, dirhandle, typeseq,
		     scopeseq, BulkData1_immediateSink, session);
	alarm(continuetime);

	if ( isdir ) {
		getfilehandle(cur_pathname, dirhandle);	/* open directory as file */

		attrseq.length= 0;
		attrseq.sequence= attrvals;
	} else {
		attrseq.length= 1;
		attrseq.sequence= attrvals;

		attrvals[0].type= Filing4_name;
		StringToAttr(cur_name, &attrvals[0]);
	}

	if (verbose) {
		if ( copy )
			printf("copying ");
		else 
			printf("moving ");
		printf("%s to %s%s%s...\n", src, dest, (isdir ? "/" : ""), 
						(isdir ? src : ""));
	}

	alarm(0);
	if ( copy ) {
		copyresults= Filing4_Copy(connected, NULL, srchandle, dirhandle,
					  attrseq, nullControls, session);

		freefilehandle(copyresults.newFile);
	} else {
		Filing4_Move(connected, NULL, srchandle, dirhandle,
			     attrseq, session);
	}
	alarm(continuetime);

	freefilehandle(srchandle);
	freefilehandle(dirhandle);
}

dounify(remote)
	char *remote;
{
	Filing4_Handle dirhandle, remotehandle;

	if ( filing_subset ) {
		NotAvailableUnderSubset("Unify AccessLists");
		return;
	}

	getdirhandle(remote, dirhandle);
	getfilehandle(cur_pathname, remotehandle);
	freefilehandle(dirhandle);

	if ( verbose ) {
		printf("unify access lists for %s\n", remote);
	}

	alarm(0);
	Filing4_UnifyAccessLists(connected, NULL, remotehandle, session);
	alarm(continuetime);

	freefilehandle(remotehandle);

}
recvrequest(cmd, local, remote, mode)
	char *cmd, *local, *remote, *mode;
{
	FILE *popen();
	int (*closefunc)(), pclose(), fclose();
	int do_unlink= FALSE;
	int pos, i;
	struct timeval start, stop;
	FilingSubset1_Handle remotehandle; /* note: an array */
	FilingSubset1_Handle dirhandle; /* note: an array */
	FilingSubset1_AttributeTypeSequence typeseq;
	FilingSubset1_AttributeType tsvals[10];
	char *dir;
	FilingSubset1_ScopeSequence scopeseq;
	FilingSubset1_Scope scope;

	closefunc = NULL;

	fout = stdout;
	typeseq.length = 0;  typeseq.sequence = tsvals;
	scopeseq.length= 1; scopeseq.sequence= &scope;
	scope.designator= FilingSubset1_filter;
	scope.FilingSubset1_filter_case.designator= FilingSubset1_matches;
	if ( filing_subset )
		scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_pathname;
	else
		scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_name;
	timbuf[0].tv_sec= 0;

	copyhandle(remotehandle, FilingSubset1_nullHandle);

	if (strcmp(local, "-") && *local != '|')
		if (access(local, 2) < 0) {
			dir = rindex(local, '/');
			/* get a good error message */
			if (dir != NULL) *dir = '\0';
			if (access(dir ? local : ".", 2) < 0) {
				perror(local);
				goto bad;
			}
			if (dir != NULL) *dir = '/';
		}
	if (strcmp(local, "-") == 0)
		fout = stdout;
	else if (*local == '|') {
		char *ptr;
		ptr= local+1;
		while (isspace(*ptr)) ptr++;
		fout = popen(ptr, "w");
		if (fout == NULL) {
			perror(ptr);
			goto bad;
		}
		closefunc = pclose;
	} else {
		fout = fopen(local, mode);
		if (fout == NULL) {
			perror(local);
			goto bad;
		}
		closefunc = fclose;
	}

	if (remote) {
		getdirhandle(remote, dirhandle);
	}
	bytessent= 0;
	filetypevalue= typevalue;

	if ( filing_subset )
		StringToAttr(cur_pathname+1,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
	else
		StringToAttr(cur_name,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);

	if (strcmp(cmd,"NLST") == 0) {
		typeseq.length = 1;
		typeseq.sequence[0] = FilingSubset1_pathname;
		ProcEachSeq = nlistproc;
		alarm(0);
		gettimeofday(&start, (struct timezone *)0);
		if ( filing_subset )
			FilingSubset1_List(connected, GetAttributeSequences, dirhandle,
				     typeseq, scopeseq,
				     BulkData1_immediateSink, session);
		else
			Filing4_List(connected, GetAttributeSequences, dirhandle,
				     typeseq, scopeseq,
				     BulkData1_immediateSink, session);
		alarm(continuetime);
	}
	else if (strcmp(cmd,"LIST") == 0) {
		typeseq.length = 7;
		if ( filing_subset )
			typeseq.sequence[0] = FilingSubset1_pathname;
		else
			typeseq.sequence[0] = FilingSubset1_name;
		typeseq.sequence[1] = FilingSubset1_dataSize;
		typeseq.sequence[2] = FilingSubset1_isDirectory;
		typeseq.sequence[3] = FilingSubset1_isTemporary;
		typeseq.sequence[4] = FilingSubset1_type;
		typeseq.sequence[5] = FilingSubset1_createdOn;
		typeseq.sequence[6] = FilingSubset1_version;
		ProcEachSeq = listproc;
		alarm(0);
		gettimeofday(&start, (struct timezone *)0);
		if ( filing_subset )
			FilingSubset1_List(connected, GetAttributeSequences, dirhandle,
				     typeseq, scopeseq,
				     BulkData1_immediateSink, session);
		else
			Filing4_List(connected, GetAttributeSequences, dirhandle,
				     typeseq, scopeseq,
				     BulkData1_immediateSink, session);
		alarm(continuetime);
	}
	else if (strcmp(cmd,"RETR") == 0) {
		typeseq.length= 4;
		typeseq.sequence[0]= FilingSubset1_createdOn;
		typeseq.sequence[1]= FilingSubset1_pathname;
		typeseq.sequence[2]= FilingSubset1_type;
		typeseq.sequence[3]= FilingSubset1_isDirectory;

		is_a_directory= FALSE;
		ProcEachSeq= rlistproc;

		alarm(0);
		if ( filing_subset )
			FilingSubset1_List(connected, GetAttributeSequences, dirhandle,
				     typeseq, scopeseq,
				     BulkData1_immediateSink, session);
		else 
			Filing4_List(connected, GetAttributeSequences, dirhandle,
				     typeseq, scopeseq,
				     BulkData1_immediateSink, session);

		alarm(continuetime);

		if ( files_found ) {
			if ( is_a_directory && (filetypevalue == FilingSubset1_tDirectory) ) {
				if ( filing_subset ) {
					NotAvailableUnderSubset("Cannot retrieve directory files");
					do_unlink= TRUE;
					goto error;
				}
			}

			if (verbose) {
			 	printf("%s...(%s)...", local, typetostring(filetypevalue));
				fflush(stdout);
			}

			if ( (filetypevalue == FilingSubset1_tDirectory) ||
					((filetypevalue > LAST_FILING_TYPE) &&
					(filetypevalue != TYPE_Interpress) &&
					(filetypevalue != TYPE_VPCanvas))  ) {
				if ( filing_subset ) {
					NotAvailableUnderSubset("Cannot retrieve Viewpoint files");
					do_unlink= TRUE;
					goto error;
				}

				alarm(0);
				ProcEachSeq= GetAllAttributes;
				Filing4_List(connected, GetAttributeSequences, dirhandle,
						Filing4_allAttributeTypes, scopeseq,
						BulkData1_immediateSink, session);
				alarm(continuetime);
			}

			bytessent= 0;
			getfilehandle(cur_pathname, remotehandle);	/* get file handle */
			alarm(0);
			gettimeofday(&start, (struct timezone *)0);
			if ( filing_subset ) {
				FilingSubset1_Retrieve(connected, retrieveproc, remotehandle,
						 BulkData1_immediateSink, session);
			} else {
				if ( is_a_directory )
					Filing4_Serialize(connected, retrieveproc, remotehandle,
						BulkData1_immediateSink, session);
				else
					Filing4_Retrieve(connected, retrieveproc, remotehandle,
						 BulkData1_immediateSink, session);
			}
			alarm(continuetime);
		}
	} else if (strcmp(cmd,"SER") == 0) {
		ProcEachSeq= GetAllAttributes;

		alarm(0);
		if ( filing_subset ) {
			NotAvailableUnderSubset("Cannot serialize files");
			do_unlink= TRUE;
			goto error;
		} else {
			Filing4_List(connected, GetAttributeSequences, dirhandle,
					Filing4_allAttributeTypes, scopeseq,
					BulkData1_immediateSink, session);
		}
		alarm(continuetime);

		if ( files_found ) {
			if (verbose) {
			 	printf("%s to %s...(%s)...",cur_pathname, local, typetostring(filetypevalue));
				fflush(stdout);
			}

			bytessent= 0;
			getfilehandle(cur_pathname, remotehandle);	/* get file handle */
			alarm(0);
			gettimeofday(&start, (struct timezone *)0);
			Filing4_Serialize(connected, retrieveproc, remotehandle,
					BulkData1_immediateSink, session);
			alarm(continuetime);
		}
	}
	else printf("unrecognized command %s\n",cmd);
	gettimeofday(&stop, (struct timezone *)0);
	freefilehandle(remotehandle);

	if ( files_found ) {
		if (bytessent > 0 && verbose)
			ptransfer("received", bytessent, &start, &stop);
	} else {
		printf("%s not found\n",cur_pathname);
		do_unlink= TRUE;
	}

error: