Files
boc/aamos-ledger-rust/target/debug/deps/libipnet-d2b7f3541848a8db.rmeta
T

486 lines
221 KiB
Plaintext
Raw Normal View History

rust
5r#rustc 1.96.0 (ac68faa20 2026-05-25)ÁíŕÄTËź ÜJîÄ)'ß\Ą!-3d1337db07d0b3aeÁŔ뉊]!ÜŰę(ąŢ—šęn-5be7b69c3ff7b5b8Á¤˛XctÔ'ĐÓ©z¨É˝Ó-a4945860e1c53b00Á¤°đ ľä-±($˛ď=©Ă-7e98a21bfd32b0edÁťňÖŔH•‘PIÓHă#Ł-055f30b747f859b6Árustc_std_workspace_coreÁ­Cçß^ň˝čÝ$­Ç˙+Cé-c4878ee60b2242c9ÁźĂď+Ń]ŠqB<ĎďW#-8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>ŕö÷g\K-1eb618da2918ab7fÁadler2ÁĆ;+Ţ®5ĄĚýݰ¦ŰL-f7919172d268e069Á hashbrownÁPäV9ŇĆčÜ"ĘÖVŽ\-0fc2184a5da6723aÁrustc_std_workspace_allocÁs&ŘňŘyŻs•bć!‰ýŠ-97e4bf30be240674Á
std_detectÁhŠBîŮşĚI®ËŹĹŹš-9dbbf8346ba7ac8bÁrustc_demangleÁűë9´Ç×@Ś’ůXFş-f33013f239bf9f14Ácfg_ifÁÜLhťž§ŚaăŻ>­Ť-0a71c8f33a838301Á addr2lineÁ׎Ţ!]8V$É@@-e618e6be60e87ba2ÁgimliÁ¸
°µ~Î1‹Ńt đÁ€w-1f7768a68858f670ÁobjectÁ
áPĂ?­Ŕ¶ĽQHJĄŹ-914cd6a4dbe590d1ÁmemchrÁ›ş«8Ór­2Ů $¨űib-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâ×ÉŻŚ-ee6f3747e38367f0Á
schemars08ÁT+»Ĺ´Ý* schemars1ÁLş+»ĺ¬•+serdeÁ,ě+»ŚË+IpAddrÁ4‚»ŔŚŢIpv4AddrÁDŠ»Ŕ#!#Ipv6AddrÁD”»ŔB@BtestsÁ,ť¬$’¬zErrorÁ,ő»ŔŚĐzź»ŔŚ´zŔ»Ŕzß»Ŕ202zţ,Ş$ö©§ź4H»Ŕ|%Ś$§ŔDP»Ŕ§ßDZ»Ŕ0/ţ
$¸
°»ŔŚ·°Ŕ»ŔŚ›°ß»Ŕipnet_schemars_08ÁŚŤ/»Ĺ´đ.ipnet_schemars_1Á„Â/»ĺ¬¦/ ipnet_serdeÁ\ň/»ŚÚ/íŔ¤ 
  
ipextÁ 
IpAddÁ&RHSÁ&°&±
IpSubÁ*ĺ
*°*˛
IpBitAndÁ.ĺ
.°.ŻIpBitOrÁ2ĺ
2°2± ip_add_implÁ ip_sub_implÁip_bitops_implÁIpStepÁ9 replace_oneÁ9 replace_zeroÁ9add_oneÁ9sub_oneÁ>«>˝>Đ>ŢC«C˝CĐCŢH÷J÷Lć L count_u64ÁOć O
count_u128ÁOcan_count_u128ÁSSó SüSSmaxÁSminÁSnthÁS size_hintÁ\\ó \ü\\®\¸\Â\Ěeeó eüee®e¸eÂeĚ n next_backÁnnth_backÁ
qŘqč tŘtč 
ipnetÁzzzzzzzzzz z
z z z
zzzzzzzzzzzzzzzz×zzć 
new_assertÁ with_netmaskÁtruncÁaddrÁ
prefix_lenÁmax_prefix_lenÁnetmaskÁhostmaskÁnetworkÁ broadcastÁsupernetÁ
is_siblingÁhostsÁsubnetsÁcontainsÁ«Ą aggregateÁz®>z°×z˛×z´÷z÷z¸÷z şć şÄşÖşęş÷şşş«ş netmask_u32Áşşş hostmask_u32ÁşĘşŮşęČ şúşŚşş¨ÍĄşintervalÁşŔĐ z
Ň>z Ô×z Ö×z
Ř÷zÚć ÚÄÚÖÚęÚ÷ÚÚÚ«Ú netmask_u128ÁÚşÚ
hostmask_u128ÁÚĘÚŮÚęč ÚúÚŚÚÚ¨íĄÚĐÚŔđ zň>zô×zö×zř÷zContainsÁúĄú¨zý'aÁý¨z˝¨z˝¨z˝¨z˝¨zŚ˝Ś¨zŹć zć z÷z÷zó znext_ipv4_subnetÁznext_ipv6_subnetÁzśśó zźźó z z!z"zmerge_intervalsÁĄĄmaskÁ§§§§§§ip_mask_to_prefixÁ§ipv4_mask_to_prefixÁ§ipv6_mask_to_prefixÁparserÁ°°°°°°°°°° °
° °ParserÁ˝˝˝ľ˝posÁ°Á˝Áć Áis_eofÁÁread_atomicallyÁĹĄĹÁ
read_till_eofÁČĄČČ Áread_orÁĚĄĚ Á
read_seq_3ÁĎĎĎĎPAÁĎPBÁĎPCÁĎ Á read_charÁÁread_given_charÁŘ Á
read_digitÁÚ parse_digitÁÚ Ü Áread_number_implÁÁ read_numberÁß Áread_ipv4_addr_implÁá á Áread_ipv4_addrÁä Áread_ipv6_addr_implÁćipv6_addr_from_head_tailÁç ć read_groupsÁé é é ě ć ć Áread_ipv6_addrÁđ Á
read_ipv4_netÁň ň ň ő ň Á
read_ipv6_netÁř ř ř ű ř Á read_ip_netÁţ ţ °ţ °ţ °ţ °Ť×°°±
°±
°˛
°˛
ś°ś˛
ź°ź˛
˘°˘ŻĄ°Ą±¨°¨Ż«°«±®°®Ż±°±±´°´Ż·°·± IpAddrRangeÁşV4Á»
»şV6Áľ
ľĂ ĹÖ!"Č#Ę$Ěď
%ΧĎů&Ń×
Ipv4AddrRangeÁÓąÓţ'()Ř*ÚÖ+,Ý-ß.áď
/ă§äů0ć×
Ipv6AddrRangeÁčąčţ123í4ďÖ56ň7ô8öď
9ř§ůů:ű×zIpNetÁý(ţ
ţý¨(
z#z$z%z&Öz'z(z)Ťz*Źď
z+§ůzIpv4NetÁ÷z,z-z.z/Öz0z1žz2 z3˘ď
z4¤§ĄůzIpv6NetÁ§÷§z5z6z7¬z8®Öz9z:±z;łz<µď
z=·§¸ůzPrefixLenErrorÁş
z>Ľ×z?ľz@zAÁzBĂÖz IpSubnetsÁĹ(Ć
ĆŨ(É
ÉzCzDzEÎzFĐÖzGzHÓzIŐzJ×ď
zK٧ÚůzLÜ×z Ipv4SubnetsÁŢąŢţŢmin_prefix_lenÁzMzNzOäzPćÖzQzRézSëzTíď
zUď§đůzVň×z Ipv6SubnetsÁôąôţô×0zWzXzYúzZüÖz[z\˙z]z^ď
z_§ůz`×°AddrParseErrorÁŠ
аŤ×°Ź°° °
Ö:
;
<
=
?
@
A
B
D
E
F
G
N
Q
R
U
Z
[
^
c
d
g
l
m
o
p
r
s
u
v



ź
 
ˇ
˘
Ł
¤
Ą
¦
§
¨
¨
©
Ş
«
­
±
±
±
ł
ł
ł
ľ
ż
Ŕ
Á
Â
Ă
Ä
Ĺ
Ć
Ç
Č
Ę
Ę
Ë
Ě
Í
Ď
Đ
Ő
Ő
Ő
×
×
×
Ţ
ß
ŕ
á
â
ă
ä
ĺ
ć
ç
č
ę
ę
ë
ě
í
ď
đ
ő
ő
ő
÷
÷
÷
ü
˙
˙





Ž

ž
ˇ
Ä
Ĺ
Ĺ
Ĺ
Č
Č
Č
Ě
Ě
Ě
Ě
Ě
Ě
Ď
Ď
Ď
Ď
Ď
Ď
Ď
×
Ř
Ú
Ţ
ß
á
ä
ć
ç
ç
é
é
é
đ
ň
ň
ň
ň
ň
ň
ň
ř
ř
ř
ř
ř
ř
ř
ţ
ţ
ţ
ţ
ţ



Ž
Ž
Ž
Ä
Ć
É
É
Ë
Ë
Í
Í
Ď
Ď
Ň
Ň
Ň
Ů
Ű
Ţ
Ţ
ŕ
ŕ
â
â
ä
ä
ç
ç
ç
î
đ
ó
ó
ő
ő
÷
÷
ů
ů
ü
ü
ü


Ś
Ś
Ž
Ž




š
ś
ź
ź
ˇ
ˇ
Ł
Ł
Ą
Ą
­
Ż
˛
˛
´
´


¸
¸
˝
˝
˝
ż
Â
Â
Ä
Ď
Ń
Ô
Ô
Ö
Ö
Ř
Ř
Ú
Ú
Ý
Ý
Ý
ĺ
ç
ę
ę
ě
ě
î
î
đ
đ
ó
ó
ó
ű
ý











Ž
Ž
Ž




&*.29ú&ľşľşŔżşoctetsÁŻQ5N`hzŘĘ&̺̺ßÍş„?ŻQɢ}ÝĎĆÚ*î?î?*î?Ą@*®@®@*®@ß@.î?î?2î?î?.î?Ą@2î?Ą@.®@®@2®@®@.®@ß@2®@ß@9î?9®@Š ş»Ľ‘(˝ľż¨(ŔË•Čú¶µĺŰ‹BŘ‹B‹BĐě‹Bµß‹B‹Bş‹Bíß‹B‹Bše‹Bżc‹BŠ ÓÓ¦)ÔąŐţÓ
čüŰ˝CŘ˝C˝CĐě˝Cµß˝C˝Cş˝Cíß˝C˝Cše˝Cżc˝CŠ čč˛*éąęţNúzbŰUüŰßDŘßDßDĐěßDµßßDßDşßDíßßDßDšeßDżcßDé‹B˝Cé‹BßDůM‹BůM˝CůMßDŚM‹BŚM˝CŚMßDňP‹BňP˝CňPßDŠ ýţ˙‘(¨(ë737ľL(ŰőFŘőFőFĐěőFµßőFőFşőFíßőFőFšeőFŠ Đ,÷zzJĐÜNĂ*ęŰťHŘťHťHĐěťHµßťHťHşťHíßťHťHšeťHŠ §§Ę-¨÷z©z_ °ńΧ;4۵IصIµIĐěµIµßµIµIşµIíßµIµIšeµIżcşş»Ä. 3 …B¶N ŘÍJĐěÍJµßÍJÍJÍJÄcÍJľÍJłőFżcőFÄcőFéőFťHéőFµIéőF¦ş§ş¨ş‘(©şŞş«ş¨(¬şbęS´PÔŰłťHżcťHÄcťHéťHî?łµIżcµIÄcµIéµI®@úőF ˝őFúőF ˝öKúťH ˝ťHúťH ˝î?úµI ˝µIúµI ˝®@Š ĹĆÇ‘(ČÉʨ(ËF“Pkć˘2lŰšNŘšNšNĐěšNµßšNšNşšNíßšNšNšešNżcšNŠ ŢŢ´0ßązŕţzá×0zykÔRcnőŰĚOŘĚOĚOĐěĚOµßĚOĚOşĚOíßĚOĚOšeĚOżcĚOŠ ôôÔ1őązöţz÷×0zA4YA2Ź|ŰůPŘůPůPĐěůPµßůPůPşůPíßůPůPšeůPżcůPéšNĚOéšNůPůMšNůMĚOůMůPňPšNňPĚOňPůPďyőFďyťHďyµIżcŠŠç2ڰ =řë´ŢŹEśŘšSĐěšSµßšSšSšSÄcšSľšSľşĚşľşľşśĚ

T®-  /
6ś—-
Ü
B 4 X »,(î?üË," ß,Tâ,/
6śË,
ĽB4X ě,üÁ,- ý í, ¸- 
üŤ-- ý ą- Ë-ťüŇ+ůü°,>üü,> őF,‰,öKę+Tö+l°,î?HťH3î?2¸a'®@áµIĚ®@˸aŔipÁ`d¬§¬,ąü­›F|°›T°› ˝› ¸a9 ľ›tŮ›  şśŐ› ÖżťHÍJ ç› ň› ˛śeó› 4:ü˙›,Źś  Tźś

2  
Şś
  üü›0 ÖżťHÍJ «ś±ş»üŃšá ֿٿڿ«ŰżÜżÝżŢż‚†f|Â
ťHÍJüî?⚸aTđššdôń¸ađüŔ›3ÍJ»ťHBî?@¸a4ŽaX[Űř=…ĄT„ŤĄTŤĄ ›Ą ¸a9 śĄ=ŮĄ šd=ŘĄ
óĄ T¦ üăĄ,  ަ •¦ŠńAČ#
ÁAČ#
ŕWüźĄ97 <Ľüş¤Ű ťH<ó¤î?Ҥ¸aTचdXT¸aSŚî?ö¸aéŽaBEsLúŻî?‰°żüËŻ>î?DçŻ ťH,ÝŻ 2|ď°¸a„±ŔüŔ°D¸aâ°k,ذ /ü±  ¸a„˛Áüɱ;¸aď±k,ĺ± /ü‹ůG„ŽůTŽů ›ů€¸a9 ťůt¸ů  şś´ů ÖżµIÍJ Ćů Ńů ‘úeŇů šd4:üŢů,îů  Tţů

2 § 
‰ú
  üŰů0 ÖżµIÍJ Šú±şŰüŻřâ ֿٿڿ«ŰżÜżÝżŢż‚†f|Â
µIÍJüář®@Ŕř¸aTÎřšdôń¸ađüźů3ÍJ»µIB®@@¸a4ŽaX[ŰřD Vڍ €¸a9 ¸ šd
 T „ ü€„, § «„ ˛„ŠńGČ#
ÁGČ#«iü»:8˝i
7ÜüŐ‚Ý µI®@킸aTű‚šdSO¸aN®@ń¸aäŽaBEsL莮@÷ŽßüąŽ>®@DŐŽ µI,ËŽ 2|ÝŹ¸aňŹŕü®ŹD¸aĐŹ˝u,ĆŹ /î €¸a÷áü»<¸aá˝u /¶w¶w¶w¶w÷F şĽ%B0˝C7>ŽG şż%B0ßD7>
 ý˙%őF0ťH7>
 ý%őF0µI7>€đ ĹÇ&šN1ĚO8?•đ ĹĘ&šN1ůP8?Ě‘U Š%šS0šd7>°íŔź*¤,Ď*Ů
,Š,&ţ'\,şžDž,.Â<¨,2 ý
,±,*
¦)l¸,Ó ˛*lÇ,č ľ+,ň,ý/Lů,ĹĐ,<„-´0\Ť-ŢĘ-<š-§Ô1\Ł-ôÄ.t°-şÄ.»ŚŘ- ­´śë- ®Ďś€. Żç2t¬.Šüţ/ü8.+ Types for IPv4 and IPv6 network addresses.ÁgúükGD This module provides types and useful methods for working with IPv4ÁüłDA and IPv6 network addresses, commonly called IP prefixes. The newÁüřGD [`IpNet`], [`Ipv4Net`], and [`Ipv6Net`] types build on the existingÁüŔHE [`IpAddr`], [`Ipv4Addr`], and [`Ipv6Addr`] types already provided inÁü‰=: Rust's standard library and align to their design to stayÁ consistent.Á×úüŰDA The module also provides the [`IpSubnets`], [`Ipv4Subnets`], andÁü EB [`Ipv6Subnets`] types for iterating over the subnets contained inÁüćDA an IP address range. The [`IpAddrRange`], [`Ipv4AddrRange`], andÁü«GD [`Ipv6AddrRange`] types for iterating over IP addresses in a range.ÁüóEB And traits that extend `Ipv4Addr` and `Ipv6Addr` with methods forÁüąFC addition, subtraction, bitwise-and, and bitwise-or operations thatÁü€+( are missing in Rust's standard library.Á¬úü°GD The module only uses stable features so it is guaranteed to compileÁüř using the stable toolchain.Áú”ś # OrganizationÁŻúüłFC * [`IpNet`] represents an IP network address, either IPv4 or IPv6.ÁüúHE * [`Ipv4Net`] and [`Ipv6Net`] are respectively IPv4 and IPv6 networkÁ„Ă
addresses.ÁüÔ GD * [`IpSubnets`], [`Ipv4Subnets`], and [`Ipv6Subnets`] are iteratorsÁüś
HE that generate the smallest set of IP network addresses bound by anÁüĺ
FC IP address range and minimum prefix length. These can be createdÁü¬ =: using their constructors. They are also returned by theÁüę HE [`subnets()`] methods and used within the [`aggregate()`] methods.Áüł C@ * [`IpAddrRange`], [`Ipv4AddrRange`], and [`Ipv6AddrRange`] areÁü÷ FC iterators that generate IP addresses. These can be created usingÁüľ
C@ their constructors. They are also returned by the [`hosts()`]Át methods.Áü‘GD * The [`IpAdd`], [`IpSub`], [`IpBitAnd`], [`IpBitOr`] traits extendÁüŮEB the [`Ipv4Addr`] and [`Ipv6Addr`] types with methods to performÁĽź these operations.Á·úô» [`IpNet`]: enum.IpNet.htmlÁüÚ$! [`Ipv4Net`]: struct.Ipv4Net.htmlÁü˙$! [`Ipv6Net`]: struct.Ipv6Net.htmlÁü¤B? [`IpAddr`]: https://doc.rust-lang.org/std/net/enum.IpAddr.htmlÁüçHE [`Ipv4Addr`]: https://doc.rust-lang.org/std/net/struct.Ipv4Addr.htmlÁü°HE [`Ipv6Addr`]: https://doc.rust-lang.org/std/net/struct.Ipv6Addr.htmlÁüů&# [`IpSubnets`]: enum.IpSubnets.htmlÁü ,) [`Ipv4Subnets`]: struct.Ipv4Subnets.htmlÁüÍ,) [`Ipv6Subnets`]: struct.Ipv6Subnets.htmlÁüú1. [`subnets()`]: enum.IpNet.html#method.subnetsÁü¬52 [`aggregate()`]: enum.IpNet.html#method.aggregateÁüâ*' [`IpAddrRange`]: enum.IpAddrRange.htmlÁüŤ0- [`Ipv4AddrRange`]: struct.Ipv4AddrRange.htmlÁüľ0- [`Ipv6AddrRange`]: struct.Ipv6AddrRange.htmlÁüď-* [`hosts()`]: enum.IpNet.html#method.hostsÁüť [`IpAdd`]: trait.IpAdd.htmlÁü˝ [`IpSub`]: trait.IpSub.htmlÁüÝ%" [`IpBitAnd`]: trait.IpBitAnd.htmlÁü# [`IpBitOr`]: trait.IpBitOr.htmlÁ§ú # FeaturesÁşúüľEB These flags can be used to extend functionality using third-partyÁü„DA dependencies or optional libraries. See the [features] referenceÁĚÉ for more information.Áăúüç\Y [features]: https://doc.rust-lang.org/cargo/reference/features.html#the-features-sectionÁÄú ## "std"ÁŐúüŮJG Enabled by default. Disabling this feature will mandate the use of theÁü¤@= [core] and [alloc] crates where applicable instead of [std].Áĺúüé+( [core]: https://doc.rust-lang.org/core/Áü•-* [alloc]: https://doc.rust-lang.org/alloc/ÁüĂ)& [std]: https://doc.rust-lang.org/std/Áíú ## "serde"Áúü„30 Uses [`serde`] to implement the `Serialize` andÁ̸ `Deserialize` traits.ÁŇúüÖFC For human readable formats (e.g. JSON) the `IpNet`, `Ipv4Net`, andÁüť>; `Ipv6Net` types will serialize to their `Display` strings.ÁÜúüŕ?< For compact binary formats (e.g. Bincode) the `Ipv4Net` andÁü EB `Ipv6Net` types will serialize to a string of 5 and 17 bytes thatÁüćA> consist of the network address octects followed by the prefixÁü¨HE length. The `IpNet` type will serialize to an Enum with the V4 or V6Áüń?< variant index prepending the above string of 5 or 17 bytes.Á±úüµ [`serde`]: https://serde.rsÁŐú´Ů ## "heapless" [^1]ÁđúüôGD Uses [`heapless`] to optimize serialization performance by avoidingÁÄĽ  dynamic allocations.ÁŐ úüŮ ;8 [`heapless`]: https://docs.rs/heapless/latest/heapless/Á•!úś™! ## "schemars08"Á­!úü±!@= Uses [`schemars@0.8.*`] to implement the `JsonSchema` trait.Áň!úüö!>; [`schemars@0.8.*`]: https://docs.rs/schemars/0.8/schemars/Áµ"ú”ą" ## "schemars1"ÁĚ"úüĐ">; Uses [`schemars@1.*`] to implement the `JsonSchema` trait.ÁŹ#úü“#:7 [`schemars@1.*`]: https://docs.rs/schemars/1/schemars/ÁÎ#ú´Ň# ## Legacy featuresÁé#úüí#B? The following features are set to be removed in the next majorÁü°$.+ release. Use the provided analogs instead.Áß$úüă$qn | Name
¦)ŠÓ ˛*č ľ+ý’/ĹĐ,´0ŢĘ-§Ô1ôÄ.şÄ.» ­´ ®Ď Żç2Šîńô„’*ë”Â*ŕ\ü+ŐŘËÎŔĂą¬Ż˘Ąš\ß,z}ordgY\NQTË-69+. #äž.L˝.,Á.&*.29şÓčLessÁ$ŔßÄ´Áß~,Ăß~Äß
FusedIteratorÁlˇňPDoubleEndedIteratorÁś°ŚM íĐë!ź¦ş#Ŕľş$ßĚş%śěĺçÁĂT”suLĘhD»[]KM;=Üł
üäGD Provides a `saturating_add()` method for `Ipv4Addr` and `Ipv6Addr`.Á¬úü°GD Adding an integer to an IP address returns the modified IP address.ÁüřEB A `u32` may added to an IPv4 address and a `u128` may be added toÁ¤ľ an IPv6 address.ÁÓút× # ExamplesÁćú ```Áüň" # #[cfg(not(feature = "std"))]Áü•*' # use core::net::{Ipv4Addr, Ipv6Addr};ÁěŔ # #[cfg(feature = "std")]ÁüŢ'$ use std::net::{Ipv4Addr, Ipv6Addr};Á¬† use ipnet::IpAdd;Áśúü 74 let ip0: Ipv4Addr = "192.168.0.0".parse().unwrap();ÁüŘ74 let ip1: Ipv4Addr = "192.168.0.5".parse().unwrap();Áü;8 let ip2: Ipv4Addr = "255.255.255.254".parse().unwrap();ÁüĚ;8 let max: Ipv4Addr = "255.255.255.255".parse().unwrap();Á úüŚ +( assert_eq!(ip0.saturating_add(5), ip1);Áü¸ +( assert_eq!(ip2.saturating_add(1), max);Áüä +( assert_eq!(ip2.saturating_add(5), max);Á
úü”
2/ let ip0: Ipv6Addr = "fd00::".parse().unwrap();矂
30 let ip1: Ipv6Addr = "fd00::5".parse().unwrap();Áüű
SP let ip2: Ipv6Addr = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe".parse().unwrap();ÁüĎ SP let max: Ipv6Addr = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff".parse().unwrap();ÁŁ úü§ +ş˝üÓ +ď˝ü˙ +¤ľ
°ą
&ĺ
''&Îěüł
gÍěĺ
&ůÂ+ůÂ1()()ÍěĂ”Ă(
żĂ)JĂ
Ă

&&üć
2
Ă”ĂÇĂ&&
)Ă”Ă
rhsÁţ
Ü®üśGD Provides a `saturating_sub()` method for `Ipv4Addr` and `Ipv6Addr`.ÁäúüčEB Subtracting an integer from an IP address returns the modified IPÁü®HE address. A `u32` may be subtracted from an IPv4 address and a `u128`Áü÷+( may be subtracted from an IPv6 address.ÁŁúü§FC Subtracting an IP address from another IP address of the same typeÁüîGD returns an integer of the appropriate width. A `u32` for IPv4 and aÁü¶C@ `u128` for IPv6. Subtracting IP addresses is useful for gettingÁüú'$ the range between two IP addresses.Á˘úŤąµú°ąüÁ"Áąüä*íąěŹ şü­'Çş¬Ő use ipnet::IpSub;Áëúüď30 let min: Ipv4Addr = "0.0.0.0".parse().unwrap();ÁüŁ74 let ip1: Ipv4Addr = "192.168.1.5".parse().unwrap();ÁüŰ96 let ip2: Ipv4Addr = "192.168.1.100".parse().unwrap();Áúü™+( assert_eq!(min.saturating_sub(ip1), 0);ÁüĹ,) assert_eq!(ip2.saturating_sub(ip1), 95);Áüň+( assert_eq!(min.saturating_sub(5), min);Áüž,) assert_eq!(ip2.saturating_sub(95), ip1);Á ÁüĐ.+ let min: Ipv6Addr = "::".parse().unwrap();Áü˙3ˇżüł41 let ip2: Ipv6Addr = "fd00::64".parse().unwrap();Áčúüě+ŻËü,äËüĹ/, assert_eq!(min.saturating_sub(5u128), min);Áüő0- assert_eq!(ip2.saturating_sub(95u128), ip1);Á°ą,¸*ĺ
+*+ůÂü®gŚĂ*ů ůÂ&,-,-ÍěĂ”Ă,ŤŃ-JľĂ**üá2ÔÕŃ**
-Ă”ĂŮĂůôĘ ü—?< Provides a `bitand()` method for `Ipv4Addr` and `Ipv6Addr`.Á×úŤąęú°ąüö"Áąü™*íąěÄ şüâ'ǺĊ use ipnet::IpBitAnd;ÁŁúü§63 let ip: Ipv4Addr = "192.168.1.1".parse().unwrap();ÁüŢ85 let mask: Ipv4Addr = "255.255.0.0".parse().unwrap();Áü—74 let res: Ipv4Addr = "192.168.0.0".parse().unwrap();ÁĎúüÓ%" assert_eq!(ip.bitand(mask), res);Áüů+( assert_eq!(ip.bitand(0xffff0000), res);Á„ÍüŞ74 let ip: Ipv6Addr = "fd00:1234::1".parse().unwrap();Áüâ30 let mask: Ipv6Addr = "ffff::".parse().unwrap();Áü–2/ let res: Ipv6Addr = "fd00::".parse().unwrap();ÁÉúüÍ%ëÔüóNK assert_eq!(ip.bitand(0xffff_0000_0000_0000_0000_0000_0000_0000u128), res);Á°ą.ĺ
/./ůÂüĘ bŚĂ.ů ůÂ&0101ÍěĂ”Ă0äŮ1JÝ Ă..ü€!*4!Ă”ĂěŮ..
1Ă”Ă$Š!ŮĂ!ěĘ'ü®!>; Provides a `bitor()` method for `Ipv4Addr` and `Ipv6Addr`.Áí!útń!Ťą€"ú<„"°ąüŚ""ÁąüŻ"*íąěÚ" şüř"'ÇşĽ # use ipnet::IpBitOr;Á¸#úüĽ#30 let ip: Ipv4Addr = "10.1.1.1".parse().unwrap();Áüđ#63 let mask: Ipv4Addr = "0.0.0.255".parse().unwrap();Áü§$63 let res: Ipv4Addr = "10.1.1.255".parse().unwrap();ÁŢ$úüâ$$! assert_eq!(ip.bitor(mask), res);Áü‡%*' assert_eq!(ip.bitor(0x000000ff), res);Á$˛%„Íü·%2/ let ip: Ipv6Addr = "fd00::1".parse().unwrap();Áüę%85 let mask: Ipv6Addr = "::ffff:ffff".parse().unwrap();ÁüŁ&;8 let res: Ipv6Addr = "fd00::ffff:ffff".parse().unw
4ß(& ĺ(8´ć($ č(, ę(8innerÁ,ë(& đ(8´ń(*ő( ř( Ż+
8$)8Ů
,‡) Ś), Ť)8ŮĂŽ) )8
“), —)8) ś) ©+
8!$Ş)8°4Ż) ¶), ¸)8»
4ą)% ż)8 Î)8±
tŃ) ß) ď)8$ŕ)$ ä)8ŮĂć)& é), ë)8ŮĂě)(ń), ô)8»
4ő) ü) ź+8Ž*8*& •*, —*8óă,* ž*8$ * ¤*8intoÁ$Ą* ©* Ş*% «*8˝*8ŮĂÁ*& Ä*, Ć*8óă,Ç* Í*8ŮĂĎ* Ň*8ç$Ó* ×* Ř*% Ů* ë* Š+8ě* ď*8±
tđ* ţ* ‰+8ŮĂ˙* +8ç$+ ‡+ + +8ç$Ś+ + +Ä´+\Á+ Í+ ą. Ó+ ű+, Ô+8Ő+& Ř+8´Ů+$ Ű+, Ý+8ŮĂŢ+& á+8´â+$ ä+, ć+8»
4ç+& í+8´î+$ đ+, ň+8óă,ó+& ř+8´ů+*ý+ €, ·.
8$Š,8ý
,Ź, ”,, •,8ŮĂ, ™,8
,, ź,8 , ¤, ±.
8!$˛,8°4·, ľ,, Ŕ,8»
4Á,% Ç,8 Ö,8˛
tŮ, ç, ÷,8$č,$ ě,8ŮĂî,& ń,, ó,8ŮĂô,(ů,, ü,8»
4ý, „- §.8-8š-& ť-, ź-8óă, - ¦-8$¨- ¬-8ç$­- ±- ˛-% ł-8Ĺ-8ŮĂÉ-& Ě-, Î-8óă,Ď- Ő-8ŮĂ×- Ú-8ç$Ű- ß- ŕ-% á- ó- .8ô- ÷-8˛
tř- †. ‘.8ŮÇ. Š.8ç$. Ź. . “.8ç$”. . ™.ÜĚ0tŮ0 č0 ą5 î0 Ť1, ď0 đ0 1 ń0 ‰1, ň08ó0& ö08´÷0$ ů0, ű08ŮĂü0& ˙08´€1$ 1, „18ż …1& †18´‡1$ Š1
Ś1*Ź1 1 ·5, 1 ™1 °58$Ł18žD¨1 °1, ±18Ůò1 µ18
·1, »18Ľ1 Ŕ1 ˘3
8!$Î18°4Ó1 Ú1, Ü18Ý1% ŕ18 ď18Ż4ň1 ř1 28$ů1$ ý18ŮĂ˙1& 2, „28ŮĂ…2(Š2, Ť28Ž2 2 38¤28¨2& «2, ­28ż ®2 °28$˛2 ¶28ç$·2 »2 Ľ2% ˝28Ď28ŮĂÓ2& Ö2, Ř28ż Ů2 Ű28ŮĂÝ2 ŕ28ç$á2 ĺ2 ć2% ç2 ů2 38ú2 ţ28ŮĂ€3 „38ç$…3 ‰3 Š38$­38Â<˛3 ą3, ş38ŮĂ»3 ľ38
Ŕ3, Ä38Ĺ3 É3 Ş5
8!$×38°4Ü3 ă3, ĺ38ć3% é38 ř38±,ű3 €4 48$4$ …48ŮÇ4& Š4, Ś48ŮĂŤ4(4, •484 š4  58¬48°4& ł4, µ48ż ¶4 ¸48$ş4 ľ48ç$ż4 Ă4 Ä4% Ĺ48×48ŮĂŰ4& Ţ4, ŕ48ż á4 ă48ŮĂĺ4 č48ç$é4 í4 î4% ď4 5 58‚5 †58ŮĂ5 Ś58ç$Ť5 5 5
±5„ę74ô799ůÂüę7ˇ9ůÂůÂ:;<=:;<==<:;ü8"\„8 ĂĂ9 89
:Ă$•8ü¨8#d«8 ĂĂ9 ¸89
;Ă$˝8ÔĐ8<Ó8 ĂĂ9 Ű89
<Ă$Ü8Ôď8<ň8 ĂĂ9 ú89
=Ă$ű8ÄŤ9î??@AB:;<=B@A?ü¬9!\Ż9š šî?î?> »9>
?$Ŕ9ü:"d“: î?î?>  :>
@$Ą:Ěő:<ř:ś śî?î?> €;>
A$;Ěş;<˝;ť ťî?î?> Ĺ;>
B$Ć;Äţ;®@DEFG:;<=DFGEüť<!\ <ž ž®@®@C ¬<C
D$±<üŤ="d=ź ź®@®@C ť=C
E$˘=Ěţ=<>   ®@®@C ‰>C
F$Š>ĚĂ><Ć>ˇ ˇ®@®@C Î>C
G$Ď>üĎR(BIëIüţR($S˝CBHH
I´ †SüÍS(BKëKüüS($˙SßDBJJ
K´ „T”ËT˝CMNüäT2ëTî?î?˝CLL
Mą,ďTţ€UÔÜVLßV˘ ˘˝CL éVL
N$ęV”¸YßDPQRüŃY2ŘY®@®@ßDOO
Pą,ÜYţíYäě[Tď[Ł ŁßDß@O ú[O
Q$ű[üä^ tç^¤ ¤ßDO ö^O
R$÷^ě±`BTUVWXYZ[úMűM€NN˛OłON˙MXVZ[YWULŐ`$Ú`SSöKüî`($ń`Ą Ą‹BŰĽÝĽŢĽ©߼ŕĽŰáĽcSń꫇zŮ‹BúMS ö`S
U$ű`ĽĚb,ĎbB¶wSS
V$Őbüęc#$íc‹B·ŠSS
W$ňcü˛e"µe‹B·ŠSS
X$ąeü‰g"Śg‹B·ŠSS
Y$güŕh1ăh¦ ¦‹B¶w·ŠS çhS
Z$ěh
 `ŁcbufÁ `ŕB¤GS
ֿٿڿ«ŰżÜżÝżŢż‚†f|Â
šdźČźČ Č  OéBL Ř
×ßěĹÍJőFśťžź ˇ˘Ł¤Ą¦§¨©Ş«­üÄ!Güř@= Creates a new IP network address from an `IpAddr` and prefixÁ length.ÁÍúŤąčú°ąÜü use std::net::Ipv6Addr;Áüś'$ use ipnet::{IpNet, PrefixLenError};ÁČúüĐ96 let net = IpNet::new(Ipv6Addr::LOCALHOST.into(), 48);ÁĚŽ  assert!(net.is_ok());Á„Íüµ EB let bad_prefix_len = IpNet::new(Ipv6Addr::LOCALHOST.into(), 129);Áü˙ 41 assert_eq!(bad_prefix_len, Err(PrefixLenError));Á<¸!°ąË!öK¸aֿٿڿ«ŰżÜżÝżŢż‚†f|Â
őFÍJ
śŽaĎ!TŰ!üŇ+<üľ#@ȧü$GD length. If called from a const context it will verify prefix lengthÁüĎ$HE at compile time. Otherwise it will panic at runtime if prefix lengthÁüś%)& is incorrect for a given IpAddr type.ÁĘ%útŇ%Ťąĺ%ú<í%°ąüů%/, use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};ÁĽ­& use ipnet::{IpNet};ÁÉ&úüŃ&-* // This code is verified at compile time:Áü'UR const NET: IpNet = IpNet::new_assert(IpAddr::V4(Ipv4Addr::new(10, 1, 1, 0)), 24);ÁüÝ'%" assert_eq!(NET.prefix_len(), 24);Á‡(úüŹ((% // This code is verified at runtime:ÁüĽ(@= let net = IpNet::new_assert(Ipv6Addr::LOCALHOST.into(), 24);Áü)%" assert_eq!(net.prefix_len(), 24);Á«)úüł)" // This code does not compile:ÁüÚ)c` // const BAD_PREFIX_LEN: IpNet = IpNet::new_assert(IpAddr::V4(Ipv4Addr::new(10, 1, 1, 0)), 33);ÁÂ*úüĘ*# // This code panics at runtime:Áüň*OL // let bad_prefix_len = IpNet::new_assert(Ipv6Addr::LOCALHOST.into(), 129);Á<Ć+°ąTß+öK¸aőF
ťŽa20;0ü›2QüŃ-B? Creates a new IP network address from an `IpAddr` and netmask.Á.út .Ťął.ú<».°ąÜÇ.רüç.'ü¨“/úü›/€} let net = IpNet::with_netmask(Ipv6Addr::LOCALHOST.into(), Ipv6Addr::from(0xffff_ffff_ffff_0000_0000_0000_0000_0000).into());ÁĚ 0ű©ľ0úüĆ0 let bad_prefix_len = IpNet::with_netmask(Ipv6Addr::LOCALHOST.into(), Ipv6Addr::from(0xffff_ffff_ffff_0000_0001_0000_0000_0000).into());ÁüÖ14úŞ<Ź2°ąd˘2öKöKج
žŽaŻ2«<»2ä«7üĘ3C@ Returns a copy of the network with the address truncated to theÁ”’4 prefix length.Á©4út±4ŤąÄ4ú<Ě4°ąĽŘ4 # use ipnet::IpNet;Á,ô4|ţ4 assert_eq!(Áü’5=: "192.168.12.34/16".parse::<IpNet>().unwrap().trunc(),ÁüÔ5)& "192.168.0.0/16".parse().unwrap()Á46 );ÁŤ6ú|•6ô»ü©6=: "fd00::1:2:3:4/16".parse::<IpNet>().unwrap().trunc(),Áüë6$! "fd00::/16".parse().unwrap()Á4”7†˝<ź7°ą,˛7· ·őFőF ¸7
ź$ą7äţ8Äá8 Returns the address.Á$…9¸ ¸őFöK Š9
 $‹9ôÓ:ô°: Returns the prefix length.ÁTÚ:ą ąőF¸a ĺ:
ˇ$ć:ü°<"ü˙;,) Returns the maximum valid prefix length.Át·<ş şőF¸a Ć<
˘$Ç<üAěč= Returns the network mask.ÁŠ>út>ŤąĄ>ú<­>°ąÜą> # use std::net::IpAddr;ÁĽŮ>Ć»,ő>ć»ü˙>41 let net: IpNet = "10.1.0.0/20".parse().unwrap();Áü¸?;8 assert_eq!(Ok(net.netmask()), "255.255.240.0".parse());Ář?úü€@2/ let net: IpNet = "fd00::/24".parse().unwrap();Áü·@96 assert_eq!(Ok(net.netmask()), "ffff:ff
,Ü^üŹh"üĚ`A> Return an `Iterator` over the host addresses in this network.ÁaútšaŤą­aú<µa°ąÜÁaÝÂĽáaĆ»,ýać»ü‡b41 let net: IpNet = "10.0.0.0/30".parse().unwrap();ÁüŔb:7 assert_eq!(net.hosts().collect::<Vec<IpAddr>>(), vec![Áü˙b.+ "10.0.0.1".parse::<IpAddr>().unwrap(),Áü˛c$! "10.0.0.2".parse().unwrap(),Á<Űc ]);Áçcúüďc41 let net: IpNet = "10.0.0.0/31".parse().unwrap();Áü¨d:ćŕüçd.+ "10.0.0.0".parse::<IpAddr>().unwrap(),Áüše$! "10.0.0.1".parse().unwrap(),Á<ĂeŹâĎeúü×e30 let net: IpNet = "fd00::/126".parse().unwrap();ÁüŹf:ćŕüÎf,) "fd00::".parse::<IpAddr>().unwrap(),Áü˙f# "fd00::1".parse().unwrap(),Áü§g# "fd00::2".parse().unwrap(),ÁüĎg# "fd00::3".parse().unwrap(),Á<÷gŹâ<h°ą,h ÂőF‹B śh
©$ťhüŔtNüŰiC@ Returns an `Iterator` over the subnets of this network with theÁÄŁj given prefix length.ÁŔjútČjŤąŰjú<ăj°ąüďj)& # use ipnet::{IpNet, PrefixLenError};Á,ťkć»ü§k41 let net: IpNet = "10.0.0.0/24".parse().unwrap();ÁüŕkFC assert_eq!(net.subnets(26).unwrap().collect::<Vec<IpNet>>(), vec![Áü«l0- "10.0.0.0/26".parse::<IpNet>().unwrap(),Áüŕl(% "10.0.0.64/26".parse().unwrap(),ÁüŤm)& "10.0.0.128/26".parse().unwrap(),Áü»m)& "10.0.0.192/26".parse().unwrap(),Á<émŹâőmúüým2/ let net: IpNet = "fd00::/16".parse().unwrap();Áü´nFC assert_eq!(net.subnets(18).unwrap().collect::<Vec<IpNet>>(), vec![Áü˙n.+ "fd00::/18".parse::<IpNet>().unwrap(),Áü˛o*' "fd00:4000::/18".parse().unwrap(),Áüáo*' "fd00:8000::/18".parse().unwrap(),Áüp*' "fd00:c000::/18".parse().unwrap(),Á<żpŹâËpúüÓp4ĚčüŚq52 assert_eq!(net.subnets(23), Err(PrefixLenError));ÁĆqúüÎq4Ěčü‡r52 assert_eq!(net.subnets(33), Err(PrefixLenError));ÁÁrúüÉr2Ĺëü€s52 assert_eq!(net.subnets(15), Err(PrefixLenError));ÁşsúüÂs2Ĺëüůs63 assert_eq!(net.subnets(129), Err(PrefixLenError));Á<´t°ą<ÇtĂ ĂőF¸aֿٿڿ«ŰżÜżÝżŢż‚†f|Â
šNÍJ Ďt
Ş$Đtnew_prefix_lenÁtÖtü…‚CüŘv=: Test if a network address contains either another networkÁěšw address or an IP address.ÁĽwútÄwŤą×wú<ßw°ąÜëwÝÂĽ‹xĆ»,§xć»ü±x85 let net4: IpNet = "192.168.0.0/24".parse().unwrap();Áüîx<9 let net4_yes: IpNet = "192.168.0.0/25".parse().unwrap();ÁüŻy;8 let net4_no: IpNet = "192.168.0.0/23".parse().unwrap();Áüďy96 let ip4_yes: IpAddr = "192.168.0.1".parse().unwrap();Áü­z85 let ip4_no: IpAddr = "192.168.1.0".parse().unwrap();Áęzúüňz" assert!(net4.contains(&net4));Áü™{&# assert!(net4.contains(&net4_yes));ÁüÄ{&# assert!(!net4.contains(&net4_no));Áüď{%" assert!(net4.contains(&ip4_yes));Áü™|%" assert!(!net4.contains(&ip4_no));ÁĂ|úË|úüÓ|30 let net6: IpNet = "fd00::/16".parse().unwrap();Áü‹}74 let net6_yes: IpNet = "fd00::/17".parse().unwrap();ÁüÇ}63 let net6_no: IpNet = "fd00::/15".parse().unwrap();Áü‚~52 let ip6_yes: IpAddr = "fd00::1".parse().unwrap();ÁüĽ~30 let ip6_no: IpAddr = "fd01::".parse().unwrap();Áô~úüü~" assert!(net6.contains(&net6));ÁüŁ&# assert!(net6.contains(&net6_yes));ÁüÎ&# assert!(!net6.contains(&net6_no));Áüů%" assert!(net6.contains(&ip6_yes));ÁüŁ€%" assert!(!net6.contains(&ip6_no));ÁÍ€úüŐ€# assert!(!net4.contains(&net6));Áüý€# assert!(!net6.contains(&net4));ÁüĄ%" assert!(!net4.contains(&ip6_no));ÁüĎ%" assert!(!net6.contains(&ip4
,ź‚35üě5üţ‚@= Aggregate a `Vec` of `IpNet`s and return the result as a newÁ `Vec`.ÁŇúŤąíú°ąĽĆ»,ť„滤§„ let nets = vec![ÁüŔ„0- "10.0.0.0/24".parse::<IpNet>().unwrap(),Áüő„'$ "10.0.1.0/24".parse().unwrap(),Áüˇ…'$ "10.0.2.0/24".parse().unwrap(),ÁüÍ…%" "fd00::/18".parse().unwrap(),Áü÷…*‰íü¦†*˝í4Ő† ];Áŕ†úüč†-* assert_eq!(IpNet::aggregate(&nets), vec![Áüš‡0- "10.0.0.0/23".parse::<IpNet>().unwrap(),Áüχ'÷‚üű‡%" "fd00::/17".parse().unwrap(),ÁüĄ*˝íŹâ°ąĹ ĹŞBŞBö­BšĄ÷<®B÷<9)
-ÜnLőFçEçEčEGlobalÁ ż±‡§í#އ ‡‰
­networksÁDý´€őFݴݤťőF®®
ŻĚâőF±Ŕc±ü‚‘6…‘ĆÇČ ĆőF Ç c c˘cµ