ftpdlib.c

vxworks bsp,s3c2410的vxworks开发资料

    "\"%s\" directory could not be created",
    "Timeout (%d seconds): closing connection.",
    "Guest login ok, send your complete e-mail address as password.",
    "Guest login ok, access restrictions apply.",
    "Guest login ok, upload directory is %s.",
    "Guest access denied.",
    };

/* Indexes to the messages [] array */

#define MSG_PASSIVE_ERROR	0
#define MSG_PARAM_BAD		1
#define MSG_DATA_CONN_ERROR	2
#define MSG_DIR_NOT_PRESENT	3
#define MSG_LOCAL_RESOURCE_FAIL	4
#define MSG_SERVER_READY	5
#define MSG_PASSWORD_REQUIRED	6
#define MSG_USER_LOGGED_IN	7
#define MSG_SEE_YOU_LATER	8
#define MSG_USER_PASS_REQ	9
#define MSG_DIR_ERROR		10
#define MSG_TRANS_COMPLETE	11
#define MSG_FILE_ERROR		12
#define MSG_CREATE_ERROR	13
#define MSG_CHANGED_DIR		14
#define MSG_TYPE_BINARY		15
#define MSG_TYPE_ASCII		16
#define MSG_PORT_SET		17
#define MSG_CUR_DIR		18
#define MSG_FILE_STRU		19
#define MSG_STREAM_MODE		20
#define MSG_ALLOC_ACCOUNT	21
#define MSG_PASSIVE_MODE	22
#define MSG_NOOP_OKAY		23
#define MSG_BAD_COMMAND		24
#define MSG_INPUT_FILE_ERROR	25
#define MSG_TYPE_ERROR		26
#define MSG_NO_GOOD_BYE		27
#define	MSG_COMMAND_LIST_BEGIN	28
#define	MSG_COMMAND_LIST_END	29
#define MSG_DELE_OK             30
#define MSG_USER_LOGIN_FAILED   31
#define	MSG_RNFR_OK		32
#define	MSG_RNTO_OK		33
#define	MSG_MKD_OK		34
#define	MSG_RMD_OK		35
#define	MSG_FILE_NOTREG		36
#define	MSG_SYST_REPLY		37
#define	MSG_MKD_ERROR		38
#define	MSG_CONN_TIMEOUT	39
#define	MSG_GUEST_PASS		40
#define	MSG_GUEST_OK		41
#define	MSG_GUEST_UPLOAD_OK	42
#define	MSG_GUEST_ACCESS	43

LOCAL char *ftpdCommandList =
"HELP	USER	PASS	QUIT	LIST	NLST\n\
RETR	STOR	CWD	TYPE	PORT	PWD\n\
STRU	MODE	ALLO	ACCT	PASV	NOOP\n\
DELE	RNFR	RNTO	MKD	RMD	MDTM\n\
SIZE	SYST	XCWD	XPWD	XMKD	XRMD\n";


/* forward declarations */

LOCAL FTPD_SESSION_DATA *ftpdSessionAdd (void);
LOCAL void ftpdSessionDelete (FTPD_SESSION_DATA *);
LOCAL STATUS ftpdWorkTask (FTPD_SESSION_DATA *);
LOCAL STATUS ftpdCmdSend (FTPD_SESSION_DATA *, int, int, const char *,
                          int, int, int, int, int, int);
LOCAL STATUS ftpdDataConnGet (FTPD_SESSION_DATA *);
LOCAL void ftpdDataStreamSend (FTPD_SESSION_DATA *, char *);
LOCAL STATUS ftpdDataStreamReceive (FTPD_SESSION_DATA *, FILE *outStream);
LOCAL void ftpdSockFree (int *);
LOCAL STATUS ftpdDirListGet (int, char *, BOOL);
LOCAL void ftpdDebugMsg (char *, int, int, int, int);
LOCAL void unImplementedType (FTPD_SESSION_DATA *pSlot);
LOCAL void dataError (FTPD_SESSION_DATA *pSlot);
LOCAL void fileError (FTPD_SESSION_DATA *pSlot);
LOCAL void transferOkay (FTPD_SESSION_DATA *pSlot);

/* rmdir() is implemented by simply calling remove() */
#define	rmdir(dName)	remove((dName))
/* mkdir() is implemented locally to avoid unnecesary dependency */
#define	mkdir(dName)	ftpMkdir((dName))

/*******************************************************************************
*
* ftpMkdir - make a directory
*
* This command creates a new directory in a hierarchical file system.
* The <dirName> string specifies the name to be used for the
* new directory, and can be either a full or relative pathname.
* This function is replicated here to avoid dependency in usrLib or
* usrFsLib.
*/

LOCAL STATUS ftpMkdir
    (
    char *dirName		/* directory name */
    )
    {
    int fd;

    if ((fd = open (dirName, O_RDWR | O_CREAT, FSTAT_DIR | DEFAULT_DIR_PERM))
	 == ERROR)
	{
	return (ERROR);
	}

    return (close (fd));
    }


/*******************************************************************************
*
* ftpdTask - FTP server daemon task
*
* This routine monitors the FTP control port for incoming requests from clients
* and processes each request by spawning a secondary server task after 
* establishing the control connection. If the maximum number of connections is
* reached, it returns the appropriate error to the requesting client. The 
* routine is the entry point for the primary FTP server task and should only
* be called internally.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* INTERNAL:
* The server task is deleted by the server shutdown routine. Adding a newly
* created client session to the list of active clients is performed atomically
* with respect to the shutdown routine. However, accepting control connections
* is not a critical section, since closing the initial socket used in the
* listen() call also closes any later connections which are still open.
*
* NOMANUAL
*/

LOCAL void ftpdTask (void)
    {
    int		newSock;
    FAST FTPD_SESSION_DATA *pSlot;
    int		on = 1;
    int		addrLen;
    struct sockaddr_in	addr;
    char	a_ip_addr [INET_ADDR_LEN];  /* ascii ip address of client */

    ftpdNumTasks = 0;

    /* The following loop halts if this task is deleted. */

    FOREVER
        {
        /* Wait for a new incoming connection. */

        addrLen = sizeof (struct sockaddr);

        ftpdDebugMsg ("waiting for a new client connection...\n",0,0,0,0);

        newSock = accept (ftpdServerSock, (struct sockaddr *) &addr, &addrLen);
	if (newSock < 0)
            {
            ftpdDebugMsg ("cannot accept a new connection\n",0,0,0,0);
            break;
            }

        /*
         * Register a new FTP client session. This process is a critical
         * section with the server shutdown routine. If an error occurs,
         * the reply must be sent over the control connection to the peer
         * before the semaphore is released. Otherwise, this task could
         * be deleted and no response would be sent, possibly causing
         * the new client to hang indefinitely.
         */

        semTake (ftpsMutexSem, WAIT_FOREVER);

        setsockopt (newSock, SOL_SOCKET, SO_KEEPALIVE, (char *) &on,
                    sizeof (on));

        inet_ntoa_b (addr.sin_addr, a_ip_addr);
        ftpdDebugMsg ("accepted a new client connection from %s\n",
                      (int) a_ip_addr, 0, 0, 0);

	/* scan the connections to shutdown any connection which is idle */

	pSlot = (FTPD_SESSION_DATA *)lstFirst (&ftpsSessionList);
	while (pSlot != NULL)
	    {
	    FTPD_SESSION_DATA * pNext ;
	    time_t now = time(NULL);
	    /* need next now, cuz it can be destroyed */
	    pNext = (FTPD_SESSION_DATA *)lstNext (&pSlot->node);
	    if( (now - pSlot->timeUsed) > FTPD_CONN_TIMEOUT )
		{
		ftpdDebugMsg("session %x idle byteCount %d\n",
			(int) pSlot, pSlot->byteCount, 0, 0);
		if ( pSlot->byteCount == 0 )
		    {
		    ftpdCmdSend (pSlot, pSlot->cmdSock, 421,
			messages [MSG_CONN_TIMEOUT], 
			now - pSlot->timeUsed, 0, 0, 0, 0, 0);
		    ftpdDebugMsg("deleting session %x\n", (int)pSlot, 0, 0, 0);
		    /* XXX ftpdSessionDelete( pSlot ); */
		    ftpdSockFree (&pSlot->cmdSock);
		    taskDelay( sysClkRateGet() / 10 );
		    }
		else
		    pSlot->byteCount = 0 ;
		}
	    pSlot = pNext ;
	    }

        /* Create a new session entry for this connection, if possible. */

        pSlot = ftpdSessionAdd ();
        if (pSlot == NULL) 	/* Maximum number of connections reached. */
            {
            /* Send transient failure report to client. */

            ftpdCmdSend (pSlot, newSock, 421, 
                         "Session limit reached, closing control connection", 
                         0, 0, 0, 0, 0, 0);
            ftpdDebugMsg ("cannot get a new connection slot\n",0,0,0,0);
            semGive (ftpsMutexSem);
            continue;
            }

	pSlot->cmdSock	= newSock;

        /* Save the control address and assign the default data address. */

        bcopy ( (char *)&addr, (char *)&pSlot->peerAddr, 
               sizeof (struct sockaddr_in));
        bcopy ( (char *)&addr, (char *)&pSlot->dataAddr, 
               sizeof (struct sockaddr_in));
        pSlot->dataAddr.sin_port = htons (FTP_DATA_PORT);

	/* Create a task name. */

        sprintf (ftpdWorkTaskName, "tFtpdServ%d", ftpdNumTasks);

        /* Spawn a secondary task to process FTP requests for this session. */

	ftpdDebugMsg ("creating a new server task %s...\n", 
		      (int) ftpdWorkTaskName, 0, 0, 0);

	if (taskSpawn (ftpdWorkTaskName, ftpdWorkTaskPriority,
		       ftpdWorkTaskOptions, ftpdWorkTaskStackSize,
		       ftpdWorkTask, (int) pSlot,
		       0, 0, 0, 0, 0, 0, 0, 0, 0) == ERROR)
	    {
            /* Send transient failure report to client. */

            ftpdCmdSend (pSlot, newSock, 421, 
                         "Service not available, closing control connection",
                         0, 0, 0, 0, 0, 0);
	    ftpdSessionDelete (pSlot);
	    ftpdDebugMsg ("cannot create a new work task\n",0,0,0,0);
            semGive (ftpsMutexSem);
            continue;
	    }

	ftpdDebugMsg ("done.\n",0,0,0,0);

        /* Session added - end of critical section with shutdown routine. */

        semGive (ftpsMutexSem);
	}

    /* Fatal error - update state of server. */

    ftpsActive = FALSE;

    return;
    }

/*******************************************************************************
*
* ftpdInit - initialize the FTP server task
*
* This routine spawns the FTP server task,
* and establishes a control connection for it on the well-knoen
* FTP service port, or on another port if a non-zero value is
* specified with the <port> argiment.
*
* Usually it is called automatically during system startup
* if INCLUDE_FTP_SERVER is defined. The primary server task 
* supports simultaneous client sessions, up to the limit specified by the 
* global variable 'ftpsMaxClients'. The default value allows a maximum of 
* four simultaneous connections. The <stackSize> argument specifies the stack 
* size for the primary server task. It is set to the value specified in the 
* 'ftpdWorkTaskStackSize' global variable by default.
*
* RETURNS:
* OK if server started, or ERROR otherwise.
*
* ERRNO: N/A
*/

STATUS ftpdInit
    (
    int		port,		/* service port */
    int 	stackSize 	/* task stack size, or 0 for default */
    )
    {
    int 		on = 1;
    struct sockaddr_in 	ctrlAddr;

    if (ftpsActive)
	return (OK);

    ftpsShutdownFlag = FALSE;
    ftpsCurrentClients = 0;

    /* Create the FTP server control socket. */

    ftpdServerSock = socket (AF_INET, SOCK_STREAM, 0);
    if (ftpdServerSock < 0)
        return (ERROR);

    /* Create data structures for managing client connections. */

    lstInit (&ftpsSessionList);
    ftpsMutexSem = semMCreate (SEM_Q_FIFO | SEM_DELETE_SAFE);
    if (ftpsMutexSem == NULL)
        {
        close (ftpdServerSock);
        return (ERROR);
        }

    ftpsSignalSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY);
    if (ftpsSignalSem == NULL)
        {
        close (ftpdServerSock);
        semDelete (ftpsMutexSem);
        return (ERROR);
        }

    /* Setup control connection for client requests. */
    if ( port == 0 )
	port = FTP_DAEMON_PORT ;

    ctrlAddr.sin_family = AF_INET;
    ctrlAddr.sin_addr.s_addr = INADDR_ANY;
    ctrlAddr.sin_port = htons ( port );

    if (setsockopt (ftpdServerSock, SOL_SOCKET, SO_REUSEADDR,
                    (char *) &on, sizeof (on)) < 0)
        {
        close (ftpdServerSock);
        semDelete (ftpsMutexSem);
        semDelete (ftpsSignalSem);
        return (ERROR);
        }

    if (bind (ftpdServerSock, (struct sockaddr *) &ctrlAddr,
              sizeof (ctrlAddr)) < 0)
        {
        close (ftpdServerSock);
        semDelete (ftpsMutexSem);
        semDelete (ftpsSignalSem);
        return (ERROR);
        }

    if (listen (ftpdServerSock, 5) < 0)
        {
        close (ftpdServerSock);
        semDelete (ftpsMutexSem);
        semDelete (ftpsSignalSem);
        return (ERROR);
        }

    /* Create a FTP server task to receive client requests. */

    ftpdTaskId = taskSpawn ("tFtpdTask", ftpdTaskPriority - 1, ftpdTaskOptions,
                            stackSize == 0 ? ftpdWorkTaskStackSize : stackSize,
                            (FUNCPTR) ftpdTask, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
    if (ftpdTaskId == ERROR)
        {
        ftpdDebugMsg ("ERROR: ftpdTask cannot be created\n",0,0,0,0);
        close (ftpdServerSock);
        semDelete (ftpsMutexSem);
        semDelete (ftpsSignalSem);
        return (ERROR);			/* errno set by taskSpawn() */
        }

    ftpsActive = TRUE;
    ftpdDebugMsg ("ftpdTask created\n",0,0,0,0);
    return (OK);
    }

/*******************************************************************************
*
* ftpdDelete - terminate the FTP server task
*
* This routine halts the FTP server and closes the control connection. All
* client sessions are removed after completing any commands in progress.
* When this routine executes, no further client connections will be accepted
* until the server is restarted. This routine is not reentrant and must not
* be called from interrupt level.
*
* NOTE: If any file transfer operations are in progress when this routine is
* executed, the transfers will be aborted, possibly leaving incomplete files
* on the destination host.
*
* RETURNS: OK if shutdown completed, or ERROR otherwise.
*
* ERRNO: N/A
*
* INTERNAL
* This routine is synchronized with the deletion routine for a client session
* so that the exit of the client tasks can be detected. It also shares a
* critical section with the creation of client sessions to prevent orphaned
* tasks, which would occur if a session were added after this routine had
* shut down all known clients.
*/

STATUS ftpdDelete (void)
    {
    BOOL serverActive = FALSE;