X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=sysklogd%2Fsyslogd.c;h=38ea3d7ff2e4177907cc94b0c8b2dca0d167468e;hb=a09a42cd83a0365b5b52dfdcce20b3c9932be801;hp=6ecbd16f018c17498fbda581f365da5ae2d4de2f;hpb=5f1b149d541ebba7cab841cb647f113248f9fb8f;p=oweals%2Fbusybox.git

diff --git a/sysklogd/syslogd.c b/sysklogd/syslogd.c
index 6ecbd16f0..38ea3d7ff 100644
--- a/sysklogd/syslogd.c
+++ b/sysklogd/syslogd.c
@@ -13,15 +13,16 @@
  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
  */
 
+/*
+ * Done in syslogd_and_logger.c:
 #include "libbb.h"
+#define SYSLOG_NAMES
+#define SYSLOG_NAMES_CONST
+#include <syslog.h>
+*/
+
 #include <paths.h>
 #include <sys/un.h>
-
-/* SYSLOG_NAMES defined to pull prioritynames[] and facilitynames[]
- * from syslog.h. Grrrr - glibc puts those in _rwdata_! :( */
-#define SYSLOG_NAMES
-#define SYSLOG_NAMES_CONST /* uclibc is saner :) */
-#include <sys/syslog.h>
 #include <sys/uio.h>
 
 #if ENABLE_FEATURE_REMOTE_LOG
@@ -42,7 +43,10 @@
  * (semaphores are down but do_mark routine tries to down them again) */
 #undef SYSLOGD_MARK
 
-enum { MAX_READ = 256 };
+enum {
+	MAX_READ = 256,
+	DNS_WAIT_SEC = 2 * 60,
+};
 
 /* Semaphore operation structures */
 struct shbuf_ds {
@@ -86,15 +90,21 @@ struct init_globals {
 
 struct globals {
 	GLOBALS
+
+#if ENABLE_FEATURE_REMOTE_LOG
+	unsigned last_dns_resolve;
+	char *remoteAddrStr;
+#endif
+
 #if ENABLE_FEATURE_IPC_SYSLOG
 	struct shbuf_ds *shbuf;
 #endif
 	time_t last_log_time;
-	/* localhost's name */
-	char localHostName[64];
+	/* localhost's name. We print only first 64 chars */
+	char *hostname;
 
 	/* We recv into recvbuf... */
-	char recvbuf[MAX_READ];
+	char recvbuf[MAX_READ * (1 + ENABLE_FEATURE_SYSLOGD_DUP)];
 	/* ...then copy to parsebuf, escaping control chars */
 	/* (can grow x2 max) */
 	char parsebuf[MAX_READ*2];
@@ -128,6 +138,9 @@ static const struct init_globals init_data = {
 };
 
 #define G (*ptr_to_globals)
+#define INIT_G() do { \
+	SET_PTR_TO_GLOBALS(memcpy(xzalloc(sizeof(G)), &init_data, sizeof(init_data))); \
+} while (0)
 
 
 /* Options */
@@ -140,8 +153,9 @@ enum {
 	USE_FEATURE_ROTATE_LOGFILE(OPTBIT_filesize   ,)	// -s
 	USE_FEATURE_ROTATE_LOGFILE(OPTBIT_rotatecnt  ,)	// -b
 	USE_FEATURE_REMOTE_LOG(    OPTBIT_remote     ,)	// -R
-	USE_FEATURE_REMOTE_LOG(    OPTBIT_localtoo   ,)	// -L
+	USE_FEATURE_REMOTE_LOG(    OPTBIT_locallog   ,)	// -L
 	USE_FEATURE_IPC_SYSLOG(    OPTBIT_circularlog,)	// -C
+	USE_FEATURE_SYSLOGD_DUP(   OPTBIT_dup        ,)	// -D
 
 	OPT_mark        = 1 << OPTBIT_mark    ,
 	OPT_nofork      = 1 << OPTBIT_nofork  ,
@@ -151,24 +165,25 @@ enum {
 	OPT_filesize    = USE_FEATURE_ROTATE_LOGFILE((1 << OPTBIT_filesize   )) + 0,
 	OPT_rotatecnt   = USE_FEATURE_ROTATE_LOGFILE((1 << OPTBIT_rotatecnt  )) + 0,
 	OPT_remotelog   = USE_FEATURE_REMOTE_LOG(    (1 << OPTBIT_remote     )) + 0,
-	OPT_locallog    = USE_FEATURE_REMOTE_LOG(    (1 << OPTBIT_localtoo   )) + 0,
+	OPT_locallog    = USE_FEATURE_REMOTE_LOG(    (1 << OPTBIT_locallog   )) + 0,
 	OPT_circularlog = USE_FEATURE_IPC_SYSLOG(    (1 << OPTBIT_circularlog)) + 0,
+	OPT_dup         = USE_FEATURE_SYSLOGD_DUP(   (1 << OPTBIT_dup        )) + 0,
 };
 #define OPTION_STR "m:nO:l:S" \
 	USE_FEATURE_ROTATE_LOGFILE("s:" ) \
 	USE_FEATURE_ROTATE_LOGFILE("b:" ) \
 	USE_FEATURE_REMOTE_LOG(    "R:" ) \
 	USE_FEATURE_REMOTE_LOG(    "L"  ) \
-	USE_FEATURE_IPC_SYSLOG(    "C::")
+	USE_FEATURE_IPC_SYSLOG(    "C::") \
+	USE_FEATURE_SYSLOGD_DUP(   "D"  )
 #define OPTION_DECL *opt_m, *opt_l \
 	USE_FEATURE_ROTATE_LOGFILE(,*opt_s) \
 	USE_FEATURE_ROTATE_LOGFILE(,*opt_b) \
-	USE_FEATURE_REMOTE_LOG(    ,*opt_R) \
 	USE_FEATURE_IPC_SYSLOG(    ,*opt_C = NULL)
 #define OPTION_PARAM &opt_m, &G.logFilePath, &opt_l \
 	USE_FEATURE_ROTATE_LOGFILE(,&opt_s) \
 	USE_FEATURE_ROTATE_LOGFILE(,&opt_b) \
-	USE_FEATURE_REMOTE_LOG(    ,&opt_R) \
+	USE_FEATURE_REMOTE_LOG(    ,&G.remoteAddrStr) \
 	USE_FEATURE_IPC_SYSLOG(    ,&opt_C)
 
 
@@ -180,8 +195,8 @@ enum {
 #error Please check CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE
 #endif
 
-/* our shared key */
-#define KEY_ID ((long)0x414e4547) /* "GENA" */
+/* our shared key (syslogd.c and logread.c must be in sync) */
+enum { KEY_ID = 0x414e4547 }; /* "GENA" */
 
 static void ipcsyslog_cleanup(void)
 {
@@ -199,15 +214,15 @@ static void ipcsyslog_cleanup(void)
 static void ipcsyslog_init(void)
 {
 	if (DEBUG)
-		printf("shmget(%lx, %d,...)\n", KEY_ID, G.shm_size);
+		printf("shmget(%x, %d,...)\n", (int)KEY_ID, G.shm_size);
 
-	G.shmid = shmget(KEY_ID, G.shm_size, IPC_CREAT | 1023);
+	G.shmid = shmget(KEY_ID, G.shm_size, IPC_CREAT | 0644);
 	if (G.shmid == -1) {
 		bb_perror_msg_and_die("shmget");
 	}
 
 	G.shbuf = shmat(G.shmid, NULL, 0);
-	if (!G.shbuf) {
+	if (G.shbuf == (void*) -1L) { /* shmat has bizarre error return */
 		bb_perror_msg_and_die("shmat");
 	}
 
@@ -274,7 +289,7 @@ void log_to_shmem(const char *msg);
 
 
 /* Print a message to the log file. */
-static void log_locally(char *msg)
+static void log_locally(time_t now, char *msg)
 {
 	struct flock fl;
 	int len = strlen(msg);
@@ -286,10 +301,10 @@ static void log_locally(char *msg)
 	}
 #endif
 	if (G.logFD >= 0) {
-		time_t cur;
-		time(&cur);
-		if (G.last_log_time != cur) {
-			G.last_log_time = cur; /* reopen log file every second */
+		if (!now)
+			now = time(NULL);
+		if (G.last_log_time != now) {
+			G.last_log_time = now; /* reopen log file every second */
 			close(G.logFD);
 			goto reopen;
 		}
@@ -299,7 +314,7 @@ static void log_locally(char *msg)
 					| O_NOCTTY | O_APPEND | O_NONBLOCK);
 		if (G.logFD < 0) {
 			/* cannot open logfile? - print to /dev/console then */
-			int fd = device_open(_PATH_CONSOLE, O_WRONLY | O_NOCTTY | O_NONBLOCK);
+			int fd = device_open(DEV_CONSOLE, O_WRONLY | O_NOCTTY | O_NONBLOCK);
 			if (fd < 0)
 				fd = 2; /* then stderr, dammit */
 			full_write(fd, msg, len);
@@ -335,6 +350,7 @@ static void log_locally(char *msg)
 				sprintf(newFile, "%s.%d", G.logFilePath, i);
 				if (i == 0) break;
 				sprintf(oldFile, "%s.%d", G.logFilePath, --i);
+				/* ignore errors - file might be missing */
 				rename(oldFile, newFile);
 			}
 			/* newFile == "f.0" now */
@@ -348,7 +364,7 @@ static void log_locally(char *msg)
 	}
 	G.curFileSize +=
 #endif
-	                full_write(G.logFD, msg, len);
+			full_write(G.logFD, msg, len);
 	fl.l_type = F_UNLCK;
 	fcntl(G.logFD, F_SETLKW, &fl);
 }
@@ -361,13 +377,15 @@ static void parse_fac_prio_20(int pri, char *res20)
 		c_fac = facilitynames;
 		while (c_fac->c_name) {
 			if (c_fac->c_val != (LOG_FAC(pri) << 3)) {
-				c_fac++; continue;
+				c_fac++;
+				continue;
 			}
 			/* facility is found, look for prio */
 			c_pri = prioritynames;
 			while (c_pri->c_name) {
 				if (c_pri->c_val != LOG_PRI(pri)) {
-					c_pri++; continue;
+					c_pri++;
+					continue;
 				}
 				snprintf(res20, 20, "%s.%s",
 						c_fac->c_name, c_pri->c_name);
@@ -381,39 +399,47 @@ static void parse_fac_prio_20(int pri, char *res20)
 }
 
 /* len parameter is used only for "is there a timestamp?" check.
- * NB: some callers cheat and supply 0 when they know
- * that there is no timestamp, short-cutting the test. */
+ * NB: some callers cheat and supply len==0 when they know
+ * that there is no timestamp, short-circuiting the test. */
 static void timestamp_and_log(int pri, char *msg, int len)
 {
 	char *timestamp;
+	time_t now;
 
 	if (len < 16 || msg[3] != ' ' || msg[6] != ' '
 	 || msg[9] != ':' || msg[12] != ':' || msg[15] != ' '
 	) {
-		time_t now;
 		time(&now);
-		timestamp = ctime(&now) + 4;
+		timestamp = ctime(&now) + 4; /* skip day of week */
 	} else {
+		now = 0;
 		timestamp = msg;
 		msg += 16;
 	}
 	timestamp[15] = '\0';
 
-	/* Log message locally (to file or shared mem) */
-	if (!ENABLE_FEATURE_REMOTE_LOG || (option_mask32 & OPT_locallog)) {
-		if (LOG_PRI(pri) < G.logLevel) {
-			if (option_mask32 & OPT_small)
-				sprintf(G.printbuf, "%s %s\n", timestamp, msg);
-			else {
-				char res[20];
-				parse_fac_prio_20(pri, res);
-				sprintf(G.printbuf, "%s %s %s %s\n", timestamp, G.localHostName, res, msg);
-			}
-			log_locally(G.printbuf);
-		}
+	if (option_mask32 & OPT_small)
+		sprintf(G.printbuf, "%s %s\n", timestamp, msg);
+	else {
+		char res[20];
+		parse_fac_prio_20(pri, res);
+		sprintf(G.printbuf, "%s %.64s %s %s\n", timestamp, G.hostname, res, msg);
 	}
+
+	/* Log message locally (to file or shared mem) */
+	log_locally(now, G.printbuf);
 }
 
+static void timestamp_and_log_internal(const char *msg)
+{
+	if (ENABLE_FEATURE_REMOTE_LOG && !(option_mask32 & OPT_locallog))
+		return;
+	timestamp_and_log(LOG_SYSLOG | LOG_INFO, (char*)msg, 0);
+}
+
+/* tmpbuf[len] is a NUL byte (set by caller), but there can be other,
+ * embedded NULs. Split messages on each of these NULs, parse prio,
+ * escape control chars and log each locally. */
 static void split_escape_and_log(char *tmpbuf, int len)
 {
 	char *p = tmpbuf;
@@ -427,10 +453,10 @@ static void split_escape_and_log(char *tmpbuf, int len)
 		if (*p == '<') {
 			/* Parse the magic priority number */
 			pri = bb_strtou(p + 1, &p, 10);
-			if (*p == '>') p++;
-			if (pri & ~(LOG_FACMASK | LOG_PRIMASK)) {
+			if (*p == '>')
+				p++;
+			if (pri & ~(LOG_FACMASK | LOG_PRIMASK))
 				pri = (LOG_USER | LOG_NOTICE);
-			}
 		}
 
 		while ((c = *p++)) {
@@ -443,137 +469,187 @@ static void split_escape_and_log(char *tmpbuf, int len)
 			*q++ = c;
 		}
 		*q = '\0';
+
 		/* Now log it */
-		timestamp_and_log(pri, G.parsebuf, q - G.parsebuf);
+		if (LOG_PRI(pri) < G.logLevel)
+			timestamp_and_log(pri, G.parsebuf, q - G.parsebuf);
 	}
 }
 
 static void quit_signal(int sig)
 {
-	timestamp_and_log(LOG_SYSLOG | LOG_INFO, (char*)"syslogd exiting", 0);
+	timestamp_and_log_internal("syslogd exiting");
 	puts("syslogd exiting");
 	if (ENABLE_FEATURE_IPC_SYSLOG)
 		ipcsyslog_cleanup();
-	exit(1);
+	kill_myself_with_sig(sig);
 }
 
 #ifdef SYSLOGD_MARK
 static void do_mark(int sig)
 {
 	if (G.markInterval) {
-		timestamp_and_log(LOG_SYSLOG | LOG_INFO, (char*)"-- MARK --", 0);
+		timestamp_and_log_internal("-- MARK --");
 		alarm(G.markInterval);
 	}
 }
 #endif
 
-static void do_syslogd(void) ATTRIBUTE_NORETURN;
-static void do_syslogd(void)
+/* Don't inline: prevent struct sockaddr_un to take up space on stack
+ * permanently */
+static NOINLINE int create_socket(void)
 {
 	struct sockaddr_un sunx;
 	int sock_fd;
-	fd_set fds;
 	char *dev_log_name;
 
-	/* Set up signal handlers */
-	signal(SIGINT, quit_signal);
-	signal(SIGTERM, quit_signal);
-	signal(SIGQUIT, quit_signal);
-	signal(SIGHUP, SIG_IGN);
-	signal(SIGCHLD, SIG_IGN);
-#ifdef SIGCLD
-	signal(SIGCLD, SIG_IGN);
-#endif
-#ifdef SYSLOGD_MARK
-	signal(SIGALRM, do_mark);
-	alarm(G.markInterval);
-#endif
-	remove_pidfile("/var/run/syslogd.pid");
-
 	memset(&sunx, 0, sizeof(sunx));
 	sunx.sun_family = AF_UNIX;
-	strcpy(sunx.sun_path, "/dev/log");
 
 	/* Unlink old /dev/log or object it points to. */
 	/* (if it exists, bind will fail) */
-	logmode = LOGMODE_NONE;
-	dev_log_name = xmalloc_readlink_or_warn("/dev/log");
-	logmode = LOGMODE_STDIO;
+	strcpy(sunx.sun_path, "/dev/log");
+	dev_log_name = xmalloc_follow_symlinks("/dev/log");
 	if (dev_log_name) {
-		int fd = xopen(".", O_NONBLOCK);
-		xchdir("/dev");
-		/* we do not check whether this is a link also */
-		unlink(dev_log_name);
-		fchdir(fd);
-		close(fd);
 		safe_strncpy(sunx.sun_path, dev_log_name, sizeof(sunx.sun_path));
 		free(dev_log_name);
-	} else {
-		unlink("/dev/log");
 	}
+	unlink(sunx.sun_path);
 
 	sock_fd = xsocket(AF_UNIX, SOCK_DGRAM, 0);
 	xbind(sock_fd, (struct sockaddr *) &sunx, sizeof(sunx));
+	chmod("/dev/log", 0666);
+
+	return sock_fd;
+}
 
-	if (chmod("/dev/log", 0666) < 0) {
-		bb_perror_msg_and_die("cannot set permission on /dev/log");
+#if ENABLE_FEATURE_REMOTE_LOG
+static int try_to_resolve_remote(void)
+{
+	if (!G.remoteAddr) {
+		unsigned now = monotonic_sec();
+
+		/* Don't resolve name too often - DNS timeouts can be big */
+		if ((now - G.last_dns_resolve) < DNS_WAIT_SEC)
+			return -1;
+		G.last_dns_resolve = now;
+		G.remoteAddr = host2sockaddr(G.remoteAddrStr, 514);
+		if (!G.remoteAddr)
+			return -1;
 	}
+	return socket(G.remoteAddr->u.sa.sa_family, SOCK_DGRAM, 0);
+}
+#endif
+
+static void do_syslogd(void) NORETURN;
+static void do_syslogd(void)
+{
+	int sock_fd;
+#if ENABLE_FEATURE_SYSLOGD_DUP
+	int last_sz = -1;
+	char *last_buf;
+	char *recvbuf = G.recvbuf;
+#else
+#define recvbuf (G.recvbuf)
+#endif
+
+	/* Set up signal handlers */
+	bb_signals(0
+		+ (1 << SIGINT)
+		+ (1 << SIGTERM)
+		+ (1 << SIGQUIT)
+		, quit_signal);
+	signal(SIGHUP, SIG_IGN);
+	/* signal(SIGCHLD, SIG_IGN); - why? */
+#ifdef SYSLOGD_MARK
+	signal(SIGALRM, do_mark);
+	alarm(G.markInterval);
+#endif
+	sock_fd = create_socket();
+
 	if (ENABLE_FEATURE_IPC_SYSLOG && (option_mask32 & OPT_circularlog)) {
 		ipcsyslog_init();
 	}
 
-	timestamp_and_log(LOG_SYSLOG | LOG_INFO,
-			(char*)"syslogd started: BusyBox v" BB_VER, 0);
+	timestamp_and_log_internal("syslogd started: BusyBox v" BB_VER);
 
 	for (;;) {
-		FD_ZERO(&fds);
-		FD_SET(sock_fd, &fds);
-
-		if (select(sock_fd + 1, &fds, NULL, NULL, NULL) < 0) {
-			if (errno == EINTR) {
-				/* alarm may have happened */
-				continue;
-			}
-			bb_perror_msg_and_die("select");
+		ssize_t sz;
+
+#if ENABLE_FEATURE_SYSLOGD_DUP
+		last_buf = recvbuf;
+		if (recvbuf == G.recvbuf)
+			recvbuf = G.recvbuf + MAX_READ;
+		else
+			recvbuf = G.recvbuf;
+#endif
+ read_again:
+		sz = safe_read(sock_fd, recvbuf, MAX_READ - 1);
+		if (sz < 0)
+			bb_perror_msg_and_die("read from /dev/log");
+
+		/* Drop trailing '\n' and NULs (typically there is one NUL) */
+		while (1) {
+			if (sz == 0)
+				goto read_again;
+			/* man 3 syslog says: "A trailing newline is added when needed".
+			 * However, neither glibc nor uclibc do this:
+			 * syslog(prio, "test")   sends "test\0" to /dev/log,
+			 * syslog(prio, "test\n") sends "test\n\0".
+			 * IOW: newline is passed verbatim!
+			 * I take it to mean that it's syslogd's job
+			 * to make those look identical in the log files. */
+			if (recvbuf[sz-1] != '\0' && recvbuf[sz-1] != '\n')
+				break;
+			sz--;
 		}
-
-		if (FD_ISSET(sock_fd, &fds)) {
-			int i;
-			i = recv(sock_fd, G.recvbuf, MAX_READ - 1, 0);
-			if (i <= 0)
-				bb_perror_msg_and_die("UNIX socket error");
-			/* TODO: maybe suppress duplicates? */
+#if ENABLE_FEATURE_SYSLOGD_DUP
+		if ((option_mask32 & OPT_dup) && (sz == last_sz))
+			if (memcmp(last_buf, recvbuf, sz) == 0)
+				continue;
+		last_sz = sz;
+#endif
 #if ENABLE_FEATURE_REMOTE_LOG
-			/* We are not modifying log messages in any way before send */
-			/* Remote site cannot trust _us_ anyway and need to do validation again */
-			if (G.remoteAddr) {
-				if (-1 == G.remoteFD) {
-					G.remoteFD = socket(G.remoteAddr->sa.sa_family, SOCK_DGRAM, 0);
-				}
-				if (-1 != G.remoteFD) {
-					/* send message to remote logger, ignore possible error */
-					sendto(G.remoteFD, G.recvbuf, i, MSG_DONTWAIT,
-						&G.remoteAddr->sa, G.remoteAddr->len);
-				}
+		/* We are not modifying log messages in any way before send */
+		/* Remote site cannot trust _us_ anyway and need to do validation again */
+		if (G.remoteAddrStr) {
+			if (-1 == G.remoteFD) {
+				G.remoteFD = try_to_resolve_remote();
+				if (-1 == G.remoteFD)
+					goto no_luck;
 			}
+			/* Stock syslogd sends it '\n'-terminated
+			 * over network, mimic that */
+			recvbuf[sz] = '\n';
+			/* send message to remote logger, ignore possible error */
+			/* TODO: on some errors, close and set G.remoteFD to -1
+			 * so that DNS resolution and connect is retried? */
+			sendto(G.remoteFD, recvbuf, sz+1, MSG_DONTWAIT,
+				    &G.remoteAddr->u.sa, G.remoteAddr->len);
+ no_luck: ;
+		}
 #endif
-			G.recvbuf[i] = '\0';
-			split_escape_and_log(G.recvbuf, i);
-		} /* FD_ISSET() */
-	} /* for */
+		if (!ENABLE_FEATURE_REMOTE_LOG || (option_mask32 & OPT_locallog)) {
+			recvbuf[sz] = '\0'; /* ensure it *is* NUL terminated */
+			split_escape_and_log(recvbuf, sz);
+		}
+	} /* for (;;) */
+#undef recvbuf
 }
 
-int syslogd_main(int argc, char **argv);
-int syslogd_main(int argc, char **argv)
+int syslogd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int syslogd_main(int argc UNUSED_PARAM, char **argv)
 {
 	char OPTION_DECL;
-	char *p;
 
-	PTR_TO_GLOBALS = memcpy(xzalloc(sizeof(G)), &init_data, sizeof(init_data));
+	INIT_G();
+#if ENABLE_FEATURE_REMOTE_LOG
+	G.last_dns_resolve = monotonic_sec() - DNS_WAIT_SEC - 1;
+#endif
 
 	/* do normal option parsing */
 	opt_complementary = "=0"; /* no non-option params */
-	getopt32(argc, argv, OPTION_STR, OPTION_PARAM);
+	getopt32(argv, OPTION_STR, OPTION_PARAM);
 #ifdef SYSLOGD_MARK
 	if (option_mask32 & OPT_mark) // -m
 		G.markInterval = xatou_range(opt_m, 0, INT_MAX/60) * 60;
@@ -589,12 +665,6 @@ int syslogd_main(int argc, char **argv)
 	if (option_mask32 & OPT_rotatecnt) // -b
 		G.logFileRotate = xatou_range(opt_b, 0, 99);
 #endif
-#if ENABLE_FEATURE_REMOTE_LOG
-	if (option_mask32 & OPT_remotelog) { // -R
-		G.remoteAddr = xhost2sockaddr(opt_R, 514);
-	}
-	//if (option_mask32 & OPT_locallog) // -L
-#endif
 #if ENABLE_FEATURE_IPC_SYSLOG
 	if (opt_C) // -Cn
 		G.shm_size = xatoul_range(opt_C, 4, INT_MAX/1024) * 1024;
@@ -605,11 +675,8 @@ int syslogd_main(int argc, char **argv)
 		option_mask32 |= OPT_locallog;
 
 	/* Store away localhost's name before the fork */
-	gethostname(G.localHostName, sizeof(G.localHostName));
-	p = strchr(G.localHostName, '.');
-	if (p) {
-		*p = '\0';
-	}
+	G.hostname = safe_gethostname();
+	*strchrnul(G.hostname, '.') = '\0';
 
 	if (!(option_mask32 & OPT_nofork)) {
 		bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv);
@@ -619,3 +686,11 @@ int syslogd_main(int argc, char **argv)
 	do_syslogd();
 	/* return EXIT_SUCCESS; */
 }
+
+/* Clean up. Needed because we are included from syslogd_and_logger.c */
+#undef G
+#undef GLOBALS
+#undef INIT_G
+#undef OPTION_STR
+#undef OPTION_DECL
+#undef OPTION_PARAM