Lazzard\FtpBridge\FtpBridge

Complexity

Total Complexity

22

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Importance

Changes	6
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	login()	0	22	4
A	openPassive()	0	4	1
A	connect()	0	4	1
A	send()	0	7	3
A	setTransferType()	0	6	2
A	openActive()	0	4	1
A	receive()	0	7	3
A	__construct()	0	3	1
A	write()	0	8	3
A	receiveData()	0	7	3

<?php

/**
 * This file is part of the Lazzard/ftp-bridge package.
 *
 * (c) El Amrani Chakir <elamrani.sv.laza@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 */

namespace Lazzard\FtpBridge;

use Lazzard\FtpBridge\Logger\LoggerInterface;
use Lazzard\FtpBridge\Response\Response;
use Lazzard\FtpBridge\Stream\ActiveDataStream;
use Lazzard\FtpBridge\Stream\CommandStream;
use Lazzard\FtpBridge\Stream\DataStream;
use Lazzard\FtpBridge\Stream\PassiveDataStream;
use Lazzard\FtpBridge\Error\ErrorTrigger;

/**
 * @since  1.0
 * @author El Amrani Chakir <elamrani.sv.laza@gmail.com>
 */
class FtpBridge
{
    /**
     * Transfer type representations.
     */
    const TR_TYPE_ASCII      = 'A';
    const TR_TYPE_BINARY     = 'I';
    const TR_TYPE_EBCDIC     = 'E';
    const TR_TYPE_LOCAL      = 'L';
    const TR_TYPE_NON_PRINT  = 'N';
    const TR_TYPE_TELNET     = 'T';
    const TR_TYPE_CR_CONTROL = 'C';

    /** @var LoggerInterface */
    public $logger;

    /** @var Response */
    public $response;

    /** @var CommandStream */
    protected $commandStream;

    /** @var DataStream */
    protected $dataStream;

    /**
     * FtpBridge constructor
     *
     * @param LoggerInterface|null $logger
     */
    public function __construct(LoggerInterface $logger = null)
    {
        $this->logger = $logger;
    }

    /**
     * Sends a command to the server thought the control channel.
     *
     * @param string $command
     *
     * @return bool
     */
    public function send($command)
    {
        if (!$this->commandStream || !is_resource($this->commandStream->stream)) {
            return !ErrorTrigger::raise("The FTP connection must be established first before try sending any commands.");
        }

        return $this->commandStream->write($command);
    }

    /**
     * Writes the string content to the data stream.
     *
     * @param string $string
     * 
     * @return bool
     */
    public function write($string)
    {
        if (!$this->dataStream || !is_resource($this->dataStream->stream)) {
            return !ErrorTrigger::raise("The FTP data connection must be established first 
                before try writing to the data stream.");
        }

        return $this->dataStream->write($string);
    }

    /**
     * Receives and gets the response from the command stream.
     * 
     * @return Response
     */
    public function receive()
    {
        if (!$this->commandStream || !is_resource($this->commandStream->stream)) {
            return !ErrorTrigger::raise("The FTP command connection not created yet.");

The expression return ! Lazzard\FtpBridge\Error\ErrorTrigger::raise('The FTP command connection not created yet.') returns the type boolean which is incompatible with the documented return type Lazzard\FtpBridge\Response\Response.

        }

        return $this->response = new Response($this->commandStream->read());
    }

    /**
     * Receives and reads the data from the data stream.
     *
     * @return string
     */
    public function receiveData()
    {
        if (!$this->dataStream || !is_resource($this->dataStream->stream)) {
            return !ErrorTrigger::raise("The FTP data connection not created yet.");

The expression return ! Lazzard\FtpBridge\Error\ErrorTrigger::raise('The FTP data connection not created yet.') returns the type boolean which is incompatible with the documented return type string.

        }

        return $this->dataStream->read();
    }

    /**
     * Opens an FTP connection.
     *
     * @param string $host     The remote host name or the IP address.
     * @param int    $port     [optional] The remote server port to connect to, if omitted the port 21 will be used.
     * @param int    $timeout  [optional] Specifies the connection timeout of all FTP transfer operations, default sets
     *                         to 90.
     * @param        $blocking $blocking [optional] The transfer mode, the blocking mode is the default.

The doc comment $blocking at position 0 could not be parsed: Unknown type name '$blocking' at position 0 in $blocking.

     *
     * @return bool Returns true on success, false on failure and an E_WARNING error raised.
     */
    public function connect($host, $port = 21, $timeout = 90, $blocking = true)
    {
        $this->commandStream = new CommandStream($this->logger, $host, $port, $timeout, $blocking);
        return $this->commandStream->open();
    }

    /**
     * Opens a passive data connection.    
     * 
     * @return bool
     */
    public function openPassive()
    {
        $this->dataStream = new PassiveDataStream($this->logger, $this->commandStream);
        return $this->dataStream->open();
    }

    /**
     * Opens an active data connection to the FTP server.
     *
     * @param string $activeIpAddress [optional] The IP address to send along with the PORT command, if omitted 
     *                                           the server IP address in the $_SERVER['SERVER_ADDR'] will be used.
     * 
     * @return bool
     */
    public function openActive($activeIpAddress = null)
    {
        $this->dataStream = new ActiveDataStream($this->logger, $this->commandStream, $activeIpAddress);
        return $this->dataStream->open();
    }

    /**
     * Logs into the FTP server.
     *
     * Note: this method must be called after a successful connection.
     *
     * @param string $username
     * @param string $password
     *
     * @return bool Returns true on success, false on failure and an E_WARNING error 
     *              will be raised.
     */
    public function login($username, $password)
    {
        $this->send("USER $username");
        $this->receive();

        if ($this->response->getCode() === 230) {
            return true;
        }

        if ($this->response->getCode() === 331) {
            $this->send("PASS $password");
            $this->receive();

            // TODO 202 code
            if ($this->response->hasCode(202, 230)) {
                return true;
            }

            return !ErrorTrigger::raise($this->response->getMessage());
        }

        return !ErrorTrigger::raise($this->response->getMessage());
    }

    /**
     * Sets the transfer type for the next transfer operation.
     *
     * @param string     $type        The transfer type can be either {@link FtpBridge::TR_TYPE_BINARY} or {@link FtpBridge::TR_TYPE_ASCII} 
     *                                or {@link FtpBridge::TR_TYPE_EBCDIC}.
     * @param string|int $secondParam Specifies how the text should be interpreted for the file types {@link FtpBridge::TR_TYPE_ASCII} 
     *                                and {@link FtpBridge::TR_TYPE_EBCDIC}, it can be either {@link FtpBridge::TR_TYPE_NON_PRINT},
     *                                {@link FtpBridge::TR_TYPE_TELNET} or {@link TR_TYPE_CONTROL}.
     *                                For the {@link FtpBridge::TR_TYPE_LOCAL} an integer must be specified to specify the 
     *                                number of bits per byte on the local system.
     *                     
     * @return bool
     */
    public function setTransferType($type, $secondParam = null)
    {
        $this->send(sprintf("TYPE %s%s", $type, $secondParam ? " $secondParam" : ''));
        $this->receive();

        return $this->response->getCode() === 200;
    }
}