xnftp.c

早期freebsd实现

	freefilehandle(dirhandle);

bad:
	if (closefunc != NULL && fout != NULL) {
		(*closefunc)(fout);
		if ( closefunc == fclose ) {
	    		if (timbuf[0].tv_sec != 0 )
				utimes(local,&timbuf[0]);
		}
	}
	if ( do_unlink )
		unlink(local);

	fout = NULL;
}


sendrequest(cmd, local, remote)
	char *cmd, *local, *remote;
{
	FILE *popen();
	int (*closefunc)(), pclose(), fclose();
	struct stat st;
	struct timeval start, stop;
	FilingSubset1_StoreResults storeresults;
	Filing4_DeserializeResults deserializeresults;
	Filing4_StoreResults storeresults2;
	FilingSubset1_Handle dirhandle;
	FilingSubset1_AttributeSequence attrseq;
	FilingSubset1_Attribute attrvals[50];
	Boolean GetDirectoryAttribute();
	struct timeval time;
	long createdate;
	long datasize;

	gettimeofday(&time,(struct timezone *) 0);
	createdate= time.tv_sec + XNS_TIME_DIFFERENCE;
	filetypevalue= typevalue;

	closefunc = NULL;
	if (strcmp(local, "-") == 0) {
		fin = stdin;
		closefunc = NULL;
	} else if (*local == '|') {
		char *ptr;
		ptr= local+1;
		while (isspace(*ptr)) ptr++;
		fin = popen(ptr, "r");
		if (fin == NULL) {
			perror(ptr);
			return;
		}
		closefunc = pclose;
	} else {
		if (typevalue == TYPE_Guess) {
		    	filetypevalue= get_type(local);	/* guess file type */
		}
		fin = fopen(local, "r");
		if (fin == NULL) {
			perror(local);
			return;
		}
		closefunc = fclose;
		if (fstat(fileno(fin), &st) < 0 ||
		    (st.st_mode&S_IFMT) != S_IFREG) {
			fprintf(stderr, "%s: not a plain file.", local);
			fclose(fin);
			fin= NULL;
			return;
		}
		createdate= st.st_mtime + XNS_TIME_DIFFERENCE;
		datasize= st.st_size;
	}

	if (filetypevalue == TYPE_Guess)	/* if input from file, TYPE_G should already be replaced */
		filetypevalue= TYPE_A;	/* assume ascii for pipes/stdin... */

	if (remote) {
		getdirhandle(remote, dirhandle);
	} else {
		printf("No remote name specified\n");
		return;
	}
	bytessent = 0;
	if (strcmp(cmd,"STOR") == 0) {
		if (verbose) {
		 	printf("%s to %s...",local,remote);
			fflush(stdout);
		}
		attrseq.length = 1;
		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]);
		}

		if ( (filetypevalue == TYPE_Directory) ||
				((filetypevalue > LAST_FILING_TYPE) && 
				(filetypevalue != TYPE_Interpress) &&
				(filetypevalue != TYPE_VPCanvas)) ) {
			isdir= GetDirectoryAttribute(fin);
		} else {
			isdir= FALSE;
		}

		if ( !isdir ) {
			attrseq.length += 4;
			attrvals[1].type = FilingSubset1_type;
			LongCardinalToAttr(filetypevalue, &attrvals[1]);
			attrvals[2].type = FilingSubset1_createdOn;
			LongCardinalToAttr(createdate,&attrvals[2]);
			attrvals[3].type= FilingSubset1_isDirectory;
			BooleanToAttr(FALSE, &attrvals[3]);
			attrvals[4].type= FilingSubset1_dataSize;
			LongCardinalToAttr(datasize, &attrvals[4]);
		}

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

		if ( (filetypevalue == TYPE_Directory) ||
				((filetypevalue > LAST_FILING_TYPE) && 
				(filetypevalue != TYPE_Interpress) &&
				(filetypevalue != TYPE_VPCanvas)) ) {
			if ( filing_subset ) {
				NotAvailableUnderSubset("Cannot store Viewpoint files");
				goto error;
			}
			if ( isdir ) {
				if ( AddExtendedDeserializeAttributes(fin, &attrseq) == 0 ) {
					goto error;
				}
			} else {
				if ( AddExtendedStoreAttributes(fin, &attrseq) == 0 ) {
					goto error;
				}
			}
		}

		alarm(0);
		gettimeofday(&start, (struct timezone *)0);
		if ( filing_subset ) {
			storeresults = FilingSubset1_Store(connected, storeproc,
						     dirhandle, attrseq,
						     nullControls,
						     BulkData1_immediateSource,
						     session);
		} else {
			if ( isdir )
				deserializeresults = Filing4_Deserialize(connected, storeproc,
						dirhandle, attrseq,
						nullControls,
						BulkData1_immediateSource,
						session);
			else
				storeresults2 = Filing4_Store(connected, storeproc,
						dirhandle, attrseq,
						nullControls,
						BulkData1_immediateSource,
						session);
		}
		alarm(continuetime);
		gettimeofday(&stop, (struct timezone *)0);
		if ( filing_subset ) {
			freefilehandle(storeresults.file);
		} else {
			if ( isdir )
				freefilehandle(deserializeresults.file);
			else
				freefilehandle(storeresults2.file);
		}
	} else if (strcmp(cmd,"DSER") == 0) {
		if ( filing_subset ) {
			NotAvailableUnderSubset("Cannot Deserialize files");
			goto error;
		}
		if (verbose) {
		 	printf("%s to %s...",local,remote);
			fflush(stdout);
		}
		attrseq.length = 1;
		attrseq.sequence = attrvals;
		attrvals[0].type = FilingSubset1_name;
		StringToAttr(cur_name, &attrvals[0]);

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

		if ( AddExtendedDeserializeAttributes(fin, &attrseq) == 0 ) {
					goto error;
		}

		alarm(0);
		gettimeofday(&start, (struct timezone *)0);
		deserializeresults = Filing4_Deserialize(connected, storeproc,
				dirhandle, attrseq, nullControls,
				BulkData1_immediateSource, session);
		alarm(continuetime);
		gettimeofday(&stop, (struct timezone *)0);
		freefilehandle(deserializeresults.file);
	} 
	else {
		printf("unrecognized command %s\n",cmd);
		alarm(continuetime);
	}
	if (bytessent > 0 && verbose)
		ptransfer("sent", bytessent, &start, &stop);
error:
	freefilehandle(dirhandle);
	if (closefunc != NULL && fin != NULL)
		(*closefunc)(fin);
	fin = NULL;
}



docd(dest)
	char *dest;
{
	FilingSubset1_AttributeSequence attrseq;
	FilingSubset1_AttributeTypeSequence typeseq;
	Boolean current= FALSE;
	FilingSubset1_AttributeType cdattrs[2];
	FilingSubset1_ScopeSequence scopeseq;
	FilingSubset1_Scope scope;
	FilingSubset1_Handle remotehandle;

	if (dest == (char*)NULL || *dest == '\0' || (strcmp(dest, "/") == 0) ) {
		getdirhandle("/", remotehandle);
		strcpy(cur_dir, "/");
		dopwd();
		return;
	} else {
		getdirhandle(dest, remotehandle);
	}

	isdir= FALSE;

	if ( filing_subset ) {
		StringToAttr(cur_pathname+1,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
		scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_pathname;
	} else {
		StringToAttr(cur_name,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
		scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_name;
	}
	typeseq.length = 2; typeseq.sequence = cdattrs;
	cdattrs[0] = FilingSubset1_isDirectory;
	cdattrs[1] = FilingSubset1_pathname;
	scopeseq.length= 1; scopeseq.sequence= &scope;
	scope.designator= FilingSubset1_filter;
	scope.FilingSubset1_filter_case.designator= FilingSubset1_matches;
	ProcEachSeq= cdproc;
	alarm(0);
	if ( filing_subset )
		FilingSubset1_List(connected, GetAttributeSequences, remotehandle, typeseq,
			     scopeseq, BulkData1_immediateSink, session);
	else
		Filing4_List(connected, GetAttributeSequences, remotehandle, typeseq,
			     scopeseq, BulkData1_immediateSink, session);

	alarm(continuetime);
	freefilehandle(remotehandle);

	if ( files_found == FALSE ) {
		printf("%s not found\n", dest);
	} else if ( !isdir ) {
		printf("%s not a directory\n", dest);
	} else {
		if ( dest[0] != '/' ) {
			if ( strcmp(cur_dir, "/") != 0 )
				strcat(cur_dir, "/");
			strcat(cur_dir, dest);
		} else {
		    	strcpy(cur_dir, dest);
		}
		if (verbose) dopwd();
	}

}

dopwd()
{
	printf("Remote working directory:  %s\n",cur_dir);
}
	
dodelete(src)
	char *src;
{
	int i;
	FilingSubset1_Handle remotehandle;
	FilingSubset1_Handle dirhandle;
	FilingSubset1_AttributeSequence attrseq;
	FilingSubset1_AttributeTypeSequence typeseq;
	FilingSubset1_AttributeType delattrs[2];
	FilingSubset1_ScopeSequence scopeseq;
	FilingSubset1_Scope scope;

	typeseq.length = 2; typeseq.sequence= delattrs;
	delattrs[0] = FilingSubset1_type;
	delattrs[1]= FilingSubset1_pathname;

	scopeseq.length= 1; scopeseq.sequence= &scope;
	scope.designator= FilingSubset1_filter;
	scope.FilingSubset1_filter_case.designator= FilingSubset1_matches;

	name_count= 0;
	name_size= MAXNAMES;
	if ( (name_list= (struct name_entry *)malloc(sizeof(struct name_entry) * name_size)) == 0 ) {
		perror("dodelete");
		return;
	}

	getdirhandle(src, dirhandle);

	if ( filing_subset ) {
		scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_pathname;
		StringToAttr(cur_pathname+1,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
	} else {
		scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute.type= FilingSubset1_name;
		StringToAttr(cur_name,&scope.FilingSubset1_filter_case.FilingSubset1_matches_case.attribute);
	}

	ProcEachSeq= deleteproc;
	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);
	freefilehandle(dirhandle);

	for ( i= 0 ; i < name_count ; i++ ) {
		struct name_entry *entry;

		entry= &name_list[i];
		if ( verbose ) {
			if ( entry->type == TYPE_Directory ) {
				if (!confirm("Delete directory", entry->pathname) ) {
					clear_String(&entry->pathname);
					continue;
				}
			} else if ( entry->type == TYPE_VPDrawer ) {
				if (!confirm("Delete file drawer", entry->pathname) ) {
					clear_String(&entry->pathname);
					continue;
				}
			} else {
				if (!confirm("Delete file",entry->pathname) ) {
					clear_String(&entry->pathname);
					continue;
				}
			}
		}

		getfilehandle(entry->pathname,remotehandle);
		alarm(0);
		if ( filing_subset )
			FilingSubset1_Delete(connected, NULL, remotehandle, session);
		else
			Filing4_Delete(connected, NULL, remotehandle, session);
		alarm(continuetime);

		clear_String(&entry->pathname);
	}
}

NYI()
{
	printf("Not yet implemented\n");
}

NotAvailableUnderSubset(message)
char *message;
{
	printf("%s under Subset,\n  Reopen connection with -F switch and retry\n", message);
}

ptransfer(direction, bytes, t0, t1)
	char *direction;
	long bytes;
	struct timeval *t0, *t1;
{
	struct timeval td;
	long ms;
	float bs;

	tvsub(&td, t1, t0);
	ms = (td.tv_sec * 1000) + (td.tv_usec / 1000);
#define	nz(x)	((x) == 0 ? 1 : (x))
	bs = ((1000. * (float) bytes) / (float) nz(ms));
	printf("\n%ld bytes %s in %d.%02d seconds (%.2g Kbytes/s)\n",
		bytes, direction, td.tv_sec, td.tv_usec / 10000, bs / 1024.);
}

tvadd(tsum, t0)
	struct timeval *tsum, *t0;
{

	tsum->tv_sec += t0->tv_sec;
	tsum->tv_usec += t0->tv_usec;
	if (tsum->tv_usec > 1000000)
		tsum->tv_sec++, tsum->tv_usec -= 1000000;
}

tvsub(tdiff, t1, t0)
	struct timeval *tdiff, *t1, *t0;
{

	tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
	tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
	if (tdiff->tv_usec < 0)
		tdiff->tv_sec--, tdiff->tv_usec += 1000000;
}

nlistproc(attr)
	FilingSubset1_AttributeSequence attr;
{
	int i;
	char *thisname;
	FilingSubset1_AttributeType t;
	
	files_found= TRUE;

	for (i = 0; i < attr.length; i++) {
		t = attr.sequence[i].type;
		if (t == FilingSubset1_pathname) {
			thisname = AttrToString(&attr.sequence[i]);
#ifdef XEROXFSCOMPATIBILITY
			/*
			 * Xerox File servers don't include beginning /
			 */
			if ( *thisname != '/' )
				fputc('/', fout);
#endif XEROXFSCOMPATIIBLITY
			fputs(thisname, fout);
			fputc('\n', fout);
			clear_String(&thisname);