1# Define the main object
  2ipaddr = {}
  3
  4root = this
  5
  6# Export for both the CommonJS and browser-like environment
  7if module? && module.exports
  8  module.exports = ipaddr
  9else
 10  root['ipaddr'] = ipaddr
 11
 12# A generic CIDR (Classless Inter-Domain Routing) RFC1518 range matcher.
 13matchCIDR = (first, second, partSize, cidrBits) ->
 14  if first.length != second.length
 15    throw new Error "ipaddr: cannot match CIDR for objects with different lengths"
 16
 17  part = 0
 18  while cidrBits > 0
 19    shift = partSize - cidrBits
 20    shift = 0 if shift < 0
 21
 22    if first[part] >> shift != second[part] >> shift
 23      return false
 24
 25    cidrBits -= partSize
 26    part     += 1
 27
 28  return true
 29
 30# An utility function to ease named range matching. See examples below.
 31ipaddr.subnetMatch = (address, rangeList, defaultName='unicast') ->
 32  for rangeName, rangeSubnets of rangeList
 33    # ECMA5 Array.isArray isn't available everywhere
 34    if rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)
 35      rangeSubnets = [ rangeSubnets ]
 36
 37    for subnet in rangeSubnets
 38      return rangeName if address.match.apply(address, subnet)
 39
 40  return defaultName
 41
 42# An IPv4 address (RFC791).
 43class ipaddr.IPv4
 44  # Constructs a new IPv4 address from an array of four octets.
 45  # Verifies the input.
 46  constructor: (octets) ->
 47    if octets.length != 4
 48      throw new Error "ipaddr: ipv4 octet count should be 4"
 49
 50    for octet in octets
 51      if !(0 <= octet <= 255)
 52        throw new Error "ipaddr: ipv4 octet is a byte"
 53
 54    @octets = octets
 55
 56  # The 'kind' method exists on both IPv4 and IPv6 classes.
 57  kind: ->
 58    return 'ipv4'
 59
 60  # Returns the address in convenient, decimal-dotted format.
 61  toString: ->
 62    return @octets.join "."
 63
 64  # Returns an array of byte-sized values in network order
 65  toByteArray: ->
 66    return @octets.slice(0) # octets.clone
 67
 68  # Checks if this address matches other one within given CIDR range.
 69  match: (other, cidrRange) ->
 70    if cidrRange == undefined
 71      [other, cidrRange] = other
 72
 73    if other.kind() != 'ipv4'
 74      throw new Error "ipaddr: cannot match ipv4 address with non-ipv4 one"
 75
 76    return matchCIDR(this.octets, other.octets, 8, cidrRange)
 77
 78  # Special IPv4 address ranges.
 79  SpecialRanges:
 80    unspecified: [
 81      [ new IPv4([0,     0,    0,   0]),  8 ]
 82    ]
 83    broadcast: [
 84      [ new IPv4([255, 255,  255, 255]), 32 ]
 85    ]
 86    multicast: [ # RFC3171
 87      [ new IPv4([224,   0,    0,   0]), 4  ]
 88    ]
 89    linkLocal: [ # RFC3927
 90      [ new IPv4([169,   254,  0,   0]), 16 ]
 91    ]
 92    loopback: [ # RFC5735
 93      [ new IPv4([127,   0,    0,   0]), 8  ]
 94    ]
 95    private: [ # RFC1918
 96      [ new IPv4([10,    0,    0,   0]), 8  ]
 97      [ new IPv4([172,   16,   0,   0]), 12 ]
 98      [ new IPv4([192,   168,  0,   0]), 16 ]
 99    ]
100    reserved: [ # Reserved and testing-only ranges; RFCs 5735, 5737, 2544, 1700
101      [ new IPv4([192,   0,    0,   0]), 24 ]
102      [ new IPv4([192,   0,    2,   0]), 24 ]
103      [ new IPv4([192,  88,   99,   0]), 24 ]
104      [ new IPv4([198,  51,  100,   0]), 24 ]
105      [ new IPv4([203,   0,  113,   0]), 24 ]
106      [ new IPv4([240,   0,    0,   0]), 4  ]
107    ]
108
109  # Checks if the address corresponds to one of the special ranges.
110  range: ->
111    return ipaddr.subnetMatch(this, @SpecialRanges)
112
113  # Convrets this IPv4 address to an IPv4-mapped IPv6 address.
114  toIPv4MappedAddress: ->
115    return ipaddr.IPv6.parse "::ffff:#{@toString()}"
116
117# A list of regular expressions that match arbitrary IPv4 addresses,
118# for which a number of weird notations exist.
119# Note that an address like 0010.0xa5.1.1 is considered legal.
120ipv4Part = "(0?\\d+|0x[a-f0-9]+)"
121ipv4Regexes =
122  fourOctet: new RegExp "^#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}$", 'i'
123  longValue: new RegExp "^#{ipv4Part}$", 'i'
124
125# Classful variants (like a.b, where a is an octet, and b is a 24-bit
126# value representing last three octets; this corresponds to a class C
127# address) are omitted due to classless nature of modern Internet.
128ipaddr.IPv4.parser = (string) ->
129  parseIntAuto = (string) ->
130    if string[0] == "0" && string[1] != "x"
131      parseInt(string, 8)
132    else
133      parseInt(string)
134
135  # parseInt recognizes all that octal & hexadecimal weirdness for us
136  if match = string.match(ipv4Regexes.fourOctet)
137    return (parseIntAuto(part) for part in match[1..5])
138  else if match = string.match(ipv4Regexes.longValue)
139    value = parseIntAuto(match[1])
140    if value > 0xffffffff || value < 0
141      throw new Error "ipaddr: address outside defined range"
142    return ((value >> shift) & 0xff for shift in [0..24] by 8).reverse()
143  else
144    return null
145
146# An IPv6 address (RFC2460)
147class ipaddr.IPv6
148  # Constructs an IPv6 address from an array of eight 16-bit parts.
149  # Throws an error if the input is invalid.
150  constructor: (parts) ->
151    if parts.length != 8
152      throw new Error "ipaddr: ipv6 part count should be 8"
153
154    for part in parts
155      if !(0 <= part <= 0xffff)
156        throw new Error "ipaddr: ipv6 part should fit to two octets"
157
158    @parts = parts
159
160  # The 'kind' method exists on both IPv4 and IPv6 classes.
161  kind: ->
162    return 'ipv6'
163
164  # Returns the address in compact, human-readable format like
165  # 2001:db8:8:66::1
166  toString: ->
167    stringParts = (part.toString(16) for part in @parts)
168
169    compactStringParts = []
170    pushPart = (part) -> compactStringParts.push part
171
172    state = 0
173    for part in stringParts
174      switch state
175        when 0
176          if part == '0'
177            pushPart('')
178          else
179            pushPart(part)
180
181          state = 1
182        when 1
183          if part == '0'
184            state = 2
185          else
186            pushPart(part)
187        when 2
188          unless part == '0'
189            pushPart('')
190            pushPart(part)
191            state = 3
192        when 3
193          pushPart(part)
194
195    if state == 2
196      pushPart('')
197      pushPart('')
198
199    return compactStringParts.join ":"
200
201  # Returns an array of byte-sized values in network order
202  toByteArray: ->
203    bytes = []
204    for part in @parts
205      bytes.push(part >> 8)
206      bytes.push(part & 0xff)
207
208    return bytes
209
210  # Returns the address in expanded format with all zeroes included, like
211  # 2001:db8:8:66:0:0:0:1
212  toNormalizedString: ->
213    return (part.toString(16) for part in @parts).join ":"
214
215  # Checks if this address matches other one within given CIDR range.
216  match: (other, cidrRange) ->
217    if cidrRange == undefined
218      [other, cidrRange] = other
219
220    if other.kind() != 'ipv6'
221      throw new Error "ipaddr: cannot match ipv6 address with non-ipv6 one"
222
223    return matchCIDR(this.parts, other.parts, 16, cidrRange)
224
225  # Special IPv6 ranges
226  SpecialRanges:
227    unspecified: [ new IPv6([0,      0,      0, 0, 0,      0,      0, 0]), 128 ] # RFC4291, here and after
228    linkLocal:   [ new IPv6([0xfe80, 0,      0, 0, 0,      0,      0, 0]), 10  ]
229    multicast:   [ new IPv6([0xff00, 0,      0, 0, 0,      0,      0, 0]), 8   ]
230    loopback:    [ new IPv6([0,      0,      0, 0, 0,      0,      0, 1]), 128 ]
231    uniqueLocal: [ new IPv6([0xfc00, 0,      0, 0, 0,      0,      0, 0]), 7   ]
232    ipv4Mapped:  [ new IPv6([0,      0,      0, 0, 0,      0xffff, 0, 0]), 96  ]
233    rfc6145:     [ new IPv6([0,      0,      0, 0, 0xffff, 0,      0, 0]), 96  ] # RFC6145
234    rfc6052:     [ new IPv6([0x64,   0xff9b, 0, 0, 0,      0,      0, 0]), 96  ] # RFC6052
235    '6to4':      [ new IPv6([0x2002, 0,      0, 0, 0,      0,      0, 0]), 16  ] # RFC3056
236    teredo:      [ new IPv6([0x2001, 0,      0, 0, 0,      0,      0, 0]), 32  ] # RFC6052, RFC6146
237    reserved: [
238      [ new IPv6([ 0x2001, 0xdb8, 0, 0, 0, 0, 0, 0]), 32 ] # RFC4291
239    ]
240
241  # Checks if the address corresponds to one of the special ranges.
242  range: ->
243    return ipaddr.subnetMatch(this, @SpecialRanges)
244
245  # Checks if this address is an IPv4-mapped IPv6 address.
246  isIPv4MappedAddress: ->
247    return @range() == 'ipv4Mapped'
248
249  # Converts this address to IPv4 address if it is an IPv4-mapped IPv6 address.
250  # Throws an error otherwise.
251  toIPv4Address: ->
252    unless @isIPv4MappedAddress()
253      throw new Error "ipaddr: trying to convert a generic ipv6 address to ipv4"
254
255    [high, low] = @parts[-2..-1]
256
257    return new ipaddr.IPv4([high >> 8, high & 0xff, low >> 8, low & 0xff])
258
259# IPv6-matching regular expressions.
260# For IPv6, the task is simpler: it is enough to match the colon-delimited
261# hexadecimal IPv6 and a transitional variant with dotted-decimal IPv4 at
262# the end.
263ipv6Part = "(?:[0-9a-f]+::?)+"
264ipv6Regexes =
265  native:       new RegExp "^(::)?(#{ipv6Part})?([0-9a-f]+)?(::)?$", 'i'
266  transitional: new RegExp "^((?:#{ipv6Part})|(?:::)(?:#{ipv6Part})?)" +
267                           "#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}\\.#{ipv4Part}$", 'i'
268
269# Expand :: in an IPv6 address or address part consisting of `parts` groups.
270expandIPv6 = (string, parts) ->
271  # More than one '::' means invalid adddress
272  if string.indexOf('::') != string.lastIndexOf('::')
273    return null
274
275  # How many parts do we already have?
276  colonCount = 0
277  lastColon = -1
278  while (lastColon = string.indexOf(':', lastColon + 1)) >= 0
279    colonCount++
280
281  # 0::0 is two parts more than ::
282  colonCount-- if string.substr(0, 2) == '::'
283  colonCount-- if string.substr(-2, 2) == '::'
284
285  # The following loop would hang if colonCount > parts
286  if colonCount > parts
287    return null
288
289  # replacement = ':' + '0:' * (parts - colonCount)
290  replacementCount = parts - colonCount
291  replacement = ':'
292  while replacementCount--
293    replacement += '0:'
294
295  # Insert the missing zeroes
296  string = string.replace('::', replacement)
297
298  # Trim any garbage which may be hanging around if :: was at the edge in
299  # the source string
300  string = string[1..-1] if string[0] == ':'
301  string = string[0..-2] if string[string.length-1] == ':'
302
303  return (parseInt(part, 16) for part in string.split(":"))
304
305# Parse an IPv6 address.
306ipaddr.IPv6.parser = (string) ->
307  if string.match(ipv6Regexes['native'])
308    return expandIPv6(string, 8)
309
310  else if match = string.match(ipv6Regexes['transitional'])
311    parts = expandIPv6(match[1][0..-2], 6)
312    if parts
313      parts.push(parseInt(match[2]) << 8 | parseInt(match[3]))
314      parts.push(parseInt(match[4]) << 8 | parseInt(match[5]))
315      return parts
316
317  return null
318
319# Checks if a given string is formatted like IPv4/IPv6 address.
320ipaddr.IPv4.isIPv4 = ipaddr.IPv6.isIPv6 = (string) ->
321  return @parser(string) != null
322
323# Checks if a given string is a valid IPv4/IPv6 address.
324ipaddr.IPv4.isValid = (string) ->
325  try
326    new this(@parser(string))
327    return true
328  catch e
329    return false
330
331ipaddr.IPv6.isValid = (string) ->
332  # Since IPv6.isValid is always called first, this shortcut
333  # provides a substantial performance gain.
334  if typeof string == "string" and string.indexOf(":") == -1
335    return false
336
337  try
338    new this(@parser(string))
339    return true
340  catch e
341    return false
342
343# Tries to parse and validate a string with IPv4/IPv6 address.
344# Throws an error if it fails.
345ipaddr.IPv4.parse = ipaddr.IPv6.parse = (string) ->
346  parts = @parser(string)
347  if parts == null
348    throw new Error "ipaddr: string is not formatted like ip address"
349
350  return new this(parts)
351
352ipaddr.IPv4.parseCIDR = (string) ->
353  if match = string.match(/^(.+)\/(\d+)$/)
354    maskLength = parseInt(match[2])
355    if maskLength >= 0 and maskLength <= 32
356      return [@parse(match[1]), maskLength]
357
358  throw new Error "ipaddr: string is not formatted like an IPv4 CIDR range"
359
360ipaddr.IPv6.parseCIDR = (string) ->
361  if match = string.match(/^(.+)\/(\d+)$/)
362    maskLength = parseInt(match[2])
363    if maskLength >= 0 and maskLength <= 128
364      return [@parse(match[1]), maskLength]
365
366  throw new Error "ipaddr: string is not formatted like an IPv6 CIDR range"
367
368# Checks if the address is valid IP address
369ipaddr.isValid = (string) ->
370  return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string)
371
372# Try to parse an address and throw an error if it is impossible
373ipaddr.parse = (string) ->
374  if ipaddr.IPv6.isValid(string)
375    return ipaddr.IPv6.parse(string)
376  else if ipaddr.IPv4.isValid(string)
377    return ipaddr.IPv4.parse(string)
378  else
379    throw new Error "ipaddr: the address has neither IPv6 nor IPv4 format"
380
381ipaddr.parseCIDR = (string) ->
382  try
383    return ipaddr.IPv6.parseCIDR(string)
384  catch e
385    try
386      return ipaddr.IPv4.parseCIDR(string)
387    catch e
388      throw new Error "ipaddr: the address has neither IPv6 nor IPv4 CIDR format"
389
390# Parse an address and return plain IPv4 address if it is an IPv4-mapped address
391ipaddr.process = (string) ->
392  addr = @parse(string)
393  if addr.kind() == 'ipv6' && addr.isIPv4MappedAddress()
394    return addr.toIPv4Address()
395  else
396    return addr