libudev-device.c revision 438d4c3cd4b89381348f84ef9f8b8937814f8362
/*
* libudev - interface to udev device information
*
* Copyright (C) 2008 Kay Sievers <kay.sievers@vrfy.org>
*
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <dirent.h>
#include <fcntl.h>
#include "libudev.h"
#include "libudev-private.h"
struct udev_device {
int refcount;
struct udev_device *parent_device;
char *syspath;
const char *devpath;
const char *sysname;
char *devnode;
char *subsystem;
struct list_node devlink_list;
struct list_node properties_list;
char *action;
int event_timeout;
char *driver;
char *devpath_old;
char *physdevpath;
int timeout;
unsigned long long int seqnum;
int num_fake_partitions;
int devlink_priority;
int ignore_remove;
int info_loaded;
};
{
/* translate to location of db file */
}
{
char filename[UTIL_PATH_SIZE];
char line[UTIL_LINE_SIZE];
FILE *f;
return -1;
}
char target[UTIL_PATH_SIZE];
int target_len;
if (target_len > 0)
else {
return -1;
}
return -ENOMEM;
info(udev_device->udev, "device %p filled with db symlink data '%s'\n", udev_device, udev_device->devnode);
return 0;
}
if (f == NULL) {
return -1;
}
const char *val;
if (len < 4)
break;
switch(line[0]) {
case 'N':
break;
case 'S':
break;
case 'L':
break;
case 'T':
break;
case 'A':
break;
case 'R':
break;
case 'E':
break;
}
}
fclose(f);
return 0;
}
{
char filename[UTIL_PATH_SIZE];
FILE *f;
char line[UTIL_LINE_SIZE];
int maj = 0;
int min = 0;
if (f == NULL)
return -1;
char *pos;
continue;
pos[0] = '\0';
}
fclose(f);
return 0;
}
{
}
{
}
{
struct udev_device *udev_device;
return NULL;
if (udev_device == NULL)
return NULL;
return udev_device;
}
/**
* udev_device_new_from_syspath:
* @udev: udev library context
* @syspath: sys device path including sys directory
*
* Create new udev device, and fill in information from the sys
* device and the udev database entry. The sypath is the absolute
* path to the device, including the sys mount point.
*
* The initial refcount is 1, and needs to be decremented to
* release the ressources of the udev device.
*
* Returns: a new udev device, or #NULL, if it does not exist
**/
{
const char *subdir;
const char *pos;
char path[UTIL_PATH_SIZE];
struct udev_device *udev_device;
return NULL;
return NULL;
/* path starts in sys */
return NULL;
}
/* path is not a root directory */
return NULL;
}
/* resolve possible symlink to real path */
/* path exists in sys */
char file[UTIL_PATH_SIZE];
/* all "devices" require a "uevent" file */
return NULL;
}
} else {
/* everything else just needs to be a directory */
return NULL;
}
}
if (udev_device == NULL)
return NULL;
return udev_device;
}
{
char path[UTIL_PATH_SIZE];
const char *type_str;
struct udev_enumerate *udev_enumerate;
struct udev_list_entry *list_entry;
if (type == 'b')
type_str = "block";
else if (type == 'c')
type_str = "char";
else
return NULL;
if (udev_enumerate == NULL)
return NULL;
if (type == 'b')
else if (type == 'c')
struct udev_device *device_loop;
if (device_loop != NULL) {
const char *subsystem;
continue;
continue;
break;
}
}
}
return device;
}
{
char path[UTIL_PATH_SIZE];
const char *subdir;
/* follow "device" link in deprecated sys layout */
return udev_device_parent;
}
while (1) {
char *pos;
break;
pos[0] = '\0';
if (udev_device_parent != NULL)
return udev_device_parent;
}
return NULL;
}
{
if (udev_device == NULL)
return NULL;
return udev_device->parent_device;
}
return udev_device->parent_device;
}
/**
* udev_device_get_udev:
* @udev_device: udev device
*
* Retrieve the udev library context the device was created with.
*
* Returns: the udev library context
**/
{
if (udev_device == NULL)
return NULL;
return udev_device->udev;
}
/**
* udev_device_ref:
* @udev_device: udev device
*
* Take a reference of a udev device.
*
* Returns: the passed udev device
**/
{
if (udev_device == NULL)
return NULL;
udev_device->refcount++;
return udev_device;
}
/**
* udev_device_unref:
* @udev_device: udev device
*
* Drop a reference of a udev device. If the refcount reaches zero,
* the ressources of the device will be released.
*
**/
{
if (udev_device == NULL)
return;
udev_device->refcount--;
if (udev_device->refcount > 0)
return;
}
/**
* udev_device_get_devpath:
* @udev_device: udev device
*
* Retrieve the kernel devpath value of the udev device. The path
* does not contain the sys mount point, and starts with a '/'.
*
* Returns: the devpath of the udev device
**/
{
if (udev_device == NULL)
return NULL;
return udev_device->devpath;
}
/**
* udev_device_get_syspath:
* @udev_device: udev device
*
* Retrieve the sys path of the udev device. The path is an
* absolute path and starts with the sys mount point.
*
* Returns: the sys path of the udev device
**/
{
if (udev_device == NULL)
return NULL;
return udev_device->syspath;
}
{
if (udev_device == NULL)
return NULL;
return udev_device->sysname;
}
/**
* udev_device_get_devnode:
* @udev_device: udev device
*
* Retrieve the device node file name belonging to the udev device.
* The path is an absolute path, and starts with the device directory.
*
* Returns: the device node file name of the udev device, or #NULL if no device node exists
**/
{
if (udev_device == NULL)
return NULL;
if (!udev_device->info_loaded)
return udev_device->devnode;
}
/**
* udev_device_get_subsystem:
* @udev_device: udev device
*
* Retrieve the subsystem string of the udev device. The string does not
* contain any "/".
*
* Returns: the subsystem name of the udev device, or #NULL if it can not be determined
**/
{
char subsystem[UTIL_NAME_SIZE];
if (udev_device == NULL)
return NULL;
return udev_device->subsystem;
/* read "subsytem" link */
if (util_get_sys_subsystem(udev_device->udev, udev_device->syspath, subsystem, sizeof(subsystem)) > 0) {
return udev_device->subsystem;
}
/* implicit names */
return udev_device->subsystem;
}
return udev_device->subsystem;
}
return udev_device->subsystem;
}
return NULL;
}
/**
* udev_device_get_devlinks_list_entry:
* @udev_device: udev device
*
* Retrieve the list of device links pointing to the device file of
* the udev device. The next list entry can be retrieved with
* udev_list_entry_next(), which returns #NULL if no more entries exist.
* The devlink path can be retrieved from the list entry by
* udev_list_entry_get_name(). The path is an absolute path, and starts with
* the device directory.
*
* Returns: the first entry of the device node link list
**/
{
if (udev_device == NULL)
return NULL;
if (!udev_device->info_loaded)
}
/**
* udev_device_get_properties_list_entry:
* @udev_device: udev device
*
* device. The next list entry can be retrieved with udev_list_entry_next(),
* which returns #NULL if no more entries exist. The property name
* can be retrieved from the list entry by udev_list_get_name(),
* the property value by udev_list_get_value().
*
* Returns: the first entry of the property list
**/
{
if (udev_device == NULL)
return NULL;
if (!udev_device->info_loaded)
}
{
char driver[UTIL_NAME_SIZE];
if (udev_device == NULL)
return NULL;
return udev_device->driver;
return NULL;
return udev_device->driver;
}
{
if (udev_device == NULL)
return makedev(0, 0);
if (!udev_device->info_loaded)
return udev_device->devnum;
}
{
if (udev_device == NULL)
return NULL;
return udev_device->action;
}
{
if (udev_device == NULL)
return 0;
return udev_device->seqnum;
}
{
struct udev_list_entry *list_entry;
char path[UTIL_PATH_SIZE];
char value[UTIL_NAME_SIZE];
int fd;
/* look for possibly already cached result */
return udev_list_entry_get_value(list_entry);
}
}
goto out;
}
/* links return the last element of the target path */
char target[UTIL_NAME_SIZE];
int len;
char *pos;
if (len > 0) {
}
}
goto out;
}
/* skip directories */
goto out;
/* skip non-readable files */
goto out;
/* read attribute value */
if (fd < 0) {
goto out;
}
if (size < 0)
goto out;
goto out;
/* got a valid value, store it in cache and return it */
out:
return val;
}
{
const char *pos;
return -ENOMEM;
return -EINVAL;
return 0;
}
{
return -1;
return 0;
}
{
return -ENOMEM;
return 0;
}
{
return -ENOMEM;
return 0;
}
{
return -ENOMEM;
return 0;
}
{
char name[UTIL_PATH_SIZE];
char *val;
return -1;
val[0] = '\0';
if (val[0] == '\0')
return 0;
}
{
return -ENOMEM;
return 0;
}
{
return -ENOMEM;
return 0;
}
{
return udev_device->devpath_old;
}
{
return -ENOMEM;
return 0;
}
{
return udev_device->physdevpath;
}
{
return -ENOMEM;
return 0;
}
{
return udev_device->timeout;
}
{
return 0;
}
{
if (!udev_device->info_loaded)
return udev_device->event_timeout;
}
{
return 0;
}
{
return 0;
}
{
return 0;
}
{
if (!udev_device->info_loaded)
return udev_device->num_fake_partitions;
}
{
return 0;
}
{
if (!udev_device->info_loaded)
return udev_device->devlink_priority;
}
{
return 0;
}
{
if (!udev_device->info_loaded)
return udev_device->ignore_remove;
}
{
return 0;
}