1 //

     2 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 // All rights reserved.

     4 // This component and the accompanying materials are made available

     5 // under the terms of "Eclipse Public License v1.0"

     6 // which accompanies this distribution, and is available

     7 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 //

     9 // Initial Contributors:

    10 // Nokia Corporation - initial contribution.

    11 //

    12 // Contributors:

    13 //

    14 // Description:

    15 //

    16 

    17 /*

    18  * Copyright (c) 1985, 1988, 1990, 1992, 1993, 1994

    19  *	The Regents of the University of California.  All rights reserved.

    20  *

    21  * Redistribution and use in source and binary forms, with or without

    22  * modification, are permitted provided that the following conditions

    23  * are met:

    24  * 1. Redistributions of source code must retain the above copyright

    25  *    notice, this list of conditions and the following disclaimer.

    26  * 2. Redistributions in binary form must reproduce the above copyright

    27  *    notice, this list of conditions and the following disclaimer in the

    28  *    documentation and/or other materials provided with the distribution.

    29  * 3. All advertising materials mentioning features or use of this software

    30  *    must display the following acknowledgement:

    31  *	This product includes software developed by the University of

    32  *	California, Berkeley and its contributors.

    33  * 4. Neither the name of the University nor the names of its contributors

    34  *    may be used to endorse or promote products derived from this software

    35  *    without specific prior written permission.

    36  *

    37  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

    38  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    39  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    40  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

    41  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    42  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

    43  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

    44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

    45  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

    46  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

    47  * SUCH DAMAGE.

    48  */

    49 

    50 /*

    51  * FTP server.

    52  */

    53 

    54 

    55 #include <netinet/net_types.h>

    56 #include <sys/param.h>

    57 #include <sys/stat.h>

    58 #include <sys/socket.h>

    59 #include <sys/mman.h>

    60 #include <netinet/in.h>

    61 

    62 #define	FTP_NAMES

    63 #include <arpa/ftp.h>

    64 #include <ctype.h>

    65 #include <dirent.h>

    66 #include <fcntl.h>

    67 #include <glob.h>

    68 #include <limits.h> /* for CHAR_BIT */

    69 #include <netdb.h>

    70 #include <pwd.h>

    71 #include <setjmp.h>

    72 #include <stdio.h>

    73 #include <stdlib.h>

    74 #include <string.h>

    75 #include <unistd.h>

    76 #include <utmp.h>

    77 #include <spawn.h>

    78 

    79 #include "pathnames.h"

    80 #include "extern.h"

    81 

    82 // Symbian includes

    83 

    84 #include <f32file.h>

    85 #include <in_iface.h>

    86 

    87 static char version[]="v1.0.1000";

    88 

    89 extern	off_t restart_point;

    90 extern	char cbuf[];

    91 

    92 struct	sockaddr_in server_addr;

    93 struct	sockaddr_in ctrl_addr;

    94 struct	sockaddr_in data_source;

    95 struct	sockaddr_in data_dest;

    96 struct	sockaddr_in his_addr;

    97 struct	sockaddr_in pasv_addr;

    98 

    99 in_addr server_in_addr;

   100 

   101 int	daemon_mode = 0;

   102 int	data;

   103 jmp_buf	errcatch, urgcatch;

   104 int	logged_in;

   105 struct	passwd *pw;

   106 int	debug = 0;

   107 int	timeout = 900;    /* timeout after 15 minutes of inactivity */

   108 int	maxtimeout = 7200;/* don't allow idle time to be set beyond 2 hours */

   109 int	logging = 0;

   110 int	replicate = 0;

   111 int	high_data_ports = 0;

   112 int	anon_only = 0;

   113 int	multihome = 0;

   114 int guest;

   115 int	stats;

   116 int	statfd = -1;

   117 int	portcheck = 1;

   118 int	dochroot;

   119 int	type;

   120 int	form;

   121 int	stru;			/* avoid C keyword */

   122 int	mode;

   123 int	doutmp = 0;		/* update utmp file */

   124 int	usedefault = 1;		/* for data transfers */

   125 int	pdata = -1;		/* for passive mode */

   126 int port = 21;    /* default FTP port */

   127 //sig_atomic_t transflag;

   128 int transflag;

   129 off_t	file_size;

   130 off_t	byte_count;

   131 #if !defined(CMASK) || CMASK == 0

   132 #undef CMASK

   133 #define CMASK 027

   134 #endif

   135 int	defumask = CMASK;		/* default umask value */

   136 char	tmpline[7];

   137 char	hostname[]="Symbian"; 

   138 char*	remotehost=hostname; 

   139 char*	dhostname=hostname;

   140 char	*guestpw;

   141 static char ttyline[20];

   142 char	*tty = ttyline;		/* for klogin */

   143 static struct utmp utmp;	/* for utmp */

   144 

   145 TDriveNumber drive;

   146 

   147 char	*ident = NULL;

   148 

   149 int root = 1;

   150 FILE* logFile;

   151 /*

   152  * Timeout intervals for retrying connections

   153  * to hosts that don't accept PORT cmds.  This

   154  * is a kludge, but given the problems with TCP...

   155  */

   156 #define	SWAITMAX	90	/* wait at most 90 seconds */

   157 #define	SWAITINT	5	/* interval between retries */

   158 

   159 int	swaitmax = SWAITMAX;

   160 int	swaitint = SWAITINT;

   161 

   162 #ifdef HASSETPROCTITLE

   163 char	proctitle[BUFSIZ];	/* initial part of title */

   164 #endif /* HASSETPROCTITLE */

   165 

   166 #define LOG(message) \

   167 	if (logging/* > 1*/) { \

   168 	    fprintf(logFile, "LOG_INFO %s\r\n", message); \

   169 		fflush(logFile); }

   170 

   171 #define LOGCMD(cmd, file) \

   172 	if (logging/* > 1*/) { \

   173 	    fprintf(logFile, "LOG_INFO %s %s\r\n", cmd, file); \

   174 		fflush(logFile); }

   175 #define LOGCMD2(cmd, file1, file2) \

   176 	 if (logging/* > 1*/) { \

   177 	 	fprintf(logFile, "LOG_INFO %s %s %s\r\n", cmd, file1, file2); \

   178 		fflush(logFile); }

   179 #define LOGBYTES(cmd, file, cnt) \

   180 	if (logging/* > 1*/) { \

   181 		if (cnt == (off_t)-1) \

   182 		    fprintf(logFile, "LOG_INFO %s %s\r\n", cmd, file); \

   183 		else \

   184 		    fprintf(logFile, "LOG_INFO %s %s = %qd bytes\r\n", cmd, file, (quad_t)(cnt)); \

   185 		fflush(logFile) ; \

   186 	}

   187 

   188 static void	 ack __P((const char *));

   189 static FILE	*dataconn __P((const char *, off_t, const char *));

   190 static void	 dolog __P((struct sockaddr_in *));

   191 static void	 end_login __P((void));

   192 static FILE	*getdatasock __P((const char *));

   193 static int	guniquefd __P((const char *, char **));

   194 static int	 receive_data __P((FILE *, FILE *));

   195 static void	 replydirname __P((const char *, const char *));

   196 static void	 send_data __P((FILE *, FILE *, off_t, off_t, int));

   197 

   198 #if defined(TCPWRAPPERS)

   199 static int	 check_host __P((struct sockaddr_in *));

   200 #endif

   201 

   202 in_addr getServerAddress();

   203 TDriveNumber getSystemDrive();

   204 

   205 void logxfer __P((const char *, off_t, time_t));

   206 

   207 #define MAXUSERNAME 64

   208 char * username[MAXUSERNAME];

   209 char * userhome[MAXPATHLEN];

   210 

   211 #undef IP_PORTRANGE

   212 

   213 int

   214 main(int argc, char *argv[], char **envp)

   215 {

   216 	int ch, on = 1;

   217 	socklen_t addrlen;

   218 	char *cp, line[LINE_MAX];

   219 	FILE *fd;

   220 	const char *argstr = "RAdDhlMSt:T:u:UvP:";

   221 	

   222 	tzset();	/* in case no timezone database in ~ftp */

   223 

   224 	/* set this here so klogin can use it... */

   225 	(void)snprintf(ttyline, sizeof(ttyline), "ftp%d", getpid());

   226 

   227 	while ((ch = getopt(argc, argv, argstr)) != -1) {

   228 		switch (ch) {

   229 		case 'A':

   230 			anon_only = 1;

   231 			break;

   232 

   233 		case 'd':

   234 			debug = 1;

   235 			break;

   236 

   237 		case 'D':

   238 		

   239 			for(int i=1 /*no name*/; i<argc; i++)

   240 				{

   241 				for(unsigned int j=0;j<strlen(argv[i]); j++)

   242 					if(argv[i][j]=='D')

   243 						{ 

   244 						//Daemon token found, change it to allow replication to new background processes

   245 						argv[i][j]='R';

   246 						}

   247 				}

   248 			posix_spawn(NULL,argv[0],NULL,NULL,argv,envp);

   249 			exit(0);

   250 		

   251 			break;

   252 

   253 		case 'R':

   254 			replicate = 1;

   255 			break;

   256 			

   257 		case 'P':

   258 			port = atoi(optarg);

   259 			break;

   260 			

   261 		case 'h':

   262 			high_data_ports = 1;

   263 			break;

   264 

   265 		case 'l':

   266 			logging++;	/* > 1 == extra logging */

   267 			break;

   268 

   269 		case 'M':

   270 			multihome = 1;

   271 			break;

   272 

   273 		case 'S':

   274 			stats = 1;

   275 			break;

   276 

   277 		case 't':

   278 			timeout = atoi(optarg);

   279 			if (maxtimeout < timeout)

   280 				maxtimeout = timeout;

   281 			break;

   282 

   283 		case 'T':

   284 			maxtimeout = atoi(optarg);

   285 			if (timeout > maxtimeout)

   286 				timeout = maxtimeout;

   287 			break;

   288 

   289 		case 'u':

   290 		    {

   291 			long val = 0;

   292 

   293 			val = strtol(optarg, &optarg, 8);

   294 			if (*optarg != '\0' || val < 0 || (val & ~ACCESSPERMS))

   295 				printf("bad value for -u");

   296 			else

   297 				defumask = val;

   298 			break;

   299 		    }

   300 

   301 		case 'U':

   302 			doutmp = 1;

   303 			break;

   304 

   305 		case 'v':

   306 			debug = 1;

   307 			break;

   308 

   309 		default:

   310 			printf("unknown flag -%c ignored", optopt);

   311 			scanf("");

   312 			break;

   313 		}

   314 	}

   315 

   316 	(void) freopen(_PATH_DEVNULL, "w", stderr);

   317 

   318 	/*

   319 	 * LOG_NDELAY sets up the logging connection immediately,

   320 	 * necessary for anonymous ftp's that chroot and can't do it later.

   321 	 */

   322 #ifndef LOG_FTP

   323 #define LOG_FTP LOG_DAEMON

   324 #endif

   325 	

   326 		int ctl_sock, fd2;

   327 	

   328 		server_in_addr = getServerAddress();

   329 		

   330 		/*

   331 		 * Open a socket, bind it to the FTP port, and start

   332 		 * listening.

   333 		 */

   334 		ctl_sock = socket(AF_INET, SOCK_STREAM, 0);

   335 		if (ctl_sock < 0) {

   336             User::Panic(_L("socket error"),0);

   337 			LOG("socket error");

   338 			exit(1);

   339 		}

   340 		

   341 		setsockopt(ctl_sock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));

   342 	

   343 		server_addr.sin_family = 0;

   344 		server_addr.sin_addr.s_addr = INADDR_ANY;

   345 		server_addr.sin_port = port; 

   346 		if (bind(ctl_sock, (struct sockaddr *)&server_addr,

   347 			 sizeof(server_addr))) {

   348 			 User::Panic(_L("bind error"),0);

   349             LOG("bind error");

   350 			exit(1);

   351 		}

   352 		if (listen(ctl_sock, 32) < 0) {

   353 		    User::Panic(_L("listen error"),0);

   354 			LOG("listen error");

   355 			exit(1);

   356 		}

   357 			addrlen = sizeof(his_addr);

   358 			fd2 = accept(ctl_sock, (struct sockaddr *)&his_addr,

   359 				    &addrlen);

   360 			

   361 			(void) dup2(fd2, 0);

   362 			(void) dup2(fd2, 1);

   363 			close(ctl_sock);

   364 			close(fd2);

   365 

   366 

   367 	drive = getSystemDrive();

   368 	

   369 	if(logging)

   370 	{

   371 		char logFileName[MAXPATHLEN];

   372 		

   373 		char driveLetter = 'A'+drive;

   374 		

   375 		sprintf(logFileName,"%c:\\ftpd_%d.log",driveLetter,getpid());

   376 		logFile = fopen(logFileName,"w");

   377 		

   378 		fprintf(logFile, "** Log file for the FTP instance with PID %d **\r\n",getpid());

   379 		fflush(logFile);

   380 	}

   381 	

   382 	

   383 	addrlen = sizeof(ctrl_addr);

   384 	if (getsockname(0, (struct sockaddr *)&ctrl_addr, &addrlen) < 0) {

   385 		User::Panic(_L("getsockname error"),0);

   386 		exit(1);

   387 	}

   388 

   389 	//clone to accept new connections

   390 	if(replicate)

   391 		posix_spawn(NULL,argv[0],NULL,NULL,argv,envp);

   392 	

   393 	data_source.sin_port = htons(ntohs(ctrl_addr.sin_port) - 1);

   394 

   395 	dolog(&his_addr);

   396 	/*

   397 	 * Set up default state

   398 	 */

   399 	data = -1;

   400 	type = TYPE_A;

   401 	form = FORM_N;

   402 	stru = STRU_F;

   403 	mode = MODE_S;

   404 	tmpline[0] = '\0';

   405 

   406 	/* If logins are disabled, print out the message. */

   407 	if ((fd = fopen(_PATH_NOLOGIN,"r")) != NULL) {

   408 		while (fgets(line, sizeof(line), fd) != NULL) {

   409 			if ((cp = strchr(line, '\n')) != NULL)

   410 				*cp = '\0';

   411 			lreply(530, "%s", line);

   412 		}

   413 		(void) fflush(stdout);

   414 		(void) fclose(fd);

   415 		reply(530, "System not available.");

   416 		exit(0);

   417 	}

   418 	if ((fd = fopen(_PATH_FTPWELCOME, "r")) != NULL) {

   419 		while (fgets(line, sizeof(line), fd) != NULL) {

   420 			if ((cp = strchr(line, '\n')) != NULL)

   421 				*cp = '\0';

   422 			lreply(220, "%s", line);

   423 		}

   424 		(void) fflush(stdout);

   425 		(void) fclose(fd);

   426 		/* reply(220,) must follow */

   427 	}

   428 	

   429 	reply(220, "%s FTP server (%s) ready.",

   430 			hostname, version);

   431 	(void) setjmp(errcatch);

   432 	for (;;)

   433 		(void) yyparse();

   434 	/* NOTREACHED */

   435 }

   436 

   437 static int login_attempts;	/* number of failed login attempts */

   438 static int askpasswd;		/* had user command, ask for passwd */

   439 static char curname[16];	/* current USER name */

   440 

   441 /*

   442  * USER command.

   443  * Sets global passwd pointer pw if named account exists and is acceptable;

   444  * sets askpasswd if a PASS command is expected.  If logged in previously,

   445  * need to reset state.  If name is "ftp" or "anonymous", the name is not in

   446  * _PATH_FTPUSERS, and ftp account exists, set guest and pw, then just return.

   447  * If account doesn't exist, ask for passwd anyway.  Otherwise, check user

   448  * requesting login privileges.  Disallow anyone who does not have a standard

   449  * shell as returned by getusershell().  Disallow anyone mentioned in the file

   450  * _PATH_FTPUSERS to allow people such as root and uucp to be avoided.

   451  */

   452 void user(char *name)

   453 {

   454 	//const char *cp, *shell;

   455 

   456 	if (logged_in) {

   457 		if (guest) {

   458 			reply(530, "Can't change user from guest login.");

   459 			return;

   460 		} else if (dochroot) {

   461 			reply(530, "Can't change user from chroot user.");

   462 			return;

   463 		}

   464 		end_login();

   465 	}

   466 

   467 	guest = 0;

   468 

   469 	// check password

   470 	

   471 	pw = (passwd *)malloc(sizeof(pw));

   472 	

   473 	strcpy((char*)username,name);

   474 	pw->pw_name = (char*)username;

   475 	

   476 	strcpy((char*)userhome,"/");

   477 	pw->pw_dir = (char*)userhome;

   478 	

   479 	if (logging) {

   480 		strncpy(curname, name, sizeof(curname)-1);

   481 		curname[sizeof(curname)-1] = '\0';

   482 	}

   483 	

   484 	if (strcmp(name, "ftp") == 0 || strcmp(name, "anonymous") == 0) 

   485 		reply(331,"Guest login ok, type your name as password.");

   486 	else

   487 		reply(331, "Password required for %s.", name);

   488 

   489 	askpasswd = 1;

   490 	/*

   491 	 * Delay before reading passwd after first failed

   492 	 * attempt to slow down passwd-guessing programs.

   493 	 */

   494 	if (login_attempts)

   495 		sleep((unsigned) login_attempts);

   496 }

   497 

   498 

   499 /*

   500  * Terminate login as previous user, if any, resetting state;

   501  * used when USER command is given or login fails.

   502  */

   503 static void end_login(void)

   504 {

   505 	(void) seteuid((uid_t)0);

   506 	if (logged_in) {

   507 		if (doutmp)

   508 			logout(utmp.ut_line);

   509 	}

   510 	pw = NULL;

   511 	logged_in = 0;

   512 	guest = 0;

   513 	dochroot = 0;

   514 }

   515 

   516 void pass(char *passwd)

   517 {

   518 	int rval;

   519 	FILE *fd;

   520 	

   521 	if (logged_in || askpasswd == 0) {

   522 		reply(503, "Login with USER first.");

   523 		return;

   524 	}

   525 	askpasswd = 0;

   526 	

   527 	if (!guest) {		/* "ftp" is only account allowed no password */

   528 	

   529 		/*

   530 		 * Authenticate password...

   531 		 */

   532 

   533 		rval = 0;

   534 

   535 		/*

   536 		 * If rval == 1, the user failed the authentication check

   537 		 * above.  If rval == 0, either Kerberos or local authentication

   538 		 * succeeded.

   539 		 */

   540 		if (rval) {

   541 			reply(530, "Login incorrect.");

   542 			pw = NULL;

   543 			return;

   544 		}

   545 	} else {

   546 		/* Save anonymous' password. */

   547 		guestpw = strdup(passwd);

   548 		if (guestpw == (char *)NULL)

   549 			fatal("Out of memory");

   550 	}

   551 	login_attempts = 0;		/* this time successful */

   552 	

   553 	if (setegid((gid_t)pw->pw_gid) < 0) {

   554 		reply(550, "Can't set gid.");

   555 		return;

   556 	}

   557 	(void) initgroups(pw->pw_name, pw->pw_gid);

   558 

   559 	/* open utmp before chroot */

   560 	if (doutmp) {

   561 		memset((void *)&utmp, 0, sizeof(utmp));

   562 		(void)time(&utmp.ut_time);

   563 		(void)strncpy(utmp.ut_name, pw->pw_name, sizeof(utmp.ut_name));

   564 		(void)strncpy(utmp.ut_host, remotehost, sizeof(utmp.ut_host));

   565 		(void)strncpy(utmp.ut_line, ttyline, sizeof(utmp.ut_line));

   566 		login(&utmp);

   567 	}

   568 

   569 	/* open stats file before chroot */

   570 	if (guest && (stats == 1) && (statfd < 0))

   571 		if ((statfd = open(_PATH_FTPDSTATFILE, O_WRONLY|O_APPEND)) < 0)

   572 			stats = 0;

   573 

   574 	logged_in = 1;

   575 	dochroot = 0; 

   576 	

   577 	/*

   578 	 * Set home directory to root

   579 	 */

   580 	chdir("/"); //root

   581 

   582 	/*

   583 	 * Display a login message, if it exists.

   584 	 * N.B. reply(230,) must follow the message.

   585 	 */

   586 	if ((fd = fopen(_PATH_FTPLOGINMESG, "r")) != NULL) {

   587 		char *cp, line[LINE_MAX];

   588 

   589 		while (fgets(line, sizeof(line), fd) != NULL) {

   590 			if ((cp = strchr(line, '\n')) != NULL)

   591 				*cp = '\0';

   592 			lreply(230, "%s", line);

   593 		}

   594 		(void) fflush(stdout);

   595 		(void) fclose(fd);

   596 	}

   597 	if (guest) {

   598 		if (ident != NULL)

   599 			free(ident);

   600 		ident = strdup(passwd);

   601 		if (ident == (char *)NULL)

   602 			fatal("Ran out of memory.");

   603 		reply(230, "Guest login ok, access restrictions apply.");

   604 	} else {

   605 		reply(230, "User %s logged in.", pw->pw_name);

   606 	}

   607 	(void) umask(defumask);

   608 	return;

   609 }

   610 

   611 void internalName(char* output, const char *input)

   612 	{

   613 		//from /c/aaa.txt to c:\aaa.txt

   614 		

   615 		strcpy(output,input);

   616 		

   617 		//root is a special case

   618 		if(strcmp(output,"/")==0)

   619 			{

   620 			return;

   621 			}

   622 		

   623 		for(unsigned int i=0 ; i<strlen(output); i++)

   624 			{

   625 			if(output[i]=='/')

   626 				output[i]= '\\';

   627 			}

   628 		

   629 		//relative path, do not modify

   630 		if((output[0]!='\\' && strlen(output)>1) || strcmp(output,".")==0)

   631 			{

   632 			return;

   633 			}

   634 		

   635 		if(strlen(output)==1 && root)

   636 			{

   637 			//it's a drive: C\0 -> C:\0

   638 			output[2]=output[1];

   639 			output[1]=':';

   640 			

   641 			}

   642 		else

   643 			{

   644 			

   645 			// /C/system\n -> C:/system\n

   646 			output[0]=output[1];

   647 			output[1]=':';

   648 			}

   649 	}

   650 

   651 void externalName(char* output, const char *input)

   652 	{

   653 		//from c:/aaa.txt to /c/aaa.txt 

   654 

   655 		strcpy(output,input);

   656 		

   657 		for(unsigned int i=0 ; i<strlen(output); i++)

   658 			{

   659 			if(output[i]=='\\')

   660 				output[i]= '/';

   661 			}

   662 		

   663 		output[1]=output[0];

   664 		output[0]='/';

   665 	}

   666 

   667 void retrieve(const char *cmd, const char *name)

   668 {

   669 	FILE *fin, *dout;

   670 	struct stat st;

   671 	int (*closefunc) __P((FILE *));

   672 	time_t start;

   673 

   674 	char adaptedName[MAXPATHLEN];

   675 	internalName(adaptedName,name);

   676 	

   677 	LOGCMD("RETR", adaptedName);

   678 	

   679 	if (cmd == 0) {

   680 		fin = fopen(adaptedName, "r"); closefunc = fclose;

   681 		st.st_size = 0;

   682 	} else {

   683 		char line[BUFSIZ];

   684 		

   685 		(void) snprintf(line, sizeof(line), cmd, adaptedName);

   686 		name = line;

   687 		fin = ftpd_popen(line, "r"), closefunc = ftpd_pclose;

   688 		st.st_size = -1;

   689 		st.st_blksize = BUFSIZ;

   690 	}

   691 	if (fin == NULL) {

   692 		if (errno != 0) {

   693 			perror_reply(550, name);

   694 			if (cmd == 0) {

   695 				LOGCMD("get", adaptedName);

   696 			}

   697 		}

   698 		return;

   699 	}

   700 	byte_count = -1;

   701 	if (cmd == 0 && (fstat(fileno(fin), &st) < 0 || !S_ISREG(st.st_mode))) {

   702 		reply(550, "%s: not a plain file.", name);

   703 		goto done;

   704 	}

   705 	

   706 	

   707 	if (restart_point) {

   708 		if (type == TYPE_A) {

   709 			off_t i, n;

   710 			int c;

   711 

   712 			n = restart_point;

   713 			i = 0;

   714 			while (i++ < n) {

   715 				if ((c=getc(fin)) == EOF) {

   716 					perror_reply(550, name);

   717 					goto done;

   718 				}

   719 				if (c == '\n')

   720 					i++;

   721 			}

   722 		} else if (lseek(fileno(fin), restart_point, SEEK_SET) < 0) {

   723 			perror_reply(550, name);

   724 			goto done;

   725 		}

   726 	}

   727 	

   728 	dout = dataconn(name, st.st_size, "w");

   729 	if (dout == NULL)

   730 		goto done;

   731 	time(&start);

   732 	send_data(fin, dout, st.st_blksize, st.st_size,

   733 		  (restart_point == 0 && cmd == 0 && S_ISREG(st.st_mode)));

   734 	if ((cmd == 0) && stats)

   735 		logxfer(name, st.st_size, start);

   736 	(void) fclose(dout);

   737 	data = -1;

   738 	pdata = -1;

   739 done:

   740 	if (cmd == 0)

   741 		LOGBYTES("get", name, byte_count);

   742 	(*closefunc)(fin);

   743 }

   744 

   745 void store(const char *name, const char *mode, int unique)

   746 {

   747 

   748 	FILE *fout, *din;

   749 	int (*closefunc) __P((FILE *));

   750 	struct stat st;

   751 	int fd;

   752 

   753 	char adaptedName[MAXPATHLEN];

   754 	internalName(adaptedName,name);

   755 	

   756 	LOGCMD("STOR", adaptedName);

   757 	

   758 	if (unique && stat(adaptedName, &st) == 0) {

   759 		char *nam;

   760 

   761 		fd = guniquefd(adaptedName, &nam);

   762 		if (fd == -1) {

   763 			LOGCMD(*mode == 'w' ? "put" : "append", name);

   764 			return;

   765 		}

   766 		name = nam;

   767 		if (restart_point)

   768 			mode = "r+";

   769 		fout = fdopen(fd, mode);

   770 	} else

   771 		fout = fopen(adaptedName, mode);

   772 

   773 	closefunc = fclose;

   774 	if (fout == NULL) {

   775 		perror_reply(553, name);

   776 		LOGCMD(*mode == 'w' ? "put" : "append", name);

   777 		return;

   778 	}

   779 	byte_count = -1;

   780 	if (restart_point) {

   781 		if (type == TYPE_A) {

   782 			off_t i, n;

   783 			int c;

   784 

   785 			n = restart_point;

   786 			i = 0;

   787 			while (i++ < n) {

   788 				if ((c=getc(fout)) == EOF) {

   789 					perror_reply(550, name);

   790 					goto done;

   791 				}

   792 				if (c == '\n')

   793 					i++;

   794 			}

   795 			/*

   796 			 * We must do this seek to "current" position

   797 			 * because we are changing from reading to

   798 			 * writing.

   799 			 */

   800 			if (fseek(fout, 0L, SEEK_CUR) < 0) {

   801 				perror_reply(550, name);

   802 				goto done;

   803 			}

   804 		} else if (lseek(fileno(fout), restart_point, SEEK_SET) < 0) {

   805 			perror_reply(550, name);

   806 			goto done;

   807 		}

   808 	}

   809 	din = dataconn(adaptedName, (off_t)-1, "r");

   810 	if (din == NULL)

   811 		goto done;

   812 	if (receive_data(din, fout) == 0) {

   813 		if (unique)

   814 			reply(226, "Transfer complete (unique file name:%s).",

   815 			    name);

   816 		else

   817 			reply(226, "Transfer complete.");

   818 	}

   819 	(void) fclose(din);

   820 	data = -1;

   821 	pdata = -1;

   822 done:

   823 	LOGBYTES(*mode == 'w' ? "put" : "append", name, byte_count);

   824 	(*closefunc)(fout);

   825 }

   826 

   827 static FILE * getdatasock(const char *mode)

   828 {

   829 	int on = 1, s, t, tries;

   830 	

   831 	if (data >= 0)

   832 		return (fdopen(data, mode));

   833 	(void) seteuid((uid_t)0);

   834 	s = socket(AF_INET, SOCK_STREAM, 0);

   835 	if (s < 0)

   836 		goto bad;

   837 	if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,

   838 	    (char *) &on, sizeof(on)) < 0)

   839 		goto bad;

   840 	/* anchor socket to avoid multi-homing problems */

   841 

   842 	data_source.sin_family = AF_INET;

   843 	data_source.sin_addr = ctrl_addr.sin_addr;

   844 	for (tries = 1; ; tries++) {

   845 		if (bind(s, (struct sockaddr *)&data_source,

   846 		    sizeof(data_source)) >= 0)

   847 			break;

   848 		if (errno != EADDRINUSE || tries > 10)

   849 			goto bad;

   850 		sleep(tries);

   851 	}

   852 	(void) seteuid((uid_t)pw->pw_uid);

   853 

   854 	return (fdopen(s, mode));

   855 bad:

   856 	/* Return the real value of errno (close may change it) */

   857 	t = errno;

   858 	(void) seteuid((uid_t)pw->pw_uid);

   859 	(void) close(s);

   860 	errno = t;

   861 	return (NULL);

   862 }

   863 

   864 static FILE * dataconn(const char *name, off_t size, const char *mode)

   865 {

   866 	char sizebuf[32];

   867 	FILE *file;

   868 	int retry = 0;

   869 

   870 	file_size = size;

   871 	byte_count = 0;

   872 	if (size != (off_t) -1) {

   873 		(void) snprintf(sizebuf, sizeof(sizebuf), " (%lld bytes)", 

   874 				(quad_t) size);

   875 	} else

   876 		sizebuf[0] = '\0';

   877 	

   878 	if (pdata >= 0) {

   879 		struct sockaddr_in from;

   880 		int s;

   881 		socklen_t fromlen = sizeof(from);

   882 

   883 		s = accept(pdata, (struct sockaddr *)&from, &fromlen);

   884 		

   885 		//TODO: OE bug ? sizebuf seems to be changed to 0x18 after accept

   886 		//reassigning sizebuf

   887 		if (size != (off_t) -1) {

   888 		(void) snprintf(sizebuf, sizeof(sizebuf), " (%lld bytes)", 

   889 				(quad_t) size);

   890 		} else

   891 			sizebuf[0] = '\0';

   892 		

   893 		

   894 		if (s < 0) {

   895 			reply(425, "Can't open data connection.");

   896 			(void) close(pdata);

   897 			pdata = -1;

   898 			return (NULL);

   899 		}

   900 		if (ntohs(from.sin_port) < IPPORT_RESERVED) {

   901 			perror_reply(425, "Can't build data connection");

   902 			(void) close(pdata);

   903 			(void) close(s);

   904 			pdata = -1;

   905 			return (NULL);

   906 		}

   907 		if (from.sin_addr.s_addr != his_addr.sin_addr.s_addr) {

   908 			perror_reply(435, "Can't build data connection"); 

   909 			(void) close(pdata);

   910 			(void) close(s);

   911 			pdata = -1;

   912 			return (NULL);

   913 		}

   914 		(void) close(pdata);

   915 		pdata = s;

   916 

   917 		if (size != (off_t) -1) {

   918 		(void) snprintf(sizebuf, sizeof(sizebuf), " (%lld bytes)", 

   919 				(quad_t) size);

   920 		} else

   921 			sizebuf[0] = '\0';

   922 		

   923 		reply(150, "Opening %s mode data connection for '%s'%s.",

   924 		     type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);

   925 		return (fdopen(pdata, mode));

   926 	}

   927 	if (data >= 0) {

   928 		reply(125, "Using existing data connection for '%s'%s.",

   929 		    name, sizebuf);

   930 		usedefault = 1;

   931 		return (fdopen(data, mode));

   932 	}

   933 	if (usedefault)

   934 		data_dest = his_addr;

   935 	usedefault = 1;

   936 	file = getdatasock(mode);

   937 	if (file == NULL) {

   938 		reply(425, "Can't create data socket (%s,%d): %s.",

   939 		    inet_ntoa(data_source.sin_addr),

   940 		    ntohs(data_source.sin_port), strerror(errno));

   941 		return (NULL);

   942 	}

   943 	data = fileno(file);

   944 

   945 	/*

   946 	 * attempt to connect to reserved port on client machine;

   947 	 * this looks like an attack

   948 	 */

   949 	if (ntohs(data_dest.sin_port) < IPPORT_RESERVED ||

   950 	    ntohs(data_dest.sin_port) == 2049) {		/* XXX */

   951 		perror_reply(425, "Can't build data connection");

   952 		(void) fclose(file);

   953 		data = -1;

   954 		return NULL;

   955 	}

   956 	if (data_dest.sin_addr.s_addr != his_addr.sin_addr.s_addr) {

   957 		perror_reply(435, "Can't build data connection");

   958 		(void) fclose(file);

   959 		data = -1;

   960 		return NULL;

   961 	}

   962 	while (connect(data, (struct sockaddr *)&data_dest,

   963 	    sizeof(data_dest)) < 0) {

   964 		if (errno == EADDRINUSE && retry < swaitmax) {

   965 			sleep((unsigned) swaitint);

   966 			retry += swaitint;

   967 			continue;

   968 		}

   969 		perror_reply(425, "Can't build data connection");

   970 		(void) fclose(file);

   971 		data = -1;

   972 		return (NULL);

   973 	}

   974 	reply(150, "Opening %s mode data connection for '%s'%s.",

   975 	     type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);

   976 	return (file);

   977 }

   978 

   979 /*

   980  * Tranfer the contents of "instr" to "outstr" peer using the appropriate

   981  * encapsulation of the data subject to Mode, Structure, and Type.

   982  *

   983  * NB: Form isn't handled.

   984  */

   985 static void send_data(FILE *instr, FILE *outstr, off_t blksize, off_t filesize, int isreg)

   986 {

   987 	int c, cnt, filefd, netfd;

   988 	char *buf, *bp;

   989 	size_t len,size;

   990 

   991 	transflag++;

   992 	if (setjmp(urgcatch)) {

   993 		transflag = 0;

   994 		return;

   995 	}

   996 	switch (type) {

   997 

   998 	case TYPE_A:

   999 		while ((c = getc(instr)) != EOF) {

  1000 			byte_count++;

  1001 			(void) putc(c, outstr);

  1002 		}

  1003 		fflush(outstr);

  1004 		transflag = 0;

  1005 		if (ferror(instr))

  1006 			goto file_err;

  1007 		if (ferror(outstr))

  1008 			goto data_err;

  1009 		reply(226, "Transfer complete.");

  1010 		return;

  1011 

  1012 	case TYPE_I:

  1013 	case TYPE_L:

  1014 		/*

  1015 		 * isreg is only set if we are not doing restart and we

  1016 		 * are sending a regular file

  1017 		 */

  1018 		netfd = fileno(outstr);

  1019 		filefd = fileno(instr);

  1020 

  1021 		if (isreg && filesize < (off_t)16 * 1024 * 1024) {

  1022 			buf = (char *)mmap(0, filesize, PROT_READ, MAP_SHARED, filefd, (off_t)0);

  1023 			if (buf==MAP_FAILED || buf==NULL) {

  1024 				goto oldway;

  1025 			}

  1026 			bp = buf;

  1027 			len = filesize;

  1028 			do {

  1029 				cnt = write(netfd, bp, len);

  1030 				len -= cnt;

  1031 				bp += cnt;

  1032 				if (cnt > 0) byte_count += cnt;

  1033 			} while(cnt > 0 && len > 0);

  1034 

  1035 			transflag = 0;

  1036 			munmap(buf, (size_t)filesize);

  1037 			if (cnt < 0)

  1038 				goto data_err;

  1039 			reply(226, "Transfer complete.");

  1040 			return;

  1041 		}

  1042 

  1043 oldway:

  1044 		size = blksize * 16; 

  1045 	

  1046 		if ((buf = (char *)malloc(size)) == NULL) {

  1047 			transflag = 0;

  1048 			perror_reply(451, "Local resource failure: malloc");

  1049 			return;

  1050 		}

  1051 

  1052 		while ((cnt = read(filefd, buf, size)) > 0 &&

  1053 		    write(netfd, buf, cnt) == cnt)

  1054 			byte_count += cnt;

  1055 

  1056 		transflag = 0;

  1057 		(void)free(buf);

  1058 		if (cnt != 0) {

  1059 			if (cnt < 0)

  1060 				goto file_err;

  1061 			goto data_err;

  1062 		}

  1063 		reply(226, "Transfer complete.");

  1064 		return;

  1065 	default:

  1066 		transflag = 0;

  1067 		reply(550, "Unimplemented TYPE %d in send_data", type);

  1068 		return;

  1069 	}

  1070 

  1071 data_err:

  1072 	transflag = 0;

  1073 	perror_reply(426, "Data connection");

  1074 	return;

  1075 

  1076 file_err:

  1077 	transflag = 0;

  1078 	perror_reply(551, "Error on input file");

  1079 }

  1080 

  1081 /*

  1082  * Transfer data from peer to "outstr" using the appropriate encapulation of

  1083  * the data subject to Mode, Structure, and Type.

  1084  *

  1085  * N.B.: Form isn't handled.

  1086  */

  1087 static int receive_data(FILE *instr, FILE *outstr)

  1088 {

  1089 	int c;

  1090 	int cnt;

  1091 	volatile int bare_lfs = 0;

  1092 	char buf[BUFSIZ];

  1093 

  1094 	transflag++;

  1095 	if (setjmp(urgcatch)) {

  1096 		transflag = 0;

  1097 		return (-1);

  1098 	}

  1099 	switch (type) {

  1100 

  1101 	case TYPE_I:

  1102 	case TYPE_L:

  1103 		

  1104 		do {

  1105 			cnt = read(fileno(instr), buf, sizeof(buf));

  1106 		

  1107 			if (cnt > 0) {

  1108 				if (write(fileno(outstr), buf, cnt) != cnt)

  1109 					goto file_err;

  1110 				byte_count += cnt;

  1111 			}

  1112 		} while (cnt > 0);

  1113 		transflag = 0;

  1114 		return (0);

  1115 

  1116 	case TYPE_E:

  1117 		reply(553, "TYPE E not implemented.");

  1118 		transflag = 0;

  1119 		return (-1);

  1120 

  1121 	case TYPE_A:

  1122 		while ((c = getc(instr)) != EOF) {

  1123 			byte_count++;

  1124 			(void) putc(c, outstr);

  1125 		}

  1126 		fflush(outstr);

  1127 		if (ferror(outstr))

  1128 			goto file_err;

  1129 		transflag = 0;

  1130 		if (bare_lfs) {

  1131 			lreply(226,

  1132 		"WARNING! %d bare linefeeds received in ASCII mode",

  1133 			    bare_lfs);

  1134 		(void)printf("   File may not have transferred correctly.\r\n");

  1135 		}