Esempio n. 1
0
    def _checkValues(self):
        if not self.ipv4Selected and not self.ipv6Selected:
            self.anaconda.intf.messageWindow(_("Missing protocol"),
                               _("You must select at least one protocol version"))
            return False

        if self.ipv4Selected:
            if self.ipv4Method == "v4manual":
                try:
                    network.sanityCheckIPString(self.ipv4Address)
                except network.IPMissing, msg:
                    self._handleIPMissing(_("IPv4 Address"))
                    return False
                except network.IPError, msg:
                    self._handleIPError(_("IPv4 Address"), msg)
                    return False

                if not self.ipv4Prefix:
                    self._handleIPMissing(_("IPv4 Prefix"))
                    return False
                elif (int(self.ipv4Prefix) < 0 or
                      int(self.ipv4Prefix) > 32):
                    msg = _("IPv4 CIDR prefix must be between 0 and 32.")
                    self._handleIPError(_("IPv4 Prefix"), msg)
                    return False

                if self.ipv4Gateway:
                    try:
                        network.sanityCheckIPString(self.ipv4Gateway)
                    except network.IPError, msg:
                        self._handleIPError(_("IPv4 Gateway"), msg)
                        return False
Esempio n. 2
0
    def getNext(self):
        nfsUrl = self.xml.get_widget('abiquo_nfs_repository').get_text()

        if re.search('(localhost|127\.0\.0\.1)', nfsUrl):
            self.intf.messageWindow("<b>NFS Repository Error</b>",
                       "<b>127.0.0.1 or localhost detected</b>\n\n"
                         "127.0.0.1 or localhost values are not allowed here. "
                         "Use an IP address reachable by other hosts "
                         "in your LAN.",
                            type="warning")
            raise gui.StayOnScreen

        # validate the host
        host = nfsUrl.split(":")[0]
        try:
            network.sanityCheckIPString(host)
        except:
            if network.sanityCheckHostname(host) is not None:
                self.intf.messageWindow("<b>Invalid NFS URL</b>",
                           "NFS Repository URL is invalid.",
                                    type="warning")
                raise gui.StayOnScreen

        if not re.search('.+:\/.*', nfsUrl):
            self.intf.messageWindow("<b>NFS Repository Error</b>",
                         "<b>Invalid NFS URL</b>\n\n"
                         "%s is not a valid NFS URL" % nfsUrl,
                                type="warning")
            raise gui.StayOnScreen

        self.data.abiquo_rs.abiquo_nfs_repository = nfsUrl
Esempio n. 3
0
    def _ok(self, *args):
        combo = self.xml.get_widget("interfaceCombo")
        active = combo.get_active_iter()
        val = combo.get_model().get_value(active, 1)
        netdev = self.network.available()[val]

        # FIXME: need to do input validation
        if self.xml.get_widget("dhcpCheckbutton").get_active():
            self.window.hide()
            w = gui.WaitWindow(_("Dynamic IP"),
                               _("Sending request for IP information "
                                 "for %s...") %(netdev.get("device")))
            ns = isys.dhcpNetDevice(netdev.get("device"))
            w.pop()
            if ns is not None:
                self.rc = gtk.RESPONSE_OK
            if ns:
                f = open("/etc/resolv.conf", "w")
                f.write("nameserver %s\n" % ns)
                f.close()
                isys.resetResolv()
        else:
            ipv4addr = self.xml.get_widget("ipv4Address").get_text()
            ipv4nm = self.xml.get_widget("ipv4Netmask").get_text()
            gateway = self.xml.get_widget("gatewayEntry").get_text()
            ns = self.xml.get_widget("nameserverEntry").get_text()

            try:
                network.sanityCheckIPString(ipv4addr)
            except network.IPMissing, msg:
                self._handleIPMissing(_("IP Address"))
                return
            except network.IPError, msg:
                self._handleIPError(_("IP Address"), msg)
                return
Esempio n. 4
0
    def _checkValues(self):
        if not self.ipv4Selected and not self.ipv6Selected:
            self.anaconda.intf.messageWindow(
                _("Missing protocol"),
                _("You must select at least one protocol version"))
            return False

        if self.ipv4Selected:
            if self.ipv4Method == "v4manual":
                try:
                    network.sanityCheckIPString(self.ipv4Address)
                except network.IPMissing, msg:
                    self._handleIPMissing(_("IPv4 Address"))
                    return False
                except network.IPError, msg:
                    self._handleIPError(_("IPv4 Address"), msg)
                    return False

                if not self.ipv4Prefix:
                    self._handleIPMissing(_("IPv4 Prefix"))
                    return False
                elif (int(self.ipv4Prefix) < 0 or int(self.ipv4Prefix) > 32):
                    msg = _("IPv4 CIDR prefix must be between 0 and 32.")
                    self._handleIPError(_("IPv4 Prefix"), msg)
                    return False

                if self.ipv4Gateway:
                    try:
                        network.sanityCheckIPString(self.ipv4Gateway)
                    except network.IPError, msg:
                        self._handleIPError(_("IPv4 Gateway"), msg)
                        return False
Esempio n. 5
0
    def getNext(self):
        hostname = string.strip(self.hostnameEntry.get_text())
        herrors = network.sanityCheckHostname(hostname)

        if not hostname:
            self.intf.messageWindow(_("Error with Hostname"),
                                    _("You must enter a valid hostname for this "
                                      "computer."), custom_icon="error")
            self.hostnameError()

        if herrors is not None:
            self.intf.messageWindow(_("Error with Hostname"),
                                    _("The hostname \"%(hostname)s\" is not "
                                      "valid for the following reason:\n\n"
                                      "%(herrors)s")
                                    % {'hostname': hostname,
                                       'herrors': herrors},
                                    custom_icon="error")
            self.hostnameError()

        netif = self.netifCombo.get_model()[self.netifCombo.get_active()][0]
        mode  = self.dhcpCombo.get_model()[self.dhcpCombo.get_active()][0]
        ipaddr = ''
        netmask = ''
        defaultgw = ''
        errors = []
        if mode == "Static":
            ipaddr = self.ipaddr.get_text()
            try:
                network.sanityCheckIPString(ipaddr)
            except network.IPError, e:
                errors.append(e.message)
            except network.IPMissing, e:
                errors.append(e.message)
    def getNext(self):
        nfsUrl = self.xml.get_widget('abiquo_nfs_repository').get_text()
        datacenterId = self.xml.get_widget('datacenterId').get_text()
        nfs_repo_selected = ('abiquo-nfs-repository' in self.anaconda.id.abiquo.selectedGroups)

        if re.search('(localhost|127\.0\.0\.1)', nfsUrl) and not nfs_repo_selected:
            self.intf.messageWindow("<b>NFS Repository Error</b>",
                         "<b>127.0.0.1 or localhost detected</b>\n\n"
                         "127.0.0.1 or localhost values are not allowed here. "
                         "Use an IP address reachable by other hosts "
                         "in your LAN.",
                            type="warning")
            raise gui.StayOnScreen

        serverIP = self.xml.get_widget('abiquo_server_ip').get_text()
        if re.search('(localhost|127\.0\.0\.1)', serverIP):
            self.intf.messageWindow("<b>Abiquo Server IP Error</b>",
                         "<b>127.0.0.1 or localhost detected</b>\n\n"
                         "127.0.0.1 or localhost values are not allowed here. "
                         "Use an IP address reachable by other hosts "
                         "in your LAN.",
                                type="warning")
            raise gui.StayOnScreen

        if not nfs_repo_selected:
            # validate the host
            host = nfsUrl.split(":")[0]
            try:
                network.sanityCheckIPString(host)
            except:
                if network.sanityCheckHostname(host) is not None:
                    self.intf.messageWindow("<b>Invalid NFS URL</b>",
                         "NFS Repository URL is invalid.",
                            type="warning")
                    raise gui.StayOnScreen

        # validate the abiquo server IP
        try:
            socket.inet_aton(serverIP.strip())
        except socket.error:
            self.intf.messageWindow("<b>Abiquo Server IP Error</b>",
                         "Invalid Abiquo Server IP address",
                                type="warning")
            raise gui.StayOnScreen

        if not re.search('.+:\/.*', nfsUrl):
            self.intf.messageWindow("<b>NFS Repository Error</b>",
                         "<b>Invalid NFS URL</b>\n\n"
                         "%s is not a valid NFS URL" % nfsUrl,
                                type="warning")
            raise gui.StayOnScreen


        self.data.abiquo_rs.abiquo_nfs_repository = nfsUrl
        self.data.abiquo_v2v.abiquo_rabbitmq_host = serverIP
        self.data.abiquo_v2v.abiquo_datacenter_id = datacenterId
Esempio n. 7
0
    def hydrate(self, ip_string):
        self.clear_entries()

        octets = network.sanityCheckIPString(ip_string)
        if octets is None:
            return

        i = 0
        for name in ip_fields:
            self.entrys[name].set_text(octets[i])
            i = i + 1
Esempio n. 8
0
    def addIscsiDriveDialog(self, screen):
        if not network.hasActiveNetDev():
            ButtonChoiceWindow(screen, _("Error"),
                               "Must have a network configuration set up "
                               "for iSCSI config.  Please boot with "
                               "'linux asknetwork'")
            return INSTALL_BACK
        
        (button, entries) = EntryWindow(screen,
                                        _("Configure iSCSI Parameters"),
                                        _("To use iSCSI disks, you must provide the address of your iSCSI target and the iSCSI initiator name you've configured for your host."),
                                        prompts = [ _("Target IP Address"),
                                                    _("iSCSI Initiator Name"),
                                                    _("CHAP username"),
                                                    _("CHAP password"),
                                                    _("Reverse CHAP username"),
                                                    _("Reverse CHAP password") ])
        if button == TEXT_CANCEL_CHECK:
            return INSTALL_BACK

        (user, pw, user_in, pw_in) = entries[2:]

        target = entries[0].strip()
        try:
            count = len(target.split(":"))
            idx = target.rfind("]:")
            # Check for IPV6 [IPV6-ip]:port
            if idx != -1:
                ip = target[1:idx]
                port = target[idx+2:]
            # Check for IPV4 aaa.bbb.ccc.ddd:port
            elif count == 2:
                idx = target.rfind(":")
                ip = target[:idx]
                port = target[idx+1:]
            else:
                ip = target
                port = "3260"
            network.sanityCheckIPString(ip)
        except network.IPMissing, msg:
            raise ValueError, msg
Esempio n. 9
0
    def _ok(self, *args):
        self.rc = gtk.RESPONSE_OK
        haveNet = False
        combo = self.xml.get_widget("interfaceCombo")
        active = combo.get_active_iter()
        val = combo.get_model().get_value(active, 1)
        for v, dev in self.network.available().items():
            if v == val:
                dev.set(('ONBOOT', 'yes'))
                netdev = dev
            else:
                dev.set(('ONBOOT', 'no'))

        # FIXME: need to do input validation
        if self.xml.get_widget("dhcpCheckbutton").get_active():
            netdev.set(('BOOTPROTO', 'dhcp'))
            self.window.hide()
            w = gui.WaitWindow(_("Dynamic IP Address"),
                               _("Sending request for IP address information "
                                 "for %s") % (netdev.get('DEVICE'),))
            haveNet = self.network.bringUp(devices=[netdev])
            w.pop()
        else:
            netdev.set(('BOOTPROTO', 'static'))
            ipv4addr = self.xml.get_widget("ipv4Address").get_text()
            ipv4nm = self.xml.get_widget("ipv4Netmask").get_text()
            gateway = self.xml.get_widget("gatewayEntry").get_text()
            ns = self.xml.get_widget("nameserverEntry").get_text()

            try:
                network.sanityCheckIPString(ipv4addr)
                netdev.set(('IPADDR', ipv4addr))
            except network.IPMissing, msg:
                self._handleIPMissing(_("IP Address"))
                return False
            except network.IPError, msg:
                self._handleIPError(_("IP Address"), msg)
                return False
def parse_ip(string_ip):
    """
    May rise network.IPMissing or network.IPError

    Returns (ip, port) tuple.
    """
    count = len(string_ip.split(":"))
    idx = string_ip.rfind("]:")
    # Check for IPV6 [IPV6-ip]:port
    if idx != -1:
        ip = string_ip[1:idx]
        port = string_ip[idx + 2:]
    # Check for IPV4 aaa.bbb.ccc.ddd:port
    elif count == 2:
        idx = string_ip.rfind(":")
        ip = string_ip[:idx]
        port = string_ip[idx + 1:]
    else:
        ip = string_ip
        port = "3260"
    network.sanityCheckIPString(ip)

    return (ip, port)
Esempio n. 11
0
def parse_ip(string_ip):
    """
    May rise network.IPMissing or network.IPError

    Returns (ip, port) tuple.
    """
    count = len(string_ip.split(":"))
    idx = string_ip.rfind("]:")
    # Check for IPV6 [IPV6-ip]:port
    if idx != -1:
        ip = string_ip[1:idx]
        port = string_ip[idx+2:]
    # Check for IPV4 aaa.bbb.ccc.ddd:port
    elif count == 2:
        idx = string_ip.rfind(":")
        ip = string_ip[:idx]
        port = string_ip[idx+1:]
    else:
        ip = string_ip
        port = "3260"
    network.sanityCheckIPString(ip)

    return (ip, port)
Esempio n. 12
0
    def getNext(self):
        hostname = string.strip(self.hostnameEntry.get_text())
        herrors = network.sanityCheckHostname(hostname)

        if not hostname:
            self.intf.messageWindow(
                _("Error with Hostname"),
                _("You must enter a valid hostname for this "
                  "computer."),
                custom_icon="error")
            self.hostnameError()

        if herrors is not None:
            self.intf.messageWindow(_("Error with Hostname"),
                                    _("The hostname \"%(hostname)s\" is not "
                                      "valid for the following reason:\n\n"
                                      "%(herrors)s") % {
                                          'hostname': hostname,
                                          'herrors': herrors
                                      },
                                    custom_icon="error")
            self.hostnameError()

        netif = self.netifCombo.get_model()[self.netifCombo.get_active()][0]
        mode = self.dhcpCombo.get_model()[self.dhcpCombo.get_active()][0]
        ipaddr = ''
        netmask = ''
        defaultgw = ''
        errors = []
        if mode == "Static":
            ipaddr = self.ipaddr.get_text()
            try:
                network.sanityCheckIPString(ipaddr)
            except network.IPError, e:
                errors.append(e.message)
            except network.IPMissing, e:
                errors.append(e.message)
    def _ok(self, *args):
        combo = self.xml.get_widget("interfaceCombo")
        active = combo.get_active_iter()
        val = combo.get_model().get_value(active, 1)
        netdev = self.network.available()[val]

        # FIXME: need to do input validation
        if self.xml.get_widget("dhcpCheckbutton").get_active():
            self.window.hide()
            w = gui.WaitWindow(
                _("Dynamic IP"),
                _("Sending request for IP information "
                  "for %s...") % (netdev.get("device")))
            ns = isys.dhcpNetDevice(netdev.get("device"))
            w.pop()
            if ns is not None:
                self.rc = gtk.RESPONSE_OK
            if ns:
                f = open("/etc/resolv.conf", "w")
                f.write("nameserver %s\n" % ns)
                f.close()
                isys.resetResolv()
        else:
            ipv4addr = self.xml.get_widget("ipv4Address").get_text()
            ipv4nm = self.xml.get_widget("ipv4Netmask").get_text()
            gateway = self.xml.get_widget("gatewayEntry").get_text()
            ns = self.xml.get_widget("nameserverEntry").get_text()

            try:
                network.sanityCheckIPString(ipv4addr)
            except network.IPMissing, msg:
                self._handleIPMissing(_("IP Address"))
                return
            except network.IPError, msg:
                self._handleIPError(_("IP Address"), msg)
                return
Esempio n. 14
0
                            self._handleIPError(_("IPv4 Network Mask "), msg)
                            continue

                    try:
                        if gateway:
                            network.sanityCheckIPString(gateway)
                            netdev.set(("GATEWAY", gateway))
                    except network.IPMissing, msg:
                        pass
                    except network.IPError, msg:
                        self._handleIPError(_("Gateway"), msg)
                        continue

                    try:
                        if ns:
                            network.sanityCheckIPString(ns)
                            netdev.set(("DNS1", ns))
                    except network.IPMissing, msg:
                        pass
                    except network.IPError, msg:
                        self._handleIPError(_("Nameserver"), msg)
                        continue

            w = self.anaconda.intf.waitWindow(
                _("Configuring Network Interfaces"),
                _("Waiting for NetworkManager"))
            result = self.anaconda.network.bringUp(devices=selected_netdevs)
            w.pop()
            if result:
                break
            else:
Esempio n. 15
0
class NetworkConfiguratorText:
    def _handleIPError(self, field, errmsg):
        self.anaconda.intf.messageWindow(_("Error With Data"),
                                         _("An error occurred converting the "
                                           "value entered for "
                                           "\"%(field)s\":\n%(errmsg)s") \
                                         % {'field': field, 'errmsg': errmsg})

    def _handleIPMissing(self, field):
        self.anaconda.intf.messageWindow(
            _("Error With Data"),
            _("A value is required for the field %s") % field)

    def __init__(self, screen, anaconda):
        self.screen = screen
        self.anaconda = anaconda
        self.netdevs = self.anaconda.id.network.netdevices

        self._initValues()

    def _initValues(self):
        self.ipv4Selected = 1
        self.ipv6Selected = 1
        self.ipv4Method = "v4dhcp"
        self.ipv6Method = "v6auto"
        self.ipv4Address = ""
        self.ipv4Prefix = ""
        self.ipv4Gateway = ""
        self.ipv4Nameserver = ""
        self.ipv6Address = ""
        self.ipv6Prefix = ""
        self.ipv6Gateway = ""
        self.ipv6Nameserver = ""

    def run(self):

        dev_list = []
        selected_devname = None

        devnames = self.netdevs.keys()
        devnames.sort()

        # Preselect device set in kickstart
        ksdevice = self.anaconda.id.network.getKSDevice()
        if ksdevice:
            ksdevice = ksdevice.get("DEVICE")

        for devname in devnames:
            hwaddr = self.netdevs[devname].get("HWADDR")

            if hwaddr:
                desc = "%s - %.50s" % (devname, hwaddr)
            else:
                desc = devname

            if selected_devname is None:
                selected_devname = devname

            if ksdevice and ksdevice == devname:
                selected_devname = devname
            dev_list.append((desc, devname))

        while True:
            w = self.deviceSelectionForm(dev_list, selected_devname)
            result = w.run()
            button = w.buttons.buttonPressed(result)

            if button == TEXT_BACK_CHECK:
                self.screen.popWindow()
                return INSTALL_BACK

            selected_devname = self.interfaceList.current()

            while True:
                w = self.configForm(selected_devname)
                result = w.run()
                button = w.buttons.buttonPressed(result)

                if button == TEXT_BACK_CHECK:
                    self.screen.popWindow()
                    self.screen.popWindow()
                    break

                self._readValues()
                if (self._checkValues()
                        and self._applyValues(selected_devname)):
                    self.screen.popWindow()
                    self.screen.popWindow()
                    return INSTALL_OK
                else:
                    self.screen.popWindow()

    def deviceSelectionForm(self, dev_list, preselected_dev=None):

        grid = GridFormHelp(self.screen, _("Enable network interface"),
                            "netselection", 1, 9)

        tb = TextboxReflowed(
            60,
            _("This requires that you have an active "
              "network connection during the installation "
              "process.  Please select network "
              "interface to configure."))
        grid.add(tb, 0, 0, anchorLeft=1, padding=(0, 0, 0, 1))

        self.interfaceList = Listbox(3, scroll=1, returnExit=0)

        for (desc, dev) in dev_list:
            self.interfaceList.append(desc, dev)
        if preselected_dev:
            self.interfaceList.setCurrent(preselected_dev)

        grid.add(self.interfaceList, 0, 1, padding=(0, 0, 0, 1))

        grid.buttons = ButtonBar(self.screen,
                                 [TEXT_OK_BUTTON, TEXT_BACK_BUTTON])
        grid.add(grid.buttons, 0, 2, anchorLeft=1, growx=1)

        return grid

    def configForm(self, devname):

        # Create device configuration screen
        grid = GridFormHelp(self.screen, _("Enable network interface"),
                            "netconfig", 1, 13)

        tb = TextboxReflowed(
            60,
            _("Configure interface %s "
              "to be used during installation process.") % devname)
        grid.add(tb, 0, 0, anchorLeft=1, padding=(0, 0, 0, 1))

        self.ipv4Checkbox = Checkbox(_("Enable IPv4 Support"),
                                     isOn=self.ipv4Selected)
        grid.add(self.ipv4Checkbox,
                 0,
                 1,
                 anchorLeft=1,
                 padding=(0, 0, 0, 0),
                 growx=1)
        self.v4radio = RadioGroup()
        self.v4radio_auto = self.v4radio.add(
            _("Dynamic IP configuration (DHCP)"), "v4dhcp",
            self.ipv4Method == "v4dhcp")
        self.v4radio_manual = self.v4radio.add(_("Manual Configuration"),
                                               "v4manual",
                                               self.ipv4Method == "v4manual")
        grid.add(self.v4radio_auto,
                 0,
                 2,
                 anchorLeft=1,
                 padding=(2, 0, 0, 0),
                 growx=1)
        grid.add(self.v4radio_manual,
                 0,
                 3,
                 anchorLeft=1,
                 padding=(2, 0, 0, 0),
                 growx=1)

        ipv4Grid = Grid(4, 3)
        ipv4Grid.setField(Label(_("IPv4 Address:")),
                          0,
                          0,
                          padding=(0, 0, 1, 0),
                          anchorLeft=1)
        self.ipv4AddressEntry = Entry(20, scroll=1)
        self.ipv4AddressEntry.set(self.ipv4Address)
        ipv4Grid.setField(self.ipv4AddressEntry, 1, 0)
        ipv4Grid.setField(Label("/"), 2, 0)
        self.ipv4PrefixEntry = Entry(3, scroll=0)
        self.ipv4PrefixEntry.set(self.ipv4Prefix)
        ipv4Grid.setField(self.ipv4PrefixEntry, 3, 0)
        ipv4Grid.setField(Label(_("Gateway:")),
                          0,
                          1,
                          padding=(0, 0, 0, 0),
                          anchorLeft=1)
        self.ipv4GatewayEntry = Entry(20, scroll=1)
        self.ipv4GatewayEntry.set(self.ipv4Gateway)
        ipv4Grid.setField(self.ipv4GatewayEntry, 1, 1)
        ipv4Grid.setField(Label(_("Nameserver:")),
                          0,
                          2,
                          padding=(0, 0, 0, 0),
                          anchorLeft=1)
        self.ipv4NameserverEntry = Entry(20, scroll=1)
        self.ipv4NameserverEntry.set(self.ipv4Nameserver)
        ipv4Grid.setField(self.ipv4NameserverEntry, 1, 2)

        grid.add(ipv4Grid, 0, 4, anchorLeft=1, padding=(6, 0, 0, 0))

        self.ipv6Checkbox = Checkbox(_("Enable IPv6 Support"),
                                     isOn=self.ipv6Selected)
        grid.add(self.ipv6Checkbox,
                 0,
                 5,
                 anchorLeft=1,
                 padding=(0, 0, 0, 0),
                 growx=1)
        self.v6radio = RadioGroup()
        self.v6radio_auto = self.v6radio.add(_("Automatic neighbor discovery"),
                                             "v6auto",
                                             self.ipv6Method == "v6auto")
        self.v6radio_dhcp = self.v6radio.add(
            _("Dynamic IP Configuration (DHCPv6)"), "v6dhcp",
            self.ipv6Method == "v6dhcp")
        self.v6radio_manual = self.v6radio.add(_("Manual Configuration"),
                                               "v6manual",
                                               self.ipv6Method == "v6manual")
        grid.add(self.v6radio_auto,
                 0,
                 6,
                 anchorLeft=1,
                 padding=(2, 0, 0, 0),
                 growx=1)
        grid.add(self.v6radio_dhcp,
                 0,
                 7,
                 anchorLeft=1,
                 padding=(2, 0, 0, 0),
                 growx=1)
        grid.add(self.v6radio_manual,
                 0,
                 8,
                 anchorLeft=1,
                 padding=(2, 0, 0, 0),
                 growx=1)

        ipv6Grid = Grid(4, 3)
        ipv6Grid.setField(Label(_("IPv6 Address:")),
                          0,
                          0,
                          padding=(0, 0, 1, 0),
                          anchorLeft=1)
        self.ipv6AddressEntry = Entry(41, scroll=1)
        self.ipv6AddressEntry.set(self.ipv6Address)
        ipv6Grid.setField(self.ipv6AddressEntry, 1, 0)
        ipv6Grid.setField(Label("/"), 2, 0)
        self.ipv6PrefixEntry = Entry(4, scroll=0)
        self.ipv6PrefixEntry.set(self.ipv6Prefix)
        ipv6Grid.setField(self.ipv6PrefixEntry, 3, 0)
        ipv6Grid.setField(Label(_("Gateway:")),
                          0,
                          1,
                          padding=(0, 0, 0, 0),
                          anchorLeft=1)
        self.ipv6GatewayEntry = Entry(41, scroll=1)
        self.ipv6GatewayEntry.set(self.ipv6Gateway)
        ipv6Grid.setField(self.ipv6GatewayEntry, 1, 1)
        ipv6Grid.setField(Label(_("Nameserver:")),
                          0,
                          2,
                          padding=(0, 0, 0, 0),
                          anchorLeft=1)
        self.ipv6NameserverEntry = Entry(41, scroll=1)
        self.ipv6NameserverEntry.set(self.ipv6Nameserver)
        ipv6Grid.setField(self.ipv6NameserverEntry, 1, 2)

        grid.add(ipv6Grid, 0, 9, anchorLeft=1, padding=(6, 0, 0, 0))

        grid.buttons = ButtonBar(self.screen,
                                 [TEXT_OK_BUTTON, TEXT_BACK_BUTTON])
        grid.add(grid.buttons, 0, 10, anchorLeft=1, growx=1)

        self.v4radio_manual.setCallback(self._ipv4MethodToggled)
        self.v4radio_auto.setCallback(self._ipv4MethodToggled)
        self.v6radio_manual.setCallback(self._ipv6MethodToggled)
        self.v6radio_auto.setCallback(self._ipv6MethodToggled)
        self.v6radio_dhcp.setCallback(self._ipv6MethodToggled)
        self.ipv4Checkbox.setCallback(self._ipv4MethodToggled)
        self.ipv6Checkbox.setCallback(self._ipv6MethodToggled)

        self._ipv4MethodToggled()
        self._ipv6MethodToggled()

        return grid

    def _readValues(self):
        self.ipv4Selected = self.ipv4Checkbox.selected()
        self.ipv6Selected = self.ipv6Checkbox.selected()
        self.ipv4Method = self.v4radio.getSelection()
        self.ipv6Method = self.v6radio.getSelection()
        self.ipv4Address = self.ipv4AddressEntry.value()
        self.ipv4Prefix = self.ipv4PrefixEntry.value()
        self.ipv4Gateway = self.ipv4GatewayEntry.value()
        self.ipv4Nameserver = self.ipv4NameserverEntry.value()
        self.ipv6Address = self.ipv6AddressEntry.value()
        self.ipv6Prefix = self.ipv6PrefixEntry.value()
        self.ipv6Gateway = self.ipv6GatewayEntry.value()
        self.ipv6Nameserver = self.ipv6NameserverEntry.value()

    def _checkValues(self):
        if not self.ipv4Selected and not self.ipv6Selected:
            self.anaconda.intf.messageWindow(
                _("Missing protocol"),
                _("You must select at least one protocol version"))
            return False

        if self.ipv4Selected:
            if self.ipv4Method == "v4manual":
                try:
                    network.sanityCheckIPString(self.ipv4Address)
                except network.IPMissing, msg:
                    self._handleIPMissing(_("IPv4 Address"))
                    return False
                except network.IPError, msg:
                    self._handleIPError(_("IPv4 Address"), msg)
                    return False

                if not self.ipv4Prefix:
                    self._handleIPMissing(_("IPv4 Prefix"))
                    return False
                elif (int(self.ipv4Prefix) < 0 or int(self.ipv4Prefix) > 32):
                    msg = _("IPv4 CIDR prefix must be between 0 and 32.")
                    self._handleIPError(_("IPv4 Prefix"), msg)
                    return False

                if self.ipv4Gateway:
                    try:
                        network.sanityCheckIPString(self.ipv4Gateway)
                    except network.IPError, msg:
                        self._handleIPError(_("IPv4 Gateway"), msg)
                        return False

                if self.ipv4Nameserver:
                    for addr in self.ipv4Nameserver.split(','):
                        addr.split()
                        try:
                            network.sanityCheckIPString(addr)
                        except network.IPError, msg:
                            self._handleIPError(_("IPv4 Nameserver"), msg)
                            return False
Esempio n. 16
0
                        self._handleIPError(_("IPv4 Gateway"), msg)
                        return False

                if self.ipv4Nameserver:
                    for addr in self.ipv4Nameserver.split(','):
                        addr.split()
                        try:
                            network.sanityCheckIPString(addr)
                        except network.IPError, msg:
                            self._handleIPError(_("IPv4 Nameserver"), msg)
                            return False

        if self.ipv6Selected:
            if self.ipv6Method == "v6manual":
                try:
                    network.sanityCheckIPString(self.ipv6Address)
                except network.IPMissing, msg:
                    self._handleIPMissing(_("IPv6 Address"))
                    return False
                except network.IPError, msg:
                    self._handleIPError(_("IPv6 Address"), msg)
                    return False

                if not self.ipv6Prefix:
                    self._handleIPMissing(_("IPv6 Prefix"))
                    return False
                elif (int(self.ipv6Prefix) < 0 or int(self.ipv6Prefix) > 128):
                    msg = _("IPv6 CIDR prefix must be between 0 and 128.")
                    self._handleIPError(_("IPv6 Prefix"), msg)
                    return False
class NetworkConfigurator:
    def __init__(self, network):
        (xml, w) = gui.getGladeWidget("netconfig.glade", "NetworkConfigWindow")

        self.window = w
        self.network = network
        self.xml = xml
        self.rc = gtk.RESPONSE_CANCEL

        self._setSizeGroup()
        self._connectSignals()
        self._populateNetdevs()

        self.xml.get_widget("ipv4Checkbutton").set_active(True)
        self.xml.get_widget("ipv6Checkbutton").set_active(False)

    def _connectSignals(self):
        sigs = {
            "on_ipv4Checkbutton_toggled": self._ipv4Toggled,
            "on_ipv6Checkbutton_toggled": self._ipv6Toggled,
            "on_dhcpCheckbutton_toggled": self._dhcpToggled,
            "on_interfaceCombo_changed": self._netdevChanged,
            "on_cancelButton_clicked": self._cancel,
            "on_okButton_clicked": self._ok
        }
        self.xml.signal_autoconnect(sigs)

    def _setSizeGroup(self):  # too bad we can't do this in the glade file
        sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
        for w in ("nameserverLabel", "gatewayLabel", "ipv6Label", "ipv4Label",
                  "interfaceLabel"):
            sg.add_widget(self.xml.get_widget(w))

    def _netdevChanged(self, combo):
        active = combo.get_active_iter()
        val = combo.get_model().get_value(active, 1)
        netdev = self.network.available()[val]

        bootproto = netdev.get("bootproto")
        if not bootproto or bootproto == "dhcp" or bootproto == "ibft":
            self.xml.get_widget("dhcpCheckbutton").set_active(True)
        else:
            self.xml.get_widget("dhcpCheckbutton").set_active(False)

            # FIXME: need to set ipv6 here too once we have that
            if netdev.get("ipaddr"):
                self.xml.get_widget("ipv4Address").set_text(
                    netdev.get("ipaddr"))
            if netdev.get("netmask"):
                self.xml.get_widget("ipv4Netmask").set_text(
                    netdev.get("netmask"))
            if self.network.gateway:
                self.xml.get_widget("gatewayEntry").set_text(
                    self.network.gateway)
            if self.network.primaryNS:
                self.xml.get_widget("nameserverEntry").set_text(
                    self.network.primaryNS)

    def _ipv4Toggled(self, cb):
        if self.xml.get_widget("dhcpCheckbutton").get_active():
            return
        if cb.get_active():
            self.xml.get_widget("ipv4Box").set_sensitive(True)
        else:
            self.xml.get_widget("ipv4Box").set_sensitive(False)

    def _ipv6Toggled(self, cb):
        if self.xml.get_widget("dhcpCheckbutton").get_active():
            return
        if cb.get_active():
            self.xml.get_widget("ipv6Box").set_sensitive(True)
        else:
            self.xml.get_widget("ipv6Box").set_sensitive(False)

    def _dhcpToggled(self, cb):
        boxes = ("ipv4Box", "ipv6Box", "nameserverBox", "gatewayBox")
        if not cb.get_active():
            map(lambda x: self.xml.get_widget(x).set_sensitive(True), boxes)
            self.xml.get_widget("ipv4Box").set_sensitive(
                self.xml.get_widget("ipv4Checkbutton").get_active())
            self.xml.get_widget("ipv6Box").set_sensitive(
                self.xml.get_widget("ipv6Checkbutton").get_active())
        else:
            map(lambda x: self.xml.get_widget(x).set_sensitive(False), boxes)

    def _populateNetdevs(self):
        combo = self.xml.get_widget("interfaceCombo")

        cell = gtk.CellRendererText()
        combo.pack_start(cell, True)
        combo.set_attributes(cell, text=0)
        cell.set_property("wrap-width", 525)
        combo.set_size_request(480, -1)

        store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
        combo.set_model(store)

        netdevs = self.network.available()
        devs = netdevs.keys()
        devs.sort()
        for dev in devs:
            i = store.append(None)
            desc = netdevs[dev].get("desc")
            if desc:
                desc = "%s - %s" % (dev, desc)
            else:
                desc = "%s" % (dev, )
            store[i] = (desc, dev)
            if dev == self.network.firstnetdevice:
                combo.set_active_iter(i)

    def run(self):
        gui.addFrame(self.window)
        self.window.show()
        gtk.main()
        return self.rc

    def destroy(self):
        self.window.destroy()

    def _handleIPMissing(self, field):
        d = gtk.MessageDialog(
            _("Error With Data"), 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
            _("A value is required for the field %s.") % (field, ))
        d.run()
        d.destroy()

    def _handleIPError(self, field, errmsg):
        d = gtk.MessageDialog(
            _("Error With Data"), 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
            _("An error occurred converting the value "
              "entered for \"%s\":\n%s") % (field, errmsg))
        d.run()
        d.destroy()

    def _cancel(self, *args):
        gtk.main_quit()
        self.rc = gtk.RESPONSE_CANCEL

    def _ok(self, *args):
        combo = self.xml.get_widget("interfaceCombo")
        active = combo.get_active_iter()
        val = combo.get_model().get_value(active, 1)
        netdev = self.network.available()[val]

        # FIXME: need to do input validation
        if self.xml.get_widget("dhcpCheckbutton").get_active():
            self.window.hide()
            w = gui.WaitWindow(
                _("Dynamic IP"),
                _("Sending request for IP information "
                  "for %s...") % (netdev.get("device")))
            ns = isys.dhcpNetDevice(netdev.get("device"))
            w.pop()
            if ns is not None:
                self.rc = gtk.RESPONSE_OK
            if ns:
                f = open("/etc/resolv.conf", "w")
                f.write("nameserver %s\n" % ns)
                f.close()
                isys.resetResolv()
        else:
            ipv4addr = self.xml.get_widget("ipv4Address").get_text()
            ipv4nm = self.xml.get_widget("ipv4Netmask").get_text()
            gateway = self.xml.get_widget("gatewayEntry").get_text()
            ns = self.xml.get_widget("nameserverEntry").get_text()

            try:
                network.sanityCheckIPString(ipv4addr)
            except network.IPMissing, msg:
                self._handleIPMissing(_("IP Address"))
                return
            except network.IPError, msg:
                self._handleIPError(_("IP Address"), msg)
                return

            if ipv4nm.find('.') == -1:
                # user provided a CIDR prefix
                try:
                    if int(ipv4nm) > 32 or int(ipv4nm) < 0:
                        msg = _("IPv4 CIDR prefix must be between 0 and 32.")
                        self._handleIPError(_("IPv4 Network Mask"), msg)
                        return
                    else:
                        ipv4nm = isys.prefix2netmask(int(ipv4nm))
                        netdev.set(('netmask', ipv4nm))
                except:
                    self._handleIPMissing(_("IPv4 Network Mask"))
                    return
            else:
                # user provided a dotted-quad netmask
                try:
                    network.sanityCheckIPString(ipv4nm)
                    netdev.set(('netmask', ipv4nm))
                except network.IPMissing, msg:
                    self._handleIPMissing(_("IPv4 Network Mask"))
                    return
                except network.IPError, msg:
                    self._handleIPError(_("IPv4 Network Mask"), msg)
                    return
Esempio n. 18
0
                        self._handleIPError(_("IPv4 Gateway"), msg)
                        return False

                if self.ipv4Nameserver:
                    for addr in self.ipv4Nameserver.split(','):
                        addr.split()
                        try:
                            network.sanityCheckIPString(addr)
                        except network.IPError, msg:
                            self._handleIPError(_("IPv4 Nameserver"), msg)
                            return False

        if self.ipv6Selected:
            if self.ipv6Method == "v6manual":
                try:
                    network.sanityCheckIPString(self.ipv6Address)
                except network.IPMissing, msg:
                    self._handleIPMissing(_("IPv6 Address"))
                    return False
                except network.IPError, msg:
                    self._handleIPError(_("IPv6 Address"), msg)
                    return False

                if not self.ipv6Prefix:
                    self._handleIPMissing(_("IPv6 Prefix"))
                    return False
                elif (int(self.ipv6Prefix) < 0 or
                      int(self.ipv6Prefix) > 128):
                    msg = _("IPv6 CIDR prefix must be between 0 and 128.")
                    self._handleIPError(_("IPv6 Prefix"), msg)
                    return False
Esempio n. 19
0
    def addIscsiDrive(self):
        if not network.hasActiveNetDev():
            net = NetworkConfigurator(self.anaconda.id.network)
            ret = net.run()
            net.destroy()

        (dxml, dialog) = gui.getGladeWidget("iscsi-config.glade",
                                            "iscsiDialog")
        gui.addFrame(dialog)
        dialog.show_all()
        sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
        map(lambda x: sg.add_widget(dxml.get_widget(x)),
            ("iscsiAddrEntry", "iscsiInitiatorEntry", "userEntry", "passEntry",
             "userinEntry", "passinEntry"))

        # get the initiator name if it exists and don't allow changing
        # once set
        e = dxml.get_widget("iscsiInitiatorEntry")
        e.set_text(self.anaconda.id.iscsi.initiator)
        if self.anaconda.id.iscsi.initiatorSet: # this is uglyyyy....
            e.set_sensitive(False)

        while 1:
            rc = dialog.run()
            if rc == gtk.RESPONSE_CANCEL:
                break

            initiator = dxml.get_widget("iscsiInitiatorEntry").get_text()
            initiator.strip()
            if len(initiator) == 0:
                self.intf.messageWindow(_("Invalid Initiator Name"),
                                        _("You must provide a non-zero length "
                                          "initiator name."))
                continue

            self.anaconda.id.iscsi.initiator = initiator

            target = dxml.get_widget("iscsiAddrEntry").get_text().strip()
            user = dxml.get_widget("userEntry").get_text().strip()
            pw = dxml.get_widget("passEntry").get_text().strip()
            user_in = dxml.get_widget("userinEntry").get_text().strip()
            pw_in = dxml.get_widget("passinEntry").get_text().strip()

            err = None
            try:
                count = len(target.split(":"))
                idx = target.rfind("]:")
                # Check for IPV6 [IPV6-ip]:port
                if idx != -1:
                    ip = target[1:idx]
                    port = target[idx+2:]
                # Check for IPV4 aaa.bbb.ccc.ddd:port
                elif count == 2:
                    idx = target.rfind(":")
                    ip = target[:idx]
                    port = target[idx+1:]
                else:
                    ip = target
                    port = "3260"
                network.sanityCheckIPString(ip)
            except network.IPMissing, msg:
                err = msg
            except network.IPError, msg:
                err = msg
Esempio n. 20
0
            except network.IPError, e:
                errors.append(e.message)
            except network.IPMissing, e:
                errors.append(e.message)

            netmask = self.netmask.get_text()
            try:
                network.sanityCheckIPString(netmask)
            except network.IPError, e:
                errors.append(e.message)
            except network.IPMissing, e:
                errors.append(e.message)

            defaultgw = self.defaultgw.get_text()
            try:
                network.sanityCheckIPString(defaultgw)
            except network.IPError, e:
                errors.append(e.message)
            except network.IPMissing, e:
                errors.append(e.message)

            if not isAddressInSubnet(defaultgw, (ipaddr, netmask)):
                errors.append("Gateway %s is outside the primary "
                              "interface's subnet." % defaultgw)

        if len(errors):
            self.intf.messageWindow(_("Error with Network Configuration"),
                                    _("The network configuration is not "
                                      "valid for the following reason(s):\n\n"
                                      "%s")
                                    % "\n".join(errors),
Esempio n. 21
0
                    return False
            else:
                # user provided a dotted-quad netmask
                try:
                    network.sanityCheckIPString(ipv4nm)
                    netdev.set(('NETMASK', ipv4nm))
                except network.IPMissing, msg:
                    self._handleIPMissing(_("IPv4 Network Mask"))
                    return False
                except network.IPError, msg:
                    self._handleIPError(_("IPv4 Network Mask"), msg)
                    return False

            try:
                if gateway:
                    network.sanityCheckIPString(gateway)
                    netdev.set(('GATEWAY', gateway))
            except network.IPMissing, msg:
                pass
            except network.IPError, msg:
                self._handleIPError(_("Gateway"), msg)
                return False

            try:
                if ns:
                    network.sanityCheckIPString(ns)
                    netdev.set(('DNS1', ns))
            except network.IPMissing, msg:
                pass
            except network.IPError, msg:
                self._handleIPError(_("Nameserver"), msg)
Esempio n. 22
0
    def __call__(self, screen, network, dir, intf):
        devices = network.available()
        if not devices:
            return INSTALL_NOOP

        # we don't let you set gateway/dns if you've got any interfaces
        # using dhcp (for better or worse)
        if anyUsingDHCP(devices):
            return INSTALL_NOOP

        thegrid = Grid(2, 4)

        thegrid.setField(Label(_("Gateway:")), 0, 0, anchorLeft = 1)
        gwEntry = Entry(16)
        # if it's set already, use that... otherwise, get the first
        # non-dhcp and active device and use it to guess the gateway
        if network.gateway:
            gwEntry.set(network.gateway)
        else:
            gwEntry.set(self.getFirstGatewayGuess(devices))
        thegrid.setField(gwEntry, 1, 0, padding = (1, 0, 0, 0))
        
        thegrid.setField(Label(_("Primary DNS:")), 0, 1, anchorLeft = 1)
        ns1Entry = Entry(16)
        ns1Entry.set(network.primaryNS)
        thegrid.setField(ns1Entry, 1, 1, padding = (1, 0, 0, 0))
        
        thegrid.setField(Label(_("Secondary DNS:")), 0, 2, anchorLeft = 1)
        ns2Entry = Entry(16)
        ns2Entry.set(network.secondaryNS)
        thegrid.setField(ns2Entry, 1, 2, padding = (1, 0, 0, 0))
        
        thegrid.setField(Label(_("Tertiary DNS:")), 0, 3, anchorLeft = 1)
        ns3Entry = Entry(16)
        ns3Entry.set(network.ternaryNS)
        thegrid.setField(ns3Entry, 1, 3, padding = (1, 0, 0, 0))

        bb = ButtonBar (screen, (TEXT_OK_BUTTON, TEXT_BACK_BUTTON))

        toplevel = GridFormHelp (screen, _("Miscellaneous Network Settings"),
				 "miscnetwork", 1, 3)
        toplevel.add (thegrid, 0, 0, (0, 0, 0, 1), anchorLeft = 1)
        toplevel.add (bb, 0, 2, growx = 1)

        while 1:
            result = toplevel.run()
            rc = bb.buttonPressed (result)

            if rc == TEXT_BACK_CHECK:
                screen.popWindow()
                return INSTALL_BACK

            val = gwEntry.value()
            if val and sanityCheckIPString(val) is None:
                badIPDisplay(screen, val)
                continue
            network.gateway = val

            val = ns1Entry.value()
            if val and sanityCheckIPString(val) is None:
                badIPDisplay(screen, val)
                continue
            network.primaryNS = val

            val = ns2Entry.value()
            if val and sanityCheckIPString(val) is None:
                badIPDisplay(screen, val)
                continue
            network.secondaryNS = val

            val = ns3Entry.value()
            if val and sanityCheckIPString(val) is None:
                badIPDisplay(screen, val)
                continue
            network.ternaryNS = val
            break

        screen.popWindow()        
        return INSTALL_OK
Esempio n. 23
0
            except network.IPError, e:
                errors.append(e.message)
            except network.IPMissing, e:
                errors.append(e.message)

            netmask = self.netmask.get_text()
            try:
                network.sanityCheckIPString(netmask)
            except network.IPError, e:
                errors.append(e.message)
            except network.IPMissing, e:
                errors.append(e.message)

            defaultgw = self.defaultgw.get_text()
            try:
                network.sanityCheckIPString(defaultgw)
            except network.IPError, e:
                errors.append(e.message)
            except network.IPMissing, e:
                errors.append(e.message)

            if not isAddressInSubnet(defaultgw, (ipaddr, netmask)):
                errors.append("Gateway %s is outside the primary "
                              "interface's subnet." % defaultgw)

        if len(errors):
            self.intf.messageWindow(_("Error with Network Configuration"),
                                    _("The network configuration is not "
                                      "valid for the following reason(s):\n\n"
                                      "%s") % "\n".join(errors),
                                    custom_icon="error")
Esempio n. 24
0
def addIscsiDrive(anaconda):
    if not network.hasActiveNetDev():
        net = NetworkConfigurator(anaconda.network)
        ret = net.run()
        net.destroy()
        if ret != gtk.RESPONSE_OK:
            return ret

    (dxml, dialog) = gui.getGladeWidget("iscsi-config.glade", "iscsiDialog")
    gui.addFrame(dialog)
    dialog.show_all()
    sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
    for w in [
            "iscsiAddrEntry", "iscsiInitiatorEntry", "userEntry", "passEntry",
            "userinEntry", "passinEntry"
    ]:
        sg.add_widget(dxml.get_widget(w))

    # get the initiator name if it exists and don't allow changing
    # once set
    e = dxml.get_widget("iscsiInitiatorEntry")
    e.set_text(anaconda.storage.iscsi.initiator)
    if anaconda.storage.iscsi.initiatorSet:
        e.set_sensitive(False)

    while True:
        rc = dialog.run()
        if rc in [gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT]:
            break

        initiator = e.get_text().strip()
        if len(initiator) == 0:
            anaconda.intf.messageWindow(
                _("Invalid Initiator Name"),
                _("You must provide an initiator name."))
            continue

        anaconda.storage.iscsi.initiator = initiator

        target = dxml.get_widget("iscsiAddrEntry").get_text().strip()
        user = dxml.get_widget("userEntry").get_text().strip()
        pw = dxml.get_widget("passEntry").get_text().strip()
        user_in = dxml.get_widget("userinEntry").get_text().strip()
        pw_in = dxml.get_widget("passinEntry").get_text().strip()

        try:
            count = len(target.split(":"))
            idx = target.rfind("]:")
            # Check for IPV6 [IPV6-ip]:port
            if idx != -1:
                ip = target[1:idx]
                port = target[idx + 2:]
            # Check for IPV4 aaa.bbb.ccc.ddd:port
            elif count == 2:
                idx = target.rfind(":")
                ip = target[:idx]
                port = target[idx + 1:]
            else:
                ip = target
                port = "3260"

            network.sanityCheckIPString(ip)
        except (network.IPMissing, network.IPError) as msg:
            anaconda.intf.messageWindow(_("Error with Data"), msg)
            continue

        try:
            anaconda.storage.iscsi.addTarget(ip, port, user, pw, user_in,
                                             pw_in, anaconda.intf)
        except ValueError as e:
            anaconda.intf.messageWindow(_("Error"), str(e))
            continue
        except IOError as e:
            anaconda.intf.messageWindow(_("Error"), str(e))
            rc = gtk.RESPONSE_CANCEL

        break

    dialog.destroy()
    return rc
Esempio n. 25
0
    def run(self):
        grid = GridFormHelp(self.screen, _("Enable network interface"),
                            "netconfig", 1, 9)

        tb = TextboxReflowed(
            60,
            _("This requires that you have an active "
              "network connection during the installation "
              "process.  Please configure a network "
              "interface."))
        grid.add(tb, 0, 0, anchorLeft=1, padding=(0, 0, 0, 1))

        self.interfaceList = CheckboxTree(height=3, scroll=1)

        netdevs = self.anaconda.network.available()
        devs = netdevs.keys()
        devs.sort()
        ksdevice = self.anaconda.network.getKSDevice()
        if ksdevice:
            ksdevice = ksdevice.get('DEVICE')
        selected_interface = None

        for dev in devs:
            hwaddr = netdevs[dev].get("HWADDR")

            if hwaddr:
                desc = "%s - %.50s" % (dev, hwaddr)
            else:
                desc = dev

            if selected_interface is None:
                selected_interface = desc

            if ksdevice and ksdevice == dev:
                selected_interface = desc

            self.interfaceList.append(desc)

        if selected_interface:
            self.interfaceList.setCurrent(selected_interface)
        else:
            self.interfaceList.setCurrent(0)

        grid.add(self.interfaceList, 0, 1, padding=(0, 0, 0, 1))

        self.dhcpCheckbox = Checkbox(_("Use dynamic IP configuration (DHCP)"),
                                     1)
        grid.add(self.dhcpCheckbox, 0, 2, anchorLeft=1)

        self.ipv4Checkbox = Checkbox(_("Enable IPv4 support"), 1)
        grid.add(self.ipv4Checkbox, 0, 3, anchorLeft=1)

        #self.ipv6Checkbox = Checkbox(_("Enable IPv6 support"), 0)
        #grid.add(self.ipv6Checkbox, 0, 4, anchorLeft = 1, padding = (0, 0, 0, 1))

        ipv4Grid = Grid(4, 1)
        ipv4Grid.setField(Label(_("IPv4 Address:")),
                          0,
                          0,
                          padding=(0, 0, 1, 0))
        self.ipv4Address = Entry(20, scroll=1)
        ipv4Grid.setField(self.ipv4Address, 1, 0)
        ipv4Grid.setField(Label("/"), 2, 0)
        self.ipv4Netmask = Entry(20, scroll=0)
        ipv4Grid.setField(self.ipv4Netmask, 3, 0)

        grid.add(ipv4Grid, 0, 5, anchorLeft=1)

        #ipv6Grid = Grid(4, 1)
        #ipv6Grid.setField(Label(_("IPv6 Address:")), 0, 0, padding = (0, 0, 1, 0))
        #self.ipv6Address = Entry(20, scroll=1)
        #ipv6Grid.setField(self.ipv6Address, 1, 0)
        #ipv6Grid.setField(Label("/"), 2, 0)
        #self.ipv6Netmask = Entry(20, scroll=0)
        #ipv6Grid.setField(self.ipv6Netmask, 3, 0)

        #grid.add(ipv6Grid, 0, 6, anchorLeft = 1)

        extraGrid = Grid(4, 1)
        extraGrid.setField(Label(_("Gateway:")), 0, 0, padding=(0, 0, 1, 0))
        self.gatewayEntry = Entry(20, scroll=1)
        extraGrid.setField(self.gatewayEntry, 1, 0, padding=(0, 0, 2, 0))
        extraGrid.setField(Label(_("Nameserver:")), 2, 0, padding=(0, 0, 1, 0))
        self.nameserverEntry = Entry(20, scroll=1)
        extraGrid.setField(self.nameserverEntry, 3, 0)

        grid.add(extraGrid, 0, 7, anchorLeft=1)

        buttons = ButtonBar(self.screen, [TEXT_OK_BUTTON, TEXT_BACK_BUTTON])
        grid.add(buttons, 0, 8, anchorLeft=1, growx=1)

        self.dhcpCheckbox.setCallback(self._dhcpToggled)
        self.ipv4Checkbox.setCallback(self._ipv4Toggled)
        #self.ipv6Checkbox.setCallback(self._ipv6Toggled)

        # Call these functions to set initial UI state.
        self._ipv4Toggled()
        #self._ipv6Toggled()
        self._dhcpToggled()

        netdevs = self.anaconda.network.available()

        while True:
            result = grid.run()
            button = buttons.buttonPressed(result)

            if button == TEXT_BACK_CHECK:
                self.screen.popWindow()
                return INSTALL_BACK

            selected = map(lambda x: x.split()[0],
                           self.interfaceList.getSelection())
            if selected is None or selected == []:
                self.anaconda.intf.messageWindow(
                    _("Missing Device"), _("You must select a network device"))
                continue

            for name, dev in netdevs.items():
                if name in selected:
                    dev.set(('ONBOOT', 'yes'))
                else:
                    dev.set(('ONBOOT', 'no'))

            selected_netdevs = []
            for devname in selected:
                if not netdevs.has_key(devname):
                    continue

                netdev = netdevs[devname]
                selected_netdevs.append(netdev)
                netdev.set(("ONBOOT", "yes"))

                if self.dhcpCheckbox.selected():
                    netdev.set(("BOOTPROTO", "dhcp"))
                else:
                    netdev.set(("BOOTPROTO", "static"))
                    ipv4addr = self.ipv4Address.value()
                    ipv4nm = self.ipv4Netmask.value()
                    gateway = self.gatewayEntry.value()
                    ns = self.nameserverEntry.value()

                    try:
                        network.sanityCheckIPString(ipv4addr)
                        netdev.set(("IPADDR", ipv4addr))
                    except network.IPMissing, msg:
                        self._handleIPMissing(_("IP Address"))
                        continue
                    except network.IPError, msg:
                        self._handleIPError(_("IP Address"), msg)
                        continue

                    if ipv4nm.find('.') == -1:
                        # user provided a CIDR prefix
                        try:
                            if int(ipv4nm) > 32 or int(ipv4nm) < 0:
                                msg = _(
                                    "IPv4 CIDR prefix must be between 0 and 32."
                                )
                                self._handleIPError(_("IPv4 Network Mask"),
                                                    msg)
                                continue
                            else:
                                ipv4nm = isys.prefix2netmask(int(ipv4nm))
                                netdev.set(("NETMASK", ipv4nm))
                        except:
                            self._handleIPMissing(_("IPv4 Network Mask"))
                            continue
                    else:
                        # user provided a dotted-quad netmask
                        try:
                            network.sanityCheckIPString(ipv4nm)
                            netdev.set(("NETMASK", ipv4nm))
                        except network.IPMissing, msg:
                            self._handleIPMissing(_("IPv4 Network Mask"))
                            continue
                        except network.IPError, msg:
                            self._handleIPError(_("IPv4 Network Mask "), msg)
                            continue
Esempio n. 26
0
def addIscsiDrive(anaconda):
    if not network.hasActiveNetDev():
        net = NetworkConfigurator(anaconda.network)
        ret = net.run()
        net.destroy()
        if ret != gtk.RESPONSE_OK:
            return ret

    (dxml, dialog) = gui.getGladeWidget("iscsi-config.glade", "iscsiDialog")
    gui.addFrame(dialog)
    dialog.show_all()
    sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
    for w in ["iscsiAddrEntry", "iscsiInitiatorEntry", "userEntry",
              "passEntry", "userinEntry", "passinEntry"]:
        sg.add_widget(dxml.get_widget(w))

    # get the initiator name if it exists and don't allow changing
    # once set
    e = dxml.get_widget("iscsiInitiatorEntry")
    e.set_text(anaconda.storage.iscsi.initiator)
    if anaconda.storage.iscsi.initiatorSet:
        e.set_sensitive(False)

    while True:
        rc = dialog.run()
        if rc in [gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT]:
            break

        initiator = e.get_text().strip()
        if len(initiator) == 0:
            anaconda.intf.messageWindow(_("Invalid Initiator Name"),
                                        _("You must provide an initiator name."))
            continue

        anaconda.storage.iscsi.initiator = initiator

        target = dxml.get_widget("iscsiAddrEntry").get_text().strip()
        user = dxml.get_widget("userEntry").get_text().strip()
        pw = dxml.get_widget("passEntry").get_text().strip()
        user_in = dxml.get_widget("userinEntry").get_text().strip()
        pw_in = dxml.get_widget("passinEntry").get_text().strip()

        try:
            count = len(target.split(":"))
            idx = target.rfind("]:")
            # Check for IPV6 [IPV6-ip]:port
            if idx != -1:
                ip = target[1:idx]
                port = target[idx+2:]
            # Check for IPV4 aaa.bbb.ccc.ddd:port
            elif count == 2:
                idx = target.rfind(":")
                ip = target[:idx]
                port = target[idx+1:]
            else:
                ip = target
                port = "3260"

            network.sanityCheckIPString(ip)
        except (network.IPMissing, network.IPError) as msg:
            anaconda.intf.messageWindow(_("Error with Data"), msg)
            continue

        try:
            anaconda.storage.iscsi.addTarget(ip, port, user, pw,
                                             user_in, pw_in,
                                             anaconda.intf)
        except ValueError as e:
            anaconda.intf.messageWindow(_("Error"), str(e))
            continue
        except IOError as e:
            anaconda.intf.messageWindow(_("Error"), str(e))
            rc = gtk.RESPONSE_CANCEL

        break

    dialog.destroy()
    return rc
Esempio n. 27
0
                            self._handleIPError(_("IPv4 Network Mask "), msg)
                            continue

                    try:
                        if gateway:
                            network.sanityCheckIPString(gateway)
                            netdev.set(("GATEWAY", gateway))
                    except network.IPMissing, msg:
                        pass
                    except network.IPError, msg:
                        self._handleIPError(_("Gateway"), msg)
                        continue

                    try:
                        if ns:
                            network.sanityCheckIPString(ns)
                            netdev.set(("DNS1", ns))
                    except network.IPMissing, msg:
                        pass
                    except network.IPError, msg:
                        self._handleIPError(_("Nameserver"), msg)
                        continue

            w = self.anaconda.intf.waitWindow(_("Configuring Network Interfaces"), _("Waiting for NetworkManager"))
            result = self.anaconda.network.bringUp(devices=selected_netdevs)
            w.pop()
            if result:
                break
            else:
                 self.anaconda.intf.messageWindow(_("Error"), _("Error configuring network device"), _("Error configuring network device %s") % netdev.get('DEVICE'))
Esempio n. 28
0
class NetworkConfigurator:
    def __init__(self, network):
        (xml, w) = gui.getGladeWidget("netconfig.glade", "NetworkConfigWindow")

        self.window = w
        self.network = network
        self.xml = xml
        self.rc = gtk.RESPONSE_CANCEL

        self._setSizeGroup()
        self._connectSignals()
        self._populateNetdevs()

        self.xml.get_widget("ipv4Checkbutton").set_active(True)
        self.xml.get_widget("ipv6Checkbutton").set_active(False)

    def _connectSignals(self):
        sigs = { "on_ipv4Checkbutton_toggled": self._ipv4Toggled,
                 "on_ipv6Checkbutton_toggled": self._ipv6Toggled,
                 "on_dhcpCheckbutton_toggled": self._dhcpToggled,
                 "on_interfaceCombo_changed": self._netdevChanged,
                 "on_cancelButton_clicked": self._cancel,
                 "on_okButton_clicked": self._ok }
        self.xml.signal_autoconnect(sigs)

    def _setSizeGroup(self): # too bad we can't do this in the glade file
        sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
        for w in ("nameserverLabel", "gatewayLabel", "ipv6Label",
                  "ipv4Label", "interfaceLabel"):
            sg.add_widget(self.xml.get_widget(w))

    def _netdevChanged(self, combo):
        active = combo.get_active_iter()
        val = combo.get_model().get_value(active, 1)
        netdev = self.network.available()[val]

        bootproto = netdev.get("BOOTPROTO")
        if not bootproto or bootproto == "dhcp" or bootproto == "ibft":
            self.xml.get_widget("dhcpCheckbutton").set_active(True)
        else:
            self.xml.get_widget("dhcpCheckbutton").set_active(False)

            # FIXME: need to set ipv6 here too once we have that
            try:
                if netdev.get('IPADDR'):
                    self.xml.get_widget("ipv4Address").set_text(netdev.get('IPADDR'))
            except:
                pass

            try:
                if netdev.get('NETMASK'):
                    self.xml.get_widget("ipv4Netmask").set_text(netdev.get('NETMASK'))
            except:
                pass

            try:
                if self.network.gateway:
                    self.xml.get_widget("gatewayEntry").set_text(self.network.gateway)
            except:
                pass

            try:
                if self.network.primaryNS:
                    self.xml.get_widget("nameserverEntry").set_text(self.network.primaryNS)
            except:
                pass

    def _ipv4Toggled(self, cb):
        if self.xml.get_widget("dhcpCheckbutton").get_active():
            return
        if cb.get_active():
            self.xml.get_widget("ipv4Box").set_sensitive(True)
        else:
            self.xml.get_widget("ipv4Box").set_sensitive(False)

    def _ipv6Toggled(self, cb):
        if self.xml.get_widget("dhcpCheckbutton").get_active():
            return
        if cb.get_active():
            self.xml.get_widget("ipv6Box").set_sensitive(True)
        else:
            self.xml.get_widget("ipv6Box").set_sensitive(False)

    def _dhcpToggled(self, cb):
        boxes = ("ipv4Box", "ipv6Box", "nameserverBox", "gatewayBox")
        if not cb.get_active():
            map(lambda x: self.xml.get_widget(x).set_sensitive(True), boxes)
            self.xml.get_widget("ipv4Box").set_sensitive(self.xml.get_widget("ipv4Checkbutton").get_active())
            self.xml.get_widget("ipv6Box").set_sensitive(self.xml.get_widget("ipv6Checkbutton").get_active())
        else:
            map(lambda x: self.xml.get_widget(x).set_sensitive(False), boxes)

    def _populateNetdevs(self):
        combo = self.xml.get_widget("interfaceCombo")

        cell = gtk.CellRendererText()
        combo.pack_start(cell, True)
        combo.set_attributes(cell, text = 0)
        cell.set_property("wrap-width", 525)
        combo.set_size_request(480, -1)

        store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
        combo.set_model(store)

        netdevs = self.network.available()
        devs = netdevs.keys()
        devs.sort()
        ksdevice = self.network.getKSDevice()
        if ksdevice:
            ksdevice = ksdevice.get('DEVICE')
        selected_interface = None

        for dev in devs:
            i = store.append(None)
            hwaddr = netdevs[dev].get("HWADDR")

            if hwaddr:
                desc = "%s - %s" %(dev, hwaddr,)
            else:
                desc = "%s" %(dev,)

            if selected_interface is None:
                selected_interface = i

            if ksdevice and ksdevice == dev:
                selected_interface = i

            store[i] = (desc, dev)

        if selected_interface:
            combo.set_active_iter(selected_interface)
        else:
            combo.set_active(0)

    def run(self):
        gui.addFrame(self.window)
        busycursor = gui.getBusyCursorStatus()
        gui.setCursorToNormal()

        self.window.show()
        while True:
            rc = self.window.run()
            if rc in [gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT]:
                self._cancel()
                break
            if self._ok():
                break

        # restore busy cursor
        if busycursor:
            gui.setCursorToBusy()
        return self.rc

    def destroy(self):
        self.window.destroy()

    def _handleIPError(self, field, errmsg):
        d = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR,
                              gtk.BUTTONS_OK,
                                _("An error occurred converting the value "
                                  "entered for \"%(field)s\":\n%(errmsg)s")
                                % {'field': field, 'errmsg': errmsg})
        d.set_title(_("Error With Data"))
        d.set_position(gtk.WIN_POS_CENTER)
        gui.addFrame(d)
        d.run()
        d.destroy()

    def _handleIPMissing(self, field):
        d = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
                         _("A value is required for the field %s.") % (field,))
        d.set_title(_("Error With Data"))
        d.set_position(gtk.WIN_POS_CENTER)
        gui.addFrame(d)
        d.run()
        d.destroy()

    def _handleNetworkError(self, field):
        d = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR,
                              gtk.BUTTONS_OK,
                              _("An error occurred trying to bring up the "
                                "%s network interface.") % (field,))
        d.set_title(_("Error Configuring Network"))
        d.set_position(gtk.WIN_POS_CENTER)
        gui.addFrame(d)
        d.run()
        d.destroy()

    def _cancel(self, *args):
        self.rc = gtk.RESPONSE_CANCEL

    def _ok(self, *args):
        self.rc = gtk.RESPONSE_OK
        haveNet = False
        combo = self.xml.get_widget("interfaceCombo")
        active = combo.get_active_iter()
        val = combo.get_model().get_value(active, 1)
        for v, dev in self.network.available().items():
            if v == val:
                dev.set(('ONBOOT', 'yes'))
                netdev = dev
            else:
                dev.set(('ONBOOT', 'no'))

        # FIXME: need to do input validation
        if self.xml.get_widget("dhcpCheckbutton").get_active():
            netdev.set(('BOOTPROTO', 'dhcp'))
            self.window.hide()
            w = gui.WaitWindow(_("Dynamic IP Address"),
                               _("Sending request for IP address information "
                                 "for %s") % (netdev.get('DEVICE'),))
            haveNet = self.network.bringUp(devices=[netdev])
            w.pop()
        else:
            netdev.set(('BOOTPROTO', 'static'))
            ipv4addr = self.xml.get_widget("ipv4Address").get_text()
            ipv4nm = self.xml.get_widget("ipv4Netmask").get_text()
            gateway = self.xml.get_widget("gatewayEntry").get_text()
            ns = self.xml.get_widget("nameserverEntry").get_text()

            try:
                network.sanityCheckIPString(ipv4addr)
                netdev.set(('IPADDR', ipv4addr))
            except network.IPMissing, msg:
                self._handleIPMissing(_("IP Address"))
                return False
            except network.IPError, msg:
                self._handleIPError(_("IP Address"), msg)
                return False

            if ipv4nm.find('.') == -1:
                # user provided a CIDR prefix
                try:
                    if int(ipv4nm) > 32 or int(ipv4nm) < 0:
                        msg = _("IPv4 CIDR prefix must be between 0 and 32.")
                        self._handleIPError(_("IPv4 Network Mask"), msg)
                        return False
                    else:
                        ipv4nm = isys.prefix2netmask(int(ipv4nm))
                        netdev.set(('NETMASK', ipv4nm))
                except:
                    self._handleIPMissing(_("IPv4 Network Mask"))
                    return False
            else:
                # user provided a dotted-quad netmask
                try:
                    network.sanityCheckIPString(ipv4nm)
                    netdev.set(('NETMASK', ipv4nm))
                except network.IPMissing, msg:
                    self._handleIPMissing(_("IPv4 Network Mask"))
                    return False
                except network.IPError, msg:
                    self._handleIPError(_("IPv4 Network Mask"), msg)
                    return False
Esempio n. 29
0
    def run(self):
        grid = GridFormHelp(self.screen, _("Enable network interface"), "netconfig",
                            1, 9)

        tb = TextboxReflowed(60, _("This requires that you have an active "
                                   "network connection during the installation "
                                   "process.  Please configure a network "
                                   "interface."))
        grid.add(tb, 0, 0, anchorLeft = 1, padding = (0, 0, 0, 1))

        self.interfaceList = CheckboxTree(height=3, scroll=1)

        netdevs = self.anaconda.network.available()
        devs = netdevs.keys()
        devs.sort()
        ksdevice = self.anaconda.network.getKSDevice()
        if ksdevice:
            ksdevice = ksdevice.get('DEVICE')
        selected_interface = None

        for dev in devs:
            hwaddr = netdevs[dev].get("HWADDR")

            if hwaddr:
                desc = "%s - %.50s" % (dev, hwaddr)
            else:
                desc = dev

            if selected_interface is None:
                selected_interface = desc

            if ksdevice and ksdevice == dev:
                selected_interface = desc

            self.interfaceList.append(desc)

        if selected_interface:
            self.interfaceList.setCurrent(selected_interface)
        else:
            self.interfaceList.setCurrent(0)

        grid.add(self.interfaceList, 0, 1, padding = (0, 0, 0, 1))

        self.dhcpCheckbox = Checkbox(_("Use dynamic IP configuration (DHCP)"), 1)
        grid.add(self.dhcpCheckbox, 0, 2, anchorLeft = 1)

        self.ipv4Checkbox = Checkbox(_("Enable IPv4 support"), 1)
        grid.add(self.ipv4Checkbox, 0, 3, anchorLeft = 1)

        #self.ipv6Checkbox = Checkbox(_("Enable IPv6 support"), 0)
        #grid.add(self.ipv6Checkbox, 0, 4, anchorLeft = 1, padding = (0, 0, 0, 1))

        ipv4Grid = Grid(4, 1)
        ipv4Grid.setField(Label(_("IPv4 Address:")), 0, 0, padding = (0, 0, 1, 0))
        self.ipv4Address = Entry(20, scroll=1)
        ipv4Grid.setField(self.ipv4Address, 1, 0)
        ipv4Grid.setField(Label("/"), 2, 0)
        self.ipv4Netmask = Entry(20, scroll=0)
        ipv4Grid.setField(self.ipv4Netmask, 3, 0)

        grid.add(ipv4Grid, 0, 5, anchorLeft = 1)

        #ipv6Grid = Grid(4, 1)
        #ipv6Grid.setField(Label(_("IPv6 Address:")), 0, 0, padding = (0, 0, 1, 0))
        #self.ipv6Address = Entry(20, scroll=1)
        #ipv6Grid.setField(self.ipv6Address, 1, 0)
        #ipv6Grid.setField(Label("/"), 2, 0)
        #self.ipv6Netmask = Entry(20, scroll=0)
        #ipv6Grid.setField(self.ipv6Netmask, 3, 0)

        #grid.add(ipv6Grid, 0, 6, anchorLeft = 1)

        extraGrid = Grid(4, 1)
        extraGrid.setField(Label(_("Gateway:")), 0, 0, padding = (0, 0, 1, 0))
        self.gatewayEntry = Entry(20, scroll=1)
        extraGrid.setField(self.gatewayEntry, 1, 0, padding = (0, 0, 2, 0))
        extraGrid.setField(Label(_("Nameserver:")), 2, 0, padding = (0, 0, 1, 0))
        self.nameserverEntry = Entry(20, scroll=1)
        extraGrid.setField(self.nameserverEntry, 3, 0)

        grid.add(extraGrid, 0, 7, anchorLeft = 1)

        buttons = ButtonBar(self.screen, [TEXT_OK_BUTTON, TEXT_BACK_BUTTON] )
        grid.add(buttons, 0, 8, anchorLeft = 1, growx = 1)

        self.dhcpCheckbox.setCallback(self._dhcpToggled)
        self.ipv4Checkbox.setCallback(self._ipv4Toggled)
        #self.ipv6Checkbox.setCallback(self._ipv6Toggled)

        # Call these functions to set initial UI state.
        self._ipv4Toggled()
        #self._ipv6Toggled()
        self._dhcpToggled()

        netdevs = self.anaconda.network.available()

        while True:
            result = grid.run()
            button = buttons.buttonPressed(result)

            if button == TEXT_BACK_CHECK:
                self.screen.popWindow()
                return INSTALL_BACK

            selected = map(lambda x: x.split()[0], self.interfaceList.getSelection())
            if selected is None or selected == []:
                self.anaconda.intf.messageWindow(_("Missing Device"),
                                                 _("You must select a network device"))
                continue

            for name, dev in netdevs.items():
                if name in selected:
                    dev.set(('ONBOOT', 'yes'))
                else:
                    dev.set(('ONBOOT', 'no'))

            selected_netdevs = []
            for devname in selected:
                if not netdevs.has_key(devname):
                    continue

                netdev = netdevs[devname]
                selected_netdevs.append(netdev)
                netdev.set(("ONBOOT", "yes"))

                if self.dhcpCheckbox.selected():
                    netdev.set(("BOOTPROTO", "dhcp"))
                else:
                    netdev.set(("BOOTPROTO", "static"))
                    ipv4addr = self.ipv4Address.value()
                    ipv4nm = self.ipv4Netmask.value()
                    gateway = self.gatewayEntry.value()
                    ns = self.nameserverEntry.value()

                    try:
                        network.sanityCheckIPString(ipv4addr)
                        netdev.set(("IPADDR", ipv4addr))
                    except network.IPMissing, msg:
                        self._handleIPMissing(_("IP Address"))
                        continue
                    except network.IPError, msg:
                        self._handleIPError(_("IP Address"), msg)
                        continue

                    if ipv4nm.find('.') == -1:
                        # user provided a CIDR prefix
                        try:
                            if int(ipv4nm) > 32 or int(ipv4nm) < 0:
                                msg = _("IPv4 CIDR prefix must be between 0 and 32.")
                                self._handleIPError(_("IPv4 Network Mask"), msg)
                                continue
                            else:
                                ipv4nm = isys.prefix2netmask(int(ipv4nm))
                                netdev.set(("NETMASK", ipv4nm))
                        except:
                            self._handleIPMissing(_("IPv4 Network Mask"))
                            continue
                    else:
                        # user provided a dotted-quad netmask
                        try:
                            network.sanityCheckIPString(ipv4nm)
                            netdev.set(("NETMASK", ipv4nm))
                        except network.IPMissing, msg:
                            self._handleIPMissing(_("IPv4 Network Mask"))
                            continue
                        except network.IPError, msg:
                            self._handleIPError(_("IPv4 Network Mask "), msg)
                            continue
Esempio n. 30
0
class NetworkWindow(InstallWindow):
    def getScreen(self, anaconda):
        self.intf = anaconda.intf
        self.anaconda = anaconda
        self.hostname = network.getDefaultHostname(anaconda)

        # load the UI
        (self.xml, self.align) = gui.getGladeWidget("network_euca.glade",
                                                    "network_align")
        self.icon = self.xml.get_widget("icon")
        self.hostnameEntry = self.xml.get_widget("hostnameEntry")
        self.hostnameEntry.set_text(self.hostname)

        self.netconfButton = self.xml.get_widget("netconfButton")
        self.netconfButton.connect("clicked", self._netconfButton_clicked)
        if len(self.anaconda.id.network.netdevices) == 0:
            self.netconfButton.set_sensitive(False)

        # pressing Enter in confirm == clicking Next
        self.hostnameEntry.connect("activate",
                                   lambda w: self.ics.setGrabNext(1))

        self.netifCombo = self.xml.get_widget("netifcombo")
        cell = gtk.CellRendererText()
        self.ipaddr = self.xml.get_widget("ipaddr")
        self.netmask = self.xml.get_widget("netmask")
        self.defaultgw = self.xml.get_widget("defaultgw")
        self.netifCombo.set_model(gtk.ListStore(gobject.TYPE_STRING))
        self.netifCombo.pack_start(cell)
        self.netifCombo.add_attribute(cell, 'text', 0)
        for dev in anaconda.id.network.netdevices.keys():
            self.netifCombo.append_text(dev)
        self.netifCombo.set_active(0)
        self.netifCombo.connect("changed", self._netifCombo_changed)
        self.dhcpCombo = self.xml.get_widget("dhcpcombo")
        self.dhcpCombo.connect("changed", self._dhcpCombo_changed)

        self.dnsserver = self.xml.get_widget("dnsserver")

        # load current network settings
        self._netifCombo_changed()

        # Only reset to Static mode when we are going forward.
        # A little hacky, but good enough for now.
        if anaconda.dir == DISPATCH_FORWARD:
            self.dhcpCombo.set_active(0)
            self._dhcpCombo_changed()

        # load the icon
        gui.readImageFromFile("network.png", image=self.icon)

        return self.align

    def _dhcpCombo_changed(self, *args):
        val = self.dhcpCombo.get_model()[self.dhcpCombo.get_active()][0]
        editable = True
        if val == "DHCP":
            editable = False
        for widget in [self.ipaddr, self.netmask, self.defaultgw]:
            widget.set_editable(editable)
            widget.set_sensitive(editable)

    def _netifCombo_changed(self, *args):
        val = self.netifCombo.get_model()[self.netifCombo.get_active()][0]
        dev = self.anaconda.id.network.netdevices[val]
        if dev.get('BOOTPROTO') in ["static", "none"]:
            self.dhcpCombo.set_active(0)
            self.ipaddr.set_text(dev.get("IPADDR"))
            netmask = dev.get("NETMASK")
            if not netmask:
                prefix = dev.get("PREFIX")
                if prefix:
                    netmask = socket.inet_ntoa(
                        struct.pack("<L", ((1L << int(prefix)) - 1)))

            self.netmask.set_text(netmask)
            self.defaultgw.set_text(dev.get("GATEWAY"))
            dnsservers = []
            i = 1
            while True:
                server = dev.get("DNS%d" % i)
                if server:
                    dnsservers.append(server)
                else:
                    break
                i += 1
            self.dnsserver.set_text(",".join(dnsservers))
        else:
            self.dhcpCombo.set_active(1)
            self.ipaddr.set_text("")
            self.netmask.set_text("")
            self.defaultgw.set_text("")
            self.dnsserver.set_text("")
        self._dhcpCombo_changed()

    def _netconfButton_clicked(self, *args):
        setupNetwork(self.intf)
        self._netifCombo_changed(self, *args)

    def focus(self):
        self.hostnameEntry.grab_focus()

    def hostnameError(self):
        self.hostnameEntry.grab_focus()
        raise gui.StayOnScreen

    def getNext(self):
        hostname = string.strip(self.hostnameEntry.get_text())
        herrors = network.sanityCheckHostname(hostname)

        if not hostname:
            self.intf.messageWindow(
                _("Error with Hostname"),
                _("You must enter a valid hostname for this "
                  "computer."),
                custom_icon="error")
            self.hostnameError()

        if herrors is not None:
            self.intf.messageWindow(_("Error with Hostname"),
                                    _("The hostname \"%(hostname)s\" is not "
                                      "valid for the following reason:\n\n"
                                      "%(herrors)s") % {
                                          'hostname': hostname,
                                          'herrors': herrors
                                      },
                                    custom_icon="error")
            self.hostnameError()

        netif = self.netifCombo.get_model()[self.netifCombo.get_active()][0]
        mode = self.dhcpCombo.get_model()[self.dhcpCombo.get_active()][0]
        ipaddr = ''
        netmask = ''
        defaultgw = ''
        errors = []
        if mode == "Static":
            ipaddr = self.ipaddr.get_text()
            try:
                network.sanityCheckIPString(ipaddr)
            except network.IPError, e:
                errors.append(e.message)
            except network.IPMissing, e:
                errors.append(e.message)

            netmask = self.netmask.get_text()
            try:
                network.sanityCheckIPString(netmask)
            except network.IPError, e:
                errors.append(e.message)
Esempio n. 31
0
    def addIscsiDrive(self):
        if not network.hasActiveNetDev():
            net = NetworkConfigurator(self.anaconda.id.network)
            ret = net.run()
            net.destroy()

        (dxml, dialog) = gui.getGladeWidget("iscsi-config.glade",
                                            "iscsiDialog")
        gui.addFrame(dialog)
        dialog.show_all()
        sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
        map(lambda x: sg.add_widget(dxml.get_widget(x)),
            ("iscsiAddrEntry", "iscsiInitiatorEntry", "userEntry", "passEntry",
             "userinEntry", "passinEntry"))

        # get the initiator name if it exists and don't allow changing
        # once set
        e = dxml.get_widget("iscsiInitiatorEntry")
        e.set_text(self.anaconda.id.iscsi.initiator)
        if self.anaconda.id.iscsi.initiatorSet:  # this is uglyyyy....
            e.set_sensitive(False)

        while 1:
            rc = dialog.run()
            if rc in [gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT]:
                break

            initiator = dxml.get_widget("iscsiInitiatorEntry").get_text()
            initiator.strip()
            if len(initiator) == 0:
                self.intf.messageWindow(
                    _("Invalid Initiator Name"),
                    _("You must provide a non-zero length "
                      "initiator name."))
                continue

            self.anaconda.id.iscsi.initiator = initiator

            target = dxml.get_widget("iscsiAddrEntry").get_text().strip()
            user = dxml.get_widget("userEntry").get_text().strip()
            pw = dxml.get_widget("passEntry").get_text().strip()
            user_in = dxml.get_widget("userinEntry").get_text().strip()
            pw_in = dxml.get_widget("passinEntry").get_text().strip()

            err = None
            try:
                count = len(target.split(":"))
                idx = target.rfind("]:")
                # Check for IPV6 [IPV6-ip]:port
                if idx != -1:
                    ip = target[1:idx]
                    port = target[idx + 2:]
                # Check for IPV4 aaa.bbb.ccc.ddd:port
                elif count == 2:
                    idx = target.rfind(":")
                    ip = target[:idx]
                    port = target[idx + 1:]
                else:
                    ip = target
                    port = "3260"
                network.sanityCheckIPString(ip)
            except network.IPMissing, msg:
                err = msg
            except network.IPError, msg:
                err = msg