Spaces:
Sleeping
Sleeping
| const v4Regex = /^(\d{1,3}\.){3,3}\d{1,3}$/ | |
| const v4Size = 4 | |
| const v6Regex = /^(::)?(((\d{1,3}\.){3}(\d{1,3}){1})?([0-9a-f]){0,4}:{0,2}){1,8}(::)?$/i | |
| const v6Size = 16 | |
| export const v4 = { | |
| name: 'v4', | |
| size: v4Size, | |
| isFormat: ip => v4Regex.test(ip), | |
| encode (ip, buff, offset) { | |
| offset = ~~offset | |
| buff = buff || new Uint8Array(offset + v4Size) | |
| const max = ip.length | |
| let n = 0 | |
| for (let i = 0; i < max;) { | |
| const c = ip.charCodeAt(i++) | |
| if (c === 46) { // "." | |
| buff[offset++] = n | |
| n = 0 | |
| } else { | |
| n = n * 10 + (c - 48) | |
| } | |
| } | |
| buff[offset] = n | |
| return buff | |
| }, | |
| decode (buff, offset) { | |
| offset = ~~offset | |
| return `${buff[offset++]}.${buff[offset++]}.${buff[offset++]}.${buff[offset]}` | |
| } | |
| } | |
| export const v6 = { | |
| name: 'v6', | |
| size: v6Size, | |
| isFormat: ip => ip.length > 0 && v6Regex.test(ip), | |
| encode (ip, buff, offset) { | |
| offset = ~~offset | |
| let end = offset + v6Size | |
| let fill = -1 | |
| let hexN = 0 | |
| let decN = 0 | |
| let prevColon = true | |
| let useDec = false | |
| buff = buff || new Uint8Array(offset + v6Size) | |
| // Note: This algorithm needs to check if the offset | |
| // could exceed the buffer boundaries as it supports | |
| // non-standard compliant encodings that may go beyond | |
| // the boundary limits. if (offset < end) checks should | |
| // not be necessary... | |
| for (let i = 0; i < ip.length; i++) { | |
| let c = ip.charCodeAt(i) | |
| if (c === 58) { // : | |
| if (prevColon) { | |
| if (fill !== -1) { | |
| // Not Standard! (standard doesn't allow multiple ::) | |
| // We need to treat | |
| if (offset < end) buff[offset] = 0 | |
| if (offset < end - 1) buff[offset + 1] = 0 | |
| offset += 2 | |
| } else if (offset < end) { | |
| // :: in the middle | |
| fill = offset | |
| } | |
| } else { | |
| // : ends the previous number | |
| if (useDec === true) { | |
| // Non-standard! (ipv4 should be at end only) | |
| // A ipv4 address should not be found anywhere else but at | |
| // the end. This codec also support putting characters | |
| // after the ipv4 address.. | |
| if (offset < end) buff[offset] = decN | |
| offset++ | |
| } else { | |
| if (offset < end) buff[offset] = hexN >> 8 | |
| if (offset < end - 1) buff[offset + 1] = hexN & 0xff | |
| offset += 2 | |
| } | |
| hexN = 0 | |
| decN = 0 | |
| } | |
| prevColon = true | |
| useDec = false | |
| } else if (c === 46) { // . indicates IPV4 notation | |
| if (offset < end) buff[offset] = decN | |
| offset++ | |
| decN = 0 | |
| hexN = 0 | |
| prevColon = false | |
| useDec = true | |
| } else { | |
| prevColon = false | |
| if (c >= 97) { | |
| c -= 87 // a-f ... 97~102 -87 => 10~15 | |
| } else if (c >= 65) { | |
| c -= 55 // A-F ... 65~70 -55 => 10~15 | |
| } else { | |
| c -= 48 // 0-9 ... starting from charCode 48 | |
| decN = decN * 10 + c | |
| } | |
| // We don't know yet if its a dec or hex number | |
| hexN = (hexN << 4) + c | |
| } | |
| } | |
| if (prevColon === false) { | |
| // Commiting last number | |
| if (useDec === true) { | |
| if (offset < end) buff[offset] = decN | |
| offset++ | |
| } else { | |
| if (offset < end) buff[offset] = hexN >> 8 | |
| if (offset < end - 1) buff[offset + 1] = hexN & 0xff | |
| offset += 2 | |
| } | |
| } else if (fill === 0) { | |
| // Not Standard! (standard doesn't allow multiple ::) | |
| // This means that a : was found at the start AND end which means the | |
| // end needs to be treated as 0 entry... | |
| if (offset < end) buff[offset] = 0 | |
| if (offset < end - 1) buff[offset + 1] = 0 | |
| offset += 2 | |
| } else if (fill !== -1) { | |
| // Non-standard! (standard doens't allow multiple ::) | |
| // Here we find that there has been a :: somewhere in the middle | |
| // and the end. To treat the end with priority we need to move all | |
| // written data two bytes to the right. | |
| offset += 2 | |
| for (let i = Math.min(offset - 1, end - 1); i >= fill + 2; i--) { | |
| buff[i] = buff[i - 2] | |
| } | |
| buff[fill] = 0 | |
| buff[fill + 1] = 0 | |
| fill = offset | |
| } | |
| if (fill !== offset && fill !== -1) { | |
| // Move the written numbers to the end while filling the everything | |
| // "fill" to the bytes with zeros. | |
| if (offset > end - 2) { | |
| // Non Standard support, when the cursor exceeds bounds. | |
| offset = end - 2 | |
| } | |
| while (end > fill) { | |
| buff[--end] = offset < end && offset > fill ? buff[--offset] : 0 | |
| } | |
| } else { | |
| // Fill the rest with zeros | |
| while (offset < end) { | |
| buff[offset++] = 0 | |
| } | |
| } | |
| return buff | |
| }, | |
| decode (buff, offset) { | |
| offset = ~~offset | |
| let result = '' | |
| for (let i = 0; i < v6Size; i += 2) { | |
| if (i !== 0) { | |
| result += ':' | |
| } | |
| result += (buff[offset + i] << 8 | buff[offset + i + 1]).toString(16) | |
| } | |
| return result | |
| .replace(/(^|:)0(:0)*:0(:|$)/, '$1::$3') | |
| .replace(/:{3,4}/, '::') | |
| } | |
| } | |
| export const name = 'ip' | |
| export function sizeOf (ip) { | |
| if (v4.isFormat(ip)) return v4.size | |
| if (v6.isFormat(ip)) return v6.size | |
| throw Error(`Invalid ip address: ${ip}`) | |
| } | |
| export function familyOf (string) { | |
| return sizeOf(string) === v4.size ? 1 : 2 | |
| } | |
| export function encode (ip, buff, offset) { | |
| offset = ~~offset | |
| const size = sizeOf(ip) | |
| if (typeof buff === 'function') { | |
| buff = buff(offset + size) | |
| } | |
| if (size === v4.size) { | |
| return v4.encode(ip, buff, offset) | |
| } | |
| return v6.encode(ip, buff, offset) | |
| } | |
| export function decode (buff, offset, length) { | |
| offset = ~~offset | |
| length = length || (buff.length - offset) | |
| if (length === v4.size) { | |
| return v4.decode(buff, offset, length) | |
| } | |
| if (length === v6.size) { | |
| return v6.decode(buff, offset, length) | |
| } | |
| throw Error(`Invalid buffer size needs to be ${v4.size} for v4 or ${v6.size} for v6.`) | |
| } | |