Ftp.hpp

Go to the documentation of this file.

//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
 
#pragma once

// Headers
#include <SFML/Network/Export.hpp>
 
#include <SFML/Network/TcpSocket.hpp>
 
#include <SFML/System/Time.hpp>
 
#include <filesystem>
#include <string>
#include <vector>
 
 
namespace sf
{
class IpAddress;

class SFML_NETWORK_API Ftp
{
public:
    enum class TransferMode
    {
        Binary, 
        Ascii,  
        Ebcdic  
    };

    class SFML_NETWORK_API Response
    {
    public:
        enum class Status
        {
            // 1xx: the requested action is being initiated,
            // expect another reply before proceeding with a new command
            RestartMarkerReply          = 110, 
            ServiceReadySoon            = 120, 
            DataConnectionAlreadyOpened = 125, 
            OpeningDataConnection       = 150, 
 
            // 2xx: the requested action has been successfully completed
            Ok               = 200, 
            PointlessCommand = 202, 
            SystemStatus     = 211, 
            DirectoryStatus  = 212, 
            FileStatus       = 213, 
            HelpMessage      = 214, 
            SystemType = 215, 
            ServiceReady          = 220, 
            ClosingConnection     = 221, 
            DataConnectionOpened  = 225, 
            ClosingDataConnection = 226, 
            EnteringPassiveMode   = 227, 
            LoggedIn              = 230, 
            FileActionOk          = 250, 
            DirectoryOk           = 257, 
 
            // 3xx: the command has been accepted, but the requested action
            // is dormant, pending receipt of further information
            NeedPassword       = 331, 
            NeedAccountToLogIn = 332, 
            NeedInformation    = 350, 
 
            // 4xx: the command was not accepted and the requested action did not take place,
            // but the error condition is temporary and the action may be requested again
            ServiceUnavailable        = 421, 
            DataConnectionUnavailable = 425, 
            TransferAborted           = 426, 
            FileActionAborted         = 450, 
            LocalError                = 451, 
            InsufficientStorageSpace = 452, 
 
            // 5xx: the command was not accepted and
            // the requested action did not take place
            CommandUnknown          = 500, 
            ParametersUnknown       = 501, 
            CommandNotImplemented   = 502, 
            BadCommandSequence      = 503, 
            ParameterNotImplemented = 504, 
            NotLoggedIn             = 530, 
            NeedAccountToStore      = 532, 
            FileUnavailable         = 550, 
            PageTypeUnknown         = 551, 
            NotEnoughMemory         = 552, 
            FilenameNotAllowed      = 553, 
 
            // 10xx: SFML custom codes
            InvalidResponse = 1000, 
            ConnectionFailed = 1001, 
            ConnectionClosed = 1002, 
            InvalidFile = 1003 
        };

        explicit Response(Status code = Status::InvalidResponse, std::string message = "");

        [[nodiscard]] bool isOk() const;

        [[nodiscard]] Status getStatus() const;

        [[nodiscard]] const std::string& getMessage() const;
 
    private:
        // Member data
        Status      m_status;  
        std::string m_message; 
    };

    class SFML_NETWORK_API DirectoryResponse : public Response
    {
    public:
        DirectoryResponse(const Response& response);

        [[nodiscard]] const std::filesystem::path& getDirectory() const;
 
    private:
        // Member data
        std::filesystem::path m_directory; 
    };
 

    class SFML_NETWORK_API ListingResponse : public Response
    {
    public:
        ListingResponse(const Response& response, const std::string& data);

        [[nodiscard]] const std::vector<std::string>& getListing() const;
 
    private:
        // Member data
        std::vector<std::string> m_listing; 
    };

    Ftp() = default;

    ~Ftp();

    Ftp(const Ftp&) = delete;

    Ftp& operator=(const Ftp&) = delete;

    [[nodiscard]] Response connect(IpAddress server, unsigned short port = 21, Time timeout = Time::Zero);

    [[nodiscard]] Response disconnect();

    [[nodiscard]] Response login();

    [[nodiscard]] Response login(const std::string& name, const std::string& password);

    [[nodiscard]] Response keepAlive();

    [[nodiscard]] DirectoryResponse getWorkingDirectory();

    [[nodiscard]] ListingResponse getDirectoryListing(const std::string& directory = "");

    [[nodiscard]] Response changeDirectory(const std::string& directory);

    [[nodiscard]] Response parentDirectory();

    [[nodiscard]] Response createDirectory(const std::string& name);

    [[nodiscard]] Response deleteDirectory(const std::string& name);

    [[nodiscard]] Response renameFile(const std::filesystem::path& file, const std::filesystem::path& newName);

    [[nodiscard]] Response deleteFile(const std::filesystem::path& name);

    [[nodiscard]] Response download(const std::filesystem::path& remoteFile,
                                    const std::filesystem::path& localPath,
                                    TransferMode                 mode = TransferMode::Binary);

    [[nodiscard]] Response upload(const std::filesystem::path& localFile,
                                  const std::filesystem::path& remotePath,
                                  TransferMode                 mode   = TransferMode::Binary,
                                  bool                         append = false);

    [[nodiscard]] Response sendCommand(const std::string& command, const std::string& parameter = "");
 
private:
    Response getResponse();

    class DataChannel;
 
    friend class DataChannel;

    // Member data
    TcpSocket   m_commandSocket; 
    std::string m_receiveBuffer; 
};
 
} // namespace sf