def __attrs_post_init__(self):
super().__attrs_post_init__()
self.log = logging.getLogger('UdevManager')
self._context = pyudev.Context()
self._monitor = pyudev.Monitor.from_netlink(self._context)
self._monitor.start()
def list_devices(fixed=False):
"""
List inserted USB devices.
:return: USB devices as list.
"""
devices = []
if platform.system() == "Linux":
try:
# pyudev is good enough to detect USB devices on modern Linux machines.
gen.log("Using pyudev for detecting USB drives...")
try:
import pyudev
except Exception as e:
gen.log(
'PyUdev is not installed on host system, using built-in.')
from . import pyudev
context = pyudev.Context()
for device in context.list_devices(subsystem='block',
ID_BUS="usb"):
devices.append(str(device['DEVNAME']))
gen.log("\t" + device['DEVNAME'])
if fixed is True:
for device in context.list_devices(subsystem='block'):
if device.get('DEVTYPE') in [
'disk', 'partition'
] and device.get('ID_PART_TABLE_TYPE'):
if device['DEVNAME'] not in devices:
devices.append(str(device['DEVNAME']))
gen.log("\t" + device['DEVNAME'])
except Exception as e:
gen.log(e)
import dbus
bus = dbus.SystemBus()
try:
# You should come here only if your system does'nt have udev installed.
# We will use udiskd2 for now.
gen.log("Falling back to Udisks2..")
ud_manager_obj = bus.get_object('org.freedesktop.UDisks2',
'/org/freedesktop/UDisks2')
ud_manager = dbus.Interface(
ud_manager_obj, 'org.freedesktop.DBus.ObjectManager')
for k, v in ud_manager.GetManagedObjects().items():
drive_info = v.get('org.freedesktop.UDisks2.Block', {})
if fixed is True:
if drive_info.get(
'IdUsage'
) == "filesystem" and not drive_info.get('ReadOnly'):
device = drive_info.get('Device')
device = bytearray(device).replace(
b'\x00', b'').decode('utf-8')
devices.append(device)
else:
if drive_info.get(
'IdUsage'
) == "filesystem" and not drive_info.get(
'HintSystem') and not drive_info.get(
'ReadOnly'):
device = drive_info.get('Device')
device = bytearray(device).replace(
b'\x00', b'').decode('utf-8')
devices.append(device)
except Exception as e:
gen.log(e, error=True)
try:
# You must be using really old distro. Otherwise, the code
# should not reach here.
gen.log("Falling back to Udisks1...")
ud_manager_obj = bus.get_object("org.freedesktop.UDisks",
"/org/freedesktop/UDisks")
ud_manager = dbus.Interface(ud_manager_obj,
'org.freedesktop.UDisks')
for dev in ud_manager.EnumerateDevices():
device_obj = bus.get_object("org.freedesktop.UDisks",
dev)
device_props = dbus.Interface(device_obj,
dbus.PROPERTIES_IFACE)
if device_props.Get(
'org.freedesktop.UDisks.Device',
"DriveConnectionInterface"
) == "usb" and device_props.Get(
'org.freedesktop.UDisks.Device',
"DeviceIsPartition"):
if device_props.Get(
'org.freedesktop.UDisks.Device',
"DeviceIsMounted"):
device_file = device_props.Get(
'org.freedesktop.UDisks.Device',
"DeviceFile")
devices.append(device_file)
except Exception as e:
gen.log(e, error=True)
gen.log("No USB device found...")
devices.sort()
elif platform.system() == "Windows":
if fixed is True:
for drive in psutil.disk_partitions():
if 'cdrom' in drive.opts or drive.fstype == '':
# Skip cdrom drives or the disk with no filesystem
continue
devices.append(drive[0][:-1])
else:
try:
# Try new method using psutil. It should also detect USB 3.0 (but not tested by me)
for drive in psutil.disk_partitions():
if 'cdrom' in drive.opts or drive.fstype == '':
# Skip cdrom drives or the disk with no filesystem
continue
if 'removable' in drive.opts:
devices.append(drive[0][:-1])
except:
# Revert back to old method if psutil fails (which is unlikely)
oFS = win32com.client.Dispatch("Scripting.FileSystemObject")
oDrives = oFS.Drives
for drive in oDrives:
if drive.DriveType == 1 and drive.IsReady:
devices.append(drive)
if devices:
return devices
else:
gen.log("No USB device found...")
return None
def _NumatoUsbDetect():
context = pyudev.Context()
tty_devices = context.list_devices(subsystem='tty')
for dev in tty_devices.match_property('ID_VENDOR_ID', '2a19'):
numato_id = _NumatoRead(dev.device_node, 'id get')
yield dev.device_node, numato_id
def get_gamepad(cls):
context = pyudev.Context()
for js_device in context.list_devices(subsystem="input", ID_INPUT_JOYSTICK=1):
if js_device.device_node:
return cls(js_device)
def get_udev_devices(job=None, logger=None, device_info=None):
"""
Get udev device nodes based on serial, vendor and product ID
All subsystems are allowed so that additional hardware like
tty devices can be added to the LXC. The ID to match is controlled
by the lab admin.
"""
context = pyudev.Context()
device_paths = set()
devices = []
if job:
devices = job.device.get("device_info", [])
# device_info argument overrides job device_info
if device_info:
devices = device_info
if not devices:
return []
added = set()
for usb_device in devices:
board_id = str(usb_device.get("board_id", ""))
usb_vendor_id = str(usb_device.get("usb_vendor_id", ""))
usb_product_id = str(usb_device.get("usb_product_id", ""))
usb_fs_label = str(usb_device.get("fs_label", ""))
# check if device is already connected
# try with all parameters such as board id, usb_vendor_id and
# usb_product_id
for device in context.list_devices():
if board_id and usb_vendor_id and usb_product_id:
if ((device.get("ID_SERIAL_SHORT") == board_id)
and (device.get("ID_VENDOR_ID") == usb_vendor_id)
and (device.get("ID_MODEL_ID") == usb_product_id)):
device_paths.add(device.device_node)
added.add(board_id)
for child in device.children:
if child.device_node:
device_paths.add(child.device_node)
for link in device.device_links:
device_paths.add(link)
elif board_id and usb_vendor_id and not usb_product_id:
# try with parameters such as board id, usb_vendor_id
if (device.get("ID_SERIAL_SHORT")
== board_id) and (device.get("ID_VENDOR_ID")
== usb_vendor_id):
device_paths.add(device.device_node)
added.add(board_id)
for child in device.children:
if child.device_node:
device_paths.add(child.device_node)
for link in device.device_links:
device_paths.add(link)
elif board_id and not usb_vendor_id and not usb_product_id:
# try with board id alone
if device.get("ID_SERIAL_SHORT") == board_id:
device_paths.add(device.device_node)
added.add(board_id)
for child in device.children:
if child.device_node:
device_paths.add(child.device_node)
for link in device.device_links:
device_paths.add(link)
elif usb_fs_label:
# Just restrict by filesystem label.
if device.get("ID_FS_LABEL") == usb_fs_label:
device_paths.add(device.device_node)
added.add(usb_fs_label)
for child in device.children:
if child.device_node:
device_paths.add(child.device_node)
for link in device.device_links:
device_paths.add(link)
if device_info:
for static_device in device_info:
for _, value in static_device.items():
if value not in added:
raise InfrastructureError(
"Unable to add all static devices: board_id '%s' was not found"
% value)
if logger and device_paths:
logger.debug("Adding %s", ", ".join(device_paths))
return list(device_paths)
import os
import re
import subprocess
import logging
import pyudev
from . import util
from .size import Size
from .flags import flags
import gi
gi.require_version("BlockDev", "2.0")
from gi.repository import BlockDev as blockdev
global_udev = pyudev.Context()
log = logging.getLogger("blivet")
ignored_device_names = []
""" device name regexes to ignore; this should be empty by default """
def device_to_dict(device):
# Transform Device to dictionary
# Originally it was possible to use directly Device where needed,
# but it lead to unfixable excessive deprecation warnings from udev.
# Sice blivet uses Device.properties only (with couple of exceptions)
# this is a functional workaround. (japokorn May 2017)
result = dict(device.properties)
result["SYS_NAME"] = device.sys_name
def test_create(self, device):
'''
Make sure the correct device is created
'''
name = f'ratbag-emu {device.name} ({self.vid:04x}:{self.pid:04x}, 0)'
assert list(pyudev.Context().list_devices(subsystem='hid', HID_NAME=name))
def get_dev_model(self):
context = pyudev.Context()
udev_model = pyudev.Device.from_device_file(context, self.dev)
dev_model = udev_model.get('ID_MODEL')
return dev_model
def execute(self):
# Check if postfix is running.
try:
manager = openmediavault.systemd.Manager()
unit = manager.get_unit("postfix.service")
active = unit.active
except Exception: # pylint: disable=broad-except
active = False
if not active:
d = dialog.Dialog(dialog="dialog")
code = d.msgbox(
"Failed to submit the system diagnostic "
"report to the administrator account via email because "
"the email notification service is disabled.",
backtitle=self.description,
height=7,
width=56,
)
if code != d.OK:
return 0
code = d.yesno(
"Do you want to copy the system diagnostic "
"report onto an USB device?",
backtitle=self.description,
height=6,
width=45,
)
if code != d.OK:
return 0
d.infobox(
"Please connect the USB device now.",
backtitle=self.description,
height=3,
width=38,
)
# Wait until USB device is plugged in.
context = pyudev.Context()
monitor = pyudev.Monitor.from_netlink(context)
monitor.filter_by(subsystem="block", device_type="partition")
monitor.start()
for device in iter(monitor.poll, None):
# Only process 'add' events.
if device.action != "add":
continue
# Only process partitions with a file systems.
if not "ID_FS_TYPE" in device:
continue
break
d.infobox(
"USB device {} detected. Please wait ...".format(
device.get("DEVNAME")),
backtitle=self.description,
height=3,
width=50,
)
try:
mntdir = tempfile.mkdtemp()
outfile = "{}/sysinfo-{}-{}.txt".format(
mntdir, socket.gethostname(), time.strftime("%Y%m%d%H%M"))
openmediavault.procutils.check_call(
["mount", device.get("DEVNAME"), mntdir])
with open(outfile, "w") as out:
openmediavault.procutils.check_call(["omv-sysinfo"],
stdout=out)
except: # pylint: disable=try-except-raise
raise
finally:
openmediavault.procutils.check_call(
["umount", device.get("DEVNAME")])
shutil.rmtree(mntdir)
d.infobox(
"You can disconnect the USB device now.",
backtitle=self.description,
height=3,
width=42,
)
else:
print("Submitting system diagnostic report to the "
"administrator account. Please check your email "
"mailbox ...")
openmediavault.procutils.check_call([
"omv-sysinfo",
"|",
"mail",
"-s",
"System diagnostic report",
"root",
])
return 0
def enumerate_devices():
global devices
global enumstate
t0 = time.monotonic()
if enumstate == 'init':
enumstate = {
'monitor': False,
'starttime': t0,
'scantime': 0,
'retries': 0,
'pyudevwarning': False
}
devices = {}
read_last_working_devices()
if enumstate['monitor']:
# only scan devices if they change
ret = enumstate['monitor'].poll(0)
if ret:
enumstate['scantime'] = t0
enumstate['retries'] = 5 # up to 5 retries
while ret:
debug('serialprobe pyudev monitor', ret)
ret = enumstate['monitor'].poll(0) # flush events
if enumstate['retries'] == 0 or t0 < enumstate['scantime']:
return False
else:
# delay monitor slightly to ensure startup speed
if t0 > enumstate['starttime'] + 5:
# try to start pyudev
import signal
# need to temporary disable sigchld while loading pyudev
cursigchld_handler = signal.getsignal(signal.SIGCHLD)
signal.signal(signal.SIGCHLD, signal.SIG_IGN)
try:
import pyudev
context = pyudev.Context()
enumstate['monitor'] = pyudev.Monitor.from_netlink(context)
enumstate['monitor'].filter_by(subsystem='usb')
except Exception as e:
# try pyudev/scanning again in 10 seconds if it is delayed loading
enumstate['starttime'] = time.monotonic() + 10
if not enumstate['pyudevwarning']:
print(_('no pyudev module! will scan usb devices often!'),
e)
enumstate['pyudevwarning'] = True
signal.signal(signal.SIGCHLD, cursigchld_handler)
if t0 < enumstate['scantime']:
return False
enumstate['scantime'] = t0 + 20 # scan every 20 seconds
scanned_devices = scan_devices()
if enumstate['monitor']:
prev_devices = {}
for name in devices:
prev_devices[name] = {'realpath': devices[name]['realpath']}
if prev_devices == scanned_devices: # compare path and realpath
if enumstate['retries'] > 0:
enumstate[
'scantime'] += 2 #try again in 2 seconds until we get a change
enumstate['retries'] -= 1
return False
elif enumstate['monitor']:
debug('serialprobe pyudev found it', devices, scanned_devices)
enumstate['retries'] = 0
debug('serialprobe scan', scanned_devices)
# remove devices not scanned
for device in list(devices):
if not device in scanned_devices:
del devices[device]
# add new devices and set the time the device was added
for device in scanned_devices:
if not device in devices:
devices[device] = scanned_devices[device]
devices[device]['time'] = t0
return True
def __registerUdevCallback(self):
context = pyudev.Context()
monitor = Monitor.from_netlink(context)
monitor.filter_by(subsystem='block')
observer = MonitorObserver(monitor, callback=self.__checkUdevEvent, name='monitor-observer')
observer.start()
def __init__(self, coresys: CoreSys):
"""Initialize Hardware Monitor object."""
self.coresys: CoreSys = coresys
self.context = pyudev.Context()
self.monitor: Optional[pyudev.Monitor] = None
self.observer: Optional[pyudev.MonitorObserver] = None
def idisk_get(self):
"""Enumerate disk topology based on:
:param self
:returns list of disk and attributes
"""
idisk = []
context = pyudev.Context()
for device in context.list_devices(DEVTYPE='disk'):
if not utils.is_system_usable_block_device(device):
continue
if device['MAJOR'] in constants.VALID_MAJOR_LIST:
if 'ID_PATH' in device:
device_path = "/dev/disk/by-path/" + device['ID_PATH']
LOG.debug("[DiskEnum] device_path: %s ", device_path)
else:
# We should always have a udev supplied /dev/disk/by-path
# value as a matter of normal operation. We do not expect
# this to occur, thus the error.
#
# The kickstart files for the host install require the
# by-path value also to be present or the host install will
# fail. Since the installer and the runtime share the same
# kernel/udev we should not see this message on an installed
# system.
device_path = None
LOG.error(
"Device %s does not have an ID_PATH value provided "
"by udev" % device.device_node)
size_mib = 0
available_mib = 0
model_num = ''
serial_id = ''
# Can merge all try/except in one block but this allows at
# least attributes with no exception to be filled
try:
size_mib = utils.get_disk_capacity_mib(device.device_node)
except Exception as e:
self.handle_exception(
"Could not retrieve disk size - %s " % e)
try:
available_mib = self.get_disk_available_mib(
device_node=device.device_node)
except Exception as e:
self.handle_exception(
"Could not retrieve disk %s free space" % e)
try:
# ID_MODEL received from udev is not correct for disks that
# are used entirely for LVM. LVM replaced the model ID with
# its own identifier that starts with "LVM PV".For this
# reason we will attempt to retrieve the correct model ID
# by using 2 different commands: hdparm and lsblk and
# hdparm. If one of them fails, the other one can attempt
# to retrieve the information. Else we use udev.
# try hdparm command first
hdparm_command = 'hdparm -I %s |grep Model' % (
device.get('DEVNAME'))
hdparm_process = subprocess.Popen(hdparm_command,
stdout=subprocess.PIPE,
shell=True)
hdparm_output = hdparm_process.communicate()[0]
if hdparm_process.returncode == 0:
second_half = hdparm_output.split(':')[1]
model_num = second_half.strip()
else:
# try lsblk command
lsblk_command = 'lsblk -dn --output MODEL %s' % (
device.get('DEVNAME'))
lsblk_process = subprocess.Popen(
lsblk_command, stdout=subprocess.PIPE, shell=True)
lsblk_output = lsblk_process.communicate()[0]
if lsblk_process.returncode == 0:
model_num = lsblk_output.strip()
else:
# both hdparm and lsblk commands failed, try udev
model_num = device.get('ID_MODEL')
if not model_num:
model_num = constants.DEVICE_MODEL_UNKNOWN
except Exception as e:
self.handle_exception("Could not retrieve disk model "
"for disk %s. Exception: %s" %
(device.get('DEVNAME'), e))
try:
if 'ID_SCSI_SERIAL' in device:
serial_id = device['ID_SCSI_SERIAL']
else:
serial_id = device['ID_SERIAL_SHORT']
except Exception as e:
self.handle_exception("Could not retrieve disk "
"serial ID - %s " % e)
capabilities = dict()
if model_num:
capabilities.update({'model_num': model_num})
if self.get_rootfs_node() == device.device_node:
capabilities.update({'stor_function': 'rootfs'})
rotational = self.is_rotational(device)
device_type = device.device_type
rotation_rate = constants.DEVICE_TYPE_UNDETERMINED
if rotational == '1':
device_type = constants.DEVICE_TYPE_HDD
if 'ID_ATA_ROTATION_RATE_RPM' in device:
rotation_rate = device['ID_ATA_ROTATION_RATE_RPM']
elif rotational == '0':
if constants.DEVICE_NAME_NVME in device.device_node:
device_type = constants.DEVICE_TYPE_NVME
else:
device_type = constants.DEVICE_TYPE_SSD
rotation_rate = constants.DEVICE_TYPE_NA
# TODO else: what is the other possible stor_function value?
# or do we just use pair { 'is_rootfs': True } instead?
# Obtain device ID and WWN.
device_id, device_wwn = self.get_device_id_wwn(device)
attr = {
'device_node': device.device_node,
'device_num': device.device_number,
'device_type': device_type,
'device_path': device_path,
'device_id': device_id,
'device_wwn': device_wwn,
'size_mib': size_mib,
'available_mib': available_mib,
'serial_id': serial_id,
'capabilities': capabilities,
'rpm': rotation_rate,
}
idisk.append(attr)
LOG.debug("idisk= %s" % idisk)
return idisk
def run(self):
context = pyudev.Context()
#Check the status of the system right now
# 1. Check if we have any drives connected
for d in context.list_devices(subsystem='block', DEVTYPE='disk'):
if d.attributes.asbool('removable'):
#it's removable media, let's find the partitions
partitions = list(
context.list_devices(subsystem='block',
DEVTYPE='partition',
parent=d))
for p in partitions:
# we only analyze the first one, ignore other partitions
#p = partitions[0]
#check if the partition is mounted
mountPoint = self._findMountPoint(p.device_node)
if mountPoint:
self._logger.info(
'Found mounted removable drive (%s) at %s' %
(p.device_node, mountPoint))
else:
self._logger.info(
'Mounting inserted removable drive (%s)' %
p.device_node)
self._mountPartition(p.device_node,
self._getDeviceMountDirectory(p))
# 2. Check if there are left over directories with no drives mounted
for f in glob('%s/*/*' % ROOT_MOUNT_POINT):
if os.path.isdir(f) and not os.listdir(f):
#empty directory found, let's see if it's mounted
if not self._isMounted(f):
#Not mounted and empty, delete directory.
os.rmdir(f) #main dir
os.rmdir('/'.join(f.split('/')[:-1])) #uuid dir
self._mountPoints = None # We reset here since we don't need it anymore, it will be re-created on shutdown
# Start listening for events
self.monitor = pyudev.Monitor.from_netlink(context)
self.monitor.filter_by(subsystem='block')
for device in iter(self.monitor.poll, None):
if self.stopThread:
self.monitor.stop()
return
if device.device_type == 'partition':
if device.action == 'add':
devName = device.device_node
self._logger.info('%s pluged in' % devName)
mountPath = self._getDeviceMountDirectory(device)
if self._mountPartition(devName, mountPath):
self._eventManager.fire(Events.EXTERNAL_DRIVE_MOUNTED,
{
"mount_path": mountPath,
"device_node": devName
})
if device.action == 'remove':
devName = device.device_node
mountPath = self._getDeviceMountDirectory(device)
self._logger.info('%s removed' % devName)
if self._umountPartition(
self._getDeviceMountDirectory(device)):
self._eventManager.fire(
Events.EXTERNAL_DRIVE_PHISICALLY_REMOVED, {
"device_node": devName,
"mount_path": mountPath,
})
License for the specific language governing permissions and limitations
under the License.
'''
import os
import re
import six
import socket
import stat
import subprocess
import uuid
from contextlib import contextmanager
import pyudev
_CONTEXT = pyudev.Context()
class RTSLibError(Exception):
'''
Generic rtslib error.
'''
pass
class RTSLibALUANotSupported(RTSLibError):
'''
Backend does not support ALUA.
'''
pass
class RTSLibBrokenLink(RTSLibError):
'''
def vendorShort(self):
lv = len(self._vendor)
lvdb = len(self._vendordb)
vendor = self._vendor
if (lvdb > 0) and (lvdb < lv) and (lv > 8):
vendor = self._vendordb
return vendor
def modelShort(self):
return self._modelenc
devices = dict()
udev = pyudev.Context()
############################################################
# gather devoces
############################################################
for d in udev.list_devices(subsystem="usb"):
#print(dict(d))
DEVTYPE = d.get("DEVTYPE")
if DEVTYPE == "usb_device": # leaf devices
busnum = d.attributes.get("busnum")
devnum = d.attributes.get("devnum")
devpath = d.attributes.get("devpath")
pos = "%03d:%03d" % (int(busnum), int(devnum))
#print(d.sys_name,busnum,devnum,devpath )
devi = devinfo(pos, pos)
def find_video_device(self):
"""
Attempts to automatically detect which video device corresponds to the PureThermal Lepton by searching for the PID and VID.
Returns
-------
int
device number
"""
res = None
if sys.platform.startswith('win32'):
device_check_path = pkg_resources.resource_filename(
'flirpy', 'bin/find_cameras.exe')
device_id = int(
subprocess.check_output([device_check_path,
"PureThermal"]).decode())
if device_id >= 0:
return device_id
elif sys.platform == "darwin":
output = subprocess.check_output(
["system_profiler", "SPCameraDataType"]).decode()
devices = [
line.strip() for line in output.decode().split("\n")
if line.strip().startswith("Model")
]
device_id = 0
for device in devices:
if device.contains("VendorID_1E4E") and device.contains(
"ProductID_0100"):
return device_id
else:
import pyudev
context = pyudev.Context()
devices = pyudev.Enumerator(context)
path = "/sys/class/video4linux/"
video_devices = [
os.path.join(path, device) for device in os.listdir(path)
]
dev = []
for device in video_devices:
udev = pyudev.Devices.from_path(context, device)
try:
vid = udev.properties['ID_VENDOR_ID']
pid = udev.properties['ID_MODEL_ID']
if vid.lower() == "1e4e" and pid.lower() == "0100":
dev.append(int(device.split('video')[-1]))
except KeyError:
pass
# For some reason multiple devices can show up
if len(dev) > 1:
for d in dev:
cam = cv2.VideoCapture(d + cv2.CAP_V4L2)
data = cam.read()
cam.release()
if data[0] == True and data[1] is not None:
res = d
break
elif len(dev) == 1:
res = dev[0]
return res
def __init__(self):
super(USBDetector, self).__init__()
self.mouse_online = False
self.context = pyudev.Context()
self.monitor = pyudev.Monitor.from_netlink(self.context)
self.monitor.filter_by(subsystem="usb")
import pyudev
import evdev
import functools
import re
context = pyudev.Context()
monitor = pyudev.Monitor.from_netlink(context)
monitor.filter_by(subsystem='input')
monitor.start()
def kbdIden():
target_device_data = [] #list to store recieved data about device
for device in iter(functools.partial(monitor.poll, 0), None):
#print ('{0.action} on {0.device_path}'.format(device))
target_device_data.append(device.device_path) #data collection
try:
if device.action == "add":
for dev in target_device_data:
splitted = dev.split('/')
target = splitted[-1]
if re.match('event[0-9+]',
target): #check of event.. param.
added_dev = str(
evdev.InputDevice(
'/dev/input/{0}'.format(target))).split(
'/') #data collection about target device
#print (added_dev)
#re_addded_dev = re.findall('.*name ".* Keyboard".*', added_dev[3])
def execute(self):
# Default values.
address = ""
netmask = ""
gateway = ""
method = "dhcp"
address6 = ""
method6 = "manual"
netmask6 = 64
gateway6 = ""
wol = False
dns_nameservers = ""
wpa_ssid = None
wpa_psk = None
rpc_method = "setEthernetIface"
rpc_params = {}
# Get the network interface device.
devices = []
context = pyudev.Context()
for device in context.list_devices(subsystem="net"):
# Skip unwanted network interface devices.
if device.sys_name in ("lo"):
continue
if device.device_type and device.device_type in ("bond"):
continue
# Append the network interface name for later use.
devices.append(device.sys_name)
devices = natsort.humansorted(devices)
choices = []
for idx, sys_name in enumerate(devices):
device = pyudev.Device.from_name(context, "net", sys_name)
for id in ["ID_MODEL_FROM_DATABASE", "ID_VENDOR_FROM_DATABASE"]:
if not id in device:
continue
choices.append([
sys_name,
openmediavault.string.truncate(device[id], 50)
])
break
d = dialog.Dialog(dialog="dialog")
(code, tag) = d.menu("Please select a network interface. Note, the " \
"existing network interface configuration will be deleted.",
backtitle=self.description, clear=True,
height=14, width=70, menu_height=6, choices=choices)
if code in (d.CANCEL, d.ESC):
return 0
device_name = tag
# Use DHCP?
code = d.yesno(
"Do you want to use DHCPv4 for this interface?",
backtitle=self.description,
height=5,
width=49
)
if code == d.ESC:
return 0
if code != d.OK:
address = None
netmask = None
gateway = None
method = "static"
# Get the static IPv4 address.
while not address:
(code, address) = d.inputbox(
"Please enter the IPv4 address.",
backtitle=self.description,
clear=True,
height=8,
width=60,
init=""
)
if code != d.OK:
return 0
if not address:
d.msgbox(
"The field must not be empty.",
backtitle=self.description,
height=5,
width=32
)
continue
try:
ipaddress.ip_address(address)
except Exception as e:
address = None
d.msgbox(
"Please enter a valid IPv4 address.",
backtitle=self.description,
height=5,
width=38
)
continue
# Get the IPv4 netmask.
while not netmask:
(code, netmask) = d.inputbox(
"Please enter the IPv4 netmask.",
backtitle=self.description,
clear=True,
height=8,
width=60,
init=""
)
if code != d.OK:
return 0
if not netmask:
d.msgbox(
"The field must not be empty.",
backtitle=self.description,
height=5,
width=32
)
continue
try:
ipaddress.ip_address(netmask)
except Exception:
netmask = None
d.msgbox(
"Please enter a valid netmask.",
backtitle=self.description,
height=5,
width=33
)
continue
# Get default IPv4 gateway.
while not gateway:
(code, gateway) = d.inputbox(
"Please enter the default IPv4 gateway.",
backtitle=self.description,
clear=True,
height=8,
width=60,
init=""
)
if code != d.OK:
return 0
try:
ipaddress.ip_address(gateway)
except Exception:
gateway = None
d.msgbox(
"Please enter a valid gateway.",
backtitle=self.description,
height=5,
width=33
)
continue
# Use IPv6?
code = d.yesno(
"Do you want to configure IPv6 for this interface?",
backtitle=self.description,
height=5,
width=53,
defaultno=True
)
if code == d.ESC:
return 0
if code == d.OK:
# Use stateful address autoconfiguration (DHCPv6)?
code = d.yesno("Do you want to enable stateful address " \
"autoconfiguration (DHCPv6)?",
backtitle=self.description,
height=6, width=42)
if code == d.ESC:
return 0
if code == d.OK:
method6 = "dhcp"
else:
# Use stateless address autoconfiguration (SLAAC)?
code = d.yesno("Do you want to enable stateless address " \
"autoconfiguration (SLAAC)?",
backtitle=self.description,
height=6, width=42)
if code == d.ESC:
return 0
if code == d.OK:
method6 = "auto"
else:
method6 = "static"
# Get static IPv6 address.
address6 = None
while not address6:
(code, address6) = d.inputbox(
"Please enter the IPv6 address.",
backtitle=self.description,
clear=True,
height=8,
width=60,
init=""
)
if code != d.OK:
return 0
if not address6:
d.msgbox(
"The field must not be empty.",
backtitle=self.description,
height=5,
width=32
)
continue
try:
ipaddress.ip_address(address6)
except Exception:
address6 = None
d.msgbox(
"Please enter a valid IPv6 address.",
backtitle=self.description,
height=5,
width=38
)
continue
# Get the prefix length.
netmask6 = None
while not netmask6:
(code, netmask6) = d.inputbox(
"Please enter the IPv6 prefix length.",
backtitle=self.description,
clear=True,
height=8,
width=64,
init="64"
)
if code != d.OK:
return 0
if not netmask6:
d.msgbox(
"The field must not be empty.",
backtitle=self.description,
height=5,
width=32
)
continue
if int(netmask6) < 0 or int(netmask6) > 128:
netmask6 = None
d.msgbox(
"Please enter a valid netmask.",
backtitle=self.description,
height=5,
width=33
)
continue
# Get default IPv6 gateway.
gateway6 = None
while not gateway6:
(code, gateway6) = d.inputbox(
"Please enter the default IPv6 gateway.",
backtitle=self.description,
clear=True,
height=8,
width=60,
init=""
)
if code != d.OK:
return 0
try:
ipaddress.ip_address(gateway6)
except Exception:
gateway6 = None
d.msgbox(
"Please enter a valid gateway.",
backtitle=self.description,
height=5,
width=33
)
continue
# Get the DNS name servers. Note, only one IP address is
# supported here.
if method == "static" or method6 == "static":
while True:
(code, dns_nameservers) = d.inputbox(
"Please enter the DNS name server. If you don't want " \
"to use any name server, just leave this field blank.",
backtitle=self.description,
clear=True, height=8, width=60, init="")
if code != d.OK:
return 0
if not dns_nameservers:
break
try:
ipaddress.ip_address(dns_nameservers)
break
except Exception:
dns_nameservers = ""
d.msgbox(
"Please enter a valid IP address.",
backtitle=self.description,
height=5,
width=30
)
# Enable WOL?
code = d.yesno(
"Do you want to enable WOL for this interface?",
backtitle=self.description,
height=5,
width=50,
defaultno=True
)
if code == d.ESC:
return 0
if code == d.OK:
wol = True
# Set the default RPC parameters.
rpc_params.update({
"uuid": openmediavault.getenv("OMV_CONFIGOBJECT_NEW_UUID"),
"devicename": device_name,
"method": method,
"address": address,
"netmask": netmask,
"gateway": gateway,
"method6": method6,
"address6": address6,
"netmask6": netmask6,
"gateway6": gateway6,
"dnsnameservers": dns_nameservers,
"dnssearch": "",
"mtu": 0,
"wol": wol,
"comment": "",
})
# Do we process a wireless network interface?
if re.match(r"^wlan[0-9]+$", device_name):
rpc_method = "setWirelessIface"
# Get the SSID.
while not wpa_ssid:
(code, wpa_ssid) = d.inputbox(
"Please enter the name of the wireless network (SSID).",
backtitle=self.description,
clear=True,
height=8,
width=60,
init=""
)
if code != d.OK:
return 0
if not wpa_ssid:
d.msgbox(
"The field must not be empty.",
backtitle=self.description,
height=5,
width=32
)
rpc_params["wpassid"] = wpa_ssid
# Get the pre-shared key.
while not wpa_psk:
(code, wpa_psk) = d.inputbox(
"Please enter the pre-shared key (PSK).",
backtitle=self.description,
clear=True,
height=8,
width=45,
init=""
)
if code != d.OK:
return 0
if not wpa_psk:
d.msgbox(
"The field must not be empty.",
backtitle=self.description,
height=5,
width=32
)
rpc_params["wpapsk"] = wpa_psk
# Update the interface configuration.
print("Configuring network interface. Please wait ...")
# Delete all existing network interface configuration objects.
interfaces = openmediavault.rpc.call(
"Network", "enumerateConfiguredDevices"
)
for interface in interfaces:
openmediavault.rpc.call(
"Network", "deleteInterface", {"uuid": interface["uuid"]}
)
# Insert a new network interface configuration object.
openmediavault.rpc.call("Network", rpc_method, rpc_params)
openmediavault.rpc.call(
"Config", "applyChanges", {
"modules": [],
"force": False
}
)
print("The network interface configuration was successfully changed.")
return 0
def usb_keyboard_present():
context = pyudev.Context()
keyboards = context.list_devices(subsystem='input', ID_INPUT_KEYBOARD='1')
return any([d.get('ID_USB_INTERFACES', False) for d in keyboards])
def details_udev(usb_disk_part):
"""
Get details of USB partition using udev
"""
assert usb_disk_part is not None
assert platform.system() == "Linux"
try:
import pyudev
except:
from . import pyudev
# Try with PyUdev to get the details of USB disks.
# This is the easiest and reliable method to find USB details.
# Also, it is a standalone package and no dependencies are required.
context = pyudev.Context()
try:
device = pyudev.Device.from_device_file(context, usb_disk_part)
except:
gen.log("ERROR: Unknown disk/partition (%s)" % str(usb_disk_part))
return None
fdisk_cmd_out = subprocess.check_output('fdisk -l ' + usb_disk_part,
shell=True)
if b'Extended' in fdisk_cmd_out:
mount_point = ''
uuid = ''
file_system = ''
vendor = ''
model = ''
label = ''
devtype = "extended partition"
elif device.get('DEVTYPE') == "partition":
uuid = device.get('ID_FS_UUID') or ""
file_system = device.get('ID_FS_TYPE') or ""
label = device.get('ID_FS_LABEL') or ""
mount_point = u.mount(usb_disk_part) or ""
mount_point = mount_point.replace('\\x20', ' ')
vendor = device.get('ID_VENDOR') or ""
model = device.get('ID_MODEL') or ""
devtype = "partition"
elif device.get('DEVTYPE') == "disk":
mount_point = ""
uuid = ""
file_system = ""
label = device.get('ID_FS_LABEL') or ""
vendor = device.get('ID_VENDOR') or ""
model = device.get('ID_MODEL') or ""
devtype = "disk"
if mount_point not in ["", "None"]:
size_total = shutil.disk_usage(mount_point)[0]
size_used = shutil.disk_usage(mount_point)[1]
size_free = shutil.disk_usage(mount_point)[2]
else:
fdisk_cmd = 'fdisk -l ' + usb_disk_part + ' | grep "^Disk /" | sed -re "s/.*\s([0-9]+)\sbytes.*/\\1/"'
size_total = subprocess.check_output(fdisk_cmd, shell=True).strip()
size_used = ""
size_free = ""
mount_point = ""
return {
'uuid': uuid,
'file_system': file_system,
'label': label,
'mount_point': mount_point,
'size_total': size_total,
'size_used': size_used,
'size_free': size_free,
'vendor': vendor,
'model': model,
'devtype': devtype
}
def __init__(self, results={}):
self.results = results
self.context = pyudev.Context()
def test_export_firmware_extended_fedora29(C):
"""
Check, whether the firmware file is exported correctly, and in correct size.
Apparently, the auto-remounting side effect of the v0.46 change, is disturbing the export process.
Unmounting the UV just before the export gives the device 20/20 success rate.
Test case for issue https://github.com/Nitrokey/nitrokey-app/issues/399
"""
skip_if_device_version_lower_than({'S': 43})
skip_if_not_fedora('Tested on Fedora only. To check on other distros.')
from time import sleep
import os
from os.path import exists as exist
import re
try:
import pyudev as pu
import pexpect
except:
pytest.skip(
'Skipping due to missing required packages: pyudev and pexpect.')
ctx = pu.Context()
devices = ctx.list_devices(subsystem='block', ID_VENDOR='Nitrokey')
device = None
for d in devices:
if d.device_type == 'partition':
device = '/dev/{}'.format(d.sys_name)
break
assert device, 'Device could not be found'
pexpect.run(f'udisksctl unmount -b {device}').decode()
sleep(1)
_res = pexpect.run(f'udisksctl mount -b {device}').decode()
firmware_abs_path = re.findall('at (/.*)\.', _res)
assert firmware_abs_path, 'Cannot get mount point'
firmware_abs_path = firmware_abs_path[0]
print('path: {}, device: {}'.format(firmware_abs_path, device))
assert firmware_abs_path, 'Cannot get mount point'
firmware_abs_path = firmware_abs_path + '/firmware.bin'
checks = 0
checks_add = 0
if exist(firmware_abs_path):
os.remove(firmware_abs_path)
assert not exist(firmware_abs_path)
ATTEMPTS = 20
for i in range(ATTEMPTS):
# if umount is disabled, success rate is 3/10, enabled: 10/10
pexpect.run(f'udisksctl unmount -b {device}')
assert C.NK_export_firmware(
DefaultPasswords.ADMIN) == DeviceErrorCode.STATUS_OK
pexpect.run(f'udisksctl mount -b {device}')
sleep(1)
firmware_file_exist = exist(firmware_abs_path)
if firmware_file_exist:
checks += 1
getsize = os.path.getsize(firmware_abs_path)
print('Firmware file exist, size: {}'.format(getsize))
checks_add += 1 if getsize >= 100 * 1024 else 0
# checks_add += 1 if os.path.getsize(firmware_abs_path) == 256*1024 else 0
os.remove(firmware_abs_path)
assert not exist(firmware_abs_path)
print('CHECK {} ; CHECK ADDITIONAL {}'.format(checks, checks_add))
assert checks == ATTEMPTS
assert checks_add == checks
