Parse an IP Address: Difference between revisions

space that   '''127.0.0.1'''   serves in the ipv4 address space.

<br><br>

 

=={{header|C}}==

{{libheader|C standard library}}

#include <string.h>

#include <memory.h>

return ParseIPv4OrIPv6 ( &pszTextLocal, abyAddr, pnPort, pbIsIPv6);

}

Test:

#include <stdio.h>

 

return 0;

}

 

Output:

to parse IP addresses. This approach will also work on Microsoft Windows with some

minor changes.

#include <stdbool.h>

#include <stdio.h>

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

return 0;

 

{{out}}

address: 260527000000000300000000471393E3

port: 80

 

</pre>

=={{header|C++}}==

{{libheader|Boost}}

#include <cstdint>

#include <iostream>

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

return 0;

 

{{out}}

</pre>

 

=={{header|Go}}==

 

import (

)

 

}

 

func main() {

{{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()

}

}

 

{{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.Matcher;

import java.util.regex.Pattern;

 

}

{{out}}

<pre>

2001:db8:85a3:0:0:8a2e:370:7334 20010db885a3000000008a2e03707334

</pre>

 

=={{header|Julia}}==

const testdata = ["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",

println("For input $ip, IP in hex is $hx, address space $add, port $por.")

end

{{output}}

<pre>

 

=={{header|Kotlin}}==

 

import java.math.BigInteger

println()

}

 

{{out}}

Port : 0

</pre>

 

=={{header|Perl}}==

my ($ip, $port) = @_;

my @quad = split(/\./, $ip);

 

print "$ver $ip\tport $port\n\n";

v4 7f000001 port -1

 

parse error

a::b::1

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

 

=={{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>

===Python: Using ipaddress===

{{works with|Python|3.5}}

from urllib.parse import urlparse

 

hex_ip = {4:'{:08X}', 6:'{:032X}'}[ip.version].format(int(ip))

print("{:39s} {:>32s} IPv{} port={}".format(

 

{{out}}

{{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>

=={{header|Raku}}==

(formerly Perl 6)

token TOP { ^ [ <IPv4> | <IPv6> ] $ }

token IPv4 {

[ <d8> +% '.' ] <?{ $<d8> == 4 }> <port>?

| <h16> +% ':' <?{ $<h16> == 8 }>

{ @*by16 = @$<h16> }

| [ (<h16>) +% ':']? '::' [ (<h16>) +% ':' ]? <?{ @$0 + @$1 ≤ 8 }>

{ @*by16 = |@$0, |('0' xx 8 - (@$0 + @$1)), |@$1 }

| '::ffff:' <IPv4>

{ @*by16 = |('0' xx 5), 'ffff', |(by8to16 @*by8) }

token d8 { (\d+) <?{ $0 < 256 }> }

token d16 { (\d+) <?{ $0 < 65536 }> }

 

token port {

}

say '';

{{out}}

<pre>127.0.0.1

the &nbsp; '''parse''' &nbsp; instruction for this purpose.

=== version 1 ===

_= "_"; say center('input IP address' , 30),

center('hex IP address' , 32),

 

say left(a,30) right(hx,32) right(x2d(hx),39) ' IPv' || (6-2*dot) right(port,5)

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

 

=== version 2 ===

* 27.05.2013 Walter Pachl

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

End

End

Output:

<pre style="overflow:scroll">

=={{header|Ruby}}==

 

 

end

 

{{Output}}

<pre> String Address Port Family Hex

 

=={{header|Rust}}==

net::{IpAddr, SocketAddr},

str::FromStr,

.cloned()

.for_each(print_addr);

 

=={{header|Scala}}==

===Full blown ultimate solution===

{{Out}}Best seen running in your browser [https://scastie.scala-lang.org/kWO8C5pLSu6xEQ0kHAlswg Scastie (remote JVM)].

 

/*

}

 

 

=={{header|Tcl}}==

{{tcllib|ip}}

package require ip

 

# Return the descriptor dictionary

return $result

Demonstration code:

127.0.0.1

127.0.0.1:80

puts ""

}

Output:

<pre>

 

=={{header|VBScript}}==

'ipv4 pattern

Set ipv4_pattern = New RegExp

For n = 0 To UBound(ip_arr)

WScript.StdOut.Write parse_ip(ip_arr(n)) & vbCrLf

 

{{Out}}

Test Case: RosettaCode

Address: Invalid Address

</pre>