1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
<?php
/*
* Collection of public static functions to play with IP address
* and IP blocks.
*
* @Author "Ashar Voultoiz" <hashar@altern.org>
* @License GPL v2 or later
*/
// Some regex definition to "play" with IP address and IP address blocks
// An IP is made of 4 bytes from x00 to xFF which is d0 to d255
define( 'RE_IP_BYTE', '(25[0-5]|2[0-4]\d|1?\d{1,2})');
define( 'RE_IP_ADD' , RE_IP_BYTE . '\.' . RE_IP_BYTE . '\.' . RE_IP_BYTE . '\.' . RE_IP_BYTE );
// An IP block is an IP address and a prefix (d1 to d32)
define( 'RE_IP_PREFIX' , '(3[0-2]|[12]?\d)');
define( 'RE_IP_BLOCK', RE_IP_ADD . '\/' . RE_IP_PREFIX);
class IP {
/**
* Validate an IP address.
* @return boolean True if it is valid.
*/
public static function isValid( $ip ) {
return preg_match( '/^' . RE_IP_ADD . '$/', $ip, $matches) ;
}
/**
* Validate an IP Block.
* @return boolean True if it is valid.
*/
public static function isValidBlock( $ipblock ) {
return ( count(self::toArray($ipblock)) == 1 + 5 );
}
/**
* Determine if an IP address really is an IP address, and if it is public,
* i.e. not RFC 1918 or similar
* Comes from ProxyTools.php
*/
public static function isPublic( $ip ) {
$n = IP::toUnsigned( $ip );
if ( !$n ) {
return false;
}
// ip2long accepts incomplete addresses, as well as some addresses
// followed by garbage characters. Check that it's really valid.
if( $ip != long2ip( $n ) ) {
return false;
}
static $privateRanges = false;
if ( !$privateRanges ) {
$privateRanges = array(
array( '10.0.0.0', '10.255.255.255' ), # RFC 1918 (private)
array( '172.16.0.0', '172.31.255.255' ), # "
array( '192.168.0.0', '192.168.255.255' ), # "
array( '0.0.0.0', '0.255.255.255' ), # this network
array( '127.0.0.0', '127.255.255.255' ), # loopback
);
}
foreach ( $privateRanges as $r ) {
$start = IP::toUnsigned( $r[0] );
$end = IP::toUnsigned( $r[1] );
if ( $n >= $start && $n <= $end ) {
return false;
}
}
return true;
}
/**
* Split out an IP block as an array of 4 bytes and a mask,
* return false if it cant be determined
*
* @parameter $ip string A quad dotted IP address
* @return array
*/
public static function toArray( $ipblock ) {
if(! preg_match( '/^' . RE_IP_ADD . '(?:\/(?:'.RE_IP_PREFIX.'))?' . '$/', $ipblock, $matches ) ) {
return false;
} else {
return $matches;
}
}
/**
* Return a zero-padded hexadecimal representation of an IP address.
*
* Hexadecimal addresses are used because they can easily be extended to
* IPv6 support. To separate the ranges, the return value from this
* function for an IPv6 address will be prefixed with "v6-", a non-
* hexadecimal string which sorts after the IPv4 addresses.
*
* @param $ip Quad dotted IP address.
*/
public static function toHex( $ip ) {
$n = self::toUnsigned( $ip );
if ( $n !== false ) {
$n = sprintf( '%08X', $n );
}
return $n;
}
/**
* Given an IP address in dotted-quad notation, returns an unsigned integer.
* Like ip2long() except that it actually works and has a consistent error return value.
* Comes from ProxyTools.php
* @param $ip Quad dotted IP address.
*/
public static function toUnsigned( $ip ) {
if ( $ip == '255.255.255.255' ) {
$n = -1;
} else {
$n = ip2long( $ip );
if ( $n == -1 || $n === false ) { # Return value on error depends on PHP version
$n = false;
}
}
if ( $n < 0 ) {
$n += pow( 2, 32 );
}
return $n;
}
/**
* Convert a dotted-quad IP to a signed integer
* Returns false on failure
*/
public static function toSigned( $ip ) {
if ( $ip == '255.255.255.255' ) {
$n = -1;
} else {
$n = ip2long( $ip );
if ( $n == -1 ) {
$n = false;
}
}
return $n;
}
/**
* Convert a network specification in CIDR notation to an integer network and a number of bits
*/
public static function parseCIDR( $range ) {
$parts = explode( '/', $range, 2 );
if ( count( $parts ) != 2 ) {
return array( false, false );
}
$network = IP::toSigned( $parts[0] );
if ( $network !== false && is_numeric( $parts[1] ) && $parts[1] >= 0 && $parts[1] <= 32 ) {
$bits = $parts[1];
if ( $bits == 0 ) {
$network = 0;
} else {
$network &= ~((1 << (32 - $bits)) - 1);
}
# Convert to unsigned
if ( $network < 0 ) {
$network += pow( 2, 32 );
}
} else {
$network = false;
$bits = false;
}
return array( $network, $bits );
}
/**
* Given a string range in a number of formats, return the start and end of
* the range in hexadecimal.
*
* Formats are:
* 1.2.3.4/24 CIDR
* 1.2.3.4 - 1.2.3.5 Explicit range
* 1.2.3.4 Single IP
*/
public static function parseRange( $range ) {
if ( strpos( $range, '/' ) !== false ) {
# CIDR
list( $network, $bits ) = IP::parseCIDR( $range );
if ( $network === false ) {
$start = $end = false;
} else {
$start = sprintf( '%08X', $network );
$end = sprintf( '%08X', $network + pow( 2, (32 - $bits) ) - 1 );
}
} elseif ( strpos( $range, '-' ) !== false ) {
# Explicit range
list( $start, $end ) = array_map( 'trim', explode( '-', $range, 2 ) );
if ( $start > $end ) {
$start = $end = false;
} else {
$start = IP::toHex( $start );
$end = IP::toHex( $end );
}
} else {
# Single IP
$start = $end = IP::toHex( $range );
}
if ( $start === false || $end === false ) {
return array( false, false );
} else {
return array( $start, $end );
}
}
}
?>
|
