/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* db.c - Helper funcs for shared NSS database
 *
 * Copyright (C) 2008 Hans Petter Jansson
 *               2008-2010 Wolfgang Rosenauer
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Authors: Hans Petter Jansson <hpj@copyleft.no> 
 *          Wolfgang Rosenauer <wr@rosenauer.org> */

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>

#include <nspr.h>
#include <nss.h>
#include <pk11priv.h>
#include <pk11pub.h>

#include "nss-shared-helper.h"

#define DEFAULT_RELATIVE_PATH ".pki/nssdb"
#define DEFAULT_PATH          "/etc/pki/nssdb"

typedef struct {
  enum {
    PW_NONE = 0,
    PW_FROMFILE = 1,
    PW_PLAINTEXT = 2,
    PW_EXTERNAL = 3
  } source;
  char *data;
} secuPWData;

char *
nsshelp_get_user_db_path (void)
{
  const char  *env;
  char        *path;
  struct stat  sbuf;
  int          result;

  env = getenv ("NSS_SHARED_DB_PATH");
  
  if (env && *env) {
    path = strdup (env);
  } else {
    /*
    env = getenv ("HOME");
    if (!env || !*env)
    {
      fprintf (stderr, "*** nss-shared-helper: Could not determine shared NSS DB path!\n");
      return NULL;
    }

    path = malloc (strlen (env) + 1 + strlen (DEFAULT_RELATIVE_PATH) + 1);
    strcpy (path, env);
    strcat (path, "/");
    strcat (path, DEFAULT_RELATIVE_PATH);
    */
    path = strdup(DEFAULT_PATH);
  }

  /* Create path if it doesn't exist */

  result = stat (path, &sbuf);

  if (result != 0)
  {
    const char *p0 = path;
    const char *p1;

    while (*p0 == '/')
      p0++;

    /* Try to create it with restrictive permissions */

    do
    {
      p1 = strchr (p0, '/');

      if (p1 == NULL)
        p1 = p0 + strlen (p0);

      if (p1 != p0)
      {
        char *path_part = strdup (path);

        *(path_part + (p1 - path)) = '\0';
        mkdir (path_part, 0700);
      }

      p0 = p1 + 1;
    }
    while (*p1 != '\0');

    result = stat (path, &sbuf);
  }

  if (result == 0 && S_ISDIR (sbuf.st_mode))
    return path;

  free (path);
  return NULL;
}

SECStatus
nsshelp_open_db (const char *app_id, const char *old_path, PRUint32 flags)
{
  char *new_path;
  char *sdb_path;
  struct stat sbuf;
  int result;
  SECStatus rv;
  PK11SlotInfo *slot;
  secuPWData pwdata = { PW_NONE, 0 };

  if (!getenv ("NSS_USE_SHARED_DB"))
  {
    fprintf (stderr, "*** nss-shared-helper: Shared database disabled (set NSS_USE_SHARED_DB to enable).\n");

    rv = NSS_Initialize (old_path,
                         "", "", "secmod.db",
                         flags);
    return rv;
  }

  new_path = nsshelp_get_user_db_path ();
  if (!new_path)
    return SECFailure;

  fprintf (stderr, "*** nss-shared-helper: Using shared location %s\n", new_path);
  sdb_path = PR_smprintf ("sql:%s", new_path);

  /* simple update (application does not care about the
   * underlying state machine). */

  /* STEP 1: Signal that update/merge may be needed  */

  rv = NSS_InitWithMerge (sdb_path,
                          "", "", "secmod.db",
                          old_path, "", "",
                          app_id, app_id /* prompt name */,
                          flags);

  if (rv == SECFailure)
  {
    /* Don't migrate anything */

    fprintf (stderr, "*** nss-shared-helper: NSS_InitWithMerge failed. Trying NSS_Initialize.\n");

    rv = NSS_Initialize (sdb_path,
                         "", "", "secmod.db",
                         flags);
    PR_smprintf_free (sdb_path);

    if (rv == SECFailure)
      fprintf (stderr, "*** nss-shared-helper: NSS_Initialize failed.\n");

    return rv;
  }

  slot = PK11_GetInternalKeySlot();

  /* Step 2: Determine if update/merge is needed. */

  if (PK11_IsRemovable(slot))
  {
    /* need to update/Merge the database */

    /* Step 3: Authenticate to the token */

    rv = PK11_Authenticate(slot, PR_FALSE, &pwdata);
    if (rv == SECSuccess)
    {
      /* just update the state machine */

      /* Step 4: */
      PK11_IsLoggedIn(slot, &pwdata);
      /* Step 5: */
      PK11_IsPresent(slot);

      /* Step 6: */
      rv = PK11_Authenticate(slot, PR_FALSE, &pwdata);
      if (rv != SECSuccess)
      {
        fprintf (stderr, "*** nss-shared-helper: Second auth call failed: %u.\n",
                 PORT_GetError ());
      }
    }
    else
    {
      fprintf (stderr, "*** nss-shared-helper: First auth call failed: %u.\n",
               PORT_GetError ());
    }
  }

  /* Step 7: NSS is initialized and (possibly) merged, start using it */

  PR_smprintf_free (sdb_path);
  return SECSuccess;
}