Current File : //usr/lib/python2.7/site-packages/pyudev/_libudev.py
# -*- coding: utf-8 -*-
# Copyright (C) 2010, 2011, 2012 Sebastian Wiesner <lunaryorn@googlemail.com>
# This library is free software; you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation; either version 2.1 of the License, or (at your
# option) any later version.
# This library is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
# for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this library; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
_libudev
========
Wrapper types for libudev. Use ``libudev`` attribute to access libudev
functions.
.. moduleauthor:: Sebastian Wiesner <lunaryorn@googlemail.com>
"""
from __future__ import (print_function, division, unicode_literals,
absolute_import)
import os
import errno
from ctypes import (CDLL, Structure, POINTER, get_errno,
c_char, c_char_p, c_int, c_ulonglong)
from ctypes.util import find_library
class udev(Structure):
"""
Dummy for ``udev`` structure.
"""
pass
udev_p = POINTER(udev)
class udev_enumerate(Structure):
"""
Dummy for ``udev_enumerate`` structure.
"""
udev_enumerate_p = POINTER(udev_enumerate)
class udev_list_entry(Structure):
"""
Dummy for ``udev_list_entry`` structure.
"""
udev_list_entry_p = POINTER(udev_list_entry)
class udev_device(Structure):
"""
Dummy for ``udev_device`` structure.
"""
udev_device_p = POINTER(udev_device)
class udev_monitor(Structure):
"""
Dummy for ``udev_device`` structure.
"""
udev_monitor_p = POINTER(udev_monitor)
dev_t = c_ulonglong
SIGNATURES = {
# context
'udev': dict(
new=(None, udev_p),
unref=([udev_p], None),
ref=([udev_p], udev_p),
get_sys_path=([udev_p], c_char_p),
get_dev_path=([udev_p], c_char_p),
get_run_path=([udev_p], c_char_p),
get_log_priority=([udev_p], c_int),
set_log_priority=([udev_p, c_int], None)),
# enumeration
'udev_enumerate': dict(
new=([udev_p], udev_enumerate_p),
ref=([udev_enumerate_p], udev_enumerate_p),
unref=([udev_enumerate_p], None),
add_match_subsystem=([udev_enumerate_p, c_char_p], c_int),
add_nomatch_subsystem=([udev_enumerate_p, c_char_p], c_int),
add_match_property=([udev_enumerate_p, c_char_p, c_char_p], c_int),
add_match_sysattr=([udev_enumerate_p, c_char_p, c_char_p], c_int),
add_nomatch_sysattr=([udev_enumerate_p, c_char_p, c_char_p], c_int),
add_match_tag=([udev_enumerate_p, c_char_p], c_int),
add_match_sysname=([udev_enumerate_p, c_char_p], c_int),
add_match_parent=([udev_enumerate_p, udev_device_p], c_int),
add_match_is_initialized=([udev_enumerate_p], c_int),
scan_devices=([udev_enumerate_p], c_int),
get_list_entry=([udev_enumerate_p], udev_list_entry_p)),
# list entries
'udev_list_entry': dict(
get_next=([udev_list_entry_p], udev_list_entry_p),
get_name=([udev_list_entry_p], c_char_p),
get_value=([udev_list_entry_p], c_char_p)),
# devices
'udev_device': dict(
ref=([udev_device_p], udev_device_p),
unref=([udev_device_p], None),
new_from_syspath=([udev_p, c_char_p], udev_device_p),
new_from_subsystem_sysname=([udev_p, c_char_p, c_char_p],
udev_device_p),
new_from_devnum=([udev_p, c_char, dev_t], udev_device_p),
new_from_environment=([udev_p], udev_device_p),
get_parent=([udev_device_p], udev_device_p),
get_parent_with_subsystem_devtype=([udev_device_p, c_char_p, c_char_p],
udev_device_p),
get_devpath=([udev_device_p], c_char_p),
get_subsystem=([udev_device_p], c_char_p),
get_syspath=([udev_device_p], c_char_p),
get_sysnum=([udev_device_p], c_char_p),
get_sysname=([udev_device_p], c_char_p),
get_driver=([udev_device_p], c_char_p),
get_devtype=([udev_device_p], c_char_p),
get_devnode=([udev_device_p], c_char_p),
get_property_value=([udev_device_p, c_char_p], c_char_p),
get_sysattr_value=([udev_device_p, c_char_p], c_char_p),
get_devnum=([udev_device_p], dev_t),
get_action=([udev_device_p], c_char_p),
get_is_initialized=([udev_device_p], c_int),
get_usec_since_initialized=([udev_device_p], c_ulonglong),
get_devlinks_list_entry=([udev_device_p], udev_list_entry_p),
get_tags_list_entry=([udev_device_p], udev_list_entry_p),
get_properties_list_entry=([udev_device_p], udev_list_entry_p),
get_sysattr_list_entry=([udev_device_p], udev_list_entry_p),
has_tag=([udev_device_p, c_char_p], c_int)),
# monitoring
'udev_monitor': dict(
ref=([udev_monitor_p], udev_monitor_p),
unref=([udev_monitor_p], None),
new_from_netlink=([udev_p, c_char_p], udev_monitor_p),
new_from_socket=([udev_p, c_char_p], udev_monitor_p),
enable_receiving=([udev_monitor_p], c_int),
set_receive_buffer_size=([udev_monitor_p], c_int),
get_fd=([udev_monitor_p], c_int),
receive_device=([udev_monitor_p], udev_device_p),
filter_add_match_subsystem_devtype=(
[udev_monitor_p, c_char_p, c_char_p], c_int),
filter_add_match_tag=([udev_monitor_p, c_char_p], c_int),
filter_update=([udev_monitor_p], c_int),
filter_remove=([udev_monitor_p], c_int))
}
ERRNO_EXCEPTIONS = {
errno.ENOMEM: MemoryError,
errno.EOVERFLOW: OverflowError,
errno.EINVAL: ValueError
}
def exception_from_errno(errno):
"""
Create an exception from ``errno``.
``errno`` is an integral error number.
Return an exception object appropriate to ``errno``.
"""
exception = ERRNO_EXCEPTIONS.get(errno)
if exception is not None:
return exception()
else:
return EnvironmentError(errno, os.strerror(errno))
def check_negative_errorcode(result, func, *args):
"""
Error checker for udev funtions, which return negative error codes.
If ``result`` is smaller than ``0``, it is interpreted as negative error
code, and an appropriate exception is raised:
- ``-ENOMEM`` raises a :exc:`~exceptions.MemoryError`
- ``-EOVERFLOW`` raises a :exc:`~exceptions.OverflowError`
- all other error codes raise :exc:`~exceptions.EnvironmentError`
If result is greater or equal to ``0``, it is returned unchanged.
"""
if result < 0:
# udev returns the *negative* errno code at this point
errno = -result
raise exception_from_errno(errno)
else:
return result
def check_errno(result, func, *args):
"""
Error checker to check the system ``errno`` as returned by
:func:`ctypes.get_errno()`.
If ``result`` is not ``0``, an exception according to this errno is raised.
Otherwise nothing happens.
"""
if result != 0:
errno = get_errno()
if errno != 0:
raise exception_from_errno(errno)
return result
def check_errno_on_null_pointer(result, func, *args):
"""
Error checker to check the system ``errno`` as returned by
:func:`ctypes.get_errno()`.
If ``result`` is a null pointer, an exception according to this errno is
raised. Otherwise nothing happens.
"""
if not result:
errno = get_errno()
if errno != 0:
raise exception_from_errno(errno)
return result
ERROR_CHECKERS = dict(
udev_enumerate_add_match_parent=check_negative_errorcode,
udev_enumerate_add_match_subsystem=check_negative_errorcode,
udev_enumerate_add_nomatch_subsystem=check_negative_errorcode,
udev_enumerate_add_match_property=check_negative_errorcode,
udev_enumerate_add_match_sysattr=check_negative_errorcode,
udev_enumerate_add_nomatch_sysattr=check_negative_errorcode,
udev_enumerate_add_match_tag=check_negative_errorcode,
udev_enumerate_add_match_sysname=check_negative_errorcode,
udev_enumerate_add_match_is_initialized=check_negative_errorcode,
udev_monitor_set_receive_buffer_size=check_errno,
# libudev doc says, enable_receiving returns a negative errno, but tests
# show that this is not reliable, so query the real error code
udev_monitor_enable_receiving=check_errno,
udev_monitor_receive_device=check_errno_on_null_pointer,
udev_monitor_filter_add_match_subsystem_devtype=check_negative_errorcode,
udev_monitor_filter_add_match_tag=check_negative_errorcode,
udev_monitor_filter_update=check_errno,
udev_monitor_filter_remove=check_errno,
)
def load_udev_library():
"""
Load the ``udev`` library and return a :class:`ctypes.CDLL` object for
it. The library has errno handling enabled.
Important functions are given proper signatures and return types to
support type checking and argument conversion.
Raise :exc:`~exceptions.ImportError`, if the udev library was not found.
"""
udev_library_name = find_library('udev')
if not udev_library_name:
raise ImportError('No library named udev')
libudev = CDLL(udev_library_name, use_errno=True)
# context function signature
for namespace, members in SIGNATURES.items():
for funcname in members:
fullname = '{0}_{1}'.format(namespace, funcname)
func = getattr(libudev, fullname, None)
if func:
argtypes, restype = members[funcname]
func.argtypes = argtypes
func.restype = restype
errorchecker = ERROR_CHECKERS.get(fullname)
if errorchecker:
func.errcheck = errorchecker
return libudev
Mini Shell