10 Networking

8.16.0.4

10 Networking🔗ℹ

10.1 Network Addresses🔗ℹ

(require scramble/net/addr)

package: scramble-lib

Added in version 0.4 of package scramble-lib.

10.1.1 IPv4 Addresses🔗ℹ

struct
(struct ip4 (number))
number : ip4-number?

Represents an IPv4 internet address.

The ip4 constructor can be given any ip4-in/c value, but the address is converted to a 32-bit unsigned integer for storage.

Instances of the ip4 structure use the string form of address for printing.

Examples:

> (ip4 #x7F000001)
(ip4 "127.0.0.1")
> (ip4 '(11 22 33 44))
(ip4 "11.22.33.44")

value
ip4-in/c : flat-contract?
= (or/c ip4? ip4-number? ip4-bytes? ip4-string? ip4-list?)

Contract for values that can be interpreted as IPv4 addresses.

procedure
(ip4-number? v) → boolean?
v : any/c

Accepts any 32-bit unsigned integer. Equivalent to uint32?.

procedure
(ip4-bytes? v) → boolean?
v : any/c

Accepts any byte string of four bytes. It is intepreted as an IPv4 address number in network byte order (big-endian).

procedure
(ip4-string? v) → boolean?
v : any/c

Accepts strings containing the “dotted-decimal” notation for IPv4 addresses.

Examples:

> (ip4-string? "127.0.0.1")
#t
> (ip4-string? "12.34.56.789") ; last component out of range
#f
> (ip4-string? "11.22.3.4.56") ; too many components
#f

procedure
(ip4-list? v) → boolean?
v : any/c

Accepts any list of four uint8? values.

Example:

> (ip4-list? '(127 0 0 1))
#t

procedure
(ip4->number addr) → ip4-number?
  addr : ip4-in/c
procedure
(ip4->bytes addr) → ip4-bytes?
  addr : ip4-in/c
procedure
(ip4->string addr) → ip4-string?
  addr : ip4-in/c
procedure
(ip4->list addr) → ip4-list
  addr : ip4-in/c

Converts the given IPv4 addr to its number, byte string, string, or list representation, respectively.

Examples:

> (ip4->number '(127 0 0 1))
2130706433
> (ip4->bytes '(127 0 0 1))
#"\177\0\0\1"
> (ip4->string (ip4 '(11 22 33 44)))
"11.22.33.44"
> (ip4->list #x7F000001)
'(127 0 0 1)

procedure
(string->ip4 address-string) → (or/c ip4? #f)
address-string : string?

If address-string is a valid IPv4 representation, converts it to an ip4 instance; otherwise, returns #f.

struct
(struct cidr4 (address prefix))
address : ip4-number?
prefix : (integer-in 0 32)

Represents a CIDR set of IPv4 addresses. In particular, it represents the set of addresses whose highest prefix bits match the high bits of address.

Like ip4, the address field is stored as an integer but can be given to the constructor in any ip4-in/c form. The constructor automatically clears the bits of address after the first prefix bits.

Examples:

> (cidr4 "11.22.0.0" 16)
(cidr4 "11.22.0.0" 16)
> (cidr4 "11.22.33.44" 16) ; low bits cleared
(cidr4 "11.22.0.0" 16)
> (cidr4 '(255 0 0 1) 4) ; low bits cleared
(cidr4 "240.0.0.0" 4)

procedure
(cidr4-contains? cidr addr) → boolean?
cidr : cidr4?
addr : ip4-in/c

Returns #t if cidr represents a set of addresses including addr; otherwise, returns #f.

Examples:

> (cidr4-contains? (cidr4 "11.22.0.0" 16) "11.22.33.44")
#t
> (cidr4-contains? (cidr4 "11.22.0.0" 16) "11.34.5.6")
#f

procedure
(cidr4-range cidr) →
ip4-number? ip4-number?
cidr : cidr4

Returns the minimum and maximum IPv4 address numbers in the contiguous range represented by cidr.

Example:

> (cidr4-range (cidr4 '(192 168 0 0) 16))
3232235520
3232301055

10.1.2 IPv6 Addresses🔗ℹ

struct
(struct ip6 (number))
number : ip6-number?

Represents an IPv6 internet address.

The ip6 constructor can be given any ip6-in/c value, but the address is converted to a 128-bit unsigned integer for storage.

Instances of the ip6 structure use the string form of address for printing.

Examples:

> (ip6 #x260647003036000000000000681530eb)
(ip6 "2606:4700:3036::6815:30eb")
> (ip6 '(9734 18176 12342 0 0 0 26645 12523))
(ip6 "2606:4700:3036::6815:30eb")
> (ip6 "2606:4700:3036::6815:30eb")
(ip6 "2606:4700:3036::6815:30eb")

value
ip6-in/c : flat-contract?
= (or/c ip6? ip6-number? ip6-bytes? ip6-string? ip6-list?)

Contract for values that can be interpreted as IPv6 addresses.

procedure
(ip6-number? v) → boolean?
v : any/c

Accepts any 128-bit unsigned integer. Equivalent to uint128?.

procedure
(ip6-bytes? v) → boolean?
v : any/c

Accepts any byte string of 16 bytes. It is intepreted as an IPv6 address number in network byte order (big-endian).

procedure
(ip6-string? v) → boolean?
v : any/c

Accepts strings containing the notation for IPv6 addresses described by RFC 1884, Section 2.2.

Examples:

> (ip6-string? "::1")
#t
> (ip6-string? "2606:4700:3036::6815:30eb")
#t
> (ip6-string? "2606:4700:3036:0:0:0:6815:30eb")
#t
> (ip6-string? "::FFFF:11.22.33.44")
#t

procedure
(ip6-list? v) → boolean?
v : any/c

Accepts any list of eight uint16? values.

procedure
(ip6->number addr) → ip6-number?
  addr : ip6-in/c
procedure
(ip6->bytes addr) → ip6-bytes?
  addr : ip6-in/c
procedure
(ip6->string addr) → ip6-string?
  addr : ip6-in/c
procedure
(ip6->list addr) → ip6-list
  addr : ip6-in/c

Converts the given IPv6 addr to its number, byte string, string, or list representation, respectively.

Examples:

> (ip6->number "2606:4700:3036::6815:30eb")
50543257686980433870399704799439565035
> (ip6->list "2606:4700:3036::6815:30eb")
'(9734 18176 12342 0 0 0 26645 12523)
> (ip6->list "::FFFF:11.22.33.44")
'(0 0 0 0 0 65535 2838 8492)

procedure
(string->ip6 address-string) → (or/c ip6? #f)
address-string : string?

If address-string is a valid IPv6 representation, converts it to an ip6 instance; otherwise, returns #f.

struct
(struct cidr6 (address prefix))
address : ip6-number?
prefix : (integer-in 0 128)

Represents a CIDR set of IPv6 addresses. In particular, it represents the set of addresses whose highest prefix bits match the high bits of address.

Like ip6, the address field is stored as an integer but can be given to the constructor in any ip6-in/c form. The constructor automatically clears the bits of address after the first prefix bits.

Example:

> (cidr6 "FE80::" 10)
(cidr6 "fe80::" 10)

procedure
(cidr6-contains? cidr addr) → boolean?
cidr : cidr6?
addr : ip6-in/c

Returns #t if cidr represents a set of addresses including addr; otherwise, returns #f.

Example:

> (cidr6-contains? (cidr6 "FE80::" 10) "FE81:1234::5:67")
#t

procedure
(cidr6-range cidr) →
ip6-number? ip6-number?
cidr : cidr6

Returns the minimum and maximum IPv6 address numbers in the contiguous range represented by cidr.

Example:

> (cidr6-range (cidr6 "FE80::" 10))
338288524927261089654018896841347694592
338288524927261089654018896841347695615

1	About Descriptions
2	Conditional Expressions
3	Contracts
4	Decimal Numbers
5	Synchronizable Events
6	Functions
7	Immutable and Mutable Conversion
8	Let-Return
9	Lists
10	Networking
11	Numbers
12	Regular Expressions
13	Relations
14	Results
15	Slices
16	Structs
17	Classes and Objects
18	Converting a Datum to an Expression
19	Compile-time Code Injection
20	Compile-time Struct Info