#define LOG_ROTATION_TIME_TAG       ("log_rotationtime")

#define LOG_FILESIZE_TAG            ("log_filesize")

static JK_CRIT_SEC log_cs;

static char log_file_effective[MAX_PATH * 2];

static long log_rotationtime = 0;

static time_t log_next_rotate_time = 0;

static long log_filesize = 0;

static int JK_METHOD iis_log_to_file(jk_logger_t *l, int level,

                                    int used, char *what);

        JK_ENTER_CS(&(log_cs), rc);

        JK_LEAVE_CS(&(log_cs), rc);

        JK_INIT_CS(&log_cs, rc);

        JK_DELETE_CS(&log_cs, rc);

/*

 * Reinitializes the logger, formatting the log file name if rotation is enabled,

 * and calculating the next rotation time if applicable.

 */

static int init_logger(int rotate, jk_logger_t **l)

{

    int rc = JK_TRUE;

    int log_open = rotate;  /* log is assumed open if a rotate is requested */

    char *log_file_name;

    char log_file_name_buf[MAX_PATH*2];

    /* If log rotation is enabled, format the log filename */

    if ((log_rotationtime > 0) || (log_filesize > 0)) {

        time_t t;

        t = time(NULL);

        if (log_rotationtime > 0) {

            /* Align time to rotationtime intervals */

            t = (t / log_rotationtime) * log_rotationtime;

            /* Calculate rotate time */

            log_next_rotate_time = t + log_rotationtime;

        }

        log_file_name = log_file_name_buf;

        if (strchr(log_file, '%')) {

            struct tm *tm_now;

            /* If there are %s in the log file name, treat it as a sprintf format */

            tm_now = localtime(&t);

            strftime(log_file_name, MAX_PATH*2, log_file, tm_now);

        } else {

            /* Otherwise append the number of seconds to the base name */        

            sprintf_s(log_file_name, MAX_PATH*2, "%s.%d", log_file, (long)t);

        }

    } else {

        log_file_name = log_file;

    }

    /* Close the current log file if required, and the effective log file name has changed */

    if (log_open && strncmp(log_file_name, log_file_effective, strlen(log_file_name)) != 0) {

        FILE* lf = ((jk_file_logger_t* )logger->logger_private)->logfile;

        fprintf_s(lf, "Log rotated to %s\r\n", log_file_name);

        fflush(lf);

        rc = jk_close_file_logger(&logger);

        log_open = JK_FALSE;

    }

    if (!log_open) {

        if (jk_open_file_logger(&logger, log_file_name, log_level)) {

            logger->log = iis_log_to_file;

            /* Remember the current log file name for the next potential rotate */

            strcpy_s(log_file_effective, MAX_PATH * 2, log_file_name);

            rc = JK_TRUE;

        } else {

            logger = NULL;

            rc = JK_FALSE;

        }

    }

    /* Update logger being used for this log call so it occurs on new file */

    (*l) = logger;

    return rc;

}

/*

 * Checks whether the log needs to be rotated. Must be called while holding the log lock.

 * The behaviour here is based on the Apache rotatelogs program.

 * http://httpd.apache.org/docs/2.0/programs/rotatelogs.html

 */

static int JK_METHOD rotate_log_file(jk_logger_t **l)

{

    int rc = JK_TRUE;

    int rotate = JK_FALSE;

    if (log_rotationtime > 0) {

        time_t t = time(NULL);

        if (t >= log_next_rotate_time) {

            rotate = JK_TRUE;

        }

    } else if (log_filesize > 0) {

#if _MSC_VER >= 1400

        long filesize = _ftell_nolock(((jk_file_logger_t *)(*l)->logger_private)->logfile);

#else

        long filesize = ftell(((jk_file_logger_t *)(*l)->logger_private)->logfile);

#endif

        if (filesize >= log_filesize) {

            rotate = JK_TRUE;

        }

    }

    if (rotate) {

        rc = init_logger(JK_TRUE, l);

    }

    return rc;

}

/*

 * Log messages to the log file, rotating the log when required.

 */

static int JK_METHOD iis_log_to_file(jk_logger_t *l, int level,

                                    int used, char *what)

{

    int rc = JK_FALSE;

    if (l &&

        (l->level <= level || level == JK_LOG_REQUEST_LEVEL) &&

        l->logger_private && what && used > 0) {

        jk_file_logger_t *p = l->logger_private;

        rc = JK_TRUE;

        if (p->logfile) {

            what[used++] = '\r';

            what[used++] = '\n';

            what[used] = '\0';

            /* Perform logging within critical section to protect rotation */

            JK_ENTER_CS(&(log_cs), rc);

            if (rc && rotate_log_file(&l)) {

                /* The rotation process will reallocate the jk_logger_t structure, so refetch */ 

                FILE *rotated = ((jk_file_logger_t *)l->logger_private)->logfile;

                fputs(what, rotated);

                fflush(rotated);

                JK_LEAVE_CS(&(log_cs), rc);

            }

        }

    }

    return rc;

}

        jk_log(logger, JK_LOG_DEBUG, "Using log rotation time %d.", log_rotationtime);

        jk_log(logger, JK_LOG_DEBUG, "Using log file size %d.", log_filesize);

    if ((log_rotationtime > 0) && (log_filesize > 0)) {

        jk_log(logger, JK_LOG_WARNING, 

            "%s is defined in configuration, but will be ignored because %s is set. ",

            LOG_FILESIZE_TAG, LOG_ROTATION_TIME_TAG);

    }

    if (get_config_parameter(src, LOG_ROTATION_TIME_TAG, tmpbuf, sizeof(tmpbuf))) {

        log_rotationtime = atol(tmpbuf);

        if (log_rotationtime < 0) {

            log_rotationtime = 0;

        }

    }

    if (get_config_parameter(src, LOG_FILESIZE_TAG, tmpbuf, sizeof(tmpbuf))) {

        log_filesize = atol(tmpbuf);

        if (log_filesize < 0) {

            log_filesize = 0;

        }

        /* Convert to MB as per Apache rotatelogs */

        log_filesize *= (1000 * 1000);

    }