/* Copyright 1996 Free Software Foundation, Inc.
   Contributed by Marcin Dalecki <dalecki@sub994.sub.uni-goettingen.de>

   This file is part of the Linux modutils.

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2 of the License, or (at your
   option) any later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software Foundation,
   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#ident "$Id: misc.c,v 1.1.1.1 1998/01/06 20:51:07 ewt Exp $"

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <syslog.h>
#include <ctype.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/utsname.h>

#include "util.h"
#include "misc.h"

/*=================================================================*/

int flag_debug = 0;

/*=================================================================*/

/*
 * Strip the directory and .o or .mod extension of a file name
 * Return a pointer to a malloc()ed buffer
 */
char *
strip_o (char *fname)
{
  char *pt = fname;

  while ((pt = strchr (fname, '/')))
    fname = pt + 1;
  if ((pt = strrchr (fname, '.'))
      && ((strcmp (pt, ".o") == 0) || (strcmp (pt, ".mod") == 0)))
    {
      char *leak = (char *) xmalloc (pt - fname + 1);
      strncpy (leak, fname, pt - fname);
      leak[pt - fname] = '\0';
      
      return leak;
    }
  return xstrdup (fname);
}

/*=================================================================*/

/*
 * Read and preprocess the contents of a configuration file.
 * Return the preprocessed contents on success and NULL otherwise.
 *
 * This function implements efficient in place reading of files,
 * the usual semantics of '#' comments and the arbitrary multiplicity of
 * white spaces as delimiters.
 */
char *
read_and_preprocess_file (const char *file)
{
  char *buf;

  char *tmp;
  char *pmt;
  char *cp;
  
  FILE *fp;
  struct stat statb;

  if (stat (file, &statb) == -1
      || (statb.st_mode & S_IFMT) != S_IFREG
      || !(fp = fopen (file, "r")))
    {
      return NULL;
    }

  /*
   * OK: Now first read all of the file into a dynamically allocated buffer.
   */
  buf = (char *) xmalloc ((unsigned) (statb.st_size + 2));
  if (!fread (buf, sizeof (char), statb.st_size + 1, fp));
    /* lprintf ("warning: file %s is empty!\n", file); */
  buf[statb.st_size] = '\0';	/* be sure to NULL-terminate */
  fclose (fp);

  if (!strlen(buf))
  	return buf;
  /* 
   * Go through the whole buffer and remove comments by blanking them out.
   */
  for (cp = buf; (cp = strchr (cp, '#')); cp = tmp)
    {
      tmp = strchr (cp, '\n');
      if (!tmp)
	tmp = cp + strlen (cp);
      memset (cp, ' ', tmp - cp);
    }

  /*
   * Replace whitespaces other then '\n' by ' '
   */
  cp = buf;
  do
    {
      cp += strcspn (cp, "\t\f\v\r");
      if (*cp)
	*cp = ' ';
    }
  while (*cp);

  /*
   * Collapse all multiple white spaces into one
   */
  tmp = pmt = buf;
  do
    {
      tmp += strspn (tmp, " ");
      cp = strchr (tmp, ' ');
      if (!cp)
	cp = tmp + strlen (tmp);
      memmove (pmt, tmp, cp - tmp + 1);
      pmt += cp - tmp + 1;

      tmp = cp + 1;
    }
  while (*cp);
  
  /*
   * Remove any white space at line ends.
   */
  tmp = pmt = buf;  
  do
    {
       cp = strstr(tmp, " \n");
       if (!cp)
         cp = tmp + strlen (tmp);
       else
         *cp = '\n';
       memmove (pmt, tmp, cp - tmp + 1);
       pmt += cp - tmp + 1;
       
       tmp = cp + 2;
    }
  while (*cp);

  tmp = pmt = buf;  
  do
    {
      cp = strstr(tmp, "\n ");
      if (!cp)
        cp = tmp + strlen (tmp);
      memmove (pmt, tmp, cp - tmp + 1);
      pmt += cp - tmp + 1;
      
      tmp = cp + 2;
    }
  while(*cp);
  
  /*
   * Make sure that the last line is terminated by newline.
   */
  if ((cp > buf) && (*(cp - 1) != '\n'))
    {
      cp[0] = '\n';
      cp[1] = '\0';		/* no problem, we allocated this bit */
    }

  return buf;
}

#define RELEASE		0
#define UNKNOWN		-1

/* We check what kind command or pattern it tries to run. */
static int
what_command (const char *cmd)
{
  /* We first build the canonical form. */
  cmd = basename (cmd);
  if (strncmp (cmd, "uname", 5) == 0)
  {
    char *p;

    /* We check the argument. */
    p = strstr (cmd, "-r");
    if (p == NULL) return UNKNOWN;
    for (cmd += 5; cmd < p; cmd++)
    {
      if (!isspace (*cmd)) return UNKNOWN;
    }
    for (cmd += 2; *cmd; cmd++)
    {
      if (!isspace (*cmd)) return UNKNOWN;
    }

    return RELEASE;
  }
  return UNKNOWN;
}

/* We expand the command or pattern. */
static char *
expand_command (const char *prefix, const char *command)
{
  static struct utsname utsbuf; 
  char *tmp;

  switch (what_command (command))
  {
  case RELEASE:
    /* We need the kernel release number. */
    if (uname (&utsbuf) && errno != 0)
    {
      /* Bad release number. */
      tmp = "uname return error";
    }
    else
    {
      tmp = utsbuf.release;
    }
    break;

  default:
    /* We can add more later. For now, we just ignore it. */
    tmp = NULL;
    break;
  }

  return tmp;
}

/* We resolve the string for patterns and commands. */
char *
resolve_string (const char *str, char *buf, int size)
{
  const char *next, *left, *right;
  char *command, *tmp, *cp;
  int len;

  /* We parse the string for `foo`. */
  cp = buf;
  right = str;
  for (next = str; (left = strchr (next, '`')) != NULL; next = right + 1)
  {
    /* We found the first `. Copy the plain part. */
    len = left - next;
    size -= len;
    if (size <= 0)
    {
      goto error;
    }
    strncpy (cp, next, len);
    cp += len;

    right = strchr (left + 1, '`');
    if (right == NULL)
    {
      /* No second `. */
      break;
    }

    /* Now we get the second `. */
    len = right - left;
    command = alloca (len);
    strncpy (command, left + 1, len - 1);
    command [len - 1] = '\0';
    *cp = '\0';

    tmp = expand_command (buf, command);
    if (tmp)
    {
      len = strlen (tmp);
      size -= len;
      if (size <= 0)
      {
	goto error;
      }
      strncpy (cp, tmp, len);
      cp += len;
    }
    else
    {
      /* We don't know how to deal with it. Just copy it for now. */
      size -= len + 1;
      if (size <= 0)
      {
	goto error;
      }
      strncpy (cp, left, len + 1);
      cp += len + 1;
    }
  }

  if (right)
  {
    /* We are done. Copy the rest. */
   strncpy (cp, next, size - 1);
  }
  else
  {
    /* No second `. Copy the rest. */
    strncpy (cp, left, size - 1);
  }
  buf [size - 1] = '\0';
  
  return buf;

error:
  /* We don't do anything. */
  return (char *) str;
}

/*
 * This function concatenates lines terminated by '\\' and increases "lines"
 * accordingly. If "src" there is no source or the source is empty, we
 * return NULL. Otherwise we are returning the end of parsing.
 * The result is placed in "src"! lines is adjusted to the number of lines
 * read.
 */
char *
get_concat_line (char *src, int *lines)
{
  char *tmp;

  if (!src)			/* nothing to be processed */
    return NULL;

  tmp = src;

  if (!*tmp)
    return NULL;

  while (*src && (*src != '\n'))
    {
      if (src[0] == '\\' && src[1] == '\n')
	{
	  ++*lines;
	  ++src;
	  *src = '*';		/* fake it for the next loop */
	  --tmp;
	}
      else
	*tmp = *src;

      ++src;
      ++tmp;
    }
  *tmp = '\0';
  ++*lines;

  return src + 1;
}

/*=================================================================*/

/*
 * Error logging facilities.
 */

int log;			/* this is passed to insmod */
static int silent;

static int errors;
static const char *error_file;

void
error (const char *fmt,...)
{
  va_list args;

  if (silent)
    ;
  else if (log)
    {
      char buf[1024];
      int n;

      n = snprintf (buf, sizeof (buf), "%s: ",
		    error_file ? error_file : "insmod");
      va_start (args, fmt);
      vsnprintf (buf + n, sizeof (buf) - n, fmt, args);
      va_end (args);

      syslog (LOG_ERR, "%s", buf);
    }
  else
    {
      fprintf (stderr, "%s: ", error_file ? error_file : "modprobe");
      va_start (args, fmt);
      vfprintf (stderr, fmt, args);
      va_end (args);
      putc ('\n', stderr);
    }

  errors++;
}

void
lprintf (const char *fmt,...)
{
  va_list args;

  if (silent)
    ;
  else if (log)
    {
      char buf[1024];
      va_start (args, fmt);
      vsnprintf (buf, sizeof (buf), fmt, args);
      va_end (args);
      syslog (LOG_INFO, "%s", buf);
    }
  else
    {
      va_start (args, fmt);
      vfprintf (stdout, fmt, args);
      va_end (args);
      putchar ('\n');
    }
}

void
setsyslog (const char *program)
{
  openlog (program, LOG_CONS, LOG_DAEMON);
  log = 1;
}
