more renaming of logging functions and more documentation of them

4 files changed, 78 insertions, 78 deletions

diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c
index d803c8b..00098ea 100644
--- a/src/daemon/daemon.c
+++ b/src/daemon/daemon.c
@@ -81,7 +81,7 @@ static wolf_error_t close_fd( int fd ) {
 				break;
 	
 			default:
-				LOG( log_EMERG, "Error while closing file descriptor %d: %s (%d)",
+				WOLF_LOG( log_EMERG, "Error while closing file descriptor %d: %s (%d)",
 					fd, strerror( errno ), errno );
 				return WOLF_ERR_INTERNAL;
 		}
@@ -108,11 +108,11 @@ static wolf_error_t daemon_close_all_fds( void ) {
 	
 	nof_files = sysconf( _SC_OPEN_MAX );
 	if( nof_files < 0 ) {
-		LOG( log_EMERG, "Unable to retrieve maximal number of files: %s (%d)",
+		WOLF_LOG( log_EMERG, "Unable to retrieve maximal number of files: %s (%d)",
 			strerror( errno ), errno );
 		return WOLF_ERR_INTERNAL;
 	}
-	LOG( log_DEBUG, "Closing all filedescriptors up to %ld", nof_files );
+	WOLF_LOG( log_DEBUG, "Closing all filedescriptors up to %ld", nof_files );
 
 	for( i = 0; i < nof_files; i++ ) {
 		if( ( i == STDIN_FILENO ) ||
@@ -137,12 +137,12 @@ static wolf_error_t open_null_fd( int must_fd, int flags ) {
 
 	fd = open( "/dev/null", flags );
 	if( fd < 0 ) {
-		LOG( log_EMERG, "Unable to open fd %d as /dev/null: %s (%d)",
+		WOLF_LOG( log_EMERG, "Unable to open fd %d as /dev/null: %s (%d)",
 			must_fd, strerror( errno ), errno );
 		return WOLF_ERR_INTERNAL;
 	}
 	if( fd != must_fd ) {
-		LOG( log_EMERG, "Something is wrong with the file descriptors (expecting %d,got %d)!",
+		WOLF_LOG( log_EMERG, "Something is wrong with the file descriptors (expecting %d,got %d)!",
 			must_fd, fd );
 		return WOLF_ERR_PROGRAMMING;
 	}
@@ -157,10 +157,10 @@ atomar_write_again:
 	res = write( fd, data, data_len );
 	if( res < 0 ) {
 		if( errno == EINTR ) goto atomar_write_again;
-		LOG( log_EMERG, "Error in atomar write to fd %d: %s (%d)",
+		WOLF_LOG( log_EMERG, "Error in atomar write to fd %d: %s (%d)",
 			fd, strerror( errno ), errno );
 	} else if( (size_t)res != data_len ) {
-		LOG( log_EMERG, "Unexpected number of octets %zd in atomar write to fd %d (expected %zd)",
+		WOLF_LOG( log_EMERG, "Unexpected number of octets %zd in atomar write to fd %d (expected %zd)",
 			res, fd, data_len );
 	}
 }
@@ -172,10 +172,10 @@ atomar_read_again:
 	res = read( fd, data, data_len );
 	if( res < 0 ) {
 		if( errno == EINTR ) goto atomar_read_again;
-		LOG( log_EMERG, "Error in atmoar read from fd %d: %s (%d)",
+		WOLF_LOG( log_EMERG, "Error in atmoar read from fd %d: %s (%d)",
 			fd, strerror( errno ), errno );
 	} else if( (size_t)res != data_len ) {
-		LOG( log_EMERG, "Unexpected number of octets %zd in atomar read from fd %d (expected %zd)",
+		WOLF_LOG( log_EMERG, "Unexpected number of octets %zd in atomar read from fd %d (expected %zd)",
 			res, fd, data_len );
 	}
 }
@@ -191,7 +191,7 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	 * error..
 	 */
 	if( getppid( ) == 1 ) {
-		LOG( log_EMERG, "Already running as daemon!" );
+		WOLF_LOG( log_EMERG, "Already running as daemon!" );
 		return( d->error = WOLF_ERR_PROGRAMMING );
 	}
 	
@@ -202,7 +202,7 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	 * we must be root (uid 0 by convention) for that.
 	 */
 	if( geteuid( ) != 0 ) {
-		LOG( log_EMERG, "Unable to start daemon as not root user!" );
+		WOLF_LOG( log_EMERG, "Unable to start daemon as not root user!" );
 		return( d->error = WOLF_ERR_INVALID_STATE );
 	}
 
@@ -227,11 +227,11 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	 * itself back to the grand-parent (exit codes).
 	 */
 	if( pipe( exit_code_pipe ) < 0 ) {
-		LOG( log_EMERG, "Unable to create exit code pipe: %s (%d)",
+		WOLF_LOG( log_EMERG, "Unable to create exit code pipe: %s (%d)",
 			strerror( errno ), errno );
 		return ( d->error = WOLF_ERR_INTERNAL );
 	}
-	LOG( log_DEBUG, "Created exit code pipe (%d,%d)", exit_code_pipe[0], exit_code_pipe[1] );
+	WOLF_LOG( log_DEBUG, "Created exit code pipe (%d,%d)", exit_code_pipe[0], exit_code_pipe[1] );
 
 	/* first fork: make sure we are no longer process group leader.
 	 * So we can get our own process group leader by calling setsid
@@ -239,12 +239,12 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	switch( ( pid = fork( ) ) ) {
 		case -1:
 			/* error */
-			LOG( log_EMERG, "Unable to fork the first time: %s", strerror( errno ) );
+			WOLF_LOG( log_EMERG, "Unable to fork the first time: %s", strerror( errno ) );
 			return ( d->error = WOLF_ERR_INTERNAL );
 		
 		case 0:
 			/* the child becomes the daemon */
-			LOG( log_DEBUG, "First fork reached" );
+			WOLF_LOG( log_DEBUG, "First fork reached" );
 			break;
 			
 		default:
@@ -254,7 +254,7 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 			/* TODO: wait for some time for correct exit
 			 * code from the error pipe
 			 */
-			LOG( log_DEBUG, "Parent after first fork: child is %d", pid );
+			WOLF_LOG( log_DEBUG, "Parent after first fork: child is %d", pid );
 			return ( d->state = TERMINATE_EXIT_CODE );
 	}
 
@@ -262,11 +262,11 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	 * (for termination and cleanup which can only be done as root) 
 	 */
 	if( pipe( daemon_parent_pipe ) < 0 ) {
-		LOG( log_EMERG, "Unable to create parent pipe: %s (%d)",
+		WOLF_LOG( log_EMERG, "Unable to create parent pipe: %s (%d)",
 			strerror( errno ), errno );
 		return ( d->error = WOLF_ERR_INTERNAL );
 	}
-	LOG( log_DEBUG, "Created parent pipe (%d,%d)", daemon_parent_pipe[0], daemon_parent_pipe[1] );
+	WOLF_LOG( log_DEBUG, "Created parent pipe (%d,%d)", daemon_parent_pipe[0], daemon_parent_pipe[1] );
 
 	/* Put the first child in it's own process group and finally detach it
 	 * from its controlling terminal. This ensure we don't get funny
@@ -274,7 +274,7 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	 */
 	if( setsid( ) < 0 ) {
 		/* should actually never fail */
-		LOG( log_EMERG, "Starting new process group session for the parent of the daemon failed: %s", strerror( errno ) );
+		WOLF_LOG( log_EMERG, "Starting new process group session for the parent of the daemon failed: %s", strerror( errno ) );
 		return WOLF_ERR_INTERNAL;
 	}
 
@@ -301,17 +301,17 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	switch( ( pid = fork( ) ) ) {
 		case -1:
 			/* error */
-			LOG( log_EMERG, "Unable to fork the second time: %s", strerror( errno ) );
+			WOLF_LOG( log_EMERG, "Unable to fork the second time: %s", strerror( errno ) );
 			return ( d->error = WOLF_ERR_INTERNAL );
 		
 		case 0:
 			/* the child becomes the daemon */
-			LOG( log_DEBUG, "Second fork reached" );
+			WOLF_LOG( log_DEBUG, "Second fork reached" );
 			break;
 			
 		default:
 			(void)wolf_signal_install_handlers_parent( );
-			LOG( log_DEBUG, "Parent after second fork: child (and daemon) is %d", pid );
+			WOLF_LOG( log_DEBUG, "Parent after second fork: child (and daemon) is %d", pid );
 			return ( d->state = TERMINATE_PARENT );
 	}
 
@@ -327,7 +327,7 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	 */
 	if( setsid( ) < 0 ) {
 		/* should actually never fail */
-		LOG( log_EMERG, "Starting new process group for daemon session failed: %s", strerror( errno ) );
+		WOLF_LOG( log_EMERG, "Starting new process group for daemon session failed: %s", strerror( errno ) );
 		return WOLF_ERR_INTERNAL;
 	}
 		
@@ -340,10 +340,10 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	 *   directory (especially they can't write files there)
 	 */
 	if( chdir( "/" ) < 0 ) {
-		LOG( log_EMERG, "Changing to root diretory failed: %s", strerror( errno ) );
+		WOLF_LOG( log_EMERG, "Changing to root diretory failed: %s", strerror( errno ) );
 		return WOLF_ERR_INTERNAL;
 	}
-	LOG( log_DEBUG, "Changed to root directory /" );
+	WOLF_LOG( log_DEBUG, "Changed to root directory /" );
 	
 	/* Change the umask to 0133 temporarily so we don't have to
 	 * chmod the logfiles, pidfiles later.
@@ -351,12 +351,12 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	 * Create pid files with permissions 0644 (rw-r--r--)
 	 */
 	mode = umask( 0133 );
-	LOG( log_DEBUG, "Switched umask from %04o to %04o", mode, 0133 );
+	WOLF_LOG( log_DEBUG, "Switched umask from %04o to %04o", mode, 0133 );
 	
 	/* check if another daemon is already running, if yes, bail out */
 	if( is_daemon_running( &d->pidfile, &pid, &error ) || ( error != WOLF_OK ) ) {
 		if( error == WOLF_OK ) {
-			LOG( log_EMERG, "Another daemon is already running with pid '%d', can't start!", pid );
+			WOLF_LOG( log_EMERG, "Another daemon is already running with pid '%d', can't start!", pid );
 		}
 		return WOLF_ERR_INTERNAL;
 	}
@@ -392,7 +392,7 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 	 * New files always get the permission 640 (rw-r-----)
 	 */
 	mode = umask( 0137 );
-	LOG( log_DEBUG, "Switched umask from %04o to %04o", mode, 0137 );
+	WOLF_LOG( log_DEBUG, "Switched umask from %04o to %04o", mode, 0137 );
 
 	/* drop permissions to a non-priviledged user now */
 	if( ( d->params.group_name != NULL ) && ( d->params.user_name != NULL ) ) {
@@ -400,9 +400,9 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 		d->groupent = getgrnam( d->params.group_name );
 		if( d->groupent == NULL ) {
 			if( errno == 0 ) {
-				LOG( log_EMERG, "No group '%s' found", d->params.group_name );
+				WOLF_LOG( log_EMERG, "No group '%s' found", d->params.group_name );
 			} else {
-				LOG( log_EMERG, "Unable to retrieve group information for group '%s': %s (%d)",
+				WOLF_LOG( log_EMERG, "Unable to retrieve group information for group '%s': %s (%d)",
 					d->params.group_name, strerror( errno ), errno );
 			}
 			return WOLF_ERR_INTERNAL;
@@ -412,22 +412,22 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 		d->userent = getpwnam( d->params.user_name );
 		if( d->userent == NULL ) {
 			if( errno == 0 ) {
-				LOG( log_EMERG, "No user '%s' found", d->params.user_name );
+				WOLF_LOG( log_EMERG, "No user '%s' found", d->params.user_name );
 			} else {
-				LOG( log_EMERG, "Unable to retrieve user information for user '%s': %s (%d)",
+				WOLF_LOG( log_EMERG, "Unable to retrieve user information for user '%s': %s (%d)",
 					d->params.user_name, strerror( errno ), errno );
 			}
 			return WOLF_ERR_INTERNAL;
 		}
 
 		if( setgid( d->userent->pw_gid ) < 0 ) {
-			LOG( log_EMERG, "Setting unprivileged group failed: %s (%d)",
+			WOLF_LOG( log_EMERG, "Setting unprivileged group failed: %s (%d)",
 				strerror( errno ), errno );
 			return WOLF_ERR_INTERNAL;
 		}
 
 		if( setuid( d->userent->pw_uid ) < 0 ) {
-			LOG( log_EMERG, "Setting unprivileged user failed: %s (%d)",
+			WOLF_LOG( log_EMERG, "Setting unprivileged user failed: %s (%d)",
 				strerror( errno ), errno );
 			return WOLF_ERR_INTERNAL;
 		}
@@ -436,7 +436,7 @@ wolf_error_t wolf_daemon_start( wolf_daemon_p d ) {
 		/* TODO: also check the permissions of the home dir
 		 *       of the unpriviledged user */
 
-		LOG( log_DEBUG, "Switched to user '%s' (%d) and group '%s' (%d)",
+		WOLF_LOG( log_DEBUG, "Switched to user '%s' (%d) and group '%s' (%d)",
 			d->params.user_name, d->userent->pw_uid,
 			d->params.group_name, d->userent->pw_gid );
 	}
@@ -465,7 +465,7 @@ NORETURN void wolf_daemon_exit( wolf_daemon_p d ) {
 	int exit_code;
 	int pid_file_fd;
 
-	LOG( log_DEBUG, "daemon_exit called int state %d (error %d)",
+	WOLF_LOG( log_DEBUG, "daemon_exit called int state %d (error %d)",
 		d->state, d->error );
 
 	switch( d->state ) {
@@ -474,11 +474,11 @@ NORETURN void wolf_daemon_exit( wolf_daemon_p d ) {
 			 * so we can return the correct exit code to
 			 * the calling script or shell
 			 */
-			LOG( log_DEBUG, "Waiting on exit_code pipe for exit code" );
+			WOLF_LOG( log_DEBUG, "Waiting on exit_code pipe for exit code" );
 
 			atomar_read( exit_code_pipe[0], &exit_code, sizeof( int ) );
 
-			LOG( log_DEBUG, "Terminating grand-parent of daemon with code %d (PID: %lu)",
+			WOLF_LOG( log_DEBUG, "Terminating grand-parent of daemon with code %d (PID: %lu)",
 				exit_code, getpid( ) );
 
 			wolf_signal_terminate( );
@@ -494,10 +494,10 @@ NORETURN void wolf_daemon_exit( wolf_daemon_p d ) {
 			 */
 
 			/* wait for termination signal */
-			LOG( log_DEBUG, "Waiting on parent pipe for termination signal" );
+			WOLF_LOG( log_DEBUG, "Waiting on parent pipe for termination signal" );
 
 			atomar_read( daemon_parent_pipe[0], &pid_file_fd, sizeof( int ) );
-			LOG( log_DEBUG, "Parent got termination (pidfile fd: %d).. cleaning up now (PID: %lu)",
+			WOLF_LOG( log_DEBUG, "Parent got termination (pidfile fd: %d).. cleaning up now (PID: %lu)",
 				pid_file_fd, getpid( ) );
 
 			/* we need root permissions for that! */
@@ -506,7 +506,7 @@ NORETURN void wolf_daemon_exit( wolf_daemon_p d ) {
 
 			wolf_signal_terminate( );
 
-			LOG( log_DEBUG, "Terminating parent of daemon pid file fd %d (PID %lu)",
+			WOLF_LOG( log_DEBUG, "Terminating parent of daemon pid file fd %d (PID %lu)",
 				pid_file_fd, getpid( ) );
 
 			/* exit code is irrelevant here.. */
@@ -523,7 +523,7 @@ NORETURN void wolf_daemon_exit( wolf_daemon_p d ) {
 
 			wolf_signal_terminate( );
 
-			LOG( log_DEBUG, "Terminating daemon (PID: %lu)", getpid( ) );
+			WOLF_LOG( log_DEBUG, "Terminating daemon (PID: %lu)", getpid( ) );
 
 			/* exit code is irrelevant here */
 			_exit( EXIT_SUCCESS );
@@ -547,7 +547,7 @@ NORETURN void wolf_daemon_exit( wolf_daemon_p d ) {
 
 			wolf_signal_terminate( );
 
-			LOG( log_DEBUG, "Terminating daemon (PID: %lu)", getpid( ) );
+			WOLF_LOG( log_DEBUG, "Terminating daemon (PID: %lu)", getpid( ) );
 
 			/* exit code is irrelevant here */
 			_exit( EXIT_SUCCESS );
diff --git a/src/daemon/pidfile.c b/src/daemon/pidfile.c
index 0456425..4ffd429 100644
--- a/src/daemon/pidfile.c
+++ b/src/daemon/pidfile.c
@@ -53,12 +53,12 @@ bool is_daemon_running( struct pidfile_t *pidfile, pid_t *pid, wolf_error_t *err
 	if( pidfile->fd < 0 ) {
 		if( errno == ENOENT ) {
 			/* this is good, pid file doesn't exist at all */
-			LOG( log_DEBUG, "No pidfile '%s' found, daemon is not running", pidfile->filename );
+			WOLF_LOG( log_DEBUG, "No pidfile '%s' found, daemon is not running", pidfile->filename );
 			(void)close( pidfile->fd );
 			*error = WOLF_OK;
 			return pidfile->running;
 		} else {
-			LOG( log_EMERG, "Unable to open pidfile '%s' for reading: %s", pidfile->filename, strerror( errno ) );
+			WOLF_LOG( log_EMERG, "Unable to open pidfile '%s' for reading: %s", pidfile->filename, strerror( errno ) );
 			*error = WOLF_ERR_INTERNAL;
 			return pidfile->running;
 		}
@@ -69,12 +69,12 @@ bool is_daemon_running( struct pidfile_t *pidfile, pid_t *pid, wolf_error_t *err
 	if( res < 0 ) {
 		if( errno == EAGAIN ) {
 			/* another process locks the file already */
-			LOG( log_DEBUG, "Another process locks the pidfile, daemon already running" );
+			WOLF_LOG( log_DEBUG, "Another process locks the pidfile, daemon already running" );
 			*error = WOLF_OK;
 			pidfile->locked = true;
 			pidfile->running = true;
 		} else {
-			LOG( log_EMERG, "Unable to lock pidfile '%s': %s", pidfile->filename, strerror( errno ) );
+			WOLF_LOG( log_EMERG, "Unable to lock pidfile '%s': %s", pidfile->filename, strerror( errno ) );
 			(void)close( pidfile->fd );
 			*error = WOLF_ERR_INTERNAL;
 			pidfile->running = false;
@@ -87,7 +87,7 @@ bool is_daemon_running( struct pidfile_t *pidfile, pid_t *pid, wolf_error_t *err
 	/* try to read the pid from the file */
 	bytes_read = read( pidfile->fd, buf, sizeof( buf ) - 1 );
 	if( bytes_read < 0 ) {
-		LOG( log_EMERG, "Unable to read pid from pidfile '%s': %s", pidfile->filename, strerror( errno ) );
+		WOLF_LOG( log_EMERG, "Unable to read pid from pidfile '%s': %s", pidfile->filename, strerror( errno ) );
 		(void)close( pidfile->fd );
 		*error = WOLF_ERR_INTERNAL;
 		return pidfile->running;
@@ -103,12 +103,12 @@ bool is_daemon_running( struct pidfile_t *pidfile, pid_t *pid, wolf_error_t *err
 	    ( end_ptr == NULL ) /* pre-condition for check for '\0'! */ ||
 	    ( end_ptr - buf < 1 ) /* too short */ ||
 	    ( *pid < 2 ) /* too small value */ ) {
-		LOG( log_EMERG, "pidfile '%s' contains invalid data, can't read PID from it!", pidfile->filename );
+		WOLF_LOG( log_EMERG, "pidfile '%s' contains invalid data, can't read PID from it!", pidfile->filename );
 		(void)close( pidfile->fd );
 		*error = WOLF_ERR_INTERNAL;
 		return pidfile->running;
 	}
-	LOG( log_DEBUG, "Found PID '%lu' in pidfile", *pid );
+	WOLF_LOG( log_DEBUG, "Found PID '%lu' in pidfile", *pid );
 	
 	/* the pid is valid, but is there a process with the pid actually running?
 	 * (this handles the case of kill -9!)
@@ -117,18 +117,18 @@ bool is_daemon_running( struct pidfile_t *pidfile, pid_t *pid, wolf_error_t *err
 	if( res < 0 ) {
 		if( errno == ESRCH ) {
 			/* this is fine, process doesn't exist with this PID */
-			LOG( log_EMERG, "Found PID '%lu' in pidfile '%s', but no such process is running. Check and manually delete the pidfile!", *pid, pidfile->filename );
+			WOLF_LOG( log_EMERG, "Found PID '%lu' in pidfile '%s', but no such process is running. Check and manually delete the pidfile!", *pid, pidfile->filename );
 			(void)close( pidfile->fd );
 			*error = WOLF_ERR_INTERNAL;
 			return pidfile->running;
 		} else {
-			LOG( log_EMERG, "Can't check if processor with PID '%lu' is alive: %s", *pid, strerror( errno ) );
+			WOLF_LOG( log_EMERG, "Can't check if processor with PID '%lu' is alive: %s", *pid, strerror( errno ) );
 			(void)close( pidfile->fd );
 			*error = WOLF_ERR_INTERNAL;
 			return pidfile->running;
 		}
 	}
-	LOG( log_DEBUG, "A process with PID '%lu' is already running", *pid );
+	WOLF_LOG( log_DEBUG, "A process with PID '%lu' is already running", *pid );
 
 	/* process successfuly signaled, so a process with this PID exists
 	 * (worst case, we assume, it's the daemon)
@@ -146,7 +146,7 @@ wolf_error_t pidfile_create( struct pidfile_t *pidfile ) {
 	/* create or open pid file with correct permissions */
 	pidfile->fd = open( pidfile->filename, O_CREAT | O_WRONLY | O_EXCL, 0644 );
 	if( pidfile->fd < 0 ) {
-		LOG( log_EMERG, "Unable to open pidfile '%s' for writing: %s", pidfile->filename, strerror( errno ) );
+		WOLF_LOG( log_EMERG, "Unable to open pidfile '%s' for writing: %s", pidfile->filename, strerror( errno ) );
 		return WOLF_ERR_INTERNAL;
 	}
 	
@@ -157,12 +157,12 @@ wolf_error_t pidfile_create( struct pidfile_t *pidfile ) {
 			/* another process locks the file already, this should not happen, maybe a
 			 * race between to daemons started in parallel?
 			 */
-			LOG( log_EMERG, "Unable to lock pidfile '%s' after creation, daemon started in parallel?", pidfile->filename );
+			WOLF_LOG( log_EMERG, "Unable to lock pidfile '%s' after creation, daemon started in parallel?", pidfile->filename );
 			(void)close( pidfile->fd );
 			(void)unlink( pidfile->filename );
 			return WOLF_ERR_INVALID_STATE;
 		} else {
-			LOG( log_EMERG, "Unable to lock pidfile '%s' after creation: %s", pidfile->filename, strerror( errno ) );
+			WOLF_LOG( log_EMERG, "Unable to lock pidfile '%s' after creation: %s", pidfile->filename, strerror( errno ) );
 			(void)close( pidfile->fd );
 			(void)unlink( pidfile->filename );
 			return WOLF_ERR_INTERNAL;
@@ -173,7 +173,7 @@ wolf_error_t pidfile_create( struct pidfile_t *pidfile ) {
 	 * in the pid file
 	 */
 	if( ftruncate( pidfile->fd, (off_t)0 ) < 0 ) {
-		LOG( log_EMERG, "Unable to truncate the pidfile '%s' before writing to it", pidfile->filename, strerror( errno ) );
+		WOLF_LOG( log_EMERG, "Unable to truncate the pidfile '%s' before writing to it", pidfile->filename, strerror( errno ) );
 		(void)close( pidfile->fd );
 		(void)unlink( pidfile->filename );
 		return WOLF_ERR_INTERNAL;
@@ -185,15 +185,15 @@ wolf_error_t pidfile_create( struct pidfile_t *pidfile ) {
 	snprintf( pid_string, 20, "%lu\n", (unsigned long)getpid( ) );
 	bytes_writen = write( pidfile->fd, pid_string, strlen( pid_string ) );
 	if( bytes_writen < 0 ) {
-		LOG( log_EMERG, "Unable to write PID into the pidfile '%s': %s", pidfile->filename, strerror( errno ) );
+		WOLF_LOG( log_EMERG, "Unable to write PID into the pidfile '%s': %s", pidfile->filename, strerror( errno ) );
 		(void)close( pidfile->fd );
 		(void)unlink( pidfile->filename );
 		return WOLF_ERR_INTERNAL;
 	} else if( bytes_writen != (ssize_t)strlen( pid_string ) ) {
 		/* non-atomic write on files with so little data, strange, should never happen! */
-		LOG( log_EMERG, "Non-atomic write failed when storing the PID into the pidfile '%s'", pidfile->filename );
+		WOLF_LOG( log_EMERG, "Non-atomic write failed when storing the PID into the pidfile '%s'", pidfile->filename );
 	}
-	LOG( log_DEBUG, "Stored '%lu' into the pidfile '%s' and locked it", (unsigned long)getpid( ), pidfile->filename );
+	WOLF_LOG( log_DEBUG, "Stored '%lu' into the pidfile '%s' and locked it", (unsigned long)getpid( ), pidfile->filename );
 	
 	pidfile->locked = true;
 	
@@ -203,12 +203,12 @@ wolf_error_t pidfile_create( struct pidfile_t *pidfile ) {
 wolf_error_t pidfile_release( struct pidfile_t *pidfile ) {
 	wolf_error_t error = WOLF_OK;
 
-	LOG( log_DEBUG, "Releasing (unlocking/closing) pidfile '%s' (fd: %d, locked: %d)",
+	WOLF_LOG( log_DEBUG, "Releasing (unlocking/closing) pidfile '%s' (fd: %d, locked: %d)",
 		pidfile->filename, pidfile->fd, pidfile->locked );
 
 	if( pidfile->locked ) {
 		if( lockf( pidfile->fd, F_ULOCK, (off_t)0 ) < 0 ) {
-			LOG( log_ALERT, "Unable to unlock the pidfile '%s': %s (%d)",
+			WOLF_LOG( log_ALERT, "Unable to unlock the pidfile '%s': %s (%d)",
 				pidfile->filename, strerror( errno ), errno );
 			error = WOLF_ERR_INTERNAL;
 		}
@@ -216,7 +216,7 @@ wolf_error_t pidfile_release( struct pidfile_t *pidfile ) {
 	
 	if( pidfile->fd >= 0 ) {
 		if( close( pidfile->fd ) < 0 ) {
-			LOG( log_ALERT, "Unable to close the pidfile '%s': %s (%d)",
+			WOLF_LOG( log_ALERT, "Unable to close the pidfile '%s': %s (%d)",
 				pidfile->filename, strerror( errno ), errno );
 			error = WOLF_ERR_INTERNAL;
 		}
@@ -229,13 +229,13 @@ wolf_error_t pidfile_release( struct pidfile_t *pidfile ) {
 wolf_error_t pidfile_remove( struct pidfile_t *pidfile ) {
 	wolf_error_t error = WOLF_OK;
 
-	LOG( log_DEBUG, "Removing pidfile '%s' (fd: %d, locked: %d, running: %d)",
+	WOLF_LOG( log_DEBUG, "Removing pidfile '%s' (fd: %d, locked: %d, running: %d)",
 		pidfile->filename, pidfile->fd, pidfile->locked, pidfile->running );
 
 
 	/* unconditionally remove the pidfile */
 	if( unlink( pidfile->filename ) < 0 ) {
-		LOG( log_ALERT, "Unable to remove the pidfile '%s': %s (%d)",
+		WOLF_LOG( log_ALERT, "Unable to remove the pidfile '%s': %s (%d)",
 			pidfile->filename, strerror( errno ), errno );
 		error = WOLF_ERR_INTERNAL;
 	}
diff --git a/src/daemon/signals.c b/src/daemon/signals.c
index c80546a..ed9e8c9 100644
--- a/src/daemon/signals.c
+++ b/src/daemon/signals.c
@@ -161,7 +161,7 @@ install_ignore_again:
 
 	if( sigaction( sig, &sa, NULL ) < 0 ) {
 		(void)strerror_r( errno, errbuf, 1024 );
-		LOG( log_CRIT, "Can't ignore signal handler for signal '%s' (%s, %d): %s (errno: %d)",
+		WOLF_LOG( log_CRIT, "Can't ignore signal handler for signal '%s' (%s, %d): %s (errno: %d)",
 			wolf_signal_get_long_name( sig ),
 			wolf_signal_get_short_name( sig ),
 			sig,
@@ -169,7 +169,7 @@ install_ignore_again:
 			errno );
 		return WOLF_ERR_PROGRAMMING;
 	}
-	LOG( log_DEBUG, "Ignoring signal handler for signal '%s' (%s)",
+	WOLF_LOG( log_DEBUG, "Ignoring signal handler for signal '%s' (%s)",
 		wolf_signal_get_long_name( sig ),
 		wolf_signal_get_short_name( sig ) );
 	sig = va_arg( ap, int );
@@ -197,7 +197,7 @@ install_empty_again:
 
 	if( sigaction( sig, &sa, NULL ) < 0 ) {
 		(void)strerror_r( errno, errbuf, 1024 );
-		LOG( log_CRIT, "Can't install empty signal handler for signal '%s' (%s, %d): %s (errno: %d)",
+		WOLF_LOG( log_CRIT, "Can't install empty signal handler for signal '%s' (%s, %d): %s (errno: %d)",
 			wolf_signal_get_long_name( sig ),
 			wolf_signal_get_short_name( sig ),
 			sig,
@@ -205,7 +205,7 @@ install_empty_again:
 			errno );
 		return WOLF_ERR_PROGRAMMING;
 	}
-	LOG( log_DEBUG, "Installed empty signal handler for signal '%s' (%s)",
+	WOLF_LOG( log_DEBUG, "Installed empty signal handler for signal '%s' (%s)",
 		wolf_signal_get_long_name( sig ),
 		wolf_signal_get_short_name( sig ) );
 	sig = va_arg( ap, int );
@@ -223,7 +223,7 @@ static void fatal_handler( int sig ) {
 	(void)sigaction( sig, &sa, NULL );
 	
 	/* log what happened */
-	LOG( log_ALERT, "Got signal '%s' (%s)",
+	WOLF_LOG( log_ALERT, "Got signal '%s' (%s)",
 		wolf_signal_get_long_name( sig ),
 		wolf_signal_get_short_name( sig ) );
 	
@@ -245,7 +245,7 @@ install_func_again:
 
 	if( sigaction( sig, &sa, NULL ) < 0 ) {
 		(void)strerror_r( errno, errbuf, 1024 );
-		LOG( log_CRIT, "Can't install signal handler for signal '%s' (%s, %d): %s (errno: %d)",
+		WOLF_LOG( log_CRIT, "Can't install signal handler for signal '%s' (%s, %d): %s (errno: %d)",
 			wolf_signal_get_long_name( sig ),
 			wolf_signal_get_short_name( sig ),
 			sig,
@@ -253,7 +253,7 @@ install_func_again:
 			errno );
 		return WOLF_ERR_PROGRAMMING;
 	}
-	LOG( log_DEBUG, "Installed signal handler for signal '%s' (%s)",
+	WOLF_LOG( log_DEBUG, "Installed signal handler for signal '%s' (%s)",
 		wolf_signal_get_long_name( sig ),
 		wolf_signal_get_short_name( sig ) );
 	sig = va_arg( ap, int );
@@ -323,11 +323,11 @@ wolf_error_t wolf_signal_initialize( void ) {
 	res = pipe( daemon_signal_pipe );
 	if( res < 0 ) {
 		(void)strerror_r( errno, errbuf, 1024 );
-		LOG( log_EMERG, "Unable to create signal pipe: %s (%d)",
+		WOLF_LOG( log_EMERG, "Unable to create signal pipe: %s (%d)",
 			errbuf, errno );
 		return WOLF_ERR_INTERNAL;
 	}
-	LOG( log_DEBUG, "Created signal pipe (%d,%d)", daemon_signal_pipe[0], daemon_signal_pipe[1] );
+	WOLF_LOG( log_DEBUG, "Created signal pipe (%d,%d)", daemon_signal_pipe[0], daemon_signal_pipe[1] );
 
 	return WOLF_OK;
 }
@@ -370,7 +370,7 @@ signal_select_again:
 			/* gdb no-brainer when pressing Ctrl-C (at least Linux) */
 			if( errno == 514 ) goto signal_select_again;
 			(void)strerror_r( errno, errbuf, 1024 );
-			LOG( log_EMERG, "Error in select when waiting for signal from pipe: %s (%d)",
+			WOLF_LOG( log_EMERG, "Error in select when waiting for signal from pipe: %s (%d)",
 				errbuf, errno );
 			*error = WOLF_ERR_INTERNAL;
 			return -1;
@@ -383,13 +383,13 @@ signal_select_again:
 
 		case -1: /* error */
 			(void)strerror_r( errno, errbuf, 1024 );
-			LOG( log_EMERG, "Error while reading a signal from the pipe: %s (%d)",
+			WOLF_LOG( log_EMERG, "Error while reading a signal from the pipe: %s (%d)",
 				errbuf, errno );
 			*error = WOLF_ERR_INTERNAL;
 			return -1;
 
 		default: /* unexpected result on atomic read */
-			LOG( log_EMERG, "Unexpected error in read: result is %d", res );
+			WOLF_LOG( log_EMERG, "Unexpected error in read: result is %d", res );
 			*error = WOLF_ERR_PROGRAMMING;
 			return -1;
 	}
diff --git a/src/log.c b/src/log.c
index 40d323f..e43597d 100644
--- a/src/log.c
+++ b/src/log.c
@@ -193,7 +193,7 @@ void wolf_log_reopenlogtosyslog( void ) {
 	setlogmask( LOG_UPTO( syslog_level ) );
 }
 
-void LOG( int level, const char *format, ... ) {
+void WOLF_LOG( int level, const char *format, ... ) {
 	va_list ap;
 	char s[1024];
 	va_start( ap, format );