PHP library to handle IPv4, IPv6 and IP ranges

Related tags

Miscellaneous ip-lib
Overview

Tests Coverage Status Scrutinizer Code Quality Packagist Downloads Open in Gitpod

IPLib - Handle IPv4, IPv6 and IP ranges

Introduction

IPLib is a modern, PSR-compliant, test-driven IP addresses and subnets manipulation library. It implements primitives to handle IPv4 and IPv6 addresses, as well as IP ranges (subnets), in CIDR format (like ::1/128 or 127.0.0.1/32) and in pattern format (like ::*:* or 127.0.*.*).

Requirements

IPLib has very basic requirements as:

  • Works with any PHP version greater than 5.3.3 (PHP 5.3.x, 5.4.x, 5.5.x, 5.6.x, 7.x, and 8.x are fully supported).
  • No external dependencies
  • No special PHP configuration needed (yes, it will always work even if PHP has not been built with IPv6 support!).

Installation

Manual installation

Download the latest version, unzip it and add these lines in our PHP files:

require_once 'path/to/iplib/ip-lib.php';

Installation with Composer

Simply run

composer require mlocati/ip-lib

or add these lines to your composer.json file:

"require": {
    "mlocati/ip-lib": "^1"
}

Sample usage

Parse an address

To parse an IPv4 address:

$address = \IPLib\Address\IPv4::parseString('127.0.0.1');

To parse an IPv6 address:

$address = \IPLib\Address\IPv6::parseString('::1');

To parse an address in any format (IPv4 or IPv6):

$address = \IPLib\Factory::parseAddressString('::1');
$address = \IPLib\Factory::parseAddressString('127.0.0.1');

Get the next/previous addresses

$address = \IPLib\Factory::parseAddressString('::1');

// This will print ::
echo (string) $address->getPreviousAddress();

// This will print ::2
echo (string) $address->getNextAddress();

Get the addresses at a specified offset

For addresses:

$address = \IPLib\Factory::parseAddressString('::1');

// This will print ::1
echo (string) $address->getAddressAtOffset(0);

// This will print ::2
echo (string) $address->getAddressAtOffset(1);

// This will print ::3
echo (string) $address->getAddressAtOffset(2);

// This will print ::3e9
echo (string) $address->getAddressAtOffset(1000);

// This will print ::
echo (string) $address->getAddressAtOffset(-1);

// This will print NULL
echo var_dump($address->getAddressAtOffset(-2));

For ranges:

$range = \IPLib\Factory::parseRangeString('::ff00/120');

// This will print ::ff00
echo (string) $range->getAddressAtOffset(0);

// This will print ::ff10
echo (string) $range->getAddressAtOffset(16);

// This will print ::ff64
echo (string) $range->getAddressAtOffset(100);

// This will print NULL because the address ::1:0 is out of the range
var_dump($range->getAddressAtOffset(256));

// This will print ::ffff
echo (string) $range->getAddressAtOffset(-1);

// This will print ::fff0
echo (string) $range->getAddressAtOffset(-16);

// This will print ::ff00
echo (string) $range->getAddressAtOffset(-256);

// This will print NULL because the address ::feff is out of the range
var_dump($range->getAddressAtOffset(-257));

Parse an IP address range

To parse a subnet (CIDR) range:

$range = \IPLib\Range\Subnet::parseString('127.0.0.1/24');
$range = \IPLib\Range\Subnet::parseString('::1/128');

To parse a pattern (asterisk notation) range:

$range = \IPLib\Range\Pattern::parseString('127.0.0.*');
$range = \IPLib\Range\Pattern::parseString('::*');

To parse an andress as a range:

$range = \IPLib\Range\Single::parseString('127.0.0.1');
$range = \IPLib\Range\Single::parseString('::1');

To parse a range in any format:

$range = \IPLib\Factory::parseRangeString('127.0.0.*');
$range = \IPLib\Factory::parseRangeString('::1/128');
$range = \IPLib\Factory::parseRangeString('::');

Retrieve a range from its boundaries

You can calculate the smallest range that comprises two addresses:

$range = \IPLib\Factory::getRangeFromBoundaries('192.168.0.1', '192.168.255.255');

// This will print 192.168.0.0/16
echo (string) $range;

You can also calculate a list of ranges that exactly describes all the addresses between two addresses:

$ranges = \IPLib\Factory::getRangesFromBoundaries('192.168.0.0', '192.168.0.5');

// This will print 192.168.0.0/30 192.168.0.4/31
echo implode(' ', $ranges);

Retrieve the boundaries of a range

$range = \IPLib\Factory::parseRangeString('127.0.0.*');

// This will print 127.0.0.0
echo (string) $range->getStartAddress();

// This will print 127.0.0.255
echo (string) $range->getEndAddress();

Format addresses and ranges

Both IP addresses and ranges have a toString method that you can use to retrieve a textual representation:

// This will print 127.0.0.1
echo \IPLib\Factory::parseAddressString('127.0.0.1')->toString();

// This will print 127.0.0.1
echo \IPLib\Factory::parseAddressString('127.000.000.001')->toString();

// This will print ::1
echo \IPLib\Factory::parseAddressString('::1')->toString();

// This will print ::1
echo \IPLib\Factory::parseAddressString('0:0::1')->toString();

// This will print ::1/64
echo \IPLib\Factory::parseRangeString('0:0::1/64')->toString();

When working with IPv6, you may want the full (expanded) representation of the addresses. In this case, simply use a true parameter for the toString method:

// This will print 0000:0000:0000:0000:0000:0000:0000:0000
echo \IPLib\Factory::parseAddressString('::')->toString(true);

// This will print 0000:0000:0000:0000:0000:0000:0000:0001
echo \IPLib\Factory::parseAddressString('::1')->toString(true);

// This will print 0fff:0000:0000:0000:0000:0000:0000:0000
echo \IPLib\Factory::parseAddressString('fff::')->toString(true);

// This will print 0000:0000:0000:0000:0000:0000:0000:0000
echo \IPLib\Factory::parseAddressString('::0:0')->toString(true);

// This will print 0001:0002:0003:0004:0005:0006:0007:0008
echo \IPLib\Factory::parseAddressString('1:2:3:4:5:6:7:8')->toString(true);

// This will print 0000:0000:0000:0000:0000:0000:0000:0001/64
echo \IPLib\Factory::parseRangeString('0:0::1/64')->toString();

The address and range objects implements the __toString() method, which call the toString() method. So, if you want the string (short) representation of an object, you can do any of the following:

$address = \IPLib\Address\IPv6::parseString('::1');

// All these will print ::1
echo $address->toString();
echo $address->toString(false);
echo (string) $address;

Check if an address is contained in a range

All the range types offer a contains method, and all the IP address types offer a matches method: you can call them to check if an address is contained in a range:

$address = \IPLib\Factory::parseAddressString('1:2:3:4:5:6:7:8');
$range = \IPLib\Factory::parseRangeString('0:0::1/64');

$contained = $address->matches($range);
// that's equivalent to
$contained = $range->contains($address);

Please remark that if the address is IPv4 and the range is IPv6 (or vice-versa), the result will always be false.

Check if a range contains another range

All the range types offer a containsRange method: you can call them to check if an address range fully contains another range:

$range1 = \IPLib\Factory::parseRangeString('0:0::1/64');
$range2 = \IPLib\Factory::parseRangeString('0:0::1/65');

$contained = $range1->containsRange($range2);

Getting the type of an IP address

If you want to know if an address is within a private network, or if it's a public IP, or whatever you want, you can use the getRangeType method:

$address = \IPLib\Factory::parseAddressString('::');

$type = $address->getRangeType();

$typeName = \IPLib\Range\Type::getName($type);

The most notable values of the range type are:

  • \IPLib\Range\Type::T_UNSPECIFIED if the address is all zeros (0.0.0.0 or ::)
  • \IPLib\Range\Type::T_LOOPBACK if the address is the localhost (usually 127.0.0.1 or ::1)
  • \IPLib\Range\Type::T_PRIVATENETWORK if the address is in the local network (for instance 192.168.0.1 or fc00::1)
  • \IPLib\Range\Type::T_PUBLIC if the address is for public usage (for instance 104.25.25.33 or 2001:503:ba3e::2:30)

Getting the type of an IP address range

If you want to know the type of an address range, you can use the getRangeType method:

$range = \IPLib\Factory::parseRangeString('2000:0::1/64');

// $type will contain the value of \IPLib\Range\Type::T_PUBLIC
$type = $range->getRangeType();

// This will print Public address
echo \IPLib\Range\Type::getName($type);

Please note that if a range spans across multiple range types, you'll get NULL as the range type:

$range = \IPLib\Factory::parseRangeString('::/127');

// $type will contain null
$type = $range->getRangeType();

// This will print Unknown type
echo \IPLib\Range\Type::getName($type);

Converting IP addresses

This library supports converting IPv4 to/from IPv6 addresses using the 6to4 notation or the IPv4-mapped notation:

$ipv4 = \IPLib\Factory::parseAddressString('1.2.3.4');

// 6to4 notation
$ipv6 = $ipv4->toIPv6();

// This will print 2002:102:304::
echo (string) $ipv6;

// This will print 1.2.3.4
echo $ipv6->toIPv4();

// IPv4-mapped notation
$ipv6 = $ipv4->toIPv6IPv4Mapped();

// This will print ::ffff:1.2.3.4
echo (string) $ipv6;

// This will print 1.2.3.4
echo $ipv6_6to4->toIPv4();

Converting IP ranges

This library supports IPv4/IPv6 ranges in pattern format (eg. 192.168.*.*) and in CIDR/subnet format (eg. 192.168.0.0/16), and it offers a way to convert between the two formats:

// This will print ::*:*:*:*
echo \IPLib\Factory::parseRangeString('::/64')->asPattern()->toString();

// This will print 1:2::/96
echo \IPLib\Factory::parseRangeString('1:2::*:*')->asSubnet()->toString();

// This will print 192.168.0.0/24
echo \IPLib\Factory::parseRangeString('192.168.0.*')->asSubnet()->toString();

// This will print 10.*.*.*
echo \IPLib\Factory::parseRangeString('10.0.0.0/8')->asPattern()->toString();

Please remark that all the range types implement the asPattern() and asSubnet() methods.

Getting the subnet mask for IPv4 ranges

You can use the getSubnetMask() to get the subnet mask for IPv4 ranges:

// This will print 255.255.255.0
echo \IPLib\Factory::parseRangeString('192.168.0.*')->getSubnetMask()->toString();

// This will print 255.255.255.252
echo \IPLib\Factory::parseRangeString('192.168.0.12/30')->getSubnetMask()->toString();

Getting the range size

You can use the getSize() to get the count of addresses this IP range contains:

// This will print 256
echo \IPLib\Factory::parseRangeString('192.168.0.*')->getSize();

// This will print 4
echo \IPLib\Factory::parseRangeString('192.168.0.12/30')->getSize();

// This will print 1
echo \IPLib\Factory::parseRangeString('192.168.0.1')->getSize();

Getting the reverse DNS lookup address

To perform reverse DNS queries, you need to use a special format of the IP addresses.

You can use the getReverseDNSLookupName() method of the IP address instances to retrieve it easily:

$ipv4 = \IPLib\Factory::parseAddressString('1.2.3.255');
$ipv6 = \IPLib\Factory::parseAddressString('1234:abcd::cafe:babe');

// This will print 255.3.2.1.in-addr.arpa
echo $ipv4->getReverseDNSLookupName();

// This will print e.b.a.b.e.f.a.c.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.d.c.b.a.4.3.2.1.ip6.arpa
echo $ipv6->getReverseDNSLookupName();

To parse addresses in reverse DNS lookup format you can use the IPLib\ParseStringFlag::ADDRESS_MAYBE_RDNS flag when parsing a string:

$ipv4 = \IPLib\Factory::parseAddressString('255.3.2.1.in-addr.arpa', \IPLib\ParseStringFlag::ADDRESS_MAYBE_RDNS);
$ipv6 = \IPLib\Factory::parseAddressString('e.b.a.b.e.f.a.c.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.d.c.b.a.4.3.2.1.ip6.arpa', \IPLib\ParseStringFlag::ADDRESS_MAYBE_RDNS);

// This will print 1.2.3.255
echo $ipv4->toString();

// This will print 1234:abcd::cafe:babe
echo $ipv6->toString();

You can also use getReverseDNSLookupName() for IP ranges. In this case, the result is an array of strings:

$range = \IPLib\Factory::parseRangeString('10.155.16.0/22');

/*
 * This will print:
 * array (
 *   0 => '16.155.10.in-addr.arpa',
 *   1 => '17.155.10.in-addr.arpa',
 *   2 => '18.155.10.in-addr.arpa',
 *   3 => '19.155.10.in-addr.arpa',
 * )
*/
var_export($range->getReverseDNSLookupName());

Using a database

This package offers a great feature: you can store address ranges in a database table, and check if an address is contained in one of the saved ranges with a simple query.

To save a range, you need to store the address type (for IPv4 it's 4, for IPv6 it's 6), as well as two values representing the start and the end of the range. These methods are:

$range->getAddressType();
$range->getComparableStartString();
$range->getComparableEndString();

Let's assume that you saved the type in a field called addressType, and the range boundaries in two fields called rangeFrom and rangeTo.

When you want to check if an address is within a stored range, simply use the getComparableString method of the address and check if it's between the fields rangeFrom and rangeTo, and check if the stored addressType is the same as the one of the address instance you want to check.

Here's a sample code:

/*
 * Let's assume that:
 * - $pdo is a PDO instance
 * - $range is a range object
 * - $address is an address object
 */

// Save the $range object
$insertQuery = $pdo->prepare('
    insert into ranges (addressType, rangeFrom, rangeTo)
    values (:addressType, :rangeFrom, :rangeTo)
');

$insertQuery->execute(array(
    ':addressType' => $range->getAddressType(),
    ':rangeFrom' => $range->getComparableStartString(),
    ':rangeTo' => $range->getComparableEndString(),
));

// Retrieve the saved ranges where an address $address falls:
$searchQuery = $pdo->prepare('
    select * from ranges
    where addressType = :addressType
    and :address between rangeFrom and rangeTo
');

$searchQuery->execute(array(
    ':addressType' => $address->getAddressType(),
    ':address' => $address->getComparableString(),
));

$rows = $searchQuery->fetchAll();
$searchQuery->closeCursor();

Handling non-standard address and range strings

Accepting ports

If you want to accept addresses that may include ports, you can specify the IPLib\ParseStringFlag::MAY_INCLUDE_PORT flag:

use IPLib\Factory;
use IPLib\ParseStringFlag;

require_once __DIR__ . '/../ip-lib.php';

// These will print NULL
var_export(Factory::parseAddressString('127.0.0.1:80'));
var_export(Factory::parseAddressString('[::]:80'));

// This will print 127.0.0.1
echo (string) Factory::parseAddressString('127.0.0.1:80', ParseStringFlag::MAY_INCLUDE_PORT);
// This will print ::
echo (string) Factory::parseAddressString('[::]:80', ParseStringFlag::MAY_INCLUDE_PORT);

Accepting IPv6 zone IDs

If you want to accept IPv6 addresses that may include a zone ID, you can specify the IPLib\ParseStringFlag::MAY_INCLUDE_ZONEID flag:

use IPLib\Factory;
use IPLib\ParseStringFlag;

// This will print NULL
var_export(Factory::parseAddressString('::%11'));

// This will print ::
echo (string) Factory::parseAddressString('::%11', ParseStringFlag::MAY_INCLUDE_ZONEID);

Accepting non-decimal IPv4 addresses

IPv4 addresses are usually expressed in decimal notation, for example as 192.168.0.1.

By the way, the GNU (used in many Linux distros), BSD (used in Mac) and Windows implementations of inet_aton and inet_addr accept IPv4 addresses with numbers in octal and/or hexadecimal format. Please remark that this does not apply to the inet_pton and ip2long functions, as well as to the Musl implementation (used in Alpine Linux) of inet_aton and inet_addr.

So, for example, these addresses are all equivalent to 192.168.0.1:

  • 0xC0.0xA8.0x0.0x01 (only hexadecimal)
  • 0300.0250.00.01 (only octal)
  • 192.0250.0.0x01 (decimal, octal and hexadecimal numbers)

(try it: if you browse to http://0177.0.0.0x1, your browser will try to browse http://127.0.0.1).

If you want to accept this non-decimal syntax, you may use the IPLib\ParseStringFlag::IPV4_MAYBE_NON_DECIMAL flag:

use IPLib\Factory;
use IPLib\ParseStringFlag;

// This will print NULL
var_export(Factory::parseAddressString('0177.0.0.0x1'));

// This will print 127.0.0.1
var_export((string) Factory::parseAddressString('0177.0.0.0x1', ParseStringFlag::IPV4_MAYBE_NON_DECIMAL));

// This will print NULL
var_export(Factory::parseRangeString('0177.0.0.0x1/32'));

// This will print 127.0.0.1/32
var_export((string) Factory::parseRangeString('0177.0.0.0x1/32', ParseStringFlag::IPV4_MAYBE_NON_DECIMAL));

Please be aware that the IPV4_MAYBE_NON_DECIMAL flag may also affect parsing decimal numbers:

use IPLib\Factory;
use IPLib\ParseStringFlag;

// This will print 127.0.0.10 since the last digit is assumed to be decimal
var_export((string) Factory::parseAddressString('127.0.0.010'));

// This will print 127.0.0.8 since the last digit is assumed to be octal
var_export((string) Factory::parseAddressString('127.0.0.010', ParseStringFlag::IPV4_MAYBE_NON_DECIMAL));

Accepting IPv4 addresses in not-quad-dotted notation

IPv4 addresses are usually expressed with 4 numbers, for example as 192.168.0.1.

By the way, the GNU (used in many Linux distros), BSD (used in Mac) and Windows implementations of inet_aton and inet_addr accept IPv4 addresses with 1 to 4 numbers.

Please remark that this does not apply to the inet_pton and ip2long functions, as well as to the Musl implementation (used in Alpine Linux) of inet_aton and inet_addr.

If you want to accept this non-decimal syntax, you may use the IPLib\ParseStringFlag::IPV4ADDRESS_MAYBE_NON_QUAD_DOTTED flag:

use IPLib\Factory;
use IPLib\ParseStringFlag;

// This will print NULL
var_export(Factory::parseAddressString('1.2.500'));

// This will print 0.0.0.0
var_export((string) Factory::parseAddressString('0', ParseStringFlag::IPV4ADDRESS_MAYBE_NON_QUAD_DOTTED));

// This will print 0.0.0.1
var_export((string) Factory::parseAddressString('1', ParseStringFlag::IPV4ADDRESS_MAYBE_NON_QUAD_DOTTED));

// This will print 0.0.1.244
var_export((string) Factory::parseAddressString('0.0.500', ParseStringFlag::IPV4ADDRESS_MAYBE_NON_QUAD_DOTTED));

// This will print 255.255.255.255
var_export((string) Factory::parseAddressString('4294967295', ParseStringFlag::IPV4ADDRESS_MAYBE_NON_QUAD_DOTTED));

Accepting compact IPv4 subnet notation

Even if there isn't an RFC that describe it, IPv4 subnet notation may also be written in a compact form, omitting extra digits (for example, 127.0.0.0/24 may be written as 127/24). If you want to accept such format, you can specify the IPLib\ParseStringFlag::IPV4SUBNET_MAYBE_COMPACT flag:

use IPLib\Factory;
use IPLib\ParseStringFlag;

// This will print NULL
var_export(Factory::parseRangeString('127/24'));

// This will print 127.0.0.0/24
echo (string) Factory::parseRangeString('127/24', ParseStringFlag::IPV4SUBNET_MAYBE_COMPACT);

Combining multiple flags

Of course, you may use more than one IPLib\ParseStringFlag flag at once:

use IPLib\Factory;
use IPLib\ParseStringFlag;

// This will print 127.0.0.255
var_export((string) Factory::parseAddressString('127.0.0.0xff:80', ParseStringFlag::MAY_INCLUDE_PORT | ParseStringFlag::IPV4_MAYBE_NON_DECIMAL));

// This will print ::
var_export((string) Factory::parseAddressString('[::%11]:80', ParseStringFlag::MAY_INCLUDE_PORT | ParseStringFlag::MAY_INCLUDE_ZONEID));

Gitpod Environment Variables

The following features can be enabled through environment variables that have been set in your Gitpod preferences.:

* Please note that storing sensitive data in environment variables is not ultimately secure but should be OK for most development situations.

  • Sign Git commits with a GPG key

    • GPG_KEY_ID (required)
      • The ID of the GPG key you want to use to sign your git commits
    • GPG_KEY (required)
      • Base64 encoded private GPG key that corresponds to your GPG_KEY_ID
    • GPG_MATCH_GIT_TO_EMAIL (optional)
      • Sets your git user.email in ~/.gitconfig to the value provided
    • GPG_AUTO_ULTIMATE_TRUST (optional)
      • If the value is set to yes or YES then your GPG_KEY will be automatically ultimately trusted

  • Activate an Intelliphense License Key

    • INTELEPHENSE_LICENSEKEY
      • Creates ~/intelephense/licence.txt and will contain the value provided
      • This will activate Intelliphense for you each time the workspace is created or restarted

Do you really want to say thank you?

You can offer me a monthly coffee or a one-time coffee 😉

Comments
  • Support for abbreviated IPv4 subnet notation

    Support for abbreviated IPv4 subnet notation

    This change extends the supported formats of the range's fromString() with the abbreviated IPv4 CIDR subnet notation. Some examples for these and the expected lowest and highest IPs can be found in the associated test case.

    closes #65

    opened by elrido 14
  • `rangeFromBoundaries` does not work with large ranges

    `rangeFromBoundaries` does not work with large ranges

    Here's an example:

    $range = \IPLib\Factory::rangeFromBoundaries('1.1.1.1', '2.2.2.2');
$cidr = (string) $range; // Results in 0.0.0.0/6

    The CIDR result is 0.0.0.0/6 in this case, while the correct output would be a list of CIDRs:

    1.1.1.1/32
1.1.1.2/31
1.1.1.4/30
1.1.1.8/29
1.1.1.16/28
1.1.1.32/27
1.1.1.64/26
1.1.1.128/25
1.1.2.0/23
1.1.4.0/22
1.1.8.0/21
1.1.16.0/20
1.1.32.0/19
1.1.64.0/18
1.1.128.0/17
1.2.0.0/15
1.4.0.0/14
1.8.0.0/13
1.16.0.0/12
1.32.0.0/11
1.64.0.0/10
1.128.0.0/9
2.0.0.0/15
2.2.0.0/23
2.2.2.0/31
2.2.2.2/32

    Can the rangeFromBoundaries method only be used for ranges that can be displayed in a single CIDR?

    opened by chescos 11
  • Incomplete support for Non-decimal notation

    Incomplete support for Non-decimal notation

    The library supports some non-decimal notations, but many formats supported by the ping and browsers do not work here using addressFromString($ip, true, true, true)

    left is result of ping, right is "valid" ip notation:

      0.0.0.0	0 (short to 1 octet, actually decimal:)
 0.0.0.10	10
  0.0.0.8	010 (octal)
 0.0.0.10	0xa (hex)
127.0.0.1	127.1 (2 octets)
 10.0.0.8	10.010
127.0.0.1	0177.0x01
127.0.0.1	127.0.1 (3 octets)
127.0.0.1	017700000001 (all-in-one octal)
127.0.0.1	00000000000000000000000000000000000000000000000000000017700000001 (all-in-one octal with infinite leading zeroes)
127.0.0.1	0x7f000001 (all-in-one hex)
127.0.0.1	0x00000000000000000000000000000000000000000000000000000007f000001 (all-in-one hex with infinite leading zeroes)
10.8.0.17	10.010.0x000000000000000011

    not sure if i missed some

    opened by cowsay1 8
  • IP Range DNS Lookup

    IP Range DNS Lookup

    Following the idea of #44, I would love to gave the possibility to get the reverse pointer for an IP range.

    Factory::rangeFromString('cafe::/32')->getReverseDNSLookupName();

// 0.0.0.0.e.f.a.c.in-addr.arpa

    Is this maybe in the scope of this package? Would love to contribute to this idea.

    opened by ya-cha 8
  • PR add godpod.io integration with git gpg support

    PR add godpod.io integration with git gpg support

    • Added Gidpod.io Button to the readme file
    • Added Gitpod.io integration with Dockerfile
    • Added GPG Support for signed git commits
    • Added Auto activate intelephense extension if license key is available
    • Added Gitpod Environment Variables Information to the readme file
    opened by strausmann 7
  • Add getAddressAtOffset for addresses and ranges

    Add getAddressAtOffset for addresses and ranges

    Shorthand for integer addition and subtraction (if available).

    This patch will also integrate getNextAddress/getPreviousAddress.

    I'm sorry to tell you that English is not my main language. Please inform me if the method name or the testing looks weirdo for you. (I'll be appreciated if you can revise any of them)

    opened by ernix 6
  • RFC6598 Addresses (CGNAT, 100.64/10)

    RFC6598 Addresses (CGNAT, 100.64/10)

    Hello, It would be nice if this lib included these ranges, as more and more ISPs deploy them as part of a DS-Lite implementation.

    RFC Link: https://tools.ietf.org/html/rfc6598

    -Stathis

    opened by stathis 6
  • getComparableString/getComparableEndString like toString

    getComparableString/getComparableEndString like toString

    Now when used $range->getComparableStartString() return 172.019.253.000 for example. If I need use it in ip2long()

    function ip_range($start, $end) {
    $start = ip2long($start);
    $end = ip2long($end);
    return array_map('long2ip', range($start, $end) );
}
print_r(ip_range($range->getComparableStartString(), $range->getComparableEndString()));

    the result will be Array ( [0] => 0.0.0.0 )

    Will be great if $range->getComparableStartString(false) returns 172.19.253.0 like AddressInterface::toString()

    opened by githubjeka 6
  • return long string of ipv4 address if parameter is present

    return long string of ipv4 address if parameter is present

    I came across the problem that when I get the long string representation of a IPv4 subnet with $subnet->toString(true) it calls the toString method on the IPv4 Address object, however it's still returning the short compacted address and not the long one requested. This causes issue if database operations and comparisons rely on this.

    opened by henry-spanka 6
  • Get reverse pointer for IP address

    Get reverse pointer for IP address

    It would great if it was possible to retrieve the reverse pointer domain for an IP.

    For example converting 1.2.3.4 to 4.3.2.1.in-addr.arpa for IPv4.

    I might PR this in the future but I wanted to leave this request here in case someone wants to pick it up and see if it would be in scope for this lib.

    opened by stayallive 5
  • toString(true) on ipv4

    toString(true) on ipv4 "expands" address

    When using toString(true) for an ipv4-address 127.0.0.1 it is converted to 127.000.000.001. This is practical when sorting but ipv4 addresses are never used like that for display or storage (to my knowledge).

    Would you be open to adding expanded() and compressed() methods to AddressInterface the expands/compresses ipv6-addresses but leaves ipv4-addresses as is? (Can provide a pull request).

    This would be very convenient when working with a list that contain both ipv4 and ipv6-addresses and you want to convert them for display/storage without having to check versions for the addresses.

    opened by emil-nasso 5
  • Convert Mac address to IPv6 link local or with the provider prefix the public ip address

    Convert Mac address to IPv6 link local or with the provider prefix the public ip address

    Would the following functions in this Project be the right place ?

    • Convert MAC address to IPv6 Local Link address. Example 11:22:33:44:55:66 to fe80::1322:33ff:fe44:5566

    • Convert MAC address and provider IPv6 prefix to a Public IPv6 address. Example Mac Address 11:22:33:44:55:66 and Provider Prefix 2001:9e5:61cf:5600:: to 2001:9e5:61cf:5600:1322:33ff:fe44:5566

    • IPv6 address to MAC address Example 2001:9e5:61cf:5600:1322:33ff:fe44:5566 to 11:22:33:44:55:66

    Here are two example functions https://stackoverflow.com/questions/54748755/how-to-convert-mac-address-into-ipv6-link-local-address-and-vice-versa

    opened by strausmann 0
Releases(1.18.0)

  • 1.18.0(Jan 13, 2022)

  • 1.17.1(Nov 10, 2021)

  • 1.17.0(Aug 3, 2021)

    New features

    Deprecated functions

    In order to support parsing the above notations, some new functions have been introduced, which deprecate some of the methods that parse strings.

    | Deprecated function | New function | |--|--| | IPLib\Factory::addressFromString | IPLib\Factory::parseAddressString| | IPLib\Factory::rangeFromString | IPLib\Factory::parseRangeString | | IPLib\Factory::rangeFromBoundaries | IPLib\Factory::getRangeFromBoundaries | | IPLib\Factory::rangesFromBoundaries | IPLib\Factory::getRangesFromBoundaries | | IPLib\Address\IPv4::fromString | IPLib\Address\IPv4::parseString | | IPLib\Address\IPv6::fromString | IPLib\Address\IPv6::parseString | | IPLib\Range\Pattern::fromString | IPLib\Range\Pattern::parseString | | IPLib\Range\Single::fromString | IPLib\Range\Single::parseString | | IPLib\Range\Subnet::fromString | IPLib\Range\Subnet::parseString |

    See the phpdoc of the deprecated methods for further details.

    Special thanks to @elrido for his productive contributions.

    Source code(tar.gz)
    Source code(zip)

  • 1.16.0(Jun 3, 2021)

  • 1.15.0(May 26, 2021)

  • 1.14.0(Dec 31, 2020)

    • New methods added to IPLib\Address\AddressInterface:
      • getNumberOfBits()
      • getBits()
    • New methods added to IPLib\Factory:
      • rangesFromBoundaries()
    Source code(tar.gz)
    Source code(zip)

  • 1.13.0(Oct 4, 2020)

  • 1.12.0(Jul 27, 2020)

  • 1.11.0(Jul 16, 2020)

  • 1.10.0(Jul 9, 2020)

  • 1.9.0(Sep 20, 2019)

    • New method: IPLib\Address\IPv6::toMixedIPv6IPv4String() to render IPv6 addresses in the mixed IPv6+IPv4 representation described in https://tools.ietf.org/html/rfc4291#section-2.2 point 3
    • IPLib\Factory::addressFromString() can now parse the mixed IPv6+IPv4 representation (for example: 2001:da8:d800:9:200:5efe:101.94.1.77)
    Source code(tar.gz)
    Source code(zip)

  • 1.8.0(Jul 30, 2019)

    • New method: IPLib\Range\Pattern::asSubnet() to convert pattern ranges (eg 192.168.0.*) to subnet/CIDR ranges (eg `192.168.0.0/24)
    • New method: IPLib\Range\Subnet::asPattern() to convert subnet/CIDR ranges (eg 192.168.0.0/24) to pattern ranges (eg 192.168.0.*)
    • New method for all the range types (getSubnetMask()) to retrieve the subnet mask (only for IPv4 ranges)
    Source code(tar.gz)
    Source code(zip)

  • 1.7.0(Feb 25, 2019)

  • 1.6.0(Aug 12, 2018)

  • 1.5.0(Dec 18, 2017)

    New instance methods available for IPLib\Range\RangeInterface:

    • getRangeType()
      to get the type of a range (if available)
    • containsRange(RangeInterface $otherRange)
      to check if a range fully contains another range

    New static methods available for IPLib\Range\AddressInterface:

    • getReservedRanges()
      to get the list of ranges
    • getDefaultReservedRangeType()
      to get the type of IP addresses not present in the ranges returned by getReservedRanges()

    New static methods available for IPLib\Range\Subnet:

    • get6to4()
      to get the IPv6 6to4 subnet range
    Source code(tar.gz)
    Source code(zip)

  • 1.4.0(Aug 30, 2017)

    • New methods available for IPLib\Address\AddressInterface:
      • getNextAddress()
      • getPreviousAddress()
    • New methods available for IPLib\Range\RangeInterface:
      • getStartAddress()
      • getEndAddress()
    Source code(tar.gz)
    Source code(zip)

  • 1.3.0(Jul 6, 2017)

  • 1.2.1(Mar 14, 2017)

  • 1.2.0(Feb 15, 2017)

  • 1.1.1(Feb 15, 2017)

  • 1.1.0(Feb 2, 2017)

  • 1.0.0(Mar 18, 2016)

Owner
Michele Locati
🇺🇦 Having fun with coding since 1988
Michele Locati
GitHub
Immutable value object for IPv4 and IPv6 addresses, including helper methods and Doctrine support.

IP is an immutable value object for (both version 4 and 6) IP addresses. Several helper methods are provided for ranges, broadcast and network address

Darsyn 224 Dec 28, 2022
AppGallery IAP is a PHP library to handle AppGallery purchase verification and Server Notifications

AppGallery IAP About AppGallery IAP is a PHP library to handle AppGallery purchase verification and Server Notifications. This package simplifies deve

Dmitry 6 Aug 10, 2022
JSON schema models and generated code to validate and handle various data in PocketMine-MP

DataModels JSON schema models and generated code to validate and handle various data in PocketMine-MP This library uses php-json-schema-model-generato

PMMP 2 Nov 9, 2022
A bundle to handle encoding and decoding of parameters using OpenSSL and Doctrine lifecycle events.

SpecShaper Encrypt Bundle A bundle to handle encoding and decoding of parameters using OpenSSL and Doctrine lifecycle events. Features include: Master

Mark Ogilvie 48 Nov 4, 2022
You can handle iOS Application Subscription Server Side with Laravel.

Auto Renewing Subscriptions for iOS Apps with Laravel This repository help you to handle iOS Application Subscription on server side. It provides Save

Ajay Thakkar 2 Jun 29, 2022
A very simple way to handle self-hosted WordPress plugin updates

Simple WP Plugin Update handling A very simple way to handle self-hosted WordPress plugin updates This uses the "update_plugins_{$hostname}" filter in

Peter Viszt 5 Jun 13, 2023
FilterGuard is a simple PHP library for sanitizing data. It provides methods to sanitize strings, integers, floats, booleans, arrays, and objects. The library helps protect against common security vulnerabilities such as XSS and SQL injection.

FilterGuard FilterGuard is a simple PHP library for data sanitization. It provides methods to sanitize strings, integers, floats, boolean values, arra

Dobren Dragojević 6 Jun 11, 2023
MOP is a php query handling and manipulation library providing easy and reliable way to manipulate query and get result in a fastest way

Mysql Optimizer mysql optimizer also known as MOP is a php query handling and manipulation library providing easy and reliable way to manipulate query

null 2 Nov 20, 2021
:date: The VObject library for PHP allows you to easily parse and manipulate iCalendar and vCard objects

sabre/vobject The VObject library allows you to easily parse and manipulate iCalendar and vCard objects using PHP. The goal of the VObject library is

sabre.io 532 Dec 25, 2022
JSONFinder - a library that can find json values in a mixed text or html documents, can filter and search the json tree, and converts php objects to json without 'ext-json' extension.

JSONFinder - a library that can find json values in a mixed text or html documents, can filter and search the json tree, and converts php objects to json without 'ext-json' extension.

Eboubaker Eboubaker 2 Jul 31, 2022
Backwards compatibility Extension and Library for PHP 8.x and later

colopl_bc Provides various compatibility functions required for PHP (temporary) migration. WARNING This extension is intended for temporary use only.

COLOPL,Inc. 10 Jun 13, 2023
PHP Text Analysis is a library for performing Information Retrieval (IR) and Natural Language Processing (NLP) tasks using the PHP language

php-text-analysis PHP Text Analysis is a library for performing Information Retrieval (IR) and Natural Language Processing (NLP) tasks using the PHP l

null 464 Dec 28, 2022
Columnar analytics for PHP - a pure PHP library to read and write simple columnar files in a performant way.

Columnar Analytics (in pure PHP) On GitHub: https://github.com/envoymediagroup/columna About the project What does it do? This library allows you to w

Envoy Media Group 2 Sep 26, 2022
PHP library providing retry functionality with multiple backoff strategies and jitter support

PHP Backoff Easily wrap your code with retry functionality. This library provides: 4 backoff strategies (plus the ability to use your own) Optional ji

Signature Tech Studio 145 Dec 21, 2022
Currency is a simple PHP library for current and historical currency exchange rates & crypto exchange rates. based on the free API exchangerate.host

Currency Currency is a simple PHP library for current and historical currency exchange rates & crypto exchange rates. based on the free API exchangera

Amr Shawky 19 Dec 12, 2022
A high-level machine learning and deep learning library for the PHP language.

Rubix ML A high-level machine learning and deep learning library for the PHP language. Developer-friendly API is delightful to use 40+ supervised and

Rubix 1.7k Jan 1, 2023
PHP library to create and validate html forms

FormManager Note: this is the documentation of FormManager 6.x For v5.x version Click here Installation: This package requires PHP>=7.1 and is availab

Oscar Otero 145 Sep 20, 2022
A small, modern, PSR-7 compatible PSR-17 and PSR-18 network library for PHP, inspired by Go's net package.

Net A small, modern, PSR-7 compatible PSR-17 and PSR-18 network library for PHP, inspired by Go's net package. Features: No hard dependencies; Favours

Minibase 16 Jun 7, 2022
Library for PHP 7.4+ to detect Browsers and Devices

This library requires PHP 7.4+. Also a PSR-3 compatible logger and a PSR-16 compatible cache are required. In

Thomas Müller 37 Oct 2, 2022