Canonicalize CIDR: Difference between revisions

{{trans|C}}

V (addr_str, m_str) = str.split(‘/’)

V (a, b, c, d) = addr_str.split(‘.’).map(Int)

‘184.232.176.184/18’]

V (address, mask_length) = cidr_parse(test)

{{out}}

=={{header|ALGOL 68}}==

# mode to hold an IPv4 address in CIDR notation #

MODE CIDR = STRUCT( BITS address

FI

OD

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

nums←(2⊃⎕VFI)¨(~⍵∊'./')⊆⍵

ip len←(4↑nums)(5⊃nums)

ip←(4/256)⊤2⊥ip

(1↓∊'.',¨⍕¨ip),'/',⍕len

{{out}}

=={{header|C}}==

This solution uses only the standard library. On POSIX platforms one can use the functions

inet_pton/inet_ntop to parse/format IPv4 addresses.

#include <stdio.h>

#include <stdint.h>

}

return 0;

{{out}}

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

#include <iomanip>

#include <iostream>

}

return 0;

{{out}}

=={{header|C sharp|C#}}==

using System.Net;

using System.Linq;

public override string ToString() => $"{ip}/{length}";

{{out}}

<pre>

=={{header|Commodore BASIC}}==

110 REM SO WE STORE THE IP ADDRESS AS AN ARRAY OF FOUR OCTETS

120 DIM IP(3)

520 REM SOME INVALID INPUTS

530 DATA 127.0.0.1, 123.45.67.89/0, 98.76.54.32/100, 123.456.789.0/12

{{Out}}<pre>READY.

READY.</pre>

=={{header|Common Lisp}}==

(flet ((int->bits (int)

(loop :for i :below 8

:for ccidr := (canonicalize-cidr cidr)

:do (format t "~&~A~20,T→ ~A~%" cidr ccidr))

{{out}}

<pre>

=={{header|Cowgol}}==

typedef IP is uint32;

print(" After canonicalization: ");

print(string);

{{out}}

<pre>Before canonicalization: 87.70.141.1/22

{{trans|Ruby}}

{{works with|Factor|0.99 2020-07-03}}

namespaces prettyprint sequences splitting ;

IN: rosetta-code.canonicalize-cidr

! and output

"%s/%d\n" printf

{{out}}

<pre>

=={{header|Go}}==

{{trans|Ruby}}

import (

fmt.Printf("%-18s -> %s\n", test, canonicalize(test))

}

{{out}}

=={{header|Hare}}==

use net::ip;

use strings;

0xff & result,

strings::cut(a, "/").1);

{{out}}

<pre>

=={{header|Haskell}}==

This is implemented using only libraries found in the base package.

import Data.Bits ((.|.), (.&.), complement, shiftL, shiftR, zeroBits)

import Data.Maybe (listToMaybe)

test "184.256.176.184/12" -- octet value is too large

test "184.232.176.184/33" -- netmask size is too large

{{out}}

Implementation:

'a e'=. 0 ".each (y rplc'. ')-.&;:'/'

('/',":e),~rplc&' .'":_8#.\32{.e{.,(8#2)#:a

In other words, convert address part to bits, truncate to the network address, extend back to 32 bits and repack into the ascii representation.

Task examples:

87.70.140.0/22

cidr '36.18.154.103/12'

161.214.74.0/24

cidr '184.232.176.184/18'

=={{header|Java}}==

import java.text.ParseException;

"184.232.176.184/18"

};

{{out}}

=={{header|JavaScript}}==

// Prepare a DataView over a 16 Byte Array buffer.

'10..55/8',

'10.../8'

{{out}}

<pre>

=={{header|Julia}}==

Julia has a Sockets library as a builtin, which has the types IPv4 and IPv6 for single IP addresses.

function canonCIDR(cidr::String)

println(canonCIDR("10..55/8"))

println(canonCIDR("10.../8"))

<pre>

87.70.140.0/22

=={{header|Lua}}==

{{libheader|inet}}

test_cases = {

for i, cidr in ipairs(test_cases) do

print( inet(cidr):network() )

{{Out}}

=={{header|Mathematica}}/{{header|Wolfram Language}}==

CanonicalizeCIDR[str_String] := Module[{i, ip, chop, keep, change},

If[StringMatchQ[str, "*.*.*.*/*"],

CanonicalizeCIDR["67.137.119.181/4"]

CanonicalizeCIDR["161.214.74.21/24"]

{{out}}

<pre>87.70.140.0/22

=={{header|Nim}}==

Using the IpAddress type from standard module “net”.

import strutils

# Canonicalize the address and display the result.

ipAddress.canonicalize(nbits)

{{out}}

=={{header|Perl}}==

There's a CPAN module for IP address manipulation, <tt>Net::IP</tt>. Unfortunately, it requires a CIDR string to be already in canonical form; otherwise it fails with an "Invalid prefix" error. So we do it manually.

use v5.16;

use Socket qw(inet_aton inet_ntoa);

# And output

say "$dotted/$size";

{{Out}}

<pre>$ canonicalize_cidr.pl 87.70.141.1/22

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> <span style="color: #000080;font-style:italic;">-- (not likely useful)</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">canonicalize_cidr</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">cidr</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%-18s -&gt; %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">,</span><span style="color: #000000;">canonicalize_cidr</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">)})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|PicoLisp}}==

(let

(L (rot (mapcar format (split (chop S) "." "/")))

"161.214.74.21/24"

"184.232.176.184/18" )

{{out}}

<pre>

=={{header|Python}}==

{{trans|Perl}}

# canonicalize a CIDR block specification:

# make sure none of the host bits are set

canon_dotted = inet_ntoa(pack('!I',

(canon_numeric))) # and then to dotted-decimal

{{Out}}

<pre>$ canonicalize_cidr.py 87.70.141.1/22

===Bit mask and shift===

DIGITS = (24, 16, 8, 0)

print(f"{ip:<18} -> {rv}")

assert rv == expect

{{out}}

The <code>ipaddress</code> module was added in Python version 3.3.

def canonicalize(address: str) -> str:

print(f"{ip:<18} -> {rv}")

assert rv == expect, expect

{{out}}

===Using library===

{{libheader|raku-IP-Addr}}

for «87.70.141.1/22 36.18.154.103/12 62.62.197.11/29 67.137.119.181/4 161.214.74.21/24 184.232.176.184/18» -> $cidr {

say "$cidr -> $(IP::Addr.new($cidr).network)";

===String manipulation===

{{trans|Perl}}

unit sub MAIN(*@cidrs);

# And output

say "$canon/$size";

{{Out}}

===Bit mask and shift===

sub CIDR-IP4-canonicalize ($address) {

constant @mask = 24, 16, 8, 0;

printf "CIDR: %18s Routing prefix: %s/%s\n", $_, |.&CIDR-IP4-canonicalize

{{out}}

<pre>CIDR: 87.70.141.1/22 Routing prefix: 87.70.140.0/22

=={{header|REXX}}==

parse arg a . /*obtain optional argument from the CL.*/

if a=='' | a=="," then a= '87.70.141.1/22' , /*Not specified? Then use the defaults*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

b2d: return x2d( b2x( arg(1) ) ) + 0 /*convert binary ───► decimal number.*/

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

<pre>

{{trans|Raku}}

# canonicalize a CIDR block: make sure none of the host bits are set

# And output

puts "#{canon}/#{size}"

{{Out}}

87.70.140.0/22</pre>

===Built in===

require "ipaddr"

puts "#{ia}/#{ia.prefix}"

end

{{out}}

<pre>

=={{header|Rust}}==

fn canonical_cidr(cidr: &str) -> Result<String, &str> {

fn main() {

println!("{}", canonical_cidr("127.1.2.3/24").unwrap());

=={{header|SNOBOL}}==

D = SPAN('0123456789')

OUTPUT = FIXCIDR('161.214.74.21/24')

OUTPUT = FIXCIDR('184.232.176.184/18')

{{Out}}

{{works with|Korn Shell}}

{{works with|Zsh}}

typeset -i addr byte

typeset -a bytes

set -- 36.18.154.103/12 62.62.197.11/29 67.137.119.181/4 161.214.74.21/24 184.232.176.184/18

fi

{{Out}}

<pre>36.16.0.0/12

{{libheader|Wren-fmt}}

{{libheader|Wren-str}}

import "/str" for Str

for (test in tests) {

Fmt.print("$-18s -> $s", test, canonicalize.call(test))

{{out}}