netconf

   1 #!/usr/bin/env python
   2 #
   3 # This file and its contents are supplied under the terms of the
   4 # Common Development and Distribution License ("CDDL"), version 1.0.
   5 # You may only use this file in accordance with the terms of version
   6 # 1.0 of the CDDL.
   7 #
   8 # A full copy of the text of the CDDL should have accompanied this
   9 # source. A copy of the CDDL is also available via the Internet at
  10 # http://www.illumos.org/license/CDDL.
  11 #
  12
  13 #
  14 # Copyright 2017 <Michael Rasmussen>
  15 #
  16
  17 #
  18 # The porpuse of this script is to help with basic and/or initial
  19 # network configuration for Illumos based distribution. However,
  20 # the script is developed specifically for OmniOS so there is no
  21 # garaunty that it will work on other Illumos based distributions
  22 # than Omnios.
  23 #
  24
  25 import sys, subprocess, getopt
  26
  27 def runcmd(cmd):
  28     process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
  29     output, error = process.communicate();
  30
  31     return (output.rstrip(), error.rstrip())
  32
  33 class ParserError(Exception):
  34     pass
  35
  36 class Parser:
  37     """ Parse nic information """
  38
  39     def __init__(self):
  40         self.__dladm1 = "dladm show-phys -p -o link,media | sed 's/:/ /g'"
  41         self.__dladm2 = "dladm show-phys -p -m -o link,address,inuse | sed 's/:/ /g' | sed 's/\\\[[:space:]]/:/g' | sed 's/\\\//g'"
  42
  43     def __parse_nics(self, text):
  44         nics = {}
  45         for line in text.splitlines():
  46             parts = line.split()
  47             #if parts[1] in ('Ethernet', 'Infiniband'):
  48             if parts[1] in ('Ethernet'):
  49                 nics[parts[0]] = [parts[0], parts[1]]
  50
  51         return nics
  52
  53     def __parse_macs(self, obj, text):
  54         list = []
  55         if obj:
  56             for line in text.splitlines():
  57                 parts = line.split()
  58                 try:
  59                     if parts[2] == 'yes':
  60                         del obj[parts[0]]
  61                     else:
  62                         obj[parts[0]].append(parts[1])
  63                 except KeyError:
  64                     pass
  65             for k, v in obj.items():
  66                 list.append(v)
  67
  68         return list
  69
  70     def parse(self):
  71         (nics, error) = runcmd(self.__dladm1)
  72         if error:
  73             raise ParserError(error)
  74
  75         (macs, error) = runcmd(self.__dladm2)
  76         if error:
  77             raise ParserError(error)
  78
  79         return self.__parse_macs(self.__parse_nics(nics), macs)
  80
  81 def get_terminal_width():
  82         try:
  83             if sys.version_info >= (2,7):
  84                 width = int(subprocess.check_output(['tput', 'cols']))
  85             else:
  86                 (out, err) = runcmd('tput cols')
  87                 if err:
  88                     raise OSError(err);
  89                 width = int(out)
  90         except OSError as e:
  91             print("Invalid Command 'tput cols': exit status ({1})".format(e.errno))
  92         except subprocess.CalledProcessError as e:
  93             print("Command 'tput cols' returned non-zero exit status: ({1})".format(e.returncode))
  94         else:
  95             return width
  96
  97 def make_menu(interfaces):
  98     res = None
  99     while not res:
 100         sys.stderr.write("\x1b[2J\x1b[H")
 101         cols = get_terminal_width()
 102         intro = 'The following unconfigured interfaces was discovered'
 103         fill = (cols / 2) - (len(intro) / 2)
 104         print '{0:^{cols}}'.format('Simple network interface configuration tool', cols=cols)
 105         print
 106         print '{0:<{fill}}{1}'.format('', intro, fill=fill)
 107         print '{0:<{fill}}{1:>2} {2:^15}  {3:^10}  {4:^17}'.format('','#','Interface','Media','MAC',fill=fill)
 108         print '{0:<{fill}}{1:-^2} {2:-^15}  {3:-^10}  {4:-^17}'.format('','','','','',fill=fill)
 109
 110         n = 0
 111         for i in interfaces:
 112             print '{0:<{fill}}{1:>2} {2:<15}  {3:<10}  {4:>17}'.format('',n,i[0],i[1],i[2],fill=fill)
 113             n += 1
 114         print
 115         print '{0:<{fill}}{1:<}'.format('','select interface number to configure:',fill=fill),
 116         nic = int(raw_input())
 117         if nic >= n or nic < 0:
 118             print '{0:<{fill}}{1:<} {2:<}'.format('','Error: Interface: 0 <= # <',n,fill=fill),
 119             raw_input(' << Hit any key >>')
 120         else:
 121             res = interfaces[nic]
 122
 123     return res
 124
 125 def get_config():
 126     ip = mask = gw = None
 127     nettype = raw_input('dhcp or static [dhcp]: ').lower()
 128     if nettype == 'static':
 129         while not ip:
 130             ip = raw_input('Enter IP: ')
 131         mask = raw_input('Enter netmask [24]: ')
 132         if not mask:
 133             mask = 24
 134         gw = raw_input('Enter default route [0=no]: ')
 135         if not gw:
 136             gw = 0
 137
 138     return (ip,mask,gw)
 139
 140 def usage():
 141     print 'Usage: %s [options]' % sys.argv[0]
 142     print
 143     print '%s' % """Options:
 144     -h, --help          This usage.
 145     -a, --address       IP for interface. 0 means use DHCP
 146     -g, --gateway       Default gateway. Optional.
 147     -i, --interface     Interface to configure.
 148     -m, --netmask       Netmask to use for interface. Default /24.
 149     -n, --nameserver    Nameserver to use. Optional."""
 150
 151 def parse_input():
 152     options = ()
 153
 154     try:
 155         opts, args = getopt.gnu_getopt(sys.argv[1:],
 156                 'ha:g:i:m:n:r', ['help', 'address=', 'gateway=',
 157                 'interface=', 'netmask=', 'nameserver=', 'record'])
 158     except getopt.GetoptError as err:
 159         print str(err)
 160         usage()
 161         sys.exit(2)
 162
 163     address = gateway = interface = netmask = nameserver = None
 164     record = False
 165
 166     if opts:
 167         for o, a in opts:
 168             if o in ('-h', '--help'):
 169                 usage()
 170                 sys.exit(0)
 171             if o in ('-a', '--address'):
 172                 address = a
 173             elif o in ('-g', '--gateway'):
 174                 gateway = a
 175             elif o in ('-i', '--interface'):
 176                 interface = a
 177             elif o in ('-m', '--netmask'):
 178                 netmask = a
 179             elif o in ('-n', '--nameserver'):
 180                 nameserver = a
 181             elif o in ('-r', '--record'):
 182                 record = True
 183             else:
 184                 assert False, 'Unhandled option'
 185
 186         if not address or not interface:
 187             print 'Error: missing options'
 188             usage()
 189             sys.exit(2)
 190         if address == '0':
 191             address = None
 192         if not netmask:
 193             netmask = '24'
 194
 195         options = (interface, address, netmask, gateway, nameserver)
 196
 197     return options
 198
 199 def main():
 200     interactive = True
 201
 202     options = parse_input()
 203     if options:
 204         interactive = False
 205
 206     p = Parser()
 207     try:
 208         interfaces = p.parse()
 209         if interfaces:
 210             if interactive:
 211                 nic = make_menu(interfaces)
 212             else:
 213                 nic = options
 214                 found = False
 215                 for i in interfaces:
 216                     if nic[0] == i[0]:
 217                         found = True
 218                         break
 219                 if not found:
 220                     err = '%s: No such interface' % nic[0]
 221                     raise RuntimeError(err)
 222             if nic:
 223                 if interactive:
 224                     (ip,mask,gw) = get_config()
 225                 else:
 226                     ip = options[1]
 227                     mask = options[2]
 228                     gw = options[3]
 229                 cmd = 'ipadm delete-if %s' % nic[0]
 230                 if record:
 231                     print cmd
 232                 else:
 233                     runcmd(cmd)
 234                 cmd = 'ipadm create-if %s' % nic[0]
 235                 if record:
 236                     print cmd
 237                 else:
 238                     (out, err) = runcmd(cmd)
 239                     if err:
 240                         raise RuntimeError(err)
 241                 if not ip:
 242                     # use DHCP
 243                     cmd = 'ipadm create-addr -T dhcp %s/v4' % nic[0]
 244                     if record:
 245                         print cmd
 246                     else:
 247                         (out, err) = runcmd(cmd)
 248                         if err:
 249                             raise RuntimeError(err)
 250                 else:
 251                     # use STATIC
 252                     cmd = 'ipadm create-addr -T static -a %s/%s %s/v4' % (ip, mask, nic[0])
 253                     if record:
 254                         print cmd
 255                     else:
 256                         (out, err) = runcmd(cmd)
 257                         if err:
 258                             raise RuntimeError(err)
 259                     if gw:
 260                         cmd = 'route -p add default %s' % gw
 261                         if record:
 262                             print cmd
 263                         else:
 264                             (out, err) = runcmd(cmd)
 265                             if err:
 266                                 raise RuntimeError(err)
 267                 if not record:
 268                     cmd = 'netstat -rn -finet'
 269                     (out, err) = runcmd(cmd)
 270                     if err:
 271                         raise RuntimeError(err)
 272                     print 'New route table'
 273                     print out
 274                 if interactive:
 275                     dns = raw_input('Configure DNS [n]? ').lower()
 276                 else:
 277                     dns = options[4]
 278                 if not dns or dns == 'n':
 279                     pass
 280                 else:
 281                     if interactive:
 282                         dns = None
 283                         print
 284                         while not dns:
 285                             dns = raw_input('Enter nameserver: ')
 286
 287                     cmd = "echo 'nameserver %s' >> /etc/resolv.conf " % dns
 288                     cmd += '&& cp /etc/nsswitch.conf{,.bak} '
 289                     cmd += '&& cp /etc/nsswitch.{dns,conf}'
 290                     if record:
 291                         print cmd
 292                     else:
 293                         (out, err) = runcmd(cmd)
 294                         if err:
 295                             raise RuntimeError(err)
 296         else:
 297             print "Found no unassigned interfaces"
 298     except ParserError as e:
 299         print 'Parse Errror: %s' % e
 300     except RuntimeError as e:
 301         print 'Runtime Error: %s' % e
 302
 303 if __name__ == '__main__':
 304     try:
 305         main()
 306     except KeyboardInterrupt:
 307         sys.stderr.write("\x1b[2J\x1b[H")
 308