मल्टीहोमेड लिनक्स राउटर को कॉन्फ़िगर करने के लिए स्क्रिप्ट

एक पूर्ण प्रणाली प्रशासक नहीं होने के नाते, हालांकि, मैं अक्सर एक प्रवेश द्वार को कॉन्फ़िगर करने की आवश्यकता का सामना करता हूं। अब तक, केवल एक बाहरी इंटरफ़ेस था - इसने इंटरनेट और lartc.com पर संकलित एक अपेक्षाकृत सार्वभौमिक बैश स्क्रिप्ट को बदल दिया। जब 2 इंटरनेट प्रदाताओं के साथ विकल्प थे - मैं आसानी से बदलाव के लिए समूहीकृत सेटिंग्स के साथ एक स्क्रिप्ट लिखने में सक्षम था।
स्क्रिप्ट कर सकते हैं:

• NAT का उपयोग कर इंटरनेट वितरण कॉन्फ़िगर करें
• खुले बंदरगाह
• आगे के बंदरगाह
• एक से अधिक प्रदाता का उपयोग करें
• अतिरिक्त वर्णित नियमों और मार्गों को लागू करें
• अतिरिक्त निर्धारित कमांड निष्पादित करें

विवरण

इसे व्यवस्थित किया जाता है ताकि मुख्य अजगर स्क्रिप्ट, अपने आप में सेटिंग्स के अनुसार, एक बैश स्क्रिप्ट बनाती है, जो चलती है। इस तरह की एक चाल पर्याप्त रूप से वजनदार कारण के लिए निकली जिसे नजरअंदाज नहीं किया जा सकता, लेकिन इसे आवाज देने के लिए पर्याप्त नहीं है। लिंक पर सेटिंग्स के साथ स्क्रिप्ट डाउनलोड करें ।
और यहां उनका उपकरण वर्णित है।

सेटिंग्स

पायथन msr_ip.py स्क्रिप्ट आवश्यक इनपुट लाइनों के साथ शुरू होती है:

#! / usr / bin / env अजगर
# - * - कोडिंग: utf-8 - * -

# सेटिंग्स यहाँ हैं

अगला सेटिंग्स की धारा आता है, पहले इंटरफेस का विवरण:

ifaces = [
{
"देव" : "एथ 1" ,
"आईपी" : "192.168.0.1" ,
"भूमिका" : "स्थानीय"
} ,
{
"देव" : "एथ 2"
} ,
{
"देव" : "एथ 3" ,
"आईपी" : "1.2.3.4" ,
"gw" : "1.2.3.1" ,
"टेबल" : "न्यूकॉमपोर्ट" ,
"निशान" : "0x2" ,
"भूमिका" : "बाहरी" ,
"वजन" : 7
} ,
{
"देव" : "ppp0" ,
"gw" : "5.6.7.1" ,
"टेबल" : "वेलनेट" ,
"निशान" : "0x1" ,
"भूमिका" : "बाहरी" ,
"वजन" : 3
} ,
{
"देव" : "ट्यून" ,
"आईपी" : "192.168.1.1" ,
"टेबल" : "वीपीएन" ,
"निशान" : "0x4" ,
"भूमिका" : "स्थानीय"
}
]

निम्नलिखित गुण एक इंटरफ़ेस पर संभव हैं, जो वास्तव में शब्दकोश तत्व हैं:
देव - इंटरफ़ेस नाम, केवल आवश्यक तत्व;
जीडब्ल्यू - गेटवे;
तालिका - रूटिंग तालिका की संख्या या नाम, यदि नाम निर्दिष्ट किया गया है, तो यह पहले से ही फ़ाइल / etc / iproute2 / rt_tables में होना चाहिए। बाहरी इंटरफेस के लिए अनिवार्य;
मार्क - पैकेज के लिए लेबल, यदि आप इसके उपयोग के साथ अपने स्वयं के नियम जोड़ेंगे;
भूमिका - एक भूमिका, बाहरी, स्थानीय या कोई भी हो सकती है। यदि बाहरी - इंटरफ़ेस को बाहरी माना जाता है, तो क्रमशः, यह NAT और बाहर से नए कनेक्शन को स्वीकार नहीं करता है। यदि स्थानीय - इंटरफ़ेस स्थानीय है: NAT और बाहर के लिए एक नया कनेक्शन बना सकता है;
वजन - मार्ग-आधारित आउटबाउंड लोड संतुलन के लिए वजन।
यदि बाहरी इंटरफ़ेस नहीं उठाया गया है, तो उसे डिफ़ॉल्ट मार्गों में सूचीबद्ध नहीं किया जाएगा।
अब उन बंदरगाहों का वर्णन करता है जिन्हें खोलने और / या अग्रेषित करने की आवश्यकता है।

बंदरगाह = [
{
"प्रोटो" : "टीसीपी" ,
"टीपोर्ट" : 22 ,
"sHost" : कोई नहीं ,
"nPort" : कोई नहीं ,
"dHost" : कोई नहीं
}
।
{} पूरे प्रोटोकॉल को तुरंत सक्षम करें
"प्रोटो" : "icmp" ,
"tPort" : कोई नहीं ,
"sHost" : कोई नहीं ,
"nPort" : कोई नहीं ,
"dHost" : कोई नहीं
}
।
{ 192.168.0.3 को इंटरनेट से लैन पर RDP को अग्रेषित करना
"प्रोटो" : "टीसीपी" ,
"टीपोर्ट" : 3389 ,
"sHost" : कोई नहीं ,
"एनपोर्ट" : 3389 ,
"dHost" : "192.168.0.3"
}
।
{ @ 192.168.0.2 को पोर्ट के साथ इंटरनेट से आरडीपी को 3390 में बदल दिया गया
"प्रोटो" : "टीसीपी" ,
"टीपोर्ट" : 3390 ,
"sHost" : कोई नहीं ,
"एनपोर्ट" : 3389 ,
"dHost" : "192.168.0.2"
}
।
{ # केवल एक रिमोट होस्ट से वेब कंट्रोल
"प्रोटो" : "टीसीपी" ,
"टीपोर्ट" : 80 ,
"sHost" : "9.8.7.6" ,
"nPort" : कोई नहीं ,
"dHost" : कोई नहीं
}
।
{ # सभी के लिए 1VPN
"प्रोटो" : "टीसीपी" ,
"टीपोर्ट" : 1194 ,
"sHost" : कोई नहीं ,
"nPort" : कोई नहीं ,
"dHost" : कोई नहीं
}
]

उदाहरणों से सब कुछ स्पष्ट होना चाहिए, लेकिन आदेश के लिए मैं वर्णन करूंगा:
प्रोटो - प्रोटोकॉल;
tPort - खुलने वाला बाहरी बंदरगाह;
sHost - प्रतिबंध, यदि आवश्यक हो, तो स्रोत पते पर;
nPort - अग्रेषण के दौरान नया पोर्ट;
dHost - वह होस्ट जिस पर पोर्ट अग्रेषित किया गया है।

अब बाहरी नोड्स पर नोड्स को बांधने के लिए नियमों का उपयोग किया जाता है:

नियम = [
इसके गेटवे के माध्यम से { प्रदाता आंकड़े
"टू" : "213.79.2.30" , # आंकड़े
"लुकअप" : "वेलनेट"
} ,
{ वीएम टेबल पर वर्चुअल मशीन
"से" : "192.168.0.150" ,
"लुकअप" : "वीएम"
} ,
{ वीएम टेबल पर वर्चुअल मशीन
"से" : "192.168.0.151" ,
"लुकअप" : "वीएम"
}
]

उदाहरण से नियम कुछ गुणों का उपयोग करते हैं, लेकिन आप अधिक आवेदन कर सकते हैं, मैंने आईपी नियम कमांड का समर्थन करने वाली हर चीज को कवर करने की कोशिश की।
cmd - कमांड, डिफ़ॉल्ट रूप से यह एक नियम जोड़ें = जोड़ें;
प्राथमिकता - प्राथमिकता, यदि निर्दिष्ट नहीं है, तो स्वचालित रूप से उल्लेख के क्रम में 1 से गिना जाता है;
fwmark - पैकेट लेबल;
से - स्रोत;
से - गंतव्य;
लुकिंग - टेबल;

अब मार्ग:

मार्ग = [
{{ वीपीएन क्लाइंट के पीछे नेटवर्क
"टू" : "192.168.8.0" ,
"देव" : "ट्यून"
} ,
{ # वीएम टेबल एक प्रदाता के माध्यम से
"टू" : "डिफ़ॉल्ट" ,
"के माध्यम से" : "5.6.7.8" ,
"देव" : "ppp0" ,
"टेबल" : "वीएम"
}
]

से - गंतव्य;
के माध्यम से - जिसके माध्यम से प्रवेश द्वार;
देव - किस इंटरफेस के माध्यम से;
टेबल - किस टेबल के लिए।

अंत में, सेटिंग्स का अंतिम भाग

ext_sure_ip = "8.8.8.8"
customcommands = ""
"" "
cmdfile = "/root/msr_ip.run"

ext_sure_ip - बाहरी इंटरफेस के लिए, जो स्वास्थ्य की जांच के लिए पिंग को संबोधित करता है, फिलहाल यह कुछ भी प्रभावित नहीं करता है;
customcommands - सभी सेटिंग्स के बाद निष्पादित होने की आज्ञा;
cmdfile - वह फ़ाइल जिसमें परिणामी स्क्रिप्ट लिखी जाएगी।

लिपि शरीर

अब केवल स्क्रिप्ट ही है और अधिक सेटिंग्स नहीं होंगी, जिसके बारे में खंड की पूर्ण रेखा हर्षित है और रिपोर्ट करती है:

# == इस पंक्ति के नीचे कोई और कॉन्फ़िगरेशन सेटिंग्स नहीं है ========================

आयात os
आयात syslog
आयात उपप्रकार

Syslog । syslog ( "प्रारंभ" )

फ़ील्ड्स = ( "देव" , "आईपी" , "जीवी" , "टेबल" , "मार्क" , "वर्क्स" , "स्टेट" , "रोल" , "टाइप" , "वेट" )
fout = open ( cmdfile, 'w' )
प्राथमिकता = १

# == सिस्टम के नियम जोड़ें
नियम = नियम + [
{ "प्राथमिकता" : 100 , "से" : "सभी" , "लुकअप" : "स्थानीय" } ,
{ "प्राथमिकता" : 32766 , "से" : "सभी" , "लुकअप" : "मुख्य" } ,
{ "प्राथमिकता" : 32767 , "से" : "सभी" , "लुकअप" : "डिफ़ॉल्ट" }
]


डीप इसुप ( देव ) :
x = उपप्रकार । call ( ( "ifconfig" , dev ] , stdin = none, stdout = open ( '/ dev / null' , 'w' ) , stderr = open ( '/ dev / null' , 'w' ) , shell = False )
यदि ( x == 0 ) :
आर = "अप"
और :
r = "डाउन"
वापसी आर

डीईएफ़ कार्य ( देव ) :
# वैश्विक ext_sure_ip
x = उपप्रकार । कॉल ( [ "पिंग" , "-I" + देव, "-c 3" , "-w 5" , ext_sure_ip ] , stdin = कोई नहीं , stdout = खुला ( '/ dev / null' , 'w ) , stderr = खुला ( '/ देव / नल' , 'w' ) , खोल = गलत )
यदि ( x == 0 ) :
r = सत्य
और :
आर = गलत
वापसी आर

डीफ़ एडिमिसिंगफील्ड्स ( iface ) :
खेतों में बड़ी के लिए:
यदि नहीं ( iface में बड़ी ) :
iface [ fld ] = कोई नहीं

ओपन ओपनस्पोर्ट्स ( पोर्ट ) :
r = "n $ IPTABLES -t फ़िल्टर-एक INPUT"
अगर पोर्ट [ "sHost" ] :
r = r + "-s {0}" । प्रारूप ( बंदरगाह [ "sHost" ] )
अगर पोर्ट [ "प्रोटो" ] :
r = r + "-p {0}" । प्रारूप ( पोर्ट [ "प्रोटो" ] )
अगर बंदरगाह [ "tPort" ] :
r = r + "--dport {0}" । प्रारूप ( पोर्ट [ "tort" ] )
r = r + "-j ACCEPT"
वापसी आर

फॉरवर्डपोर्टपोर्ट ( पोर्ट ) को हराया:
यदि पोर्ट [ "dHost" ] :
# $ IPTABLES -एक फॉरवर्ड -p tcp -dport 3389 -j ACCEPT की अनुमति दें
r = "n $ IPTABLES -A FORWARD"
अगर पोर्ट [ "प्रोटो" ] :
r = r + "-p {0}" । प्रारूप ( पोर्ट [ "प्रोटो" ] )
अगर पोर्ट [ "nPort" ] :
r = r + "--dport {0}" । प्रारूप ( पोर्ट [ "nPort" ] )
r = r + "-j ACCEPT"

# आगे
r = r + "n $ IPTABLES -t nat-PREROUTING"
अगर पोर्ट [ "sHost" ] :
r = r + "-s {0}" । प्रारूप ( बंदरगाह [ "sHost" ] )
अगर पोर्ट [ "प्रोटो" ] :
r = r + "-p {0}" । प्रारूप ( पोर्ट [ "प्रोटो" ] )
अगर बंदरगाह [ "tPort" ] :
r = r + "--dport {0}" । प्रारूप ( पोर्ट [ "tort" ] )
r = r + "-j DNAT -to-गंतव्य {0}" । प्रारूप ( बंदरगाह [ "dHost" ] )
अगर पोर्ट [ "nPort" ] :
r = r + ": {0}" । प्रारूप ( पोर्ट [ "nPort" ] )
वापसी आर
और :
वापसी ""

नियम नियम ( नियम ) को परिभाषित करें:
वैश्विक प्राथमिकता
प्राथमिकता = प्राथमिकता + १
r = "निप नियम"
यदि ( नियम में "cmd" ) और ( नियम [ "cmd" ] ) :
r = r + "{0}" । नियम [ "cmd" ]
और :
r = r + "जोड़ें"

यदि ( नियम में "प्राथमिकता" ) और ( नियम [ "प्राथमिकता" ] ) :
r = r + "प्राथमिकता {0}" । प्रारूप ( नियम [ "प्राथमिकता" ] )
और :
r = r + "प्राथमिकता {0}" । प्रारूप ( प्राथमिकता )

अगर ( नियम में "fwmark" ) और ( नियम [ "fwmark" ] ) :
r = r + "fwmark {0} / {0}" । प्रारूप ( नियम [ "fwmark" ] )

अगर ( " नियम से" ) और ( नियम [ "से" ] ) :
r = r + "{0}" से । प्रारूप ( नियम [ "से" ] )

यदि ( " नियम से" ) और ( नियम [ "से" ] ) :
r = r + "से {0}" । प्रारूप ( नियम [ "से" ] )

यदि ( नियम में "लुकअप" ) और ( नियम [ "लुकअप" ] ) :
r = r + "लुकअप {0}" । प्रारूप ( नियम [ "लुकअप" ] )

वापसी आर

डीईएम रेकमेड ( मार्ग ) :
r = "निप मार्ग जोड़"
यदि ( " मार्ग में " ) और ( मार्ग [ "से" ] ) :
r = r + "{0}" । प्रारूप ( मार्ग [ "से" ] )
# यदि (मार्ग में "नेटमास्क") और (मार्ग ["नेटमास्क"]):
# r = r + "/ {0}"। प्रारूप (मार्ग ["netmask"])
अगर ( " मार्ग में " ) और ( मार्ग [ "से" ] ) :
r = r + "{0}" के माध्यम से । प्रारूप ( मार्ग [ "के माध्यम से" ] )
यदि ( मार्ग में "देव" ) और ( मार्ग [ "देव" ] ) :
r = r + "देव {0}" । प्रारूप ( मार्ग [ "देव" ] )
यदि ( मार्ग में "तालिका" ) और ( मार्ग [ "तालिका" ] ) :
r = r + "तालिका {0}" । प्रारूप ( मार्ग [ "तालिका" ] )
वापसी आर

भाग = "" "#! / बिन / श

# == सेट चर ================================================
IPTABLES = / sbin / iptables
"" "
fout। लिखना ( भाग )


fout। लिखना ( "एन # == इंटरफेस:" )

iface में iface के लिए :
addmissingfields ( iface )

iface [ "स्टेट" ] = isup ( iface [ "देव" ] )

अगर ( iface [ "भूमिका" ] == "बाहरी" ) :
iface [ "वर्क्स" ] = कार्य करता है ( iface [ "dev" ] )
descr = "{3} {0} {1} है और कार्य करता है = {2}" । प्रारूप ( iface [ "dev" ] , iface [ "state" ] , iface [ "works" ] , iface [ "भूमिका" ]]
fout। लिखना ( "n #" + descr )
Syslog । Syslog ( descr )

भाग = "" "
# == स्क्रिप्ट चलाने के दौरान अग्रेषित करना ==========================================
इको ०> / प्रोक / सीस / नेट / आईपीवी ४ / आईपी_फोवर्ड
# == स्क्रिप्ट चलाने के सभी नियमों को छोड़ दें ==========================================
आईपी ​​शासन फ्लश

# == सभी मौजूदा नीतियों को हटाएं ==================================
$ IPTABLES -F
$ IPTABLES -t nat -F
$ IPTABLES -t mangle -F
$ IPTABLES -X
$ IPTABLES -Z

# == डिफ़ॉल्ट नीतियां निर्धारित करें ======================================
$ IPTABLES -P INPUT DROP
$ IPTABLES -P OUTPUT ACCEPT
$ IPTABLES -P FORWARD DROP

# == DROP खराब पैकेट =============================================
$ IPTABLES -t फ़िल्टर -एक INPUT -m राज्य --state INVALID -j DROP
$ IPTABLES -t फ़िल्टर-एक OUTPUT -m राज्य --state INVALID -j DROP
$ IPTABLES -t फ़िल्टर-एक OUTPUT -m राज्य --state INVALID -j DROP

# == केवल SYN पैकेट नए कनेक्शन स्थापित करते हैं ===============
$ IPTABLES -t फ़िल्टर-एक INPUT -p tcp! - सिन-एम राज्य - स्टेट न्यू -j DROP
$ IPTABLES -t फ़िल्टर-एक OUTPUT -p tcp! - सिन-एम राज्य - स्टेट न्यू -j DROP
$ IPTABLES -t फ़िल्टर-फॉरवर्ड -p tcp! - सिन-एम राज्य - स्टेट न्यू -j DROP

# == सुरक्षित लो iface ============================================
$ IPTABLES -t फ़िल्टर-एक FORWARD -i लो -j DROP
$ IPTABLES -t फ़िल्टर-फ़ॉरवर्ड-लो लो -j DROP
$ IPTABLES -t फ़िल्टर-एक OUTPUT -o lo -s 127.0.0.1/255.0.0.0 -j ACCEPT
$ IPTABLES -t फ़िल्टर-एक INPUT -i लो -d 127.0.0.1/255.0.0.0 -j एसीटीपीटी
$ IPTABLES -t फ़िल्टर-एक OUTPUT -o lo -j DROP
$ IPTABLES -t फ़िल्टर-INPUT -i lo -j DROP

"" "

fout। लिखना ( भाग )

fout। लिखना ( "")

# == खुले और आगे के बंदरगाह =================================== ”” )
बंदरगाहों में बंदरगाह के लिए:
fout। लिखना ( ओपेनपोर्टेम्कड ( पोर्ट ) )
fout। लिखना ( फ़ॉरपोर्टपोर्टम ( पोर्ट ) )

fout। लिखना ( "")

# == अगर सभी के बीच: सभी लोको-लोकेशन की अनुमति दें, नए लोको 2 को एक्सट्रा अनुमति दें, नए को ड्राप करें, पूर्व से छोड़ें, एक्सट्रीम को ""
iface में iface के लिए :
fout। {"0}" के लिए ( "n # ====" लिखें । प्रारूप ( iface [ "dev" ] )
अगरबत्ती में स्थान:
अगर ( iface ! = inace ) :
अगर ( iface [ "भूमिका" ] == "स्थानीय" ) और ( inace [ "भूमिका" ] == "स्थानीय" ) :
fout। लिखना ( "n $ IPTABLES -t फ़िल्टर-एक फ़ॉरवर्ड-आई {0} -o {1} -j ACCEPT" । प्रारूप ( iface [ "dev" ] , oface [ "dev" ] ) )
अगर ( iface [ "भूमिका" ] == "स्थानीय" ) और ( inace [ "भूमिका" ] == "बाहरी" ) :
fout। लिखना ( "n $ IPTABLES -t फ़िल्टर-एक फ़ॉरवर्ड -i {0} -o {1} -m राज्य --state NEW -j ACCEPT" । प्रारूप ( iface [ "dev" ] , oface [ "dev" ] )) )

अगर iface [ "भूमिका" ] == "स्थानीय" :
कार्रवाई = "ACCEPT"
और :
कार्रवाई = "DROP"
fout। लिखना ( "n $ IPTABLES -t फ़िल्टर-एक INPUT -i {0} -m राज्य --state NEW -j {1}") । प्रारूप ( iface [ "dev" ] , क्रिया )।

fout। लिखना ( "n $ IPTABLES -t nat-POSTROUTING -o {0} -j MASERERADE" । प्रारूप ( iface [ "dev" ] ) )


fout। लिखना ( "")

# == आगे स्थापित करने की अनुमति दें, दूसरों को नीति से हटा दिया जाएगा
$ IPTABLES -t फ़िल्टर-एक FORWARD -m राज्य --स्टेट इस्टैब्लिश्ड, संबंधित-राज्य ACPT
$ IPTABLES -t फ़िल्टर-एक INPUT -m राज्य --स्टेट स्थापित, संबंधित-स्वीकृत ACPT

"" " )


fout। लिखना ( "")
# == कुछ स्थानों के लिए तालिकाओं, अंकों और नियमों को निर्धारित करने के लिए ============================================ ============== "" " )
iface में iface के लिए :

अगर iface [ "टेबल" ] और iface [ "gw" ] और iface [ "टेबल" ] :
fout। लिखें ( "एनआईपी मार्ग {0} देव {1} तालिका {2}" के माध्यम से डिफ़ॉल्ट जोड़ें । प्रारूप ( iface [ "gw" ] , iface [ "dev" ] , iface [ "तालिका" ] )

अगर iface [ "निशान" ] :
fout। लिखना
"fwmark" : iface [ "निशान" ] ,
"लुकअप" : iface [ "टेबल" ]
} )


fout। लिखना ( "")

# == उत्तर incomming iface से भेजे जाने चाहिए ===================================== ”” )
# if iface में स्थान:
# अगर iface ["निशान"]:
# fout.write ("n $ IPTABLES -t mangle -A INPUT -i {0} -j CONNMARK --सेट-मार्क {1}"। प्रारूप (iface ["dev"], iface [mark]])))।
# fout.write ("n $ IPTABLES -t mangle -A OUTPUT -j CONNMARK --restore-markn")
iface में iface के लिए :
अगर iface [ "टेबल" ] और iface [ "gw" ] :
fout। लिखना
"से" : iface [ "gw" ] ,
"लुकअप" : iface [ "टेबल" ]
} )

fout। लिखना ( "")

# == नियमों की सूची से नियम ==========================================
नियमों में नियम के लिए:
fout। लिखना ( नियम ) ( नियम )

fout। लिखना ( "")

# == मार्गों की सूची से मार्ग ===================================== "" )
मार्गों में मार्ग के लिए:
fout। लिखना ( रूटमेम ( मार्ग ) )

fout। लिखना ( "")

# == बाहरी आईलिशिंग (सभी यूपी के बीच) ======================================= "" )
भाग = "डिफ़ॉल्ट मार्ग वैश्विक को प्रतिस्थापित करता है"
iface में iface के लिए :
अगर iface [ "देव" ] और iface [ "gw" ] और iface [ "वजन" ] और ( iface [ "भूमिका" ] == "बाहरी" ) और ( iface [ "राज्य" ] == "ऊपर" ) :
part = part + "nexthop {0} dev {1} वजन {2}" के माध्यम से । प्रारूप ( iface [ "gw" ] , iface [ "dev" ] , iface [ "वजन" ] )
fout। लिखना ( भाग )

fout। लिखना ( "")

# == अग्रेषण =============================================== अनुमति दें ===========================
गूंज 1> / proc / sys / net / ipv4 / ip_forward
"" " )

fout। लिखना ( "")

# == कुछ हस्तनिर्मित कस्टम कमांड ================================================== ===================
{0}
"" " । प्रारूप ( कस्टमकमांड ) )


fout। पास ( )

Syslog । syslog ( "समाप्त" )
Syslog । syslog ( "स्क्रिप्ट शुरू हुई" )
x = उपप्रकार । कॉल ( [ "/ बिन / श" , "{0}" । प्रारूप ( cmdfile ) ] , stdin = कोई नहीं , stdout = खुला ( '/ dev / null' , 'w' ) , stderr = खुला ( 'dev ' ) null ' , ' w ' ) , शेल = गलत )
Syslog । syslog ( "स्क्रिप्ट परिणाम {0}" के साथ समाप्त हुई । प्रारूप ( x ) )

लांच

एक विकल्प जो मैं वर्तमान में उपयोग कर रहा हूं, वह है कि इंटरफेस बदलते समय एक स्क्रिप्ट को कॉल करना। ऐसा करने के लिए, एक कॉल स्क्रिप्ट लिखी जाती है:

 
  रूट @ गेट: / रूट # कैट ।/msr_on_if_changed  
  #! / बिन / श 
  / usr / bin / python /root/msr_ip.py 
  बाहर निकलें 0 
 

स्क्रिप्ट के लिंक नेटवर्क इंटरफ़ेस कॉन्फ़िगरेशन निर्देशिकाओं में स्थापित हैं। मुख्य बात यह है कि नाम बिना विस्तार के हो जाता है, अन्यथा लिंक को इनिशियलाइज़ेशन सिस्टम द्वारा अनदेखा कर दिया जाएगा:

 ln -s /root/msr_ip.py / etc / network / if-down / msr_ip
 ln -s /root/msr_ip.py / etc / network / if-up / msr_ip
 ln -s /root/msr_ip.py /etc/ppp/ip-up.d/msr_ip
 ln -s /root/msr_ip.py /etc/ppp/ip-down.d/msr_ip

कुल मिलाकर

स्क्रिप्ट 3 महीने से चल रही है और अभी तक इसकी गलती के कारण कोई असफलता नहीं हुई है, मुझे उम्मीद है कि ऐसा होगा।