/*

 * ntp_filegen.c,v 3.12 1994/01/25 19:06:11 kardel Exp

 *

 *  implements file generations support for NTP

 *  logfiles and statistic files

 *

 *

 * Copyright (C) 1992, 1996 by Rainer Pruy

 * Friedrich-Alexander Universitaet Erlangen-Nuernberg, Germany

 *

 * This code may be modified and used freely

 * provided credits remain intact.

 */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "ntpd.h"

#include "ntp_io.h"

#include "ntp_string.h"

#include "ntp_calendar.h"

#include "ntp_filegen.h"

#include "ntp_stdlib.h"

/*

 * NTP is intended to run long periods of time without restart.

 * Thus log and statistic files generated by NTP will grow large.

 *

 * this set of routines provides a central interface 

 * to generating files using file generations

 *

 * the generation of a file is changed according to file generation type

 */

/*

 * redefine this if your system dislikes filename suffixes like

 * X.19910101 or X.1992W50 or ....

 */

#define SUFFIX_SEP '.'

static  void  filegen_open  (FILEGEN *, u_int32, const time_t*);

static  int valid_fileref (const char *, const char *);

static  void  filegen_init  (const char *, const char *, FILEGEN *);

#ifdef  DEBUG

static  void  filegen_uninit    (FILEGEN *);

#endif  /* DEBUG */

/*

 * filegen_init

 */

static void

filegen_init(

  const char *  dir,

  const char *  fname,

  FILEGEN * fgp

  )

{

  fgp->fp = NULL;

  fgp->dir = estrdup(dir);

  fgp->fname = estrdup(fname);

  fgp->id_lo = 0;

  fgp->id_hi = 0;

  fgp->type = FILEGEN_DAY;

  fgp->flag = FGEN_FLAG_LINK; /* not yet enabled !!*/

}

/*

 * filegen_uninit - free memory allocated by filegen_init

 */

#ifdef DEBUG

static void

filegen_uninit(

  FILEGEN *fgp

  )

{

  free(fgp->dir);

  free(fgp->fname);

}

#endif

/*

 * open a file generation according to the current settings of gen

 * will also provide a link to basename if requested to do so

 */

static void

filegen_open(

  FILEGEN * gen,

  u_int32   stamp,

  const time_t *  pivot

  )

{

  char *savename; /* temp store for name collision handling */

  char *fullname; /* name with any designation extension */

  char *filename; /* name without designation extension */

  char *suffix; /* where to print suffix extension */

  u_int len, suflen;

  FILE *fp;

  struct calendar cal;

  struct isodate  iso;

  /* get basic filename in buffer, leave room for extensions */

  len = strlen(gen->dir) + strlen(gen->fname) + 65;

  filename = emalloc(len);

  fullname = emalloc(len);

  savename = NULL;

  snprintf(filename, len, "%s%s", gen->dir, gen->fname);

  /* where to place suffix */

  suflen = strlcpy(fullname, filename, len);

  suffix = fullname + suflen;

  suflen = len - suflen;

  /* last octet of fullname set to '\0' for truncation check */

  fullname[len - 1] = '\0';

  switch (gen->type) {

  default:

    msyslog(LOG_ERR, 

      "unsupported file generations type %d for "

      "\"%s\" - reverting to FILEGEN_NONE",

      gen->type, filename);

    gen->type = FILEGEN_NONE;

    break;

  case FILEGEN_NONE:

    /* no suffix, all set */

    break;

  case FILEGEN_PID:

    gen->id_lo = getpid();

    gen->id_hi = 0;

    snprintf(suffix, suflen, "%c#%ld",

       SUFFIX_SEP, gen->id_lo);

    break;

  case FILEGEN_DAY:

    /*

     * You can argue here in favor of using MJD, but I

     * would assume it to be easier for humans to interpret

     * dates in a format they are used to in everyday life.

     */

    ntpcal_ntp_to_date(&cal, stamp, pivot);

    snprintf(suffix, suflen, "%c%04d%02d%02d",

       SUFFIX_SEP, cal.year, cal.month, cal.monthday);

    cal.hour = cal.minute = cal.second = 0;

    gen->id_lo = ntpcal_date_to_ntp(&cal); 

    gen->id_hi = (u_int32)(gen->id_lo + SECSPERDAY);

    break;

  case FILEGEN_WEEK:

    isocal_ntp_to_date(&iso, stamp, pivot);

    snprintf(suffix, suflen, "%c%04dw%02d",

       SUFFIX_SEP, iso.year, iso.week);

    iso.hour = iso.minute = iso.second = 0;

    iso.weekday = 1;

    gen->id_lo = isocal_date_to_ntp(&iso);

    gen->id_hi = (u_int32)(gen->id_lo + 7 * SECSPERDAY);

    break;

  case FILEGEN_MONTH:

    ntpcal_ntp_to_date(&cal, stamp, pivot);

    snprintf(suffix, suflen, "%c%04d%02d",

       SUFFIX_SEP, cal.year, cal.month);

    cal.hour = cal.minute = cal.second = 0;

    cal.monthday = 1;

    gen->id_lo = ntpcal_date_to_ntp(&cal); 

    cal.month++;

    gen->id_hi = ntpcal_date_to_ntp(&cal); 

    break;

  case FILEGEN_YEAR:

    ntpcal_ntp_to_date(&cal, stamp, pivot);

    snprintf(suffix, suflen, "%c%04d",

       SUFFIX_SEP, cal.year);

    cal.hour = cal.minute = cal.second = 0;

    cal.month = cal.monthday = 1;

    gen->id_lo = ntpcal_date_to_ntp(&cal); 

    cal.year++;

    gen->id_hi = ntpcal_date_to_ntp(&cal); 

    break;

  case FILEGEN_AGE:

    gen->id_lo = current_time - (current_time % SECSPERDAY);

    gen->id_hi = gen->id_lo + SECSPERDAY;

    snprintf(suffix, suflen, "%ca%08ld",

       SUFFIX_SEP, gen->id_lo);

  }

  /* check possible truncation */

  if ('\0' != fullname[len - 1]) {

    fullname[len - 1] = '\0';

    msyslog(LOG_ERR, "logfile name truncated: \"%s\"",

      fullname);

  }

  if (FILEGEN_NONE != gen->type) {

    /*

     * check for existence of a file with name 'basename'

     * as we disallow such a file

     * if FGEN_FLAG_LINK is set create a link

     */

    struct stat stats;

    /*

     * try to resolve name collisions

     */

    static u_long conflicts = 0;

#ifndef S_ISREG

#define S_ISREG(mode) (((mode) & S_IFREG) == S_IFREG)

#endif

    if (stat(filename, &stats) == 0) {

      /* Hm, file exists... */

      if (S_ISREG(stats.st_mode)) {

        if (stats.st_nlink <= 1) {

          /*

           * Oh, it is not linked - try to save it

           */

          savename = emalloc(len);

          snprintf(savename, len,

            "%s%c%dC%lu",

            filename, SUFFIX_SEP,

            (int)getpid(), conflicts++);

          if (rename(filename, savename) != 0)

            msyslog(LOG_ERR,

              "couldn't save %s: %m",

              filename);

          free(savename);

        } else {

          /*

           * there is at least a second link to

           * this file.

           * just remove the conflicting one

           */

          if (

#if !defined(VMS)

            unlink(filename) != 0

#else

            delete(filename) != 0

#endif

            )

            msyslog(LOG_ERR, 

              "couldn't unlink %s: %m",

              filename);

        }

      } else {

        /*

         * Ehh? Not a regular file ?? strange !!!!

         */

        msyslog(LOG_ERR, 

          "expected regular file for %s "

          "(found mode 0%lo)",

          filename,

          (unsigned long)stats.st_mode);

      }

    } else {

      /*

       * stat(..) failed, but it is absolutely correct for

       * 'basename' not to exist

       */

      if (ENOENT != errno)

        msyslog(LOG_ERR, "stat(%s) failed: %m",

             filename);

    }

  }

  /*

   * now, try to open new file generation...

   */

  DPRINTF(4, ("opening filegen (type=%d/stamp=%u) \"%s\"\n",

        gen->type, stamp, fullname));

  fp = fopen(fullname, "a");

  if (NULL == fp) {

    /* open failed -- keep previous state

     *

     * If the file was open before keep the previous generation.

     * This will cause output to end up in the 'wrong' file,

     * but I think this is still better than losing output

     *

     * ignore errors due to missing directories

     */

    if (ENOENT != errno)

      msyslog(LOG_ERR, "can't open %s: %m", fullname);

  } else {

    if (NULL != gen->fp) {

      fclose(gen->fp);

      gen->fp = NULL;

    }

    gen->fp = fp;

    if (gen->flag & FGEN_FLAG_LINK) {

      /*

       * need to link file to basename

       * have to use hardlink for now as I want to allow

       * gen->basename spanning directory levels

       * this would make it more complex to get the correct

       * fullname for symlink

       *

       * Ok, it would just mean taking the part following

       * the last '/' in the name.... Should add it later....

       */

      /* Windows NT does not support file links -Greg Schueman 1/18/97 */

#if defined(SYS_WINNT) || defined(SYS_VXWORKS)

      SetLastError(0); /* On WinNT, don't support FGEN_FLAG_LINK */

#elif defined(VMS)

      errno = 0; /* On VMS, don't support FGEN_FLAG_LINK */

#else  /* not (VMS) / VXWORKS / WINNT ; DO THE LINK) */

      if (link(fullname, filename) != 0)

        if (EEXIST != errno)

          msyslog(LOG_ERR, 

            "can't link(%s, %s): %m",

            fullname, filename);

#endif /* SYS_WINNT || VXWORKS */

    }   /* flags & FGEN_FLAG_LINK */

  }     /* else fp == NULL */

  free(filename);

  free(fullname);

  return;

}

/*

 * this function sets up gen->fp to point to the correct

 * generation of the file for the time specified by 'now'

 *

 * 'now' usually is interpreted as second part of a l_fp as is in the cal...

 * library routines

 */

void

filegen_setup(

  FILEGEN * gen,

  u_int32   now

  )

{

  int current;

  time_t  pivot;

  if (!(gen->flag & FGEN_FLAG_ENABLED)) {

    if (NULL != gen->fp) {

      fclose(gen->fp);

      gen->fp = NULL;

    }

    return;

  }

  switch (gen->type) {

  default:

  case FILEGEN_NONE:

    current = TRUE;

    break;

  case FILEGEN_PID:

    current = ((int)gen->id_lo == getpid());

    break;

  case FILEGEN_AGE:

    current = (gen->id_lo <= current_time) &&

        (gen->id_hi > current_time);

    break;

  case FILEGEN_DAY:

  case FILEGEN_WEEK:

  case FILEGEN_MONTH:

  case FILEGEN_YEAR:

    current = (gen->id_lo <= now) &&

        (gen->id_hi > now);

    break;

  }

  /*

   * try to open file if not yet open

   * reopen new file generation file on change of generation id

   */

  if (NULL == gen->fp || !current) {

    DPRINTF(1, ("filegen  %0x %u\n", gen->type, now));

    pivot = time(NULL);

    filegen_open(gen, now, &pivot);

  }

}

/*

 * change settings for filegen files

 */

void

filegen_config(

  FILEGEN * gen,

  const char *  dir,

  const char *  fname,

  u_int   type,

  u_int   flag

  )

{

  int file_existed;

  l_fp now;

  /*

   * if nothing would be changed...

   */

  if (strcmp(dir, gen->dir) == 0 && strcmp(fname, gen->fname) == 0

      && type == gen->type && flag == gen->flag)

    return;

  /*

   * validate parameters

   */

  if (!valid_fileref(dir, fname))

    return;

  if (NULL != gen->fp) {

    fclose(gen->fp);

    gen->fp = NULL;

    file_existed = TRUE;

  } else {

    file_existed = FALSE;

  }

  DPRINTF(3, ("configuring filegen:\n"

        "\tdir:\t%s -> %s\n"

        "\tfname:\t%s -> %s\n"

        "\ttype:\t%d -> %d\n"

        "\tflag: %x -> %x\n",

        gen->dir, dir,

        gen->fname, fname,

        gen->type, type,

        gen->flag, flag));

  if (strcmp(gen->dir, dir) != 0) {

    free(gen->dir);

    gen->dir = estrdup(dir);

  }

  if (strcmp(gen->fname, fname) != 0) {

    free(gen->fname);

    gen->fname = estrdup(fname);

  }

  gen->type = (u_char)type;

  gen->flag = (u_char)flag;

  /*

   * make filegen use the new settings

   * special action is only required when a generation file

   * is currently open

   * otherwise the new settings will be used anyway at the next open

   */

  if (file_existed) {

    get_systime(&now);

    filegen_setup(gen, now.l_ui);

  }

}

/*

 * check whether concatenating prefix and basename

 * yields a legal filename

 */

static int

valid_fileref(

  const char *  dir,

  const char *  fname

  )

{

  /*

   * dir cannot be changed dynamically

   * (within the context of filegen)

   * so just reject basenames containing '..'

   *

   * ASSUMPTION:

   *    file system parts 'below' dir may be

   *    specified without infringement of security

   *

   *    restricting dir to legal values

   *    has to be ensured by other means

   * (however, it would be possible to perform some checks here...)

   */

  const char *p;

  /*

   * Just to catch, dumb errors opening up the world...

   */

  if (NULL == dir || '\0' == dir[0])

    return FALSE;

  if (NULL == fname)

    return FALSE;

#ifdef SYS_WINNT

  /*

   * Windows treats / equivalent to \, reject any / to ensure

   * check below for DIR_SEP (\ on windows) are adequate.

   */

  if (strchr(fname, '/')) {

    msyslog(LOG_ERR,

      "filegen filenames must not contain '/': %s",

      fname);

    return FALSE;

  }

#endif

  for (p = fname; p != NULL; p = strchr(p, DIR_SEP)) {

    if ('.' == p[0] && '.' == p[1] 

        && ('\0' == p[2] || DIR_SEP == p[2]))

      return FALSE;

  }

  return TRUE;

}

/*

 * filegen registry

 */

static struct filegen_entry {

  char *      name;

  FILEGEN *   filegen;

  struct filegen_entry *  next;

} *filegen_registry = NULL;

FILEGEN *

filegen_get(

  const char *  name

  )

{

  struct filegen_entry *f = filegen_registry;

  while (f) {

    if (f->name == name || strcmp(name, f->name) == 0) {

      DPRINTF(4, ("filegen_get(%s) = %p\n",

            name, f->filegen));

      return f->filegen;

    }

    f = f->next;

  }

  DPRINTF(4, ("filegen_get(%s) = NULL\n", name));

  return NULL;

}

void

filegen_register(

  const char *  dir,

  const char *  name,

  FILEGEN * filegen

  )

{

  struct filegen_entry **ppfe;

  DPRINTF(4, ("filegen_register(%s, %p)\n", name, filegen));

  filegen_init(dir, name, filegen);

  ppfe = &filegen_registry;

  while (NULL != *ppfe) {

    if ((*ppfe)->name == name 

        || !strcmp((*ppfe)->name, name)) {

      DPRINTF(5, ("replacing filegen %p\n",

            (*ppfe)->filegen));

      (*ppfe)->filegen = filegen;

      return;

    }

    ppfe = &((*ppfe)->next);

  }

  *ppfe = emalloc(sizeof **ppfe);

  (*ppfe)->next = NULL;

  (*ppfe)->name = estrdup(name);

  (*ppfe)->filegen = filegen;

  DPRINTF(6, ("adding new filegen\n"));

  return;

}

/*

 * filegen_statsdir() - reset each filegen entry's dir to statsdir.

 */

void

filegen_statsdir(void)

{

  struct filegen_entry *f;

  for (f = filegen_registry; f != NULL; f = f->next)

    filegen_config(f->filegen, statsdir, f->filegen->fname,

             f->filegen->type, f->filegen->flag);

}

/*

 * filegen_unregister frees memory allocated by filegen_register for

 * name.

 */

#ifdef DEBUG

void

filegen_unregister(

  const char *name

  )

{

  struct filegen_entry ** ppfe;

  struct filegen_entry *  pfe;

  FILEGEN *   fg;

  DPRINTF(4, ("filegen_unregister(%s)\n", name));

  ppfe = &filegen_registry;

  while (NULL != *ppfe) {

    if ((*ppfe)->name == name

        || !strcmp((*ppfe)->name, name)) {

      pfe = *ppfe;

      *ppfe = (*ppfe)->next;

      fg = pfe->filegen;

      free(pfe->name);

      free(pfe);

      filegen_uninit(fg);

      break;

    }

    ppfe = &((*ppfe)->next);

  }

}  

#endif  /* DEBUG */