Parse an IP Address: Difference between revisions

 

Taking the following as inputs:

|-

|127.0.0.1

|}

 

 

 

=={{header|C}}==

{{libheader|C standard library}}

#include <string.h>

#include <memory.h>

static unsigned int _parseDecimal ( const char** pchCursor )

{

 

}

 

static unsigned int _parseHex ( const char** pchCursor )

{

 

}

 

//Note: the binary address and integer port are in network order.

int ParseIPv4OrIPv6 ( const char** ppszText,

{

 

 

 

 

 

 

 

 

 

 

 

 

 

 

}

//simple version if we want don't care about knowing how much we ate

int ParseIPv4OrIPv6_2 ( const char* pszText,

{

}

Test:

#include <stdio.h>

 

unsigned short htons ( unsigned short us )

{

}

 

void dumpbin ( unsigned char* pbyBin, int nLen )

{

}

 

void testcase ( const char* pszTest )

{

 

}

 

int main ( int argc, char* argv[] )

{

}

 

Output:

</pre>

 

=={{header|Go}}==

 

import (

"fmt"

"net"

"strconv"

"strings"

)

 

}

if ip == nil {

}

}

 

func main() {

"127.0.0.1",

"127.0.0.1:80",

"::1",

"2605:2700:0:3::4713:93e3",

"[2605:2700:0:3::4713:93e3]:80",

}

}

for _, addr := range testCases {

if err != nil {

}

}

}

{{out}}

<pre>

[2605:2700:0:3::4713:93e3]:80 260527000000000300000000471393e3 IPv6 80

</pre>

 

=={{header|Haskell}}==

import Numeric (showHex)

import Data.Char (isDigit)

"2605:2700:0:3::4713:93e3", -- Rosetta Code

"[2605:2700:0:3::4713:93e3]:80"] -- Rosetta Code

Output:<pre>

IPv4 7f000001

 

=={{header|Icon}} and {{header|Unicon}}==

 

procedure main()

"::", # unspecified

"::ffff:192.168.0.1", # transition

"[2605:2700:0:3::4713:93e3]:80", # RC

"::ffff:71.19.147.227", # RC transition

}

}

 

{{libheader|Icon Programming Library}}

Implementation:

 

if. '.' e. y do.

if. +./'::' E. y do.

((#y){.'v';'addr';'port')=. y

'ipv',(":v),' ',(hfd addr),(#port)#' ',":port

 

Task examples:

 

ipv4 7f000001

fmt parseaddr '127.0.0.1:80'

ipv6 260527000000000300000000471393e3

fmt parseaddr '[2605:2700:0:3::4713:93e3]:80'

 

 

=={{header|Java}}==

import java.util.regex.Pattern;

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

{{out}}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

(de ipAddress (Adr)

(use (@A @B @C @D @Port)

(need (- 9 (length Lst)) 0) ) ) # Handle '::'

(cons (or (car Lst) "0") (cdr Lst)) ) )

Test:

(quote

"127.0.0.1"

(hex (car I))

(format (car I))

Output:

<pre style="height:8em;overflow:scroll">127.0.0.1 7F000001 2130706433

 

==PL/I==

/*********************************************************************

* Program to parse an IP address into --> IPv4 or IPv6 format

End;

 

Output:

<pre style="overflow:scroll">

 

=={{header|PowerShell}}==

function Get-IpAddress

{

}

}

Parse an array of IP addresses in a text format:

$ipAddresses = "127.0.0.1","127.0.0.1:80","::1","[::1]:80","2605:2700:0:3::4713:93e3","[2605:2700:0:3::4713:93e3]:80" | Get-IpAddress

$ipAddresses

{{Out}}

<pre>

</pre>

The '''Address''' "property" is an object containing more information...

$ipAddresses[5].Address

{{Out}}

<pre>

</pre>

... allowing for specific filtering:

$ipAddresses | where {$_.Address.AddressFamily -eq "InterNetworkV6" -and $_.Port -ne $null}

{{Out}}

<pre>

 

=={{header|Python}}==

{{libheader|pyparse}}

The following uses [http://pyparsing.wikispaces.com/ pyparse] to parse the IP address. It's an attempt at using pyparse to describe an IP address in an ''extended'' [[wp:Backus–Naur_Form|BNF syntax]]. Using a parser does seems a bit like using a sledgehammer to crack a nut. However it does make for an interesting alternative to using a [[Regular expression|regular expressions]] to parse IP addresses. Note - for example - that the parser specifically reports - as an exception - the location where the IP address is syntactically wrong.

from pyparsing import * # import antigravity

 

print ip, "IP Version:",ip.version,"- Address is OK!",

except (ParseException,ValueError), details: print "Bad! IP address syntax error detected:",details,

Output:

<pre>

 

=={{header|Racket}}==

#lang racket

 

"2605:2700:0:3::4713:93e3"

"[2605:2700:0:3::4713:93e3]:80"))

{{out}}

<pre>

[2605:2700:0:3::4713:93e3]:80 260527000000000300000000471393e3 ipv6 80

</pre>

 

=={{header|REXX}}==

call IP_parse '127.0.0.1:80'

call IP_parse '::1'

call IP_parse '2605:2700:0:3::4713:93e3'

call IP_parse '[2605:2700:0:3::4713:93e3]:80'

 

 

 

input IP address hex IP address decimal IP address space port

────────────────────────────── ──────────────────────────────── ─────────────────────────────────────── ───── ─────

</pre>

 

* 27.05.2013 Walter Pachl

**********************************************************************/

End

End

Output:

<pre style="overflow:scroll">

=={{header|Ruby}}==

 

 

"::1", "[::1]:80",

 

when /\A\[(?<address> .* )\]:(?<port> \d+ )\z/x # string like "[::1]:80"

address, port = $~[:address], $~[:port]

address, port = $~[:address], $~[:port]

else # string with no port number

end

 

end

 

 

 

 

 

 

 

 

=={{header|Tcl}}==

{{tcllib|ip}}

package require ip

 

set port -1

if {$family == -1} {

}

# Only possible error in ports is to be too large an integer

if {$port > 65535} {

}

dict set result family $family

if {$family == 4} {

} else {

}

# Return the descriptor dictionary

return $result

Demonstration code:

127.0.0.1

127.0.0.1:80

} {

if {[catch {

} msg]} {

}

dict with parsed {

}

Output:

<pre>

 

=={{header|VBScript}}==

End Function

 

'Testing the function

ip_arr = Array("127.0.0.1","127.0.0.1:80","::1",_

 

For n = 0 To UBound(ip_arr)

 

{{Out}}

Test Case: RosettaCode

Address: Invalid Address