vendor/geoip2/geoip2/src/Database/Reader.php line 69

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace GeoIp2\Database;
  7. use GeoIp2\Exception\AddressNotFoundException;
  8. use GeoIp2\Model\AnonymousIp;
  9. use GeoIp2\Model\Asn;
  10. use GeoIp2\Model\City;
  11. use GeoIp2\Model\ConnectionType;
  12. use GeoIp2\Model\Country;
  13. use GeoIp2\Model\Domain;
  14. use GeoIp2\Model\Enterprise;
  15. use GeoIp2\Model\Isp;
  16. use GeoIp2\ProviderInterface;
  17. use MaxMind\Db\Reader as DbReader;
  18. use MaxMind\Db\Reader\InvalidDatabaseException;
  20. /**
  21.  * Instances of this class provide a reader for the GeoIP2 database format.
  22.  * IP addresses can be looked up using the database specific methods.
  23.  *
  24.  * ## Usage ##
  25.  *
  26.  * The basic API for this class is the same for every database. First, you
  27.  * create a reader object, specifying a file name. You then call the method
  28.  * corresponding to the specific database, passing it the IP address you want
  29.  * to look up.
  30.  *
  31.  * If the request succeeds, the method call will return a model class for
  32.  * the method you called. This model in turn contains multiple record classes,
  33.  * each of which represents part of the data returned by the database. If
  34.  * the database does not contain the requested information, the attributes
  35.  * on the record class will have a `null` value.
  36.  *
  37.  * If the address is not in the database, an
  38.  * {@link \GeoIp2\Exception\AddressNotFoundException} exception will be
  39.  * thrown. If an invalid IP address is passed to one of the methods, a
  40.  * SPL {@link \InvalidArgumentException} will be thrown. If the database is
  41.  * corrupt or invalid, a {@link \MaxMind\Db\Reader\InvalidDatabaseException}
  42.  * will be thrown.
  43.  */
  44. class Reader implements ProviderInterface
  45. {
  46.     private DbReader $dbReader;
  48.     private string $dbType;
  50.     /**
  51.      * @var array<string>
  52.      */
  53.     private array $locales;
  55.     /**
  56.      * Constructor.
  57.      *
  58.      * @param string $filename the path to the GeoIP2 database file
  59.      * @param array  $locales  list of locale codes to use in name property
  60.      *                         from most preferred to least preferred
  61.      *
  62.      * @throws \MaxMind\Db\Reader\InvalidDatabaseException if the database
  63.      *                                                     is corrupt or invalid
  64.      */
  65.     public function __construct(
  66.         string $filename,
  67.         array $locales = ['en']
  68.     ) {
  69.         $this->dbReader = new DbReader($filename);
  70.         $this->dbType = $this->dbReader->metadata()->databaseType;
  71.         $this->locales = $locales;
  72.     }
  74.     /**
  75.      * This method returns a GeoIP2 City model.
  76.      *
  77.      * @param string $ipAddress an IPv4 or IPv6 address as a string
  78.      *
  79.      * @throws \GeoIp2\Exception\AddressNotFoundException  if the address is
  80.      *                                                     not in the database
  81.      * @throws \MaxMind\Db\Reader\InvalidDatabaseException if the database
  82.      *                                                     is corrupt or invalid
  83.      */
  84.     public function city(string $ipAddress): City
  85.     {
  86.         return $this->modelFor(City::class, 'City', $ipAddress);
  87.     }
  89.     /**
  90.      * This method returns a GeoIP2 Country model.
  91.      *
  92.      * @param string $ipAddress an IPv4 or IPv6 address as a string
  93.      *
  94.      * @throws \GeoIp2\Exception\AddressNotFoundException  if the address is
  95.      *                                                     not in the database
  96.      * @throws \MaxMind\Db\Reader\InvalidDatabaseException if the database
  97.      *                                                     is corrupt or invalid
  98.      */
  99.     public function country(string $ipAddress): Country
  100.     {
  101.         return $this->modelFor(Country::class, 'Country', $ipAddress);
  102.     }
  104.     /**
  105.      * This method returns a GeoIP2 Anonymous IP model.
  106.      *
  107.      * @param string $ipAddress an IPv4 or IPv6 address as a string
  108.      *
  109.      * @throws \GeoIp2\Exception\AddressNotFoundException  if the address is
  110.      *                                                     not in the database
  111.      * @throws \MaxMind\Db\Reader\InvalidDatabaseException if the database
  112.      *                                                     is corrupt or invalid
  113.      */
  114.     public function anonymousIp(string $ipAddress): AnonymousIp
  115.     {
  116.         return $this->flatModelFor(
  117.             AnonymousIp::class,
  118.             'GeoIP2-Anonymous-IP',
  119.             $ipAddress
  120.         );
  121.     }
  123.     /**
  124.      * This method returns a GeoLite2 ASN model.
  125.      *
  126.      * @param string $ipAddress an IPv4 or IPv6 address as a string
  127.      *
  128.      * @throws \GeoIp2\Exception\AddressNotFoundException  if the address is
  129.      *                                                     not in the database
  130.      * @throws \MaxMind\Db\Reader\InvalidDatabaseException if the database
  131.      *                                                     is corrupt or invalid
  132.      */
  133.     public function asn(string $ipAddress): Asn
  134.     {
  135.         return $this->flatModelFor(
  136.             Asn::class,
  137.             'GeoLite2-ASN',
  138.             $ipAddress
  139.         );
  140.     }
  142.     /**
  143.      * This method returns a GeoIP2 Connection Type model.
  144.      *
  145.      * @param string $ipAddress an IPv4 or IPv6 address as a string
  146.      *
  147.      * @throws \GeoIp2\Exception\AddressNotFoundException  if the address is
  148.      *                                                     not in the database
  149.      * @throws \MaxMind\Db\Reader\InvalidDatabaseException if the database
  150.      *                                                     is corrupt or invalid
  151.      */
  152.     public function connectionType(string $ipAddress): ConnectionType
  153.     {
  154.         return $this->flatModelFor(
  155.             ConnectionType::class,
  156.             'GeoIP2-Connection-Type',
  157.             $ipAddress
  158.         );
  159.     }
  161.     /**
  162.      * This method returns a GeoIP2 Domain model.
  163.      *
  164.      * @param string $ipAddress an IPv4 or IPv6 address as a string
  165.      *
  166.      * @throws \GeoIp2\Exception\AddressNotFoundException  if the address is
  167.      *                                                     not in the database
  168.      * @throws \MaxMind\Db\Reader\InvalidDatabaseException if the database
  169.      *                                                     is corrupt or invalid
  170.      */
  171.     public function domain(string $ipAddress): Domain
  172.     {
  173.         return $this->flatModelFor(
  174.             Domain::class,
  175.             'GeoIP2-Domain',
  176.             $ipAddress
  177.         );
  178.     }
  180.     /**
  181.      * This method returns a GeoIP2 Enterprise model.
  182.      *
  183.      * @param string $ipAddress an IPv4 or IPv6 address as a string
  184.      *
  185.      * @throws \GeoIp2\Exception\AddressNotFoundException  if the address is
  186.      *                                                     not in the database
  187.      * @throws \MaxMind\Db\Reader\InvalidDatabaseException if the database
  188.      *                                                     is corrupt or invalid
  189.      */
  190.     public function enterprise(string $ipAddress): Enterprise
  191.     {
  192.         return $this->modelFor(Enterprise::class, 'Enterprise', $ipAddress);
  193.     }
  195.     /**
  196.      * This method returns a GeoIP2 ISP model.
  197.      *
  198.      * @param string $ipAddress an IPv4 or IPv6 address as a string
  199.      *
  200.      * @throws \GeoIp2\Exception\AddressNotFoundException  if the address is
  201.      *                                                     not in the database
  202.      * @throws \MaxMind\Db\Reader\InvalidDatabaseException if the database
  203.      *                                                     is corrupt or invalid
  204.      */
  205.     public function isp(string $ipAddress): Isp
  206.     {
  207.         return $this->flatModelFor(
  208.             Isp::class,
  209.             'GeoIP2-ISP',
  210.             $ipAddress
  211.         );
  212.     }
  214.     private function modelFor(string $class, string $type, string $ipAddress): object
  215.     {
  216.         [$record, $prefixLen] = $this->getRecord($class, $type, $ipAddress);
  218.         $record['traits']['ip_address'] = $ipAddress;
  219.         $record['traits']['prefix_len'] = $prefixLen;
  221.         return new $class($record, $this->locales);
  222.     }
  224.     private function flatModelFor(string $class, string $type, string $ipAddress): object
  225.     {
  226.         [$record, $prefixLen] = $this->getRecord($class, $type, $ipAddress);
  228.         $record['ip_address'] = $ipAddress;
  229.         $record['prefix_len'] = $prefixLen;
  231.         return new $class($record);
  232.     }
  234.     private function getRecord(string $class, string $type, string $ipAddress): array
  235.     {
  236.         if (!str_contains($this->dbType, $type)) {
  237.             $method = lcfirst((new \ReflectionClass($class))->getShortName());
  239.             throw new \BadMethodCallException(
  240.                 "The $method method cannot be used to open a {$this->dbType} database"
  241.             );
  242.         }
  243.         [$record, $prefixLen] = $this->dbReader->getWithPrefixLen($ipAddress);
  244.         if ($record === null) {
  245.             throw new AddressNotFoundException(
  246.                 "The address $ipAddress is not in the database."
  247.             );
  248.         }
  249.         if (!\is_array($record)) {
  250.             // This can happen on corrupt databases. Generally,
  251.             // MaxMind\Db\Reader will throw a
  252.             // MaxMind\Db\Reader\InvalidDatabaseException, but occasionally
  253.             // the lookup may result in a record that looks valid but is not
  254.             // an array. This mostly happens when the user is ignoring all
  255.             // exceptions and the more frequent InvalidDatabaseException
  256.             // exceptions go unnoticed.
  257.             throw new InvalidDatabaseException(
  258.                 "Expected an array when looking up $ipAddress but received: "
  259.                 . \gettype($record)
  260.             );
  261.         }
  263.         return [$record, $prefixLen];
  264.     }
  266.     /**
  267.      * @throws \InvalidArgumentException if arguments are passed to the method
  268.      * @throws \BadMethodCallException   if the database has been closed
  269.      *
  270.      * @return \MaxMind\Db\Reader\Metadata object for the database
  271.      */
  272.     public function metadata(): DbReader\Metadata
  273.     {
  274.         return $this->dbReader->metadata();
  275.     }
  277.     /**
  278.      * Closes the GeoIP2 database and returns the resources to the system.
  279.      */
  280.     public function close(): void
  281.     {
  282.         $this->dbReader->close();
  283.     }
  284. }