/* reverse mapping from the device file name to the devpath */
static int name_index(struct udev *udev, const char *devpath, const char *name, int add, int test)
{
char device[UTIL_PATH_SIZE];
char filename[UTIL_PATH_SIZE * 2];
size_t devlen = strlen(udev_get_dev_path(udev))+1;
size_t start;
int fd;
/* directory with device name */
util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
start = util_strlcat(filename, "/.udev/names/", sizeof(filename));
util_strlcat(filename, &name[devlen], sizeof(filename));
util_path_encode(&filename[start], sizeof(filename) - start);
/* entry with the devpath */
util_strlcpy(device, devpath, sizeof(device));
util_path_encode(device, sizeof(device));
util_strlcat(filename, "/", sizeof(filename));
util_strlcat(filename, device, sizeof(filename));
if (add) {
dbg(udev, "creating index: '%s'\n", filename);
util_create_path(udev, filename);
fd = open(filename, O_WRONLY|O_TRUNC|O_CREAT, 0644);
if (fd > 0)
close(fd);
} else {
dbg(udev, "removing index: '%s'\n", filename);
unlink(filename);
util_delete_path(udev, filename);
}
return 0;
}
/**
* Logs a text to the console; it uses a printf-like format
*
* @param[in] fmt printf-like format
* @param[in] ... Additional arguments
*/
void con_printf(char *fmt, ...)
{
char curstr[CON_STR_SZ];
va_list vargs;
va_start(vargs, fmt);
vsnprintf(curstr, sizeof(curstr), fmt, vargs);
va_end(vargs);
if (strcmp(curstr, con_str) == 0)
{
con_str_rep++;
return;
}
if (con_str_rep > 0)
{
char rep_str[CON_STR_SZ];
snprintf(rep_str, sizeof(rep_str), "Last message was repeated %d more time/s.\n", con_str_rep);
con_str_rep = 0;
tb_strput(&con_tb, rep_str);
#ifdef CON_DEBUG
fputs(rep_str, stdout);
#endif
}
util_strlcpy(con_str, curstr, sizeof(con_str));
#ifdef CON_DEBUG
fputs(con_str, stdout);
#endif
tb_strput(&con_tb, con_str);
}
/**
* Copy @p text to the clipboard
*
* @param[in] text Text to copy to the clipboard
*
* @retval true On success
* @retval false If any of the Windows clipboard functions failed
*/
bool clipboard_set_text(char *text)
{
bool retval;
HGLOBAL hdst;
char *dst;
DWORD dst_sz = strlen(text) + sizeof('\0');
/* Allocate and copy the string to the global memory */
hdst = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, dst_sz);
dst = (char *)GlobalLock(hdst);
util_strlcpy(dst, text, dst_sz);
GlobalUnlock(hdst);
/* Set clipboard data */
retval = OpenClipboard(NULL);
if (!retval)
{
con_printf("Error opening clipboard\n");
return false;
}
EmptyClipboard();
retval = SetClipboardData(CF_TEXT, hdst);
if (!retval)
{
con_printf("Error pasting to clipboard\n");
return false;
}
CloseClipboard();
return true;
}
static int name_index_get_devices(struct udev *udev, const char *name, struct udev_list_node *dev_list)
{
char dirname[PATH_MAX];
size_t devlen = strlen(udev_get_dev_path(udev))+1;
size_t start;
DIR *dir;
int count = 0;
util_strlcpy(dirname, udev_get_dev_path(udev), sizeof(dirname));
start = util_strlcat(dirname, "/.udev/names/", sizeof(dirname));
util_strlcat(dirname, &name[devlen], sizeof(dirname));
util_path_encode(&dirname[start], sizeof(dirname) - start);
dir = opendir(dirname);
if (dir == NULL) {
dbg(udev, "no index directory '%s': %m\n", dirname);
count = -1;
goto out;
}
dbg(udev, "found index directory '%s'\n", dirname);
while (1) {
struct dirent *ent;
char device[UTIL_PATH_SIZE];
ent = readdir(dir);
if (ent == NULL || ent->d_name[0] == '\0')
break;
if (ent->d_name[0] == '.')
continue;
util_strlcpy(device, udev_get_sys_path(udev), sizeof(device));
util_strlcat(device, ent->d_name, sizeof(device));
util_path_decode(device);
udev_list_entry_add(udev, dev_list, device, NULL, 1, 0);
count++;
}
closedir(dir);
out:
return count;
}
/**
* Find out the path to the executable of the current process
*
* @param[out] path The path to our executable
* @param[in] pathsz Maximum size of @p path in bytes
*
* @retval true On success
* @retval false On error
*/
bool sys_self_exe(char *path, size_t pathsz)
{
char exepath[MAX_PATH];
DWORD retval;
retval = GetModuleFileName(NULL, exepath, sizeof(exepath));
if (retval == 0)
{
con_printf("GetModuleFileName() failed.\n");
return false;
}
con_printf("Our executable path is %s\n", exepath);
util_strlcpy(path, exepath, pathsz);
return true;
}
struct udev_device *udev_watch_lookup(struct udev *udev, int wd)
{
char filename[UTIL_PATH_SIZE];
char buf[UTIL_PATH_SIZE];
ssize_t syslen;
ssize_t len;
if (inotify_fd < 0 || wd < 0)
return NULL;
snprintf(filename, sizeof(filename), "%s/.udev/watch/%d", udev_get_dev_path(udev), wd);
syslen = util_strlcpy(buf, udev_get_sys_path(udev), sizeof(buf));
len = readlink(filename, &buf[syslen], sizeof(buf)-syslen);
if (len > 0 || len < (ssize_t)(sizeof(buf)-syslen)) {
buf[syslen + len] = '\0';
return udev_device_new_from_syspath(udev, buf);
}
return NULL;
}
/**
* udev_monitor_new_from_socket:
* @udev: udev library context
* @socket_path: unix socket path
*
* Create new udev monitor and connect to a specified socket. The
* path to a socket either points to an existing socket file, or if
* the socket path starts with a '@' character, an abstract namespace
* socket will be used.
*
* A socket file will not be created. If it does not already exist,
* it will fall-back and connect to an abstract namespace socket with
* the given path. The permissions adjustment of a socket file, as
* well as the later cleanup, needs to be done by the caller.
*
* The initial refcount is 1, and needs to be decremented to
* release the resources of the udev monitor.
*
* Returns: a new udev monitor, or #NULL, in case of an error
**/
struct udev_monitor *udev_monitor_new_from_socket(struct udev *udev, const char *socket_path)
{
struct udev_monitor *udev_monitor;
struct stat statbuf;
if (udev == NULL)
return NULL;
if (socket_path == NULL)
return NULL;
udev_monitor = udev_monitor_new(udev);
if (udev_monitor == NULL)
return NULL;
udev_monitor->sun.sun_family = AF_LOCAL;
if (socket_path[0] == '@') {
/* translate leading '@' to abstract namespace */
util_strlcpy(udev_monitor->sun.sun_path, socket_path, sizeof(udev_monitor->sun.sun_path));
udev_monitor->sun.sun_path[0] = '\0';
udev_monitor->addrlen = offsetof(struct sockaddr_un, sun_path) + strlen(socket_path);
} else if (stat(socket_path, &statbuf) == 0 && S_ISSOCK(statbuf.st_mode)) {
/**
* Return the local APPDATA directory for APme.
*
* Create the folder if it does not exist.
*
* @param[out] path Path to the APPDATA directory
* @param[in] pathsz Maximum number of characters that @p path can hold
*
* @retval true On success
* @Retval false On error
*/
bool sys_appdata_path(char *path, size_t pathsz)
{
char appdata_path[MAX_PATH];
char *pstr;
HRESULT hres;
/* Retrieve the APP data path */
hres = SHGetFolderPath(NULL, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, appdata_path);
if (!SUCCEEDED(hres))
{
con_printf("Error retrieving the LOCAL APPDATA path\n");
return false;
}
/* Replace '\' with '/' */
pstr = appdata_path;
while (*pstr != '\0')
{
if (*pstr == '\\') *pstr = '/';
pstr++;
}
util_strlcat(appdata_path, "/APme", sizeof(appdata_path));
con_printf("APPDATA directory: %s\n", appdata_path);
/* Check if the directory exists, otherwise create it */
if (!CreateDirectory(appdata_path, NULL))
{
if (GetLastError() != ERROR_ALREADY_EXISTS)
{
con_printf("Create directory on '%s' failed\n", appdata_path);
return false;
}
}
util_strlcpy(path, appdata_path, pathsz);
return true;
}
/**
* Store the content of the clipboard to @p text
*
* @param[out] text Buffer that will receive the buffer data
* @param[in] text_sz Maximum size of @p text
*
* @retval true On success
* @retval false On error
*/
bool clipboard_get_text(char *text, size_t text_sz)
{
HGLOBAL hsrc;
char *src;
bool status = false;
// Set clipboard data
if (!OpenClipboard(NULL))
{
con_printf("Error opening clipboard\n");
return false;
}
hsrc = GetClipboardData(CF_TEXT);
if (hsrc == NULL)
{
// Nothing to retrieve
goto error;
}
src = GlobalLock(hsrc);
if (src == NULL)
{
con_printf("Error locking clipboard data\n");
goto error;
}
util_strlcpy(text, src, text_sz);
GlobalUnlock(hsrc);
status = true;
error:
CloseClipboard();
return status;
}
static void exec_list(struct udev_enumerate *udev_enumerate, const char *action)
{
struct udev *udev = udev_enumerate_get_udev(udev_enumerate);
struct udev_list_entry *entry;
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(udev_enumerate)) {
char filename[UTIL_PATH_SIZE];
int fd;
if (verbose)
printf("%s\n", udev_list_entry_get_name(entry));
if (dry_run)
continue;
util_strlcpy(filename, udev_list_entry_get_name(entry), sizeof(filename));
util_strlcat(filename, "/uevent", sizeof(filename));
fd = open(filename, O_WRONLY);
if (fd < 0) {
dbg(udev, "error on opening %s: %m\n", filename);
continue;
}
if (write(fd, action, strlen(action)) < 0)
info(udev, "error writing '%s' to '%s': %m\n", action, filename);
close(fd);
}
int udev_node_mknod(struct udev_device *dev, const char *file, dev_t devnum, mode_t mode, uid_t uid, gid_t gid)
{
struct udev *udev = udev_device_get_udev(dev);
char file_tmp[UTIL_PATH_SIZE + sizeof(TMP_FILE_EXT)];
struct stat stats;
int preserve = 0;
int err = 0;
if (major(devnum) == 0)
devnum = udev_device_get_devnum(dev);
if (strcmp(udev_device_get_subsystem(dev), "block") == 0)
mode |= S_IFBLK;
else
mode |= S_IFCHR;
if (file == NULL)
file = udev_device_get_devnode(dev);
if (lstat(file, &stats) == 0) {
if (((stats.st_mode & S_IFMT) == (mode & S_IFMT)) && (stats.st_rdev == devnum)) {
info(udev, "preserve file '%s', because it has correct dev_t\n", file);
preserve = 1;
udev_selinux_lsetfilecon(udev, file, mode);
} else {
info(udev, "atomically replace existing file '%s'\n", file);
util_strlcpy(file_tmp, file, sizeof(file_tmp));
util_strlcat(file_tmp, TMP_FILE_EXT, sizeof(file_tmp));
unlink(file_tmp);
udev_selinux_setfscreatecon(udev, file_tmp, mode);
err = mknod(file_tmp, mode, devnum);
udev_selinux_resetfscreatecon(udev);
if (err != 0) {
err(udev, "mknod(%s, %#o, %u, %u) failed: %m\n",
file_tmp, mode, major(devnum), minor(devnum));
goto exit;
}
err = rename(file_tmp, file);
if (err != 0) {
err(udev, "rename(%s, %s) failed: %m\n", file_tmp, file);
unlink(file_tmp);
}
}
} else {
info(udev, "mknod(%s, %#o, (%u,%u))\n", file, mode, major(devnum), minor(devnum));
udev_selinux_setfscreatecon(udev, file, mode);
err = mknod(file, mode, devnum);
udev_selinux_resetfscreatecon(udev);
if (err != 0) {
err(udev, "mknod(%s, %#o, (%u,%u) failed: %m\n", file, mode, major(devnum), minor(devnum));
goto exit;
}
}
if (!preserve || stats.st_mode != mode) {
info(udev, "chmod(%s, %#o)\n", file, mode);
err = chmod(file, mode);
if (err != 0) {
err(udev, "chmod(%s, %#o) failed: %m\n", file, mode);
goto exit;
}
}
if (!preserve || stats.st_uid != uid || stats.st_gid != gid) {
info(udev, "chown(%s, %u, %u)\n", file, uid, gid);
err = chown(file, uid, gid);
if (err != 0) {
err(udev, "chown(%s, %u, %u) failed: %m\n", file, uid, gid);
goto exit;
}
}
exit:
return err;
}
static int update_link(struct udev_device *dev, const char *slink, int test)
{
struct udev *udev = udev_device_get_udev(dev);
struct udev_list_node dev_list;
struct udev_list_entry *dev_entry;
char target[UTIL_PATH_SIZE];
int count;
int priority = 0;
int rc = 0;
dbg(udev, "update symlink '%s' of '%s'\n", slink, udev_device_get_syspath(dev));
udev_list_init(&dev_list);
count = name_index_get_devices(udev, slink, &dev_list);
if (count > 1)
info(udev, "found %i devices with name '%s'\n", count, slink);
/* if we don't have a reference, delete it */
if (count <= 0) {
info(udev, "no reference left, remove '%s'\n", slink);
if (!test) {
unlink(slink);
util_delete_path(udev, slink);
}
goto out;
}
/* find the device with the highest priority */
target[0] = '\0';
udev_list_entry_foreach(dev_entry, udev_list_get_entry(&dev_list)) {
const char *syspath;
struct udev_device *dev_db;
const char *devnode;
syspath = udev_list_entry_get_name(dev_entry);
dbg(udev, "found '%s' for '%s'\n", syspath, slink);
/* did we find ourself? we win, if we have the same priority */
if (strcmp(udev_device_get_syspath(dev), syspath) == 0) {
dbg(udev, "compare (our own) priority of '%s' %i >= %i\n",
udev_device_get_devpath(dev), udev_device_get_devlink_priority(dev), priority);
if (strcmp(udev_device_get_devnode(dev), slink) == 0) {
info(udev, "'%s' is our device node, database inconsistent, skip link update\n",
udev_device_get_devnode(dev));
} else if (target[0] == '\0' || udev_device_get_devlink_priority(dev) >= priority) {
priority = udev_device_get_devlink_priority(dev);
util_strlcpy(target, udev_device_get_devnode(dev), sizeof(target));
}
continue;
}
/* another device, read priority from database */
dev_db = udev_device_new_from_syspath(udev, syspath);
if (dev_db == NULL)
continue;
devnode = udev_device_get_devnode(dev_db);
if (devnode != NULL) {
if (strcmp(devnode, slink) == 0) {
info(udev, "'%s' is a device node of '%s', skip link update\n",
devnode, syspath);
} else {
dbg(udev, "compare priority of '%s' %i > %i\n",
udev_device_get_devpath(dev_db),
udev_device_get_devlink_priority(dev_db),
priority);
if (target[0] == '\0' || udev_device_get_devlink_priority(dev_db) > priority) {
priority = udev_device_get_devlink_priority(dev_db);
util_strlcpy(target, devnode, sizeof(target));
}
}
}
udev_device_unref(dev_db);
}
udev_list_cleanup_entries(udev, &dev_list);
if (target[0] == '\0') {
info(udev, "no current target for '%s' found\n", slink);
rc = 1;
goto out;
}
/* create symlink to the target with the highest priority */
info(udev, "'%s' with target '%s' has the highest priority %i, create it\n", slink, target, priority);
if (!test) {
util_create_path(udev, slink);
node_symlink(udev, target, slink);
}
out:
return rc;
}
static int node_symlink(struct udev *udev, const char *node, const char *slink)
{
struct stat stats;
char target[UTIL_PATH_SIZE];
char slink_tmp[UTIL_PATH_SIZE + sizeof(TMP_FILE_EXT)];
int i = 0;
int tail = 0;
int len;
int err = 0;
/* use relative link */
target[0] = '\0';
while (node[i] && (node[i] == slink[i])) {
if (node[i] == '/')
tail = i+1;
i++;
}
while (slink[i] != '\0') {
if (slink[i] == '/')
util_strlcat(target, "../", sizeof(target));
i++;
}
util_strlcat(target, &node[tail], sizeof(target));
/* preserve link with correct target, do not replace node of other device */
if (lstat(slink, &stats) == 0) {
if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode)) {
struct stat stats2;
info(udev, "found existing node instead of symlink '%s'\n", slink);
if (lstat(node, &stats2) == 0) {
if ((stats.st_mode & S_IFMT) == (stats2.st_mode & S_IFMT) &&
stats.st_rdev == stats2.st_rdev) {
info(udev, "replace device node '%s' with symlink to our node '%s'\n",
slink, node);
} else {
err(udev, "device node '%s' already exists, "
"link to '%s' will not overwrite it\n",
slink, node);
goto exit;
}
}
} else if (S_ISLNK(stats.st_mode)) {
char buf[UTIL_PATH_SIZE];
dbg(udev, "found existing symlink '%s'\n", slink);
len = readlink(slink, buf, sizeof(buf));
if (len > 0) {
buf[len] = '\0';
if (strcmp(target, buf) == 0) {
info(udev, "preserve already existing symlink '%s' to '%s'\n",
slink, target);
udev_selinux_lsetfilecon(udev, slink, S_IFLNK);
goto exit;
}
}
}
} else {
info(udev, "creating symlink '%s' to '%s'\n", slink, target);
udev_selinux_setfscreatecon(udev, slink, S_IFLNK);
err = symlink(target, slink);
udev_selinux_resetfscreatecon(udev);
if (err == 0)
goto exit;
}
info(udev, "atomically replace '%s'\n", slink);
util_strlcpy(slink_tmp, slink, sizeof(slink_tmp));
util_strlcat(slink_tmp, TMP_FILE_EXT, sizeof(slink_tmp));
unlink(slink_tmp);
udev_selinux_setfscreatecon(udev, slink, S_IFLNK);
err = symlink(target, slink_tmp);
udev_selinux_resetfscreatecon(udev);
if (err != 0) {
err(udev, "symlink(%s, %s) failed: %m\n", target, slink_tmp);
goto exit;
}
err = rename(slink_tmp, slink);
if (err != 0) {
err(udev, "rename(%s, %s) failed: %m\n", slink_tmp, slink);
unlink(slink_tmp);
goto exit;
}
exit:
return err;
}
bool sys_appdata_path(char *path, size_t pathsz)
{
util_strlcpy(path, "./", pathsz);
return true;
}
/* move any old watches directory out of the way, and then restore
* the watches
*/
void udev_watch_restore(struct udev *udev)
{
char filename[UTIL_PATH_SIZE], oldname[UTIL_PATH_SIZE];
if (inotify_fd < 0)
return;
util_strlcpy(oldname, udev_get_dev_path(udev), sizeof(oldname));
util_strlcat(oldname, "/.udev/watch.old", sizeof(oldname));
util_strlcpy(filename, udev_get_dev_path(udev), sizeof(filename));
util_strlcat(filename, "/.udev/watch", sizeof(filename));
if (rename(filename, oldname) == 0) {
DIR *dir;
struct dirent *ent;
dir = opendir(oldname);
if (dir == NULL) {
err(udev, "unable to open old watches dir '%s', old watches will not be restored: %m", oldname);
return;
}
while ((ent = readdir(dir)) != NULL) {
char path[UTIL_PATH_SIZE];
char buf[UTIL_PATH_SIZE];
ssize_t syslen;
ssize_t len;
struct udev_device *dev;
if (ent->d_name[0] < '0' || ent->d_name[0] > '9')
continue;
util_strlcpy(path, oldname, sizeof(path));
util_strlcat(path, "/", sizeof(path));
util_strlcat(path, ent->d_name, sizeof(path));
syslen = util_strlcpy(buf, udev_get_sys_path(udev), sizeof(buf));
len = readlink(path, &buf[syslen], sizeof(buf)-syslen);
if (len <= 0 || len >= (ssize_t)(sizeof(buf)-syslen)) {
unlink(path);
continue;
}
buf[syslen + len] = '\0';
dbg(udev, "old watch to '%s' found\n", buf);
dev = udev_device_new_from_syspath(udev, buf);
if (dev == NULL) {
unlink(path);
continue;
}
info(udev, "restoring old watch on '%s'\n", udev_device_get_devnode(dev));
udev_watch_begin(udev, dev);
udev_device_unref(dev);
unlink(path);
}
closedir(dir);
rmdir(oldname);
} else if (errno != ENOENT) {
err(udev, "unable to move watches dir '%s', old watches will not be restored: %m", filename);
}
}
int main(int argc, char *argv[])
{
struct udev *udev;
struct udev_event *event;
struct udev_device *dev;
struct udev_rules *rules;
char syspath[UTIL_PATH_SIZE];
const char *devpath;
const char *action;
const char *subsystem;
struct sigaction act;
int err = -EINVAL;
udev = udev_new();
if (udev == NULL)
exit(1);
info(udev, "version %s\n", VERSION);
udev_selinux_init(udev);
/* set signal handlers */
memset(&act, 0x00, sizeof(act));
act.sa_handler = (void (*)(int)) sig_handler;
sigemptyset (&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGALRM, &act, NULL);
sigaction(SIGINT, &act, NULL);
sigaction(SIGTERM, &act, NULL);
/* trigger timeout to prevent hanging processes */
alarm(UDEV_EVENT_TIMEOUT);
action = getenv("ACTION");
devpath = getenv("DEVPATH");
subsystem = getenv("SUBSYSTEM");
if (action == NULL || subsystem == NULL || devpath == NULL) {
err(udev, "action, subsystem or devpath missing\n");
goto exit;
}
rules = udev_rules_new(udev, 1);
util_strlcpy(syspath, udev_get_sys_path(udev), sizeof(syspath));
util_strlcat(syspath, devpath, sizeof(syspath));
dev = udev_device_new_from_syspath(udev, syspath);
if (dev == NULL) {
info(udev, "unknown device '%s'\n", devpath);
goto fail;
}
/* skip reading of db, but read kernel parameters */
udev_device_set_info_loaded(dev);
udev_device_read_uevent_file(dev);
udev_device_set_action(dev, action);
event = udev_event_new(dev);
err = udev_event_execute_rules(event, rules);
/* rules may change/disable the timeout */
if (udev_device_get_event_timeout(dev) >= 0)
alarm(udev_device_get_event_timeout(dev));
if (err == 0 && !event->ignore_device && udev_get_run(udev))
udev_event_execute_run(event);
udev_event_unref(event);
udev_device_unref(dev);
fail:
udev_rules_unref(rules);
exit:
udev_selinux_exit(udev);
udev_unref(udev);
if (err != 0)
return 1;
return 0;
}