logfile.c

Go to the documentation of this file.

#include "config.h"
#include "logfile.h"

#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <syslog.h>
#include <libintl.h>

#include "output.h"
#include "len.h"

#ifndef TMP_LOGFILE_TEMPLATE
#  define TMP_LOGFILE_TEMPLATE "logfile.XXXXXX"
#endif

#ifdef P_tmpdir
#  define TMPDIR P_tmpdir
#else
#  define TMPDIR "/tmp"
#endif

static char *_logfile_tmplog;

FILE *mk_temp_logfile(void)
{
        if(_logfile_tmplog == NULL)
        {
                char *name = malloc(str_len(TMPDIR) + str_len(TMP_LOGFILE_TEMPLATE) + 2);
                char *ptr = name + str_len(TMPDIR);

                strcpy(name, TMPDIR);
                ptr[0] = '/';
                strcpy(++ptr, TMP_LOGFILE_TEMPLATE);

                int fd = mkstemp(name);
                if(fd == -1)
                {
                        error(_("cannot create temporary log file '%s': %s"), name, strerror(errno));
                        free(name);
                        return NULL;
                }
                FILE *fp = fdopen(fd, "w");
                if(fp != NULL)
                {
                        _logfile_tmplog = name;
                        return fp;
                }
                error(_("cannot create temporary log file '%s': %s"), name, strerror(errno));
                close(fd);
        }
        return NULL;
}

void remove_temp_logfile(FILE **tmplogfp)
{
        if(*tmplogfp != NULL && _logfile_tmplog != NULL)
        {
                fflush(*tmplogfp);
                close_logfile(tmplogfp);
                if(remove(_logfile_tmplog) != 0)
                {
                        output(LOG_WARNING, _("cannot remove temporary log file '%s': %s"), _logfile_tmplog, strerror(errno));
                }
                free(_logfile_tmplog);
                _logfile_tmplog = NULL;
        }
        return;
}

FILE *mk_logfile(FILE *tmplogfp, const char *file)
{
        FILE *fp = NULL;
        FILE *destfp = fopen(file, "w");
        if(destfp == NULL)
        {
                error(_("cannot create log file '%s': %s"), file, strerror(errno));
                return NULL;
        }
        
        if(tmplogfp != NULL && _logfile_tmplog != NULL)
        {
                fflush(tmplogfp);
                FILE *srcfp = fopen(_logfile_tmplog, "r");

                size_t size = 512;
                size_t read = 0;
                size_t write = 0;

                flockfile(srcfp);
                flockfile(destfp);

                char *buf = (char *)malloc(size);
                while(feof(srcfp) == 0)
                {
                        read = fread_unlocked(buf, 1, size, srcfp);
                        if(read != size && ferror(srcfp) != 0) /* if this is, these are the last blocks read, then all the output until freopen will not be logged. */
                        {
                                error(_("cannot copy log file: %s"), strerror(errno));
                                return NULL;
                        }

                        write = fwrite_unlocked(buf, 1, read, destfp);
                        if(write != read)
                        {
                                error(_("number of bytes read and written are not the same, while coping logfile"));
                                debug(_("bytes read: %d; bytes written: %d"), (int)read, (int)write);
                                return NULL;
                        }
                }
                fflush(destfp);
                funlockfile(srcfp);
                funlockfile(destfp);

                fp = freopen(file, "a", tmplogfp); /* from here fp and oldfp points to the same stream to file 'FILE'. */
                free(buf);
                buf = NULL;

                fclose(srcfp);
                srcfp = NULL;
                fclose(destfp);
                destfp = NULL;

                if(remove(_logfile_tmplog) != 0)
                {
                        output(LOG_WARNING, _("cannot remove temporary log file '%s': %s"), _logfile_tmplog, strerror(errno));
                }

                free(_logfile_tmplog);
                _logfile_tmplog = NULL;
        }
        else
                fp = destfp;

        return fp;
}

void close_logfile(FILE **fd)
{
        fclose(*fd);
        *fd = NULL;
}