/* tinyproxy - A fast light-weight HTTP proxy
 * Copyright (C) 1998 Steven Young <sdyoung@miranda.org>
 * Copyright (C) 1999-2003 Robert James Kaes <rjkaes@users.sourceforge.net>
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

/* Misc. routines which are used by the various functions to handle strings
 * and memory allocation and pretty much anything else we can think of. Also,
 * the load cutoff routine is in here. Could not think of a better place for
 * it, so it's in here.
 */

#include "tinyproxy.h"

#include "conns.h"
#include "heap.h"
#include "http-message.h"
#include "utils.h"

/*
 * Build the data for a complete HTTP & HTML message for the client.
 */
int
send_http_message (struct conn_s *connptr, int http_code,
		   const char *error_title, const char *message)
{
  static char *headers[] = {
    "Server: " PACKAGE "/" VERSION,
    "Content-type: text/html",
    "Connection: close"
  };

  http_message_t msg;

  msg = http_message_create (http_code, error_title);
  if (msg == NULL)
    return -1;

  http_message_add_headers (msg, headers, 3);
  http_message_set_body (msg, message, strlen (message));
  http_message_send (msg, connptr->client_fd);
  http_message_destroy (msg);

  return 0;
}

/*
 * Safely creates filename and returns the low-level file descriptor.
 */
int
create_file_safely (const char *filename, unsigned int truncate_file)
{
  struct stat lstatinfo;
  int fildes;

  /*
   * lstat() the file. If it doesn't exist, create it with O_EXCL.
   * If it does exist, open it for writing and perform the fstat()
   * check.
   */
  if (lstat (filename, &lstatinfo) < 0)
    {
      /*
       * If lstat() failed for any reason other than "file not
       * existing", exit.
       */
      if (errno != ENOENT)
	{
	  fprintf (stderr,
		   "%s: Error checking file %s: %s\n",
		   PACKAGE, filename, strerror (errno));
	  return -EACCES;
	}

      /*
       * The file doesn't exist, so create it with O_EXCL to make
       * sure an attacker can't slip in a file between the lstat()
       * and open()
       */
      if ((fildes = open (filename, O_RDWR | O_CREAT | O_EXCL, 0600)) < 0)
	{
	  fprintf (stderr,
		   "%s: Could not create file %s: %s\n",
		   PACKAGE, filename, strerror (errno));
	  return fildes;
	}
    }
  else
    {
      struct stat fstatinfo;
      int flags;

      flags = O_RDWR;
      if (!truncate_file)
	flags |= O_APPEND;

      /*
       * Open an existing file.
       */
      if ((fildes = open (filename, flags)) < 0)
	{
	  fprintf (stderr,
		   "%s: Could not open file %s: %s\n",
		   PACKAGE, filename, strerror (errno));
	  return fildes;
	}

      /*
       * fstat() the opened file and check that the file mode bits,
       * inode, and device match.
       */
      if (fstat (fildes, &fstatinfo) < 0
	  || lstatinfo.st_mode != fstatinfo.st_mode
	  || lstatinfo.st_ino != fstatinfo.st_ino
	  || lstatinfo.st_dev != fstatinfo.st_dev)
	{
	  fprintf (stderr,
		   "%s: The file %s has been changed before it could be opened\n",
		   PACKAGE, filename);
	  close (fildes);
	  return -EIO;
	}

      /*
       * If the above check was passed, we know that the lstat()
       * and fstat() were done on the same file. Now we check that
       * there's only one link, and that it's a normal file (this
       * isn't strictly necessary because the fstat() vs lstat()
       * st_mode check would also find this)
       */
      if (fstatinfo.st_nlink > 1 || !S_ISREG (lstatinfo.st_mode))
	{
	  fprintf (stderr,
		   "%s: The file %s has too many links, or is not a regular file: %s\n",
		   PACKAGE, filename, strerror (errno));
	  close (fildes);
	  return -EMLINK;
	}

      /*
       * Just return the file descriptor if we _don't_ want the file
       * truncated.
       */
      if (!truncate_file)
	return fildes;

      /*
       * On systems which don't support ftruncate() the best we can
       * do is to close the file and reopen it in create mode, which
       * unfortunately leads to a race condition, however "systems
       * which don't support ftruncate()" is pretty much SCO only,
       * and if you're using that you deserve what you get.
       * ("Little sympathy has been extended")
       */
#ifdef HAVE_FTRUNCATE
      ftruncate (fildes, 0);
#else
      close (fildes);
      if ((fildes = open (filename, O_RDWR | O_CREAT | O_TRUNC, 0600)) < 0)
	{
	  fprintf (stderr,
		   "%s: Could not open file %s: %s.",
		   PACKAGE, filename, strerror (errno));
	  return fildes;
	}
#endif /* HAVE_FTRUNCATE */
    }

  return fildes;
}

/*
 * Write the PID of the program to the specified file.
 */
int
pidfile_create (const char *filename)
{
  int fildes;
  FILE *fd;

  /*
   * Create a new file
   */
  if ((fildes = create_file_safely (filename, TRUE)) < 0)
    return fildes;

  /*
   * Open a stdio file over the low-level one.
   */
  if ((fd = fdopen (fildes, "w")) == NULL)
    {
      fprintf (stderr,
	       "%s: Could not write PID file %s: %s.",
	       PACKAGE, filename, strerror (errno));
      close (fildes);
      unlink (filename);
      return -EIO;
    }

  fprintf (fd, "%ld\n", (long) getpid ());
  fclose (fd);
  return 0;
}