Attachment #104257 for bug #158423

View | Details | Raw Unified | Return to bug 158423
Collapse All | Expand All

Lines 505-511 Link Here

(-)lighttpd-1.4.11.orig/src/base.h (-1 / +1 lines)
505		505
506	/* the errorlog */	506	/* the errorlog */
507	int errorlog_fd;	507	int errorlog_fd;
508	enum { ERRORLOG_STDERR, ERRORLOG_FILE, ERRORLOG_SYSLOG } errorlog_mode;	508	enum { ERRORLOG_STDERR, ERRORLOG_FILE, ERRORLOG_SYSLOG, ERRORLOG_PIPE } errorlog_mode;
509	buffer *errorlog_buf;	509	buffer *errorlog_buf;
510		510
511	fdevents ev, ev_ins;	511	fdevents ev, ev_ins;




/** 
 * open the errorlog
 * 
 * we have 4 possibilities:
 * - stderr (default)
 * - syslog 
 * - logfile
 * - pipe
 * 
 * if the open failed, report to the user and die
 * 

		srv->errorlog_mode = ERRORLOG_SYSLOG;
	} else if (!buffer_is_empty(srv->srvconf.errorlog_file)) {
		const char *logfile = srv->srvconf.errorlog_file->ptr;

		if (logfile[0] == '|') {
#ifdef HAVE_FORK
			/* create write pipe and spawn process */

			int to_log_fds[2];
			pid_t pid;

			if (pipe(to_log_fds)) {
				log_error_write(srv, __FILE__, __LINE__, "ss",
				"pipe failed: ", strerror(errno));
				return -1;
			}

			/* fork, execve */
			switch (pid = fork()) {
			case 0:
				/* child */

				close(STDIN_FILENO);
				dup2(to_log_fds[0], STDIN_FILENO);
				close(to_log_fds[0]);
				/* not needed */
				close(to_log_fds[1]);

				/* we don't need the client socket */
				for (fd = 3; fd < 256; fd++) {
					close(fd);
				}

				/* exec the log-process (skip the | )
				 *
				 */

				execl("/bin/sh", "sh", "-c", logfile + 1, NULL);
				
				log_error_write(srv, __FILE__, __LINE__, "sss",
					"spawning log-process failed: ",
					strerror(errno), logfile + 1);

				exit(-1);
				break;
			case -1:
				/* error */
				log_error_write(srv, __FILE__, __LINE__, "ss", "fork failed:", strerror(errno));
				break;
			default:
				close(to_log_fds[0]);

				srv->errorlog_fd = to_log_fds[1];

				break;
			}
			srv->errorlog_mode = ERRORLOG_PIPE;
#else
			log_error_write(srv, __FILE__, __LINE__, "SSS",
				"opening errorlog '", logfile,"' impossible");
			return -1;
#endif
		} else {
			if (-1 == (srv->errorlog_fd = open(logfile, O_APPEND | O_WRONLY | O_CREAT | O_LARGEFILE, 0644))) {
				log_error_write(srv, __FILE__, __LINE__, "SSSS",
  					"opening errorlog '", logfile,
  					"' failed: ", strerror(errno));
  
				return -1;
			}
			srv->errorlog_mode = ERRORLOG_FILE;
  		}
#ifdef FD_CLOEXEC
  		/* close fd on exec (cgi) */
  		fcntl(srv->errorlog_fd, F_SETFD, FD_CLOEXEC);
#endif
  	}
  
	
	log_error_write(srv, __FILE__, __LINE__, "s", "server started");
	
#ifdef HAVE_VALGRIND_VALGRIND_H

 */

int log_error_cycle(server *srv) {
	/* only cycle if the error log is a file */
	
	if (srv->errorlog_mode == ERRORLOG_FILE) {
		const char *logfile = srv->srvconf.errorlog_file->ptr;

	log_error_write(srv, __FILE__, __LINE__, "s", "server stopped");
	
	switch(srv->errorlog_mode) {
	case ERRORLOG_PIPE: /* fall through */
	case ERRORLOG_FILE:
		close(srv->errorlog_fd);
		break;

	va_list ap;
	
	switch(srv->errorlog_mode) {
	case ERRORLOG_PIPE:
	case ERRORLOG_FILE:
	case ERRORLOG_STDERR:
		/* cache the generated timestamp */

	va_end(ap);
	
	switch(srv->errorlog_mode) {
	case ERRORLOG_PIPE: /* fall through */
	case ERRORLOG_FILE:
		BUFFER_APPEND_STRING_CONST(srv->errorlog_buf, "\n");
		write(srv->errorlog_fd, srv->errorlog_buf->ptr, srv->errorlog_buf->used - 1);

Lines 750-756 Link Here

(-)lighttpd-1.4.11.orig/src/mod_cgi.c (-1 / +1 lines)
750	*	750	*
751	* we feed the stderr of the CGI to our errorlog, if possible	751	* we feed the stderr of the CGI to our errorlog, if possible
752	*/	752	*/
753	if (srv->errorlog_mode == ERRORLOG_FILE) {	753	if ((srv->errorlog_mode == ERRORLOG_FILE) \|\| (srv->errorlog_mode == ERRORLOG_PIPE)) {
754	close(STDERR_FILENO);	754	close(STDERR_FILENO);
755	dup2(srv->errorlog_fd, STDERR_FILENO);	755	dup2(srv->errorlog_fd, STDERR_FILENO);
756	}	756	}

Lines 134-140 Link Here

(-)lighttpd-1.4.11.orig/src/mod_rrdtool.c (-1 / +1 lines)
134		134
135	close(STDERR_FILENO);	135	close(STDERR_FILENO);
136		136
137	if (srv->errorlog_mode == ERRORLOG_FILE) {	137	if ((srv->errorlog_mode == ERRORLOG_FILE) \|\| (srv->errorlog_mode == ERRORLOG_PIPE)) {
138	dup2(srv->errorlog_fd, STDERR_FILENO);	138	dup2(srv->errorlog_fd, STDERR_FILENO);
139	close(srv->errorlog_fd);	139	close(srv->errorlog_fd);
140	}	140	}

Return to bug 158423

Lines 34-43 Link Here

(-)lighttpd-1.4.11.orig/src/log.c (-14 / +78 lines)
34	/**	34	/**
35	* open the errorlog	35	* open the errorlog
36	*	36	*
37	* we have 3 possibilities:	37	* we have 4 possibilities:
38	* - stderr (default)	38	* - stderr (default)
39	* - syslog	39	* - syslog
40	* - logfile	40	* - logfile
		41	* - pipe
41	*	42	*
42	* if the open failed, report to the user and die	43	* if the open failed, report to the user and die
43	*	44	*
Lines 57-77 Link Here
57	srv->errorlog_mode = ERRORLOG_SYSLOG;	58	srv->errorlog_mode = ERRORLOG_SYSLOG;
58	} else if (!buffer_is_empty(srv->srvconf.errorlog_file)) {	59	} else if (!buffer_is_empty(srv->srvconf.errorlog_file)) {
59	const char *logfile = srv->srvconf.errorlog_file->ptr;	60	const char *logfile = srv->srvconf.errorlog_file->ptr;
60		61
61	if (-1 == (srv->errorlog_fd = open(logfile, O_APPEND \| O_WRONLY \| O_CREAT \| O_LARGEFILE, 0644))) {	62	if (logfile[0] == '\|') {
62	log_error_write(srv, __FILE__, __LINE__, "SSSS",	63	#ifdef HAVE_FORK
63	"opening errorlog '", logfile,	64	/* create write pipe and spawn process */
64	"' failed: ", strerror(errno));	65
65		66	int to_log_fds[2];
		67	pid_t pid;
		68
		69	if (pipe(to_log_fds)) {
		70	log_error_write(srv, __FILE__, __LINE__, "ss",
		71	"pipe failed: ", strerror(errno));
		72	return -1;
		73	}
		74
		75	/* fork, execve */
		76	switch (pid = fork()) {
		77	case 0:
		78	/* child */
		79
		80	close(STDIN_FILENO);
		81	dup2(to_log_fds[0], STDIN_FILENO);
		82	close(to_log_fds[0]);
		83	/* not needed */
		84	close(to_log_fds[1]);
		85
		86	/* we don't need the client socket */
		87	for (fd = 3; fd < 256; fd++) {
		88	close(fd);
		89	}
		90
		91	/* exec the log-process (skip the \| )
		92	*
		93	*/
		94
		95	execl("/bin/sh", "sh", "-c", logfile + 1, NULL);
		96
		97	log_error_write(srv, __FILE__, __LINE__, "sss",
		98	"spawning log-process failed: ",
		99	strerror(errno), logfile + 1);
		100
		101	exit(-1);
		102	break;
		103	case -1:
		104	/* error */
		105	log_error_write(srv, __FILE__, __LINE__, "ss", "fork failed:", strerror(errno));
		106	break;
		107	default:
		108	close(to_log_fds[0]);
		109
		110	srv->errorlog_fd = to_log_fds[1];
		111
		112	break;
		113	}
		114	srv->errorlog_mode = ERRORLOG_PIPE;
		115	#else
		116	log_error_write(srv, __FILE__, __LINE__, "SSS",
		117	"opening errorlog '", logfile,"' impossible");
66	return -1;	118	return -1;
67	}	119	#endif
		120	} else {
		121	if (-1 == (srv->errorlog_fd = open(logfile, O_APPEND \| O_WRONLY \| O_CREAT \| O_LARGEFILE, 0644))) {
		122	log_error_write(srv, __FILE__, __LINE__, "SSSS",
		123	"opening errorlog '", logfile,
		124	"' failed: ", strerror(errno));
		125
		126	return -1;
		127	}
		128	srv->errorlog_mode = ERRORLOG_FILE;
		129	}
68	#ifdef FD_CLOEXEC	130	#ifdef FD_CLOEXEC
69	/* close fd on exec (cgi) */	131	/* close fd on exec (cgi) */
70	fcntl(srv->errorlog_fd, F_SETFD, FD_CLOEXEC);	132	fcntl(srv->errorlog_fd, F_SETFD, FD_CLOEXEC);
71	#endif	133	#endif
72	srv->errorlog_mode = ERRORLOG_FILE;	134	}
73	}	135
74
75	log_error_write(srv, __FILE__, __LINE__, "s", "server started");	136	log_error_write(srv, __FILE__, __LINE__, "s", "server started");
76		137
77	#ifdef HAVE_VALGRIND_VALGRIND_H	138	#ifdef HAVE_VALGRIND_VALGRIND_H
Lines 99-105 Link Here
99	*/	160	*/
100		161
101	int log_error_cycle(server *srv) {	162	int log_error_cycle(server *srv) {
102	/* only cycle if we are not in syslog-mode */	163	/* only cycle if the error log is a file */
103		164
104	if (srv->errorlog_mode == ERRORLOG_FILE) {	165	if (srv->errorlog_mode == ERRORLOG_FILE) {
105	const char *logfile = srv->srvconf.errorlog_file->ptr;	166	const char *logfile = srv->srvconf.errorlog_file->ptr;
Lines 135-140 Link Here
135	log_error_write(srv, __FILE__, __LINE__, "s", "server stopped");	196	log_error_write(srv, __FILE__, __LINE__, "s", "server stopped");
136		197
137	switch(srv->errorlog_mode) {	198	switch(srv->errorlog_mode) {
		199	case ERRORLOG_PIPE: /* fall through */
138	case ERRORLOG_FILE:	200	case ERRORLOG_FILE:
139	close(srv->errorlog_fd);	201	close(srv->errorlog_fd);
140	break;	202	break;
Lines 154-159 Link Here
154	va_list ap;	216	va_list ap;
155		217
156	switch(srv->errorlog_mode) {	218	switch(srv->errorlog_mode) {
		219	case ERRORLOG_PIPE:
157	case ERRORLOG_FILE:	220	case ERRORLOG_FILE:
158	case ERRORLOG_STDERR:	221	case ERRORLOG_STDERR:
159	/* cache the generated timestamp */	222	/* cache the generated timestamp */
Lines 238-243 Link Here
238	va_end(ap);	301	va_end(ap);
239		302
240	switch(srv->errorlog_mode) {	303	switch(srv->errorlog_mode) {
		304	case ERRORLOG_PIPE: /* fall through */
241	case ERRORLOG_FILE:	305	case ERRORLOG_FILE:
242	BUFFER_APPEND_STRING_CONST(srv->errorlog_buf, "\n");	306	BUFFER_APPEND_STRING_CONST(srv->errorlog_buf, "\n");
243	write(srv->errorlog_fd, srv->errorlog_buf->ptr, srv->errorlog_buf->used - 1);	307	write(srv->errorlog_fd, srv->errorlog_buf->ptr, srv->errorlog_buf->used - 1);