rfkilld

rfkilld.c (6347B)

---

 /*
  * Copy me if you can.
  * by 20h
  */
 
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <poll.h>
 #include <ctype.h>
 #include <string.h>
 #include <stdarg.h>
 #include <syslog.h>
 #include <signal.h>
 #include <libgen.h>
 #include <errno.h>
 #include <strings.h>
 #include <sys/wait.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/socket.h>
 #include <fcntl.h>
 #include <linux/types.h>
 #include <linux/netlink.h>
 
 #include "arg.h"
 
 char *argv0;
 char *etcdir = "/etc/rfkilld";
 char lastname[129];
 char lasttype[129];
 int listfd = -1;
 int dolog = 0, dodebug = 0;
 
 void
 edie(char *fmt, ...)
 {
 	va_list fmtargs;
 
 	va_start(fmtargs, fmt);
 	vfprintf(stderr, fmt, fmtargs);
 	va_end(fmtargs);
 	fprintf(stderr, ": ");
 
 	perror(NULL);
 
 	exit(1);
 }
 
 void
 die(char *fmt, ...)
 {
 	va_list fmtargs;
 
 	va_start(fmtargs, fmt);
 	vfprintf(stderr, fmt, fmtargs);
 	va_end(fmtargs);
 
 	exit(1);
 }
 
 void
 dbg(char *fmt, ...)
 {
 	va_list fmtargs;
 
 	if (dodebug) {
 		fprintf(stderr, "%s: ", argv0);
 		va_start(fmtargs, fmt);
 		vfprintf(stderr, fmt, fmtargs);
 		va_end(fmtargs);
 		fprintf(stderr, "\n");
 	}
 }
 
 int
 setnonblocking(int fd)
 {
 	int flags;
 
 	flags = fcntl(fd, F_GETFL);
 	if (flags < 0)
 		return 1;
 	if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0)
 		return 1;
 
 	return 0;
 }
 
 void
 runifexecutable(char *file, char *oname, char *ostate)
 {
 	char cmd[512], name[64], state[16];
 	int pid, fd;
 
 	strncpy(name, oname, sizeof(name)-1);
 	name[sizeof(name)-1] = '\0';
 	strncpy(state, ostate, sizeof(state)-1);
 	state[sizeof(state)-1] = '\0';
 
 	snprintf(cmd, sizeof(cmd), "%s/%s.sh", etcdir, file);
 	if (!access(cmd, X_OK)) {
 		if (!(pid = fork())) {
 			if (!fork()) {
 				fd = open("/dev/null", O_RDWR);
 				if (fd < 0)
 					edie("open");
 				dup2(fd, 1);
 				dup2(fd, 2);
 				if (fd > 2)
 					close(fd);
 				if(execl(cmd, basename(name),
 						state, name, NULL) < 0) {
 					edie("execl");
 				}
 			}
 			exit(0);
 		}
 		waitpid(pid, NULL, 0);
 	}
 }
 
 void
 runscripts(char *name, char *type, char *state)
 {
 	dbg("runscripts: %s %s %s", name, type, state);
 
 	if (dolog) {
 		syslog(LOG_NOTICE, "name: %s; type: %s; state: %s;\n",
 				name, type, state);
 	}
 
 	runifexecutable(name, type, state);
 	runifexecutable(type, name, state);
 }
 
 void
 sighandler(int sig)
 {
 	switch(sig) {
 	case SIGCHLD:
 		while(waitpid(-1, NULL, WNOHANG) > 0);
 		break;
 	case SIGHUP:
 	case SIGINT:
 	case SIGQUIT:
 	case SIGABRT:
 	case SIGTERM:
 		if (dolog)
 			closelog();
 		if (listfd >= 0) {
 			shutdown(listfd, SHUT_RDWR);
 			close(listfd);
 		}
 		exit(0);
 		break;
 	default:
 		break;
 	}
 }
 
 void
 initsignals(void)
 {
 	signal(SIGCHLD, sighandler);
 	signal(SIGHUP, sighandler);
 	signal(SIGINT, sighandler);
 	signal(SIGQUIT, sighandler);
 	signal(SIGABRT, sighandler);
 	signal(SIGTERM, sighandler);
 
 	signal(SIGPIPE, SIG_IGN);
 }
 
 void
 usage(void)
 {
 	die("usage: %s [-hfdl] [-e etcdir]\n", argv0);
 }
 
 int
 main(int argc, char *argv[])
 {
 	struct sockaddr_nl nls, cnls;
 	struct msghdr hdr;
 	struct iovec iov;
 	char buf[4097], *key, *value, *type, *name, *state,
 	     cbuf[CMSG_SPACE(sizeof(struct ucred))], *subsystem;
 	struct cmsghdr *chdr;
 	struct ucred *cred;
 	struct pollfd fds;
 	int i, len, slen, dodaemonize;
 
 	dodaemonize = 1;
 	memset(lastname, 0, sizeof(lastname));
 	memset(lasttype, 0, sizeof(lasttype));
 
 	ARGBEGIN {
 	case 'f':
 		dodaemonize = 0;
 		break;
 	case 'd':
 		printf("dodebug = 1\n");
 		dodebug = 1;
 		break;
 	case 'l':
 		dolog = 1;
 		break;
 	case 'e':
 		etcdir = EARGF(usage());
 		break;
 	default:
 		usage();
 	} ARGEND;
 
 	memset(&nls, 0, sizeof(nls));
 	nls.nl_family = AF_NETLINK;
 	nls.nl_pid = getpid();
 	nls.nl_groups = -1;
 
 	fds.events = POLLIN;
 	fds.fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
 	listfd = fds.fd;
 	if (fds.fd < 0)
 		edie("socket");
 
 	slen = 128*1024*1024;
 	if (setsockopt(fds.fd, SOL_SOCKET, SO_RCVBUFFORCE, &slen,
 				sizeof(slen)) < 0) {
 		edie("setsockopt");
 	}
 	slen = 1;
 	if (setsockopt(fds.fd, SOL_SOCKET, SO_PASSCRED, &slen,
 				sizeof(slen)) < 0) {
 		edie("setsockopt");
 	}
 
 	if (bind(fds.fd, (void *)&nls, sizeof(nls)))
 		edie("bind");
 
 	if(dodaemonize) {
 		if (daemon(0, 0) < 0)
 			edie("daemon");
 		umask(022);
 	}
 
 	if(dolog)
 		openlog("rfkilld", 0, LOG_DAEMON);
 
 	initsignals();
 
 	while (poll(&fds, 1, -1) > -1) {
 		iov.iov_base = &buf;
 		iov.iov_len = sizeof(buf);
 		memset(&hdr, 0, sizeof(hdr));
 		hdr.msg_iov = &iov;
 		hdr.msg_iovlen = 1;
 		hdr.msg_control = cbuf;
 		hdr.msg_controllen = sizeof(cbuf);
 		hdr.msg_name = &cnls;
 		hdr.msg_namelen = sizeof(cnls);
 
 		len = recvmsg(fds.fd, &hdr, 0);
 		if (len < 0) {
 			if (errno == EINTR)
 				continue;
 			edie("recvmsg");
 		}
 		if (len < 32 || len >= sizeof(buf))
 			continue;
 
 		chdr = CMSG_FIRSTHDR(&hdr);
 		if (chdr == NULL || chdr->cmsg_type != SCM_CREDENTIALS)
 			continue;
 
 		/*
 		 * Don't allow anyone but root to send us messages.
 		 *
 		 * We will allow users to send us messages, when
 		 * udev is enabled. Udev is just a toy you should
 		 * only use for testing.
 		 */
 		cred = (struct ucred *)CMSG_DATA(chdr);
 		if (cred->uid != 0)
 			continue;
 
 		if (!memcmp(buf, "libudev", 8)) {
 			continue;
 		} else {
 			if (cnls.nl_pid > 0)
 				continue;
 		}
 
 		type = NULL;
 		name = NULL;
 		state = NULL;
 		for (i = 0; i < len; i += slen + 1) {
 			key = buf + i;
 			value = strchr(key, '=');
 			slen = strlen(buf+i);
 			if (!slen || value == NULL)
 				continue;
 
 			value[0] = '\0';
 			value++;
 
 			printf("%s = %s\n", key, value);
 			if (!strcmp(key, "SUBSYSTEM"))
 				subsystem = value;
 			if (!strcmp(key, "RFKILL_NAME"))
 				name = value;
 			if (!strcmp(key, "RFKILL_TYPE"))
 				type = value;
 			/*
 			 * 0 -> soft blocked
 			 * 1 -> unblocked
 			 * 2 -> hard blocked
 			 */
 			if (!strcmp(key, "RFKILL_STATE"))
 				state = value;
 		}
 		dbg("name = %s, type = %s, state = %s", name, type,
 				state);
 		if (strcmp(subsystem, "rfkill"))
 			continue;
 
 		if (name != NULL && type != NULL && state != NULL) {
 			if (strcmp(name, lastname) &&
 					strcmp(type, lasttype)) {
 				slen = strlen(name);
 				if (slen > sizeof(lastname)-1)
 					die("name is too large\n");
 				memmove(lastname, name, slen+1);
 
 				slen = strlen(type);
 				if (slen > sizeof(lasttype)-1)
 					die("type is too large\n");
 				memmove(lasttype, type, slen+1);
 
 				runscripts(name, type, state);
 			}
 		}
 	}
 
 	if (dolog)
 		closelog();
 
 	shutdown(listfd, SHUT_RDWR);
 	close(listfd);
 
 	return 0;
 }