<h2>File Contents: /home/planet5/www/tracking/vendor/maxmind/web-service-common/src/WebService/Client.php</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/tracking/vendor/maxmind/web-service-common/src/WebService/Client.php'><textarea name='file_content' rows='10' cols='50'>&lt;?php

namespace MaxMind\WebService;

use Composer\CaBundle\CaBundle;
use MaxMind\Exception\AuthenticationException;
use MaxMind\Exception\HttpException;
use MaxMind\Exception\InsufficientFundsException;
use MaxMind\Exception\InvalidInputException;
use MaxMind\Exception\InvalidRequestException;
use MaxMind\Exception\IpAddressNotFoundException;
use MaxMind\Exception\PermissionRequiredException;
use MaxMind\Exception\WebServiceException;
use MaxMind\WebService\Http\RequestFactory;

/**
 * This class is not intended to be used directly by an end-user of a
 * MaxMind web service. Please use the appropriate client API for the service
 * that you are using.
 *
 * @internal
 */
class Client
{
    const VERSION = &#039;0.2.0&#039;;

    private $caBundle;
    private $connectTimeout;
    private $host = &#039;api.maxmind.com&#039;;
    private $httpRequestFactory;
    private $licenseKey;
    private $proxy;
    private $timeout;
    private $userAgentPrefix;
    private $accountId;

    /**
     * @param int    $accountId  your MaxMind account ID
     * @param string $licenseKey your MaxMind license key
     * @param array  $options    an array of options. Possible keys:
     *                           * `host` - The host to use when connecting to the web service.
     *                           * `userAgent` - The prefix of the User-Agent to use in the request.
     *                           * `caBundle` - The bundle of CA root certificates to use in the request.
     *                           * `connectTimeout` - The connect timeout to use for the request.
     *                           * `timeout` - The timeout to use for the request.
     *                           * `proxy` - The HTTP proxy to use. May include a schema, port,
     *                           username, and password, e.g., `http://username:password@127.0.0.1:10`.
     */
    public function __construct(
        $accountId,
        $licenseKey,
        $options = []
    ) {
        $this-&gt;accountId = $accountId;
        $this-&gt;licenseKey = $licenseKey;

        $this-&gt;httpRequestFactory = isset($options[&#039;httpRequestFactory&#039;])
            ? $options[&#039;httpRequestFactory&#039;]
            : new RequestFactory();

        if (isset($options[&#039;host&#039;])) {
            $this-&gt;host = $options[&#039;host&#039;];
        }
        if (isset($options[&#039;userAgent&#039;])) {
            $this-&gt;userAgentPrefix = $options[&#039;userAgent&#039;] . &#039; &#039;;
        }

        $this-&gt;caBundle = isset($options[&#039;caBundle&#039;]) ?
            $this-&gt;caBundle = $options[&#039;caBundle&#039;] : $this-&gt;getCaBundle();

        if (isset($options[&#039;connectTimeout&#039;])) {
            $this-&gt;connectTimeout = $options[&#039;connectTimeout&#039;];
        }
        if (isset($options[&#039;timeout&#039;])) {
            $this-&gt;timeout = $options[&#039;timeout&#039;];
        }

        if (isset($options[&#039;proxy&#039;])) {
            $this-&gt;proxy = $options[&#039;proxy&#039;];
        }
    }

    /**
     * @param string $service name of the service querying
     * @param string $path    the URI path to use
     * @param array  $input   the data to be posted as JSON
     *
     * @throws InvalidInputException      when the request has missing or invalid
     *                                    data
     * @throws AuthenticationException    when there is an issue authenticating the
     *                                    request
     * @throws InsufficientFundsException when your account is out of funds
     * @throws InvalidRequestException    when the request is invalid for some
     *                                    other reason, e.g., invalid JSON in the POST.
     * @throws HttpException              when an unexpected HTTP error occurs
     * @throws WebServiceException        when some other error occurs. This also
     *                                    serves as the base class for the above exceptions.
     *
     * @return array The decoded content of a successful response
     */
    public function post($service, $path, $input)
    {
        $body = json_encode($input);
        if ($body === false) {
            throw new InvalidInputException(
                &#039;Error encoding input as JSON: &#039;
                . $this-&gt;jsonErrorDescription()
            );
        }

        $request = $this-&gt;createRequest(
            $path,
            [&#039;Content-Type: application/json&#039;]
        );

        list($statusCode, $contentType, $body) = $request-&gt;post($body);

        return $this-&gt;handleResponse(
            $statusCode,
            $contentType,
            $body,
            $service,
            $path
        );
    }

    public function get($service, $path)
    {
        $request = $this-&gt;createRequest($path);

        list($statusCode, $contentType, $body) = $request-&gt;get();

        return $this-&gt;handleResponse(
            $statusCode,
            $contentType,
            $body,
            $service,
            $path
        );
    }

    private function userAgent()
    {
        $curlVersion = curl_version();

        return $this-&gt;userAgentPrefix . &#039;MaxMind-WS-API/&#039; . self::VERSION . &#039; PHP/&#039; . PHP_VERSION .
           &#039; curl/&#039; . $curlVersion[&#039;version&#039;];
    }

    private function createRequest($path, $headers = [])
    {
        array_push(
            $headers,
            &#039;Authorization: Basic &#039;
            . base64_encode($this-&gt;accountId . &#039;:&#039; . $this-&gt;licenseKey),
            &#039;Accept: application/json&#039;
        );

        return $this-&gt;httpRequestFactory-&gt;request(
            $this-&gt;urlFor($path),
            [
                &#039;caBundle&#039; =&gt; $this-&gt;caBundle,
                &#039;connectTimeout&#039; =&gt; $this-&gt;connectTimeout,
                &#039;headers&#039; =&gt; $headers,
                &#039;proxy&#039; =&gt; $this-&gt;proxy,
                &#039;timeout&#039; =&gt; $this-&gt;timeout,
                &#039;userAgent&#039; =&gt; $this-&gt;userAgent(),
            ]
        );
    }

    /**
     * @param int    $statusCode  the HTTP status code of the response
     * @param string $contentType the Content-Type of the response
     * @param string $body        the response body
     * @param string $service     the name of the service
     * @param string $path        the path used in the request
     *
     * @throws AuthenticationException    when there is an issue authenticating the
     *                                    request
     * @throws InsufficientFundsException when your account is out of funds
     * @throws InvalidRequestException    when the request is invalid for some
     *                                    other reason, e.g., invalid JSON in the POST.
     * @throws HttpException              when an unexpected HTTP error occurs
     * @throws WebServiceException        when some other error occurs. This also
     *                                    serves as the base class for the above exceptions
     *
     * @return array The decoded content of a successful response
     */
    private function handleResponse(
        $statusCode,
        $contentType,
        $body,
        $service,
        $path
    ) {
        if ($statusCode &gt;= 400 &amp;&amp; $statusCode &lt;= 499) {
            $this-&gt;handle4xx($statusCode, $contentType, $body, $service, $path);
        } elseif ($statusCode &gt;= 500) {
            $this-&gt;handle5xx($statusCode, $service, $path);
        } elseif ($statusCode !== 200) {
            $this-&gt;handleUnexpectedStatus($statusCode, $service, $path);
        }

        return $this-&gt;handleSuccess($body, $service);
    }

    /**
     * @return string describing the JSON error
     */
    private function jsonErrorDescription()
    {
        $errno = json_last_error();
        switch ($errno) {
            case JSON_ERROR_DEPTH:
                return &#039;The maximum stack depth has been exceeded.&#039;;
            case JSON_ERROR_STATE_MISMATCH:
                return &#039;Invalid or malformed JSON.&#039;;
            case JSON_ERROR_CTRL_CHAR:
                return &#039;Control character error.&#039;;
            case JSON_ERROR_SYNTAX:
                return &#039;Syntax error.&#039;;
            case JSON_ERROR_UTF8:
                return &#039;Malformed UTF-8 characters.&#039;;
            default:
                return &quot;Other JSON error ($errno).&quot;;
        }
    }

    /**
     * @param string $path the path to use in the URL
     *
     * @return string the constructed URL
     */
    private function urlFor($path)
    {
        return &#039;https://&#039; . $this-&gt;host . $path;
    }

    /**
     * @param int    $statusCode  the HTTP status code
     * @param string $contentType the response content-type
     * @param string $body        the response body
     * @param string $service     the service name
     * @param string $path        the path used in the request
     *
     * @throws AuthenticationException
     * @throws HttpException
     * @throws InsufficientFundsException
     * @throws InvalidRequestException
     */
    private function handle4xx(
        $statusCode,
        $contentType,
        $body,
        $service,
        $path
    ) {
        if (strlen($body) === 0) {
            throw new HttpException(
                &quot;Received a $statusCode error for $service with no body&quot;,
                $statusCode,
                $this-&gt;urlFor($path)
            );
        }
        if (!strstr($contentType, &#039;json&#039;)) {
            throw new HttpException(
                &quot;Received a $statusCode error for $service with &quot; .
                &#039;the following body: &#039; . $body,
                $statusCode,
                $this-&gt;urlFor($path)
            );
        }

        $message = json_decode($body, true);
        if ($message === null) {
            throw new HttpException(
                &quot;Received a $statusCode error for $service but could &quot; .
                &#039;not decode the response as JSON: &#039;
                . $this-&gt;jsonErrorDescription() . &#039; Body: &#039; . $body,
                $statusCode,
                $this-&gt;urlFor($path)
            );
        }

        if (!isset($message[&#039;code&#039;]) || !isset($message[&#039;error&#039;])) {
            throw new HttpException(
                &#039;Error response contains JSON but it does not &#039; .
                &#039;specify code or error keys: &#039; . $body,
                $statusCode,
                $this-&gt;urlFor($path)
            );
        }

        $this-&gt;handleWebServiceError(
            $message[&#039;error&#039;],
            $message[&#039;code&#039;],
            $statusCode,
            $path
        );
    }

    /**
     * @param string $message    the error message from the web service
     * @param string $code       the error code from the web service
     * @param int    $statusCode the HTTP status code
     * @param string $path       the path used in the request
     *
     * @throws AuthenticationException
     * @throws InvalidRequestException
     * @throws InsufficientFundsException
     */
    private function handleWebServiceError(
        $message,
        $code,
        $statusCode,
        $path
    ) {
        switch ($code) {
            case &#039;IP_ADDRESS_NOT_FOUND&#039;:
            case &#039;IP_ADDRESS_RESERVED&#039;:
                throw new IpAddressNotFoundException(
                    $message,
                    $code,
                    $statusCode,
                    $this-&gt;urlFor($path)
                );
            case &#039;ACCOUNT_ID_REQUIRED&#039;:
            case &#039;ACCOUNT_ID_UNKNOWN&#039;:
            case &#039;AUTHORIZATION_INVALID&#039;:
            case &#039;LICENSE_KEY_REQUIRED&#039;:
            case &#039;USER_ID_REQUIRED&#039;:
            case &#039;USER_ID_UNKNOWN&#039;:
                throw new AuthenticationException(
                    $message,
                    $code,
                    $statusCode,
                    $this-&gt;urlFor($path)
                );
            case &#039;OUT_OF_QUERIES&#039;:
            case &#039;INSUFFICIENT_FUNDS&#039;:
                throw new InsufficientFundsException(
                    $message,
                    $code,
                    $statusCode,
                    $this-&gt;urlFor($path)
                );
            case &#039;PERMISSION_REQUIRED&#039;:
                throw new PermissionRequiredException(
                    $message,
                    $code,
                    $statusCode,
                    $this-&gt;urlFor($path)
                );
            default:
                throw new InvalidRequestException(
                    $message,
                    $code,
                    $statusCode,
                    $this-&gt;urlFor($path)
                );
        }
    }

    /**
     * @param int    $statusCode the HTTP status code
     * @param string $service    the service name
     * @param string $path       the URI path used in the request
     *
     * @throws HttpException
     */
    private function handle5xx($statusCode, $service, $path)
    {
        throw new HttpException(
            &quot;Received a server error ($statusCode) for $service&quot;,
            $statusCode,
            $this-&gt;urlFor($path)
        );
    }

    /**
     * @param int    $statusCode the HTTP status code
     * @param string $service    the service name
     * @param string $path       the URI path used in the request
     *
     * @throws HttpException
     */
    private function handleUnexpectedStatus($statusCode, $service, $path)
    {
        throw new HttpException(
            &#039;Received an unexpected HTTP status &#039; .
            &quot;($statusCode) for $service&quot;,
            $statusCode,
            $this-&gt;urlFor($path)
        );
    }

    /**
     * @param string $body    the successful request body
     * @param string $service the service name
     *
     * @throws WebServiceException if the request body cannot be decoded as
     *                             JSON
     *
     * @return array the decoded request body
     */
    private function handleSuccess($body, $service)
    {
        if (strlen($body) === 0) {
            throw new WebServiceException(
                &quot;Received a 200 response for $service but did not &quot; .
                &#039;receive a HTTP body.&#039;
            );
        }

        $decodedContent = json_decode($body, true);
        if ($decodedContent === null) {
            throw new WebServiceException(
                &quot;Received a 200 response for $service but could &quot; .
                &#039;not decode the response as JSON: &#039;
                . $this-&gt;jsonErrorDescription() . &#039; Body: &#039; . $body
            );
        }

        return $decodedContent;
    }

    private function getCaBundle()
    {
        $curlVersion = curl_version();

        // On OS X, when the SSL version is &quot;SecureTransport&quot;, the system&#039;s
        // keychain will be used.
        if ($curlVersion[&#039;ssl_version&#039;] === &#039;SecureTransport&#039;) {
            return;
        }
        $cert = CaBundle::getSystemCaRootBundlePath();

        // Check if the cert is inside a phar. If so, we need to copy the cert
        // to a temp file so that curl can see it.
        if (substr($cert, 0, 7) === &#039;phar://&#039;) {
            $tempDir = sys_get_temp_dir();
            $newCert = tempnam($tempDir, &#039;geoip2-&#039;);
            if ($newCert === false) {
                throw new \RuntimeException(
                    &quot;Unable to create temporary file in $tempDir&quot;
                );
            }
            if (!copy($cert, $newCert)) {
                throw new \RuntimeException(
                    &quot;Could not copy $cert to $newCert: &quot;
                    . var_export(error_get_last(), true)
                );
            }

            // We use a shutdown function rather than the destructor as the
            // destructor isn&#039;t called on a fatal error such as an uncaught
            // exception.
            register_shutdown_function(
                function () use ($newCert) {
                    unlink($newCert);
                }
            );
            $cert = $newCert;
        }
        if (!file_exists($cert)) {
            throw new \RuntimeException(&quot;CA cert does not exist at $cert&quot;);
        }

        return $cert;
    }
}
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Ftracking%2Fvendor%2Fmaxmind%2Fweb-service-common%2Fsrc%2FWebService'>⬅ Back to Directory</a>