آموزش ۱: آدرس‌های IP، زیرشبکه‌ها و محدوده‌ها (Tutorial 1: IP Addresses, Subnets and Ranges)

پیش از هر چیز باید کلاس‌ها و توابع گوناگون netaddr را به فضای‌نام (namespace) خود وارد کنید.

نکته:

>>> from netaddr import *

ما همچنین ماژول کتابخانه استاندارد pprint را برای کمک به قالب‌بندی خروجی وارد می‌کنیم.

>>> import pprint

عملیات پایه (Basic operations)

شیء IPAddress زیر یک آدرس IP منفرد را نمایش می‌دهد.

>>> ip = IPAddress('192.0.2.1')
>>> ip.version
4

فراخوانی repr() یک عبارت پایتون بازمی‌گرداند که در صورت اجرا در مفسر پایتون، می‌تواند برای بازسازی وضعیت شیء آدرس IP مشابه از ابتدا مورد استفاده قرار گیرد.

>>> repr(ip)
"IPAddress('192.0.2.1')"
>>> ip
IPAddress('192.0.2.1')

دسترسی به شیء IP در بافت رشته‌ای (string context)، مقدار آن را به صورت رشته برمی‌گرداند.

>>> str(ip)
'192.0.2.1'
>>> '%s' % ip
'192.0.2.1'
>>> ip.format()  # only really useful for IPv6 addresses.
'192.0.2.1'

نمایش عددی (Numerical representation)

شما می‌توانید یک آدرس IP را در قالب‌های گوناگون دیگری مشاهده کنید.

>>> int(ip) == 3221225985
True
>>> hex(ip)
'0xc0000201'
>>> ip.bin
'0b11000000000000000000001000000001'
>>> ip.bits()
'11000000.00000000.00000010.00000001'
>>> ip.words == (192, 0, 2, 1)
True

نمایش شبکه‌ها و زیرشبکه‌ها (Representing networks and subnets)

اشیای IPNetwork برای نمایش زیرشبکه‌ها، شبکه‌ها یا VLANهایی به کار می‌روند که پیشوندهای CIDR و netmaskها را می‌پذیرند.

>>> ip = IPNetwork('192.0.2.1')
>>> ip.ip
IPAddress('192.0.2.1')
>>> ip.network, ip.broadcast
(IPAddress('192.0.2.1'), None)
>>> ip.netmask, ip.hostmask
(IPAddress('255.255.255.255'), IPAddress('0.0.0.0'))
>>> ip.size
1

در این حالت، آدرس شبکه و برودکست (broadcast) یکسان هستند، مشابه با یک مسیر میزبان (host route).

>>> ip = IPNetwork('192.0.2.0/24')
>>> ip.ip
IPAddress('192.0.2.0')
>>> ip.network, ip.broadcast
(IPAddress('192.0.2.0'), IPAddress('192.0.2.255'))
>>> ip.netmask, ip.hostmask
(IPAddress('255.255.255.0'), IPAddress('0.0.0.255'))
>>> ip.size
256

و در نهایت، این شیء IPNetwork نمایانگر یک آدرس IP است که متعلق به یک زیرشبکه IP مشخص است.

>>> ip = IPNetwork('192.0.3.112/22')
>>> ip.ip
IPAddress('192.0.3.112')
>>> ip.network, ip.broadcast
(IPAddress('192.0.0.0'), IPAddress('192.0.3.255'))
>>> ip.netmask, ip.hostmask
(IPAddress('255.255.252.0'), IPAddress('0.0.3.255'))
>>> ip.size
1024

از نظر درونی، هر شیء IPNetwork تنها ۳ مقدار را ذخیره می‌کند:

سایر مقادیر در هنگام دسترسی به صورت درجا (on-the-fly) محاسبه می‌شوند.

تنظیم مقدار آدرس IP و پیشوند CIDR پس از نمونه‌سازی (instantiation) شیء امکان‌پذیر است.

>>> ip = IPNetwork('0.0.0.0/0')
>>> ip
IPNetwork('0.0.0.0/0')
>>> ip.value = 3221225985
>>> ip
IPNetwork('192.0.2.1/0')
>>> ip.prefixlen
0
>>> ip.prefixlen = 23
>>> ip
IPNetwork('192.0.2.1/23')

طول پیشوند (prefix length) را می‌توان با تعیین یک subnet mask نیز تغییر داد:

>>> ip = IPNetwork('192.168.1.0/24')
>>> ip.netmask = '255.255.0.0'
>>> ip
IPNetwork('192.168.1.0/16')
>>> ip = IPNetwork('fe80::dead:beef/64')
>>> ip.netmask = 'ffff:ffff::'
>>> ip
IPNetwork('fe80::dead:beef/32')

همچنین ویژگی‌ای (property) وجود دارد که به شما امکان دسترسی به آدرس CIDR واقعی را می‌دهد که تمامی بیت‌های میزبان (host bits) را بر اساس پیشوند زیرشبکه CIDR از آدرس شبکه حذف می‌کند.

>>> ip = IPNetwork('192.0.2.1/23')
>>> ip.cidr
IPNetwork('192.0.2.0/23')

این ویژگی برای تعیین دقیق و صحیح برخی پیکربندی‌های شبکه بسیار کاربردی است.

اگر می‌خواهید به اطلاعات مربوط به تک‌تک آدرس‌های IP تشکیل‌دهنده زیرشبکه دسترسی داشته باشید، این امر از طریق فراخوانی‌های مستقیم متدهای فرعی در هر شیء IPAddress امکان‌پذیر است.

برای مثال، اگر می‌خواهید نمایش ارقام دودویی (باینری) هر آدرس را مشاهده کنید، می‌توانید به صورت زیر عمل نمایید.

>>> ip.ip.bits()
'11000000.00000000.00000010.00000001'
>>> ip.network.bits()
'11000000.00000000.00000010.00000000'
>>> ip.netmask.bits()
'11111111.11111111.11111110.00000000'
>>> ip.broadcast.bits()
'11000000.00000000.00000011.11111111'

پشتیبانی کامل از IPv6 ارائه شده است. بیایید چند مثال را بررسی کنیم:

>>> ip = IPAddress(0, 6)
>>> ip
IPAddress('::')
>>> ip = IPNetwork('fe80::dead:beef/64')
>>> str(ip), ip.prefixlen, ip.version
('fe80::dead:beef/64', 64, 6)
>>> int(ip.ip) == 338288524927261089654018896845083623151
True
>>> hex(ip.ip)
'0xfe8000000000000000000000deadbeef'

خروجی به سبک بیتی برای چنین اعداد طویلی به اندازهٔ هگزادسیمال خوش‌خوان نیست، اما این اثبات کارکرد آن است!

>>> ip.ip.bits()
'1111111010000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:1101111010101101:1011111011101111'

در اینجا برخی از جزئیات شبکه‌ای برای یک زیرشبکهٔ IPv6 آورده شده است.

>>> ip.network, ip.broadcast, ip.netmask, ip.hostmask
(IPAddress('fe80::'), IPAddress('fe80::ffff:ffff:ffff:ffff'), IPAddress('ffff:ffff:ffff:ffff::'), IPAddress('::ffff:ffff:ffff:ffff'))

سازگاری متقابل میان IPv4 و IPv6

با گسترش روزافزون IPv6، به احتمال زیاد مایل خواهید بود که بتوانید میان نشانی‌های IPv4 و IPv6 به‌صورت یکپارچه تعامل برقرار کنید.

در اینجا چند متد آورده شده است که به دستیابی به این هدف کمک می‌کنند.

تبدیل IPv4 به IPv6

>>> IPAddress('192.0.2.15').ipv4()
IPAddress('192.0.2.15')
>>> ip = IPAddress('192.0.2.15').ipv6()
>>> ip
IPAddress('::ffff:192.0.2.15')
>>> ip.is_ipv4_mapped()
True
>>> ip.is_ipv4_compat()
False

>>> IPAddress('192.0.2.15').ipv6(ipv4_compatible=True)
IPAddress('::192.0.2.15')
>>> IPAddress('192.0.2.15').ipv6(ipv4_compatible=True).is_ipv4_compat()
True
>>> IPAddress('192.0.2.15').ipv6(True)
IPAddress('::192.0.2.15')
>>> ip = IPNetwork('192.0.2.1/23')
>>> ip.ipv4()
IPNetwork('192.0.2.1/23')
>>> ip.ipv6()
IPNetwork('::ffff:192.0.2.1/119')
>>> ip.ipv6(ipv4_compatible=True)
IPNetwork('::192.0.2.1/119')

تبدیل IPv6 به IPv4

>>> IPNetwork('::ffff:192.0.2.1/119').ipv6()
IPNetwork('::ffff:192.0.2.1/119')
>>> IPNetwork('::ffff:192.0.2.1/119').ipv6(ipv4_compatible=True)
IPNetwork('::192.0.2.1/119')
>>> IPNetwork('::ffff:192.0.2.1/119').ipv4()
IPNetwork('192.0.2.1/23')
>>> IPNetwork('::192.0.2.1/119').ipv4()
IPNetwork('192.0.2.1/23')

توجه داشته باشید که شیء IP به‌طور پیش‌فرض نشانی‌های IPv4 از نوع "نگاشت‌شده" (mapped) را بر نشانی‌های "سازگار" (compatible) ترجیح داده و بازمی‌گرداند. این انتخاب هدفمند بوده است چرا که قالب دوم منسوخ شده است (برای جزئیات به RFC 4291 مراجعه کنید).

عملیات‌های فهرست

اگر با یک شیء IPNetwork به‌گونه‌ای رفتار کنید که گویی یک شیء فهرست استاندارد Python است، به شما امکان دسترسی به فهرستی از اشیاء نشانی IP مجزا را می‌دهد. این امر البته صوری است و آن‌ها تا زمانی که به آن‌ها دسترسی پیدا نکنید ایجاد نمی‌شوند.

>>> ip = IPNetwork('192.0.2.16/29')

دسترسی به یک شیء IP با استفاده از بافت list()، مولد پیش‌فرض را فرامی‌خواند که فهرستی از تمام اشیاء IP در محدودهٔ مشخص‌شده توسط زیرشبکهٔ شیء IP را بازمی‌گرداند.

>>> ip_list = list(ip)
>>> len(ip_list)
8
>>> ip_list
[IPAddress('192.0.2.16'), IPAddress('192.0.2.17'), ..., IPAddress('192.0.2.22'), IPAddress('192.0.2.23')]

طول آن فهرست ۸ نشانی IP مجزا است.

>>> len(ip)
8

می‌توانید از دسترسی استاندارد بر پایه اندیس برای نشانی‌های IP در زیرشبکه استفاده کنید.

>>> ip[0]
IPAddress('192.0.2.16')
>>> ip[1]
IPAddress('192.0.2.17')
>>> ip[-1]
IPAddress('192.0.2.23')

برش‌زدن (Slicing)

همچنین می‌توانید از برش‌های فهرست روی نشانی‌های IP در زیرشبکه استفاده کنید.

>>> ip[0:4]
<generator object ...>

برش یک تابع مولد (generator function) است. این کار برای صرفه‌جویی در زمان و منابع سیستم انجام شده است، زیرا برخی برش‌ها برای زیرشبکه‌های خاص ممکن است بسیار بزرگ شوند!

نحوه دسترسی به تمام عناصر موجود در یک برش به این صورت است:

>>> list(ip[0:4])
[IPAddress('192.0.2.16'), IPAddress('192.0.2.17'), IPAddress('192.0.2.18'), IPAddress('192.0.2.19')]

برش‌زدن گسترده (Extended slicing) نیز پشتیبانی می‌شود.

>>> list(ip[0::2])
[IPAddress('192.0.2.16'), IPAddress('192.0.2.18'), IPAddress('192.0.2.20'), IPAddress('192.0.2.22')]

معکوس‌سازی فهرست.

>>> list(ip[-1::-1])
[IPAddress('192.0.2.23'), IPAddress('192.0.2.22'), ..., IPAddress('192.0.2.17'), IPAddress('192.0.2.16')]

استفاده از مولدها تضمین می‌کند که کار با زیرشبکه‌های بزرگ IP بهینه و کارآمد است.

>>> for ip in IPNetwork('192.0.2.0/23'):
...    print('%s' % ip)
...
192.0.2.0
192.0.2.1
192.0.2.2
192.0.2.3
...
192.0.3.252
192.0.3.253
192.0.3.254
192.0.3.255

در شبکه‌های IPv4 معمولاً فقط نشانی‌های بین نشانی شبکه و نشانی پخش همگانی (broadcast) را به رابط‌های میزبان واقعی روی سیستم‌ها اختصاص می‌دهید.

تکرارکننده (iterator) ارائه‌شده برای دسترسی به این نشانی‌های IP به شرح زیر است:

>>> for ip in IPNetwork('192.0.2.0/23').iter_hosts():
...     print('%s' % ip)
...
192.0.2.1
192.0.2.2
192.0.2.3
192.0.2.4
...
192.0.3.251
192.0.3.252
192.0.3.253
192.0.3.254

مرتب‌سازی نشانی‌ها و شبکه‌های IP (Sorting IP addresses and networks)

مرتب‌سازی استاندارد و متعارف نشانی‌ها و شبکه‌های IP امری نسبتاً رایج و مفید است.

نحوه کارکرد مرتب‌سازی روی نشانی‌های مجزا بدین صورت است:

>>> import random
>>> ip_list = list(IPNetwork('192.0.2.128/28'))
>>> random.shuffle(ip_list)
>>> sorted(ip_list)
[IPAddress('192.0.2.128'), IPAddress('192.0.2.129'), ..., IPAddress('192.0.2.142'), IPAddress('192.0.2.143')]

جهت سهولت کار، می‌توانید زیرشبکه‌های IP را هم‌زمان با نشانی‌ها مرتب کنید و آن‌ها می‌توانند به‌طور هم‌زمان ترکیبی از نشانی‌های IPv4 و IPv6 باشند (نشانی‌ها و شبکه‌های IPv4 پیش از موارد IPv6 قرار می‌گیرند).

>>> ip_list = [
... IPAddress('192.0.2.130'),
... IPAddress('10.0.0.1'),
... IPNetwork('192.0.2.128/28'),
... IPNetwork('192.0.3.0/24'),
... IPNetwork('192.0.2.0/24'),
... IPNetwork('fe80::/64'),
... IPAddress('::')]
>>> random.shuffle(ip_list)
>>> ip_list.sort()
>>> pprint.pprint(ip_list)
[IPAddress('10.0.0.1'),
 IPNetwork('192.0.2.0/24'),
 IPNetwork('192.0.2.128/28'),
 IPAddress('192.0.2.130'),
 IPNetwork('192.0.3.0/24'),
 IPAddress('::'),
 IPNetwork('fe80::/64')]

توجه داشته باشید که چگونه زیرشبکه‌های هم‌پوشان نیز به ترتیب از بزرگ‌ترین به کوچک‌ترین مرتب می‌شوند..SS "خلاصه‌سازی فهرستی از نشانی‌ها و زیرشبکه‌ها (Summarizing list of addresses and subnets)"

یک عملیات مفید دیگر، قابلیت خلاصه‌سازی گروه‌هایی از زیرشبکه‌ها و نشانی‌های IP و ادغام آن‌ها با یکدیگر در صورت امکان، به منظور ایجاد کوچک‌ترین فهرست ممکن از زیرشبکه‌های CIDR است.

شما این کار را در netaddr با استفاده از تابع cidr_merge() انجام می‌دهید.

ابتدا فهرستی از اشیاء IP ایجاد می‌کنیم که شامل ترکیبی مناسب از نشانی‌ها و زیرشبکه‌های جداگانه، به همراه چند مقدار متنی نشانی IP برای اطمینان بیشتر است. برای جالب‌تر شدن ماجرا، چند نشانی IPv6 نیز اضافه شده است.

>>> ip_list = [ip for ip in IPNetwork('fe80::/120')]
>>> ip_list.append(IPNetwork('192.0.2.0/24'))
>>> ip_list.extend([str(ip) for ip in IPNetwork('192.0.3.0/24')])
>>> ip_list.append(IPNetwork('192.0.4.0/25'))
>>> ip_list.append(IPNetwork('192.0.4.128/25'))
>>> len(ip_list)
515
>>> cidr_merge(ip_list)
[IPNetwork('192.0.2.0/23'), IPNetwork('192.0.4.0/24'), IPNetwork('fe80::/120')]

مفید است، این‌طور نیست؟

ابَرشبکه‌ها و زیرشبکه‌ها (Supernets and subnets)

بسیار معمول است که یک زیرشبکهٔ بزرگ CIDR داشته باشید و بخواهید آن را به چندین بلوک مؤلفهٔ کوچک‌تر تقسیم کنید تا تخصیص‌های شبکه، قوانین دیوار آتش (firewall) و غیره را بهتر مدیریت کنید؛ netaddr ابزارهای لازم برای این کار را در اختیارتان می‌گذارد.

در اینجا یک بلوک شبکهٔ بزرگ کلاس B خصوصی /16 را در نظر می‌گیریم و آن را به مجموعه‌ای از بلوک‌های کوچک‌تر با اندازهٔ ۵۱۲ تقسیم می‌کنیم.

>>> ip = IPNetwork('172.24.0.0/16')
>>> ip.subnet(23)
<generator object ...>

بار دیگر، این متد به دلیل احتمال وجود تعداد زیادی مقدار بازگشتی بسته به اندازهٔ زیرشبکهٔ مشخص‌شده، یک تکرارکننده (iterator) تولید می‌کند.

>>> subnets = list(ip.subnet(23))
>>> len(subnets)
128
>>> subnets
[IPNetwork('172.24.0.0/23'), IPNetwork('172.24.2.0/23'), IPNetwork('172.24.4.0/23'), ..., IPNetwork('172.24.250.0/23'), IPNetwork('172.24.252.0/23'), IPNetwork('172.24.254.0/23')]

همچنین می‌توان فهرست ابرشبکه‌هایی (supernets) را که یک نشانی IP یا زیرشبکهٔ مشخص به آن‌ها تعلق دارد دریافت کرد. شما همچنین می‌توانید یک حد اختیاری تعیین کنید.

>>> ip = IPNetwork('192.0.2.114')
>>> supernets = ip.supernet(22)
>>> pprint.pprint(supernets)
[IPNetwork('192.0.0.0/22'),
 IPNetwork('192.0.2.0/23'),
 IPNetwork('192.0.2.0/24'),
 IPNetwork('192.0.2.0/25'),
 IPNetwork('192.0.2.64/26'),
 IPNetwork('192.0.2.96/27'),
 IPNetwork('192.0.2.112/28'),
 IPNetwork('192.0.2.112/29'),
 IPNetwork('192.0.2.112/30'),
 IPNetwork('192.0.2.114/31')]

در اینجا، به جای یک تولیدکننده (generator)، یک فهرست بازگردانده می‌شود؛ زیرا فهرست مقادیر بالقوه اندازه‌ای قابل‌پیش‌بینی دارد (حداکثر ۳۱ زیرشبکه برای یک نشانی IPv4 و ۱۲۷ برای IPv6).

پشتیبانی از محدوده‌های نشانی غیراستاندارد (Support for non-standard address ranges)

اگرچه CIDR روشی سودمند برای توصیف موجز شبکه‌ها است، اما غالباً (به‌ویژه در IPv4 که پیش از مشخصات CIDR معرفی شده بود) ضروری است که بتوان فهرستی از نشانی‌های IP با نشانی شروع و پایان دلخواه تولید کرد که دقیقاً منطبق بر مرزهای ماسک بیتی نیستند.

تابع iter_iprange() دقیقاً امکان انجام این کار را به شما می‌دهد.

>>> ip_list = list(iter_iprange('192.0.2.1', '192.0.2.14'))
>>> len(ip_list)
14
>>> ip_list
[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), ..., IPAddress('192.0.2.13'), IPAddress('192.0.2.14')]

همچنین دانستن اینکه فهرست واقعی زیرشبکه‌های CIDR که این محدودهٔ غیرهم‌تراز نشانی‌ها را به‌درستی پوشش می‌دهند چیست، بسیار سودمند است.

در اینجا cidr_merge() بار دیگر به کمک می‌آید.

>>> cidr_merge(ip_list)
[IPNetwork('192.0.2.1/32'), IPNetwork('192.0.2.2/31'), IPNetwork('192.0.2.4/30'), IPNetwork('192.0.2.8/30'), IPNetwork('192.0.2.12/31'), IPNetwork('192.0.2.14/32')]

تا پیش از پیدایش مشخصهٔ CIDR، مرسوم بود که netmask یک نشانی IPv4 بر اساس نخستین octet آن و با استفاده از مجموعه‌ای از قوانین کلاس‌بندی‌شده (classful، که نخستین‌بار در RFC 791 تعریف شدند) استنتاج شود.

شما غالباً با ارجاعاتی به آن‌ها در RFCهای مختلف روبه‌رو می‌شوید و کتابخانه‌های نرم‌افزاری متعددی نیز به‌خوبی از آن‌ها پشتیبانی می‌کنند. برای حفظ جامعیت، به‌جای کنار گذاشتن این مجموعه قوانین مهم (اما اکنون تا حدی تاریخی)، از آن‌ها از طریق تابعی با نام رمزگونهٔ cidr_abbrev_to_verbose() پشتیبانی می‌شود.

در اینجا مثالی از این قوانین برای کل فضای نشانی IPv4 آورده شده است.

>>> cidrs = [cidr_abbrev_to_verbose(octet) for octet in range(0, 256)]
>>> pprint.pprint(cidrs)
['0.0.0.0/8',
...
 '127.0.0.0/8',
 '128.0.0.0/16',
...
 '191.0.0.0/16',
 '192.0.0.0/24',
...
 '223.0.0.0/24',
 '224.0.0.0/4',
...
 '239.0.0.0/4',
 '240.0.0.0/32',
...
 '255.0.0.0/32']
>>> len(cidrs)
256

دسته‌بندی نشانی‌های IP

نشانی‌های IP به چندین دسته تقسیم می‌شوند که همهٔ آن‌ها برای تخصیص به‌عنوان نشانی‌های میزبان (host) مناسب نیستند.

تک‌پخشی (Unicast)

>>> IPAddress('192.0.2.1').is_unicast()
True
>>> IPAddress('fe80::1').is_unicast()
True

چندپخشی (Multicast)

برای شناسایی گروه‌های چندپخشی استفاده می‌شود (برای اطلاعات بیشتر به RFC 2365 و 3171 مراجعه کنید).

>>> IPAddress('239.192.0.1').is_multicast()
True
>>> IPAddress('ff00::1').is_multicast()
True

رزروشده (Reserved)

نشانی‌های موجود در محدوده‌های رزروشده برای استفادهٔ عمومی در دسترس نیستند.

>>> IPAddress('253.0.0.1').is_reserved()
True

ماسک‌های شبکه (Netmasks)

یک بیت‌ماسک که برای تقسیم یک نشانی IP به نشانی شبکه و نشانی میزبان به‌کار می‌رود.

>>> IPAddress('255.255.254.0').is_netmask()
True

ماسک‌های میزبان (Hostmasks)

مشابه با netmask است، با این تفاوت که تمام بیت‌های آن معکوس شده‌اند.

>>> IPAddress('0.0.1.255').is_hostmask()
True

لوپ‌بک (Loopback)

این نشانی‌ها به‌صورت داخلی درون پشتهٔ شبکهٔ IP استفاده می‌شوند و بسته‌های ارسال‌شده به این نشانی‌ها از طریق یک اتصال شبکه فیزیکی توزیع نمی‌شوند.

>>> IPAddress('127.0.0.1').is_loopback()
True
>>> IPAddress('::1').is_loopback()
True

اشیاء IPAddress می‌توانند با یکدیگر مقایسه شوند. از آنجا که یک شیء IPAddress می‌تواند هم بیانگر یک نشانی IP تکی و هم یک شبکه ضمنی باشد، بهتر است برای جلوگیری از نتایج نامتعارف، پیش از مقایسه اطمینان حاصل کنید که هر دو طرف مقایسه در شرایط یکسانی قرار دارند.

در اینجا چند نمونه از مقایسه‌های نشانی‌های IP تکی برای شروع آورده شده است.

>>> IPAddress('192.0.2.1') == IPAddress('192.0.2.1')
True
>>> IPAddress('192.0.2.1') < IPAddress('192.0.2.2')
True
>>> IPAddress('192.0.2.2') > IPAddress('192.0.2.1')
True
>>> IPAddress('192.0.2.1') != IPAddress('192.0.2.1')
False
>>> IPAddress('192.0.2.1') >= IPAddress('192.0.2.1')
True
>>> IPAddress('192.0.2.2') >= IPAddress('192.0.2.1')
True
>>> IPAddress('192.0.2.1') <= IPAddress('192.0.2.1')
True
>>> IPAddress('192.0.2.1') <= IPAddress('192.0.2.2')
True

حال بیایید موردی کمی جالب‌تر را بررسی کنیم.

>>> IPNetwork('192.0.2.0/24') == IPNetwork('192.0.2.112/24')
True

همممم... کمی عجیب به نظر می‌رسد، این‌طور نیست؟ دلیلش این است که به صورت پیش‌فرض، اشیاء IP زیرشبکه‌های خود (یا مرزهای کران پایین و بالا) را با یکدیگر مقایسه می‌کنند نه مقادیر تک‌تک نشانی‌های IP را.

راه‌حل این وضعیت بسیار ساده است. با دانستن این رفتار پیش‌فرض، تنها کافی است با استفاده از ویژگی‌های مستقیم، صریحاً مشخص کنید که می‌خواهید دقیقاً کدام بخش از هر شیء IP مقایسه شود.

>>> IPNetwork('192.0.2.0/24').ip == IPNetwork('192.0.2.112/24').ip
False
>>> IPNetwork('192.0.2.0/24').ip < IPNetwork('192.0.2.112/24').ip
True

حالا شد! در صورت تمایل می‌توانید برای مقایسه شبکه‌ها نیز به همین شیوه صریح عمل کنید (اگرچه الزاماً ضروری نیست).

>>> IPNetwork('192.0.2.0/24').cidr == IPNetwork('192.0.2.112/24').cidr
True

با داشتن این اطلاعات، در ادامه چند نمونه از مقایسه‌های شبکه آورده شده است.

>>> IPNetwork('192.0.2.0/24') == IPNetwork('192.0.3.0/24')
False
>>> IPNetwork('192.0.2.0/24') < IPNetwork('192.0.3.0/24')
True

این موضوع ناگزیر پرسش‌هایی را در مورد مقایسه اشیاء IPAddress (اسکالر) و اشیاء IPNetwork (برداری) با یکدیگر به وجود می‌آورد (یا دست‌کم باید بیاورد).

در اینجا نحوه برخورد netaddr با این وضعیت نشان داده شده است.

>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32')
False
>>> IPAddress('192.0.2.0') != IPNetwork('192.0.2.0/32')
True

یک شبکه یا زیرشبکه IP با یک نشانی IP تکی متفاوت است و بنابراین نمی‌توانند (به‌طور مستقیم) مقایسه شوند.

اگر می‌خواهید آن‌ها را با موفقیت مقایسه کنید، باید به طور صریح مشخص کنید که کدام جنبه از شبکه IP را می‌خواهید با نشانی IP مورد نظر مطابقت دهید.

چنانچه یک /32 باشد، می‌توانید مانند زیر از اندیس اولین یا آخرین نشانی استفاده کنید:

>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32')[0]
True
>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32')[-1]
True
>>> IPAddress('192.0.2.0') != IPNetwork('192.0.2.0/32')[0]
False

همچنین اگر قصد مقایسه نشانی پایه را دارید، می‌توانید از آن استفاده کنید:

>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32').ip
True
>>> IPAddress('192.0.2.0') != IPNetwork('192.0.2.0/32').ip
False

گرچه ممکن است این رویکرد در ابتدا کمی بیهوده به نظر برسد، اما netaddr تلاش می‌کند تا ضمن مجزا نگه‌داشتن نشانی‌های IP و شبکه‌ها از یکدیگر، تعامل‌پذیری معقولی را نیز میان آن‌ها فراهم سازد..SS پشتیبانی از DNS

ایجاد جستجوهای معکوس IP برای DNS یک وظیفه مدیریتی متداول است. این کار به ویژه برای نشانی‌های IPv6 بسیار دشوار و زمان‌بر است.

در اینجا نحوه انجام این کار با استفاده از متد reverse_dns() در شیء IPAddress آورده شده است.

>>> IPAddress('172.24.0.13').reverse_dns
'13.0.24.172.in-addr.arpa.'
>>> IPAddress('fe80::feeb:daed').reverse_dns
'd.e.a.d.b.e.e.f.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.e.f.ip6.arpa.'

توجه داشته باشید که از ip6.int استفاده نمی‌شود چرا که این دامنه منسوخ شده است (برای جزئیات RFC 3152 را ببینید).

محدوده‌های آدرس غیراستاندارد

با توجه به پیشینه طولانی نسخه ۴ پروتکل IP، روش CIDR پدیده‌ای نسبتاً جدید به شمار می‌رود؛ از این رو بسیار محتمل است با سیستم‌ها و مستنداتی برخورد کنید که به محدوده‌های نشانی IP در قالب‌هایی غیر از CIDR ارجاع می‌دهند. تبدیل این نوع محدوده‌های دلخواه به CIDR و برعکس، کار چندان خوشایندی نیست. خوشبختانه netaddr تلاش می‌کند با دو کلاس اختصاصی، این کار را برای شما آسان سازد.

محدوده‌های دلخواه آدرس IP

شما می‌توانید یک محدوده دلخواه نشانی IP را با استفاده از نشانی‌های کران پایین و بالا در قالب یک شیء IPRange نمایش دهید.

>>> r1 = IPRange('192.0.2.1', '192.0.2.15')
>>> r1
IPRange('192.0.2.1', '192.0.2.15')

شما می‌توانید درست مانند یک شیء IPNetwork، روی این محدوده‌ها پیمایش کرده و آن‌ها را اندیس‌گذاری کنید.

نکته مهم این است که می‌توانید آن را به معادل CIDR آن نیز تبدیل کنید.

>>> r1.cidrs()
[IPNetwork('192.0.2.1/32'), IPNetwork('192.0.2.2/31'), IPNetwork('192.0.2.4/30'), IPNetwork('192.0.2.8/29')]

در ادامه نحوه مقایسه IPRange و IPNetwork منفرد نشان داده شده است.

>>> IPRange('192.0.2.0', '192.0.2.255') != IPNetwork('192.0.2.0/24')
False
>>> IPRange('192.0.2.0', '192.0.2.255') == IPNetwork('192.0.2.0/24')
True

ممکن است بخواهید یک محدوده IP را در برابر فهرستی از اشیاء IPAddress و IPNetwork مقایسه کنید.

>>> r1 = IPRange('192.0.2.1', '192.0.2.15')
>>> addrs = list(r1)
>>> addrs
[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), IPAddress('192.0.2.3'), IPAddress('192.0.2.4'), IPAddress('192.0.2.5'), IPAddress('192.0.2.6'), IPAddress('192.0.2.7'), IPAddress('192.0.2.8'), IPAddress('192.0.2.9'), IPAddress('192.0.2.10'), IPAddress('192.0.2.11'), IPAddress('192.0.2.12'), IPAddress('192.0.2.13'), IPAddress('192.0.2.14'), IPAddress('192.0.2.15')]
>>> r1 == addrs
False

اوه! دقیقاً آن چیزی نشد که دنبالش بودیم یا انتظار داشتیم.

راهکار انجام این کار این است که هر دو طرف عملیات مقایسه را به یک نوع و قالب یکسان تبدیل کنیم.

>>> list(r1) == addrs
True

حالا شد، این همان چیزی است که می‌خواستیم.

همین موضوع برای اشیاء IPNetwork نیز صدق می‌کند.

>>> subnets = r1.cidrs()
>>> subnets
[IPNetwork('192.0.2.1/32'), IPNetwork('192.0.2.2/31'), IPNetwork('192.0.2.4/30'), IPNetwork('192.0.2.8/29')]
>>> r1 == subnets
False
>>> r1.cidrs() == subnets
True

روش بالا زمانی پاسخ می‌دهد که فهرست مقایسه‌شده شامل یکی از این نوع‌ها باشد، اما اگر فهرستی ترکیبی از IPAddress، IPNetwork و نشانی‌های متنی داشته باشید چه؟

اکنون زمان عملیات‌های کمی قدرتمندتر فرا رسیده است. بیایید از یک کلاس جدید برای کار با گروه‌های نشانی‌های IP و زیرشبکه‌ها استفاده کنیم: کلاس IPSet.

>>> ips = [IPAddress('192.0.2.1'), '192.0.2.2/31', IPNetwork('192.0.2.4/31'), IPAddress('192.0.2.6'), IPAddress('192.0.2.7'), '192.0.2.8', '192.0.2.9', IPAddress('192.0.2.10'), IPAddress('192.0.2.11'), IPNetwork('192.0.2.12/30')]
>>> s1 = IPSet(r1.cidrs())
>>> s2 = IPSet(ips)
>>> s2
IPSet(['192.0.2.1/32', '192.0.2.2/31', '192.0.2.4/30', '192.0.2.8/29'])
>>> s1 == s2
True

بیایید یکی از عناصر را از یکی از اشیاء IPSet حذف کنیم و ببینیم چه رخ می‌دهد.

>>> s2.pop()
IPNetwork('...')
>>> s1 == s2
False

شاید این یک مثال ساختگی به نظر برسد، اما برخی از قابلیت‌های ارائه شده را به نمایش می‌گذارد.

برای جزئیات بیشتر در مورد این کلاس، آموزش IPSet یعنی Tutorial 3: Working with IP sets <> را ببینید..SS محدوده‌های سراسری IP (IP Glob ranges)

بسته netaddr همچنین از یک شیوهٔ کاربرپسند برای مشخص کردن محدوده‌های آدرس IP با استفاده از ساختار دستوری سبک «glob» پشتیبانی می‌کند.

نکته:

>>> IPGlob('192.0.2.*') == IPNetwork('192.0.2.0/24')
True

>>> IPGlob('192.0.2.*') != IPNetwork('192.0.2.0/24')
False

از آنجا که IPGlob یک زیرکلاس از IPRange است، تمام همان عملیات روی آن نیز اعمال‌پذیر هستند.

آموزش ۲: آدرس‌های MAC (MAC addresses)

پیش از هر چیز لازم است کلاس‌ها و توابع مختلف مرتبط با MAC را به فضای‌نام (namespace) خود وارد کنید.

نکته:

>>> from netaddr import *

می‌توانید با اطمینان نسبتاً بالایی همه چیز را از فضای‌نام netaddr وارد کنید، چرا که دقت کافی به عمل آمده تا تنها کلاس‌ها، توابع و ثابت‌های ضروری صادر شوند.

در صورتی که در مورد تداخل‌های نام احتمالی نامطمئن هستید، همیشه وارد کردن موارد مورد نیاز را به‌صورت دستی و انتخابی انجام دهید.

عملیات پایه (Basic operations)

نمونه‌های کلاس EUI برای نمایش آدرس‌های MAC استفاده می‌شوند.

>>> mac = EUI('00-1B-77-49-54-FD')

دسترسی استاندارد از طریق repr() یک عبارت پایتون برمی‌گرداند که در صورت اجرا در مفسر پایتون، می‌تواند شیء آدرس MAC را از نو بازسازی کند.

>>> mac
EUI('00-1B-77-49-54-FD')

دسترسی به شیء EUI در بستر متنی (رشته‌ای).

>>> str(mac)
'00-1B-77-49-54-FD'
>>> '%s' % mac
'00-1B-77-49-54-FD'

در اینجا چند ویژگی متداول دیگر آورده شده است.

>>> str(mac), str(mac.oui), mac.ei, mac.version
('00-1B-77-49-54-FD', '00-1B-77', '49-54-FD', 48)

نمایش‌های عددی (Numerical representations)

می‌توانید یک آدرس MAC تکی را در قالب‌های عددی مختلف دیگری مشاهده کنید.

>>> int(mac) == 117965411581
True
>>> hex(mac)
'0x1b774954fd'
>>> oct(mac)
'0o1556722252375'
>>> mac.bits()
'00000000-00011011-01110111-01001001-01010100-11111101'
>>> mac.bin
'0b1101101110111010010010101010011111101'

بسیار رایج است که آدرس MAC در قالب‌های متعددی به‌جز استاندارد معمول IEEE EUI-48 مشاهده شود.

سازنده کلاس EUI از تمامی این قالب‌های رایج پشتیبانی می‌کند.

>>> EUI('00-1B-77-49-54-FD')
EUI('00-1B-77-49-54-FD')

قالب با حروف کوچک IEEE EUI-48

>>> EUI('00-1b-77-49-54-fd')
EUI('00-1B-77-49-54-FD')

قالب رایج UNIX

>>> EUI('0:1b:77:49:54:fd')
EUI('00-1B-77-49-54-FD')

قالب سه‌تایی هگزت (triple hextet) سیسکو (Cisco)

>>> EUI('001b:7749:54fd')
EUI('00-1B-77-49-54-FD')
>>> EUI('1b:7749:54fd')
EUI('00-1B-77-49-54-FD')
>>> EUI('1B:7749:54FD')
EUI('00-1B-77-49-54-FD')

آدرس‌های MAC خام (بدون جداکننده)

>>> EUI('001b774954fd')
EUI('00-1B-77-49-54-FD')
>>> EUI('01B774954FD')
EUI('00-1B-77-49-54-FD')

قالب PostgreSQL (یافت‌شده در مستندات)

>>> EUI('001B77:4954FD')
EUI('00-1B-77-49-54-FD')

همچنین می‌توان قالبی انتخابی را برای خروجی رشته‌ای MAC در قالب یک کلاس 'dialect' تعیین کرد. کاربرد آن مشابه کلاس dialect مورد استفاده در ماژول csv کتابخانه استاندارد Python است.

>>> mac = EUI('00-1B-77-49-54-FD')
>>> mac
EUI('00-1B-77-49-54-FD')
>>> mac.dialect = mac_unix
>>> mac
EUI('0:1b:77:49:54:fd')
>>> mac.dialect = mac_unix_expanded
>>> mac
EUI('00:1b:77:49:54:fd')
>>> mac.dialect = mac_cisco
>>> mac
EUI('001b.7749.54fd')
>>> mac.dialect = mac_bare
>>> mac
EUI('001B774954FD')
>>> mac.dialect = mac_pgsql
>>> mac
EUI('001b77:4954fd')

البته در صورتی که گزینه‌های استاندارد پاسخگوی نیازهای شما نباشند، می‌توانید کلاس‌های dialect سفارشی خود را برای تنظیم قالب‌بندی MAC بسازید.

در ادامه نمونه‌ای از یک dialect دست‌کاری‌شده UNIX برای MAC آمده است که اکتت‌ها (octets) را با حروف بزرگ و صفرهای پیشین تولید می‌کند.

>>> class mac_custom(mac_unix): pass
>>> mac_custom.word_fmt = '%.2X'
>>> mac = EUI('00-1B-77-49-54-FD', dialect=mac_custom)
>>> mac
EUI('00:1B:77:49:54:FD')

شیءهای EUI رابطی به پایگاه‌های دادهٔ ثبت OUI (شناسهٔ منحصربه‌فرد سازمانی یا Organisationally Unique Identifier) و IAB (بلاک آدرس فردی یا Individual Address Block) که توسط IEEE ارائه می‌شوند فراهم می‌کنند.

نحوهٔ پرس‌وجوی یک OUI با استفاده از رابط EUI در اینجا آمده است:

>>> mac = EUI('00-1B-77-49-54-FD')
>>> oui = mac.oui
>>> oui
OUI('00-1B-77')
>>> oui.registration().address
['Lot 8, Jalan Hi-Tech 2/3', 'Kulim  Kedah  09000', 'MY']
>>> oui.registration().org
'Intel Corporate'

همچنین می‌توانید بدون استفاده از رابط EUI، مستقیماً از شیءهای OUI بهره ببرید.

تعداد اندکی از رکوردهای OUI دارای چند مورد ثبت در برابر خود هستند. مشخص نیست که آیا این موضوع برای ثبت اطلاعات تاریخی است یا صرفاً رفتاری غریب در فرایند ثبت IEEE.

این مثال نشان می‌دهد که چگونه می‌توانید با مشخص کردن شمارهٔ اندیس، به‌صورت جداگانه به آن‌ها دسترسی پیدا کنید:

>>> oui = OUI(524336)   #   OUI constructor accepts integer values, too.
>>> oui
OUI('08-00-30')
>>> oui.registration(0).address
['2380 N. ROSE AVENUE', 'OXNARD  CA  93010', 'US']
>>> oui.registration(0).org
'NETWORK RESEARCH CORPORATION'
>>> oui.registration(0).oui
'08-00-30'
>>> oui.registration(1).address
['GPO BOX 2476V', 'MELBOURNE  VIC  3001', 'AU']
>>> oui.registration(1).org
'ROYAL MELBOURNE INST OF TECH'
>>> oui.registration(1).oui
'08-00-30'
>>> oui.registration(2).address
['CH-1211', 'GENEVE  SUISSE/SWITZ  023', 'CH']
>>> oui.registration(2).org
'CERN'
>>> oui.registration(2).oui
'08-00-30'
>>> for i in range(oui.reg_count):
...     str(oui), oui.registration(i).org
...
('08-00-30', 'NETWORK RESEARCH CORPORATION')
('08-00-30', 'ROYAL MELBOURNE INST OF TECH')
('08-00-30', 'CERN')

نحوهٔ پرس‌وجوی یک IAB با استفاده از رابط EUI در اینجا آمده است:

>>> mac = EUI('00-50-C2-00-0F-01')
>>> mac.is_iab()
True
>>> iab = mac.iab
>>> iab
IAB('00-50-C2-00-00-00')
>>> iab.registration()
{'address': ['1241 Superieor Ave E', 'Cleveland  OH  44114', 'US'],
 'iab': '00-50-C2-00-00-00',
 'idx': 84680704,
 ...
 'org': 'T.L.S. Corp.',
 'size': 537}

آموزش ۳: کار با مجموعه‌های IP

پیش از هر چیز باید کلاس‌ها و توابع مختلف netaddr را به فضای نام (namespace) خود وارد کنید.

نکته:

>>> from netaddr import *

در اینجا نحوهٔ ایجاد مجموعه‌های IP آورده شده است.

یک مجموعهٔ خالی.

>>> IPSet()
IPSet([])
>>> IPSet([])
IPSet([])
>>> len(IPSet([]))
0

می‌توانید نشانی‌های IP و شبکه‌ها را به‌صورت رشته مشخص کنید. همچنین می‌توانید از اشیاء IPAddress، IPNetwork، IPRange یا سایر اشیاء IPSet استفاده کنید.

>>> IPSet(['192.0.2.0'])
IPSet(['192.0.2.0/32'])
>>> IPSet([IPAddress('192.0.2.0')])
IPSet(['192.0.2.0/32'])
>>> IPSet([IPNetwork('192.0.2.0')])
IPSet(['192.0.2.0/32'])
>>> IPSet(IPNetwork('1234::/32'))
IPSet(['1234::/32'])
>>> IPSet([IPNetwork('192.0.2.0/24')])
IPSet(['192.0.2.0/24'])
>>> IPSet(IPSet(['192.0.2.0/32']))
IPSet(['192.0.2.0/32'])
>>> IPSet(IPRange("10.0.0.0", "10.0.1.31"))
IPSet(['10.0.0.0/24', '10.0.1.0/27'])
>>> IPSet(IPRange('0.0.0.0', '255.255.255.255'))
IPSet(['0.0.0.0/0'])

می‌توانید روی تمامی نشانی‌های IP که عضو مجموعهٔ IP هستند پیمایش کنید.

>>> for ip in IPSet(['192.0.2.0/28', '::ffff:192.0.2.0/124']):
...     print(ip)
192.0.2.0
192.0.2.1
192.0.2.2
192.0.2.3
192.0.2.4
192.0.2.5
192.0.2.6
192.0.2.7
192.0.2.8
192.0.2.9
192.0.2.10
192.0.2.11
192.0.2.12
192.0.2.13
192.0.2.14
192.0.2.15
::ffff:192.0.2.0
::ffff:192.0.2.1
::ffff:192.0.2.2
::ffff:192.0.2.3
::ffff:192.0.2.4
::ffff:192.0.2.5
::ffff:192.0.2.6
::ffff:192.0.2.7
::ffff:192.0.2.8
::ffff:192.0.2.9
::ffff:192.0.2.10
::ffff:192.0.2.11
::ffff:192.0.2.12
::ffff:192.0.2.13
::ffff:192.0.2.14
::ffff:192.0.2.15

افزودن و حذف عناصر مجموعه

>>> s1 = IPSet()
>>> s1.add('192.0.2.0')
>>> s1
IPSet(['192.0.2.0/32'])
>>> s1.remove('192.0.2.0')
>>> s1
IPSet([])
>>> s1.add(IPRange("10.0.0.0", "10.0.0.255"))
>>> s1
IPSet(['10.0.0.0/24'])
>>> s1.remove(IPRange("10.0.0.128", "10.10.10.10"))
>>> s1
IPSet(['10.0.0.0/25'])

در اینجا یک بازه ساده و دلخواه از آدرس‌های IP آورده شده است.

>>> iprange = IPRange('192.0.1.255', '192.0.2.16')

می‌توانیم شبکه‌های CIDR موجود در این بازه تعریف‌شده را مشاهده کنیم.

>>> iprange.cidrs()
[IPNetwork('192.0.1.255/32'), IPNetwork('192.0.2.0/28'), IPNetwork('192.0.2.16/32')]

در اینجا یک مجموعه IP آورده شده است.

>>> ipset = IPSet(['192.0.2.0/28'])

اکنون بیایید روی آدرس‌های IP موجود در این بازه دلخواه پیمایش کنیم و بررسی کنیم که آیا درون مجموعه IP یافت می‌شوند یا خیر.

>>> for ip in iprange:
...     print(ip, ip in ipset)
192.0.1.255 False
192.0.2.0 True
192.0.2.1 True
192.0.2.2 True
192.0.2.3 True
192.0.2.4 True
192.0.2.5 True
192.0.2.6 True
192.0.2.7 True
192.0.2.8 True
192.0.2.9 True
192.0.2.10 True
192.0.2.11 True
192.0.2.12 True
192.0.2.13 True
192.0.2.14 True
192.0.2.15 True
192.0.2.16 False

مجموعه‌های IPSet خاص‌تر

>>> bigone = IPSet(['0.0.0.0/0'])
>>> IPAddress("10.0.0.1") in bigone
True
>>> IPAddress("0.0.0.0") in bigone
True
>>> IPAddress("255.255.255.0") in bigone
True
>>> IPNetwork("10.0.0.0/24") in bigone
True
>>> IPAddress("::1") in bigone
False

>>> smallone = IPSet(["10.0.0.42/32"])
>>> IPAddress("10.0.0.42") in smallone
True
>>> IPAddress("10.0.0.41") in smallone
False
>>> IPAddress("10.0.0.43") in smallone
False
>>> IPNetwork("10.0.0.42/32") in smallone
True
>>> IPNetwork("10.0.0.42/31") in smallone
False

اجتماع، اشتراک و تفاضل‌ها (Unions, intersections and differences)

در اینجا چند مثال از عملیات اجتماع انجام‌شده بر روی اشیاء IPSet آورده شده است.

>>> IPSet(['192.0.2.0'])
IPSet(['192.0.2.0/32'])

>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1'])
IPSet(['192.0.2.0/31'])

>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1']) | IPSet(['192.0.2.3'])
IPSet(['192.0.2.0/31', '192.0.2.3/32'])

>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1']) | IPSet(['192.0.2.3/30'])
IPSet(['192.0.2.0/30'])

>>> IPSet(['192.0.2.0']) | IPSet(['192.0.2.1']) | IPSet(['192.0.2.3/31'])
IPSet(['192.0.2.0/30'])

>>> IPSet(['192.0.2.0/24']) | IPSet(['192.0.3.0/24']) | IPSet(['192.0.4.0/24'])
IPSet(['192.0.2.0/23', '192.0.4.0/24'])

در اینجا مثالی از به کارگیری هم‌زمان عملیات‌های اجتماع، اشتراک و تفاضل متقارن آورده شده است.

>>> adj_cidrs = list(IPNetwork('192.0.2.0/24').subnet(28))
>>> even_cidrs = adj_cidrs[::2]
>>> evens = IPSet(even_cidrs)
>>> evens
IPSet(['192.0.2.0/28', '192.0.2.32/28', '192.0.2.64/28', '192.0.2.96/28', '192.0.2.128/28', '192.0.2.160/28', '192.0.2.192/28', '192.0.2.224/28'])
>>> IPSet(['192.0.2.0/24']) & evens
IPSet(['192.0.2.0/28', '192.0.2.32/28', '192.0.2.64/28', '192.0.2.96/28', '192.0.2.128/28', '192.0.2.160/28', '192.0.2.192/28', '192.0.2.224/28'])
>>> odds = IPSet(['192.0.2.0/24']) ^ evens
>>> odds
IPSet(['192.0.2.16/28', '192.0.2.48/28', '192.0.2.80/28', '192.0.2.112/28', '192.0.2.144/28', '192.0.2.176/28', '192.0.2.208/28', '192.0.2.240/28'])
>>> evens | odds
IPSet(['192.0.2.0/24'])
>>> evens & odds
IPSet([])
>>> evens ^ odds
IPSet(['192.0.2.0/24'])

مجموعه‌های IP این امکان را فراهم می‌کنند که بررسی کنید آیا گروهی از بازه‌های آدرس در مجموعه گروه دیگری از بازه‌های آدرس جای می‌گیرند یا خیر.

>>> s1 = IPSet(['192.0.2.0/24', '192.0.4.0/24'])
>>> s2 = IPSet(['192.0.2.0', '192.0.4.0'])
>>> s1
IPSet(['192.0.2.0/24', '192.0.4.0/24'])
>>> s2
IPSet(['192.0.2.0/32', '192.0.4.0/32'])
>>> s1.issuperset(s2)
True
>>> s2.issubset(s1)
True
>>> s2.issuperset(s1)
False
>>> s1.issubset(s2)
False

در اینجا مثال کامل‌تری با استفاده از بازه‌های مختلف و شناخته‌شده آدرس IPv4 آورده شده است.

>>> ipv4_addr_space = IPSet(['0.0.0.0/0'])
>>> private = IPSet(['10.0.0.0/8', '172.16.0.0/12', '192.0.2.0/24', '192.168.0.0/16', '239.192.0.0/14'])
>>> reserved = IPSet(['225.0.0.0/8', '226.0.0.0/7', '228.0.0.0/6', '234.0.0.0/7', '236.0.0.0/7', '238.0.0.0/8', '240.0.0.0/4'])
>>> unavailable = reserved | private
>>> available = ipv4_addr_space ^ unavailable

بیایید ببینیم چه چیزی به دست آورده‌ایم:

>>> for cidr in available.iter_cidrs():
...     print(cidr, cidr[0], cidr[-1])
0.0.0.0/5 0.0.0.0 7.255.255.255
8.0.0.0/7 8.0.0.0 9.255.255.255
11.0.0.0/8 11.0.0.0 11.255.255.255
12.0.0.0/6 12.0.0.0 15.255.255.255
16.0.0.0/4 16.0.0.0 31.255.255.255
32.0.0.0/3 32.0.0.0 63.255.255.255
64.0.0.0/2 64.0.0.0 127.255.255.255
128.0.0.0/3 128.0.0.0 159.255.255.255
160.0.0.0/5 160.0.0.0 167.255.255.255
168.0.0.0/6 168.0.0.0 171.255.255.255
172.0.0.0/12 172.0.0.0 172.15.255.255
172.32.0.0/11 172.32.0.0 172.63.255.255
172.64.0.0/10 172.64.0.0 172.127.255.255
172.128.0.0/9 172.128.0.0 172.255.255.255
173.0.0.0/8 173.0.0.0 173.255.255.255
174.0.0.0/7 174.0.0.0 175.255.255.255
176.0.0.0/4 176.0.0.0 191.255.255.255
192.0.0.0/23 192.0.0.0 192.0.1.255
192.0.3.0/24 192.0.3.0 192.0.3.255
192.0.4.0/22 192.0.4.0 192.0.7.255
192.0.8.0/21 192.0.8.0 192.0.15.255
192.0.16.0/20 192.0.16.0 192.0.31.255
192.0.32.0/19 192.0.32.0 192.0.63.255
192.0.64.0/18 192.0.64.0 192.0.127.255
192.0.128.0/17 192.0.128.0 192.0.255.255
192.1.0.0/16 192.1.0.0 192.1.255.255
192.2.0.0/15 192.2.0.0 192.3.255.255
192.4.0.0/14 192.4.0.0 192.7.255.255
192.8.0.0/13 192.8.0.0 192.15.255.255
192.16.0.0/12 192.16.0.0 192.31.255.255
192.32.0.0/11 192.32.0.0 192.63.255.255
192.64.0.0/10 192.64.0.0 192.127.255.255
192.128.0.0/11 192.128.0.0 192.159.255.255
192.160.0.0/13 192.160.0.0 192.167.255.255
192.169.0.0/16 192.169.0.0 192.169.255.255
192.170.0.0/15 192.170.0.0 192.171.255.255
192.172.0.0/14 192.172.0.0 192.175.255.255
192.176.0.0/12 192.176.0.0 192.191.255.255
192.192.0.0/10 192.192.0.0 192.255.255.255
193.0.0.0/8 193.0.0.0 193.255.255.255
194.0.0.0/7 194.0.0.0 195.255.255.255
196.0.0.0/6 196.0.0.0 199.255.255.255
200.0.0.0/5 200.0.0.0 207.255.255.255
208.0.0.0/4 208.0.0.0 223.255.255.255
224.0.0.0/8 224.0.0.0 224.255.255.255
232.0.0.0/7 232.0.0.0 233.255.255.255
239.0.0.0/9 239.0.0.0 239.127.255.255
239.128.0.0/10 239.128.0.0 239.191.255.255
239.196.0.0/14 239.196.0.0 239.199.255.255
239.200.0.0/13 239.200.0.0 239.207.255.255
239.208.0.0/12 239.208.0.0 239.223.255.255
239.224.0.0/11 239.224.0.0 239.255.255.255

>>> ipv4_addr_space ^ available
IPSet(['10.0.0.0/8', '172.16.0.0/12', '192.0.2.0/24', '192.168.0.0/16', '225.0.0.0/8', '226.0.0.0/7', '228.0.0.0/6', '234.0.0.0/7', '236.0.0.0/7', '238.0.0.0/8', '239.192.0.0/14', '240.0.0.0/4'])

در راستای رویکرد عمل‌گرایانه netaddr، شما می‌توانید به دلخواه IPv4 و IPv6 را در یک ساختار داده یکسان ترکیب کنید.

>>> s1 = IPSet(['192.0.2.0', '::ffff:192.0.2.0', '192.0.2.2', '::ffff:192.0.2.2'])
>>> s2 = IPSet(['192.0.2.2', '::ffff:192.0.2.2', '192.0.2.4', '::ffff:192.0.2.4'])

>>> s1
IPSet(['192.0.2.0/32', '192.0.2.2/32', '::ffff:192.0.2.0/128', '::ffff:192.0.2.2/128'])
>>> s2
IPSet(['192.0.2.2/32', '192.0.2.4/32', '::ffff:192.0.2.2/128', '::ffff:192.0.2.4/128'])

اجتماع مجموعه‌های IPv4 و IPv6

>>> s1 | s2
IPSet(['192.0.2.0/32', '192.0.2.2/32', '192.0.2.4/32', '::ffff:192.0.2.0/128', '::ffff:192.0.2.2/128', '::ffff:192.0.2.4/128'])
>>> s2 | s1
IPSet(['192.0.2.0/32', '192.0.2.2/32', '192.0.2.4/32', '::ffff:192.0.2.0/128', '::ffff:192.0.2.2/128', '::ffff:192.0.2.4/128'])

اشتراک مجموعه

>>> s1 & s2
IPSet(['192.0.2.2/32', '::ffff:192.0.2.2/128'])

تفاضل مجموعه

>>> s1 - s2
IPSet(['192.0.2.0/32', '::ffff:192.0.2.0/128'])
>>> s2 - s1
IPSet(['192.0.2.4/32', '::ffff:192.0.2.4/128'])

تفاضل متقارن مجموعه

>>> s1 ^ s2
IPSet(['192.0.2.0/32', '192.0.2.4/32', '::ffff:192.0.2.0/128', '::ffff:192.0.2.4/128'])

مجموعه‌های IP مجزا

>>> s1 = IPSet(['192.0.2.0', '192.0.2.1', '192.0.2.2'])
>>> s2 = IPSet(['192.0.2.2', '192.0.2.3', '192.0.2.4'])
>>> s1 & s2
IPSet(['192.0.2.2/32'])
>>> s1.isdisjoint(s2)
False
>>> s1 = IPSet(['192.0.2.0', '192.0.2.1'])
>>> s2 = IPSet(['192.0.2.3', '192.0.2.4'])
>>> s1 & s2
IPSet([])
>>> s1.isdisjoint(s2)
True

به‌روزرسانی یک مجموعه IP

همانند یک مجموعه معمولی در Python، می‌توانید یک مجموعه IP را نیز با محتویات مجموعه‌ای دیگر به‌روزرسانی کنید.

>>> s1 = IPSet(['192.0.2.0/25'])
>>> s1
IPSet(['192.0.2.0/25'])
>>> s2 = IPSet(['192.0.2.128/25'])
>>> s2
IPSet(['192.0.2.128/25'])
>>> s1.update(s2)
>>> s1
IPSet(['192.0.2.0/24'])
>>> s1.update(['192.0.0.0/24', '192.0.1.0/24', '192.0.3.0/24'])
>>> s1
IPSet(['192.0.0.0/22'])

>>> s2 = IPSet(['10.0.0.0/16'])
>>> s2.update(IPRange('10.1.0.0', '10.1.255.255'))
>>> s2
IPSet(['10.0.0.0/15'])

>>> s2.clear()
>>> s2
IPSet([])

حذف یک آدرس IP از یک IPSet، زیرشبکه‌های CIDR درون آن را به بخش‌های تشکیل‌دهنده‌شان تقسیم می‌کند.

در اینجا مجموعه‌ای ایجاد می‌کنیم که کل فضای آدرس IPv4 را نشان می‌دهد.

>>> s1 = IPSet(['0.0.0.0/0'])
>>> s1
IPSet(['0.0.0.0/0'])

سپس آخرین آدرس را حذف می‌کنیم.

>>> s1.remove('255.255.255.255')

که نتیجه به این صورت خواهد بود:

>>> s1
IPSet(['0.0.0.0/1', '128.0.0.0/2', ..., '255.255.255.252/31', '255.255.255.254/32'])
>>> list(s1.iter_cidrs())
[IPNetwork('0.0.0.0/1'), IPNetwork('128.0.0.0/2'), ..., IPNetwork('255.255.255.252/31'), IPNetwork('255.255.255.254/32')]
>>> len(list(s1.iter_cidrs()))
32

بیایید نتیجه را با استفاده از تابع cidr_exclude بررسی کنیم.

>>> list(s1.iter_cidrs()) == cidr_exclude('0.0.0.0/0', '255.255.255.255')
True

سپس، نخستین آدرس را از بازه اصلی حذف می‌کنیم.

>>> s1.remove('0.0.0.0')

این کار زیرشبکه‌های CIDR را بیش از پیش خرد می‌کند.

>>> s1
IPSet(['0.0.0.1/32', '0.0.0.2/31', ..., '255.255.255.252/31', '255.255.255.254/32'])
>>> len(list(s1.iter_cidrs()))
62

می‌توانید به این کار ادامه دهید، اما آگاه باشید که مجموعه‌های IP بزرگ در صورتی که شامل چندین هزار مدخل باشند، ممکن است حافظه زیادی را مصرف کنند.

افزودن عناصر به یک IP set

بیایید مجموعه IP خردشده در بخش قبلی را با افزودن مجدد آدرس‌های IP حذف‌شده، ترمیم کنیم.

>>> s1.add('255.255.255.255')
>>> s1
IPSet(['0.0.0.1/32', '0.0.0.2/31', ..., '64.0.0.0/2', '128.0.0.0/1'])

بهتر شد.

>>> list(s1.iter_cidrs())
[IPNetwork('0.0.0.1/32'), IPNetwork('0.0.0.2/31'), ..., IPNetwork('64.0.0.0/2'), IPNetwork('128.0.0.0/1')]

>>> len(list(s1.iter_cidrs()))
32

آدرس IP دیگر را مجدداً اضافه می‌کنیم.

>>> s1.add('0.0.0.0')

و به آدرس اصلی خود بازمی‌گردیم.

>>> s1
IPSet(['0.0.0.0/0'])

گاهی اوقات ممکن است بخواهید یک IPSet را مجدداً به یک IPRange تبدیل کنید.

>>> s1 = IPSet(['10.0.0.0/25', '10.0.0.128/25'])
>>> s1.iprange()
IPRange('10.0.0.0', '10.0.0.255')

این کار تنها در صورتی امکان‌پذیر است که IPSet پیوسته باشد

>>> s1.iscontiguous()
True
>>> s1.remove('10.0.0.16')
>>> s1
IPSet(['10.0.0.0/28', '10.0.0.17/32', '10.0.0.18/31', '10.0.0.20/30', '10.0.0.24/29', '10.0.0.32/27', '10.0.0.64/26', '10.0.0.128/25'])
>>> s1.iscontiguous()
False
>>> s1.iprange()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: IPSet is not contiguous

اگر پیوسته نباشد، همچنان می‌توانید IPSet را تبدیل کنید، اما چندین IPRange دریافت خواهید کرد. >>> list(s1.iter_ipranges()) [IPRange('10.0.0.0', '10.0.0.15'), IPRange('10.0.0.17', '10.0.0.255')]

>>> s2 = IPSet(['0.0.0.0/0'])
>>> s2.iscontiguous()
True
>>> s2.iprange()
IPRange('0.0.0.0', '255.255.255.255')

>>> s3 = IPSet()
>>> s3.iscontiguous()
True
>>> s3.iprange()

>>> s4 = IPSet(IPRange('10.0.0.0', '10.0.0.8'))
>>> s4.iscontiguous()
True

ترتیبی‌سازی (Pickling) اشیاء IPSet

مشابه تمام کلاس‌های دیگر netaddr، می‌توانید از pickle برای ماندگارسازی IP setها جهت استفاده‌های بعدی استفاده کنید.

>>> import pickle
>>> ip_data = IPSet(['10.0.0.0/16', 'fe80::/64'])
>>> buf = pickle.dumps(ip_data)
>>> ip_data_unpickled = pickle.loads(buf)
>>> ip_data == ip_data_unpickled
True

مقایسه اشیاء IPSet

>>> x = IPSet(['fc00::/2'])
>>> y = IPSet(['fc00::/3'])

>>> x > y
True

>>> x < y
False

>>> x != y
True

صفحات این بخش به صورت دستورالعمل بوده و مراحلی را برای حل مشکلات و موارد استفاده رایج ارائه می‌دهند.

نحوه نصب netaddr

توزیع‌های مختلف لینوکس آن را از طریق مدیرهای بسته خود در دسترس قرار می‌دهند.

نصب از مخزن بسته‌های پایتون (PyPI)

ساده‌ترین راه برای نصب netaddr استفاده از pip است.

آخرین نسخه را از PyPI دریافت و نصب کنید - https://pypi.org/project/pip و دستور زیر را اجرا نمایید:

pip install netaddr

اگر تجربه بهتری در پوسته تعاملی <#interactive-shell> می‌خواهید، می‌توانید وابستگی اضافی IPython را بدین صورت نصب کنید:

pip install 'netaddr[nicer-shell]'

یا مستقیماً IPython را نصب نمایید:

pip install ipython

نصب با استفاده از مدیر بسته توزیع لینوکس شما

توزیع‌های مختلف لینوکس netaddr را از طریق مدیرهای بسته خود ارائه می‌دهند.

نکته:

برای دستورالعمل‌های نصب به مستندات توزیع خود مراجعه کنید.

دستورهای نمونه:

# Debian, Ubuntu
sudo apt install python3-netaddr
# Fedora
# Base installation
sudo dnf install python3-netaddr
# The CLI tool
sudo dnf install python3-netaddr-shell

نصب از یک بسته منبع

آخرین فایل tarball/zip منتشرشده را دریافت کرده و آن را در یک دایرکتوری موقت استخراج کنید یا مخزن را در یک دایرکتوری کاری محلی کلون نمایید.

بسته محلی را نصب کنید:

pip install .

این کار فایل‌های مورد نیاز را به‌طور خودکار در دایرکتوری lib/site-packages از نسخه پایتونی که برای اجرای اسکریپت نصب استفاده کرده‌اید قرار می‌دهد؛ همچنین ممکن است بخشی از یک virtualenv یا مدیر محیط مشابه باشد..SH "مرجع (REFERENCE)"

صفحات این بخش شامل توصیف فنی بخش‌های گوناگون سازوکار netaddr است.

سازگاری

نسخه‌های پشتیبانی‌شدهٔ Python

netaddr از نسخه‌های پایتون زیر (CPython و PyPy) پشتیبانی می‌کند:

پشتیبانی از نسخه‌های زیر در 1.0.0 حذف شده است:

پشتیبانی منسوخ شده و برای حذف برنامه‌ریزی شده است در netaddr 2:

سیستم‌عامل‌های پشتیبانی‌شده

این کتابخانه مستقل از سیستم‌عامل است.

معماری‌های سخت‌افزاری پشتیبانی‌شده

این کتابخانه مستقل از معماری سخت‌افزار است.

مرجع API

این صفحه API عمومی netaddr را مستند می‌کند. تنها مواردی که صراحتاً در این مستندات ذکر شده‌اند پشتیبانی می‌شوند و بخشی از API عمومی به شمار می‌روند.

هر یک از موارد زیر خصوصی و پشتیبانی‌نشده در نظر گرفته می‌شوند:

سلسله‌مراتب کلاس‌های IP

در اینجا سلسله‌مراتب کلاس‌ها برای کلاس‌های مرتبط با IP آمده است:

+---------+                                                +---------+
| ipv4(M) |                                                | ipv6(M) |
+---------+                                                +---------+
     |                                                          |
  (HAS A)                                                    (HAS A)
     |                                                          |
     +-----+----------------+-----------------+                 |
           |       +--------|-------+---------|--------+--------+
           |       |        |       |         |        |
           |       |        |       |         |        |
           v       v        v       v         |        |
         +-----------+    +-----------+       |        |
         | IPAddress |    | IPNetwork |       |        |
         +-----------+    +-----------+       |        |
               |                |             |        |
            (HAS A)          (HAS A)          |        |
               |                |             v        v
               +-------+--------+           +------------+
                       |                    |  IPRange   |
                       |                    +-----------+
                       v                          |
                   +-------+                      |
                   | IPSet |                      v
                   +-------+                  +--------+
                                              | IPGlob |
                                              +--------+

استثناهای سفارشی

نشانی‌های IP

نشانی IP یک نشانی مجازی است که برای شناسایی مبدأ و مقصد بسته‌های (لایهٔ ۳) منتقل‌شده میان میزبان‌ها در یک شبکهٔ سوئیچ‌شده استفاده می‌شود. این کتابخانه به‌طور کامل از هر دو استاندارد IPv4 و استاندارد جدیدتر IPv6 پشتیبانی می‌کند.

کلاس IPAddress برای شناسایی نشانی‌های IP منفرد به کار می‌رود.

گویش‌های قالب‌بندی IPv6

کلاس‌های گویش زیر می‌توانند با متد IPAddress.format استفاده شوند.

شبکه‌ها و زیرشبکه‌های IP

کلاس IPNetwork برای نمایش گروهی از نشانی‌های IP استفاده می‌شود که یک شبکه/زیرشبکه/VLAN شامل میزبان‌ها را تشکیل می‌دهند.

امروزه، شبکه‌های IP معمولاً با استفاده از قالب CIDR به همراه یک پیشوند مشخص‌کنندهٔ اندازهٔ netmask تعیین می‌شوند. در دنیای واقعی، روش‌های متعددی برای بیان یک "شبکه" وجود دارد و انعطاف‌پذیری سازندهٔ کلاس IPNetwork بازتاب‌دهندهٔ این موضوع است.

محدوده‌های دلخواه نشانی IP

کتابخانهٔ netaddr طوری طراحی شده است تا روش‌های گوناگونی را که در آن‌ها گروه‌هایی از نشانی‌های IP و شبکه‌های IP مشخص می‌شوند پوشش دهد؛ نه تنها در پیکربندی‌های مسیریاب، بلکه در شکل‌های کمتر استاندارد اما خواناتر برای انسان که برای نمونه در فایل‌های پیکربندی یافت می‌شوند.

گزینه‌هایی که در حال حاضر در دسترس هستند در ادامه آمده‌اند.

محدوده‌های کران‌دار

یک محدودهٔ کران‌دار، گروهی از نشانی‌های IP است که با استفاده از یک نشانی آغازین و یک نشانی پایانی مشخص شده و یک بلوک پیوسته را تشکیل می‌دهند. هیچ مرز بیتی مفروض نیست، اما نشانی پایانی باید از نظر عددی بزرگ‌تر یا مساوی نشانی آغازین باشد.

محدوده‌های IP glob

روشی بسیار کاربردی برای نمایش شبکهٔ IP در فایل‌های پیکربندی و در خط فرمان برای کسانی که با CIDR آشنایی ندارند.

کلاس IPGlob برای نمایش تک‌تک محدوده‌های glob به کار می‌رود.

توابع globbing

توانایی تبدیل بین محدوده‌های glob و محدوده‌های CIDR و IP نیز بسیار کاربردی است. تابع زیر این تبدیل‌های گوناگون را امکان‌پذیر می‌سازد.

محدوده‌های nmap

ابزار nmap یک ابزار شناخته‌شدهٔ امنیت شبکه است. این ابزار روش انعطاف‌پذیر ویژه‌ای برای تعیین گروه‌بندی‌های نشانی IP دارد.

توابعی ارائه شده‌اند که امکان اعتبارسنجی و شمارش نشانی‌های IP مشخص‌شده در این قالب را فراهم می‌کنند.

مجموعه‌های IP

هنگام کار با تعداد زیادی از نشانی‌ها و محدوده‌های IP، اغلب دستکاری آن‌ها به عنوان مجموعه مفید است تا بتوانید اشتراک، اجتماع و تفاضل میان گروه‌های گوناگون آن‌ها را محاسبه کنید.

کلاس IPSet مشخصاً برای همین هدف ساخته شده است.

توابع و مولدهای IP

موارد زیر مجموعه‌ای از توابع کمکی کاربردی مرتبط با قالب‌های گوناگون پشتیبانی‌شده در این کتابخانه هستند..SS آدرس‌های MAC و استاندارد IEEE EUI

یک آدرس MAC، یک آدرس سخت‌افزاری 48-بیتی مرتبط با یک رابط فیزیکی مشخص در یک میزبان شبکه‌ای است. آن‌ها در تمامی دستگاه‌های شبکه‌ای یافت می‌شوند و برای شناسایی فریم‌ها (در لایه ۲) در پشته شبکه به کار می‌روند.

از کلاس EUI برای نمایش آدرس‌های MAC (و همچنین نمونه‌های بزرگ‌تر و کمتر رایج 64-بیتی آن‌ها) استفاده می‌شود.

گویش‌های قالب‌بندی MAC

از گویش‌های زیر برای مشخص کردن قالب‌بندی آدرس‌های MAC استفاده می‌شود.

توابع اعتبارسنجی

کمی سرگرمی

چه کسی گفته شبکه همیشه باید خشک و جدی باشد؟ همیشه خوب است که فضا را تلطیف کنیم و کمی سرگرمی داشته باشیم.

بیایید واقع‌بین باشیم؛ هیچ کتابخانه شبکهٔ درست‌وحسابی بدون پشتیبانی از RFC 1924 - http://www.ietf.org/rfc/rfc1924 کامل نخواهد بود :-)

ابزار خط فرمان (CLI)

بسته netaddr شامل یک برنامه خط فرمانی netaddr است.

نکته:

برای مشاهده نحوه استفاده:

% netaddr --help
               __            __    __
   ____  ___  / /_____ _____/ /___/ /____
  / __ \/ _ \/ __/ __ `/ __  / __  / ___/
 / / / /  __/ /_/ /_/ / /_/ / /_/ / /
/_/ /_/\___/\__/\__,_/\__,_/\__,_/_/
usage: netaddr [-h]
The netaddr CLI tool
options:
-h, --help  show this help message and exit
Share and enjoy!

پوسته تعاملی

فراخوانی netaddr بدون هیچ آرگومانی یک پوسته تعاملی را اجرا می‌کند.

این پوسته در صورت در دسترس بودن از IPython https://pypi.org/project/ipython و در غیر این صورت از REPL توکار Python استفاده می‌کند. REPL مربوط به IPython قابلیت‌های بیشتری دارد و در مجموع تجربه کاربری بهتری ارائه می‌دهد.

این پوسته تمام بخش‌های API مربوط به netaddr <> را از پیش وارد می‌کند (pre-imported) تا بتوانید بلافاصله و با کمترین زحمت با آن کار کنید:

% netaddr
               __            __    __
   ____  ___  / /_____ _____/ /___/ /____
  / __ \/ _ \/ __/ __ `/ __  / __  / ___/
 / / / /  __/ /_/ /_/ / /_/ / /_/ / /
/_/ /_/\___/\__/\__,_/\__,_/\__,_/_/
netaddr shell 1.0.0 - an interactive shell for the netaddr library
In [1]: '10.0.0.2' in IPNetwork('10.0.0.0/24')
Out[1]: True
In [2]:

تغییریافته در نسخه 1.2.0: وابستگی به IPython اختیاری شد..SS اطلاعات شبکه

برای نمایش اطلاعات یک شبکه IP، دستور netaddr info <network> را اجرا کنید:

% netaddr info 192.2.2.27/24
               __            __    __
   ____  ___  / /_____ _____/ /___/ /____
  / __ \/ _ \/ __/ __ `/ __  / __  / ___/
 / / / /  __/ /_/ /_/ / /_/ / /_/ / /
/_/ /_/\___/\__/\__,_/\__,_/\__,_/_/
IP network information
CIDR                     192.2.2.0/24
Network IP               192.2.2.0
Network IP (binary)      11000000.00000010.00000010.00000000
Network IP (decimal)     3221357056
Network IP (hex)         0xc0020200
Subnet mask              255.255.255.0
Subnet mask (binary)     11111111.11111111.11111111.00000000
Broadcast IP             192.2.2.255
Range                    192.2.2.0-192.2.2.255
Total addresses          256
Usable range             192.2.2.1-192.2.2.254
Usable addresses         254

استانداردها و مراجع

مراجع زیر برای کتابخانه netaddr کاربرد دارند.

RFCها

RFCهای زیر راهنمای مجموعه ویژگی‌ها و قابلیت‌های netaddr بوده‌اند.

IPv4

چندپخشی (IPv4)

مسیریابی بین‌دامنه‌ای بدون رده (CIDR)

منابع داده

داده‌های برگرفته از منابع زیر از طریق API بسته netaddr ارائه می‌شوند.

مرجع واگذاری اعداد اینترنتی (IANA)

نحوه انتشار netaddr

در اینجا نحوه انتشار نسخه جدیدی از netaddr آورده شده است.

pip install --upgrade wheel twine

make build-and-publish

git tag -a x.y.z -m 'Release version x.y.z'
make push_tags

NEXT_NETADDR_VERSION

تاریخ: هنوز منتشر نشده است

انتشار: 1.3.0

تاریخ: 2024-05-28

افزوده‌شده:

برطرف‌شده:

انتشار: 1.2.1

تاریخ: 2024-02-17

برطرف‌شده:

انتشار: 1.2.0

تاریخ: 2024-02-17

افزوده‌شده:

تغییریافته:

برطرف‌شده:

انتشار: 1.1.0

تاریخ: 2024-02-15

افزوده‌شده:

برطرف‌شده:

انتشار: 0.10.1

تاریخ: 2024-01-02

رفع‌شده:

منسوخ‌شده:

انتشار: 0.9.0 (Release: 0.9.0)

تاریخ: 2023-09-18

افزوده‌شده:

برطرف‌شده:

سایر:

تغییرات از 0.7.20

اشکالات مشخص برطرف‌شده در این انتشار

متفرقه (Miscellanea)

انتشار: 0.7.20

تاریخ: 19 ژوئن 2020

تغییرات از 0.7.19

اشکالات مشخص برطرف‌شده در این انتشار

انتشار: 0.7.19 (Release: 0.7.19)

تاریخ: ۱۱ ژانویه ۲۰۱۷ (11 Jan 2017)

تغییرات از نسخهٔ 0.7.18 (Changes since 0.7.18)

باگ‌های خاص رفع‌شده در این انتشار (Specific bug fixes addressed in this release)

متفرقه (Miscellanea)

انتشار: 0.7.18 (Release: 0.7.18)

تاریخ: ۴ سپتامبر ۲۰۱۵ (4 Sep 2015)

تغییرات از نسخهٔ 0.7.17 (Changes since 0.7.17)

انتشار: 0.7.17

تاریخ: ۳۱ اوت ۲۰۱۵

تغییرات از زمان 0.7.16

باگ‌های خاص رفع‌شده در این انتشار

انتشار: 0.7.16

تاریخ: ۳۰ اوت ۲۰۱۵

تغییرات از زمان 0.7.15

باگ‌های خاص رفع‌شده در این انتشار

تغییرات از 0.7.14

اشکالات خاص برطرف‌شده در این انتشار

انتشار: 0.7.14

تاریخ: ۳۱ مارس ۲۰۱۵

تغییرات از 0.7.13

اشکالات خاص برطرف‌شده در این انتشار

تغییرات نسبت به 0.7.12

رفع باگ‌های خاص انجام‌شده در این انتشار

انتشار: 0.7.12

تاریخ: 6 ژوئیه 2014

تغییرات نسبت به 0.7.11

رفع باگ‌های خاص انجام‌شده در این انتشار

انتشار: 0.7.11

تاریخ: 19 مارس 2014

تغییرات نسبت به 0.7.10

تغییرات از نسخهٔ 0.7.9

باگ‌های خاص رفع‌شده در این انتشار

رفع Issue 36 - https://github.com/drkjam/netaddr/issues/36

رفع Issue 35 - https://github.com/drkjam/netaddr/issues/35

رفع Issue 34 - https://github.com/drkjam/netaddr/issues/34

رفع Issue 33 - https://github.com/drkjam/netaddr/issues/33

رفع Issue 23 - https://github.com/drkjam/netaddr/issues/23

رفع Issue 22 - https://github.com/drkjam/netaddr/issues/22

انتشار: 0.7.9

تاریخ: ۲۸ اوت ۲۰۱۲

تغییرات از نسخهٔ 0.7.8

انتشار: 0.7.8

تاریخ: ۲۸ اوت ۲۰۱۲

تغییرات از نسخهٔ 0.7.7

باگ‌های خاص رفع‌شده در این انتشار

رفع Issue 31 - https://github.com/drkjam/netaddr/issues/31

رفع Issue 28 - https://github.com/drkjam/netaddr/issues/28

رفع Issue 25 - https://github.com/drkjam/netaddr/issues/25

رفع Issue 21 - https://github.com/drkjam/netaddr/issues/21

تغییرات نسبت به 0.7.6

اشکالات مشخص رفع‌شده در این انتشار

رفع مشکل 24 - https://github.com/drkjam/netaddr/issues/24

رفع مشکل 17 - https://github.com/drkjam/netaddr/issues/17

رفع مشکل 20 - https://github.com/drkjam/netaddr/issues/20

انتشار: 0.7.6

تاریخ: ۱۳ سپتامبر ۲۰۱۱

تغییرات نسبت به 0.7.5

اشکالات مشخص رفع‌شده در این انتشار

رفع مشکل 15 - https://github.com/drkjam/netaddr/issues/15

رفع مشکل 13 - https://github.com/drkjam/netaddr/issues/13

رفع مشکل 11 - https://github.com/drkjam/netaddr/issues/11

رفع مشکل 7 - https://github.com/drkjam/netaddr/issues/7

رفع مشکل 2 - https://github.com/drkjam/netaddr/issues/2

انتشار: 0.7.5 (Release: 0.7.5)

تاریخ: ۵ اکتبر ۲۰۱۰

تغییرات نسبت به 0.7.4 (Changes since 0.7.4)

اشکالات خاص برطرف‌شده در این انتشار (Specific bug fixes addressed in this release)

رفع مشکل ۴۹ - http://code.google.com/p/netaddr/issues/detail?id=49

رفع مشکل ۵۰ - http://code.google.com/p/netaddr/issues/detail?id=50

رفع مشکل ۵۲ - http://code.google.com/p/netaddr/issues/detail?id=52

رفع مشکل ۵۳ - http://code.google.com/p/netaddr/issues/detail?id=53

رفع مشکل ۵۴ - http://code.google.com/p/netaddr/issues/detail?id=54

رفع مشکل ۵۵ - http://code.google.com/p/netaddr/issues/detail?id=55

رفع مشکل ۵۶ - http://code.google.com/p/netaddr/issues/detail?id=56

رفع مشکل ۵۷ - http://code.google.com/p/netaddr/issues/detail?id=57

رفع مشکل ۵۸ - http://code.google.com/p/netaddr/issues/detail?id=58

رفع مشکل ۵۹ - http://code.google.com/p/netaddr/issues/detail?id=59

انتشار: 0.7.4

تاریخ: ۲ دسامبر ۲۰۰۹

تغییرات نسبت به 0.7.3

انتشار: 0.7.3

تاریخ: ۱۴ سپتامبر ۲۰۰۹

تغییرات نسبت به 0.7.2

رفع باگ‌های خاص پرداخته‌شده در این انتشار

رفع Issue 44 - http://code.google.com/p/netaddr/issues/detail?id=44

رفع Issue 46 - http://code.google.com/p/netaddr/issues/detail?id=46

رفع Issue 47 - http://code.google.com/p/netaddr/issues/detail?id=47

انتشار: 0.7.2

تاریخ: ۲۰ اوت ۲۰۰۹

تغییرات نسبت به 0.7.1

انتشار: 0.7.1

تاریخ: ۱۴ اوت ۲۰۰۹

تغییرات نسبت به 0.7

رفع باگ‌های خاص انجام‌شده در این انتشار

رفع شد: Issue 42 - http://code.google.com/p/netaddr/issues/detail?id=42

انتشار: 0.7

تاریخ: ۱۱ اوت ۲۰۰۹

تغییرات نسبت به 0.6.x

لطفاً توجه داشته باشید - این انتشار یک بازنگری اساسی در netaddr است. این تغییرات سازگاری عقبرو با نسخه‌های پیشین را می‌شکند. برای جزئیات کامل امکانات در دسترس، به مستندات API مراجعه کنید.

برخی از نکات برجسته تغییرات:-

انتشار: 0.6.4

تاریخ: 11 اوت 2009

اشکالات خاص برطرف‌شده در این انتشار

رفع مسئله 40 - http://code.google.com/p/netaddr/issues/detail?id=40

انتشار: 0.6.3

تاریخ: 23 ژوئن 2009

تغییرات نسبت به 0.6.2

اشکالات خاص برطرف‌شده در این انتشار

رفع مسئله 33 - http://code.google.com/p/netaddr/issues/detail?id=33

رفع مسئله 35 - http://code.google.com/p/netaddr/issues/detail?id=35

رفع مسئله 36 - http://code.google.com/p/netaddr/issues/detail?id=36

رفع مسئله 37 - http://code.google.com/p/netaddr/issues/detail?id=37

رفع مسئله 38 - http://code.google.com/p/netaddr/issues/detail?id=38

رفع مسئله 39 - http://code.google.com/p/netaddr/issues/detail?id=39

تغییرات از نسخه 0.6.1

رفع باگ‌های خاص انجام‌شده در این انتشار

رفع مشکل Issue 32 - http://code.google.com/p/netaddr/issues/detail?id=32

انتشار: 0.6.1

تاریخ: ۶ آوریل ۲۰۰۹

تغییرات از نسخه 0.6

انتشار: 0.6

تاریخ: ۲۰ ژانویه ۲۰۰۹

تغییرات نسبت به 0.5.x

•

اکنون نمایش‌های رشته‌ای بسیار بیشتری از نشانی‌های MAC و IPv4 پشتیبانی می‌شوند

•

تغییر رفتار متد __repr__()

•

تغییر نام ویژگی 'klass' به 'fmt' (format)

•

بازنویسی کامل و یکپارچه‌سازی آزمون‌های واحد (unit tests).

•

پشتیبانی نوپا از eggهای Python و setuptools.

رفع باگ‌های خاص انجام‌شده در این انتشار (Specific bug fixes addressed in this release)

قابلیت‌های آزمایشی (Experimental Features)

باگ‌های خاص رفع‌شده در این انتشار

انتشار: 0.5.1

تاریخ: ۲۳ سپتامبر ۲۰۰۸

باگ‌های خاص رفع‌شده در این انتشار

انتشار: 0.5

تاریخ: ۱۹ سپتامبر ۲۰۰۸

تغییرات نسبت به 0.4.x

عمومی

تغییرات کلاس Addr

تغییرات کلاس IP

تغییرات کلاس AddrRange

تغییرات کلاس CIDR

تغییرات کلاس Wildcard

تغییرات نسبت به 0.3.x

تغییرات نگهداری و ساختاری

netaddr

حق نشر (c) 2008 David P. D. Moss بخش‌هایی حق نشر (c) 2020 مشارکت‌کنندگان netaddr

تحت مجوز BSD منتشر شده است. برای جزئیات به فایل LICENSE مراجعه کنید.

IANA (Internet Assigned Numbers Authority)

پروژه netaddr توسط IANA پشتیبانی مالی یا تأیید نشده است.

استفاده از داده‌های IANA (مرجع واگذاری اعداد اینترنتی) مشمول حق نشر بوده و با اجازه کتبی قبلی ارائه شده است.

فایل‌های داده IANA که همراه netaddr گنجانده شده‌اند، به هیچ وجه تغییر نیافته‌اند، بلکه تجزیه شده و از طریق یک API در دسترس کاربران نهایی قرار گرفته‌اند.

برای نشانی‌های اینترنتی مربوط به آخرین نسخه‌های فایل‌های مربوطه، فایل README و کد منبع را ببینید..SS "IEEE (مؤسسه مهندسان برق و الکترونیک)"

netaddr توسط IEEE حمایت مالی یا تأیید نشده است.

استفاده از داده‌های IEEE (مؤسسه مهندسان برق و الکترونیک) مشمول حق نشر (کپی‌رایت) است. برای جزئیات به نشانی اینترنتی زیر مراجعه کنید:

http://www.ieee.org/web/publications/rights/legal.html

فایل‌های دادهٔ IEEE گنجانده‌شده در netaddr به هیچ وجه دستکاری نشده‌اند، بلکه تجزیه شده و از طریق یک API در دسترس کاربران نهایی قرار گرفته‌اند. هیچ تضمینی وجود ندارد که فایل‌های ارجاع‌شده منسوخ نشده باشند.

برای نشانی‌های اینترنتی آخرین نسخه‌های فایل‌های مربوطه، فایل README و کد منبع را ببینید.

netaddr

حق نشر و مجوز (COPYRIGHT AND LICENSE)

Copyright (c) 2008 David P. D. Moss Portions Copyright (c) 2020 netaddr contributors

توزیع مجدد و استفاده در قالب‌های سورس و باینری، با یا بدون تغییر، مجاز است به شرطی که شرایط زیر برآورده شوند:

این نرم‌افزار توسط دارندگان حق نشر و مشارکت‌کنندگان به‌صورت «همان‌گونه که هست» ("AS IS") ارائه می‌شود و هرگونه ضمانت صریح یا ضمنی، از جمله، اما نه محدود به، ضمانت‌های ضمنی قابلیت خرید و فروش و تناسب برای یک هدف خاص، سلب می‌شود. تحت هیچ شرایطی، دارندهٔ حق نشر یا مشارکت‌کنندگان در قبال هرگونه خسارت مستقیم، غیرمستقیم، اتفاقی، خاص، نمونه‌ای، یا تبعی (از جمله، اما نه محدود به، تهیهٔ کالاها یا خدمات جایگزین؛ از دست دادن استفاده، داده‌ها یا سود؛ یا وقفه در کسب‌وکار) به هر نحوی که ایجاد شده باشد و بر پایهٔ هر تئوری مسئولیت، خواه قراردادی، مسئولیت مطلق یا شبه‌جرم (از جمله سهل‌انگاری یا موارد دیگر) که به هر نحوی از استفاده از این نرم‌افزار ناشی شود، مسئولیتی نخواهند داشت، حتی در صورتی که احتمال وقوع چنین خسارتی تذکر داده شده باشد.