/* keybox-init.c - Initialization of the library

 *  Copyright (C) 2001 Free Software Foundation, Inc.

 *

 * This file is part of GnuPG.

 *

 * GnuPG 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 3 of the License, or

 * (at your option) any later version.

 *

 * GnuPG 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, see <https://www.gnu.org/licenses/>.

 */

#include <config.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <assert.h>

#include "keybox-defs.h"

#include "../common/sysutils.h"

#include "../common/mischelp.h"

#ifdef HAVE_W32_SYSTEM

# define DEFAULT_LL_BUFFER_SIZE 128

#else

# define DEFAULT_LL_BUFFER_SIZE 64

#endif

static unsigned int ll_buffer_size = DEFAULT_LL_BUFFER_SIZE;

static KB_NAME kb_names;

/* This object is used to mahe setvbuf buffers.  We use a short arary

 * to be able to reuse already allocated buffers.  */

struct stream_buffer_s

{

  int inuse;       /* True if used by a stream. */

  size_t bufsize;

  char *buf;

};

static struct stream_buffer_s stream_buffers[5];

/* Register a filename for plain keybox files.  Returns 0 on success,

 * GPG_ERR_EEXIST if it has already been registered, or another error

 * code.  On success or with error code GPG_ERR_EEXIST a token usable

 * to access the keybox handle is stored at R_TOKEN, NULL is stored

 * for all other errors.  */

gpg_error_t

keybox_register_file (const char *fname, int secret, void **r_token)

{

  KB_NAME kr;

  *r_token = NULL;

  for (kr=kb_names; kr; kr = kr->next)

    {

      if (same_file_p (kr->fname, fname) )

        {

          *r_token = kr;

          return gpg_error (GPG_ERR_EEXIST); /* Already registered. */

        }

    }

  kr = xtrymalloc (sizeof *kr + strlen (fname));

  if (!kr)

    return gpg_error_from_syserror ();

  strcpy (kr->fname, fname);

  kr->secret = !!secret;

  kr->handle_table = NULL;

  kr->handle_table_size = 0;

  kr->lockhd = NULL;

  kr->is_locked = 0;

  kr->did_full_scan = 0;

  /* keep a list of all issued pointers */

  kr->next = kb_names;

  kb_names = kr;

  /* create the offset table the first time a function here is used */

/*      if (!kb_offtbl) */

/*        kb_offtbl = new_offset_hash_table (); */

  *r_token = kr;

  return 0;

}

int

keybox_is_writable (void *token)

{

  KB_NAME r = token;

  return r? !gnupg_access (r->fname, W_OK) : 0;

}

/* Change the default buffering to KBYTES KiB; using 0 uses the system

 * buffers.  This function must be called early.  */

void

keybox_set_buffersize (unsigned int kbytes, int reserved)

{

  (void)reserved;

  /* Round down to 8k multiples.  */

  ll_buffer_size = (kbytes + 7)/8 * 8;

}

static KEYBOX_HANDLE

do_keybox_new (KB_NAME resource, int secret, int for_openpgp)

{

  KEYBOX_HANDLE hd;

  int idx;

  assert (resource && !resource->secret == !secret);

  hd = xtrycalloc (1, sizeof *hd);

  if (hd)

    {

      hd->kb = resource;

      hd->secret = !!secret;

      hd->for_openpgp = for_openpgp;

      if (!resource->handle_table)

        {

          resource->handle_table_size = 3;

          resource->handle_table = xtrycalloc (resource->handle_table_size,

                                               sizeof *resource->handle_table);

          if (!resource->handle_table)

            {

              resource->handle_table_size = 0;

              xfree (hd);

              return NULL;

            }

        }

      for (idx=0; idx < resource->handle_table_size; idx++)

        if (!resource->handle_table[idx])

          {

            resource->handle_table[idx] = hd;

            break;

          }

      if (!(idx < resource->handle_table_size))

        {

          KEYBOX_HANDLE *tmptbl;

          size_t newsize;

          newsize = resource->handle_table_size + 5;

          tmptbl = xtryrealloc (resource->handle_table,

                                newsize * sizeof (*tmptbl));

          if (!tmptbl)

            {

              xfree (hd);

              return NULL;

            }

          resource->handle_table = tmptbl;

          resource->handle_table_size = newsize;

          resource->handle_table[idx] = hd;

          for (idx++; idx < resource->handle_table_size; idx++)

            resource->handle_table[idx] = NULL;

        }

    }

  return hd;

}

/* Create a new handle for the resource associated with TOKEN.  SECRET

   is just a cross-check.  This is the OpenPGP version.  The returned

   handle must be released using keybox_release.  */

KEYBOX_HANDLE

keybox_new_openpgp (void *token, int secret)

{

  KB_NAME resource = token;

  return do_keybox_new (resource, secret, 1);

}

/* Create a new handle for the resource associated with TOKEN.  SECRET

   is just a cross-check.  This is the X.509 version.  The returned

   handle must be released using keybox_release.  */

KEYBOX_HANDLE

keybox_new_x509 (void *token, int secret)

{

  KB_NAME resource = token;

  return do_keybox_new (resource, secret, 0);

}

void

keybox_fp_close (KEYBOX_HANDLE hd)

{

  if (!hd)

    return;

  if (hd->fp)

    {

      _keybox_ll_close (hd->fp);

      hd->fp = NULL;

    }

}

void

keybox_release (KEYBOX_HANDLE hd)

{

  if (!hd)

    return;

  if (hd->kb->handle_table)

    {

      int idx;

      for (idx=0; idx < hd->kb->handle_table_size; idx++)

        if (hd->kb->handle_table[idx] == hd)

          hd->kb->handle_table[idx] = NULL;

    }

  _keybox_release_blob (hd->found.blob);

  _keybox_release_blob (hd->saved_found.blob);

  xfree (hd->word_match.name);

  xfree (hd->word_match.pattern);

  xfree (hd);

}

/* Save the current found state in HD for later retrieval by

   keybox_restore_found_state.  Only one state may be saved.  */

void

keybox_push_found_state (KEYBOX_HANDLE hd)

{

  if (hd->saved_found.blob)

    {

      _keybox_release_blob (hd->saved_found.blob);

      hd->saved_found.blob = NULL;

    }

  hd->saved_found = hd->found;

  hd->found.blob = NULL;

}

/* Restore the saved found state in HD.  */

void

keybox_pop_found_state (KEYBOX_HANDLE hd)

{

  if (hd->found.blob)

    {

      _keybox_release_blob (hd->found.blob);

      hd->found.blob = NULL;

    }

  hd->found = hd->saved_found;

  hd->saved_found.blob = NULL;

}

const char *

keybox_get_resource_name (KEYBOX_HANDLE hd)

{

  if (!hd || !hd->kb)

    return NULL;

  return hd->kb->fname;

}

int

keybox_set_ephemeral (KEYBOX_HANDLE hd, int yes)

{

  if (!hd)

    return gpg_error (GPG_ERR_INV_HANDLE);

  hd->ephemeral = yes;

  return 0;

}

/* Low-level open function to be used for keybox files.  This function

 * also manages custom buffering.  On success 0 is returned and a new

 * file pointer stored at RFP; on error an error code is returned and

 * NULL is stored at RFP.  MODE is one of

 *   KEYBOX_LL_OPEN_READ(0) := fopen mode is "rb"

 *   KEYBOX_LL_OPEN_UPDATE  := fopen mode is "r+b"

 *   KEYBOX_LL_OPEN_CREATE  := fopen mode is "wb"

 */

gpg_error_t

_keybox_ll_open (estream_t *rfp, const char *fname, unsigned int mode)

{

  estream_t fp;

  int i;

  size_t bufsize;

  *rfp = NULL;

  fp = es_fopen (fname,

                 mode == KEYBOX_LL_OPEN_CREATE

                 ? "wb,sysopen,sequential,share=rw" :

                 mode == KEYBOX_LL_OPEN_UPDATE

                 ? "r+b,sysopen,sequential,share=rw" :

                 "rb,sysopen,sequential,share=rw");

  if (!fp)

    return gpg_error_from_syserror ();

  if (ll_buffer_size)

    {

      for (i=0; i < DIM (stream_buffers); i++)

        if (!stream_buffers[i].inuse)

          {

            /* There is a free slot - we can use a larger buffer.  */

            stream_buffers[i].inuse = 1;

            if (!stream_buffers[i].buf)

              {

                bufsize = ll_buffer_size * 1024;

                stream_buffers[i].buf = xtrymalloc (bufsize);

                if (stream_buffers[i].buf)

                  stream_buffers[i].bufsize = bufsize;

                else

                  {

                    log_info ("can't allocate a large buffer for a kbx file;"

                              " using default\n");

                    stream_buffers[i].inuse = 0;

                  }

              }

            if (stream_buffers[i].buf)

              {

                es_setvbuf (fp, stream_buffers[i].buf, _IOFBF,

                            stream_buffers[i].bufsize);

                es_opaque_set (fp, stream_buffers + i);

              }

            break;

          }

    }

  *rfp = fp;

  return 0;

}

/* Wrapper around es_fclose to be used for file opened with

 * _keybox_ll_open.  */

gpg_error_t

_keybox_ll_close (estream_t fp)

{

  gpg_error_t err;

  struct stream_buffer_s *sbuf;

  int i;

  if (!fp)

    return 0;

  sbuf = ll_buffer_size? es_opaque_get (fp) : NULL;

  if (es_fclose (fp))

    err = gpg_error_from_syserror ();

  else

    err = 0;

  if (sbuf)

    {

      for (i=0; i < DIM (stream_buffers); i++)

        if (stream_buffers + i == sbuf)

          break;

      log_assert (i < DIM (stream_buffers));

      stream_buffers[i].inuse = 0;

    }

  return err;

}

/* Close the file of the resource identified by HD.  For consistent

   results this function closes the files of all handles pointing to

   the resource identified by HD.  */

void

_keybox_close_file (KEYBOX_HANDLE hd)

{

  int idx;

  KEYBOX_HANDLE roverhd;

  if (!hd || !hd->kb || !hd->kb->handle_table)

    return;

  for (idx=0; idx < hd->kb->handle_table_size; idx++)

    if ((roverhd = hd->kb->handle_table[idx]))

      {

        if (roverhd->fp)

          {

            _keybox_ll_close (roverhd->fp);

            roverhd->fp = NULL;

          }

      }

  log_assert (!hd->fp);

}

/*

 * Lock the keybox at handle HD, or unlock if YES is false.  TIMEOUT

 * is the value used for dotlock_take.  In general -1 should be used

 * when taking a lock; use 0 when releasing a lock.

 */

gpg_error_t

keybox_lock (KEYBOX_HANDLE hd, int yes, long timeout)

{

  gpg_error_t err = 0;

  KB_NAME kb = hd->kb;

  if (!keybox_is_writable (kb))

    return 0;

  /* Make sure the lock handle has been created.  */

  if (!kb->lockhd)

    {

      kb->lockhd = dotlock_create (kb->fname, 0);

      if (!kb->lockhd)

        {

          err = gpg_error_from_syserror ();

          log_info ("can't allocate lock for '%s'\n", kb->fname );

          return err;

        }

    }

  if (yes) /* Take the lock.  */

    {

      if (!kb->is_locked)

        {

#ifdef HAVE_W32_SYSTEM

          /* Under Windows we need to close the file before we try

           * to lock it.  This is because another process might have

           * taken the lock and is using keybox_file_rename to

           * rename the base file.  Now if our dotlock_take below is

           * waiting for the lock but we have the base file still

           * open, keybox_file_rename will never succeed as we are

           * in a deadlock.  */

          _keybox_close_file (hd);

#endif /*HAVE_W32_SYSTEM*/

          if (dotlock_take (kb->lockhd, timeout))

            {

              err = gpg_error_from_syserror ();

              if (!timeout && gpg_err_code (err) == GPG_ERR_EACCES)

                ; /* No diagnostic if we only tried to lock.  */

              else

                log_info ("can't lock '%s'\n", kb->fname );

            }

          else

            kb->is_locked = 1;

        }

    }

  else /* Release the lock.  */

    {

      if (kb->is_locked)

        {

          if (dotlock_release (kb->lockhd))

            {

              err = gpg_error_from_syserror ();

              log_info ("can't unlock '%s'\n", kb->fname );

            }

          else

            kb->is_locked = 0;

        }

   }

  return err;

}