[thirdparty/systemd.git] / dev_d.c

/*
 * dev_d.c - dev.d/ multiplexer
 * 
 * Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
 *
 *	This program is free software; you can redistribute it and/or modify it
 *	under the terms of the GNU General Public License as published by the
 *	Free Software Foundation version 2 of the License.
 */

/*
 * This essentially emulates the following shell script logic in C:
 *	DIR="/etc/dev.d"
 *	export DEVNAME="whatever_dev_name_udev_just_gave"
 *	for I in "${DIR}/$DEVNAME/"*.dev "${DIR}/$1/"*.dev "${DIR}/default/"*.dev ; do
 *		if [ -f $I ]; then $I $1 ; fi
 *	done
 *	exit 1;
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include "udev.h"
#include "udev_lib.h"
#include "logging.h"

#define DEVD_DIR			"/etc/dev.d/"
#define DEVD_SUFFIX			".dev"

static int run_program(char *name)
{
	pid_t pid;

	dbg("running %s", name);

	pid = fork();
	switch (pid) {
	case 0:
		/* child */
		execv(name, main_argv);
		dbg("exec of child failed");
		exit(1);
	case -1:
		dbg("fork of child failed");
		break;
		return -1;
	default:
		wait(NULL);
	}

	return 0;
}

/* 
 * runs files in these directories in order:
 * 	<node name given by udev>/
 * 	subsystem/
 * 	default/
 */
void dev_d_send(struct udevice *dev, const char *subsystem, const char *devpath)
{
	char dirname[256];
	char env_devname[NAME_SIZE];
	char *devname;
	char *temp;

	if (udev_dev_d == 0)
		return;

	memset(env_devname, 0x00, sizeof(env_devname));
	if (dev->type == 'b' || dev->type == 'c') {
		strfieldcpy(env_devname, udev_root);
		strfieldcat(env_devname, dev->name);
	} else if (dev->type == 'n') {
		strfieldcpy(env_devname, dev->name);
		setenv("DEVPATH", devpath, 1);
	}
	setenv("DEVNAME", env_devname, 1);
	dbg("DEVNAME='%s'", env_devname);

	devname = strdup(dev->name);
	if (!devname) {
		dbg("out of memory");
		return;
	}

	/* Chop the device name up into pieces based on '/' */
	temp = strchr(devname, '/');
	while (temp != NULL) {
		*temp = 0x00;
		strcpy(dirname, DEVD_DIR);
		strfieldcat(dirname, devname);
		call_foreach_file(run_program, dirname, DEVD_SUFFIX);

		*temp = '/';
		++temp;
		temp = strchr(temp, '/');
	}

	strcpy(dirname, DEVD_DIR);
	strfieldcat(dirname, dev->name);
	call_foreach_file(run_program, dirname, DEVD_SUFFIX);

	strcpy(dirname, DEVD_DIR);
	strfieldcat(dirname, subsystem);
	call_foreach_file(run_program, dirname, DEVD_SUFFIX);

	strcpy(dirname, DEVD_DIR "default");
	call_foreach_file(run_program, dirname, DEVD_SUFFIX);
}
Commit	Line	Data
dd64e26b	1	/*
4a539daf	2	* dev_d.c - dev.d/ multiplexer
dd64e26b GKH	3	*
	4	* Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation version 2 of the License.
dd64e26b GKH	9	*/
dd64e26b GKH	10
4a539daf	11	/*
dd64e26b	12	* This essentially emulates the following shell script logic in C:
4a539daf	13	* DIR="/etc/dev.d"
4b06c852	14	* export DEVNAME="whatever_dev_name_udev_just_gave"
4b06c852	15	* for I in "${DIR}/$DEVNAME/".dev "${DIR}/$1/".dev "${DIR}/default/"*.dev ; do
4a539daf KS	16	* if [ -f $I ]; then $I $1 ; fi
	17	* done
	18	* exit 1;
dd64e26b GKH	19	*/
dd64e26b GKH	20
dd64e26b GKH	21	#include <stdio.h>
	22	#include <stdlib.h>
	23	#include <string.h>
	24	#include <sys/types.h>
	25	#include <sys/wait.h>
	26	#include <unistd.h>
	27	#include "udev.h"
	28	#include "udev_lib.h"
	29	#include "logging.h"
	30
4a539daf KS	31	#define DEVD_DIR "/etc/dev.d/"
4a539daf KS	32	#define DEVD_SUFFIX ".dev"
dd64e26b	33
4a539daf	34	static int run_program(char *name)
dd64e26b GKH	35	{
	36	pid_t pid;
	37
	38	dbg("running %s", name);
	39
	40	pid = fork();
4a539daf KS	41	switch (pid) {
	42	case 0:
	43	/* child */
	44	execv(name, main_argv);
	45	dbg("exec of child failed");
	46	exit(1);
	47	case -1:
	48	dbg("fork of child failed");
	49	break;
	50	return -1;
	51	default:
dd64e26b	52	wait(NULL);
dd64e26b GKH	53	}
dd64e26b GKH	54
4a539daf	55	return 0;
dd64e26b GKH	56	}
dd64e26b GKH	57
4a539daf KS	58	/*
	59	* runs files in these directories in order:
	60	* <node name given by udev>/
	61	* subsystem/
	62	* default/
dd64e26b	63	*/
eb6c7cd0	64	void dev_d_send(struct udevice dev, const char subsystem, const char *devpath)
dd64e26b GKH	65	{
dd64e26b GKH	66	char dirname[256];
a3e6c800 GKH	67	char env_devname[NAME_SIZE];
	68	char *devname;
	69	char *temp;
dd64e26b	70
bbbe503e KS	71	if (udev_dev_d == 0)
	72	return;
	73
470c0ef2	74	memset(env_devname, 0x00, sizeof(env_devname));
bbbe503e	75	if (dev->type == 'b' \|\| dev->type == 'c') {
a3e6c800 GKH	76	strfieldcpy(env_devname, udev_root);
a3e6c800 GKH	77	strfieldcat(env_devname, dev->name);
bbbe503e	78	} else if (dev->type == 'n') {
a3e6c800	79	strfieldcpy(env_devname, dev->name);
9b28a52a	80	setenv("DEVPATH", devpath, 1);
bbbe503e	81	}
a3e6c800 GKH	82	setenv("DEVNAME", env_devname, 1);
	83	dbg("DEVNAME='%s'", env_devname);
	84
	85	devname = strdup(dev->name);
	86	if (!devname) {
	87	dbg("out of memory");
	88	return;
	89	}
	90
	91	/* Chop the device name up into pieces based on '/' */
	92	temp = strchr(devname, '/');
	93	while (temp != NULL) {
	94	*temp = 0x00;
	95	strcpy(dirname, DEVD_DIR);
	96	strfieldcat(dirname, devname);
	97	call_foreach_file(run_program, dirname, DEVD_SUFFIX);
	98
	99	*temp = '/';
	100	++temp;
	101	temp = strchr(temp, '/');
	102	}
dd64e26b	103
4a539daf KS	104	strcpy(dirname, DEVD_DIR);
	105	strfieldcat(dirname, dev->name);
	106	call_foreach_file(run_program, dirname, DEVD_SUFFIX);
dd64e26b	107
4a539daf KS	108	strcpy(dirname, DEVD_DIR);
	109	strfieldcat(dirname, subsystem);
	110	call_foreach_file(run_program, dirname, DEVD_SUFFIX);
dd64e26b	111
4a539daf KS	112	strcpy(dirname, DEVD_DIR "default");
4a539daf KS	113	call_foreach_file(run_program, dirname, DEVD_SUFFIX);
dd64e26b	114	}