* dump message headers on artv dump

[citadel.git] / citadel / sysdep.c

diff --git a/citadel/sysdep.c b/citadel/sysdep.c
index 1d24919c7ac02c042629948a5701b2ffb664f3a5..182c0df7d1b0795b098eb566d092025ca9d95f53 100644 (file)
--- a/citadel/sysdep.c
+++ b/citadel/sysdep.c
@@ -100,17 +100,37 @@ int enable_syslog = 0;
 
 void DestroyWorkerList(void);
 
+
+/*
+ * Create an interface to lprintf that follows the coding convention.
+ * This is here until such time as we have replaced all calls to lprintf with CtdlLogPrintf
+ */
+ 
+void CtdlLogPrintf(enum LogLevel loglevel, const char *format, ...)
+{
+       va_list arg_ptr;
+       va_start(arg_ptr, format);
+       vlprintf(loglevel, format, arg_ptr);
+       va_end(arg_ptr);
+}
+
+
 /*
  * lprintf()  ...   Write logging information
  */
 void lprintf(enum LogLevel loglevel, const char *format, ...) {   
        va_list arg_ptr;
+       va_start(arg_ptr, format);
+       vlprintf(loglevel, format, arg_ptr);
+       va_end(arg_ptr);
+}
+
+void vlprintf(enum LogLevel loglevel, const char *format, va_list arg_ptr)
+{
        char buf[SIZ], buf2[SIZ];
 
        if (enable_syslog) {
-               va_start(arg_ptr, format);
-                       vsyslog((syslog_facility | loglevel), format, arg_ptr);
-               va_end(arg_ptr);
+               vsyslog((syslog_facility | loglevel), format, arg_ptr);
        }
 
        /* stderr output code */
@@ -140,9 +160,7 @@ void lprintf(enum LogLevel loglevel, const char *format, ...) {
                                tim.tm_mday, tim.tm_hour, tim.tm_min,
                                tim.tm_sec, (long)tv.tv_usec);
                }
-               va_start(arg_ptr, format);   
-                       vsprintf(buf2, format, arg_ptr);   
-               va_end(arg_ptr);   
+               vsprintf(buf2, format, arg_ptr);   
 
                fprintf(stderr, "%s%s", buf, buf2);
                fflush(stderr);
@@ -571,26 +589,28 @@ void client_write(char *buf, int nbytes)
 #ifndef HAVE_TCP_BUFFERING
        int old_buffer_len = 0;
 #endif
-
-       if (CC->redirect_buffer != NULL) {
-               if ((CC->redirect_len + nbytes + 2) >= CC->redirect_alloc) {
-                       CC->redirect_alloc = (CC->redirect_alloc * 2) + nbytes;
-                       CC->redirect_buffer = realloc(CC->redirect_buffer,
-                                               CC->redirect_alloc);
+       t_context *Ctx;
+
+       Ctx = CC;
+       if (Ctx->redirect_buffer != NULL) {
+               if ((Ctx->redirect_len + nbytes + 2) >= Ctx->redirect_alloc) {
+                       Ctx->redirect_alloc = (Ctx->redirect_alloc * 2) + nbytes;
+                       Ctx->redirect_buffer = realloc(Ctx->redirect_buffer,
+                                               Ctx->redirect_alloc);
                }
-               memcpy(&CC->redirect_buffer[CC->redirect_len], buf, nbytes);
-               CC->redirect_len += nbytes;
-               CC->redirect_buffer[CC->redirect_len] = 0;
+               memcpy(&Ctx->redirect_buffer[Ctx->redirect_len], buf, nbytes);
+               Ctx->redirect_len += nbytes;
+               Ctx->redirect_buffer[Ctx->redirect_len] = 0;
                return;
        }
 
 #ifndef HAVE_TCP_BUFFERING
        /* If we're buffering for later, do that now. */
-       if (CC->buffering) {
-               old_buffer_len = CC->buffer_len;
-               CC->buffer_len += nbytes;
-               CC->output_buffer = realloc(CC->output_buffer, CC->buffer_len);
-               memcpy(&CC->output_buffer[old_buffer_len], buf, nbytes);
+       if (Ctx->buffering) {
+               old_buffer_len = Ctx->buffer_len;
+               Ctx->buffer_len += nbytes;
+               Ctx->output_buffer = realloc(Ctx->output_buffer, Ctx->buffer_len);
+               memcpy(&Ctx->output_buffer[old_buffer_len], buf, nbytes);
                return;
        }
 #endif
@@ -598,14 +618,14 @@ void client_write(char *buf, int nbytes)
        /* Ok, at this point we're not buffering.  Go ahead and write. */
 
 #ifdef HAVE_OPENSSL
-       if (CC->redirect_ssl) {
+       if (Ctx->redirect_ssl) {
                client_write_ssl(buf, nbytes);
                return;
        }
 #endif
 
        while (bytes_written < nbytes) {
-               retval = write(CC->client_socket, &buf[bytes_written],
+               retval = write(Ctx->client_socket, &buf[bytes_written],
                        nbytes - bytes_written);
                if (retval < 1) {
                        lprintf(CTDL_ERR,
@@ -613,8 +633,8 @@ void client_write(char *buf, int nbytes)
                                nbytes - bytes_written,
                                strerror(errno), errno);
                        cit_backtrace();
-                       lprintf(CTDL_DEBUG, "Tried to send: %s",  &buf[bytes_written]);
-                       CC->kill_me = 1;
+                       // lprintf(CTDL_DEBUG, "Tried to send: %s",  &buf[bytes_written]);
+                       Ctx->kill_me = 1;
                        return;
                }
                bytes_written = bytes_written + retval;
@@ -651,6 +671,7 @@ int client_read_to(char *buf, int bytes, int timeout)
 {
        int len,rlen;
        fd_set rfds;
+       int fd;
        struct timeval tv;
        int retval;
 
@@ -660,20 +681,21 @@ int client_read_to(char *buf, int bytes, int timeout)
        }
 #endif
        len = 0;
+       fd = CC->client_socket;
        while(len<bytes) {
                FD_ZERO(&rfds);
-               FD_SET(CC->client_socket, &rfds);
+               FD_SET(fd, &rfds);
                tv.tv_sec = timeout;
                tv.tv_usec = 0;
 
-               retval = select( (CC->client_socket)+1, 
-                                       &rfds, NULL, NULL, &tv);
+               retval = select( (fd)+1, 
+                                &rfds, NULL, NULL, &tv);
 
-               if (FD_ISSET(CC->client_socket, &rfds) == 0) {
+               if (FD_ISSET(fd, &rfds) == 0) {
                        return(0);
                }
 
-               rlen = read(CC->client_socket, &buf[len], bytes-len);
+               rlen = read(fd, &buf[len], bytes-len);
                if (rlen<1) {
                        /* The socket has been disconnected! */
                        CC->kill_me = 1;
@@ -721,10 +743,13 @@ int client_getln(char *buf, int bufsize)
        /* Strip the trailing LF, and the trailing CR if present.
         */
        buf[i] = 0;
-       while ( (!IsEmptyStr(buf)) && ((buf[strlen(buf)-1]==10) || (buf[strlen(buf)-1] == 13)) ) {
-               buf[strlen(buf)-1] = 0;
+       while ( (i > 0)
+               && ( (buf[i - 1]==13)
+                    || ( buf[i - 1]==10)) ) {
+               i--;
+               buf[i] = 0;
        }
-       if (retval < 0) safestrncpy(buf, "000", bufsize);
+       if (retval < 0) safestrncpy(&buf[i], "000", bufsize - i);
        return(retval);
 }
 
@@ -854,7 +879,11 @@ void start_daemon(int unused) {
                else {
                        fp = fopen(file_pid_file, "w");
                        if (fp != NULL) {
-                               fprintf(fp, ""F_PID_T"\n", child);
+               /*
+                * NB.. The pid file contains the pid of the actual server.
+                * This is not the pid of the watcher process
+                */
+                               fprintf(fp, ""F_PID_T"\n", current_child);
                                fclose(fp);
                        }
                        waitpid(current_child, &status, 0);