len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-04-24 15:31:56 -04:00
Code Issues Packages Projects Releases Wiki Activity
FreeRTOS-Kernel/FreeRTOS-Plus/Source/FreeRTOS-Plus-TCP/protocols/FTP/FreeRTOS_FTP_server.c

2640 lines
78 KiB
C
Raw Blame History

/*
* FreeRTOS+TCP V2.0.1
* Copyright (C) 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* http://www.FreeRTOS.org
* http://aws.amazon.com/freertos
*
* 1 tab == 4 spaces!
*/
/* Standard includes. */
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "portmacro.h"
/* FreeRTOS+TCP includes. */
#include "FreeRTOS_IP.h"
#include "FreeRTOS_TCP_IP.h"
#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_Stream_Buffer.h"
/* FreeRTOS Protocol includes. */
#include "FreeRTOS_FTP_commands.h"
#include "FreeRTOS_TCP_server.h"
#include "FreeRTOS_server_private.h"
/* Remove the whole file if FTP is not supported. */
#if( ipconfigUSE_FTP == 1 )
#ifndef HTTP_SERVER_BACKLOG
#define HTTP_SERVER_BACKLOG ( 12 )
#endif
#if !defined( ARRAY_SIZE )
#define ARRAY_SIZE( x ) ( BaseType_t ) (sizeof( x ) / sizeof( x )[ 0 ] )
#endif
#if defined(__WIN32__) && !defined(ipconfigFTP_FS_USES_BACKSLAH)
#define ipconfigFTP_FS_USES_BACKSLAH 1
#endif
/* Some defines to make the code more readbale */
#define pcCOMMAND_BUFFER pxClient->pxParent->pcCommandBuffer
#define pcNEW_DIR pxClient->pxParent->pcNewDir
#define pcFILE_BUFFER pxClient->pxParent->pcFileBuffer
/* This FTP server will only do binary transfers */
#define TMODE_BINARY 1
#define TMODE_ASCII 2
#define TMODE_7BITS 3
#define TMODE_8BITS 4
/* Ascii character definitions. */
#define ftpASCII_CR 13
#define ftpASCII_LF 10
#if defined( FTP_WRITES_ALIGNED ) || defined( ipconfigFTP_WRITES_ALIGNED )
#error Name change : please rename the define to the new name 'ipconfigFTP_ZERO_COPY_ALIGNED_WRITES'
#endif
/*
* ipconfigFTP_ZERO_COPY_ALIGNED_WRITES : experimental optimisation option.
* If non-zero, receiving data will be done with the zero-copy method and also
* writes to disk will be done with sector-alignment as much as possible.
*/
#ifndef ipconfigFTP_ZERO_COPY_ALIGNED_WRITES
#define ipconfigFTP_ZERO_COPY_ALIGNED_WRITES 0
#endif
/*
* This module only has 2 public functions:
*/
BaseType_t xFTPClientWork( TCPClient_t *pxClient );
void vFTPClientDelete( TCPClient_t *pxClient );
/*
* Process a single command.
*/
static BaseType_t prvProcessCommand( FTPClient_t *pxClient, BaseType_t xIndex, char *pcRestCommand );
/*
* Create a socket for a data connection to the FTP client.
*/
static BaseType_t prvTransferConnect( FTPClient_t *pxClient, BaseType_t xDoListen );
/*
* Either call listen() or connect() to start the transfer connection.
*/
static BaseType_t prvTransferStart( FTPClient_t *pxClient );
/*
* See if the socket has got connected or disconnected. Close the socket if
* necessary.
*/
static void prvTransferCheck( FTPClient_t *pxClient );
/*
* Close the data socket and issue some informative logging.
*/
static void prvTransferCloseSocket( FTPClient_t *pxClient );
/*
* Close the file handle (pxReadHandle or pxWriteHandle).
*/
static void prvTransferCloseFile( FTPClient_t *pxClient );
/*
* Close a directory (-handle).
*/
static void prvTransferCloseDir( FTPClient_t *pxClient );
/*
* Translate a string (indicating a transfer type) to a number.
*/
static BaseType_t prvGetTransferType( const char *pcType );
#if( ipconfigHAS_PRINTF != 0 )
/*
* For nice logging: write an amount (number of bytes), e.g. 3512200 as
* "3.45 MB"
*/
static const char *pcMkSize( uint32_t ulAmount, char *pcBuffer, BaseType_t xBufferSize );
#endif
#if( ipconfigHAS_PRINTF != 0 )
/*
* Calculate the average as bytes-per-second, when amount and milliseconds
* are known.
*/
static uint32_t ulGetAverage( uint32_t ulAmount, TickType_t xDeltaMs );
#endif
/*
* A port command looks like: PORT h1,h2,h3,h4,p1,p2. Parse it and translate it
* to an IP-address and a port number.
*/
static UBaseType_t prvParsePortData( const char *pcCommand, uint32_t *pulIPAddress );
/*
* CWD: Change current working directory.
*/
static BaseType_t prvChangeDir( FTPClient_t *pxClient, char *pcDirectory );
/*
* RNFR: Rename from ...
*/
static BaseType_t prvRenameFrom( FTPClient_t *pxClient, const char *pcFileName );
/*
* RNTO: Rename to ...
*/
static BaseType_t prvRenameTo( FTPClient_t *pxClient, const char *pcFileName );
/*
* SITE: Change file permissions.
*/
static BaseType_t prvSiteCmd( FTPClient_t *pxClient, char *pcRestCommand );
/*
* DELE: Delete a file.
*/
static BaseType_t prvDeleteFile( FTPClient_t *pxClient, char *pcFileName );
/*
* SIZE: get the size of a file (xSendDate = 0).
* MDTM: get data and time properties (xSendDate = 1).
*/
static BaseType_t prvSizeDateFile( FTPClient_t *pxClient, char *pcFileName, BaseType_t xSendDate );
/*
* MKD: Make / create a directory (xDoRemove = 0).
* RMD: Remove a directory (xDoRemove = 1).
*/
static BaseType_t prvMakeRemoveDir( FTPClient_t *pxClient, const char *pcDirectory, BaseType_t xDoRemove );
/*
* The next three commands: LIST, RETR and STOR all require a data socket.
* The data connection is either started with a 'PORT' or a 'PASV' command.
* Each of the commands has a prepare- (Prep) and a working- (Work) function.
* The Work function should be called as long as the data socket is open, and
* there is data to be transmitted.
*/
/*
* LIST: Send a directory listing in Unix style.
*/
static BaseType_t prvListSendPrep( FTPClient_t *pxClient );
static BaseType_t prvListSendWork( FTPClient_t *pxClient );
/*
* RETR: Send a file to the FTP client.
*/
static BaseType_t prvRetrieveFilePrep( FTPClient_t *pxClient, char *pcFileName );
static BaseType_t prvRetrieveFileWork( FTPClient_t *pxClient );
/*
* STOR: Receive a file from the FTP client and store it.
*/
static BaseType_t prvStoreFilePrep( FTPClient_t *pxClient, char *pcFileName );
static BaseType_t prvStoreFileWork( FTPClient_t *pxClient );
/*
* Print/format a single directory entry in Unix style.
*/
static BaseType_t prvGetFileInfoStat( FF_DirEnt_t *pxEntry, char *pcLine, BaseType_t xMaxLength );
/*
* Send a reply to a socket, either the command- or the data-socket.
*/
static BaseType_t prvSendReply( Socket_t xSocket, const char *pcBuffer, BaseType_t xLength );
/*
* Prepend the root directory (if any), plus the current working directory
* (always), to get an absolute path.
*/
BaseType_t xMakeAbsolute( FTPClient_t *pxClient, char *pcBuffer, BaseType_t xBufferLength, const char *pcPath );
/*
####### ##### ###### # # ##
# ## # # # # # # # #
# # # # # # #
# # # # # # # #### ### ## # #
##### # ##### # # # # # # # # # #
# # # # # # # # # ## # ####
# # # ## ## # # # # #
# # # ## ## # # # # #
#### #### #### ## ## #### #### ## ##
* xFTPClientWork()
* will be called by FreeRTOS_TCPServerWork(), after select has expired().
* FD_ISSET will not be used. This work function will always be called at
* regular intervals, and also after a select() event has occurred.
*/
BaseType_t xFTPClientWork( TCPClient_t *pxTCPClient )
{
FTPClient_t *pxClient = ( FTPClient_t * ) pxTCPClient;
BaseType_t xRc;
if( pxClient->bits.bHelloSent == pdFALSE_UNSIGNED )
{
BaseType_t xLength;
pxClient->bits.bHelloSent = pdTRUE_UNSIGNED;
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"220 Welcome to the FreeRTOS+TCP FTP server\r\n" );
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
}
/* Call recv() in a non-blocking way, to see if there is an FTP command
sent to this server. */
xRc = FreeRTOS_recv( pxClient->xSocket, ( void * )pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), 0 );
if( xRc > 0 )
{
BaseType_t xIndex;
const FTPCommand_t *pxCommand;
char *pcRestCommand;
if( xRc < ( BaseType_t ) sizeof( pcCOMMAND_BUFFER ) )
{
pcCOMMAND_BUFFER[ xRc ] = '\0';
}
while( xRc && ( ( pcCOMMAND_BUFFER[ xRc - 1 ] == ftpASCII_CR ) || ( pcCOMMAND_BUFFER[ xRc - 1 ] == ftpASCII_LF ) ) )
{
pcCOMMAND_BUFFER[ --xRc ] = '\0';
}
/* Now iterate through a list of FTP commands, and look for a match. */
pxCommand = xFTPCommands;
pcRestCommand = pcCOMMAND_BUFFER;
for( xIndex = 0; xIndex < FTP_CMD_COUNT - 1; xIndex++, pxCommand++ )
{
BaseType_t xLength;
/* The length of each command is stored as well, just to be a bit
quicker here. */
xLength = pxCommand->xCommandLength;
if( ( xRc >= xLength ) && ( memcmp( ( const void * ) pxCommand->pcCommandName, ( const void * ) pcCOMMAND_BUFFER, xLength ) == 0 ) )
{
/* A match with an existing command is found. Skip any
whitespace to get the first parameter. */
pcRestCommand += xLength;
while( ( *pcRestCommand == ' ' ) || ( *pcRestCommand == '\t' ) )
{
pcRestCommand++;
}
break;
}
}
/* If the command received was not recognised, xIndex will point to a
fake entry called 'ECMD_UNKNOWN'. */
prvProcessCommand( pxClient, xIndex, pcRestCommand );
}
else if( xRc < 0 )
{
/* The connection will be closed and the client will be deleted. */
FreeRTOS_printf( ( "xFTPClientWork: xRc = %ld\n", xRc ) );
}
/* Does it have an open data connection? */
if( pxClient->xTransferSocket != FREERTOS_NO_SOCKET )
{
/* See if the connection has changed. */
prvTransferCheck( pxClient );
/* "pcConnectionAck" contains a string like:
"Response: 150 Accepted data connection from 192.168.2.3:6789"
The socket can only be used once this acknowledgement has been sent. */
if( ( pxClient->xTransferSocket != FREERTOS_NO_SOCKET ) && ( pxClient->pcConnectionAck[ 0 ] == '\0' ) )
{
BaseType_t xClientRc = 0;
if( pxClient->bits1.bDirHasEntry )
{
/* Still listing a directory. */
xClientRc = prvListSendWork( pxClient );
}
else if( pxClient->pxReadHandle != NULL )
{
/* Sending a file. */
xClientRc = prvRetrieveFileWork( pxClient );
}
else if( pxClient->pxWriteHandle != NULL )
{
/* Receiving a file. */
xClientRc = prvStoreFileWork( pxClient );
}
if( xClientRc < 0 )
{
prvTransferCloseSocket( pxClient );
prvTransferCloseFile( pxClient );
}
}
}
return xRc;
}
/*-----------------------------------------------------------*/
static void prvTransferCloseDir( FTPClient_t *pxClient )
{
/* Nothing to close for +FAT. */
( void ) pxClient;
}
/*-----------------------------------------------------------*/
void vFTPClientDelete( TCPClient_t *pxTCPClient )
{
FTPClient_t *pxClient = ( FTPClient_t * ) pxTCPClient;
/* Close any directory-listing-handles (not used by +FAT ). */
prvTransferCloseDir( pxClient );
/* Close the data-socket. */
prvTransferCloseSocket( pxClient );
/* Close any open file handle. */
prvTransferCloseFile( pxClient );
/* Close the FTP command socket */
if( pxClient->xSocket != FREERTOS_NO_SOCKET )
{
FreeRTOS_FD_CLR( pxClient->xSocket, pxClient->pxParent->xSocketSet, eSELECT_ALL );
FreeRTOS_closesocket( pxClient->xSocket );
pxClient->xSocket = FREERTOS_NO_SOCKET;
}
}
/*-----------------------------------------------------------*/
static BaseType_t prvProcessCommand( FTPClient_t *pxClient, BaseType_t xIndex, char *pcRestCommand )
{
const FTPCommand_t *pxFTPCommand = &( xFTPCommands[ xIndex ] );
const char *pcMyReply = NULL;
BaseType_t xResult = 0;
if( ( pxFTPCommand->ucCommandType != ECMD_PASS ) && ( pxFTPCommand->ucCommandType != ECMD_PORT ) )
{
FreeRTOS_printf( ( " %s %s\n", pxFTPCommand->pcCommandName, pcRestCommand ) );
}
if( ( pxFTPCommand->checkLogin != pdFALSE ) && ( pxClient->bits.bLoggedIn == pdFALSE_UNSIGNED ) )
{
pcMyReply = REPL_530; /* Please first log in. */
}
else if( ( pxFTPCommand->checkNullArg != pdFALSE ) && ( ( pcRestCommand == NULL ) || ( pcRestCommand[ 0 ] == '\0' ) ) )
{
pcMyReply = REPL_501; /* Command needs a parameter. */
}
if( pcMyReply == NULL )
{
switch( pxFTPCommand->ucCommandType )
{
case ECMD_USER: /* User. */
/* User name has been entered, expect password. */
pxClient->bits.bStatusUser = pdTRUE_UNSIGNED;
#if( ipconfigFTP_HAS_USER_PASSWORD_HOOK != 0 )/*_RB_ Needs defaulting and adding to the web documentation. */
{
/* Save the user name in 'pcFileName'. */
snprintf( pxClient->pcFileName, sizeof( pxClient->pcFileName ), "%s", pcRestCommand );
/* The USER name is presented to the application. The function
may return a const string like "331 Please enter your
password\r\n". */
pcMyReply = pcApplicationFTPUserHook( pxClient->pcFileName );
if( pcMyReply == NULL )
{
pcMyReply = REPL_331_ANON;
}
}
#else
{
/* No password checks, any password will be accepted. */
pcMyReply = REPL_331_ANON;
}
#endif /* ipconfigFTP_HAS_USER_PASSWORD_HOOK != 0 */
#if( ipconfigFTP_HAS_USER_PROPERTIES_HOOK != 0 )/*_RB_ Needs defaulting and adding to the web documentation. */
{
FTPUserProperties_t xProperties;
xProperties.pcRootDir = pxClient->pcRootDir;
xProperties.xReadOnly = pdFALSE;
xProperties.usPortNumber = pxClient->usClientPort;
vApplicationFTPUserPropertiesHook( pxClient->pcFileName, &( xProperties ) );
if( xProperties.pcRootDir != NULL )
{
pxClient->pcRootDir = xProperties.pcRootDir;
}
pxClient->bits.bReadOnly = ( xProperties.xReadOnly != pdFALSE_UNSIGNED );
}
#endif /* ipconfigFTP_HAS_USER_PROPERTIES_HOOK */
break;
case ECMD_PASS: /* Password. */
pxClient->ulRestartOffset = 0;
if( pxClient->bits.bStatusUser == pdFALSE_UNSIGNED )
{
pcMyReply = REPL_503; /* "503 Bad sequence of commands.\r\n". */
}
else
{
BaseType_t xAllow;
pxClient->bits.bStatusUser = pdFALSE_UNSIGNED;
#if( ipconfigFTP_HAS_USER_PASSWORD_HOOK != 0 )
{
xAllow = xApplicationFTPPasswordHook( pxClient->pcFileName, pcRestCommand );
}
#else
{
xAllow = 1;
}
#endif /* ipconfigFTP_HAS_USER_PASSWORD_HOOK */
if( xAllow > 0 )
{
pxClient->bits.bLoggedIn = pdTRUE_UNSIGNED; /* Client has now logged in. */
pcMyReply = "230 OK. Current directory is /\r\n";
}
else
{
pcMyReply = "530 Login incorrect\r\n"; /* 530 Login incorrect. */
}
strcpy( pxClient->pcCurrentDir, ( const char * ) "/" );
}
break;
case ECMD_SYST: /* System. */
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), "215 UNIX Type: L8\r\n" );
pcMyReply = pcCOMMAND_BUFFER;
break;
case ECMD_PWD: /* Get working directory. */
xMakeRelative( pxClient, pcFILE_BUFFER, sizeof( pcFILE_BUFFER ), pxClient->pcCurrentDir );
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), REPL_257_PWD, pcFILE_BUFFER );
pcMyReply = pcCOMMAND_BUFFER;
break;
case ECMD_REST:
if( pxClient->bits.bReadOnly != pdFALSE_UNSIGNED )
{
pcMyReply = REPL_553_READ_ONLY;
}
else
{
const char *pcPtr = pcRestCommand;
while( *pcPtr == ' ' )
{
pcPtr++;
}
if( ( *pcPtr >= '0' ) && ( *pcPtr <= '9' ) )
{
sscanf( pcPtr, "%lu", &pxClient->ulRestartOffset );
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"350 Restarting at %lu. Send STORE or RETRIEVE\r\n", pxClient->ulRestartOffset );
pcMyReply = pcCOMMAND_BUFFER;
}
else
{
pcMyReply = REPL_500; /* 500 Syntax error, command unrecognised. */
}
}
break;
case ECMD_NOOP: /* NOP operation */
if( pxClient->xTransferSocket != FREERTOS_NO_SOCKET )
{
pcMyReply = REPL_200_PROGRESS;
}
else
{
pcMyReply = REPL_200;
}
break;
case ECMD_TYPE: /* Ask or set transfer type. */
{
/* e.g. "TYPE I" for Images (binary). */
BaseType_t xType = prvGetTransferType( pcRestCommand );
if( xType < 0 )
{
/* TYPE not recognised. */
pcMyReply = REPL_500;
}
else
{
pxClient->xTransType = xType;
pcMyReply = REPL_200;
}
}
break;
case ECMD_PASV: /* Enter passive mode. */
/* Connect passive: Server will listen() and wait for a connection.
Start up a new data connection with 'xDoListen' set to true. */
if( prvTransferConnect( pxClient, pdTRUE ) == pdFALSE )
{
pcMyReply = REPL_502;
}
else
{
uint32_t ulIP;
uint16_t ulPort;
struct freertos_sockaddr xLocalAddress;
struct freertos_sockaddr xRemoteAddress;
FreeRTOS_GetLocalAddress( pxClient->xTransferSocket, &xLocalAddress );
FreeRTOS_GetRemoteAddress( pxClient->xSocket, &xRemoteAddress );
ulIP = FreeRTOS_ntohl( xLocalAddress.sin_addr );
pxClient->ulClientIP = FreeRTOS_ntohl( xRemoteAddress.sin_addr );
ulPort = FreeRTOS_ntohs( xLocalAddress.sin_port );
pxClient->usClientPort = FreeRTOS_ntohs( xRemoteAddress.sin_port );
/* REPL_227_D "227 Entering Passive Mode (%d,%d,%d,%d,%d,%d). */
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), REPL_227_D,
( unsigned )ulIP >> 24,
( unsigned )( ulIP >> 16 ) & 0xFF,
( unsigned )( ulIP >> 8 ) & 0xFF,
( unsigned )ulIP & 0xFF,
( unsigned )ulPort >> 8,
( unsigned )ulPort & 0xFF );
pcMyReply = pcCOMMAND_BUFFER;
}
break;
case ECMD_PORT: /* Active connection to the client. */
/* The client uses this command to tell the server to what
client-side port the server should contact; use of this command
indicates an active data transfer. e.g. PORT 192,168,1,2,4,19. */
{
uint32_t ulIPAddress = 0;
UBaseType_t uxPort;
uxPort = prvParsePortData( pcRestCommand, &ulIPAddress );
FreeRTOS_printf( (" PORT %lxip:%ld\n", ulIPAddress, uxPort ) );
if( uxPort == 0u )
{
pcMyReply = REPL_501;
}
else if( prvTransferConnect( pxClient, pdFALSE ) == pdFALSE )
{
/* Call prvTransferConnect() with 'xDoListen' = false for an
active connect(). */
pcMyReply = REPL_501;
}
else
{
pxClient->usClientPort = ( uint16_t ) uxPort;
pxClient->ulClientIP = ulIPAddress;
FreeRTOS_printf( ("Client address %lxip:%lu\n", ulIPAddress, uxPort ) );
pcMyReply = REPL_200;
}
}
break;
case ECMD_CWD: /* Change current working directory. */
prvChangeDir( pxClient, pcRestCommand );
break;
case ECMD_RNFR:
if( pxClient->bits.bReadOnly != pdFALSE_UNSIGNED )
{
pcMyReply = REPL_553_READ_ONLY;
}
else
{
prvRenameFrom( pxClient, pcRestCommand );
}
break;
case ECMD_RNTO:
if( pxClient->bits.bInRename == pdFALSE_UNSIGNED )
{
pcMyReply = REPL_503; /* "503 Bad sequence of commands. */
}
else
{
prvRenameTo( pxClient, pcRestCommand );
}
break;
case ECMD_SITE: /* Set file permissions */
if( pxClient->bits.bReadOnly != pdFALSE_UNSIGNED )
{
pcMyReply = REPL_553_READ_ONLY;
}
else if( prvSiteCmd( pxClient, pcRestCommand ) == pdFALSE )
{
pcMyReply = REPL_202;
}
break;
case ECMD_DELE:
if( pxClient->bits.bReadOnly != pdFALSE_UNSIGNED )
{
pcMyReply = REPL_553_READ_ONLY;
}
else
{
prvDeleteFile( pxClient, pcRestCommand );
}
break;
case ECMD_MDTM:
prvSizeDateFile( pxClient, pcRestCommand, pdTRUE );
break;
case ECMD_SIZE:
if( pxClient->pxWriteHandle != NULL )
{
/* This SIZE query is probably about a file which is now being
received. If so, return the value of pxClient->ulRecvBytes,
pcRestCommand points to 'pcCommandBuffer', make it free by
copying it to pcNewDir. */
xMakeAbsolute( pxClient, pcNEW_DIR, sizeof( pcNEW_DIR ), pcRestCommand );
if( strcmp( pcNEW_DIR, pcRestCommand ) == 0 )
{
BaseType_t xCount;
for( xCount = 0; xCount < 3 && pxClient->pxWriteHandle; xCount++ )
{
prvStoreFileWork( pxClient );
}
if( pxClient->pxWriteHandle != NULL )
{
/* File being queried is still open, return number of
bytes received until now. */
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), "213 %lu\r\n", pxClient->ulRecvBytes );
pcMyReply = pcCOMMAND_BUFFER;
} /* otherwise, do a normal stat(). */
}
strcpy( pcRestCommand, pcNEW_DIR );
}
if( pcMyReply == NULL )
{
prvSizeDateFile( pxClient, pcRestCommand, pdFALSE );
}
break;
case ECMD_MKD:
case ECMD_RMD:
if( pxClient->bits.bReadOnly != pdFALSE_UNSIGNED )
{
pcMyReply = REPL_553_READ_ONLY;
}
else
{
prvMakeRemoveDir( pxClient, pcRestCommand, pxFTPCommand->ucCommandType == ECMD_RMD );
}
break;
case ECMD_CDUP:
prvChangeDir( pxClient, ".." );
break;
case ECMD_QUIT:
prvSendReply( pxClient->xSocket, REPL_221, 0 );
pxClient->bits.bLoggedIn = pdFALSE_UNSIGNED;
break;
case ECMD_LIST:
case ECMD_RETR:
case ECMD_STOR:
if( ( pxClient->xTransferSocket == FREERTOS_NO_SOCKET ) &&
( ( pxFTPCommand->ucCommandType != ECMD_STOR ) ||
( pxClient->bits1.bEmptyFile == pdFALSE_UNSIGNED ) ) )
{
/* Sending "425 Can't open data connection." :
Before receiving any of these commands, there must have been a
PORT or PASV command, which causes the creation of a data socket. */
/* There is one exception: a STOR command is received while the
data connection has already been closed. This is tested with the
'bEmptyFile' flag. */
pcMyReply = REPL_425;
}
else
{
/* In case an empty file was received ( bits1.bEmptyFile ), the
transfer socket never delivered any data. Check if the transfer
socket is still open: */
if( pxClient->xTransferSocket != FREERTOS_NO_SOCKET )
{
prvTransferCheck( pxClient );
}
switch( pxFTPCommand->ucCommandType )
{
case ECMD_LIST:
prvListSendPrep( pxClient );
break;
case ECMD_RETR:
prvRetrieveFilePrep( pxClient, pcRestCommand );
break;
case ECMD_STOR:
if( pxClient->bits.bReadOnly != pdFALSE_UNSIGNED )
{
pcMyReply = REPL_553_READ_ONLY;
}
else
{
prvStoreFilePrep( pxClient, pcRestCommand );
if( pxClient->bits1.bEmptyFile != pdFALSE_UNSIGNED )
{
/* Although the 'xTransferSocket' is closed already,
call this function just for the logging. */
prvTransferCloseSocket( pxClient );
/* Close an empty file. */
prvTransferCloseFile( pxClient );
}
}
break;
}
}
break;
case ECMD_FEAT:
{
static const char pcFeatAnswer[] =
"211-Features:\x0a"
/* The MDTM command is only allowed when
there is support for date&time. */
#if( ffconfigTIME_SUPPORT != 0 )
" MDTM\x0a"
#endif
" REST STREAM\x0a"
" SIZE\x0d\x0a"
"211 End\x0d\x0a";
pcMyReply = pcFeatAnswer;
}
break;
case ECMD_UNKNOWN:
FreeRTOS_printf( ("ftp::processCmd: Cmd %s unknown\n", pcRestCommand ) );
pcMyReply = REPL_500;
break;
}
}
if( pxFTPCommand->ucCommandType != ECMD_RNFR )
{
pxClient->bits.bInRename = pdFALSE_UNSIGNED;
}
if( pcMyReply != NULL )
{
xResult = prvSendReply( pxClient->xSocket, pcMyReply, strlen( pcMyReply ) );
}
return xResult;
}
/*-----------------------------------------------------------*/
static BaseType_t prvTransferConnect( FTPClient_t *pxClient, BaseType_t xDoListen )
{
Socket_t xSocket;
BaseType_t xResult;
/* Open a socket for a data connection with the FTP client.
Happens after a PORT or a PASV command. */
/* Make sure the previous socket is deleted and flags reset */
prvTransferCloseSocket( pxClient );
pxClient->bits1.bEmptyFile = pdFALSE_UNSIGNED;
xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP );
if( ( xSocket != FREERTOS_NO_SOCKET ) && ( xSocket != FREERTOS_INVALID_SOCKET ) )
{
BaseType_t xSmallTimeout = pdMS_TO_TICKS( 100 );
struct freertos_sockaddr xAddress;
#if( ipconfigFTP_TX_BUFSIZE > 0 )
WinProperties_t xWinProps;
#endif
xAddress.sin_addr = FreeRTOS_GetIPAddress( ); /* Single NIC, currently not used */
xAddress.sin_port = FreeRTOS_htons( 0 ); /* Bind to any available port number */
FreeRTOS_bind( xSocket, &xAddress, sizeof( xAddress ) );
#if( ipconfigFTP_TX_BUFSIZE > 0 )
{
/* Fill in the buffer and window sizes that will be used by the
socket. */
xWinProps.lTxBufSize = ipconfigFTP_TX_BUFSIZE;
xWinProps.lTxWinSize = ipconfigFTP_TX_WINSIZE;
xWinProps.lRxBufSize = ipconfigFTP_RX_BUFSIZE;
xWinProps.lRxWinSize = ipconfigFTP_RX_WINSIZE;
/* Set the window and buffer sizes. */
FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_WIN_PROPERTIES, ( void * ) &xWinProps, sizeof( xWinProps ) );
}
#endif
FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, ( void * ) &xSmallTimeout, sizeof( BaseType_t ) );
FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, ( void * ) &xSmallTimeout, sizeof( BaseType_t ) );
/* The same instance of the socket will be used for the connection and
data transport. */
if( xDoListen != pdFALSE )
{
BaseType_t xTrueValue = pdTRUE;
FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_REUSE_LISTEN_SOCKET, ( void * ) &xTrueValue, sizeof( xTrueValue ) );
}
pxClient->bits1.bIsListen = xDoListen;
pxClient->xTransferSocket = xSocket;
if( xDoListen != pdFALSE )
{
FreeRTOS_FD_SET( xSocket, pxClient->pxParent->xSocketSet, eSELECT_EXCEPT | eSELECT_READ );
/* Calling FreeRTOS_listen( ) */
xResult = prvTransferStart( pxClient );
if( xResult >= 0 )
{
xResult = pdTRUE;
}
}
else
{
FreeRTOS_FD_SET( xSocket, pxClient->pxParent->xSocketSet, eSELECT_EXCEPT | eSELECT_READ | eSELECT_WRITE );
xResult = pdTRUE;
}
}
else
{
FreeRTOS_printf( ( "FreeRTOS_socket() failed\n" ) );
xResult = -pdFREERTOS_ERRNO_ENOMEM;
}
/* An active socket (PORT) should connect() later. */
return xResult;
}
/*-----------------------------------------------------------*/
static BaseType_t prvTransferStart( FTPClient_t *pxClient )
{
BaseType_t xResult;
/* A transfer socket has been opened, now either call listen() for 'PASV'
or connect() for the 'PORT' command. */
if( pxClient->bits1.bIsListen != pdFALSE_UNSIGNED )
{
xResult = FreeRTOS_listen( pxClient->xTransferSocket, 1 );
}
else
{
struct freertos_sockaddr xAddress;
xAddress.sin_addr = FreeRTOS_htonl( pxClient->ulClientIP );
xAddress.sin_port = FreeRTOS_htons( pxClient->usClientPort );
/* Start an active connection for this data socket */
xResult = FreeRTOS_connect( pxClient->xTransferSocket, &xAddress, sizeof( xAddress ) );
}
return xResult;
}
/*-----------------------------------------------------------*/
static void prvTransferCheck( FTPClient_t *pxClient )
{
BaseType_t xRxSize;
/* A data transfer is busy. Check if there are changes in connectedness. */
xRxSize = FreeRTOS_rx_size( pxClient->xTransferSocket );
if( pxClient->bits1.bClientConnected == pdFALSE_UNSIGNED )
{
/* The time to receive a small file can be so short, that we don't even
see that the socket gets connected and disconnected. Therefore, check
the sizeof of the RX buffer. */
{
struct freertos_sockaddr xAddress;
Socket_t xNexSocket;
socklen_t xSocketLength = sizeof( xAddress );
if( pxClient->bits1.bIsListen != pdFALSE_UNSIGNED )
{
xNexSocket = FreeRTOS_accept( pxClient->xTransferSocket, &xAddress, &xSocketLength);
if( ( ( xNexSocket != FREERTOS_NO_SOCKET ) && ( xNexSocket != FREERTOS_INVALID_SOCKET ) ) ||
xRxSize > 0 )
{
pxClient->bits1.bClientConnected = pdTRUE_UNSIGNED;
}
}
else
{
if( FreeRTOS_issocketconnected( pxClient->xTransferSocket ) > 0 ||
xRxSize > 0 )
{
pxClient->bits1.bClientConnected = pdTRUE_UNSIGNED;
}
}
if( pxClient->bits1.bClientConnected != pdFALSE_UNSIGNED )
{
pxClient->bits1.bEmptyFile = pdFALSE_UNSIGNED;
#if( ipconfigHAS_PRINTF != 0 )
{
struct freertos_sockaddr xRemoteAddress, xLocalAddress;
FreeRTOS_GetRemoteAddress( pxClient->xTransferSocket, &xRemoteAddress );
FreeRTOS_GetLocalAddress( pxClient->xTransferSocket, &xLocalAddress );
FreeRTOS_printf( ( "%s Connected from %u to %u\n",
pxClient->bits1.bIsListen != pdFALSE_UNSIGNED ? "PASV" : "PORT",
( unsigned ) FreeRTOS_ntohs( xLocalAddress.sin_port ),
( unsigned ) FreeRTOS_ntohs( xRemoteAddress.sin_port ) ) );
}
#endif /* ipconfigHAS_PRINTF */
FreeRTOS_FD_CLR( pxClient->xTransferSocket, pxClient->pxParent->xSocketSet, eSELECT_WRITE );
FreeRTOS_FD_SET( pxClient->xTransferSocket, pxClient->pxParent->xSocketSet, eSELECT_READ|eSELECT_EXCEPT );
}
}
}
if ( pxClient->bits1.bClientConnected != pdFALSE_UNSIGNED )
{
if( pxClient->pcConnectionAck[ 0 ] != '\0' )
{
BaseType_t xLength;
BaseType_t xRemotePort;
struct freertos_sockaddr xRemoteAddress;
FreeRTOS_GetRemoteAddress( pxClient->xTransferSocket, &xRemoteAddress );
xRemotePort = FreeRTOS_ntohs( xRemoteAddress.sin_port );
/* Tell on the command port 21 we have a data connection */
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
pxClient->pcConnectionAck, pxClient->ulClientIP, xRemotePort );
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
pxClient->pcConnectionAck[ 0 ] = '\0';
}
if( ( FreeRTOS_issocketconnected( pxClient->xTransferSocket ) == pdFALSE ) && FreeRTOS_rx_size( pxClient->xTransferSocket ) == 0 )
{
prvTransferCloseSocket( pxClient );
prvTransferCloseFile( pxClient );
}
}
}
/*-----------------------------------------------------------*/
static void prvTransferCloseSocket( FTPClient_t *pxClient )
{
if( pxClient->xTransferSocket != FREERTOS_NO_SOCKET )
{
/* DEBUGGING ONLY */
BaseType_t xRxSize = FreeRTOS_rx_size( pxClient->xTransferSocket );
if( xRxSize > 0 )
{
BaseType_t xRxSize2;
BaseType_t xStatus;
prvStoreFileWork( pxClient );
xStatus = FreeRTOS_connstatus( pxClient->xTransferSocket );
xRxSize2 = FreeRTOS_rx_size( pxClient->xTransferSocket );
FreeRTOS_printf( ( "FTP: WARNING: %s: RX size = %ld -> %ld (%s)\n",
FreeRTOS_GetTCPStateName( xStatus ),
xRxSize, xRxSize2, pxClient->pcFileName ) );
if( xRxSize2 > 1 )
{
return;
}
/* Remove compiler warnings in case FreeRTOS_printf() is not
defined. */
( void ) xStatus;
}
}
if( ( pxClient->pxWriteHandle != NULL ) || ( pxClient->pxReadHandle != NULL ) )
{
BaseType_t xLength;
char pcStrBuf[ 32 ];
if( pxClient->bits1.bHadError == pdFALSE_UNSIGNED )
{
xLength = snprintf( pxClient->pcClientAck, sizeof( pxClient->pcClientAck ),
"226 Closing connection %d bytes transmitted\r\n", ( int ) pxClient->ulRecvBytes );
}
else
{
xLength = snprintf( pxClient->pcClientAck, sizeof( pxClient->pcClientAck ),
"451 Requested action aborted after %d bytes\r\n", ( int ) pxClient->ulRecvBytes );
}
/* Tell on the command socket the data connection is now closed. */
prvSendReply( pxClient->xSocket, pxClient->pcClientAck, xLength );
#if( ipconfigHAS_PRINTF != 0 )
{
TickType_t xDelta;
uint32_t ulAverage;
xDelta = xTaskGetTickCount( ) - pxClient->xStartTime;
ulAverage = ulGetAverage( pxClient->ulRecvBytes, xDelta );
FreeRTOS_printf( ("FTP: %s: '%s' %lu Bytes (%s/sec)\n",
pxClient->pxReadHandle ? "sent" : "recv",
pxClient->pcFileName,
pxClient->ulRecvBytes,
pcMkSize( ulAverage, pcStrBuf, sizeof( pcStrBuf ) ) ) );
}
#endif
}
if( pxClient->xTransferSocket != FREERTOS_NO_SOCKET )
{
FreeRTOS_FD_CLR( pxClient->xTransferSocket, pxClient->pxParent->xSocketSet, eSELECT_ALL );
FreeRTOS_closesocket( pxClient->xTransferSocket );
pxClient->xTransferSocket = FREERTOS_NO_SOCKET;
if( pxClient->ulRecvBytes == 0ul )
{
/* Received zero bytes: an empty file */
pxClient->bits1.bEmptyFile = pdTRUE_UNSIGNED;
}
else
{
pxClient->bits1.bEmptyFile = pdFALSE_UNSIGNED;
}
}
pxClient->bits1.bIsListen = pdFALSE_UNSIGNED;
pxClient->bits1.bDirHasEntry = pdFALSE_UNSIGNED;
pxClient->bits1.bClientConnected = pdFALSE_UNSIGNED;
pxClient->bits1.bHadError = pdFALSE_UNSIGNED;
}
/*-----------------------------------------------------------*/
static void prvTransferCloseFile( FTPClient_t *pxClient )
{
if( pxClient->pxWriteHandle != NULL )
{
ff_fclose( pxClient->pxWriteHandle );
pxClient->pxWriteHandle = NULL;
#if( ipconfigFTP_HAS_RECEIVED_HOOK != 0 )
{
vApplicationFTPReceivedHook( pxClient->pcFileName, pxClient->ulRecvBytes, pxClient );
}
#endif
}
if( pxClient->pxReadHandle != NULL )
{
ff_fclose( pxClient->pxReadHandle );
pxClient->pxReadHandle = NULL;
}
/* These two field are only used for logging / file-statistics */
pxClient->ulRecvBytes = 0ul;
pxClient->xStartTime = 0ul;
}
/*-----------------------------------------------------------*/
/**
* Guess the transfer type, given the client requested type.
* Actually in unix there is no difference between binary and
* ascii mode when we work with file descriptors.
* If #type is not recognized as a valid client request, -1 is returned.
*/
static BaseType_t prvGetTransferType( const char *pcType )
{
BaseType_t xResult = -1;
if( pcType != NULL )
{
BaseType_t xLength = strlen( pcType );
if( xLength == 0 )
{
return -1;
}
switch( pcType[ 0 ] ) {
case 'I':
xResult = TMODE_BINARY;
break;
case 'A':
xResult = TMODE_ASCII;
break;
case 'L':
if( xLength >= 3 )
{
if( pcType[ 2 ] == '7' )
{
xResult = TMODE_7BITS;
}
else if( pcType[ 2 ] == '8' )
{
xResult = TMODE_7BITS;
}
}
break;
}
}
return xResult;
}
/*-----------------------------------------------------------*/
#if( ipconfigHAS_PRINTF != 0 )
#define SIZE_1_GB ( 1024ul * 1024ul * 1024ul )
#define SIZE_1_MB ( 1024ul * 1024ul )
#define SIZE_1_KB ( 1024ul )
static const char *pcMkSize( uint32_t ulAmount, char *pcBuffer, BaseType_t xBufferSize )
{
uint32_t ulGB, ulMB, ulKB, ulByte;
ulGB = ( ulAmount / SIZE_1_GB );
ulAmount -= ( ulGB * SIZE_1_GB );
ulMB = ( ulAmount / SIZE_1_MB );
ulAmount -= ( ulMB * SIZE_1_MB );
ulKB = ( ulAmount / SIZE_1_KB );
ulAmount -= ( ulKB * SIZE_1_KB );
ulByte = ( ulAmount );
if (ulGB != 0ul )
{
snprintf( pcBuffer, xBufferSize, "%lu.%02lu GB", ulGB, (100 * ulMB) / SIZE_1_KB );
}
else if( ulMB != 0ul )
{
snprintf( pcBuffer, xBufferSize, "%lu.%02lu MB", ulMB, (100 * ulKB) / SIZE_1_KB );
}
else if( ulKB != 0ul )
{
snprintf(pcBuffer, xBufferSize, "%lu.%02lu KB", ulKB, (100 * ulByte) / SIZE_1_KB );
}
else
{
snprintf( pcBuffer, xBufferSize, "%lu bytes", ulByte );
}
return pcBuffer;
}
/*-----------------------------------------------------------*/
#endif /* ipconfigHAS_PRINTF != 0 */
#if( ipconfigHAS_PRINTF != 0 )
static uint32_t ulGetAverage( uint32_t ulAmount, TickType_t xDeltaMs )
{
uint32_t ulAverage;
/* Get the average amount of bytes per seconds. Ideally this is
calculated by Multiplying with 1000 and dividing by milliseconds:
ulAverage = ( 1000ul * ulAmount ) / xDeltaMs;
Now get a maximum precision, while avoiding an arithmetic overflow:
*/
if( xDeltaMs == 0ul )
{
/* Time is zero, there is no average */
ulAverage = 0ul;
}
else if( ulAmount >= ( ~0ul / 10ul ) )
{
/* More than 409 MB has been transferred, do not multiply. */
ulAverage = ( ulAmount / ( xDeltaMs / 1000ul ) );
}
else if( ulAmount >= ( ~0ul / 100ul ) )
{
/* Between 409 and 41 MB has been transferred, can multiply by 10. */
ulAverage = ( ( ulAmount * 10ul ) / ( xDeltaMs / 100ul ) );
}
else if( ulAmount >= ( ~0ul / 1000ul ) )
{
/* Between 4.1 MB and 41 has been transferred, can multiply by 100. */
ulAverage = ( ( ulAmount * 100ul ) / ( xDeltaMs / 10ul ) );
}
else
{
/* Less than 4.1 MB: can multiply by 1000. */
ulAverage = ( ( ulAmount * 1000ul ) / xDeltaMs );
}
return ulAverage;
}
/*-----------------------------------------------------------*/
#endif /* ipconfigHAS_PRINTF != 0 */
static UBaseType_t prvParsePortData( const char *pcCommand, uint32_t *pulIPAddress )
{
/*_HT_ Using 'unsigned' here because when sscanf() sees '%u', it expects a pointer to 'unsigned'.
Not sure about the sscanf() format for UBaseType_t ? */
unsigned h1, h2, h3, h4, p1, p2;
char sep;
UBaseType_t uxResult;
/* Expect PORT h1,h2,h3,h4,p1,p2 */
if (sscanf (pcCommand, "%u%c%u%c%u%c%u%c%u%c%u", &h1, &sep, &h2, &sep, &h3, &sep, &h4, &sep, &p1, &sep, &p2) != 11)
{
uxResult= 0u;
}
else
{
/* Put in network byte order. */
*pulIPAddress =
( ( uint32_t ) h1 << 24 ) |
( ( uint32_t ) h2 << 16 ) |
( ( uint32_t ) h3 << 8 ) |
( ( uint32_t ) h4 );
uxResult = ( p1 << 8 ) | p2;
}
return uxResult;
}
/*-----------------------------------------------------------*/
/*
#### ####### # ###
# # # # ## # #
# # # # # #
# ###### #### ### ## #### # # ### # ####
## # # # # # # # # ##### # # # #
## # # # ## # ###### # # # # ######
# # # # # # # # # # #
# # # ## # # # # ## # # # # ##
#### ## #### #### #### #### ##### ##### ####
*/
static BaseType_t prvStoreFilePrep( FTPClient_t *pxClient, char *pcFileName )
{
BaseType_t xResult;
FF_FILE *pxNewHandle;
size_t uxFileSize = 0ul;
int iErrorNo;
/* Close previous handle (if any) and reset file transfer parameters. */
prvTransferCloseFile( pxClient );
xMakeAbsolute( pxClient, pxClient->pcFileName, sizeof( pxClient->pcFileName ), pcFileName );
pxNewHandle = NULL;
if( pxClient->ulRestartOffset != 0 )
{
size_t uxOffset = pxClient->ulRestartOffset;
int32_t lRc;
pxClient->ulRestartOffset = 0ul; /* Only use 1 time. */
pxNewHandle = ff_fopen( pxClient->pcFileName, "ab" );
if( pxNewHandle != NULL )
{
uxFileSize = pxNewHandle->ulFileSize;
if( uxOffset <= uxFileSize )
{
lRc = ff_fseek( pxNewHandle, uxOffset, FF_SEEK_SET );
}
else
{
/* Won't even try to seek after EOF */
lRc = -pdFREERTOS_ERRNO_EINVAL;
}
if( lRc != 0 )
{
BaseType_t xLength;
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"450 Seek invalid %u length %u\r\n",
( unsigned ) uxOffset, ( unsigned ) uxFileSize );
/* "Requested file action not taken". */
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
FreeRTOS_printf( ( "ftp::storeFile: create %s: Seek %u length %u\n",
pxClient->pcFileName, ( unsigned ) uxOffset, ( unsigned ) uxFileSize ) );
ff_fclose( pxNewHandle );
pxNewHandle = NULL;
}
}
}
else
{
pxNewHandle = ff_fopen( pxClient->pcFileName, "wb" );
}
if( pxNewHandle == NULL )
{
iErrorNo = stdioGET_ERRNO();
if( iErrorNo == pdFREERTOS_ERRNO_ENOSPC )
{
prvSendReply( pxClient->xSocket, REPL_552, 0 );
}
else
{
/* "Requested file action not taken". */
prvSendReply( pxClient->xSocket, REPL_450, 0 );
}
FreeRTOS_printf( ( "ftp::storeFile: create %s: %s (errno %d)\n",
pxClient->pcFileName,
( const char* ) strerror( iErrorNo ), iErrorNo ) );
xResult = pdFALSE;
}
else
{
if( pxClient->bits1.bIsListen )
{
/* True if PASV is used. */
snprintf( pxClient->pcConnectionAck, sizeof( pxClient->pcConnectionAck ),
"150 Accepted data connection from %%xip:%%u\r\n" );
prvTransferCheck( pxClient );
}
else
{
BaseType_t xLength;
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), "150 Opening BIN connection to store file\r\n" );
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
pxClient->pcConnectionAck[ 0 ] = '\0';
prvTransferStart( pxClient ); /* Now active connect. */
}
pxClient->pxWriteHandle = pxNewHandle;
/* To get some statistics about the performance. */
pxClient->xStartTime = xTaskGetTickCount( );
xResult = pdTRUE;
}
return xResult;
}
/*-----------------------------------------------------------*/
#if( ipconfigFTP_ZERO_COPY_ALIGNED_WRITES == 0 )
static BaseType_t prvStoreFileWork( FTPClient_t *pxClient )
{
BaseType_t xRc, xWritten;
/* Read from the data socket until all has been read or until a negative value
is returned. */
for( ; ; )
{
char *pcBuffer;
/* The "zero-copy" method: */
xRc = FreeRTOS_recv( pxClient->xTransferSocket, ( void * ) &pcBuffer,
0x20000u, FREERTOS_ZERO_COPY | FREERTOS_MSG_DONTWAIT );
if( xRc <= 0 )
{
break;
}
pxClient->ulRecvBytes += xRc;
xWritten = ff_fwrite( pcBuffer, 1, xRc, pxClient->pxWriteHandle );
FreeRTOS_recv( pxClient->xTransferSocket, ( void * ) NULL, xRc, 0 );
if( xWritten != xRc )
{
xRc = -1;
/* bHadError: a transfer got aborted because of an error. */
pxClient->bits1.bHadError = pdTRUE_UNSIGNED;
break;
}
}
return xRc;
}
#else /* ipconfigFTP_ZERO_COPY_ALIGNED_WRITES != 0 */
#if !defined( ipconfigFTP_PREFERRED_WRITE_SIZE )
/* If you store data on flash, it may be profitable to give 'ipconfigFTP_PREFERRED_WRITE_SIZE'
the same size as the size of the flash' erase blocks, e.g. 4KB */
#define ipconfigFTP_PREFERRED_WRITE_SIZE 512ul
#endif
static BaseType_t prvStoreFileWork( FTPClient_t *pxClient )
{
BaseType_t xRc, xWritten;
/* Read from the data socket until all has been read or until a negative
value is returned. */
for( ; ; )
{
char *pcBuffer;
UBaseType_t xStatus;
/* The "zero-copy" method: */
xRc = FreeRTOS_recv( pxClient->xTransferSocket, ( void * ) &pcBuffer,
0x20000u, FREERTOS_ZERO_COPY | FREERTOS_MSG_DONTWAIT );
if( xRc <= 0 )
{
/* There are no data or the connection is closed. */
break;
}
xStatus = FreeRTOS_connstatus( pxClient->xTransferSocket );
if( xStatus != eESTABLISHED )
{
/* The connection is not established (any more), therefore
accept any amount of bytes, probably the last few bytes. */
}
else
{
if( xRc >= ipconfigFTP_PREFERRED_WRITE_SIZE )
{
/* More than a sector to write, round down to a multiple of
PREFERRED_WRITE_SIZE bytes. */
xRc = ( xRc / ipconfigFTP_PREFERRED_WRITE_SIZE ) * ipconfigFTP_PREFERRED_WRITE_SIZE;
}
else
{
const StreamBuffer_t *pxBuffer = FreeRTOS_get_rx_buf( pxClient->xTransferSocket );
size_t uxSpace = pxBuffer->LENGTH - pxBuffer->uxTail;
if( uxSpace >= ipconfigFTP_PREFERRED_WRITE_SIZE )
{
/* At this moment there are les than PREFERRED_WRITE_SIZE bytes in the RX
buffer, but there is space for more. Just return and
wait for more. */
xRc = 0;
}
else
{
/* Now reading beyond the end of the circular buffer,
use a normal read. */
pcBuffer = pcFILE_BUFFER;
xRc = FreeRTOS_recvcount( pxClient->xTransferSocket );
xRc = ( xRc / ipconfigFTP_PREFERRED_WRITE_SIZE ) * ipconfigFTP_PREFERRED_WRITE_SIZE;
if( xRc > 0 )
{
xRc = FreeRTOS_recv( pxClient->xTransferSocket, ( void * ) pcBuffer,
sizeof( pcFILE_BUFFER ), FREERTOS_MSG_DONTWAIT );
}
}
}
}
if( xRc == 0 )
{
break;
}
pxClient->ulRecvBytes += xRc;
xWritten = ff_fwrite( pcBuffer, 1, xRc, pxClient->pxWriteHandle );
if( pcBuffer != pcFILE_BUFFER )
{
FreeRTOS_recv( pxClient->xTransferSocket, ( void * ) NULL, xRc, 0 );
}
if( xWritten != xRc )
{
xRc = -1;
/* bHadError: a transfer got aborted because of an error. */
pxClient->bits1.bHadError = pdTRUE_UNSIGNED;
break;
}
}
return xRc;
}
#endif /* ipconfigFTP_ZERO_COPY_ALIGNED_WRITES */
/*-----------------------------------------------------------*/
/*
###### # ####### # ###
# # # # # ## # #
# # # # # #
# # #### ###### ### ## ### #### # # #### # # ### # ####
###### # # # # # # # # # # # # # ##### # # # #
# ## ###### # ## # # ###### # # ###### # # # # ######
# # # # # # # # # # # # # #
# # # ## # ## # # # ## # # # ## # # # # ##
### ## #### ## #### ##### #### ## #### #### ##### ##### ####
*/
static BaseType_t prvRetrieveFilePrep( FTPClient_t *pxClient, char *pcFileName )
{
BaseType_t xResult = pdTRUE;
size_t uxFileSize;
/* Close previous handle (if any) and reset file transfer parameters */
prvTransferCloseFile( pxClient );
xMakeAbsolute( pxClient, pxClient->pcFileName, sizeof( pxClient->pcFileName ), pcFileName );
pxClient->pxReadHandle = ff_fopen( pxClient->pcFileName, "rb" );
if( pxClient->pxReadHandle == NULL )
{
int iErrno = stdioGET_ERRNO();
/* "Requested file action not taken". */
prvSendReply( pxClient->xSocket, REPL_450, 0 );
FreeRTOS_printf( ("prvRetrieveFilePrep: open '%s': errno %d: %s\n",
pxClient->pcFileName, iErrno, ( const char * ) strerror( iErrno ) ) );
uxFileSize = 0ul;
xResult = pdFALSE;
}
else
{
uxFileSize = pxClient->pxReadHandle->ulFileSize;
pxClient->uxBytesLeft = uxFileSize;
if( pxClient->ulRestartOffset != 0ul )
{
size_t uxOffset = pxClient->ulRestartOffset;
int32_t iRc;
/* Only use 1 time. */
pxClient->ulRestartOffset = 0;
if( uxOffset < uxFileSize )
{
iRc = ff_fseek( pxClient->pxReadHandle, uxOffset, FF_SEEK_SET );
}
else
{
iRc = -pdFREERTOS_ERRNO_EINVAL;
}
if( iRc != 0 )
{
BaseType_t xLength;
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"450 Seek invalid %u length %u\r\n", ( unsigned ) uxOffset, ( unsigned ) uxFileSize );
/* "Requested file action not taken". */
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
FreeRTOS_printf( ( "prvRetrieveFilePrep: create %s: Seek %u length %u\n",
pxClient->pcFileName, ( unsigned ) uxOffset, ( unsigned ) uxFileSize ) );
ff_fclose( pxClient->pxReadHandle );
pxClient->pxReadHandle = NULL;
xResult = pdFALSE;
}
else
{
pxClient->uxBytesLeft = uxFileSize - pxClient->ulRestartOffset;
}
}
}
if( xResult != pdFALSE )
{
if( pxClient->bits1.bIsListen != pdFALSE_UNSIGNED )
{
/* True if PASV is used. */
snprintf( pxClient->pcConnectionAck, sizeof( pxClient->pcConnectionAck ),
"150%cAccepted data connection from %%xip:%%u\r\n%s",
pxClient->xTransType == TMODE_ASCII ? '-' : ' ',
pxClient->xTransType == TMODE_ASCII ? "150 NOTE: ASCII mode requested, but binary mode used\r\n" : "" );
} else {
BaseType_t xLength;
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), "150%cOpening data connection to %lxip:%u\r\n%s",
pxClient->xTransType == TMODE_ASCII ? '-' : ' ',
pxClient->ulClientIP,
pxClient->usClientPort,
pxClient->xTransType == TMODE_ASCII ? "150 NOTE: ASCII mode requested, but binary mode used\r\n" : "" );
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
pxClient->pcConnectionAck[ 0 ] = '\0';
prvTransferStart( pxClient );
}
/* Prepare the ACK which will be sent when all data has been sent. */
snprintf( pxClient->pcClientAck, sizeof( pxClient->pcClientAck ), "%s", REPL_226 );
/* To get some statistics about the performance. */
pxClient->xStartTime = xTaskGetTickCount( );
if( uxFileSize == 0ul )
{
FreeRTOS_shutdown( pxClient->xTransferSocket, FREERTOS_SHUT_RDWR );
}
}
return xResult;
}
/*-----------------------------------------------------------*/
static BaseType_t prvRetrieveFileWork( FTPClient_t *pxClient )
{
size_t uxSpace;
size_t uxCount, uxItemsRead;
BaseType_t xRc = 0;
BaseType_t xSetEvent = pdFALSE;
do
{
#if( ipconfigFTP_TX_ZERO_COPY != 0 )
char *pcBuffer;
BaseType_t xBufferLength;
#endif /* ipconfigFTP_TX_ZERO_COPY */
/* Take the lesser of the two: tx_space (number of bytes that can be
queued for transmission) and uxBytesLeft (the number of bytes left to
read from the file) */
uxSpace = FreeRTOS_tx_space( pxClient->xTransferSocket );
if( uxSpace == 0 )
{
FreeRTOS_FD_SET( pxClient->xTransferSocket, pxClient->pxParent->xSocketSet, eSELECT_WRITE | eSELECT_EXCEPT );
xRc = FreeRTOS_select( pxClient->pxParent->xSocketSet, 200 );
uxSpace = FreeRTOS_tx_space( pxClient->xTransferSocket );
}
uxCount = FreeRTOS_min_uint32( pxClient->uxBytesLeft, uxSpace );
if( uxCount == 0 )
{
break;
}
#if( ipconfigFTP_TX_ZERO_COPY == 0 )
{
if( uxCount > sizeof( pcFILE_BUFFER ) )
{
uxCount = sizeof( pcFILE_BUFFER );
}
uxItemsRead = ff_fread( pcFILE_BUFFER, 1, uxCount, pxClient->pxReadHandle );
if( uxItemsRead != uxCount )
{
FreeRTOS_printf( ( "prvRetrieveFileWork: Got %u Expected %u\n", ( unsigned )uxItemsRead, ( unsigned ) uxCount ) );
xRc = FreeRTOS_shutdown( pxClient->xTransferSocket, FREERTOS_SHUT_RDWR );
pxClient->uxBytesLeft = 0u;
break;
}
pxClient->uxBytesLeft -= uxCount;
if( pxClient->uxBytesLeft == 0u )
{
BaseType_t xTrueValue = 1;
FreeRTOS_setsockopt( pxClient->xTransferSocket, 0, FREERTOS_SO_CLOSE_AFTER_SEND, ( void * ) &xTrueValue, sizeof( xTrueValue ) );
}
xRc = FreeRTOS_send( pxClient->xTransferSocket, pcFILE_BUFFER, uxCount, 0 );
}
#else /* ipconfigFTP_TX_ZERO_COPY != 0 */
{
/* Use zero-copy transmission:
FreeRTOS_get_tx_head() returns a direct pointer to the TX stream and
set xBufferLength to know how much space there is left. */
pcBuffer = ( char * )FreeRTOS_get_tx_head( pxClient->xTransferSocket, &xBufferLength );
if( ( pcBuffer != NULL ) && ( xBufferLength >= 512 ) )
{
/* Will read disk data directly to the TX stream of the socket. */
uxCount = FreeRTOS_min_uint32( uxCount, ( uint32_t )xBufferLength );
if( uxCount > ( size_t ) 0x40000u )
{
uxCount = ( size_t ) 0x40000u;
}
}
else
{
/* Use the normal file i/o buffer. */
pcBuffer = pcFILE_BUFFER;
if( uxCount > sizeof( pcFILE_BUFFER ) )
{
uxCount = sizeof( pcFILE_BUFFER );
}
}
if ( pxClient->uxBytesLeft >= 1024u )
{
uxCount &= ~( ( size_t ) 512u - 1u );
}
if( uxCount <= 0u )
{
/* Nothing to send after rounding down to a multiple of a sector size. */
break;
}
uxItemsRead = ff_fread( pcBuffer, 1, uxCount, pxClient->pxReadHandle );
if( uxCount != uxItemsRead )
{
FreeRTOS_printf( ( "prvRetrieveFileWork: Got %u Expected %u\n", ( unsigned )uxItemsRead, ( unsigned )uxCount ) );
xRc = FreeRTOS_shutdown( pxClient->xTransferSocket, FREERTOS_SHUT_RDWR );
pxClient->uxBytesLeft = 0u;
break;
}
pxClient->uxBytesLeft -= uxCount;
if( pxClient->uxBytesLeft == 0u )
{
BaseType_t xTrueValue = 1;
FreeRTOS_setsockopt( pxClient->xTransferSocket, 0, FREERTOS_SO_CLOSE_AFTER_SEND, ( void * ) &xTrueValue, sizeof( xTrueValue ) );
}
if( pcBuffer != pcFILE_BUFFER )
{
pcBuffer = NULL;
}
xRc = FreeRTOS_send( pxClient->xTransferSocket, pcBuffer, uxCount, 0 );
}
#endif /* ipconfigFTP_TX_ZERO_COPY */
if( xRc < 0 )
{
break;
}
pxClient->ulRecvBytes += xRc;
if( pxClient->uxBytesLeft == 0u )
{
break;
}
} while( uxCount > 0u );
if( xRc < 0 )
{
FreeRTOS_printf( ( "prvRetrieveFileWork: already disconnected\n" ) );
}
else if( pxClient->uxBytesLeft <= 0u )
{
BaseType_t x;
for( x = 0; x < 5; x++ )
{
xRc = FreeRTOS_recv( pxClient->xTransferSocket, pcFILE_BUFFER, sizeof( pcFILE_BUFFER ), 0 );
if( xRc < 0 )
{
break;
}
}
// FreeRTOS_printf( ( "prvRetrieveFileWork: %s all sent: xRc %ld\n", pxClient->pcFileName, xRc ) );
}
else
{
FreeRTOS_FD_SET( pxClient->xTransferSocket, pxClient->pxParent->xSocketSet, eSELECT_WRITE );
xSetEvent = pdTRUE;
}
if( xSetEvent == pdFALSE )
{
FreeRTOS_FD_CLR( pxClient->xTransferSocket, pxClient->pxParent->xSocketSet, eSELECT_WRITE );
}
return xRc;
}
/*-----------------------------------------------------------*/
/*
### ##### #### #####
# # # # # # #
# # # # #
# # # #
# # ## #
# # # ## #
# # # # # #
# # # # # #
####### ##### #### ####
*/
/* Prepare sending a directory LIST */
static BaseType_t prvListSendPrep( FTPClient_t *pxClient )
{
BaseType_t xFindResult;
int iErrorNo;
if( pxClient->bits1.bIsListen != pdFALSE_UNSIGNED )
{
/* True if PASV is used */
snprintf( pxClient->pcConnectionAck, sizeof( pxClient->pcConnectionAck ),
"150 Accepted data connection from %%xip:%%u\r\n" );
}
else
{
BaseType_t xLength;
/* Here the FTP server is supposed to connect() */
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"150 Opening ASCII mode data connection to for /bin/ls \r\n" );
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
/* Clear the current connection acknowledge message */
pxClient->pcConnectionAck[ 0 ] = '\0';
prvTransferStart( pxClient );
}
pxClient->xDirCount = 0;
xMakeAbsolute( pxClient, pcNEW_DIR, sizeof( pcNEW_DIR ), pxClient->pcCurrentDir );
xFindResult = ff_findfirst( pcNEW_DIR, &pxClient->xFindData );
pxClient->bits1.bDirHasEntry = ( xFindResult >= 0 );
iErrorNo = stdioGET_ERRNO();
if( ( xFindResult < 0 ) && ( iErrorNo == pdFREERTOS_ERRNO_ENMFILE ) )
{
FreeRTOS_printf( ("prvListSendPrep: Empty directory? (%s)\n", pxClient->pcCurrentDir ) );
prvSendReply( pxClient->xTransferSocket, "total 0\r\n", 0 );
pxClient->xDirCount++;
}
else if( xFindResult < 0 )
{
FreeRTOS_printf( ( "prvListSendPrep: rc = %ld iErrorNo = %d\n", xFindResult, iErrorNo ) );
prvSendReply( pxClient->xSocket, REPL_451, 0 );
}
pxClient->pcClientAck[ 0 ] = '\0';
return pxClient->xDirCount;
}
/*-----------------------------------------------------------*/
#define MAX_DIR_LIST_ENTRY_SIZE 256
static BaseType_t prvListSendWork( FTPClient_t *pxClient )
{
BaseType_t xTxSpace;
while( pxClient->bits1.bClientConnected != pdFALSE_UNSIGNED )
{
char *pcWritePtr = pcCOMMAND_BUFFER;
BaseType_t xWriteLength;
xTxSpace = FreeRTOS_tx_space( pxClient->xTransferSocket );
if( xTxSpace > ( BaseType_t ) sizeof( pcCOMMAND_BUFFER ) )
{
xTxSpace = sizeof( pcCOMMAND_BUFFER );
}
while( ( xTxSpace >= MAX_DIR_LIST_ENTRY_SIZE ) && ( pxClient->bits1.bDirHasEntry != pdFALSE_UNSIGNED ) )
{
BaseType_t xLength, xEndOfDir;
int32_t iRc;
int iErrorNo;
xLength = prvGetFileInfoStat( &( pxClient->xFindData.xDirectoryEntry ), pcWritePtr, xTxSpace );
pxClient->xDirCount++;
pcWritePtr += xLength;
xTxSpace -= xLength;
iRc = ff_findnext( &pxClient->xFindData );
iErrorNo = stdioGET_ERRNO();
xEndOfDir = ( iRc < 0 ) && ( iErrorNo == pdFREERTOS_ERRNO_ENMFILE );
pxClient->bits1.bDirHasEntry = ( xEndOfDir == pdFALSE ) && ( iRc >= 0 );
if( ( iRc < 0 ) && ( xEndOfDir == pdFALSE ) )
{
FreeRTOS_printf( ("prvListSendWork: %s (rc %08x)\n",
( const char * ) strerror( iErrorNo ),
( unsigned )iRc ) );
}
}
xWriteLength = ( BaseType_t ) ( pcWritePtr - pcCOMMAND_BUFFER );
if( xWriteLength == 0 )
{
break;
}
if( pxClient->bits1.bDirHasEntry == pdFALSE_UNSIGNED )
{
uint32_t ulTotalCount;
uint32_t ulFreeCount;
uint32_t ulPercentage;
ulTotalCount = 1;
ulFreeCount = ff_diskfree( pxClient->pcCurrentDir, &ulTotalCount );
ulPercentage = ( uint32_t ) ( ( 100ULL * ulFreeCount + ulTotalCount / 2 ) / ulTotalCount );
/* Prepare the ACK which will be sent when all data has been sent. */
snprintf( pxClient->pcClientAck, sizeof( pxClient->pcClientAck ),
"226-Options: -l\r\n"
"226-%ld matches total\r\n"
"226 Total %lu KB (%lu %% free)\r\n",
pxClient->xDirCount, ulTotalCount /1024, ulPercentage );
}
if( xWriteLength )
{
if( pxClient->bits1.bDirHasEntry == pdFALSE_UNSIGNED )
{
BaseType_t xTrueValue = 1;
FreeRTOS_setsockopt( pxClient->xTransferSocket, 0, FREERTOS_SO_CLOSE_AFTER_SEND, ( void * ) &xTrueValue, sizeof( xTrueValue ) );
}
prvSendReply( pxClient->xTransferSocket, pcCOMMAND_BUFFER, xWriteLength );
}
if( pxClient->bits1.bDirHasEntry == pdFALSE_UNSIGNED )
{
prvSendReply( pxClient->xSocket, pxClient->pcClientAck, 0 );
break;
}
} /* while( pxClient->bits1.bClientConnected ) */
return 0;
}
/*-----------------------------------------------------------*/
static const char *pcMonthAbbrev( BaseType_t xMonth )
{
static const char pcMonthList[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
if( xMonth < 1 || xMonth > 12 )
xMonth = 12;
return pcMonthList + 3 * ( xMonth - 1 );
};
/*-----------------------------------------------------------*/
static BaseType_t prvGetFileInfoStat( FF_DirEnt_t *pxEntry, char *pcLine, BaseType_t xMaxLength )
{
char date[ 16 ];
char mode[ 11 ] = "----------";
BaseType_t st_nlink = 1;
const char user[ 9 ] = "freertos";
const char group[ 8 ] = "plusfat";
/*
* Creates a unix-style listing, understood by most FTP clients:
*
* -rw-rw-r-- 1 freertos FreeRTOS+FAT 10564588 Sep 01 00:17 03. Metaharmoniks - Star (Instrumental).mp3
* -rw-rw-r-- 1 freertos FreeRTOS+FAT 19087839 Sep 01 00:17 04. Simon Le Grec - Dimitri (Wherever U Are) (Cosmos Mix).mp3
* -rw-rw-r-- 1 freertos FreeRTOS+FAT 11100621 Sep 01 00:16 05. D-Chill - Mistake (feat. Katy Blue).mp3
*/
#if ( ffconfigTIME_SUPPORT == 1 )
const FF_SystemTime_t *pxCreateTime = &( pxEntry->xCreateTime );
#else
#warning Do not use this.
FF_SystemTime_t xCreateTime;
const FF_SystemTime_t *pxCreateTime = &xCreateTime;
#endif
size_t ulSize = ( size_t )pxEntry->ulFileSize;
const char *pcFileName = pxEntry->pcFileName;
mode[ 0 ] = ( ( pxEntry->ucAttrib & FF_FAT_ATTR_DIR ) != 0 ) ? 'd' : '-';
#if( ffconfigDEV_SUPPORT != 0 )
{
if( ( pxEntry->ucAttrib & FF_FAT_ATTR_DIR ) == 0 )
{
switch( pxEntry->ucIsDeviceDir )
{
case FF_DEV_CHAR_DEV:
mode[ 0 ] = 'c';
break;
case FF_DEV_BLOCK_DEV:
mode[ 0 ] = 'b';
break;
}
}
}
#endif /* ffconfigDEV_SUPPORT != 0 */
mode[ 1 ] = 'r'; /* Owner. */
mode[ 2 ] = ( ( pxEntry->ucAttrib & FF_FAT_ATTR_READONLY ) != 0 ) ? '-' : 'w';
mode[ 3 ] = '-'; /* x for executable. */
mode[ 4 ] = 'r'; /* group. */
mode[ 5 ] = ( ( pxEntry->ucAttrib & FF_FAT_ATTR_READONLY ) != 0 ) ? '-' : 'w';
mode[ 6 ] = '-'; /* x for executable. */
mode[ 7 ] = 'r'; /* world. */
mode[ 8 ] = '-';
mode[ 9 ] = '-'; /* x for executable. */
if( pxCreateTime->Month && pxCreateTime->Day )
{
snprintf( date, sizeof( date ), "%-3.3s %02d %02d:%02d",
pcMonthAbbrev( pxCreateTime->Month ),
pxCreateTime->Day,
pxCreateTime->Hour,
pxCreateTime->Minute );
}
else
{
snprintf (date, sizeof( date ), "Jan 01 1970");
}
return snprintf( pcLine, xMaxLength, "%s %3ld %-4s %-4s %8d %12s %s\r\n",
mode, st_nlink, user, group, ( int ) ulSize, date, pcFileName );
}
/*-----------------------------------------------------------*/
/*
#### # # #####
# # # # # #
# # # # # #
# # # # # #
# # # # # #
# # # # # #
# # ## ## # #
# # ## ## # #
#### ## ## #####
*/
static BaseType_t prvChangeDir( FTPClient_t *pxClient, char *pcDirectory )
{
BaseType_t xResult;
BaseType_t xIsRootDir, xLength, xValid;
BaseType_t xIsDotDir = 0;
if( pcDirectory[ 0 ] == '.' )
{
if( ( pcDirectory[ 1 ] == '.' ) &&
( pcDirectory[ 2 ] == '\0' ) )
{
xIsDotDir = 2;
}
else if( pcDirectory[ 1 ] == '\0' )
{
xIsDotDir = 1;
}
}
if( xIsDotDir != 0 )
{
strcpy( pcFILE_BUFFER, pxClient->pcCurrentDir );
if( pcDirectory[ 1 ] == '.' )
{
char *p = strrchr( pcFILE_BUFFER, '/' );
if( p != NULL )
{
if( p == pcFILE_BUFFER )
{
p[ 1 ] = '\0';
}
else
{
p[ 0 ] = '\0';
}
}
}
}
else
{
if(pcDirectory[ 0 ] != '/' )
{
BaseType_t xCurLength;
xCurLength = strlen( pxClient->pcCurrentDir );
snprintf( pcFILE_BUFFER, sizeof( pcFILE_BUFFER ), "%s%s%s",
pxClient->pcCurrentDir,
pxClient->pcCurrentDir[ xCurLength - 1 ] == '/' ? "" : "/",
pcDirectory );
}
else
{
snprintf( pcFILE_BUFFER, sizeof( pcFILE_BUFFER ), "%s", pcDirectory );
}
}
xIsRootDir = ( pcFILE_BUFFER[ 0 ] == '/' ) && ( pcFILE_BUFFER[ 1 ] == '\0' );
xMakeAbsolute( pxClient, pcNEW_DIR, sizeof( pcNEW_DIR ), pcFILE_BUFFER );
if( ( ( xIsRootDir == pdFALSE ) || ( FF_FS_Count() == 0 ) ) && ( ff_finddir( pcNEW_DIR ) == pdFALSE ) )
{
xValid = pdFALSE;
}
else
{
xValid = pdTRUE;
}
if( xValid == pdFALSE )
{
/* Get the directory cluster, if it exists. */
FreeRTOS_printf( ("FTP: chdir \"%s\": No such dir\n", pcNEW_DIR ) );
//#define REPL_550 "550 Requested action not taken.\r\n"
//550 /home/hein/arch/h8300: No such file or directory
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"550 %s: No such file or directory\r\n",
pcNEW_DIR );
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
xResult = pdFALSE;
}
else
{
memcpy( pxClient->pcCurrentDir, pcNEW_DIR, sizeof( pxClient->pcCurrentDir ) );
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), "250 Changed to %s\r\n", pcNEW_DIR );
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
xResult = pdTRUE;
}
return xResult;
}
/*-----------------------------------------------------------*/
/*
###### ## # ####### ######
# # ## # # ## # #
# # ## # # # # #
# # ### # # # # #
###### # ## # ##### ######
# ## # ## # # # # ##
# # # ### # # #
# # # ## # # #
### ## # ## #### ### ##
*/
static BaseType_t prvRenameFrom( FTPClient_t *pxClient, const char *pcFileName )
{
const char *myReply;
FF_FILE *fh;
xMakeAbsolute( pxClient, pxClient->pcFileName, sizeof( pxClient->pcFileName ), pcFileName );
myReply = NULL;
fh = ff_fopen( pxClient->pcFileName, "rb" );
if( fh != NULL )
{
ff_fclose( fh );
/* REPL_350; "350 Requested file action pending further information." */
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"350 Rename '%s' ...\r\n", pxClient->pcFileName );
myReply = pcCOMMAND_BUFFER;
pxClient->bits.bInRename = pdTRUE_UNSIGNED;
}
else if( stdioGET_ERRNO() == pdFREERTOS_ERRNO_EISDIR )
{
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"350 Rename directory '%s' ...\r\n", pxClient->pcFileName );
myReply = pcCOMMAND_BUFFER;
pxClient->bits.bInRename = pdTRUE_UNSIGNED;
}
else
{
FreeRTOS_printf( ("ftp::renameFrom[%s]\n%s\n", pxClient->pcFileName, strerror( stdioGET_ERRNO() ) ) );
myReply = REPL_451; /* "451 Requested action aborted. Local error in processing." */
}
if( myReply )
{
prvSendReply( pxClient->xSocket, myReply, 0 );
}
return pdTRUE;
}
/*-----------------------------------------------------------*/
/*
###### ## # ##### ###
# # ## # # # # ## ##
# # ## # # ## ##
# # ### # # # #
###### # ## # # # #
# ## # ## # # # #
# # # ### # ## ##
# # # ## # ## ##
### ## # ## #### ###
*/
static BaseType_t prvRenameTo( FTPClient_t *pxClient, const char *pcFileName )
{
const char *myReply = NULL;
int iResult;
xMakeAbsolute( pxClient, pcNEW_DIR, sizeof( pcNEW_DIR ), pcFileName );
/* FreeRTOS+FAT rename has an extra parameter: "remove target if already
exists". */
iResult = ff_rename( pxClient->pcFileName, pcNEW_DIR, pdFALSE );
if( iResult < 0 )
{
iResult = stdioGET_ERRNO();
}
else
{
iResult = 0;
}
switch( iResult )
{
case 0:
FreeRTOS_printf( ( "ftp::renameTo[%s,%s]: Ok\n", pxClient->pcFileName, pcNEW_DIR ) );
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"250 Rename successful to '%s'\r\n", pcNEW_DIR );
myReply = pcCOMMAND_BUFFER;
break;
case pdFREERTOS_ERRNO_EEXIST:
/* the destination file already exists.
"450 Requested file action not taken.\r\n"*/
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"450 Already exists '%s'\r\n", pcNEW_DIR );
myReply = pcCOMMAND_BUFFER;
break;
case pdFREERTOS_ERRNO_EIO: /* FF_ERR_FILE_COULD_NOT_CREATE_DIRENT */
/* if dirent creation failed (fatal error!).
"553 Requested action not taken.\r\n" */
FreeRTOS_printf( ("ftp::renameTo[%s,%s]: Error creating DirEnt\n",
pxClient->pcFileName, pcNEW_DIR ) );
myReply = REPL_553;
break;
case pdFREERTOS_ERRNO_ENXIO:
case pdFREERTOS_ERRNO_ENOENT:
/* if the source file was not found.
"450 Requested file action not taken.\r\n" */
snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"450 No such file '%s'\r\n", pxClient->pcFileName );
myReply = pcCOMMAND_BUFFER;
break;
default:
FreeRTOS_printf( ("ftp::renameTo[%s,%s]: %s\n", pxClient->pcFileName, pcNEW_DIR,
(const char*)strerror( stdioGET_ERRNO() ) ) );
myReply = REPL_451; /* "451 Requested action aborted. Local error in processing." */
break;
}
prvSendReply( pxClient->xSocket, myReply, 0 );
return pdTRUE;
}
/*-----------------------------------------------------------*/
/*
#### #
# # # #
# # #
# ### ###### ####
## # # # #
## # # ######
# # # # #
# # # # ## # ##
#### ##### ## ####
*/
static BaseType_t prvSiteCmd( FTPClient_t *pxClient, char *pcRestCommand )
{
( void ) pxClient;
( void ) pcRestCommand;
return 0;
}
/*-----------------------------------------------------------*/
/*
##### ###
# # # #
# # # #
# # #### # #### ###### ####
# # # # # # # # # #
# # ###### # ###### # ######
# # # # # # #
# # # ## # # ## # ## # ##
##### #### ##### #### ## ####
*/
static BaseType_t prvDeleteFile( FTPClient_t *pxClient, char *pcFileName )
{
BaseType_t xResult, xLength;
int32_t iRc;
int iErrorNo;
/* DELE: Delete a file. */
xMakeAbsolute( pxClient, pxClient->pcFileName, sizeof( pxClient->pcFileName ), pcFileName );
iRc = ff_remove( pxClient->pcFileName );
if (iRc >= 0 )
{
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"250 File \"%s\" removed\r\n", pxClient->pcFileName );
xResult = pdTRUE;
}
else
{
const char *errMsg = "other error";
iErrorNo = stdioGET_ERRNO();
switch( iErrorNo )
{ /*_RB_ What do these negative numbers relate to? */
case pdFREERTOS_ERRNO_ENOENT: errMsg = "No such file"; break; /* -31 File was not found. */
case pdFREERTOS_ERRNO_EALREADY: errMsg = "File still open"; break; /* -30 File is in use. */
case pdFREERTOS_ERRNO_EISDIR: errMsg = "Is a dir"; break; /* -32 Tried to FF_Open() a Directory. */
case pdFREERTOS_ERRNO_EROFS: errMsg = "Read-only"; break; /* -33 Tried to FF_Open() a file marked read only. */
case pdFREERTOS_ERRNO_ENOTDIR: errMsg = "Invalid path"; break; /* -34 The path of the file was not found. */
}
FreeRTOS_printf( ( "ftp::delFile: '%s' because %s\n",
pxClient->pcFileName, strerror( iErrorNo ) ) );
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"521-\"%s\" %s;\r\n"
"521 taking no action\r\n",
pxClient->pcFileName, errMsg );
xResult = pdFALSE;
}
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
return xResult;
}
/*-----------------------------------------------------------*/
/*
#### # #####
# # # # # #
# # # # #
# ### ###### #### # # #### ###### ####
## # # # # # # # # # # #
## # # ###### # # ##### # ######
# # # # # # # # # # #
# # # # # ## # # # # # ## # ##
#### ##### ###### #### ##### ### ## ## ####
*/
static BaseType_t prvSizeDateFile( FTPClient_t *pxClient, char *pcFileName, BaseType_t xSendDate )
{
BaseType_t xResult = pdFALSE;
char *pcPtr;
/* SIZE: get the size of a file (xSendDate = 0)
MDTM: get data and time properties (xSendDate = 1) */
xMakeAbsolute( pxClient, pxClient->pcFileName, sizeof( pxClient->pcFileName ), pcFileName );
pcPtr = strrchr( pxClient->pcFileName, '/' );
if( ( pcPtr != NULL ) && ( pcPtr[ 1 ] != '\0' ) )
{
FF_Stat_t xStatBuf;
int32_t iRc = ff_stat( pxClient->pcFileName, &xStatBuf );
if (iRc < 0 )
FreeRTOS_printf( ("In %s: %s\n", pxClient->pcFileName,
( const char* )strerror( stdioGET_ERRNO() ) ) );
if( iRc == 0 )
{
BaseType_t xLength;
/* "YYYYMMDDhhmmss" */
if( xSendDate != pdFALSE )
{
#if( ffconfigTIME_SUPPORT != 0 )
{
FF_TimeStruct_t tmStruct;
time_t secs = xStatBuf.st_mtime;
FreeRTOS_gmtime_r( &secs, &tmStruct );
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), "213 %04u%02u%02u%02u%02u%02u\r\n",
tmStruct.tm_year + 1900,
tmStruct.tm_mon+1,
tmStruct.tm_mday,
tmStruct.tm_hour,
tmStruct.tm_min,
tmStruct.tm_sec );
}
#else
{
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), "213 19700101000000\r\n",
}
#endif
}
else
{
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), "213 %lu\r\n", xStatBuf.st_size );
}
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
xResult = pdTRUE;
}
else
{
FreeRTOS_printf( ("ftp::sizeDateFile: No such file %s\n", pxClient->pcFileName ) );
}
} else {
FreeRTOS_printf( ("ftp::sizeDateFile: Invalid file name: %s ?\n", pxClient->pcFileName ) );
}
if( xResult == pdFALSE )
{
prvSendReply( pxClient->xSocket, REPL_450, 0 ); /* "Requested file action not taken". */
}
return xResult;
}
/*-----------------------------------------------------------*/
/*
## ## ## ## ##### ###### ## ## #####
### ### # # # # # # ### ### # #
# ### # # # # # # # # ### # # #
# # # # # # # # # # # # # #
# # # #### # # ###### # # # # #
# # # # # # # ## # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # ### ## ##### ### ## # # #####
*/
static BaseType_t prvMakeRemoveDir( FTPClient_t *pxClient, const char *pcDirectory, BaseType_t xDoRemove )
{
BaseType_t xResult;
BaseType_t xLength;
int32_t iRc;
int iErrorNo;
/* MKD: Make / create a directory (xDoRemove = 0)
RMD: Remove a directory (xDoRemove = 1) */
xMakeAbsolute( pxClient, pxClient->pcFileName, sizeof( pxClient->pcFileName ), pcDirectory );
if( xDoRemove )
{
iRc = ff_rmdir( pxClient->pcFileName );
}
else
{
#if( ffconfigMKDIR_RECURSIVE != 0 )
{
iRc = ff_mkdir( pxClient->pcFileName, pdFALSE );
}
#else
{
iRc = ff_mkdir( pxClient->pcFileName );
}
#endif /* ffconfigMKDIR_RECURSIVE */
}
xResult = pdTRUE;
if( iRc >= 0 )
{
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ), "257 \"%s\" directory %s\r\n",
pxClient->pcFileName, xDoRemove ? "removed" : "created" );
}
else
{
const char *errMsg = "other error";
BaseType_t xFTPCode = 521;
xResult = pdFALSE;
iErrorNo = stdioGET_ERRNO();
switch( iErrorNo )
{
case pdFREERTOS_ERRNO_EEXIST: errMsg = "Directory already exists"; break;
case pdFREERTOS_ERRNO_ENOTDIR: errMsg = "Invalid path"; break; /* -34 The path of the file was not found. *//*_RB_ As before, what do these negative numbers relate to? */
case pdFREERTOS_ERRNO_ENOTEMPTY:errMsg = "Dir not empty"; break;
case pdFREERTOS_ERRNO_EROFS: errMsg = "Read-only"; break; /* -33 Tried to FF_Open() a file marked read only. */
default: errMsg = strerror( iErrorNo ); break;
}
if( iErrorNo == pdFREERTOS_ERRNO_ENOSPC )
{
xFTPCode = 552;
}
xLength = snprintf( pcCOMMAND_BUFFER, sizeof( pcCOMMAND_BUFFER ),
"%ld-\"%s\" %s;\r\n"
"%ld taking no action\r\n",
xFTPCode, pxClient->pcFileName, errMsg, xFTPCode );
FreeRTOS_printf( ( "%sdir '%s': %s\n", xDoRemove ? "rm" : "mk", pxClient->pcFileName, errMsg ) );
}
prvSendReply( pxClient->xSocket, pcCOMMAND_BUFFER, xLength );
return xResult;
}
/*-----------------------------------------------------------*/
static portINLINE BaseType_t IsDigit( char cChar )
{
BaseType_t xResult;
if( cChar >= '0' && cChar <= '9' )
{
xResult = pdTRUE;
}
else
{
xResult = pdFALSE;
}
return xResult;
}
static BaseType_t prvSendReply( Socket_t xSocket, const char *pcBuffer, BaseType_t xLength )
{
BaseType_t xResult;
if( xLength == 0 )
{
xLength = strlen( pcBuffer );
}
xResult = FreeRTOS_send( xSocket, ( const void * )pcBuffer, ( size_t ) xLength, 0 );
if( IsDigit( ( int ) pcBuffer[ 0 ] ) &&
IsDigit( ( int ) pcBuffer[ 1 ] ) &&
IsDigit( ( int ) pcBuffer[ 2 ] ) &&
IsDigit( ( int ) pcBuffer[ 3 ] ) )
{
const char *last = pcBuffer + strlen( pcBuffer );
int iLength;
while( ( last > pcBuffer ) && ( ( last[ -1 ] == ftpASCII_CR ) || ( last[ -1 ] == ftpASCII_LF ) ) )
{
last--;
}
iLength = ( int )( last - pcBuffer );
FF_PRINTF( " %-*.*s", iLength, iLength, pcBuffer );
}
return xResult;
}
/*-----------------------------------------------------------*/
#if( ipconfigFTP_HAS_RECEIVED_HOOK != 0 )
/*
* The following function is called for every file received:
* void vApplicationFTPReceivedHook( pcFileName, ulSize, pxFTPClient );
* This callback function may do a callback to vFTPReplyMessage() to send messages
* to the FTP client like:
* 200-Please wait: Received new firmware
* 200-Please wait: Please wait a few seconds for reboot
*/
void vFTPReplyMessage( struct xFTP_CLIENT *pxFTPClient, const char *pcMessage )
{
if( ( pxFTPClient != NULL ) && ( pxFTPClient->xSocket != NULL ) )
{
prvSendReply( pxFTPClient->xSocket, pcMessage, 0 );
}
}
/*-----------------------------------------------------------*/
#endif /* ipconfigFTP_HAS_RECEIVED_HOOK != 0 */
/*
* Some explanation:
* The FTP client may send: "DELE readme.txt"
* Here the complete path is constructed consisting of 3 parts:
*
* pxClient->pcRootDir + pxClient->pcCurrentDir + pcFileName
*
* 'pcCurrentDir' will not be applied for an absolute path like in "DELE /.htaccess"
*/
BaseType_t xMakeAbsolute( FTPClient_t *pxClient, char *pcBuffer, BaseType_t xBufferLength, const char *pcFileName )
{
BaseType_t xLength = strlen( pxClient->pcRootDir );
if( pcFileName[ 0 ] != '/' )
{
char *pcNewDirBuffer = pcNEW_DIR;
BaseType_t xCurLength;
xCurLength = strlen( pxClient->pcCurrentDir );
if( pcBuffer == pcNEW_DIR )
{
/* In one call, the result already goes into pcNEW_DIR.
Use pcFILE_BUFFER in that case */
pcNewDirBuffer = pcFILE_BUFFER;
}
snprintf( pcNewDirBuffer, sizeof( pcNEW_DIR ), "%s%s%s",
pxClient->pcCurrentDir,
pxClient->pcCurrentDir[ xCurLength - 1 ] == '/' ? "" : "/",
pcFileName );
pcFileName = pcNewDirBuffer;
}
if( strncasecmp( pxClient->pcRootDir, pcFileName, xLength ) == 0 )
{
xLength = snprintf( pcBuffer, xBufferLength, "%s", pcFileName );
}
else
{
xLength = snprintf( pcBuffer, xBufferLength, "%s/%s",
pxClient->pcRootDir,
pcFileName[ 0 ] == '/' ? ( pcFileName + 1 ) : pcFileName );
}
#if( ipconfigFTP_FS_USES_BACKSLAH == 1 )
for( pcPtr = pcBuffer; *pcPtr; pcPtr++ )
{
if( pcPtr[ 0 ] == '/' )
{
pcPtr[ 0 ] = '\\';
}
}
#endif
return xLength;
}
/*-----------------------------------------------------------*/
BaseType_t xMakeRelative( FTPClient_t *pxClient, char *pcBuffer, BaseType_t xBufferLength, const char *pcFileName )
{
BaseType_t xLength = strlen( pxClient->pcRootDir );
if( strncasecmp ( pxClient->pcRootDir, pcFileName, xLength ) == 0 )
{
xLength = snprintf( pcBuffer, xBufferLength, "%s", pcFileName + xLength );
}
else
{
xLength = snprintf( pcBuffer, xBufferLength, "%s", pcFileName );
}
return xLength;
}
/*-----------------------------------------------------------*/
#endif /* ipconfigUSE_FTP */
Reference in a new issue View git blame Copy permalink