4 files changed, 394 insertions, 19 deletions

diff --git a/configure.ac b/configure.ac
index 2bb8f38..56e0411 100644
--- a/configure.ac
+++ b/configure.ac
@@ -19,24 +19,25 @@ AC_CONFIG_AUX_DIR([build-aux])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_SRCDIR(src/binlog.c)
 AM_CONFIG_HEADER(config.h)
 
 AC_CANONICAL_SYSTEM
 AC_LANG(C)
 
 AM_INIT_AUTOMAKE([gnu tar-ustar])
 
 AC_GNU_SOURCE
 AC_PROG_CC
 AC_PROG_CC_STDC
+AM_PROG_CC_C_O
 if test "x$ac_cv_prog_cc_c99" = xno; then
         AC_MSG_ERROR([could not find a C99 compatible compiler])
 fi
 AC_PROG_CPP
 AC_PROG_YACC
 AC_PROG_INSTALL
 AC_PROG_LIBTOOL
 AC_PROG_MAKE_SET
 
 # Check for pkg-config
 PKG_PROG_PKG_CONFIG
 
diff --git a/src/binlog.c b/src/binlog.c
index 765b945..e7ac7e5 100644
--- a/src/binlog.c
+++ b/src/binlog.c
@@ -29,24 +29,25 @@
 #include <time.h>
 #include "vrt.h"
 #include "vcc_if.h"
 #include "bin/varnishd/cache.h"
 #include "vmod-binlog.h"
 #include "pack.h"
 
 #ifndef O_SEARCH
 # define O_SEARCH 0
 #endif
 
 #define BLF_ROUNDTS  0x01
+#define BLF_TRUNCATE 0x02
 
 enum binlog_state {
         state_init,
         state_start,
         state_pack
 };
 
 struct binlog_config {
         size_t size;                /* maximum file size */
         unsigned interval;          /* file rotation interval */
         char *pattern;              /* file name pattern */
         int umask;                  /* umask for new files and directories */
@@ -174,32 +175,56 @@ getinterval(char *p, char **endp)
                         seconds = n;
                         break;
                 default:
                         *endp = p;
                         if (!hours && !minutes && !seconds)
                                 return n;
                         return (hours*60 + minutes)*60 + seconds;
                 }
                 p++;
         }
 }
 
+static struct indexdef {
+        char *name;
+        char *pat;
+} indextab[] = {
+        { "year",   "%Y" },
+        { "0",      "%Y" },
+        { "month",  "%Y/%m" },
+        { "1",      "%Y/%m" },
+        { "day",    "%Y/%m/%d" },
+        { "2",      "%Y/%m/%d" },
+        { NULL }
+};
+
+static char *
+getindexpat(const char *name)
+{
+        struct indexdef *p;
+        for (p = indextab; p->name; p++)
+                if (strcmp(p->name, name) == 0)
+                        return p->pat;
+        return NULL;
+}
+
 void
 vmod_init(struct sess *sp, struct vmod_priv *priv,
           const char *dir, const char *dataspec, const char *param)
 {
         struct binlog_config *conf = priv->priv;
         struct stat st;
         char *p, *q;
         unsigned long n;
+        int user_pattern = 0;
         
         p = findparam(param, "debug");
         if (p) {
                 conf->debug = atoi(p);
                 free(p);
         }
 
         if (stat(dir, &st)) {
                 if (errno == ENOENT)
                         binlog_error("logging directory does not exist");
                 else
                         binlog_error("cannot stat logging directory %s: %s",
@@ -229,26 +254,50 @@ vmod_init(struct sess *sp, struct vmod_priv *priv,
         }
         conf->recsize = packsize(conf->inst_head);
         conf->env = packenv_create(conf->recsize);
         AN(conf->env);
         conf->recsize += offsetof(struct binlog_record,data);
         conf->dataspec = strdup(dataspec);
         AN(conf->dataspec);
                 
         p = findparam(param, "pattern");
         if (!p) {
                 p = strdup(BINLOG_PATTERN);
                 AN(p);
+        } else
+                user_pattern = 1;
+        conf->pattern = p;
+
+        p = findparam(param, "index");
+        if (p) {
+                q = getindexpat(p);
+                if (!q) {
+                        binlog_error("invalid index type");
+                        abort();
                 }
+        } else if (!user_pattern) {
+                q = getindexpat(BINLOG_INDEX);
+                AN(q);
+        } else
+                q = NULL;
+        
+        if (q) {
+                p = malloc(strlen(q) + strlen(conf->pattern) + 2);
+                AN(p);
+                strcpy(p, q);
+                strcat(p, "/");
+                strcat(p, conf->pattern);
+                free(conf->pattern);
                 conf->pattern = p;
+        }
         
         p = findparam(param, "size");
         if (p) {
                 uintmax_t u;
                 
                 errno = 0;
                 u = strtoul(p, &q, 10);
                 if (errno) {
                         binlog_error("invalid size value");
                         abort();
                 }
                 free(p);
@@ -297,24 +346,33 @@ vmod_init(struct sess *sp, struct vmod_priv *priv,
         } else
                 conf->umask = BINLOG_UMASK;
         
         p = findparam(param, "roundts");
         if (p) {
                 if (atoi(p))
                         conf->flags |= BLF_ROUNDTS;
                 else
                         conf->flags &= ~BLF_ROUNDTS;
                 free(p);
         }
 
+        p = findparam(param, "reuselog");
+        if (p) {
+                if (atoi(p))
+                        conf->flags &= ~BLF_TRUNCATE;
+                else
+                        conf->flags |= BLF_TRUNCATE;
+                free(p);
+        }