--enable-glamor

		--enable-glamor --enable-config-devd=yes

post-configure:

post-install:

.if ${PORT_OPTIONS:MDEVD}

	@${REINPLACE_CMD} -e 's|config\.c|config.c devd.c|g' \

		-e 's|config\.lo|config.lo devd.lo|g' \

		${WRKSRC}/config/Makefile

	@${REINPLACE_CMD} -e 's|^/\* #undef CONFIG_UDEV \*/|#define CONFIG_DEVD 1|' \

		${WRKSRC}/include/dix-config.h

.endif

@@ -0,0 +1,531 @@

@@ -0,0 +1,960 @@

+#define RECONNECT_DELAY		5 * 1000

+#define RECONNECT_DELAY		(5 * 1000)

+static int sock_devd;

+

+static bool is_console_kbd = false;

+#define is_meuqual(__v1, __v1sz, __v2, __v2sz)				\

+static bool is_kbdmux = false;

+	((__v1sz) == (__v2sz) && NULL != (__v1) && NULL != (__v2) &&	\

+	 0 == memcmp((__v1), (__v2), (__v1sz)))

+

+#define is_meuqual_cstr(__cstr, __v, __vsz)				\

+	is_meuqual(__cstr, (sizeof(__cstr) - 1), __v, __vsz)

+

+#define is_de_euqual_cstr(__de, __cstr)					\

+	(NULL != (__de) &&						\

+	 is_meuqual((__de)->d_name, (__de)->d_namlen, __cstr, (sizeof(__cstr) - 1)))

+

+#define devd_get_val_cstr(__cstr, __buf, __bufsz, __valsz)		\

+	devd_get_val((__buf), (__bufsz), __cstr, (sizeof(__cstr) - 1),	\

+	(__valsz))

+

+

+static int devd_skt;

+static char devd_buf[4096];

+static size_t devd_buf_used = 0;

+static int is_kbdmux = 0;

+struct hw_type {

+

+	const char *driver;

+/* Input devices. */

+	int flag;

+typedef struct hw_type_s {

+	const char *xdriver;

+	const char	*dev_name;

+	size_t		dev_name_size;

+	size_t		path_offset;

+	int		flags;

+	const char	*xdriver; 

+} hw_type_t, *hw_type_p;

+

+/* xdriver can be set via config "InputClass" section.

+ * Do not set xdriver name if device have more than one

+ * xf86-input-* drivers.

+ * "input/event" can be hadled by: xf86-input-evdev and

+ * xf86-input-wacom, let user chooses.

+ */

+static hw_type_t hw_types[] = {

+	{ "uhid",	4, 0, 0, NULL },

+	{ "ukbd",	4, 0, ATTR_KEYBOARD, "kbd" },

+	{ "atkbd",	5, 0, ATTR_KEYBOARD, "kbd" },

+	{ "kbdmux",	6, 0, ATTR_KEYBOARD, "kbd" },

+	{ "sysmouse",	8, 0, ATTR_POINTER, "mouse" },

+	{ "ums",	3, 0, ATTR_POINTER, "mouse" },

+	{ "psm",	3, 0, ATTR_POINTER, "mouse" },

+	{ "vboxguest",	9, 0, ATTR_POINTER, "vboxmouse" },

+	{ "joy",	3, 0, ATTR_JOYSTICK, NULL },

+	{ "atp",	3, 0, ATTR_TOUCHPAD, NULL },

+	{ "uep",	3, 0, ATTR_TOUCHSCREEN, NULL },

+	{ "input/event",5, 6, 0, NULL },

+	{ "input/js",	2, 6, ATTR_JOYSTICK, NULL },

+	{ NULL,		0, 0, 0, NULL },

+static struct hw_type hw_types[] = {

+/* Input devices paths. */

+	{ "ukbd", ATTR_KEYBOARD, "kbd" },

+static hw_type_t hw_type_path[] = {

+	{ "atkbd", ATTR_KEYBOARD, "kbd" },

+	{ "input/",	0, 6, 0, NULL },

+	{ "kbdmux", ATTR_KEYBOARD, "kbd" },

+	{ NULL,		0, 0, 0, NULL },

+	{ "sysmouse", ATTR_POINTER, "mouse" },

+	{ "ums", ATTR_POINTER, "mouse" },

+	{ "psm", ATTR_POINTER, "mouse" },

+	{ "vboxguest", ATTR_POINTER, "vboxmouse" },

+	{ "joy", ATTR_JOYSTICK, NULL },

+	{ "atp", ATTR_TOUCHPAD, NULL },

+	{ "uep", ATTR_TOUCHSCREEN, NULL },

+	{ NULL, -1, NULL },

+static bool

+

+sysctl_exists(const struct hw_type *device, int unit,

+static size_t

+	char *devname, size_t devname_len)

+bits_calc(const uint32_t *bits, size_t off_start, size_t off_stop)

+	char sysctlname[PATH_MAX];

+	size_t i, count = 0;

+	size_t len;

+	int ret;

+	if (device == NULL || device->driver == NULL)

+	for (i = off_start; i < off_stop; i ++) {

+		return false;

+		if (U32_IS_BIT_SET(bits, i)) {

+			count ++;

+		}

+	}

+	return (count);

+}

+	/* Check if a sysctl exists. */

+static hw_type_p

+	snprintf(sysctlname, sizeof(sysctlname), "dev.%s.%i.%%desc",

+get_dev_type_by_name(const char *dev_name, size_t dev_name_size)

+	    device->driver, unit);

+{

+	ret = sysctlbyname(sysctlname, NULL, &len, NULL, 0);

+	size_t i;

+	if (ret == 0 && len > 0) {

+	if (NULL == dev_name || 0 == dev_name_size)

+		snprintf(devname, devname_len, "%s%i", device->driver, unit);

+		return (NULL);

+		return true;

+	for (i = 0; NULL != hw_types[i].dev_name; i ++) {

+		if (dev_name_size >= (hw_types[i].dev_name_size + hw_types[i].path_offset) &&

+		    0 == memcmp(dev_name, hw_types[i].dev_name,

+		    (hw_types[i].path_offset + hw_types[i].dev_name_size))) {

+			return (&hw_types[i]);

+		}

+	return false;

+/* From: sys/dev/usb/usb_hid.c */

+static int

+hid_is_collection(report_desc_t s, uint32_t usage)

+{

+	struct hid_data *hd;

+	struct hid_item hi;

+	int rc;

+

+	hd = hid_start_parse(s, ~0, -1);

+	if (hd == NULL)

+		return (0);

+

+	while ((rc = hid_get_item(hd, &hi))) {

+		 if (hi.kind == hid_collection &&

+		     hi.usage == usage)

+			break;

+	}

+	hid_end_parse(hd);

+	return (rc);

+static bool

+static int

+devpath_exists(const struct hw_type *device,

+hid_is_mouse(report_desc_t s)

+	char *devname, size_t devname_len)

+	char *devpath;

+	struct hid_data *hd;

+	struct stat st;

+	struct hid_item hi;

+	int ret;

+	int mdepth;

+	int found;

+	if (device == NULL || device->driver == NULL)

+	hd = hid_start_parse(s, (1 << hid_input), -1);

+		return false;

+	if (hd == NULL)

+		return (0);

+	/* Check if /dev/$driver exists. */

+	mdepth = 0;

+	asprintf(&devpath, "/dev/%s", device->driver);

+	found = 0;

+	if (devpath == NULL)

+		return false;

+	ret = stat(devpath, &st);

+	while (hid_get_item(hd, &hi)) {

+	free(devpath);

+		switch (hi.kind) {

+		case hid_collection:

+			if (mdepth != 0)

+				mdepth ++;

+			else if (hi.collection == 1 &&

+			     hi.usage ==

+			      HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_MOUSE))

+				mdepth ++;

+			break;

+		case hid_endcollection:

+			if (mdepth != 0)

+				mdepth --;

+			break;

+		case hid_input:

+			if (mdepth == 0)

+				break;

+			if (hi.usage ==

+			     HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X) &&

+			    (hi.flags & (HIO_CONST|HIO_RELATIVE)) == HIO_RELATIVE)

+				found ++;

+			if (hi.usage ==

+			     HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y) &&

+			    (hi.flags & (HIO_CONST|HIO_RELATIVE)) == HIO_RELATIVE)

+				found ++;

+			break;

+		default:

+			break;

+		}

+	}

+	hid_end_parse(hd);

+	return (found);

+}

+	if (ret == 0) {

+

+		strncpy(devname, device->driver, devname_len);

+static hw_type_p

+		return true;

+get_dev_type_by_path(const char *dev_name, size_t dev_name_size,

+    hw_type_p hw_type_cust)

+{

+	size_t i;

+

+	if (NULL == dev_name || 0 == dev_name_size || NULL == hw_type_cust)

+		return (NULL);

+	for (i = 0; NULL != hw_type_path[i].dev_name; i ++) {

+		if (dev_name_size <= hw_type_path[i].path_offset ||

+		    0 != memcmp(dev_name, hw_type_path[i].dev_name,

+		    hw_type_path[i].path_offset))

+			continue;

+		/* Path in white list. */

+		hw_type_cust->dev_name = dev_name;

+		hw_type_cust->path_offset = hw_type_path[i].path_offset;

+		for (i = hw_type_cust->path_offset; i < dev_name_size; i ++) {

+			if (isdigit(dev_name[i]))

+				break;

+		}

+		hw_type_cust->dev_name_size = (i - hw_type_cust->path_offset);

+		hw_type_cust->flags = hw_type_path[i].flags;

+		hw_type_cust->xdriver = hw_type_path[i].xdriver;

+		return (hw_type_cust);

+	return false;

+static int

+is_kbdmux_enabled(void)

+{

+	/* Xorg uses /dev/ttyv0 as a console device */

+	/* const char device[]="/dev/console"; */

+	int fd;

+	const char *device = _PATH_TTY "v0";

+	keyboard_info_t info;

+

+	fd = open(device, O_RDONLY);

+	if (0 > fd)

+		return (0);

+	if (-1 == ioctl(fd, KDGKBINFO, &info) ||

+	    0 != memcmp(info.kb_name, "kbdmux", 6)) {

+		close(fd);

+		return (0);

+	}

+	close(fd);

+	return (1);

+sysctl_get_str(const char *sysctlname)

+sysctl_get_str(const char *sysctlname, size_t *size_ret)

+	char *dest = NULL;

+	char *dest;

+	if (sysctlname == NULL)

+	if (NULL == sysctlname)

+		return NULL;

+		return (NULL);

+	if (0 != sysctlbyname(sysctlname, NULL, &len, NULL, 0))

+		return (NULL);

+	dest = malloc(len + 4);

+	if (NULL == dest)

+		return (NULL);

+	if (0 != sysctlbyname(sysctlname, dest, &len, NULL, 0)) {

+		free(dest);

+		return (NULL);

+	}

+	dest[len] = 0;

+	if (NULL != size_ret)

+		(*size_ret) = len;

+	return (dest);

+}

+	if (sysctlbyname(sysctlname, NULL, &len, NULL, 0) == 0) {

+static char *

+		dest = malloc(len + 1);

+devd_get_val(char *buf, size_t buf_size, const char *val_name,

+		if (dest) {

+    size_t val_name_size, size_t *val_size)

+			if (sysctlbyname(sysctlname, dest, &len, NULL, 0) == 0)

+{

+				dest[len] = '\0';

+	char *ret, *buf_end, *ptr;

+			else {

+

+				free(dest);

+	buf_end = (buf + buf_size);

+				dest = NULL;

+	for (ret = buf; ret != NULL && ret < buf_end;) {

+			}

+		ret = memmem(ret, (buf_end - ret), val_name, val_name_size);

+		if (ret == NULL)

+			return (NULL);

+		/* Found. */

+		/* Check: space before or buf+1. */

+		if ((buf + 1) < ret && ret[-1] != ' ') {

+			ret += val_name_size;

+			continue;

+

+	if (ret == NULL || val_size == NULL)

+	return dest;

+		return (ret);

+	/* Calc value data size. */

+	ptr = memchr(ret, ' ', (buf_end - ret));

+	if (ptr == NULL) /* End of string/last value. */

+		ptr = buf_end;

+	(*val_size) = (ptr - ret);

+	return (ret);

+device_added(const char *devname)

+device_added(const char *dev_name, size_t dev_name_size, int allow_no_device)

+	char path[PATH_MAX];

+	int fd;

+	char sysctlname[PATH_MAX];

+	char *vendor;

+	char *product = NULL;

+	char *config_info = NULL;

+	char *walk;

+	InputAttributes attrs = { };

+	InputAttributes attrs;

+	DeviceIntPtr dev = NULL;

+	DeviceIntPtr dev_iptr = NULL;

+	int i;

+	keyboard_info_t kbdi;

+	int fd;

+	mousehw_t mshw;

+	struct input_id iid;

+	report_desc_t rep_desc;

+	struct usb_device_info usb_dev_info;

+	size_t has_keys = 0, has_buttons = 0, has_lmr = 0;

+	size_t has_rel_axes = 0, has_abs_axes = 0, has_mt = 0;

+	uint32_t key_bits[U32_CNT(KEY_CNT)];

+	uint32_t rel_bits[U32_CNT(REL_CNT)];

+	uint32_t abs_bits[U32_CNT(ABS_CNT)];

+	char *dev_path, config_info[(PATH_MAX + 32)];

+	char sysctlname[PATH_MAX], *sdata, *ptr_pid, *ptr_vid;

+	char pnp_usb_id[PATH_MAX], vendor[PATH_MAX], product[PATH_MAX];

+	size_t sdata_size, pid_size, vid_size;

+	hw_type_t *hwtype, hwtype_cust;

+	unsigned short vid, pid;

+		len = strlen(hw_types[i].driver);

+	if (NULL == dev_name || 0 == dev_name_size || PATH_MAX < dev_name_size)

+		if (strcmp(devname, hw_types[i].driver) == 0 ||

+		return;

+			(strncmp(devname, hw_types[i].driver, len) == 0 &&

+	/* Make dev_name null ended string. */

+				isnumber(*(devname + len)))) {

+	snprintf(config_info, sizeof(config_info), DEVD_PATH_DEV"%.*s",

+			attrs.flags |= hw_types[i].flag;

+	    (int)dev_name_size, dev_name);

+			break;

+	/* Set / update pointers to dev_name and dev_path. */

+		}

+	dev_path = (config_info + 5); /* Skip: "devd:" */

+	dev_name = (dev_path + _PATH_DEV_LEN); /* Skip: "/dev/" */

+

+	/* Is known input device or path? */

+	hwtype = get_dev_type_by_name(dev_name, dev_name_size);

+	if (NULL == hwtype) {

+		hwtype = get_dev_type_by_path(dev_name, dev_name_size,

+		    &hwtype_cust);

+

+	if (NULL == hwtype) /* Not found in white list. */

+	if (hw_types[i].driver == NULL || hw_types[i].xdriver == NULL) {

+		LogMessage(X_INFO, "config/devd: ignoring device %s\n",

+				devname);

+	}

+	/* Init and set attributes. */

+	memset(&attrs, 0, sizeof(attrs));

+	attrs.device = dev_path;

+	attrs.flags = hwtype->flags;

+	if (is_kbdmux && is_console_kbd && hw_types[i].flag & ATTR_KEYBOARD) {

+	if (is_kbdmux && 0 == allow_no_device && (hwtype->flags & ATTR_KEYBOARD)) {

+skip_kbd_dev:

+				devname);

+		    dev_name);

+

+	/* Skip duplicate devices. */

+	snprintf(path, sizeof(path), "/dev/%s", devname);

+	if (device_is_duplicate(config_info)) {

+

+		LogMessage(X_WARNING, "config/devd: device %s already added. ignoring\n",

+	options = input_option_new(NULL, "_source", "server/devd");

+		    dev_path);

+	if (!options)

+		attrs.vendor = strdup(vendor);

+	/* Try to open device. */

+		if (product) {

+	fd = open(dev_path, O_RDONLY);

+			attrs.product = strdup(product);

+	if (0 > fd) {

+			options = input_option_new(options, "name", product);

+		if (0 == (hwtype->flags & ATTR_KEYBOARD)) {

+		}

+		else

+			options = input_option_new(options, "name", "(unnamed)");

+

+		free(vendor);

+	}

+

+	/* XXX implement usb_id */

+	attrs.usb_id = NULL;

+	attrs.device = strdup(path);

+	options = input_option_new(options, "driver", hw_types[i].xdriver);

+

+	fd = open(path, O_RDONLY);

+	if (fd > 0) {

+		close(fd);

+		options = input_option_new(options, "device", path);

+	}

+	else {

+		if (attrs.flags & ~ATTR_KEYBOARD) {

+					 path);

+			    dev_path);

+

+			goto unwind;

+			return;

+

+		if (0 == allow_no_device) {

+		if (is_console_kbd) {

+					"already added, ignoring %s (%s)\n",

+			    "already added, ignoring %s\n",

+					attrs.product, path);

+			    dev_path);

+			goto unwind;

+			return;

+		else

+		/*

+			/*

+		 * Don't pass "device" option if the keyboard is already

+			 * Don't pass "device" option if the keyboard is already

+		 * attached to the console (ie. open() fails).

+			 * attached to the console (ie. open() fails).

+		 * This would activate a special logic in xf86-input-keyboard.

+			 * This would activate a special logic in xf86-input-keyboard.

+		 * Prevent any other attached to console keyboards being

+			 * Prevent any other attached to console keyboards being

+		 * processed. There can be only one such device.

+			 * processed. There can be only one such device.

+		 */

+			 */

+		goto skip_ioctl;

+			is_console_kbd = true;

+	if (asprintf(&config_info, "devd:%s", devname) == -1) {

+	/* Try to get device info via ioctl(). */

+		config_info = NULL;

+	if (-1 != ioctl(fd, KDGKBINFO, &kbdi)) { /* Is this keyboard? */

+		goto unwind;

+		memcpy(product, kbdi.kb_name, sizeof(kbdi.kb_name));

+		attrs.product = product;

+		attrs.flags = ATTR_KEYBOARD;

+		LogMessage(X_INFO, "config/devd: detected keyboard: %s, kb_index=%i, kb_unit=%i, kb_type=%i, kb_config=%i\n",

+		    kbdi.kb_name, kbdi.kb_index, kbdi.kb_unit, kbdi.kb_type, kbdi.kb_config);

+	} else if (-1 != ioctl(fd, MOUSE_GETHWINFO, &mshw)) { /* Is this mouse? */

+#ifdef notyet /* FreeBSD mouse drivers does not return real vid+pid. */

+		/* construct USB ID in lowercase hex - "0000:ffff" */

+		snprintf(pnp_usb_id, sizeof(pnp_usb_id), "%04x:%04x",

+		    mshw.hwid, mshw.model);

+		attrs.usb_id = pnp_usb_id;

+#endif

+

+		switch (mshw.type) {

+		case MOUSE_MOUSE:

+		case MOUSE_TRACKBALL:

+		case MOUSE_STICK:

+			attrs.flags = ATTR_POINTER;

+			break;

+		case MOUSE_PAD:

+			attrs.flags = ATTR_TOUCHPAD;		

+			break;

+		}

+		LogMessage(X_INFO, "config/devd: detected mouse: hwid=%04x, model=%04x, type=%04x, iftype=%04x, buttons=%04x\n",

+		    mshw.hwid, mshw.model, mshw.type, mshw.iftype, mshw.buttons);

+	} else if (-1 != ioctl(fd, JSIOCGNAME((sizeof(product) - 1)), product)) { /* Is this joystick? */

+		attrs.product = product;

+		attrs.flags = ATTR_JOYSTICK;

+		LogMessage(X_INFO, "config/devd: detected joystick: %s\n",

+		    product);

+	} else if (-1 != ioctl(fd, EVIOCGID, &iid) &&

+	    -1 != ioctl(fd, EVIOCGNAME((sizeof(product) - 1)), product)) { /* Is this event? */

+		/* construct USB ID in lowercase hex - "0000:ffff" */

+		snprintf(pnp_usb_id, sizeof(pnp_usb_id), "%04x:%04x",

+		    iid.vendor, iid.product);

+		attrs.usb_id = pnp_usb_id;

+		attrs.product = product;

+

+		/* Detect device type. */

+		if (-1 != ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)), key_bits)) {

+			has_keys = bits_calc(key_bits, 0, BTN_MISC);

+			has_buttons = bits_calc(key_bits, BTN_MISC, BTN_JOYSTICK);

+			has_lmr = bits_calc(key_bits, BTN_LEFT, BTN_MIDDLE);

+		}

+		if (-1 != ioctl(fd, EVIOCGBIT(EV_REL, sizeof(rel_bits)), rel_bits)) {

+			has_rel_axes = bits_calc(rel_bits, 0, REL_MAX);

+		}

+		if (-1 != ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(abs_bits)), abs_bits)) {

+			has_abs_axes = bits_calc(abs_bits, 0, ABS_MAX);

+			has_mt = bits_calc(abs_bits, ABS_MT_SLOT, ABS_MAX);

+		}

+

+		if (has_abs_axes) {

+			if (has_mt) {

+				if (0 == has_buttons) {

+					/*

+					 * XXX: I'm not sure that joystick detection is

+					 * done right. xf86-evdev does not support them.

+					 */

+					if (U32_IS_BIT_SET(key_bits, BTN_JOYSTICK)) {

+						attrs.flags = ATTR_JOYSTICK;

+						goto event_done;

+					} else {

+						has_buttons ++;

+					}

+				}

+			}

+			if (U32_IS_BIT_SET(abs_bits, ABS_X) &&

+			    U32_IS_BIT_SET(abs_bits, ABS_Y)) {

+				if (U32_IS_BIT_SET(key_bits, BTN_TOOL_PEN) ||

+				    U32_IS_BIT_SET(key_bits, BTN_STYLUS) ||

+				    U32_IS_BIT_SET(key_bits, BTN_STYLUS2)) {

+					attrs.flags = ATTR_TABLET;

+					goto event_done;

+				} else if (U32_IS_BIT_SET(abs_bits, ABS_PRESSURE) ||

+					   U32_IS_BIT_SET(key_bits, BTN_TOUCH)) {

+					if (has_lmr ||

+					    U32_IS_BIT_SET(key_bits, BTN_TOOL_FINGER)) {

+						attrs.flags = ATTR_TOUCHPAD;

+					} else {

+						attrs.flags = ATTR_TOUCHSCREEN;

+					}

+					goto event_done;

+				} else if (!(U32_IS_BIT_SET(rel_bits, REL_X) &&

+					     U32_IS_BIT_SET(rel_bits, REL_Y)) &&

+					    has_lmr) {

+					/* some touchscreens use BTN_LEFT rather than BTN_TOUCH */

+					attrs.flags = ATTR_TOUCHSCREEN;

+					goto event_done;

+				}

+			}

+		}

+		if (has_keys) {

+			if (is_kbdmux) {

+				close(fd);

+				goto skip_kbd_dev;

+			}

+			attrs.flags = ATTR_KEYBOARD;

+		} else if (has_rel_axes || has_abs_axes || has_buttons) {

+			attrs.flags = ATTR_POINTER;			

+		}

+event_done:

+		LogMessage(X_INFO, "config/devd: detected event: %s, bustype=%04x, vendor=%04x, product=%04x, version=%04x\n",

+		    product, iid.bustype, iid.vendor, iid.product, iid.version);

+	} else if (0 != (rep_desc = hid_get_report_desc(fd))) { /* Is USB HID? */

+		if (hid_is_mouse(rep_desc)) {

+			attrs.flags = ATTR_POINTER;

+		} else if (hid_is_collection(rep_desc, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYBOARD))) {

+			/* Skip keyboard devices if kbdmux is enabled */

+			if (is_kbdmux) {

+				hid_dispose_report_desc(rep_desc);

+				close(fd);

+				goto skip_kbd_dev;

+			}

+			attrs.flags = ATTR_KEYBOARD;

+		} else if (hid_is_collection(rep_desc, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_JOYSTICK)) ||

+		    hid_is_collection(rep_desc, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_GAME_PAD))) {

+			attrs.flags = ATTR_JOYSTICK;

+		}

+

+		hid_dispose_report_desc(rep_desc);

+		LogMessage(X_INFO, "config/devd: detected USB HID...\n");

+	if (device_is_duplicate(config_info)) {

+	if (NULL == attrs.usb_id) { /* Is this webcamd device? */

+		LogMessage(X_WARNING, "config/devd: device %s (%s) already added. "

+		if (-1 != ioctl(fd, WEBCAMD_IOCTL_GET_USB_VENDOR_ID, &vid) &&

+				"ignoring\n", attrs.product, path);

+		    -1 != ioctl(fd, WEBCAMD_IOCTL_GET_USB_PRODUCT_ID, &pid)) {

+		goto unwind;

+			snprintf(pnp_usb_id, sizeof(pnp_usb_id),

+			    "%04x:%04x", vid, pid);

+			attrs.usb_id = pnp_usb_id;

+			LogMessage(X_INFO, "config/devd: WebCamD device: %s\n", pnp_usb_id);

+		}

+	LogMessage(X_INFO, "config/devd: adding input device %s (%s)\n",

+	if (NULL == options)

+			attrs.product, path);

+		goto err_out;

+	NewInputDeviceRequest(options, &attrs, &dev);

+	options = input_option_new(options, "name",

+	    ((NULL != attrs.product) ? attrs.product : dev_name));

+	if (NULL == options)

+		goto err_out;

+unwind:

+	if (fd >= 0) {

+	free(config_info);

+		options = input_option_new(options, "device", dev_path);

+		if (NULL == options)

+			goto err_out;

+	}

+

+	if (NULL != hwtype->xdriver) {

+		options = input_option_new(options, "driver", hwtype->xdriver);

+		if (NULL == options)

+			goto err_out;

+	}

+

+	LogMessage(X_INFO, "config/devd: adding input device %s\n", dev_path);

+	NewInputDeviceRequest(options, &attrs, &dev_iptr);

+	goto done;

+

+err_out:

+	LogMessage(X_INFO, "config/devd: error adding device '%s'\n",

+	    dev_path);

+done:

+device_removed(char *devname)

+device_removed(const char *dev_name, size_t dev_name_size)

+	char *config_info;

+	char config_info[(PATH_MAX + 32)];

+	hw_type_t hwtype_cust;

+	if (asprintf(&config_info, "devd:%s", devname) == -1)

+	if (NULL == dev_name || 0 == dev_name_size || PATH_MAX < dev_name_size)

+

+	if (NULL == get_dev_type_by_name(dev_name, dev_name_size) &&

+	    NULL == get_dev_type_by_path(dev_name, dev_name_size, &hwtype_cust))

+		return; /* Device not in list - unknown. */

+	snprintf(config_info, sizeof(config_info), DEVD_PATH_DEV"%.*s",

+	    (int)dev_name_size, dev_name);

+	/* Skip non added devices. */

+	if (device_is_duplicate(config_info)) {

+		LogMessage(X_INFO, "config/devd: removing input device '%s'\n",

+		    (config_info + DEVD_PATH_DEV_LEN));

+	}

+	if (sock >= 0) {

+	if (0 > sock)

+		RemoveGeneralSocket(sock);

+		return;

+		close(sock);

+	RemoveGeneralSocket(sock);

+	}

+	close(sock);

+	if (sock < 0) {

+	if (0 > sock) {

+		return -1;

+		return (-1);

+	strlcpy(devd.sun_path, DEVD_SOCK_PATH, sizeof(devd.sun_path));

+	memcpy(devd.sun_path, DEVD_SOCK_PATH, sizeof(DEVD_SOCK_PATH));

+

+	if (0 > connect(sock, (struct sockaddr*)&devd, sizeof(devd))) {

+	if (connect(sock, (struct sockaddr *) &devd, sizeof(devd)) < 0) {

+		return -1;

+		return (-1);

+	return	sock;

+	return (sock);

+	int newsock;

+	devd_buf_used = 0;

+	devd_skt = connect_devd();

+	if (-1 == devd_skt) /* Try again after RECONNECT_DELAY */

+		return (RECONNECT_DELAY);

+	TimerFree(rtimer);

+	rtimer = NULL;

+	LogMessage(X_INFO, "config/devd: reopening devd socket\n");

+	if ((newsock = connect_devd()) > 0) {

+	return (0);

+		sock_devd = newsock;

+		TimerFree(rtimer);

+		rtimer = NULL;

+		LogMessage(X_INFO, "config/devd: reopening devd socket\n");

+		return 0;

+	}

+

+	/* Try again after RECONNECT_DELAY */

+	return RECONNECT_DELAY;

+static ssize_t

+static void

+socket_getline(int fd, char **out)

+wakeup_handler(void *data, int err, void *read_mask)

+	char *buf, *newbuf;

+	int error;

+	ssize_t ret, cap, sz = 0;

+	char *ptr, *line, *val, *cdev;

+	char c;

+	size_t line_size, val_size, cdev_size;

+	ssize_t ios;

+	cap = 1024;

+	if (0 > err)

+	buf = malloc(cap * sizeof(char));

+		return;

+	if (!buf)

+	if (!FD_ISSET(devd_skt, (fd_set*)read_mask))

+		return -1;

+		return;

+

+	/* Read new data. */

+		ret = read(sock_devd, &c, 1);

+		ios = recv(devd_skt, (devd_buf + devd_buf_used), 

+		if (ret < 0) {

+		    (sizeof(devd_buf) - devd_buf_used), MSG_DONTWAIT);

+			if (errno == EINTR)

+		if (0 < ios) { /* Read OK. */

+				continue;

+			devd_buf_used += ios;

+			free(buf);

+			continue; /* Try to read more. */

+			return -1;

+		/* EOF - devd socket is lost */

+		} else if (ret == 0) {

+			disconnect_devd(sock_devd);

+			rtimer = TimerSet(NULL, 0, 1, reconnect_handler, NULL);

+			LogMessage(X_WARNING, "config/devd: devd socket is lost\n");

+			return -1;

+		if (c == '\n')

+		/* Something wrong. */

+			break;

+		error = errno;

+

+		if (error == EAGAIN)

+		if (sz + 1 >= cap) {

+			break; /* All avaible data readed. */

+			cap *= 2;

+		if (error == EINTR)

+			newbuf = realloc(buf, cap * sizeof(char));

+			continue;

+			if (!newbuf) {

+		if (sizeof(devd_buf) == devd_buf_used) { /* Message to long, reset buf. */

+				free(buf);

+			devd_buf_used = 0;

+				return -1;

+			continue;

+			}

+			buf = newbuf;

+		buf[sz] = c;

+		/* devd socket is lost */

+		sz++;

+		disconnect_devd(devd_skt);

+		rtimer = TimerSet(NULL, 0, 1, reconnect_handler, NULL);

+		LogMessage(X_WARNING, "config/devd: devd socket read error: %i - %s\n", error, strerror(error));

+		return;

+	buf[sz] = '\0';

+	/* Process data. */

+	if (sz >= 0)

+	line = (devd_buf + 1);

+		*out = buf;

+	for (;;) {

+	else

+		line_size = (ptr - line);

+		free(buf);

+		if (DEVD_EVENT_NOTIFY != (*(line - 1)))

+			goto move_next_event; /* Handle only notify. */

+		/* Check: is system=DEVFS. */

+		val = devd_get_val_cstr("system", line, line_size, &val_size);

+		if (!is_meuqual_cstr("DEVFS", val, val_size))

+			goto move_next_event;

+		/* Check: is subsystem=CDEV. */

+		val = devd_get_val_cstr("subsystem", line, line_size, &val_size);

+		if (!is_meuqual_cstr("CDEV", val, val_size))

+			goto move_next_event;

+		/* Get device name. */

+		cdev = devd_get_val_cstr("cdev", line, line_size, &cdev_size);

+		if (NULL == cdev)

+			goto move_next_event;

+		/* Get event type. */

+		val = devd_get_val_cstr("type", line, line_size, &val_size);

+		if (is_meuqual_cstr("CREATE", val, val_size)) {

+			device_added(cdev, cdev_size, 0);

+		} else if (is_meuqual_cstr("DESTROY", val, val_size)) {

+			device_removed(cdev, cdev_size);

+		}

+	/* Number of bytes in the line, not counting the line break */

+move_next_event:

+	return sz;

+		line += (line_size + 2); /* Skip '\n' and event type byte. */

+}

+		line_size = (line - devd_buf);

+

+		if (devd_buf_used <= line_size) {

+static void

+			devd_buf_used = 0;

+wakeup_handler(void *data, int err, void *read_mask)

+{

+	char *line = NULL;

+	char *walk;

+

+	if (err < 0)

+		return;

+

+	if (FD_ISSET(sock_devd, (fd_set *) read_mask)) {

+		if (socket_getline(sock_devd, &line) < 0)

+

+		}

+		walk = strchr(line + 1, ' ');

+		ptr = memchr(line, '\n', (devd_buf_used - line_size));

+		if (walk != NULL)

+		if (NULL == ptr)

+			walk[0] = '\0';

+

+		switch (*line) {

+		case DEVD_EVENT_ADD:

+			device_added(line + 1);

+	char devicename[1024];

+	size_t i, j, dir_cnt, sdir_cnt, tm;

+	int i, j;

+	char devicename[PATH_MAX];

+	struct dirent *de, **namelist, *sde, **snamelist;

+	if ((is_kbdmux = is_kbdmux_enabled()) == true)

+	is_kbdmux = is_kbdmux_enabled();

+		device_added("kbdmux");

+	if (is_kbdmux)

+		device_added("kbdmux0", 7, 1);

+	for (i = 0; hw_types[i].driver != NULL; i++) {

+	/* Scan /dev/ for devices. */

+		/* First scan the sysctl to determine the hardware */

+	dir_cnt = scandir(_PATH_DEV, &namelist, 0, alphasort);

+		for (j = 0; j < 16; j++) {

+	for (i = 0; i < dir_cnt; i ++) {

+			if (sysctl_exists(&hw_types[i], j,

+		de = namelist[i];

+					devicename, sizeof(devicename)) != 0)

+		if (is_de_euqual_cstr(de, ".") ||

+				device_added(devicename);

+		    is_de_euqual_cstr(de, "..")) {

+			free(de);

+			continue;

+

+		if (DT_DIR != de->d_type) {

+		if (devpath_exists(&hw_types[i], devicename, sizeof(devicename)) != 0)

+			device_added(de->d_name, de->d_namlen, 0);

+			device_added(devicename);

+		} else { /* Sub folder. */

+			snprintf(devicename, sizeof(devicename),

+			    _PATH_DEV "%s", de->d_name);

+			sdir_cnt = scandir(devicename, &snamelist, 0, alphasort);

+			for (j = 0; j < sdir_cnt; j ++) {

+				sde = snamelist[j];

+				if (!is_de_euqual_cstr(sde, ".") &&

+				    !is_de_euqual_cstr(sde, "..") &&

+				    DT_DIR != sde->d_type) {

+					tm = snprintf(devicename, sizeof(devicename),

+					    "%s/%s", de->d_name, sde->d_name);

+					device_added(devicename, tm, 0);

+				}

+				free(sde);

+			}

+			free(snamelist);

+		}

+		free(de);

+	if ((sock_devd = connect_devd()) < 0)

+	devd_buf_used = 0;

+		return 0;

+	devd_skt = connect_devd();

+	if (-1 == devd_skt)

+		return (0);

+	return 1;

+	return (1);

+	disconnect_devd(sock_devd);

+	disconnect_devd(devd_skt);

@@ -25559,7 +25564,7 @@

@@ -22760,6 +23255,9 @@

 $as_echo "#define SYSCONS_SUPPORT 1" >>confdefs.h

+

+$as_echo "#define CONFIG_DEVD 1" >>confdefs.h

+

 	DRI=yes

 	;;

   *netbsd*)

@@ -23517,6 +24015,13 @@

   CONFIG_WSCONS=auto

 fi

+# Check whether --enable-config-devd was given.

+if test "${enable_config_devd+set}" = set; then :

+  enableval=$enable_config_devd; CONFIG_DEVD=$enableval

+else

+  CONFIG_DEVD=auto

+fi

+

 # Check whether --enable-xfree86-utils was given.

 if test "${enable_xfree86_utils+set}" = set; then :

   enableval=$enable_xfree86_utils; XF86UTILS=$enableval

@@ -24239,6 +24744,7 @@

 		CONFIG_HAL=no

 		CONFIG_UDEV=no

 		CONFIG_UDEV_KMS=no

+		CONFIG_DEVD=no

 		DGA=no

 		DRM=no

 		DRI2=no

@@ -24568,6 +25074,30 @@

 fi

+if test "x$CONFIG_DEVD" = xauto; then

+	case $host_os in

+		*freebsd*)

+			CONFIG_DEVD=yes;

+			;;

+		*)

+			CONFIG_DEVD=no;

+			;;

+	esac

+fi

+ if test "x$CONFIG_DEVD" = xyes; then

+  CONFIG_DEVD_TRUE=

+  CONFIG_DEVD_FALSE='#'

+else

+  CONFIG_DEVD_TRUE='#'

+  CONFIG_DEVD_FALSE=

+fi

+

+if test "x$CONFIG_DEVD" = xyes; then

+

+$as_echo "#define CONFIG_DEVD 1" >>confdefs.h

+

+fi

+

 if test "x$CONFIG_UDEV" = xyes && test "x$CONFIG_HAL" = xyes; then

 	as_fn_error $? "Hotplugging through both libudev and hal not allowed" "$LINENO" 5

 fi

@@ -25559,7 +26089,7 @@