/* t-gpgconf.c - Regression test.
 * Copyright (C) 2001, 2004, 2007 g10 Code GmbH
 *
 * This file is part of GPGME.
 *
 * GPGME 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.1 of
 * the License, or (at your option) any later version.
 *
 * GPGME 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 program; if not, see <https://gnu.org/licenses/>.
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>

#ifdef HAVE_W32_SYSTEM
#include <windows.h>
#endif

#include <gpgme.h>

#include "t-support.h"

static char *
spaces (char *str, int extra)
{
  static char buf[80];
  int len = str ? strlen (str) : 0;
  int n;

#define TABSTOP 30
  n = TABSTOP - len - extra;

  memset (buf, ' ', sizeof (buf));
  if (n < 1 || n > (sizeof (buf) - 1))
    {
      buf[0] = '\n';
      n = TABSTOP + 1;
    }

  buf[n] = '\0';
  return buf;
}


void
dump_arg (int type, gpgme_conf_arg_t arg)
{
  if (!arg)
    {
      printf ("(none)");
      return;
    }

  while (arg)
    {
      switch (type)
	{
	case GPGME_CONF_STRING:
	case GPGME_CONF_PATHNAME:
	case GPGME_CONF_LDAP_SERVER:
        case GPGME_CONF_KEY_FPR:
        case GPGME_CONF_PUB_KEY:
        case GPGME_CONF_SEC_KEY:
        case GPGME_CONF_ALIAS_LIST:
	  printf ("`%s'", arg->value.string);
	  break;

	case GPGME_CONF_UINT32:
	  printf ("%u", arg->value.uint32);
	  break;

	case GPGME_CONF_INT32:
	  printf ("%i", arg->value.int32);
	  break;

	case GPGME_CONF_NONE:
	  printf ("%i (times)", arg->value.count);
	  break;

	default:
	  printf ("(unknown type)");
	}

      arg = arg->next;
      if (arg)
	printf (" ");
    }
}


void
dump_opt (gpgme_conf_opt_t opt)
{
  char level;
  char runtime = (opt->flags & GPGME_CONF_RUNTIME) ? 'r' : ' ';

  switch (opt->level)
    {
    case GPGME_CONF_BASIC:
      level = 'b';
      break;
    case GPGME_CONF_ADVANCED:
      level = 'a';
      break;
    case GPGME_CONF_EXPERT:
      level = 'e';
      break;
    case GPGME_CONF_INVISIBLE:
      level = 'i';
      break;
    case GPGME_CONF_INTERNAL:
      level = '#';
      break;
    default:
      level = '?';
    }

  if (opt->flags & GPGME_CONF_GROUP)
    {
      printf ("\n");
      printf ("%c%c [%s]%s%s\n", level, runtime, opt->name, spaces (opt->name, 5),
	      opt->description
	      ? opt->description : "");
    }
  else
    {
      if (opt->argname)
	{
	  const char *more = (opt->flags & GPGME_CONF_LIST) ? "..." : "";

	  if (opt->flags & GPGME_CONF_OPTIONAL)
	    {
	      printf ("%c%c --%s [%s%s] %s", level, runtime, opt->name, opt->argname, more,
		      spaces (opt->name, 9 + strlen (opt->argname) + strlen (more)));
	    }
	  else
	    {
	      printf ("%c%c --%s %s%s %s", level, runtime, opt->name, opt->argname, more,
		      spaces (opt->name, 7 + strlen (opt->argname) + strlen (more)));
	    }
	}
      else
	printf ("%c%c --%s%s", level, runtime, opt->name, spaces (opt->name, 5));

      if (opt->description)
	printf ("%s", opt->description);
      printf ("\n");

      if (opt->flags & GPGME_CONF_DEFAULT)
	{
	  printf ("%s%s = ", spaces (NULL, 0), opt->argname ? opt->argname : "(default)");
	  dump_arg (opt->type, opt->default_value);
	  printf ("\n");
	}
      else if (opt->flags & GPGME_CONF_DEFAULT_DESC)
	printf ("%s%s = %s\n", spaces (NULL, 0), opt->argname ? opt->argname : "(default)",
		opt->default_description);

      if (opt->no_arg_value)
	{
	  printf ("%sNo Arg Def = ", spaces (NULL, 0));
	  dump_arg (opt->type, opt->no_arg_value);
	  printf ("\n");
	}
      if (opt->value)
	{
	  printf ("%sCurrent = ", spaces (NULL, 0));
	  dump_arg (opt->type, opt->value);
	  printf ("\n");
	}
    }

#if 0
  arg = comp->options;
  while (opt)
    {
      dump_opt (opt);
      opt = opt->next;
    }
#endif
}


void
dump_comp (gpgme_conf_comp_t comp)
{
  gpgme_conf_opt_t opt;

  printf ("COMPONENT\n");
  printf ("=========\n");
  printf ("  Name: %s\n", comp->name);
  if (comp->description)
    printf ("  Desc: %s\n", comp->description);
  if (comp->program_name)
    printf ("  Path: %s\n", comp->program_name);
  printf ("\n");

  opt = comp->options;
  while (opt)
    {
      dump_opt (opt);
      opt = opt->next;
    }
}


int
lookup (gpgme_conf_comp_t conf,
	const char *component,
	const char *option,
	gpgme_conf_comp_t *comp,
	gpgme_conf_opt_t *opt)
{
  *comp = conf;
  while (*comp && strcmp ((*comp)->name, component))
    *comp = (*comp)->next;

  if (*comp)
    {
      *opt = (*comp)->options;
      while (*opt && strcmp ((*opt)->name, option))
	*opt = (*opt)->next;

      /* Allow for the option not to be there.  */
      if (*opt)
	return 1;	/* Found.  */
    }

  return 0;		/* Not found.  */
}

#include <assert.h>


int
main (void)
{
  gpgme_ctx_t ctx;
  gpgme_error_t err;
  gpgme_conf_comp_t conf;
  gpgme_conf_comp_t comp;
  int first;
  int i, N = 10;

  init_gpgme (GPGME_PROTOCOL_GPGCONF);

  err = gpgme_new (&ctx);
  fail_if_err (err);

  {
    /* Let's check getting the agent-socket directory for different homedirs.  */
    char *result1 = NULL;
    char *result2 = NULL;
    err = gpgme_ctx_set_engine_info (ctx, GPGME_PROTOCOL_GPGCONF, NULL, "/tmp/foo");
    fail_if_err (err);
    err = gpgme_op_conf_dir (ctx, "agent-socket", &result1);
    fail_if_err (err);

    err = gpgme_ctx_set_engine_info (ctx, GPGME_PROTOCOL_GPGCONF, NULL, NULL);
    fail_if_err (err);
    err = gpgme_op_conf_dir (ctx, "agent-socket", &result2);
    fail_if_err (err);

    /* They have to be different.  */
    test (strcmp(result1, result2));
    gpgme_free (result1);
    gpgme_free (result2);
  }

  err = gpgme_op_conf_load (ctx, &conf);
  fail_if_err (err);

  comp = conf;
  first = 1;
  while (comp)
    {
      if (!first)
	printf ("\n");
      else
	first = 0;
      dump_comp (comp);
      comp = comp->next;
    }

  /* Now change something.  */
  fprintf (stderr, " dirmngr.verbose ");
  for (i = 0; i < N; i++) {
    unsigned int count = i % 4 + 1; /* counts must not be zero */
    gpgme_conf_arg_t arg;
    gpgme_conf_opt_t opt;

    err = gpgme_conf_arg_new (&arg, GPGME_CONF_NONE, &count);
    fail_if_err (err);

    if (lookup (conf, "dirmngr", "verbose", &comp, &opt))
      {
	/* Found.  */
	err = gpgme_conf_opt_change (opt, 0, arg);
	fail_if_err (err);

	err = gpgme_op_conf_save (ctx, comp);
	fail_if_err (err);
      }
    else
      {
	fprintf (stderr, "Skipping test, option dirmngr.verbose not found.\n");
	break;
      }

    /* Reload config and verify that the value was updated.  */
    gpgme_conf_release (conf);
    err = gpgme_op_conf_load (ctx, &conf);
    fail_if_err (err);
    if (lookup (conf, "dirmngr", "verbose", &comp, &opt))
      {
        /* Found.  */
        test (opt->alt_type == GPGME_CONF_NONE);
        test (opt->value);
        test ((unsigned long) opt->value->value.count == count);
      }

    fprintf (stderr, ".");
    fflush (stderr);
  }

  /* Now change something else.  */
  fprintf (stderr, " gpg.keyserver ");
  for (i = 0; i < N; i++) {
    const char *values[2] = { "hkp://foo.bar", "hkps://bar.foo" };
    gpgme_conf_arg_t arg;
    gpgme_conf_opt_t opt;

    err = gpgme_conf_arg_new (&arg, GPGME_CONF_STRING, values[i%2]);
    fail_if_err (err);

    if (lookup (conf, "gpg", "keyserver", &comp, &opt))
      {
	/* Found.  */
	test (opt->alt_type == GPGME_CONF_STRING);
	err = gpgme_conf_opt_change (opt, 0, arg);
	fail_if_err (err);

	err = gpgme_op_conf_save (ctx, comp);
	fail_if_err (err);
      }
    else
      {
	fprintf (stderr, "Skipping test, option gpg.keyserver not found.\n");
	break;
      }

    /* Reload config and verify that the value was updated.  */
    gpgme_conf_release (conf);
    err = gpgme_op_conf_load (ctx, &conf);
    fail_if_err (err);
    if (lookup (conf, "gpg", "keyserver", &comp, &opt))
      {
        /* Found.  */
        test (opt->alt_type == GPGME_CONF_STRING);
        test (opt->value);
        test (opt->value->value.string);
        test (strcmp (opt->value->value.string, values[i%2]) == 0);
      }

    fprintf (stderr, ".");
    fflush (stderr);
  }
  fprintf (stderr, "\n");

  gpgme_conf_release (conf);
  gpgme_release (ctx);
  return 0;
}