/* file.c Copyright 1992-2000 by Michael Temari All Rights Reserved
 *
 * This file is part of ftpd.
 *
 * This file handles:
 *
 *      ALLO APPE CDUP CWD  DELE LIST MDTM MODE MKD  NLST PWD REST RETR
 *      RMD  RNFR RNTO SITE SIZE STAT STOR STOU STRU SYST TYPE
 *
 * 01/25/96 Initial Release	Michael Temari
 * 03/09/00 			Michael Temari, <Michael@TemWare.Com>
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <net/hton.h>
#include <net/gen/in.h>
#include <net/gen/inet.h>
#include <net/gen/tcp.h>

#include "ftpd.h"
#include "access.h"
#include "file.h"
#include "net.h"

_PROTOTYPE(static int fdxcmd, (int cmd, char *arg));
_PROTOTYPE(static int endfdxcmd, (int fd));
_PROTOTYPE(static int asciisize, (char *filename, unsigned long *filesize));
_PROTOTYPE(static int cnvtfile, (char *name, char **name2));
_PROTOTYPE(static int procfile, (char *name));
_PROTOTYPE(static unsigned long fsize, (char *fname));
_PROTOTYPE(static int sendfile, (char *name, int xmode));
_PROTOTYPE(static int recvfile, (char *name, int xmode));
_PROTOTYPE(static char *uniqname, (void));
_PROTOTYPE(static int docrc, (char *buff, int xmode));
_PROTOTYPE(static int dofdet, (char *buff));
_PROTOTYPE(static char *path, (char *fname));

#define	SEND_FILE	0
#define	SEND_NLST	1
#define	SEND_LIST	2

#define	RECV_FILE	0
#define	RECV_APND	1
#define	RECV_UNIQ	2

#define	CNVT_ERROR	0
#define	CNVT_NONE	1
#define	CNVT_TAR	2
#define	CNVT_TAR_Z	3
#define	CNVT_COMP	4
#define	CNVT_TAR_GZ	5
#define	CNVT_GZIP	6
#define	CNVT_UNCOMP	7


#define	PROG_FTPDSH	"ftpdsh"
#define	CMD_NLST	1
#define	CMD_LIST	2
#define	CMD_CRC		3

static char *msg550 = "550 %s %s.\r\n";

static unsigned long file_restart = 0;

static char rnfr[256];
static char buffer[8192];
static char bufout[8192];

static cmdpid = -1;

/* allocate, we don't need no stink'n allocate */
int doALLO(buff)
char *buff;
{
   printf("202 ALLO command not needed at this site.\r\n");

   return(GOOD);
}

/* append to a file if it exists */
int doAPPE(buff)
char *buff;
{
   return(recvfile(buff, RECV_APND));
}

/* change to parent directory */
int doCDUP(buff)
char *buff;
{
   if(ChkLoggedIn())
	return(GOOD);

   return(doCWD(".."));
}

/* change directory */
int doCWD(buff)
char *buff;
{
   if(ChkLoggedIn())
	return(GOOD);

   if(chdir(buff))
	printf(msg550, buff, strerror(errno));
   else {
	showmsg("250", ".ftpd_msg");
	printf("250 %s command okay.\r\n", line);
   }

   return(GOOD);
}

/* remove a file */
int doDELE(buff)
char *buff;
{
   if(ChkLoggedIn())
	return(GOOD);

   if(anonymous) {
	printf("550 Command not allowed for anonymous user\r\n");
	return(GOOD);
   }

   if(unlink(buff))
	printf(msg550, buff, strerror(errno));
   else {
	printf("250 File \"%s\" deleted.\r\n", buff);
	logit("DELE", path(buff));
   }

   return(GOOD);
}

/* directory listing */
int doLIST(buff)
char *buff;
{
   file_restart = 0;

   return(sendfile(buff, SEND_LIST));
}

/* file modification time, btw when will this be put into an RFC */
int doMDTM(buff)
char *buff;
{
struct stat st;
struct tm *t;

   if(ChkLoggedIn())
	return(GOOD);

   if(stat(buff, &st)) {
	printf(msg550, buff, strerror(errno));
	return(GOOD);
   }

   if((st.st_mode & S_IFMT) != S_IFREG) {
	printf("550 Not a regular file.\r\n");
	return(GOOD);
   }

   t = gmtime(&st.st_mtime);

   printf("215 %04d%02d%02d%02d%02d%02d\r\n",
	t->tm_year+1900, t->tm_mon+1, t->tm_mday,
	t->tm_hour, t->tm_min, t->tm_sec);

   return(GOOD);
}

/* mode */
int doMODE(buff)
char *buff;
{
   switch(*buff) {
	case 'b':
	case 'B':
		printf("200 Mode set to %c.\r\n", *buff);
		mode = MODE_B;
		break;
	case 's':
	case 'S':
		printf("200 Mode set to %c.\r\n", *buff);
		mode = MODE_S;
		break;
	default:
		printf("501 Unknown mode %c.\r\n", *buff);
   }

   return(GOOD);
}

/* make a directory */
int doMKD(buff)
char *buff;
{
   if(ChkLoggedIn())
	return(GOOD);

   if(anonymous) {
	printf("550 Command not allowed for anonymous user\r\n");
	return(GOOD);
   }

   if(mkdir(buff, 0777))
	printf(msg550, buff, strerror(errno));
   else {
	printf("257 \"%s\" directory created.\r\n", buff);
	logit("MKD ", path(buff));
   }

   return(GOOD);
}

/* name listing */
int doNLST(buff)
char *buff;
{
   file_restart = 0;

   return(sendfile(buff, SEND_NLST));
}

/* where are we */
int doPWD(buff)
char *buff;
{
char dir[128];

   if(ChkLoggedIn())
	return(GOOD);

   if(getcwd(dir, sizeof(dir)) == (char *)NULL)
	printf(msg550, buff, strerror(errno));
   else
	printf("257 \"%s\" is current directory.\r\n", dir);

   return(GOOD);
}

/* restart command */
int doREST(buff)
char *buff;
{
   if(ChkLoggedIn())
	return(GOOD);

   file_restart = atol(buff);

   printf("350 Next file transfer will restart at %lu.\r\n", file_restart);

   return(GOOD);
}

/* they want a file */
int doRETR(buff)
char *buff;
{
   return(sendfile(buff, SEND_FILE));
}

/* remove a directory */
int doRMD(buff)
char *buff;
{
   if(ChkLoggedIn())
	return(GOOD);

   if(anonymous) {
	printf("550 Command not allowed for anonymous user\r\n");
	return(GOOD);
   }

   if(rmdir(buff))
	printf(msg550, buff, strerror(errno));
   else {
	printf("250 Directory \"%s\" deleted.\r\n", buff);
	logit("RMD ", path(buff));
   }

   return(GOOD);
}

/* rename from */
int doRNFR(buff)
char *buff;
{
   if(ChkLoggedIn())
	return(GOOD);

   if(anonymous) {
	printf("550 Command not allowed for anonymous user\r\n");
	return(GOOD);
   }

   strncpy(rnfr, buff, sizeof(rnfr));
   rnfr[sizeof(rnfr)-1] = '\0';

   printf("350 Got RNFR waiting for RNTO.\r\n");

   return(GOOD);
}

/* rename to */
int doRNTO(buff)
char *buff;
{
   if(ChkLoggedIn())
	return(GOOD);

   if(anonymous) {
	printf("550 Command not allowed for anonymous user\r\n");
	return(GOOD);
   }

   if(rnfr[0] == '\0') {
	printf("550 Rename failed.\r\n");
	return(GOOD);
   }

   if(rename(rnfr, buff) < 0)
	printf("550 Rename failed. Error %s\r\n", strerror(errno));
   else {
	printf("250 Renamed %s to %s.\r\n", rnfr, buff);
	logit("RNFR", path(rnfr));
	logit("RNTO", path(buff));
   }

   rnfr[0] = '\0';

   return(GOOD);
}

/* xmode = 0 for multiline crc, xmode <> 0 for single file single line crc */
static int docrc(buff, xmode)
char *buff;
int xmode;
{
unsigned short cs;
long fs;
int fd;
int s;
char *p;

   if((fd = fdxcmd(CMD_CRC, buff)) < 0) {
	printf("501 Could not obtain CRC.\r\n");
	return(GOOD);
   }

   if(xmode == 0)
	printf("202-SITE CRC \"%s\"\r\n", buff);

   while(1) {
	p = buffer;
	while(1) {
		if((s = read(fd, p, 1)) != 1) {
			if(xmode == 0)
				printf("202 SITE CRC DONE.\r\n");
			else
				printf("501 Could not obtain CRC.\r\n");
			endfdxcmd(fd);
			return(GOOD);
		}
		if(*p == '\n') {
			*p++ = '\r';
			*p++ = '\n';
			*p = '\0';
			break;
		}
		p++;
	}
	if(xmode != 0)
		break;
	printf("    %s", buffer);
   }

   cs = atoi(buffer);

   fs = atol(buffer+6);

   printf("202 CRC %05u %ld.\r\n", cs, fs);

   endfdxcmd(fd);

   return(GOOD);
}

/* site specific */
int doSITE(buff)
char *buff;
{
char *args;

   if(ChkLoggedIn())
	return(GOOD);


   strncpy(line, buff, sizeof(line));
   line[sizeof(line)-1] = '\0';

   cvtline(&args);

   if(!strcmp(line, "CRC") || !strcmp(line, "CCRC"))
	return(docrc(args, strcmp(line, "CRC")));

   if(!strcmp(line, "FDET"))
	return(dofdet(args));

   printf("501 Unknown SITE command %s.\r\n", line);

   return(GOOD);
}

static unsigned long fsize(fname)
char *fname;
{
struct stat st;
unsigned long fs = 0L;

   if(stat(fname, &st))
	return(fs);

   if((st.st_mode & S_IFMT) != S_IFREG)
	return(fs);

   if(type == TYPE_A)
	return(fs);

   fs = st.st_size;

   return(fs);
}

/* file size, btw when will this be put into an RFC */
int doSIZE(buff)
char *buff;
{
struct stat st;
unsigned long filesize;

   if(ChkLoggedIn())
	return(GOOD);

   if(stat(buff, &st)) {
	printf(msg550, buff, strerror(errno));
	return(GOOD);
   }

   if((st.st_mode & S_IFMT) != S_IFREG) {
	printf("550 Not a regular file.\r\n");
	return(GOOD);
   }

   filesize = st.st_size;

   if(type == TYPE_A)
	if(asciisize(buff, &filesize))
		return(GOOD);

   printf("215 %lu\r\n", filesize);

   return(GOOD);
}

/* server status, or file status */
int doSTAT(buff)
char *buff;
{
time_t now;
struct tm *tm;
int fd;
int s;

   if(!*buff) {
	(void) time(&now);
	tm = localtime(&now);
	printf("211-%s(%s:%u) FTP server status:\r\n",
		myhostname, inet_ntoa(myipaddr), ntohs(myport));
	printf("    Version %s  ", FtpdVersion);
	printf("%s, %02d %s %d %02d:%02d:%02d %s\r\n", days[tm->tm_wday],
		tm->tm_mday, months[tm->tm_mon], 1900+tm->tm_year,
		tm->tm_hour, tm->tm_min, tm->tm_sec, tzname[tm->tm_isdst]);
	printf("    Connected to %s:%u\r\n", inet_ntoa(rmtipaddr), ntohs(rmtport));
	if(!loggedin)
		printf("    Not logged in\r\n");
	else
		printf("    Logged in %s\r\n", username);
	printf("    MODE: %s\r\n",(mode == MODE_B) ? "Block" : "Stream");
	printf("    TYPE: %s\r\n",(type == TYPE_A) ? "Ascii" : "Binary");
	printf("211 End of status\r\n");
	return(GOOD);
   }

   if(ChkLoggedIn())
	return(GOOD);

   printf("211-Status of %s:\r\n", buff);

   if((fd = fdxcmd(CMD_LIST, buff)) < 0)
	printf("   Could not retrieve status");
   else {
	while((s = read(fd, buffer, 1)) == 1) {
		if(*buffer == '\n')
			printf("\r\n");
		else
			printf("%c", *buffer);
	}
	endfdxcmd(fd);
   }

   printf("211 End of status\r\n");

   return(GOOD);
}

/* hey look, we're getting a file */
int doSTOR(buff)
char *buff;
{
   return(recvfile(buff, RECV_FILE));
}

/* hey, get a file unique */
int doSTOU(buff)
char *buff;
{
   return(recvfile(buff, RECV_UNIQ));
}

/* structure */
int doSTRU(buff)
char *buff;
{
   switch(*buff) {
	case 'f':
	case 'F':
		printf("200 Structure set to %c.\r\n", *buff);
		break;
	default:
		printf("501 Unknown structure %c.\r\n", *buff);
   }

   return(GOOD);
}

/* we're UNIX and proud of it! */
int doSYST(buff)
char *buff;
{
   printf("215 UNIX Type: L8\r\n");

   return(GOOD);
}

/* change transfer type */
int doTYPE(buff)
char *buff;
{
   if(*(buff+1) != '\0') {
	printf("501 Syntax error in parameters.\r\n");
	return(GOOD);
   }

   switch(*buff) {
	case 'A':
	case 'a':
		type = TYPE_A;
		printf("200 Type set to A.\r\n");
		break;
	case 'I':
	case 'i':
		type = TYPE_I;
		printf("200 Type set to I.\r\n");
		break;
	default:
		printf("501 Invalid type %c.\r\n", *buff);
   }

   return(GOOD);
}

static int fdxcmd(cmd, arg)
int   cmd;
char *arg;
{
char xcmd[3];
char *argv[5];
int fds[2];
char *smallenv[] = { "PATH=/bin:/usr/bin:/usr/local/bin", NULL, NULL };

   if((smallenv[1] = getenv("TZ")) != NULL) smallenv[1] -= 3;	/* ouch... */

   sprintf(xcmd, "%d", cmd);

   argv[0] = PROG_FTPDSH;
   argv[1] = xcmd;
   argv[2] = arg;
   argv[3] = (char *)NULL;

   if(pipe(fds) < 0)
	return(-1);

   if((cmdpid = fork()) < 0) {
	close(fds[0]);
	close(fds[1]);
	return(-1);
   }

   if(cmdpid == 0) { /* Child */
	close(fds[0]);
	close(0);
	open("/dev/null", O_RDONLY);
	dup2(fds[1], 1);
	dup2(fds[1], 2);
	close(fds[1]);
	sprintf(argv[0], "/bin/%s", PROG_FTPDSH);
	execve(argv[0], argv, smallenv);
	sprintf(argv[0], "/usr/bin/%s", PROG_FTPDSH);
	execve(argv[0], argv, smallenv);
	sprintf(argv[0], "/usr/local/bin/%s", PROG_FTPDSH);
	execve(argv[0], argv, smallenv);
	exit(0);
   }

   close(fds[1]);

   return(fds[0]);
}

/* Same as close if not cmd child started */
static int endfdxcmd(fd)
int fd;
{
int s;
int cs;

   close(fd);

   if(cmdpid == -1)
	return(0);

   s = waitpid(cmdpid, &cs, 0);

   cmdpid = -1;

   return(0);
}

/* returns -1 = size could not be determined, */
/*          0 = size determined and in filesize */
static int asciisize(filename, filesize)
char *filename;
unsigned long *filesize;
{
unsigned long count;
int fd;
char *p, *pp;
int cnt;

   if((fd = open(filename, O_RDONLY)) < 0) {
	printf(msg550, filename, strerror(errno));
	return(-1);
   }

   count = 0;

   while((cnt = read(fd, buffer, sizeof(buffer))) > 0) {
	count += cnt;
	p = buffer;
	while(cnt > 0)
		if((pp = memchr(p, '\n', cnt)) != (char *)NULL) {
			count++;
			cnt = cnt - 1 - (pp - p);
			p = pp + 1;
		} else
			break;
   }

   if(cnt == 0) {
	*filesize = count;
	close(fd);
	return(0);
   }

   printf(msg550, filename, strerror(errno));

   close(fd);

   return(-1);
}

/* see if we need to run a command to convert the file */
static int cnvtfile(name, name2)
char *name;
char **name2;
{
struct stat st;
static char fname[256];
char *p;
int cmode;

   if(!stat(name, &st))			/* file exists can't be a conversion */
   	if((st.st_mode & S_IFMT) != S_IFREG) {	/* must be regular file */
		printf("550 Not a regular file.\r\n");
		return(CNVT_ERROR);
	} else
		return(CNVT_NONE);

   if(errno != ENOENT) {	/* doesn't exist is okay, others are not */
	printf(msg550, name, strerror(errno));
	return(CNVT_ERROR);
   }

   /* find out what kind of conversion */
   strncpy(fname, name, sizeof(fname));
   fname[sizeof(fname)-1] = '\0';

   p = fname + strlen(fname);
   cmode = CNVT_ERROR;
   while(p > fname && cmode == CNVT_ERROR) {
	if(*p == '.') {
		if(!strcmp(p, ".tar"))
			cmode = CNVT_TAR;
		else
		if(!strcmp(p, ".tar.Z"))
			cmode = CNVT_TAR_Z;
		else
		if(!strcmp(p, ".Z"))
			cmode = CNVT_COMP;
		else
		if(!strcmp(p, ".tar.gz"))
			cmode = CNVT_TAR_GZ;
		else
		if(!strcmp(p, ".gz"))
			cmode = CNVT_GZIP;

		if (cmode != CNVT_ERROR) {
			/* is there a file to convert? */
			*p = '\0';
			if (!stat(fname, &st)) break;
			*p = '.';
			cmode = CNVT_ERROR;
		}
	}
	p--;
   }

   if(cmode == CNVT_ERROR) {
	printf(msg550, fname, strerror(errno));
	return(CNVT_ERROR);
   }

   if(cmode == CNVT_COMP || cmode == CNVT_GZIP || cmode == CNVT_UNCOMP)
	if((st.st_mode & S_IFMT) != S_IFREG) {
		printf("550 Not a regular file.\r\n");
		return(CNVT_ERROR);
	}

   *name2 = fname;

   return(cmode);
}

static int procfile(name)
char *name;
{
int cmd;
int fd;
char *name2;

   cmd = cnvtfile(name, &name2);

   switch(cmd) {
	case CNVT_TAR:
		fd = fdxcmd(cmd + 10, name2);
		break;
	case CNVT_TAR_Z:
		fd = fdxcmd(cmd + 10, name2);
		break;
	case CNVT_COMP:
		fd = fdxcmd(cmd + 10, name2);
		break;
	case CNVT_TAR_GZ:
		fd = fdxcmd(cmd + 10, name2);
		break;
	case CNVT_GZIP:
		fd = fdxcmd(cmd + 10, name2);
		break;
	case CNVT_UNCOMP:
		fd = fdxcmd(cmd + 10, name2);
		break;
	case CNVT_NONE:
		fd = open(name, O_RDONLY);
		break;
	case CNVT_ERROR:
	default:
		return(-1);
   }

   if(fd < 0)
	printf(msg550, name, strerror(errno));

   return(fd);
}

/* oh no, they're taking a file */
static int sendfile(name, xmode)
char *name;
int xmode;
{
char *fname;
int fd, s;
time_t datastart, dataend;
unsigned long datacount;
long kbs;
char c;
char *p;
char *op, *ope;
off_t sp;
int doascii;
unsigned long fs;
char block[3];

   if(ChkLoggedIn()) 
	return(GOOD);

   switch(xmode) {
	case SEND_NLST:
		fname = "NLST";
		fd = fdxcmd(CMD_NLST, name);
		if(fd < 0)
			printf(msg550, name, strerror(errno));
		break;
	case SEND_LIST:
		fname = "LIST";
		fd = fdxcmd(CMD_LIST, name);
		if(fd < 0)
			printf(msg550, name, strerror(errno));
		break;
	default:
		fname = name;
		fd = procfile(name);
		if(fd < 0)
			logit("FAIL", path(fname));
		else
			logit("SEND", path(fname));
   }

   if(fd < 0)
	return(GOOD);

   /* set file position at approriate spot */
   if(file_restart) {
	if(type == TYPE_A) {
		sp = 0;
		while(sp < file_restart) {
			sp++;
			s = read(fd, buffer, 1);
			if(s < 0) {
				printf(msg550, fname, strerror(errno));
				endfdxcmd(fd);
				file_restart = 0;
				return(GOOD);
			}
			if(s == 0) break;
			if(*buffer == '\n')
				sp++;
		}
	} else {
		sp = lseek(fd, file_restart, SEEK_SET);
		if(sp == -1) {
			printf(msg550, fname, strerror(errno));
			endfdxcmd(fd);
			file_restart = 0;
			return(GOOD);
		}
	}
	if(sp != file_restart) {
		printf("550 File restart point error. %lu not %lu\r\n", sp, file_restart);
		endfdxcmd(fd);
		file_restart = 0;
		return(GOOD);
	}
   }
   file_restart = 0;

   fs = fsize(fname);
   if(fs == 0L)
	printf("%03d File %s okay.  Opening data connection.\r\n",
		ftpdata_fd >= 0 ? 125 : 150, fname);
   else
	printf("%03d Opening %s mode data connection for %s (%ld bytes).\r\n",
		ftpdata_fd >= 0 ? 125 : 150,
		type == TYPE_A ? "ASCII" : "BINARY",
		fname, fs);
   fflush(stdout);

#ifdef DEBUG
   fprintf(logfile, "After 125/150 b4 DataConnect\n");
   fflush(logfile);
#endif

   if(DataConnect()) {
	endfdxcmd(fd);
	return(GOOD);
   }

#ifdef DEBUG
   fprintf(logfile, "After DataConnect\n");
   fflush(logfile);
   fprintf(logfile, "ftpd: parent %d start sendfile \n", getpid());
   fflush(logfile);
#endif

   /* start transfer */
   doascii = (type == TYPE_A) ||
   	((xmode == SEND_LIST) || (xmode == SEND_NLST)); /* per RFC1123 4.1.2.7 */
   datacount = 0;
   time(&datastart);
   op = bufout; ope = bufout + sizeof(bufout) - 3;
   while((s = read(fd, buffer, sizeof(buffer))) > 0) {
#ifdef DEBUG
	fprintf(logfile, "sendfile read %d\n", s); fflush(logfile);
#endif
	datacount += s;
	if(doascii) {
		p = buffer;
		while(s-- > 0) {
			c = *p++;
			if(c == '\n') {
				*op++ = '\r';
				datacount++;
			}
			*op++ = c;
			if(op >= ope) {
				if(mode == MODE_B) {
					block[0] = '\0';
					*(u16_t *)&block[1] = htons(op - bufout);
					write(ftpdata_fd, block, sizeof(block));
				}
				write(ftpdata_fd, bufout, op - bufout);
				op = bufout;
			}
		}
	} else {
		if(mode == MODE_B) {
			block[0] = '\0';
			*(u16_t *)&block[1] = htons(s);
			write(ftpdata_fd, block, sizeof(block));
		}
		s = write(ftpdata_fd, buffer, s);
	}
   }
   if(op > bufout) {
	if(mode == MODE_B) {
		block[0] = MODE_B_EOF;
		*(u16_t *)&block[1] = htons(op - bufout);
		write(ftpdata_fd, block, sizeof(block));
	}
	write(ftpdata_fd, bufout, op - bufout);
   } else
	if(mode == MODE_B) {
		block[0] = MODE_B_EOF;
		*(u16_t *)&block[1] = htons(0);
		write(ftpdata_fd, block, sizeof(block));
	}
   time(&dataend);

#ifdef DEBUG
   fprintf(logfile, "ftpd: parent %d end sendfile \n", getpid());
   fflush(logfile);
#endif

   endfdxcmd(fd);
   if(mode != MODE_B) {
	close(ftpdata_fd); 
	ftpdata_fd = -1;
   }

   if(dataend == datastart) dataend++;
   kbs = (datacount * 100 / (dataend - datastart)) / 1024;

   if(s < 0)
	printf("451 Transfer aborted.\r\n");
   else
	printf("%03d Transfer finished successfully. %ld.%02d KB/s\r\n",
		mode == MODE_B ? 250 : 226,
		(long)(kbs / 100), (int)(kbs % 100));

   return(GOOD);
}

static int recvfile(name, xmode)
char *name;
int xmode;
{
char *fname;
time_t datastart, dataend;
unsigned long datacount;
long kbs;
char c;
char *p;
char *op, *ope;
int fd, oflag;
int s;
int gotcr;
off_t sp;
char block[3];
unsigned short cnt;

   if(ChkLoggedIn())
	return(GOOD);

   fname = name;

   switch(xmode) {
	case RECV_APND:
		oflag = O_WRONLY | O_APPEND;
		break;
	case RECV_UNIQ:
		fname = uniqname();
		oflag = O_WRONLY | O_CREAT;
		break;
	default:
		oflag = O_WRONLY | O_CREAT | O_TRUNC;
   }

   if(file_restart)
	oflag = O_RDWR;

   fd = open(fname, oflag, (anonymous ? 0000:0600));

   if(fd < 0) {
	printf(msg550, fname, strerror(errno));
	return(GOOD);
   }

   /* log the received file */
   logit("RECV", path(fname));

   /* set file position at approriate spot */
   if(file_restart) {
	if(type == TYPE_A) {
		sp = 0;
		while(sp < file_restart) {
			sp++;
			s = read(fd, buffer, 1);
			if(s < 0) {
				printf(msg550, fname, strerror(errno));
				close(fd);
				file_restart = 0;
				return(GOOD);
			}
			if(s == 0) break;
			if(*buffer == '\n')
				sp++;
		}
	} else {
		sp = lseek(fd, file_restart, SEEK_SET);
		if(sp == -1) {
			printf(msg550, fname, strerror(errno));
			close(fd);
			file_restart = 0;
			return(GOOD);
		}
	}
	if(sp != file_restart) {
		printf("550 File restart point error. %lu not %lu\r\n", sp, file_restart);
		close(fd);
		file_restart = 0;
		return(GOOD);
	}
   }
   file_restart = 0;

   if(xmode == RECV_UNIQ)
   	printf("%03d FILE: %s\r\n",
   		ftpdata_fd >= 0 ? 125 : 150, fname);	/* per RFC1123 4.1.2.9 */
   else
	printf("%03d File %s okay.  Opening data connection.\r\n",
		ftpdata_fd >= 0 ? 125 : 150, fname);
   fflush(stdout);

   if(DataConnect()) {
   	close(fd);
	return(GOOD);
   }

#ifdef DEBUG
   fprintf(logfile, "ftpd: parent %d start recvfile \n", getpid());
   fflush(logfile);
#endif

   /* start receiving file */
   datacount = 0;
   gotcr = 0;
   op = bufout; ope = bufout + sizeof(bufout) - 3;
   cnt = 0;
   time(&datastart);
   while(1) {
   	if(mode != MODE_B)
   		cnt = sizeof(buffer);
   	else
   		if(cnt == 0) {
   			s = read(ftpdata_fd, block, sizeof(block));
   			cnt = ntohs(*(u16_t *)&block[1]);
   			s = 0;
   			if(cnt == 0 && block[0] & MODE_B_EOF)
   				break;
   		}
	s = read(ftpdata_fd, buffer, cnt > sizeof(buffer) ? sizeof(buffer) : cnt);
	if(s <= 0) break;
	cnt -= s;
	datacount += (long)s;
	if(type == TYPE_A) {
		p = buffer;
		while(s-- > 0) {
			c = *p++;
			if(gotcr) {
				gotcr = 0;
				if(c != '\n')
					*op++ = '\r';
			}
			if(c == '\r')
				gotcr = 1;
			else
				*op++ = c;
			if(op >= ope) {
				write(fd, bufout, op - bufout);
				op = bufout;
			}
		}
	} else
		write(fd, buffer, s);
	if(cnt == 0 && mode == MODE_B && block[0] & MODE_B_EOF) {
		s = 0;
		break;
	}
   }
   if(gotcr)
	*op++ = '\r';
   if(op > bufout)
	write(fd, bufout, op - bufout);
   time(&dataend);

#ifdef DEBUG
   fprintf(logfile, "ftpd: parent %d end recvfile \n", getpid());
   fflush(logfile);
#endif

   close(fd);
   if(mode != MODE_B) {
	close(ftpdata_fd); 
	ftpdata_fd = -1;
   }

   if(dataend == datastart) dataend++;
   kbs = (datacount * 100 / (dataend - datastart)) / 1024;

   if((mode == MODE_B && cnt != 0) || s != 0)
	printf("451 Transfer aborted.\r\n");
   else {
	printf("%03d Transfer finished successfully. ",
		mode == MODE_B ? 250 : 226);
	if(xmode == RECV_UNIQ)
		printf("Unique file %s. ", fname);
	printf("%ld.%02d KB/s\r\n", (long)(kbs / 100), (int)(kbs % 100));
   }

   return(GOOD);
}

static char *uniqname()
{
static char uniq[32];
int i;
struct stat st;

   for(i = 0; i < 1000; i++) {
	sprintf(uniq, "ftpd%d%d", getpid(), i);
	if(stat(uniq, &st) == -1)
		return(uniq);
   }
   return(uniq);
}

static char *spath[256];
static char *path(fname)
char *fname;
{
char dir[128];

   if(getcwd(dir, sizeof(dir)) == (char *)NULL)
	sprintf(dir, "???");

   if(fname[0] == '/')
	sprintf((char *)spath, "%s%s", newroot, fname);
   else
	if(dir[1] == '\0')
		sprintf((char *)spath, "%s%s%s", newroot, dir, fname);
	else
		sprintf((char *)spath, "%s%s/%s", newroot, dir, fname);

   return((char *)spath);
}

/* do file detail */
static int dofdet(buff)
char *buff;
{
struct stat st;
char ft;

   if(ChkLoggedIn())
	return(GOOD);

   if(stat(buff, &st)) {
	printf("501 Could not obtain file detail.\r\n");
	return(GOOD);
   }
   switch(st.st_mode & S_IFMT) {
   	case S_IFIFO:	ft = 'p'; break;
   	case S_IFCHR:	ft = 'c'; break;
   	case S_IFDIR:	ft = 'd'; break;
   	case S_IFBLK:	ft = 'b'; break;
   	case S_IFREG:	ft = 'f'; break;
   	default:	ft = '?'; break;
   }
   printf("202 %c %u %u %u %u %u %lu %lu\r\n", 
   	ft,					/* file type */
   	st.st_rdev >> 8,			/* Major */
   	st.st_rdev & 0xff,			/* Minor */
   	st.st_uid,				/* UID */
   	st.st_gid,				/* GID */
   	st.st_mode,				/* File Modes */
   	st.st_size,				/* SIZE */
   	st.st_mtime);				/* Mod Time */

   return(GOOD);
}