FM / S3

/home/techb158/ileadtechnology.com/vendor/aws/aws-sdk-php/src/S3/

/home/techb158/ileadtechnology.com/vendor/aws/aws-sdk-php/src/S3

Name	Size	Mode	Actions
Crypto/	-	0755	rm
Exception/	-	0755	rm
RegionalEndpoint/	-	0755	rm
UseArnRegion/	-	0755	rm
AmbiguousSuccessParser.php	2280	0644	edit dl rm
ApplyChecksumMiddleware.php	4191	0644	edit dl rm
BatchDelete.php	7672	0644	edit dl rm
BucketEndpointArnMiddleware.php	14018	0644	edit dl rm
BucketEndpointMiddleware.php	3399	0644	edit dl rm
CalculatesChecksumTrait.php	1839	0644	edit dl rm
EndpointRegionHelperTrait.php	3230	0644	edit dl rm
GetBucketLocationParser.php	1320	0644	edit dl rm
MultipartCopy.php	9040	0644	edit dl rm
MultipartUploader.php	6280	0644	edit dl rm
MultipartUploadingTrait.php	4206	0644	edit dl rm
ObjectCopier.php	5959	0644	edit dl rm
ObjectUploader.php	5500	0644	edit dl rm
PermanentRedirectMiddleware.php	1742	0644	edit dl rm
PostObject.php	3927	0644	edit dl rm
PostObjectV4.php	5430	0644	edit dl rm
PutObjectUrlMiddleware.php	1569	0644	edit dl rm
RetryableMalformedResponseParser.php	1453	0644	edit dl rm
S3Client.php	49161	0644	edit dl rm
S3ClientInterface.php	14447	0644	edit dl rm
S3ClientTrait.php	10411	0644	edit dl rm
S3EndpointMiddleware.php	11320	0644	edit dl rm
S3MultiRegionClient.php	19797	0644	edit dl rm
S3UriParser.php	5027	0644	edit dl rm
SSECMiddleware.php	2289	0644	edit dl rm
StreamWrapper.php	31433	0644	edit dl rm
Transfer.php	15513	0644	edit dl rm
ValidateResponseChecksumParser.php	5209	0644	edit dl rm

Edit: /home/techb158/ileadtechnology.com/vendor/aws/aws-sdk-php/src/S3/S3EndpointMiddleware.php (11320B)

<?php
namespace Aws\S3;

use Aws\Arn\ArnParser;
use Aws\Arn\ObjectLambdaAccessPointArn;
use Aws\ClientResolver;
use Aws\CommandInterface;
use Aws\Endpoint\EndpointProvider;
use Aws\Endpoint\PartitionEndpointProvider;
use GuzzleHttp\Exception\InvalidArgumentException;
use GuzzleHttp\Psr7\Uri;
use Psr\Http\Message\RequestInterface;

/**
 * Used to update the URL used for S3 requests to support:
 * S3 Accelerate, S3 DualStack or Both. It will build to
 * host style paths unless specified, including for S3
 * DualStack.
 *
 * IMPORTANT: this middleware must be added after the "build" step.
 *
 * @internal
 */
class S3EndpointMiddleware
{
    private static $exclusions = [
        'CreateBucket' => true,
        'DeleteBucket' => true,
        'ListBuckets' => true,
    ];

const NO_PATTERN = 0;
    const DUALSTACK = 1;
    const ACCELERATE = 2;
    const ACCELERATE_DUALSTACK = 3;
    const PATH_STYLE = 4;
    const HOST_STYLE = 5;

/** @var bool */
    private $accelerateByDefault;
    /** @var bool */
    private $dualStackByDefault;
    /** @var bool */
    private $pathStyleByDefault;
    /** @var string */
    private $region;
    /** @var callable */
    private $endpointProvider;
    /** @var callable */
    private $nextHandler;
    /** @var string */
    private $endpoint;

/**
     * Create a middleware wrapper function
     *
     * @param string $region
     * @param EndpointProvider $endpointProvider
     * @param array  $options
     *
     * @return callable
     */
    public static function wrap($region, $endpointProvider, array $options)
    {
        return function (callable $handler) use ($region, $endpointProvider, $options) {
            return new self($handler, $region, $options, $endpointProvider);
        };
    }

public function __construct(
        callable $nextHandler,
        $region,
        array $options,
        $endpointProvider = null
    ) {
        $this->pathStyleByDefault = isset($options['path_style'])
            ? (bool) $options['path_style'] : false;
        $this->dualStackByDefault = isset($options['dual_stack'])
            ? (bool) $options['dual_stack'] : false;
        $this->accelerateByDefault = isset($options['accelerate'])
            ? (bool) $options['accelerate'] : false;
        $this->region = (string) $region;
        $this->endpoint = isset($options['endpoint'])
            ? $options['endpoint'] : "";
        $this->endpointProvider = is_null($endpointProvider)
            ? PartitionEndpointProvider::defaultProvider()
            : $endpointProvider;
        $this->nextHandler = $nextHandler;
    }

public function __invoke(CommandInterface $command, RequestInterface $request)
    {
        if (!empty($this->endpoint)) {
            $request = $this->applyEndpoint($command, $request);
        } else {
            switch ($this->endpointPatternDecider($command, $request)) {
                case self::HOST_STYLE:
                    $request = $this->applyHostStyleEndpoint($command, $request);
                    break;
                case self::NO_PATTERN:
                    break;
                case self::PATH_STYLE:
                    $request = $this->applyPathStyleEndpointCustomizations($command, $request);
                    break;
                case self::DUALSTACK:
                    $request = $this->applyDualStackEndpoint($command, $request);
                    break;
                case self::ACCELERATE:
                    $request = $this->applyAccelerateEndpoint(
                        $command,
                        $request,
                        's3-accelerate'
                    );
                    break;
                case self::ACCELERATE_DUALSTACK:
                    $request = $this->applyAccelerateEndpoint(
                        $command,
                        $request,
                        's3-accelerate.dualstack'
                    );
                    break;
            }
        }
        $nextHandler = $this->nextHandler;
        return $nextHandler($command, $request);
    }

private static function isRequestHostStyleCompatible(
        CommandInterface $command,
        RequestInterface $request
    ) {
        return S3Client::isBucketDnsCompatible($command['Bucket'])
            && (
                $request->getUri()->getScheme() === 'http'
                || strpos($command['Bucket'], '.') === false
            )
            && filter_var($request->getUri()->getHost(), FILTER_VALIDATE_IP) === false;
    }

private function endpointPatternDecider(
        CommandInterface $command,
        RequestInterface $request
    ) {
        $accelerate = isset($command['@use_accelerate_endpoint'])
            ? $command['@use_accelerate_endpoint'] : $this->accelerateByDefault;
        $dualStack = isset($command['@use_dual_stack_endpoint'])
            ? $command['@use_dual_stack_endpoint'] : $this->dualStackByDefault;
        $pathStyle = isset($command['@use_path_style_endpoint'])
            ? $command['@use_path_style_endpoint'] : $this->pathStyleByDefault;

if ($accelerate && $dualStack) {
            // When try to enable both for operations excluded from s3-accelerate,
            // only dualstack endpoints will be enabled.
            return $this->canAccelerate($command)
                ? self::ACCELERATE_DUALSTACK
                : self::DUALSTACK;
        }

if ($accelerate && $this->canAccelerate($command)) {
            return self::ACCELERATE;
        }

if ($dualStack) {
            return self::DUALSTACK;
        }

if (!$pathStyle
            && self::isRequestHostStyleCompatible($command, $request)
        ) {
            return self::HOST_STYLE;
        }

return self::PATH_STYLE;
    }

private function canAccelerate(CommandInterface $command)
    {
        return empty(self::$exclusions[$command->getName()])
            && S3Client::isBucketDnsCompatible($command['Bucket']);
    }

private function getBucketStyleHost(CommandInterface $command, $host)
    {
        // For operations on the base host (e.g. ListBuckets)
        if (!isset($command['Bucket'])) {
            return $host;
        }

return "{$command['Bucket']}.{$host}";
    }

private function applyHostStyleEndpoint(
        CommandInterface $command,
        RequestInterface $request
    ) {
        $uri = $request->getUri();
        $request = $request->withUri(
            $uri->withHost($this->getBucketStyleHost(
                    $command,
                    $uri->getHost()
                ))
                ->withPath($this->getBucketlessPath(
                    $uri->getPath(),
                    $command
                ))
        );
        return $request;
    }

private function applyPathStyleEndpointCustomizations(
        CommandInterface $command,
        RequestInterface $request
    ) {
        if ($command->getName() == 'WriteGetObjectResponse') {
            $dnsSuffix = $this->endpointProvider
                ->getPartition($this->region, 's3')
                ->getDnsSuffix();
            $fips = \Aws\is_fips_pseudo_region($this->region) ? "-fips" : "";
            $region = \Aws\strip_fips_pseudo_regions($this->region);
            $host =
                "{$command['RequestRoute']}.s3-object-lambda{$fips}.{$region}.{$dnsSuffix}";

$uri = $request->getUri();
            $request = $request->withUri(
                $uri->withHost($host)
                    ->withPath($this->getBucketlessPath(
                        $uri->getPath(),
                        $command
                    ))
            );
        }
        return $request;
    }

private function applyDualStackEndpoint(
        CommandInterface $command,
        RequestInterface $request
    ) {
        $request = $request->withUri(
            $request->getUri()->withHost($this->getDualStackHost())
        );

if (empty($command['@use_path_style_endpoint'])
            && !$this->pathStyleByDefault
            && self::isRequestHostStyleCompatible($command, $request)
        ) {
            $request = $this->applyHostStyleEndpoint($command, $request);
        }
        return $request;
    }

private function getDualStackHost()
    {
        $dnsSuffix = $this->endpointProvider
            ->getPartition($this->region, 's3')
            ->getDnsSuffix();
        return "s3.dualstack.{$this->region}.{$dnsSuffix}";
    }

private function applyAccelerateEndpoint(
        CommandInterface $command,
        RequestInterface $request,
        $pattern
    ) {
        $request = $request->withUri(
            $request->getUri()
                ->withHost($this->getAccelerateHost($command, $pattern))
                ->withPath($this->getBucketlessPath(
                    $request->getUri()->getPath(),
                    $command
                ))
        );
        return $request;
    }

private function getAccelerateHost(CommandInterface $command, $pattern)
    {
        $dnsSuffix = $this->endpointProvider
            ->getPartition($this->region, 's3')
            ->getDnsSuffix();
        return "{$command['Bucket']}.{$pattern}.{$dnsSuffix}";
    }

private function getBucketlessPath($path, CommandInterface $command)
    {
        $pattern = '/^\\/' . preg_quote($command['Bucket'], '/') . '/';
        $path = preg_replace($pattern, '', $path) ?: '/';
        if (substr($path, 0 , 1) !== '/') {
            $path = '/' . $path;
        }
        return $path;
    }

private function applyEndpoint(
        CommandInterface $command,
        RequestInterface $request
    ) {
        $dualStack = isset($command['@use_dual_stack_endpoint'])
            ? $command['@use_dual_stack_endpoint'] : $this->dualStackByDefault;
        if (ArnParser::isArn($command['Bucket'])) {
            $arn = ArnParser::parse($command['Bucket']);
            $outpost = $arn->getService() == 's3-outposts';
            if ($outpost && $dualStack) {
                throw new InvalidArgumentException("Outposts + dualstack is not supported");
            }
            if ($arn instanceof ObjectLambdaAccessPointArn) {
                return $request;
            }
        }
        if ($dualStack) {
            throw new InvalidArgumentException("Custom Endpoint + Dualstack not supported");
        }
        if ($command->getName() == 'WriteGetObjectResponse') {
            $host = "{$command['RequestRoute']}.{$this->endpoint}";
            $uri = $request->getUri();
            return $request = $request->withUri(
                $uri->withHost($host)
                    ->withPath($this->getBucketlessPath(
                        $uri->getPath(),
                        $command
                    ))
            );
        }
        $host = ($this->pathStyleByDefault) ?
            $this->endpoint :
            $this->getBucketStyleHost(
                $command,
                $this->endpoint
            );
        $uri = $request->getUri();
        $scheme = $uri->getScheme();
        if(empty($scheme)){
            $request = $request->withUri(
                $uri->withHost($host)
            );
        } else {
            $request = $request->withUri($uri);
        }

return $request;
    }
}

cmd: