नेटलिंक का उपयोग करके सरल लिनक्स नेटवर्क इंटरफेस मॉनिटर

एक बार, एक परियोजना में, मुझे सभी नेटवर्क इंटरफेस, रूटिंग टेबल पर सख्त और विश्वसनीय नियंत्रण को व्यवस्थित करने की आवश्यकता थी, साथ ही किसी भी बदलाव की सूचना भी प्राप्त हुई। एक रणनीतिक निर्णय किया गया था - अच्छे पुराने ioctl netdevice (SIOCGIFMETRIC, SIOCSIFNAME, आदि) या संबंधित उपयोगिताओं (ifconfig, मार्ग, आदि) को सीधे कॉल का उपयोग नहीं करने के लिए, लेकिन एक अधिक आधुनिक और अधिक सुविधाजनक समाधान खोजने के लिए। यह पाया गया - libnetlink। यह एक पुस्तकालय है जो नेटलिंक तंत्र का उपयोग करके कर्नेल के साथ संचार करने के लिए बड़ी संख्या में तरीके प्रदान करता है। यह लाइब्रेरी मेरे उद्देश्यों के लिए आदर्श रूप से अनुकूल थी, जिससे मुझे बड़ी संख्या में कार्यों को हल करने की अनुमति मिली। दुर्भाग्य से, लाइब्रेरी बहुत सुविधाजनक नहीं थी बल्कि जटिल एपीआई थी, जिसमें बहुत सारी अस्पष्ट क्रियाएं थीं। प्रलेखन की लगभग पूर्ण अनुपस्थिति और इस विषय पर आम तौर पर किसी भी सामग्री ने विशेष मज़ा जोड़ा।
सोचने के बाद, मैंने नेटलिंक को ठीक से समझने और अपनी लाइब्रेरी लिखने का फैसला किया। फिलहाल, सूचनाओं, नेटवर्क इंटरफेस, राउटिंग टेबल के साथ काम करने के लिए सभी कार्यक्षमता, निश्चित रूप से IPv4 और IPv6 समर्थित हैं। जल्द ही इस परियोजना को जनता के सामने पेश किया जाएगा :) अब के लिए, मैं उन सभी को पेश करना चाहूंगा जो नेटवर्क इंटरफेस के एक साधारण मॉनिटर के उदाहरण का उपयोग करते हुए, नेटलिंक की खूबसूरत दुनिया में दिलचस्पी रखते हैं।

नेटलिंक क्या है?

तो, नेटलिंक उपयोगकर्ता अंतरिक्ष और लिनक्स कर्नेल के बीच संवाद करने का एक सुविधाजनक तरीका है। संचार एक नियमित सॉकेट का उपयोग करके किया जाता है, एक विशेष प्रोटोकॉल का उपयोग करके - AF_NETLINK।
नेटलिंक आपको कर्नेल सबसिस्टम की एक बड़ी संख्या के साथ सहभागिता करने की अनुमति देता है - इंटरफेस, रूटिंग, नेटवर्क पैकेट फ़िल्टर। इसके अलावा, आप अपने कर्नेल मॉड्यूल के साथ संवाद कर सकते हैं। बेशक, बाद वाले को इस प्रकार के संचार का समर्थन करना चाहिए।
प्रत्येक नेटलिंक संदेश एक हेडर होता है जो कि शम्सगड्र संरचना द्वारा प्रस्तुत किया जाता है, साथ ही एक निश्चित संख्या में बाइट्स - एक "पेलोड"। यह "लोड" किसी प्रकार की संरचना, या सिर्फ रॉ डेटा हो सकता है। संदेश, प्रसव के दौरान, कई हिस्सों में टूट सकता है। ऐसे मामलों में, प्रत्येक बाद के पैकेट को ध्वज NLM_F_MULTI, और अंतिम ध्वज NLMSG_DONE से चिह्नित किया जाता है। संदेशों के विश्लेषण के लिए हेडर फ़ाइलों netlink.h और rtnetlink.h में परिभाषित मैक्रोज़ का एक पूरा सेट है

एक नेटलिंक सॉकेट बनाएं।

एक नेटलिंक सॉकेट घोषणा बहुत मानक लगती है:

socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)

जहाँ AF_NETLINK - नेटलिंक प्रोटोकॉल
SOCK_RAW - सॉकेट प्रकार
NETLINK_ROUTE - नेटलिंक प्रोटोकॉल परिवार।

अंतिम पैरामीटर अलग हो सकता है, जो हम नेटलिंक से प्राप्त करना चाहते हैं उसके आधार पर हो सकता है।
मैं सबसे दिलचस्प मापदंडों के साथ एक तालिका दूंगा (प्रलेखन में मापदंडों की पूरी सूची मिल सकती है):

NETLINK_ROUTE - रूटिंग टेबल और नेटवर्क इंटरफेस में परिवर्तन की सूचनाएँ प्राप्त करें।
इसका उपयोग उपरोक्त वस्तुओं के सभी मापदंडों को बदलने के लिए भी किया जा सकता है।
NETLINK_USERSOCK - उपयोगकर्ता प्रोटोकॉल को परिभाषित करने के लिए आरक्षित है।
NETLINK_FIREWALL - नेटवर्क फ़िल्टर से उपयोगकर्ता स्तर तक IPv4 पैकेट को स्थानांतरित करने का कार्य करता है
NETLINK_INET_DIAG - इनसेट सॉकेट की निगरानी करना
NETLINK_NFLOG - ULOG नेटवर्क / पैकेट फ़िल्टर
NETLINK_SELINUX - सेलिनक्स प्रणाली से सूचनाएं प्राप्त करता है
NETLINK_NETFILTER - नेटवर्क फ़िल्टर सबसिस्टम के साथ काम करें
NETLINK_KOBJECT_UEVENT - कर्नेल संदेश प्राप्त करना

इसके अलावा, बनाए गए सॉकेट का उपयोग संदेश भेजने के लिए किया जा सकता है, उदाहरण के लिए, सेंड फंक्शन का उपयोग करके और पुनः प्राप्त करने वाले संदेशों का उपयोग करके।

नेटलिंक संदेश।

संदेश शीर्ष लेख का प्रतिनिधित्व nlmsghdr संरचना द्वारा किया जाता है।

 struct nlmsghdr { __u32 nlmsg_len; //  ,    __u16 nlmsg_type; //    (  ) __u16 nlmsg_flags; //    __u32 nlmsg_seq; //    __u32 nlmsg_pid; //   (PID),   }; 

Nlmsg_type फ़ील्ड मानक संदेश प्रकारों में से एक को इंगित कर सकती है:
NLMSG_NOOP - इस प्रकार के संदेशों को अनदेखा किया जाता है।
NLMSG_ERROR - एक त्रुटि संदेश, और nlmsgerr संरचना पेलोड अनुभाग में होगी (नीचे देखें)
NLMSG_DONE - इस ध्वज के साथ एक संदेश को पूरा करना चाहिए संदेश, कई भागों में विभाजित है

Nlmsgerr संरचना

 struct nlmsgerr { int error; //     struct nlmsghdr msg; //  ,    }; 

संदेश एक या अधिक हो सकते हैं (विभिन्न प्रकार के तार्किक या) प्रकार के संचालन का उपयोग करके संयुक्त होते हैं:

NLM_F_REQUEST - संदेश - किसी चीज़ के लिए अनुरोध
NLM_F_MULTI - संदेश, संदेश का हिस्सा भागों में टूट गया है
NLM_F_ACK - संदेश - पुष्टिकरण अनुरोध
NLM_F_ECHO - गूंज अनुरोध। सामान्य दिशा कर्नेल स्तर से उपयोगकर्ता स्तर तक क्वेरी है
NLM_F_ROOT - इस प्रकार की क्वेरी एक निश्चित इकाई के अंदर एक निश्चित तालिका लौटाती है
NLM_F_MATCH - क्वेरी सभी मिले हुए मैचों को लौटाता है
NLM_F_ATOMIC - एक निश्चित तालिका का परमाणु टुकड़ा लौटाता है
NLM_F_DUMP - NLM_F_ROOT का एनालॉग | NLM_F_MATCH

अतिरिक्त झंडे:

NLM_F_REPLACE - एक मौजूदा समान वस्तु को प्रतिस्थापित करता है
NLM_F_EXCL - यदि ऐसी कोई वस्तु पहले से मौजूद है तो उसे प्रतिस्थापित न करें
NLM_F_CREATE - मौजूद न होने पर एक ऑब्जेक्ट बनाएं
NLM_F_APPEND - सूची में एक मौजूदा एक वस्तु जोड़ें

ग्राहकों की पहचान करने के लिए (कर्नेल स्तर पर और उपयोगकर्ता स्तर पर), एक विशेष पता संरचना है - nladdr:

 struct sockaddr_nl { sa_family_t nl_family; //   -  AF_NETLINK unsigned short nl_pad; //     pid_t nl_pid; //   __u32 nl_groups; //   / }; 

nl_pid एक अद्वितीय सॉकेट पता है। कर्नेल में ग्राहकों के लिए, यह हमेशा शून्य होता है। उपयोगकर्ता स्तर पर उपयोगकर्ताओं के लिए, यह सॉकेट के स्वामित्व वाली प्रक्रिया के पहचानकर्ता के बराबर है। प्रत्येक पहचानकर्ता अद्वितीय होना चाहिए, इसलिए जब आप एक बहु-थ्रेडेड एप्लिकेशन में कई नेटलिंक सॉकेट बनाने का प्रयास करते हैं, तो आप एक समस्या का सामना कर सकते हैं: एक नया सॉकेट बनाते समय, त्रुटि "ऑपरेशन की अनुमति नहीं" वापस आ जाएगी। इस सीमा के आसपास काम करने के लिए, nl_pid को इस अभिव्यक्ति का मान सौंपा जाना चाहिए:
pthread_self() << 16 | getpid();
सॉकेट के लिए पहचानकर्ता मान को बाइंड होने से पहले असाइन किया जाना चाहिए।
इसके अलावा, पहचानकर्ता को एक शून्य मान सौंपा जा सकता है। इस मामले में, कर्नेल विशिष्ट पहचानकर्ता उत्पन्न करेगा, लेकिन एप्लिकेशन में बनाए गए पहले सॉकेट को हमेशा इस एप्लिकेशन के पहचानकर्ता मान को सौंपा जाएगा।

nl_groups एक बिटमास्क है, जिसमें से प्रत्येक बिट एक नेटलिंक समूह संख्या का प्रतिनिधित्व करता है। नेटलिंक सॉकेट पर बाइंड () कॉल करते समय, उस समूह के बिट मास्क को निर्दिष्ट करें जिसे एप्लिकेशन इस संदर्भ में सुनना चाहता है। विभिन्न समूहों को तार्किक या का उपयोग करके जोड़ा जा सकता है।
प्रमुख समूह नेटलिंक हेडर फ़ाइल में परिभाषित किए गए हैं।
उनमें से कुछ का एक उदाहरण:

RTMGRP_LINK - यह समूह नेटवर्क इंटरफेस में बदलाव की सूचना प्राप्त करता है (इंटरफ़ेस सेवानिवृत्त, जोड़ा, गिरा, गुलाब)
RTMGRP_IPV4_IFADDR - इस समूह को इंटरफेस के IPv4 पतों में परिवर्तन की सूचना प्राप्त होती है (पता जोड़ा या हटा दिया गया है)
RTMGRP_IPV6_IFADDR - इस समूह को इंटरफेस के IPv6 पतों में परिवर्तन की सूचना मिलती है (पता जोड़ा या हटा दिया गया था)
RTMGRP_IPV4_ROUTE - इस समूह को IPv4 पतों के लिए राउटिंग टेबल में बदलाव की सूचनाएँ मिलती हैं
RTMGRP_IPV6_ROUTE - इस समूह को IPv6 पतों के लिए राउटिंग टेबल में बदलाव की सूचनाएँ मिलती हैं

Nlmsghdr हेडर संरचना के बाद, डेटा ब्लॉक के लिए हमेशा एक सूचक होता है। मैक्रोज़ का उपयोग करके इसे प्राप्त किया जा सकता है, जिसे बाद में वर्णित किया जाएगा।

नेटलिंक मैक्रोज़

इस मामले में सबसे उपयोगी, मैक्रो हैं:
NLMSG_ALIGN - निकटतम बड़ी सीमा-संरेखित मान के लिए नेटलिंक संदेश के आकार को सीमाबद्ध करता है ।
NLMSG_LENGTH - डेटा फ़ील्ड (पेलोड) के आकार को एक पैरामीटर के रूप में लेता है और nlmsgdlen हेडर के nlmsg_len क्षेत्र के लिए लिखने के लिए एक सीमा-संरेखित आकार मान देता है।
NLMSG_SPACE - वह आकार लौटाता है जो नेटलिंक पैकेट में निर्दिष्ट लंबाई के डेटा पर कब्जा करेगा।
NLMSG_DATA - पास किए गए nlmsghdr हेडर से जुड़े डेटा के लिए एक पॉइंटर लौटाता है।
NLMSG_NEXT - एक संदेश के अगले भाग को कई भागों से मिलकर लौटाता है। मैक्रो एक बहु-भाग संदेश में निम्नलिखित nlmsghdr हेडर को स्वीकार करता है। कॉल करने वाले एप्लिकेशन को वर्तमान एम्‍म्‍समैगड्रर हेडर में NLMSG_DONE फ्लैग की जाँच करनी चाहिए - जब संदेश संसाधित होता है तो फ़ंक्शन NULL नहीं लौटता है। दूसरा पैरामीटर संदेश बफ़र के शेष भाग का आकार सेट करता है। मैसेज हेडर के आकार द्वारा मैक्रो इस मान को कम कर देता है।
NLMSG_OK - यदि संदेश काट नहीं किया गया था और उसका डिस्सेक्शन सफल रहा था तो यह सही है।
NLMSG_PAYLOAD - nlmsghdr हैडर से जुड़े पेलोड डेटा का आकार लौटाता है।

सिद्धांत से अभ्यास तक।

तो ठीक है। मुझे लगता है कि मैं पहले से ही एक उबाऊ सिद्धांत से ऊब गया था :) शायद कुछ भ्रमित या समझ में नहीं आ रहा था - मैं उदाहरणों में सब कुछ चबाने की कोशिश करूंगा, वहां वास्तव में कुछ भी जटिल नहीं है।
नीचे वादा किया गया आवेदन है जो नेटवर्क इंटरफेस और रूटिंग टेबल में बदलाव की सूचना प्राप्त करेगा।
उदाहरण में, कई नए ढांचे पेश किए गए हैं:

 struct iovec { void *iov_base; //   __kernel_size_t iov_len; //   }; 

यह संरचना नेटलिंक सॉकेट्स के माध्यम से प्रेषित उपयोगी डेटा के भंडार के रूप में कार्य करती है। Iov_base फ़ील्ड को एक बाइट सरणी के लिए एक संकेत दिया गया है। यह इस बाइट सरणी में है कि संदेश डेटा लिखा जाएगा।

 struct msghdr { void *msg_name; //   ( ) int msg_namelen; //   struct iovec *msg_iov; //     __kernel_size_t msg_iovlen; //    void *msg_control; //    ,      __kernel_size_t msg_controllen; //     unsigned msg_flags; //   }; 

यह संरचना सीधे सॉकेट के माध्यम से प्रेषित होती है। इसमें एक संकेतक होता है उपयोगी डेटा के ब्लॉक में, ब्लॉक डेटा की मात्रा, साथ ही साथ कई अतिरिक्त झंडे और फ़ील्ड जो अधिकांश भाग के लिए आए हैं, बीएसडी प्लेटफॉर्म से।

 struct ifinfomsg { unsigned char ifi_family; //  (AF_UNSPEC) unsigned short ifi_type; //   int ifi_index; //   unsigned int ifi_flags; //   unsigned int ifi_change; //  ,           0xFFFFFFFF }; 

इस संरचना का उपयोग नेटवर्क डिवाइस, उसके परिवार, प्रकार, सूचकांक और झंडे का प्रतिनिधित्व करने के लिए किया जाता है।

 struct ifaddrmsg { unsigned char ifa_family; //   (AF_INET  AF_INET6) unsigned char ifa_prefixlen; //    (  ) unsigned char ifa_flags; //   unsigned char ifa_scope; //   int ifa_index; //  ,     ifinfomsg }; 

इस संरचना का उपयोग नेटवर्क इंटरफ़ेस को निर्दिष्ट नेटवर्क पते का प्रतिनिधित्व करने के लिए किया जाता है।

 struct rtattr { unsigned short rta_len; //   unsigned short rta_type; //   /*  */ } 

इस संरचना का उपयोग किसी भी कनेक्शन पैरामीटर या पते को संग्रहीत करने के लिए किया जाता है।

स्रोत कोड मॉनिटर

 #include <errno.h> #include <stdio.h> #include <memory.h> #include <net/if.h> #include <arpa/inet.h> #include <sys/socket.h> #include <linux/rtnetlink.h> //   ,     netlink    //       rtattr void parseRtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len) { memset(tb, 0, sizeof(struct rtattr *) * (max + 1)); while (RTA_OK(rta, len)) { //     if (rta->rta_type <= max) { tb[rta->rta_type] = rta; //  } rta = RTA_NEXT(rta,len); //    } } int main() { int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); //    if (fd < 0) { printf("  netlink : %s", (char*)strerror(errno)); return 1; } struct sockaddr_nl local; //   char buf[8192]; //   struct iovec iov; //   iov.iov_base = buf; //  buf      iov iov.iov_len = sizeof(buf); //    memset(&local, 0, sizeof(local)); //   local.nl_family = AF_NETLINK; //    local.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV4_ROUTE; //    local.nl_pid = getpid(); //       //   netlink -    struct msghdr msg; { msg.msg_name = &local; //   -    msg.msg_namelen = sizeof(local); //   msg.msg_iov = &iov; //     msg.msg_iovlen = 1; //    } if (bind(fd, (struct sockaddr*)&local, sizeof(local)) < 0) { //    printf("   netlink : %s", (char*)strerror(errno)); close(fd); return 1; } //       while (1) { ssize_t status = recvmsg(fd, &msg, MSG_DONTWAIT); //   bind()        //   if (status < 0) { if (errno == EINTR || errno == EAGAIN) { usleep(250000); continue; } printf("   netlink: %s", (char*)strerror(errno)); continue; } if (msg.msg_namelen != sizeof(local)) { //  ,   :) printf("   "); continue; } //    struct nlmsghdr *h; //     for (h = (struct nlmsghdr*)buf; status >= (ssize_t)sizeof(*h); ) { //     int len = h->nlmsg_len; //    int l = len - sizeof(*h); //    char *ifName; //   if ((l < 0) || (len > status)) { printf("  : %i", len); continue; } //    if ((h->nlmsg_type == RTM_NEWROUTE) || (h->nlmsg_type == RTM_DELROUTE)) { //     -   printf("    \n"); } else { //        char *ifUpp; //   char *ifRunn; //   struct ifinfomsg *ifi; //   ,      struct rtattr *tb[IFLA_MAX + 1]; //   , IFLA_MAX   rtnetlink.h ifi = (struct ifinfomsg*) NLMSG_DATA(h); //          parseRtattr(tb, IFLA_MAX, IFLA_RTA(ifi), h->nlmsg_len); //     if (tb[IFLA_IFNAME]) { //   ,    ifName = (char*)RTA_DATA(tb[IFLA_IFNAME]); //   } if (ifi->ifi_flags & IFF_UP) { //    UP   ifUpp = (char*)"UP"; } else { ifUpp = (char*)"DOWN"; } if (ifi->ifi_flags & IFF_RUNNING) { //    RUNNING   ifRunn = (char*)"RUNNING"; } else { ifRunn = (char*)"NOT RUNNING"; } char ifAddress[256]; //    struct ifaddrmsg *ifa; //         struct rtattr *tba[IFA_MAX+1]; //    ifa = (struct ifaddrmsg*)NLMSG_DATA(h); //     parseRtattr(tba, IFA_MAX, IFA_RTA(ifa), h->nlmsg_len); //     if (tba[IFA_LOCAL]) { //      inet_ntop(AF_INET, RTA_DATA(tba[IFA_LOCAL]), ifAddress, sizeof(ifAddress)); //  IP  } switch (h->nlmsg_type) { //   case RTM_DELADDR: printf("    %s\n", ifName); break; case RTM_DELLINK: printf("   %s\n", ifName); break; case RTM_NEWLINK: printf("  %s,   %s %s\n", ifName, ifUpp, ifRunn); break; case RTM_NEWADDR: printf("     %s: %s\n", ifName, ifAddress); break; } } status -= NLMSG_ALIGN(len); //     (    -   ,   :)) h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len)); //   } usleep(250000); //  ,       } close(fd); //    return 0; } 

कार्यक्रम का संकलन:
gcc monitor.c -o monitor

और काम का परिणाम:


कोड के लिए स्पष्टीकरण।
कार्यक्रम शुरू करने के बाद, हम एक नेटलिंक सॉकेट बनाते हैं और इसके निर्माण की सफलता को सत्यापित करते हैं। इसके बाद, आवश्यक चर घोषित किए जाते हैं और स्थानीय पता संरचना आबाद होती है। यहां हम उन संदेशों के समूहों को इंगित करते हैं जिन्हें हम सदस्यता लेना चाहते हैं: RTMGRP_LINK, RTMGRP_IPV4_IFADDR, RTMGRP_IPV4_ROUTE।
हम संदेश संरचना को भी घोषित करते हैं और एक डेटा ब्लॉक को इसके साथ जोड़ते हैं।
उसके बाद, सॉकेट के साथ बाइंडिंग () का उपयोग करके होता है। उसके बाद हम निर्दिष्ट समूहों के लिए संदेशों के सदस्य बन जाते हैं। आप एक सॉकेट के माध्यम से संदेश प्राप्त कर सकते हैं।
इसके बाद सॉकेट से संदेश प्राप्त करने के लिए एक अंतहीन लूप होता है। क्योंकि प्राप्त डेटा ब्लॉक में कई हेडर और उनसे जुड़े डेटा हो सकते हैं - हम नेटलिंक मैक्रोज़ का उपयोग करके सभी प्राप्त डेटा के माध्यम से सॉर्ट करना शुरू करते हैं।
प्रत्येक नया संदेश पॉइंटर संरचना nlmsghdr * h पर स्थित है।
अब आप संदेश को स्वयं पार्स कर सकते हैं। हम nlmsg_type फ़ील्ड को देखते हैं और यह पता लगाते हैं कि हमें किस प्रकार का संदेश आया। यदि यह रूटिंग टेबल के साथ जुड़ा हुआ है, तो हम संदेश प्रिंट करते हैं और अगले संदेश पर जाते हैं। और यदि नहीं, तो हम विस्तार से समझना शुरू करते हैं।
आरटीएटीआर विकल्पों की घोषणा की जाती है, जहां सभी आवश्यक डेटा जोड़े जाएंगे। इस डेटा को प्राप्त करने के लिए parseRtattr हेल्पर फ़ंक्शन जिम्मेदार है। यह netlink मैक्रोज़ का उपयोग करता है और ifinfomsg या ifaddrmsg संरचना के डेटा ब्लॉक से सभी विशेषताओं के साथ निर्दिष्ट सरणी को पॉप्युलेट करता है।
विशेषताएँ प्राप्त करने के बाद हमें सरणियाँ मिलीं - हम इन मूल्यों के साथ काम कर सकते हैं, उनका विश्लेषण कर सकते हैं, प्रिंट कर सकते हैं।
प्रत्येक विशेषता को इसके सूचकांक द्वारा एक्सेस किया जाता है। सभी सूचकांक नेटलिंक हेडर फाइलों में परिभाषित किए गए हैं और टिप्पणी की गई है।
इस स्थिति में, हम निम्नलिखित सूचकांकों का उपयोग करते हैं:
IFLA_IFNAME - इंटरफ़ेस नाम के साथ विशेषता सूचकांक।
IFA_LOCAL - स्थानीय आईपी पते के साथ विशेषता सूचकांक।
इस सब के बाद, हमारे पास पूरी जानकारी है कि क्या हुआ और स्क्रीन पर जानकारी प्रिंट कर सकते हैं।

वह सब है। मुझे वास्तव में उम्मीद है कि यह सामग्री किसी के लिए उपयोगी होगी।
यदि पर्याप्त लोग हैं (एक से अधिक व्यक्ति :)) - मैं एक अगली कड़ी लिख सकता हूं और विचार कर सकता हूं, उदाहरण के लिए, कर्नेल मॉड्यूल के साथ बातचीत या आईपीवी 6 के साथ काम का कार्यान्वयन।

एक लेख लिखते समय, निम्नलिखित का उपयोग किया गया था:
1. tools.ietf.org/html/rfc3549
2. www.linuxjournal.com/article/7356

आपका ध्यान देने के लिए धन्यवाद।