text:
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/* bus.c  message bus context object
 *
 * Copyright (C) 2003, 2004 Red Hat, Inc.
 *
 * Licensed under the Academic Free License version 2.1
 *
 * 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
 *
 */

#include <config.h>
#include "bus.h"

#include <stdio.h>

#include "activation.h"
#include "connection.h"
#include "services.h"
#include "utils.h"
#include "policy.h"
#include "config-parser.h"
#include "signals.h"
#include "selinux.h"
#include "dir-watch.h"
#include <dbus/dbus-list.h>
#include <dbus/dbus-hash.h>
#include <dbus/dbus-credentials.h>
#include <dbus/dbus-internals.h>

#ifdef DBUS_CYGWIN
#include <signal.h>
#endif

struct BusContext
{
  int refcount;
  DBusGUID uuid;
  char *config_file;
  char *type;
  char *servicehelper;
  char *address;
#ifdef WANT_PIDFILE
  char *pidfile;
#endif
  char *user;
  char *log_prefix;
  DBusLoop *loop;
  DBusList *servers;
  BusConnections *connections;
  BusActivation *activation;
  BusRegistry *registry;
  BusPolicy *policy;
  BusMatchmaker *matchmaker;
  BusLimits limits;
  unsigned int fork : 1;
  unsigned int syslog : 1;
  unsigned int keep_umask : 1;
  unsigned int allow_anonymous : 1;
  unsigned int systemd_activation : 1;
};

static dbus_int32_t server_data_slot = -1;

typedef struct
{
  BusContext *context;
} BusServerData;

#define BUS_SERVER_DATA(server) (dbus_server_get_data ((server), server_data_slot))

static BusContext*
server_get_context (DBusServer *server)
{
  BusContext *context;
  BusServerData *bd;

  if (!dbus_server_allocate_data_slot (&server_data_slot))
    return NULL;

  bd = BUS_SERVER_DATA (server);
  if (bd == NULL)
    {
      dbus_server_free_data_slot (&server_data_slot);
      return NULL;
    }

  context = bd->context;

  dbus_server_free_data_slot (&server_data_slot);

  return context;
}

static dbus_bool_t
server_watch_callback (DBusWatch     *watch,
                       unsigned int   condition,
                       void          *data)
{
  /* FIXME this can be done in dbus-mainloop.c
   * if the code in activation.c for the babysitter
   * watch handler is fixed.
   */

  return dbus_watch_handle (watch, condition);
}

static dbus_bool_t
add_server_watch (DBusWatch  *watch,
                  void       *data)
{
  DBusServer *server = data;
  BusContext *context;

  context = server_get_context (server);

  return _dbus_loop_add_watch (context->loop,
                               watch, server_watch_callback, server,
                               NULL);
}

static void
remove_server_watch (DBusWatch  *watch,
                     void       *data)
{
  DBusServer *server = data;
  BusContext *context;

  context = server_get_context (server);

  _dbus_loop_remove_watch (context->loop,
                           watch, server_watch_callback, server);
}

static void
server_timeout_callback (DBusTimeout   *timeout,
                         void          *data)
{
  /* can return FALSE on OOM but we just let it fire again later */
  dbus_timeout_handle (timeout);
}

static dbus_bool_t
add_server_timeout (DBusTimeout *timeout,
                    void        *data)
{
  DBusServer *server = data;
  BusContext *context;

  context = server_get_context (server);

  return _dbus_loop_add_timeout (context->loop,
                                 timeout, server_timeout_callback, server, NULL);
}

static void
remove_server_timeout (DBusTimeout *timeout,
                       void        *data)
{
  DBusServer *server = data;
  BusContext *context;

  context = server_get_context (server);

  _dbus_loop_remove_timeout (context->loop,
                             timeout, server_timeout_callback, server);
}

static void
new_connection_callback (DBusServer     *server,
                         DBusConnection *new_connection,
                         void           *data)
{
  BusContext *context = data;

  if (!bus_connections_setup_connection (context->connections, new_connection))
    {
      _dbus_verbose ("No memory to setup new connection\n");

      /* if we don't do this, it will get unref'd without
       * being disconnected... kind of strange really
       * that we have to do this, people won't get it right
       * in general.
       */
      dbus_connection_close (new_connection);
    }

  dbus_connection_set_max_received_size (new_connection,
                                         context->limits.max_incoming_bytes);

  dbus_connection_set_max_message_size (new_connection,
                                        context->limits.max_message_size);

  dbus_connection_set_max_received_unix_fds (new_connection,
                                         context->limits.max_incoming_unix_fds);

  dbus_connection_set_max_message_unix_fds (new_connection,
                                        context->limits.max_message_unix_fds);

  dbus_connection_set_allow_anonymous (new_connection,
                                       context->allow_anonymous);

  /* on OOM, we won't have ref'd the connection so it will die. */
}

static void
free_server_data (void *data)
{
  BusServerData *bd = data;

  dbus_free (bd);
}

static dbus_bool_t
setup_server (BusContext *context,
              DBusServer *server,
              char      **auth_mechanisms,
              DBusError  *error)
{
  BusServerData *bd;

  bd = dbus_new0 (BusServerData, 1);
  if (bd == NULL || !dbus_server_set_data (server,
                                           server_data_slot,
                                           bd, free_server_data))
    {
      dbus_free (bd);
      BUS_SET_OOM (error);
      return FALSE;
    }

  bd->context = context;

  if (!dbus_server_set_auth_mechanisms (server, (const char**) auth_mechanisms))
    {
      BUS_SET_OOM (error);
      return FALSE;
    }

  dbus_server_set_new_connection_function (server,
                                           new_connection_callback,
                                           context, NULL);

  if (!dbus_server_set_watch_functions (server,
                                        add_server_watch,
                                        remove_server_watch,
                                        NULL,
                                        server,
                                        NULL))
    {
      BUS_SET_OOM (error);
      return FALSE;
    }

  if (!dbus_server_set_timeout_functions (server,
                                          add_server_timeout,
                                          remove_server_timeout,
                                          NULL,
                                          server, NULL))
    {
      BUS_SET_OOM (error);
      return FALSE;
    }

  return TRUE;
}

/* This code only gets executed the first time the
 * config files are parsed.  It is not executed
 * when config files are reloaded.
 */
static dbus_bool_t
process_config_first_time_only (BusContext       *context,
				BusConfigParser  *parser,
                                const DBusString *address,
                                dbus_bool_t      systemd_activation,
				DBusError        *error)
{
  DBusString log_prefix;
  DBusList *link;
  DBusList **addresses;
  const char *user, *pidfile;
  char **auth_mechanisms;
  DBusList **auth_mechanisms_list;
  int len;
  dbus_bool_t retval;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  retval = FALSE;
  auth_mechanisms = NULL;

  _dbus_init_system_log ();

  context->systemd_activation = systemd_activation;

#ifdef WANT_PIDFILE
  /* Check for an existing pid file. Of course this is a race;
   * we'd have to use fcntl() locks on the pid file to
   * avoid that. But we want to check for the pid file
   * before overwriting any existing sockets, etc.
   */
  pidfile = bus_config_parser_get_pidfile (parser);
  if (pidfile != NULL)
    {
      DBusString u;
      DBusStat stbuf;

      _dbus_string_init_const (&u, pidfile);

      if (_dbus_stat (&u, &stbuf, NULL))
        {
#ifdef DBUS_CYGWIN
          DBusString p;
          long /* int */ pid;

          _dbus_string_init (&p);
          _dbus_file_get_contents(&p, &u, NULL);
          _dbus_string_parse_int(&p, 0, &pid, NULL);
          _dbus_string_free(&p);

          if ((kill((int)pid, 0))) {
            dbus_set_error(NULL, DBUS_ERROR_FILE_EXISTS,
                           "pid %ld not running, removing stale pid file\n",
                           pid);
            _dbus_delete_file(&u, NULL);
          } else {
#endif
          dbus_set_error (error, DBUS_ERROR_FAILED,
		                  "The pid file \"%s\" exists, if the message bus is not running, remove this file",
                          pidfile);
	      goto failed;
#ifdef DBUS_CYGWIN
          }
#endif
        }
    }

  /* keep around the pid filename so we can delete it later */
  context->pidfile = _dbus_strdup (pidfile);
#endif

  /* note that type may be NULL */
  context->type = _dbus_strdup (bus_config_parser_get_type (parser));
  if (bus_config_parser_get_type (parser) != NULL && context->type == NULL)
    goto oom;

  user = bus_config_parser_get_user (parser);
  if (user != NULL)
    {
      context->user = _dbus_strdup (user);
      if (context->user == NULL)
        goto oom;
    }

  /* Set up the prefix for syslog messages */
  if (!_dbus_string_init (&log_prefix))
    goto oom;
  if (context->type && !strcmp (context->type, "system"))
    {
      if (!_dbus_string_append (&log_prefix, "[system] "))
        goto oom;
    }
  else if (context->type && !strcmp (context->type, "session"))
    {
      DBusCredentials *credentials;

      credentials = _dbus_credentials_new_from_current_process ();
      if (!credentials)
        goto oom;
      if (!_dbus_string_append (&log_prefix, "[session "))
        {
          _dbus_credentials_unref (credentials);
          goto oom;
        }
      if (!_dbus_credentials_to_string_append (credentials, &log_prefix))
        {
          _dbus_credentials_unref (credentials);
          goto oom;
        }
      if (!_dbus_string_append (&log_prefix, "] "))
        {
          _dbus_credentials_unref (credentials);
          goto oom;
        }
      _dbus_credentials_unref (credentials);
    }
  if (!_dbus_string_steal_data (&log_prefix, &context->log_prefix))
    goto oom;
  _dbus_string_free (&log_prefix);

  /* Build an array of auth mechanisms */

  auth_mechanisms_list = bus_config_parser_get_mechanisms (parser);
  len = _dbus_list_get_length (auth_mechanisms_list);

  if (len > 0)
    {
      int i;

      auth_mechanisms = dbus_new0 (char*, len + 1);
      if (auth_mechanisms == NULL)
        goto oom;

      i = 0;
      link = _dbus_list_get_first_link (auth_mechanisms_list);
      while (link != NULL)
        {
          auth_mechanisms[i] = _dbus_strdup (link->data);
          if (auth_mechanisms[i] == NULL)
            goto oom;
          link = _dbus_list_get_next_link (auth_mechanisms_list, link);
          i += 1;
        }
    }
  else
    {
      auth_mechanisms = NULL;
    }

  /* Listen on our addresses */

  if (address)
    {
      DBusServer *server;

      server = dbus_server_listen (_dbus_string_get_const_data(address), error);
      if (server == NULL)
        {
          _DBUS_ASSERT_ERROR_IS_SET (error);
          goto failed;
        }
      else if (!setup_server (context, server, auth_mechanisms, error))
        {
          _DBUS_ASSERT_ERROR_IS_SET (error);
          goto failed;
        }

      if (!_dbus_list_append (&context->servers, server))
        goto oom;
    }
  else
    {
      addresses = bus_config_parser_get_addresses (parser);

      link = _dbus_list_get_first_link (addresses);
      while (link != NULL)
        {
          DBusServer *server;

          server = dbus_server_listen (link->data, error);
          if (server == NULL)
            {
              _DBUS_ASSERT_ERROR_IS_SET (error);
              goto failed;
            }
          else if (!setup_server (context, server, auth_mechanisms, error))
            {
              _DBUS_ASSERT_ERROR_IS_SET (error);
              goto failed;
            }

          if (!_dbus_list_append (&context->servers, server))
            goto oom;

          link = _dbus_list_get_next_link (addresses, link);
        }
    }

  context->fork = bus_config_parser_get_fork (parser);
  context->syslog = bus_config_parser_get_syslog (parser);
  context->keep_umask = bus_config_parser_get_keep_umask (parser);
  context->allow_anonymous = bus_config_parser_get_allow_anonymous (parser);

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  retval = TRUE;

 failed:
  dbus_free_string_array (auth_mechanisms);
  return retval;

 oom:
  BUS_SET_OOM (error);
  dbus_free_string_array (auth_mechanisms);
  return FALSE;
}

/* This code gets executed every time the config files
 * are parsed: both during BusContext construction
 * and on reloads. This function is slightly screwy
 * since it can do a "half reload" in out-of-memory
 * situations. Realistically, unlikely to ever matter.
 */
static dbus_bool_t
process_config_every_time (BusContext      *context,
			   BusConfigParser *parser,
			   dbus_bool_t      is_reload,
			   DBusError       *error)
{
  DBusString full_address;
  DBusList *link;
  DBusList **dirs;
  BusActivation *new_activation;
  char *addr;
  const char *servicehelper;
  char *s;

  dbus_bool_t retval;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  addr = NULL;
  retval = FALSE;

  if (!_dbus_string_init (&full_address))
    {
      BUS_SET_OOM (error);
      return FALSE;
    }

  /* get our limits and timeout lengths */
  bus_config_parser_get_limits (parser, &context->limits);

  if (context->policy)
    bus_policy_unref (context->policy);
  context->policy = bus_config_parser_steal_policy (parser);
  _dbus_assert (context->policy != NULL);

  /* We have to build the address backward, so that
   * <listen> later in the config file have priority
   */
  link = _dbus_list_get_last_link (&context->servers);
  while (link != NULL)
    {
      addr = dbus_server_get_address (link->data);
      if (addr == NULL)
        {
          BUS_SET_OOM (error);
          goto failed;
        }

      if (_dbus_string_get_length (&full_address) > 0)
        {
          if (!_dbus_string_append (&full_address, ";"))
            {
              BUS_SET_OOM (error);
              goto failed;
            }
        }

      if (!_dbus_string_append (&full_address, addr))
        {
          BUS_SET_OOM (error);
          goto failed;
        }

      dbus_free (addr);
      addr = NULL;

      link = _dbus_list_get_prev_link (&context->servers, link);
    }

  if (is_reload)
    dbus_free (context->address);

  if (!_dbus_string_copy_data (&full_address, &context->address))
    {
      BUS_SET_OOM (error);
      goto failed;
    }

  /* get the service directories */
  dirs = bus_config_parser_get_service_dirs (parser);

  /* and the service helper */
  servicehelper = bus_config_parser_get_servicehelper (parser);

  s = _dbus_strdup(servicehelper);
  if (s == NULL && servicehelper != NULL)
    {
      BUS_SET_OOM (error);
      goto failed;
    }
  else
    {
      dbus_free(context->servicehelper);
      context->servicehelper = s;
    }

  /* Create activation subsystem */
  if (context->activation)
    {
      if (!bus_activation_reload (context->activation, &full_address, dirs, error))
        goto failed;
    }
  else
    {
      context->activation = bus_activation_new (context, &full_address, dirs, error);
    }

  if (context->activation == NULL)
    {
      _DBUS_ASSERT_ERROR_IS_SET (error);
      goto failed;
    }

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  retval = TRUE;

 failed:
  _dbus_string_free (&full_address);

  if (addr)
    dbus_free (addr);

  return retval;
}

static dbus_bool_t
list_concat_new (DBusList **a,
                 DBusList **b,
                 DBusList **result)
{
  DBusList *link;

  *result = NULL;

  for (link = _dbus_list_get_first_link (a); link; link = _dbus_list_get_next_link (a, link))
    {
      if (!_dbus_list_append (result, link->data))
        goto oom;
    }
  for (link = _dbus_list_get_first_link (b); link; link = _dbus_list_get_next_link (b, link))
    {
      if (!_dbus_list_append (result, link->data))
        goto oom;
    }

  return TRUE;
oom:
  _dbus_list_clear (result);
  return FALSE;
}

static void
raise_file_descriptor_limit (BusContext      *context)
{

  /* I just picked this out of thin air; we need some extra
   * descriptors for things like any internal pipes we create,
   * inotify, connections to SELinux, etc.
   */
  unsigned int arbitrary_extra_fds = 32;
  unsigned int limit;

  limit = context->limits.max_completed_connections +
    context->limits.max_incomplete_connections
    + arbitrary_extra_fds;

  _dbus_request_file_descriptor_limit (limit);
}

static dbus_bool_t
process_config_postinit (BusContext      *context,
			 BusConfigParser *parser,
			 DBusError       *error)
{
  DBusHashTable *service_context_table;
  DBusList *watched_dirs = NULL;

  raise_file_descriptor_limit (context);

  service_context_table = bus_config_parser_steal_service_context_table (parser);
  if (!bus_registry_set_service_context_table (context->registry,
					       service_context_table))
    {
      BUS_SET_OOM (error);
      return FALSE;
    }

  _dbus_hash_table_unref (service_context_table);

  /* We need to monitor both the configuration directories and directories
   * containing .service files.
   */
  if (!list_concat_new (bus_config_parser_get_conf_dirs (parser),
                        bus_config_parser_get_service_dirs (parser),
                        &watched_dirs))
    {
      BUS_SET_OOM (error);
      return FALSE;
    }

  bus_set_watched_dirs (context, &watched_dirs);

  _dbus_list_clear (&watched_dirs);

  return TRUE;
}

BusContext*
bus_context_new (const DBusString *config_file,
                 ForceForkSetting  force_fork,
                 DBusPipe         *print_addr_pipe,
                 DBusPipe         *print_pid_pipe,
                 const DBusString *address,
                 dbus_bool_t      systemd_activation,
                 DBusError        *error)
{
  DBusString log_prefix;
  BusContext *context;
  BusConfigParser *parser;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  context = NULL;
  parser = NULL;

  if (!dbus_server_allocate_data_slot (&server_data_slot))
    {
      BUS_SET_OOM (error);
      return NULL;
    }

  context = dbus_new0 (BusContext, 1);
  if (context == NULL)
    {
      BUS_SET_OOM (error);
      goto failed;
    }
  context->refcount = 1;

  _dbus_generate_uuid (&context->uuid);

  if (!_dbus_string_copy_data (config_file, &context->config_file))
    {
      BUS_SET_OOM (error);
      goto failed;
    }

  context->loop = _dbus_loop_new ();
  if (context->loop == NULL)
    {
      BUS_SET_OOM (error);
      goto failed;
    }

  context->registry = bus_registry_new (context);
  if (context->registry == NULL)
    {
      BUS_SET_OOM (error);
      goto failed;
    }

  parser = bus_config_load (config_file, TRUE, NULL, error);
  if (parser == NULL)
    {
      _DBUS_ASSERT_ERROR_IS_SET (error);
      goto failed;
    }

  if (!process_config_first_time_only (context, parser, address, systemd_activation, error))
    {
      _DBUS_ASSERT_ERROR_IS_SET (error);
      goto failed;
    }
  if (!process_config_every_time (context, parser, FALSE, error))
    {
      _DBUS_ASSERT_ERROR_IS_SET (error);
      goto failed;
    }

  /* we need another ref of the server data slot for the context
   * to own
   */
  if (!dbus_server_allocate_data_slot (&server_data_slot))
    _dbus_assert_not_reached ("second ref of server data slot failed");

  /* Note that we don't know whether the print_addr_pipe is
   * one of the sockets we're using to listen on, or some
   * other random thing. But I think the answer is "don't do
   * that then"
   */
  if (print_addr_pipe != NULL && _dbus_pipe_is_valid (print_addr_pipe))
    {
      DBusString addr;
      const char *a = bus_context_get_address (context);
      int bytes;

      _dbus_assert (a != NULL);
      if (!_dbus_string_init (&addr))
        {
          BUS_SET_OOM (error);
          goto failed;
        }

      if (!_dbus_string_append (&addr, a) ||
          !_dbus_string_append (&addr, "\n"))
        {
          _dbus_string_free (&addr);
          BUS_SET_OOM (error);
          goto failed;
        }

      bytes = _dbus_string_get_length (&addr);
      if (_dbus_pipe_write (print_addr_pipe, &addr, 0, bytes, error) != bytes)
        {
          /* pipe write returns an error on failure but not short write */
          if (error != NULL && !dbus_error_is_set (error))
            {
              dbus_set_error (error, DBUS_ERROR_FAILED,
                              "Printing message bus address: did not write all bytes\n");
            }
          _dbus_string_free (&addr);
          goto failed;
        }

      if (!_dbus_pipe_is_stdout_or_stderr (print_addr_pipe))
        _dbus_pipe_close (print_addr_pipe, NULL);

      _dbus_string_free (&addr);
    }

  context->connections = bus_connections_new (context);
  if (context->connections == NULL)
    {
      BUS_SET_OOM (error);
      goto failed;
    }

  context->matchmaker = bus_matchmaker_new ();
  if (context->matchmaker == NULL)
    {
      BUS_SET_OOM (error);
      goto failed;
    }

  /* check user before we fork */
  if (context->user != NULL)
    {
      if (!_dbus_verify_daemon_user (context->user))
        {
          dbus_set_error (error, DBUS_ERROR_FAILED,
                          "Could not get UID and GID for username \"%s\"",
                          context->user);
          goto failed;
        }
    }

  /* Now become a daemon if appropriate and write out pid file in any case */
  {
#ifdef WANT_PIDFILE
    DBusString u;

    if (context->pidfile)
      _dbus_string_init_const (&u, context->pidfile);

    if ((force_fork != FORK_NEVER && context->fork) || force_fork == FORK_ALWAYS)
      {
        _dbus_verbose ("Forking and becoming daemon\n");

        if (!_dbus_become_daemon (context->pidfile ? &u : NULL,
                                  print_pid_pipe,
                                  error,
                                  context->keep_umask))

          {
            _DBUS_ASSERT_ERROR_IS_SET (error);
            goto failed;
          }
      }
    else
      {
        _dbus_verbose ("Fork not requested\n");

        /* Need to write PID file and to PID pipe for ourselves,
         * not for the child process. This is a no-op if the pidfile
         * is NULL and print_pid_pipe is NULL.
         */
        if (!_dbus_write_pid_to_file_and_pipe (context->pidfile ? &u : NULL,
                                               print_pid_pipe,
                                               _dbus_getpid (),
                                               error))
          {
            _DBUS_ASSERT_ERROR_IS_SET (error);
            goto failed;
          }
      }
#else
    if ((force_fork != FORK_NEVER && context->fork) || force_fork == FORK_ALWAYS)
      {
        if (!_dbus_become_daemon (NULL,
                                  0,
                                  error,
                                  context->keep_umask))
          {
            _DBUS_ASSERT_ERROR_IS_SET (error);
            goto failed;
          }
      }
#endif
  }

  if (print_pid_pipe && _dbus_pipe_is_valid (print_pid_pipe) &&
      !_dbus_pipe_is_stdout_or_stderr (print_pid_pipe))
    _dbus_pipe_close (print_pid_pipe, NULL);

  if (!bus_selinux_full_init ())
    {
      bus_context_log (context, DBUS_SYSTEM_LOG_FATAL, "SELinux enabled but AVC initialization failed; check system log\n");
    }

  if (!process_config_postinit (context, parser, error))
    {
      _DBUS_ASSERT_ERROR_IS_SET (error);
      goto failed;
    }

  if (parser != NULL)
    {
      bus_config_parser_unref (parser);
      parser = NULL;
    }

  /* Here we change our credentials if required,
   * as soon as we've set up our sockets and pidfile
   */
  if (context->user != NULL)
    {
      if (!_dbus_change_to_daemon_user (context->user, error))
	{
	  _DBUS_ASSERT_ERROR_IS_SET (error);
	  goto failed;
	}

#ifdef HAVE_SELINUX
      /* FIXME - why not just put this in full_init() below? */
      bus_selinux_audit_init ();
#endif
    }

  dbus_server_free_data_slot (&server_data_slot);

  return context;

 failed:
  if (parser != NULL)
    bus_config_parser_unref (parser);
  if (context != NULL)
    bus_context_unref (context);

  if (server_data_slot >= 0)
    dbus_server_free_data_slot (&server_data_slot);

  return NULL;
}

dbus_bool_t
bus_context_get_id (BusContext       *context,
                    DBusString       *uuid)
{
  return _dbus_uuid_encode (&context->uuid, uuid);
}

dbus_bool_t
bus_context_reload_config (BusContext *context,
			   DBusError  *error)
{
  BusConfigParser *parser;
  DBusString config_file;
  dbus_bool_t ret;

  /* Flush the user database cache */
  _dbus_flush_caches ();

  ret = FALSE;
  _dbus_string_init_const (&config_file, context->config_file);
  parser = bus_config_load (&config_file, TRUE, NULL, error);
  if (parser == NULL)
    {
      _DBUS_ASSERT_ERROR_IS_SET (error);
      goto failed;
    }

  if (!process_config_every_time (context, parser, TRUE, error))
    {
      _DBUS_ASSERT_ERROR_IS_SET (error);
      goto failed;
    }
  if (!process_config_postinit (context, parser, error))
    {
      _DBUS_ASSERT_ERROR_IS_SET (error);
      goto failed;
    }
  ret = TRUE;

  bus_context_log (context, DBUS_SYSTEM_LOG_INFO, "Reloaded configuration");
 failed:
  if (!ret)
    bus_context_log (context, DBUS_SYSTEM_LOG_INFO, "Unable to reload configuration: %s", error->message);
  if (parser != NULL)
    bus_config_parser_unref (parser);
  return ret;
}

static void
shutdown_server (BusContext *context,
                 DBusServer *server)
{
  if (server == NULL ||
      !dbus_server_get_is_connected (server))
    return;

  if (!dbus_server_set_watch_functions (server,
                                        NULL, NULL, NULL,
                                        context,
                                        NULL))
    _dbus_assert_not_reached ("setting watch functions to NULL failed");

  if (!dbus_server_set_timeout_functions (server,
                                          NULL, NULL, NULL,
                                          context,
                                          NULL))
    _dbus_assert_not_reached ("setting timeout functions to NULL failed");

  dbus_server_disconnect (server);
}

void
bus_context_shutdown (BusContext  *context)
{
  DBusList *link;

  link = _dbus_list_get_first_link (&context->servers);
  while (link != NULL)
    {
      shutdown_server (context, link->data);

      link = _dbus_list_get_next_link (&context->servers, link);
    }
}

BusContext *
bus_context_ref (BusContext *context)
{
  _dbus_assert (context->refcount > 0);
  context->refcount += 1;

  return context;
}

void
bus_context_unref (BusContext *context)
{
  _dbus_assert (context->refcount > 0);
  context->refcount -= 1;

  if (context->refcount == 0)
    {
      DBusList *link;

      _dbus_verbose ("Finalizing bus context %p\n", context);

      bus_context_shutdown (context);

      if (context->connections)
        {
          bus_connections_unref (context->connections);
          context->connections = NULL;
        }

      if (context->registry)
        {
          bus_registry_unref (context->registry);
          context->registry = NULL;
        }

      if (context->activation)
        {
          bus_activation_unref (context->activation);
          context->activation = NULL;
        }

      link = _dbus_list_get_first_link (&context->servers);
      while (link != NULL)
        {
          dbus_server_unref (link->data);

          link = _dbus_list_get_next_link (&context->servers, link);
        }
      _dbus_list_clear (&context->servers);

      if (context->policy)
        {
          bus_policy_unref (context->policy);
          context->policy = NULL;
        }

      if (context->loop)
        {
          _dbus_loop_unref (context->loop);
          context->loop = NULL;
        }

      if (context->matchmaker)
        {
          bus_matchmaker_unref (context->matchmaker);
          context->matchmaker = NULL;
        }

      dbus_free (context->config_file);
      dbus_free (context->log_prefix);
      dbus_free (context->type);
      dbus_free (context->address);
      dbus_free (context->user);
      dbus_free (context->servicehelper);

#ifdef WANT_PIDFILE
      if (context->pidfile)
	{
          DBusString u;
          _dbus_string_init_const (&u, context->pidfile);

          /* Deliberately ignore errors here, since there's not much
	   * we can do about it, and we're exiting anyways.
	   */
	  _dbus_delete_file (&u, NULL);

          dbus_free (context->pidfile);
	}
#endif

      dbus_free (context);

      dbus_server_free_data_slot (&server_data_slot);
    }
}

/* type may be NULL */
const char*
bus_context_get_type (BusContext *context)
{
  return context->type;
}

const char*
bus_context_get_address (BusContext *context)
{
  return context->address;
}

const char*
bus_context_get_servicehelper (BusContext *context)
{
  return context->servicehelper;
}

dbus_bool_t
bus_context_get_systemd_activation (BusContext *context)
{
  return context->systemd_activation;
}

BusRegistry*
bus_context_get_registry (BusContext  *context)
{
  return context->registry;
}

BusConnections*
bus_context_get_connections (BusContext  *context)
{
  return context->connections;
}

BusActivation*
bus_context_get_activation (BusContext  *context)
{
  return context->activation;
}

BusMatchmaker*
bus_context_get_matchmaker (BusContext  *context)
{
  return context->matchmaker;
}

DBusLoop*
bus_context_get_loop (BusContext *context)
{
  return context->loop;
}

dbus_bool_t
bus_context_allow_unix_user (BusContext   *context,
                             unsigned long uid)
{
  return bus_policy_allow_unix_user (context->policy,
                                     uid);
}

/* For now this is never actually called because the default
 * DBusConnection behavior of 'same user that owns the bus can connect'
 * is all it would do.
 */
dbus_bool_t
bus_context_allow_windows_user (BusContext       *context,
                                const char       *windows_sid)
{
  return bus_policy_allow_windows_user (context->policy,
                                        windows_sid);
}

BusPolicy *
bus_context_get_policy (BusContext *context)
{
  return context->policy;
}

BusClientPolicy*
bus_context_create_client_policy (BusContext      *context,
                                  DBusConnection  *connection,
                                  DBusError       *error)
{
  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
  return bus_policy_create_client_policy (context->policy, connection,
                                          error);
}

int
bus_context_get_activation_timeout (BusContext *context)
{

  return context->limits.activation_timeout;
}

int
bus_context_get_auth_timeout (BusContext *context)
{
  return context->limits.auth_timeout;
}

int
bus_context_get_max_completed_connections (BusContext *context)
{
  return context->limits.max_completed_connections;
}

int
bus_context_get_max_incomplete_connections (BusContext *context)
{
  return context->limits.max_incomplete_connections;
}

int
bus_context_get_max_connections_per_user (BusContext *context)
{
  return context->limits.max_connections_per_user;
}

int
bus_context_get_max_pending_activations (BusContext *context)
{
  return context->limits.max_pending_activations;
}

int
bus_context_get_max_services_per_connection (BusContext *context)
{
  return context->limits.max_services_per_connection;
}

int
bus_context_get_max_match_rules_per_connection (BusContext *context)
{
  return context->limits.max_match_rules_per_connection;
}

int
bus_context_get_max_replies_per_connection (BusContext *context)
{
  return context->limits.max_replies_per_connection;
}

int
bus_context_get_reply_timeout (BusContext *context)
{
  return context->limits.reply_timeout;
}

void
bus_context_log (BusContext *context, DBusSystemLogSeverity severity, const char *msg, ...) _DBUS_GNUC_PRINTF (3, 4);

void
bus_context_log (BusContext *context, DBusSystemLogSeverity severity, const char *msg, ...)
{
  va_list args;

  if (!context->syslog)
    {
      /* we're not syslogging; just output to stderr */
      va_start (args, msg);
      vfprintf (stderr, msg, args);
      fprintf (stderr, "\n");
      va_end (args);
      return;
    }

  va_start (args, msg);

  if (context->log_prefix)
    {
      DBusString full_msg;

      if (!_dbus_string_init (&full_msg))
        goto out;
      if (!_dbus_string_append (&full_msg, context->log_prefix))
        goto oom_out;
      if (!_dbus_string_append_printf_valist (&full_msg, msg, args))
        goto oom_out;

      _dbus_system_log (severity, "%s", _dbus_string_get_const_data (&full_msg));
    oom_out:
      _dbus_string_free (&full_msg);
    }
  else
    _dbus_system_logv (severity, msg, args);

out:
  va_end (args);
}

static inline const char *
nonnull (const char *maybe_null,
         const char *if_null)
{
  return (maybe_null ? maybe_null : if_null);
}

/*
 * Log something about a message, usually that it was rejected.
 */
static void
complain_about_message (BusContext     *context,
                        const char     *error_name,
                        const char     *complaint,
                        int             matched_rules,
                        DBusMessage    *message,
                        DBusConnection *sender,
                        DBusConnection *proposed_recipient,
                        dbus_bool_t     requested_reply,
                        dbus_bool_t     log,
                        DBusError      *error)
{
  DBusError stack_error = DBUS_ERROR_INIT;
  const char *sender_name;
  const char *sender_loginfo;
  const char *proposed_recipient_loginfo;

  if (error == NULL && !log)
    return;

  if (sender != NULL)
    {
      sender_name = bus_connection_get_name (sender);
      sender_loginfo = bus_connection_get_loginfo (sender);
    }
  else
    {
      sender_name = "(unset)";
      sender_loginfo = "(bus)";
    }

  if (proposed_recipient != NULL)
    proposed_recipient_loginfo = bus_connection_get_loginfo (proposed_recipient);
  else
    proposed_recipient_loginfo = "bus";

  dbus_set_error (&stack_error, error_name,
      "%s, %d matched rules; type=\"%s\", sender=\"%s\" (%s) "
      "interface=\"%s\" member=\"%s\" error name=\"%s\" "
      "requested_reply=\"%d\" destination=\"%s\" (%s)",
      complaint,
      matched_rules,
      dbus_message_type_to_string (dbus_message_get_type (message)),
      sender_name,
      sender_loginfo,
      nonnull (dbus_message_get_interface (message), "(unset)"),
      nonnull (dbus_message_get_member (message), "(unset)"),
      nonnull (dbus_message_get_error_name (message), "(unset)"),
      requested_reply,
      nonnull (dbus_message_get_destination (message), DBUS_SERVICE_DBUS),
      proposed_recipient_loginfo);

  /* If we hit OOM while setting the error, this will syslog "out of memory"
   * which is itself an indication that something is seriously wrong */
  if (log)
    bus_context_log (context, DBUS_SYSTEM_LOG_SECURITY, "%s",
        stack_error.message);

  dbus_move_error (&stack_error, error);
}

/*
 * addressed_recipient is the recipient specified in the message.
 *
 * proposed_recipient is the recipient we're considering sending
 * to right this second, and may be an eavesdropper.
 *
 * sender is the sender of the message.
 *
 * NULL for proposed_recipient or sender definitely means the bus driver.
 *
 * NULL for addressed_recipient may mean the bus driver, or may mean
 * no destination was specified in the message (e.g. a signal).
 */
dbus_bool_t
bus_context_check_security_policy (BusContext     *context,
                                   BusTransaction *transaction,
                                   DBusConnection *sender,
                                   DBusConnection *addressed_recipient,
                                   DBusConnection *proposed_recipient,
                                   DBusMessage    *message,
                                   DBusError      *error)
{
  const char *dest;
  BusClientPolicy *sender_policy;
  BusClientPolicy *recipient_policy;
  dbus_int32_t toggles;
  dbus_bool_t log;
  int type;
  dbus_bool_t requested_reply;
  const char *sender_name;
  const char *sender_loginfo;
  const char *proposed_recipient_loginfo;

  type = dbus_message_get_type (message);
  dest = dbus_message_get_destination (message);

  /* dispatch.c was supposed to ensure these invariants */
  _dbus_assert (dest != NULL ||
                type == DBUS_MESSAGE_TYPE_SIGNAL ||
                (sender == NULL && !bus_connection_is_active (proposed_recipient)));
  _dbus_assert (type == DBUS_MESSAGE_TYPE_SIGNAL ||
                addressed_recipient != NULL ||
                strcmp (dest, DBUS_SERVICE_DBUS) == 0);

  switch (type)
    {
    case DBUS_MESSAGE_TYPE_METHOD_CALL:
    case DBUS_MESSAGE_TYPE_SIGNAL:
    case DBUS_MESSAGE_TYPE_METHOD_RETURN:
    case DBUS_MESSAGE_TYPE_ERROR:
      break;

    default:
      _dbus_verbose ("security check disallowing message of unknown type %d\n",
                     type);

      dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
                      "Message bus will not accept messages of unknown type\n");

      return FALSE;
    }

  requested_reply = FALSE;

  if (sender != NULL)
    {
      /* First verify the SELinux access controls.  If allowed then
       * go on with the standard checks.
       */
      if (!bus_selinux_allows_send (sender, proposed_recipient,
				    dbus_message_type_to_string (dbus_message_get_type (message)),
				    dbus_message_get_interface (message),
				    dbus_message_get_member (message),
				    dbus_message_get_error_name (message),
				    dest ? dest : DBUS_SERVICE_DBUS, error))
        {
          if (error != NULL && !dbus_error_is_set (error))
            {
              /* don't syslog this, just set the error: avc_has_perm should
               * have already written to either the audit log or syslog */
              complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
                  "An SELinux policy prevents this sender from sending this "
                  "message to this recipient",
                  0, message, sender, proposed_recipient, FALSE, FALSE, error);
              _dbus_verbose ("SELinux security check denying send to service\n");
            }

          return FALSE;
        }

      if (bus_connection_is_active (sender))
        {
          sender_policy = bus_connection_get_policy (sender);
          _dbus_assert (sender_policy != NULL);

          /* Fill in requested_reply variable with TRUE if this is a
           * reply and the reply was pending.
           */
          if (dbus_message_get_reply_serial (message) != 0)
            {
              if (proposed_recipient != NULL /* not to the bus driver */ &&
                  addressed_recipient == proposed_recipient /* not eavesdropping */)
                {
                  DBusError error2;

                  dbus_error_init (&error2);
                  requested_reply = bus_connections_check_reply (bus_connection_get_connections (sender),
                                                                 transaction,
                                                                 sender, addressed_recipient, message,
                                                                 &error2);
                  if (dbus_error_is_set (&error2))
                    {
                      dbus_move_error (&error2, error);
                      return FALSE;
                    }
                }
            }
        }
      else
        {
          /* Policy for inactive connections is that they can only send
           * the hello message to the bus driver
           */
          if (proposed_recipient == NULL &&
              dbus_message_is_method_call (message,
                                           DBUS_INTERFACE_DBUS,
                                           "Hello"))
            {
              _dbus_verbose ("security check allowing %s message\n",
                             "Hello");
              return TRUE;
            }
          else
            {
              _dbus_verbose ("security check disallowing non-%s message\n",
                             "Hello");

              dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
                              "Client tried to send a message other than %s without being registered",
                              "Hello");

              return FALSE;
            }
        }
    }
  else
    {
      sender_policy = NULL;

      /* If the sender is the bus driver, we assume any reply was a
       * requested reply as bus driver won't send bogus ones
       */
      if (addressed_recipient == proposed_recipient /* not eavesdropping */ &&
          dbus_message_get_reply_serial (message) != 0)
        requested_reply = TRUE;
    }

  _dbus_assert ((sender != NULL && sender_policy != NULL) ||
                (sender == NULL && sender_policy == NULL));

  if (proposed_recipient != NULL)
    {
      /* only the bus driver can send to an inactive recipient (as it
       * owns no services, so other apps can't address it). Inactive
       * recipients can receive any message.
       */
      if (bus_connection_is_active (proposed_recipient))
        {
          recipient_policy = bus_connection_get_policy (proposed_recipient);
          _dbus_assert (recipient_policy != NULL);
        }
      else if (sender == NULL)
        {
          _dbus_verbose ("security check using NULL recipient policy for message from bus\n");
          recipient_policy = NULL;
        }
      else
        {
          _dbus_assert_not_reached ("a message was somehow sent to an inactive recipient from a source other than the message bus\n");
          recipient_policy = NULL;
        }
    }
  else
    recipient_policy = NULL;

  _dbus_assert ((proposed_recipient != NULL && recipient_policy != NULL) ||
                (proposed_recipient != NULL && sender == NULL && recipient_policy == NULL) ||
                (proposed_recipient == NULL && recipient_policy == NULL));

  log = FALSE;
  if (sender_policy &&
      !bus_client_policy_check_can_send (sender_policy,
                                         context->registry,
                                         requested_reply,
                                         proposed_recipient,
                                         message, &toggles, &log))
    {
      const char *msg = "Rejected send message, %d matched rules; "
                        "type=\"%s\", sender=\"%s\" (%s) interface=\"%s\" member=\"%s\" error name=\"%s\" requested_reply=%d destination=\"%s\" (%s))";

      complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
          "Rejected send message", toggles,
          message, sender, proposed_recipient, requested_reply,
          (addressed_recipient == proposed_recipient), error);
      _dbus_verbose ("security policy disallowing message due to sender policy\n");
      return FALSE;
    }

  if (log)
    {
      /* We want to drop this message, and are only not doing so for backwards
       * compatibility. */
      complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
          "Would reject message", toggles,
          message, sender, proposed_recipient, requested_reply,
          TRUE, NULL);
    }

  if (recipient_policy &&
      !bus_client_policy_check_can_receive (recipient_policy,
                                            context->registry,
                                            requested_reply,
                                            sender,
                                            addressed_recipient, proposed_recipient,
                                            message, &toggles))
    {
      complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
          "Rejected receive message", toggles,
          message, sender, proposed_recipient, requested_reply,
          (addressed_recipient == proposed_recipient), NULL);
      _dbus_verbose ("security policy disallowing message due to recipient policy\n");
      return FALSE;
    }

  /* See if limits on size have been exceeded */
  if (proposed_recipient &&
      ((dbus_connection_get_outgoing_size (proposed_recipient) > context->limits.max_outgoing_bytes) ||
       (dbus_connection_get_outgoing_unix_fds (proposed_recipient) > context->limits.max_outgoing_unix_fds)))
    {
      complain_about_message (context, DBUS_ERROR_LIMITS_EXCEEDED,
          "Rejected: destination has a full message queue",
          0, message, sender, proposed_recipient, requested_reply, TRUE,
          error);
      _dbus_verbose ("security policy disallowing message due to full message queue\n");
      return FALSE;
    }

  /* Record that we will allow a reply here in the future (don't
   * bother if the recipient is the bus or this is an eavesdropping
   * connection). Only the addressed recipient may reply.
   */
  if (type == DBUS_MESSAGE_TYPE_METHOD_CALL &&
      sender &&
      addressed_recipient &&
      addressed_recipient == proposed_recipient && /* not eavesdropping */
      !bus_connections_expect_reply (bus_connection_get_connections (sender),
                                     transaction,
                                     sender, addressed_recipient,
                                     message, error))
    {
      _dbus_verbose ("Failed to record reply expectation or problem with the message expecting a reply\n");
      return FALSE;
    }

  _dbus_verbose ("security policy allowing message\n");
  return TRUE;
}


text:
<?php

namespace Namshi\JOSE\Test;

use DateTime;
use Namshi\JOSE\JWS;
use PHPUnit_Framework_TestCase as TestCase;
use Prophecy\Argument;

class JWSTest extends TestCase
{
    const SSL_KEY_PASSPHRASE = 'tests';

    public function setup()
    {
        $date = new DateTime('tomorrow');
        $data = array(
            'a' => 'b'
        );
        $this->jws = new JWS(array('alg' => 'RS256'));
        $this->jws->setPayload($data);
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testLoadingUnsecureJwsWithNoneAlgo()
    {
        $date = new DateTime('tomorrow');
        $data = array(
            'a' => 'b',
            'exp' => $date->format('U')
        );
        $this->jws = new JWS(array('alg' => 'None'));
        $this->jws->setPayload($data);
        $this->jws->sign('111');

        $jws = JWS::load($this->jws->getTokenString());
        $this->assertFalse($jws->verify('111'));

        $payload = $jws->getPayload();
        $this->assertEquals('b', $payload['a']);
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testLoadingUnsecureJwsWithLowercaseNone()
    {
        $date = new DateTime('tomorrow');
        $data = array(
            'a' => 'b',
            'exp' => $date->format('U')
        );
        $this->jws = new JWS(array('alg' => 'none'));
        $this->jws->setPayload($data);
        $this->jws->sign('111');

        $jws = JWS::load($this->jws->getTokenString());
        $this->assertFalse($jws->verify('111'));

        $payload = $jws->getPayload();
        $this->assertEquals('b', $payload['a']);
    }

    public function testAllowingUnsecureJws()
    {
        $date = new DateTime('tomorrow');
        $data = array(
            'a' => 'b',
            'exp' => $date->format('U')
        );
        $this->jws = new JWS(array('alg' => 'None'));
        $this->jws->setPayload($data);
        $this->jws->sign('111');

        $jws = JWS::load($this->jws->getTokenString(), true);
        $this->assertTrue($jws->verify('111'));

        $payload = $jws->getPayload();
        $this->assertEquals('b', $payload['a']);
    }

    public function testRestrictingTheAlgorithmsKo()
    {
        $this->jws = new JWS(array('alg' => 'HS256'));
        $this->jws->sign('12345');

        $jws = JWS::load($this->jws->getTokenString());
        $this->assertFalse($jws->verify('12345', 'RS256'));
    }

    public function testRestrictingTheAlgorithmsOk()
    {
        $date = new DateTime('tomorrow');
        $data = array(
            'a' => 'b',
            'exp' => $date->format('U')
        );
        $this->jws = new JWS(array('alg' => 'HS256'));
        $this->jws->setPayload($data);
        $this->jws->sign('123');

        $jws = JWS::load($this->jws->getTokenString());
        $this->assertTrue($jws->verify('123', 'HS256'));
    }

    public function testVerificationRS256()
    {
        $privateKey = openssl_pkey_get_private(SSL_KEYS_PATH . "private.key", self::SSL_KEY_PASSPHRASE);
        $this->jws->sign($privateKey);

        $jws = JWS::load($this->jws->getTokenString());
        $public_key = openssl_pkey_get_public(SSL_KEYS_PATH . "public.key");
        $this->assertTrue($jws->verify($public_key));

        $payload = $jws->getPayload();
        $this->assertEquals('b', $payload['a']);
    }

    public function testVerificationRS256KeyAsString()
    {
        $privateKey = file_get_contents(TEST_DIR . "/private.key");//, self::SSL_KEY_PASSPHRASE);
        $this->jws->sign($privateKey, self::SSL_KEY_PASSPHRASE);

        $jws = JWS::load($this->jws->getTokenString());
        $public_key = openssl_pkey_get_public(SSL_KEYS_PATH . "public.key");
        $this->assertTrue($jws->verify($public_key));

        $payload = $jws->getPayload();
        $this->assertEquals('b', $payload['a']);
    }

    public function testUseOfCustomEncoder()
    {
        $encoder = $this->prophesize('Namshi\JOSE\Base64\Encoder');
        $encoder
            ->decode(Argument::any())
            ->willReturn('{"whatever": "the payload should be"}')
            ->shouldBeCalled();
        $encoder
            ->decode(Argument::any())
            ->willReturn('{"alg": "test"}')
            ->shouldBeCalled();
        JWS::load($this->jws->getTokenString(), false, $encoder->reveal());
    }

    public function testVerificationThatTheJWSIsSigned()
    {
        $privateKey = openssl_pkey_get_private(SSL_KEYS_PATH . "private.key", self::SSL_KEY_PASSPHRASE);
        $this->jws->sign($privateKey);
        $this->assertTrue($this->jws->isSigned());
    }

    public function testVerificationThatTheJWSIsNotSigned()
    {
        $this->assertFalse($this->jws->isSigned());
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testWrongVerificationRS256()
    {
        $privateKey = openssl_pkey_get_private(SSL_KEYS_PATH . "private.key", self::SSL_KEY_PASSPHRASE);
        $this->jws->sign($privateKey);

        $jws = JWS::load('eyJhbGciOiJ0ZXN0In0=.eyJhbGciOiJ0ZXN0In0=.eyJhbGciOiJ0ZXN0In0=');
        $public_key = openssl_pkey_get_public(SSL_KEYS_PATH . "public.key");
        $this->assertFalse($jws->verify($public_key));
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testLoadingAMalformedTokenString()
    {
        JWS::load('test.Test.TEST');
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testLoadingAMalformedTokenString2()
    {
        JWS::load('test');
    }

    public function testSignAndVerifyWithFalsePublicKey()
    {
        $public_key = false;
        $jwsHMAC = new JWS(array('alg' => 'HS256'));

        $jwsHMAC->sign(false);
        $jws = JWS::load($jwsHMAC->getTokenString());

        $this->assertFalse($jws->verify($public_key));

    }

    public function testSignAndVerifyWithEmptyStringPublicKey()
    {
        $public_key = false;
        $jwsHMAC = new JWS(array('alg' => 'HS256'));

        $jwsHMAC->sign('');
        $jws = JWS::load($jwsHMAC->getTokenString());

        $this->assertFalse($jws->verify($public_key));

    }

    public function testLoadingWithAnyOrderOfHeaders()
    {
        $privateKey = openssl_pkey_get_private(SSL_KEYS_PATH . "private.key", self::SSL_KEY_PASSPHRASE);
        $public_key = openssl_pkey_get_public(SSL_KEYS_PATH . "public.key");

        $this->jws = new JWS(array('alg' => 'RS256', 'custom' => '1'));

        $header = $this->jws->getHeader();
        $reversedHeader = array_reverse($header);
        $this->assertFalse($header === $reversedHeader);

        $this->jws->setHeader($reversedHeader);
        $this->jws->sign($privateKey);

        $tokenString = $this->jws->getTokenString();
        $jws = JWS::load($tokenString);
        $this->assertTrue($reversedHeader === $jws->getHeader());
    }

    public function testSignAndVerifyWithSecLib()
    {
        $jwsRSA = new JWS(array('alg' => 'RS256'), 'SecLib');
        $data = array('a' => 'b',);
        $jwsRSA->setPayload($data);

        $jwsRSA->sign(file_get_contents(SSL_KEYS_PATH . "private.key"), 'tests');
        $jws = JWS::load($jwsRSA->getTokenString(), false, null, 'SecLib');

        $this->assertTrue($jws->verify(file_get_contents(SSL_KEYS_PATH . "public.key", 'RS256')));
    }

    public function testConstructionFromHeader()
    {
        $header = array('alg' => 'RS256', 'test' => true);
        $jws = new JWS($header);

        $this->assertTrue($header == $jws->getHeader());
    }

    public function testVerificationCustomizedHeader()
    {
        $header = $this->jws->getHeader();
        $header['test'] = true;
        $this->jws->setHeader($header);

        $privateKey = openssl_pkey_get_private(SSL_KEYS_PATH . "private.key", self::SSL_KEY_PASSPHRASE);
        $this->jws->sign($privateKey);

        $jws = JWS::load($this->jws->getTokenString());
        $public_key = openssl_pkey_get_public(SSL_KEYS_PATH . "public.key");
        $headerFromSig = $jws->getHeader();

        $this->assertSame($headerFromSig['test'], true);
        $this->assertTrue($jws->verify($public_key));
    }
}

redpajama_set_name: RedPajamaGithub


text:
namespace igl
{
  // Triangulate a general polygonal mesh into a triangle mesh.
  //
  // Inputs:
  //   vF  list of polygon index lists
  // Outputs:
  //   F  eigen int matrix #F by 3
  //
  // Example:
  //   vector<vector<double > > vV;
  //   vector<vector<int > > vF;
  //   read_triangle_mesh("poly.obj",vV,vF);
  //   MatrixXd V;
  //   MatrixXi F;
  //   list_to_matrix(vV,V);
  //   triangulate(vF,F);
  template <typename Index, typename DerivedF>
  IGL_INLINE void polygon_mesh_to_triangle_mesh(
    const std::vector<std::vector<Index> > & vF,
    Eigen::PlainObjectBase<DerivedF>& F);
  template <typename DerivedP, typename DerivedF>
  IGL_INLINE void polygon_mesh_to_triangle_mesh(
    const Eigen::PlainObjectBase<DerivedP>& P,
    Eigen::PlainObjectBase<DerivedF>& F);
}

#ifndef IGL_STATIC_LIBRARY
#  include "polygon_mesh_to_triangle_mesh.cpp"
#endif

#endif


text:
using System.Collections.Generic;
using System.Linq;
using System.Net;
using JetBlack.MessageBus.FeedBus.Distributor.Config;

namespace JetBlack.MessageBus.FeedBus.Distributor
{
    internal class PermissionManager
    {
        private readonly DistributorConfig _configuration;
        private readonly IPAddress _ipAddress;
        private readonly string _user;
        private readonly IDictionary<string, IDictionary<ClientRole, bool>> feedDecision = new Dictionary<string, IDictionary<ClientRole, bool>>();

        public PermissionManager(DistributorConfig configuration, IPAddress ipAddress, string user)
        {
            _configuration = configuration;
            _ipAddress = ipAddress;
            _user = user;
        }

        public bool HasRole(string feed, ClientRole role)
        {
            IDictionary<ClientRole, bool> roleDecision;
            if (!feedDecision.TryGetValue(feed, out roleDecision))
                feedDecision.Add(feed, roleDecision = new Dictionary<ClientRole, bool>());
            bool decision;
            if (roleDecision.TryGetValue(role, out decision))
                return decision;

            // Check the distributor.
            if ((_configuration.Allow & role) == role)
                decision = true;
            // Deny overrides allow.
            if ((_configuration.Deny & role) == role)
                decision = false;

            // Is there a feed definition?
            FeedConfig feedConfiguration;
            if (_configuration.FeedConfigurations.TryGetValue(feed, out feedConfiguration))
            {
                // Feed configuration overrides distributor.
                if ((feedConfiguration.Allow & role) == role)
                    decision = true;
                // Deny overrides allow.
                if ((feedConfiguration.Deny & role) == role)
                    decision = false;

                // Is there a client definition?
                var client = feedConfiguration.Clients.FirstOrDefault(c => IPAddress.Equals(c.IPAddress, _ipAddress) && string.Equals(c.User, _user));
                if (client != null)
                {
                    // Client configuration overrides feed.
                    if ((client.Allow & role) == role)
                        decision = true;
                    // Deny overrides allow.
                    if ((client.Deny & role) == role)
                        decision = false;
                }
            }

            // Cache the decision;
            roleDecision.Add(role, decision);

            return decision;
        }
    }
}


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

    <title>protoplug: Example sinemouse-demo.lua</title>
    <link rel="stylesheet" href="../ldoc.css" type="text/css" />

<big></big>

protoplug

	Lua API reference

Index

Examples

classic-filter.lua

sine-organ.lua

midi-chordify.lua

sinemouse-demo.lua

soundfile-test.lua

Modules

plugin

script

midi

gui

polyGen

stereoFx

Classes

juce.AffineTransform

juce.AudioFormatReader

juce.Colour

juce.ColourGradient

juce.Component

juce.FillType

juce.Font

juce.Graphics

juce.Image

juce.Justification

juce.LagrangeInterpolator

juce.Line

juce.Path

juce.Point

juce.RectanglePlacement

juce.Rectangle_float

juce.Rectangle_int

--[[
name: sinemouse demo
description: >
  Custom GUI demonstration : Drag your mouse around in the
  frame to control the sine wave's amplitude and frequency.
author: osar.fr
--]]

require "include/protoplug"

local freq,amp = 440, 0
local delta, phase = 0.06, 0

function plugin.processBlock(samples, smax)
	for i=0,smax do
		local s = math.sin(phase)*amp
		samples[0][i] = s -- left
		samples[1][i] = s -- right
		phase = phase + delta
	end
end

local J = juce
local frame = J.Rectangle_int(20,20,400,300)
local sideways = J.AffineTransform():rotated(math.pi*0.5)

function gui.paint(g)
	g:fillAll()
	g:setColour(J.Colour.green)
	g:drawRect(frame)
	g:drawText("Frequency", 20, 320, 400, 20, J.Justification.centred)
	g:addTransform(sideways)
	g:drawText("amplitude", 20, -440, 300, 20, J.Justification.centred)
end

local function mouseHandler(event)
	if not frame:contains(J.Point(event.x,event.y)) then
		return
	end
	freq = event.x + 80
	amp = (320-event.y)/300
	local sr = plugin.isSampleRateKnown() and plugin.getSampleRate() or 44100
	delta = 2*math.pi*freq/sr
end

gui.addHandler("mouseDrag", mouseHandler)
gui.addHandler("mouseDown", mouseHandler)

generated by LDoc 1.4.2


text:
package eu.modernmt.engine;

/**
 * Created by davide on 19/04/16.
 */
public class BootstrapException extends Exception {

    public BootstrapException(Throwable cause) {
        super(cause);
    }

    public BootstrapException(String message) {
        super(message);
    }

    public BootstrapException(String message, Throwable cause) {
        super(message, cause);
    }

    protected BootstrapException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}


text:
require "forecastr/version"

module ForecastR
  # Your code goes here...
end


text:
#include "ServiceInstaller.h"
#include "ServiceBase.h"
#include <iostream>
#include <Windows.h>
#include "Prgram.h"

#define SERVICE_NAME             L"XSIncGAW"
#define SERVICE_DISPLAY_NAME     L"XSIncGAW"
#define SERVICE_START_TYPE       SERVICE_AUTO_START
#define SERVICE_DEPENDENCIES     L""
#define SERVICE_ACCOUNT          NULL
#define SERVICE_PASSWORD         NULL

using namespace std;

int WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR    lpCmdLine,
                     int       nCmdShow)
{
    ServerStart();
    return 0;
}
/*
int wmain(int argc, wchar_t* argv[]) {
	FreeConsole();
	ServerStart();
	/*if (argc > 1) {
		if (_wcsicmp(argv[1], L"-install") == 0) {
			InstallService(
				SERVICE_NAME,               // Name of service
				SERVICE_DISPLAY_NAME,       // Name to display
				SERVICE_START_TYPE,         // Service start type
				SERVICE_DEPENDENCIES,       // Dependencies
				SERVICE_ACCOUNT,            // Service running account
				SERVICE_PASSWORD            // Password of the account
				);
			::Sleep(1000);

			DoStart(SERVICE_NAME);
		}
		else if (_wcsicmp(argv[1], L"-delete") == 0) {
			UninstallService(SERVICE_NAME);
		}
		else {
			cout << "e.g " << argv[0] << " (-install, -delete)" << endl;
		}
	}
	else {
		CServiceBase* service = new CServiceBase(SERVICE_NAME);
		if (!CServiceBase::Run(*service))
		{
			wprintf(L"Service failed to run w/err 0x%08lx\n", GetLastError());
		}
	}
	return 0;
}*/


text:
ALTER TABLE `event_cases`
    CHANGE `update_at` `update_at` timestamp NULL DEFAULT CURRENT_TIMESTAMP;


text:
$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
$LOAD_PATH.unshift(File.dirname(__FILE__))

require 'bundler'
Bundler.setup :default, :test

require 'active_support/core_ext/hash/conversions'
require 'grape/jbuilder'
require 'json_expressions/rspec'
require 'ostruct'
require 'rack/test'
require 'rspec'

RSpec.configure do |config|
  config.include Rack::Test::Methods
end

Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}


text:
namespace Microsoft.Azure.Management.Storage
{
  using System;
  using System.Collections.Generic;
  using System.Linq;

  internal static partial class SdkInfo
  {
      public static IEnumerable<Tuple<string, string, string>> ApiInfo_StorageManagementClient
      {
          get
          {
              return new Tuple<string, string, string>[]
              {
                new Tuple<string, string, string>("Storage", "BlobContainers", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "BlobInventoryPolicies", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "BlobServices", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "DeletedAccounts", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "EncryptionScopes", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "FileServices", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "FileShares", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "ManagementPolicies", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "ObjectReplicationPolicies", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "Operations", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "PrivateEndpointConnections", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "PrivateLinkResources", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "Queue", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "QueueServices", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "Skus", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "StorageAccounts", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "Table", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "TableServices", "2021-02-01"),
                new Tuple<string, string, string>("Storage", "Usages", "2021-02-01"),
              }.AsEnumerable();
          }
      }
      // BEGIN: Code Generation Metadata Section
      public static readonly String AutoRestVersion = "v2";
      public static readonly String AutoRestBootStrapperVersion = "autorest@2.0.4413";
      public static readonly String AutoRestCmdExecuted = "cmd.exe /c autorest.cmd https://github.com/Azure/azure-rest-api-specs/blob/master/specification/storage/resource-manager/readme.md --csharp --version=v2 --reflect-api-versions --csharp.output-folder=C:\\code\\srpsdk\\sdk\\storage\\Microsoft.Azure.Management.Storage\\src\\Generated";
      public static readonly String GithubForkName = "Azure";
      public static readonly String GithubBranchName = "master";
      public static readonly String GithubCommidId = "5d89c9807d3e84a5890b381a68a308198f9ef141";
      public static readonly String CodeGenerationErrors = "";
      public static readonly String GithubRepoName = "azure-rest-api-specs";
      // END: Code Generation Metadata Section
  }
}


text:
.vimrc
======

A short & sweet configuration for Vim 7.4, optimized for web design and front-end web development.

Rationale
---------
I got tired of using pre-built Vim configs because they were usually slow, loaded with stuff I don't need, and confusing to customize. So I started growing my own, and then I decided, "Hey, this became a useful config. I need to get this on my other computers and might as well share it with the public in the process."
It's meant to be first and foremost simple and easy to hack on. There's nothing special about it; it's the stuff you would write in a new .vimrc anyway.

Installation
------------
Grab the patched Anonymous Pro font ("Anonymice Powerline") from (Lokaltog/powerline-fonts)[1], or use a font of your choice and adjust .vimrc (search for "Anonymice Powerline"). If your font isn't patched to contain powerline/airline symbols, disable those by changing the airline setting to 0 (search for "airline_powerline_fonts").

Also install Exuberant Ctags if you haven't already. (And if you haven't, shame on you! You're missing out.) Alternatively, just remove the taglist.vim and tagbar plugins, but I highly recommend ctags.

Then just [download my .vimrc][2] and copy it to wherever your OS puts yours. It's not meant to be cloned because it's meant for you to customize. My .vimrc should just be a solid base for yours, plus some packages helpful for front-end work. Those are delete-key friendly if you don't do web.

[1]: https://github.com/Lokaltog/powerline-fonts
[2]: https://raw2.github.com/alpha123/.vimrc/master/.vimrc


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Text;
using System.Threading.Tasks;

namespace ClarityServices.LedorVador {

    public class LedorVadorResponse {
        public List<int> documentosAceptados = new List<int>();
        public List<int> documentosOmitidos = new List<int>();
        public string responseMessage = "";
    }
    public class LedorVadorRequest {
        public string login = "";
        public string password ="";
        public List<LedorVadorFlowPackage> packages = new List<LedorVadorFlowPackage>();
    }
    public class LedorVadorFlowPackage {
        public int histClinica;
        public string razonSocial;
        public int empresaPropia;
        public string documento_externId;
        public string establecimiento_numero;
        public string documento_numero;
        public DateTime fecha;
        public string observacion;
        public int tipoServicioId;
        public int tipoImpuestoId_Iva;
        public double cantidad;
        public double importeUnitario;
    }

    [ServiceContract]
    public interface ILedorVadorFlowService {

        [OperationContract]
        LedorVadorResponse SendPackages(LedorVadorRequest request);

    }

}


text:
<#
The MIT License (MIT)

Copyright (c) 2015 Objectivity Bespoke Software Specialists

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
#>

function Protect-WebConfig {
    <#
    .SYNOPSIS
    Encrypt section in web.confing in the $Path.

    .DESCRIPTION
    It will encypt $Section in the web.config in the $Path using aspnet_regiis.exe.

    .PARAMETER Path
    Directory where web.config is located.

    .PARAMETER Section
    Section to encrypt. Default is "connectionStrings".

    .EXAMPLE
    Protect-WebConfig -Path "C:\inetpub\wwwroot\Application" -Section "connectionStrings"
    #>
    [CmdletBinding()]
    [OutputType([void])]
    param(
        [Parameter(Mandatory=$true)]
        [string]
        $Path,

        [Parameter(Mandatory=$false)]
        [string]
        $Section = "connectionStrings"
    )

    $aspnet_regiis = Join-Path -Path $env:windir -ChildPath "Microsoft.NET\Framework\v4.0.30319\aspnet_regiis.exe"
    if(!(Test-Path -LiteralPath $aspnet_regiis))
    {
        throw "$aspnet_regiis doesn't exists."
    }

    Write-Log -Info "Start encrypt web.config section $Section in $Path"

    $argumentsList = "-pef $Section $Path"

    Start-ExternalProcess -Command $aspnet_regiis -ArgumentList $argumentsList

    Write-Log -Info "End encrypt web.config section $Section in $Path"
}


text:
from datetime import date, timedelta
from random import uniform

from numpy import ndarray

def _generator(x):
    return uniform(0, 1)

class gdata(object):

    def __init__(self, data):
        self.data = data

    def __iter__(self):
        return (v for v in self.data)

def datepopulate(size = 10, start=None, delta=1):
    dt = start or date.today() - timedelta(days=delta*(size-1))
    td = timedelta(days=delta)
    return [dt+s*td for s in range(size)]

def populate(size=100, cols=1, generator=None):
    generator = generator or _generator
    data = ndarray([size,cols])
    for c in range(0, cols):
        data[:, c] = [generator(i) for i in range(0, size)]
    return data

def polygen(*coefficients):
    '''Polynomial generating function'''
    if not coefficients:
        return lambda i: 0
    else:
        c0 = coefficients[0]
        coefficients = coefficients[1:]

        def _(i):
            v = c0
            for c in coefficients:
                v += c*i
                i *= i
            return v

        return _


text:
using System;
using CefSharp;
using TweetLib.Browser.CEF.Interfaces;

namespace TweetImpl.CefSharp.Adapters {
	sealed class CefAdapter : ICefAdapter {
		public static CefAdapter Instance { get; } = new ();

		private CefAdapter() {}

		public void RunOnUiThread(Action action) {
			Cef.UIThreadTaskFactory.StartNew(action);
		}
	}
}


text:
This flying reptile has large, leathery wings and a vibrantly colored crest on its horned, narrow-snouted head.

**YrthakCR 9**

**XP 6,400**

N Huge [magical beast](monsters/creatureTypes#_magical-beast)

**Init** +6; **Senses** [blindsight](monsters/universalMonsterRules#_blindsight) 120 ft.; [Perception](additionalMonsters/../skills/perception#_perception) +18

Defense

**AC** 23, touch 11, flat-footed 20 (+2 Dex, +1 dodge, +12 natural, –2 size)

**hp** 114 (12d10+48)

**Fort** +12, **Ref** +12, **Will** +8

**Immune** [gaze](monsters/universalMonsterRules#_gaze) attacks, visual effects and illusions, sight-based attacks, sonic

**Weaknesses** blind

Offense

**Speed** 20 ft., fly 60 ft. (average)

**Melee** bite +17 (2d6+7), 2 claws +17 (1d8+7)

**Ranged** sonic lance +12 ranged touch (8d6 sonic)

**Space** 15 ft.; **Reach** 10 ft.

**Special Attacks** explosion

Statistics

**Str** 24, **Dex** 14, **Con** 18, **Int** 7, **Wis** 15, **Cha** 11

**Base Atk** +12; **CMB** +21; **CMD** 34 (38 vs. trip)

**Feats** [Dodge](additionalMonsters/../feats#_dodge), [Flyby Attack](additionalMonsters/../monsters/monsterFeats#_flyby-attack), Improved
Initiative, [Iron Will](additionalMonsters/../feats#_iron-will), [Lightning Reflexes](additionalMonsters/../feats#_lightning-reflexes),
 [Skill Focus](additionalMonsters/../feats#_skill-focus) ( [Perception](additionalMonsters/../skills/perception#_perception))

**Skills** [Fly](additionalMonsters/../skills/fly#_fly) +7, [Perception](additionalMonsters/../skills/perception#_perception) +18; **Racial Modifiers** +4 [Perception](additionalMonsters/../skills/perception#_perception)

**Languages** Draconic

Ecology

**Environment** temperate deserts, hills, or mountains

**Organization** solitary, pair, or clutch (3–6)

**Treasure** incidental

Special Abilities

**Blind (Ex)** A yrthak sees and senses exclusively through its [blindsight](monsters/universalMonsterRules#_blindsight) ability, which is based on sound and movement—beyond 120 feet, it is considered blind. A deaf yrthak is effectively blinded as well except against adjacent foes—its weak eyesight functions enough for it to attack targets this close, although in such cases these creatures still gain the benefit of concealment (20% miss chance) because of the creature's poor vision. It is invulnerable to all sight-based effects and attacks, including [gaze](monsters/universalMonsterRules#_gaze) attacks.

**Explosion (Ex)** As a standard action, a yrthak can [fire](monsters/creatureTypes#_fire-subtype) its sonic lance at the ground, a large rock, a stone wall, or a similar nonmagical object within 60 feet to create an explosion. This attack deals 2d6 points of piercing damage to all within 10 feet of the effect's center.

**Sonic Lance (Ex)** Once per round, a yrthak can focus sonic energy in a 60-foot ray that deals 8d6 sonic damage to one target.

Swift, cunning, and perpetually ravenous, the yrthak terrorizes the barren wastelands in which it makes its home, swooping down from on high to blast prey with bursts of pure sound. Though technically blind, as its eyes are tiny and barely capable of vision beyond a few feet, the yrthak senses its surroundings via acute hearing and echolocation. While its powerful jaws and claws are equally capable of taking down opponents, the yrthak generally prefers to wheel through the sky on its membranous wings, firing bolt after bolt of sound into its prey, and exulting in the thrill of the hunt. An adult yrthak is 20 feet long and weighs 1,500 pounds.

Yrthaks spend most of their time aloft—a yrthak hunt often lasts several days, with the yrthak skimming roughly 100 feet over the ground in its wide-ranging search for live prey, only resorting to grazing on carrion in direst need. While they have near-human intelligence, yrthaks generally do not seem interested in forming societies of their own—although the sight of a clutch of yrthaks tormenting a captured morsel might seem to indicate otherwise.


text:
.merchant-listings, .merchant-cart {
  overflow-x: scroll; }

.order .segment {
  margin-bottom: 0px; }
  .order .segment .order-segment-details {
    margin-top: 5px;
    margin-bottom: 0px; }
.order .details {
  display: none; }

.listing-contain .custom-search .search-bar input[name=main-search] {
  position: fixed !important;
  left: 0px !important;
  top: 75px;
  height: 75px;
  padding: 20px;
  width: 75% !important;
  border-radius: 0px !important;
  background: #FFFFFF !important;
  z-index: 500; }
  @media screen and (max-width: 768px) {
    .listing-contain .custom-search .search-bar input[name=main-search] {
      width: 60% !important; } }
.listing-contain .custom-search .side-bar {
  background: #FFFFFF;
  border-right: 1px solid #CCC;
  padding: 20px;
  padding-bottom: 30px;
  line-height: 40px;
  width: 250px;
  position: fixed !important;
  left: 0px;
  height: 100%;
  top: 150px; }
  .listing-contain .custom-search .side-bar input {
    border-radius: 0px !important; }
  @media screen and (max-width: 768px) {
    .listing-contain .custom-search .side-bar {
      display: none; } }
.listing-contain .custom-search .submit-section button {
  position: fixed !important;
  top: 75px;
  right: 0px;
  width: 12.5%;
  border-radius: 0px;
  margin: 0px;
  height: 75px;
  z-index: 500; }
  @media screen and (max-width: 768px) {
    .listing-contain .custom-search .submit-section button {
      right: 0%;
      width: 20%; } }
.listing-contain .custom-search .submit-section .clearbutton {
  position: fixed !important;
  top: 75px;
  right: 12.5%;
  width: 12.5%;
  border-radius: 0px;
  margin: 0px;
  padding-top: 30px;
  line-height: 14px;
  height: 75px;
  z-index: 500; }
  @media screen and (max-width: 768px) {
    .listing-contain .custom-search .submit-section .clearbutton {
      right: 20%;
      width: 20%; } }
.listing-contain .listings {
  position: absolute !important;
  left: 300px;
  font-size: 1.10em !important; }
  @media screen and (max-width: 768px) {
    .listing-contain .listings {
      left: 10px; } }

.pagination-styles {
  position: relative;
  bottom: 0;
  z-index: 10; }

/*# sourceMappingURL=merchant.css.map */


text:
package org.ensembl.healthcheck.configurationmanager;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.ensembl.healthcheck.configurationmanager.AbstractAliasAwareConfigurationBacking.configurationDataType;

import uk.co.flamingpenguin.jewel.cli.Option;

/**
 *
 * Provides methods for classes that operate on objects implementing the
 * configuration interface. These objects are the objects proxying the
 * configuration interface and the ConfigurationDumper.
 *
 */
public class ConfigurationProcessor<T> {

	/**
	 * @param A
	 *            method of type java.lang.reflect.Method
	 * @return true, if the method expects a java.util.List of Strings, false
	 *         otherwise.
	 */
	boolean listOfStringsExpected(Method m) {

		boolean listOfStringsExpected = false;

		Type t = m.getGenericReturnType();

		if (t instanceof ParameterizedType) {

			Type rawType = ((ParameterizedType) t).getRawType();
			Type actualType = ((ParameterizedType) t).getActualTypeArguments()[0];

			listOfStringsExpected = rawType.equals(java.util.List.class)
					&& actualType.equals(java.lang.String.class);

		}
		return listOfStringsExpected;
	}

	/**
	 * @param m
	 *            - A method
	 * @return True, if the method name begins with get, false otherwise
	 */
	boolean isGetMethod(Method m) {
		return isGetMethod(m.getName());
	}

	boolean isGetMethod(String m) {
		return m.startsWith("get");
	}

	/**
	 * @param m
	 *            - A method
	 * @return True, if the method name begins with is, false otherwise
	 */
	boolean isIsMethod(Method m) {
		return isIsMethod(m.getName());
	}

	boolean isIsMethod(String m) {
		return m.startsWith("is");
	}

	/**
	 * @param m
	 * @return
	 *
	 *         returns the name of a variable requested by a method.
	 *
	 *         getHost will return host getDatabase will return database etc.
	 *
	 */
	String getVariableRequested(Method m) {
		return getVariableRequested(m.getName());
	}

	String getVariableRequested(String methodName) {

		if (isGetMethod(methodName)) {
			return methodName.substring(3).toLowerCase();
		}

		if (isIsMethod(methodName)) {
			return methodName.substring(2).toLowerCase();
		}

		throw new IllegalArgumentException("Method " + methodName
				+ " is an unknown type of method!");
	}

	/**
	 *

	 * Creates a map that maps the name of a variable, as it may be requested in
	 * a get method like configuration.get*someVariable* to all its possible
	 * aliases. Aliases for variables can be specified in the configuration
	 * interface as long- or short name annotations like these:
	 *

	 *
	 *

	 * @Option(longName = "output.databases")
	 * List<String> getOutputDatabases();
	 *

	 *
	 * or
	 *
	 *

	 * @Option(shortName = "c")
	 * List<File> getConf();
	 *

	 *
	 */
	public Map<String, Set<String>> createVarName2AllAliases(
			Class<T> configurationClass) {

		Map<String, Set<String>> varName2AllAliases = new HashMap<String, Set<String>>();

		List<Method> getMethods = getGetMethods(configurationClass);

		for (Method getMethod : getMethods) {

			varName2AllAliases.put(getVariableRequested(getMethod),
					getAliases(getMethod));
		}
		return varName2AllAliases;
	}

	public Map<String, String> createAlias2CanonicalVarName(
			Class<T> configurationClass) {

		Map<String, String> alias2MethodName = new HashMap<String, String>();

		List<Method> getMethods = getGetMethods(configurationClass);

		for (Method getMethod : getMethods) {

			String methodName = getVariableRequested(getMethod);

			for (String possibleName : getAliases(getMethod)) {

				alias2MethodName.put(possibleName, methodName);
			}
		}
		return alias2MethodName;
	}

	public Map<String, configurationDataType> createVarName2DataType(
			Class<T> configurationClass) {

		Map<String, configurationDataType> varName2DataType = new HashMap<String, configurationDataType>();

		List<Method> getMethods = getGetMethods(configurationClass);

		for (Method getMethod : getMethods) {

			configurationDataType returnTypeExpected = null;

			if (getMethod.getReturnType().equals(String.class)) {
				returnTypeExpected = configurationDataType.String;
			}
			if (getMethod.getReturnType().equals(java.util.List.class)) {
				returnTypeExpected = configurationDataType.List_Of_Strings;
			}

			if (returnTypeExpected == null) {

				throw new RuntimeException("Unknown return type "
						+ getMethod.getReturnType().getName() + " for "
						+ getMethod.getName() + "!");
			}

			varName2DataType.put(getVariableRequested(getMethod),
					returnTypeExpected);
		}
		return varName2DataType;
	}

	/**
	 *

	 * This method takes a getMethod from the configuration interface as a
	 * parameter and returns the names (aliases) by which this parameter could
	 * be requested for as a set of strings.
	 *

	 *
	 *

	 * The aliases are taken from the annotations in the configuration
	 * interface. The names are in the "shortName" and the "longName"
	 * Annotations.
	 *

	 *
	 * @param getMethod
	 *            - A method
	 * @return A list of names of configuration variables that can be returned
	 *
	 */
	Set<String> getAliases(Method getMethod) {

		Set<String> possibleRequestedNames = new HashSet<String>();
		String variableRequested = getVariableRequested(getMethod);
		possibleRequestedNames.add(variableRequested);
		Annotation[] annotations = getMethod.getAnnotations();

		for (Annotation annotation : annotations) {
			if (annotation instanceof uk.co.flamingpenguin.jewel.cli.Option) {
				Option o = (uk.co.flamingpenguin.jewel.cli.Option) annotation;
				for (String sn : o.shortName()) {
					if (sn.length() > 0) {
						possibleRequestedNames.add(sn);
					}
				}
				if (o.longName().length() > 0) {
					possibleRequestedNames.add(o.longName());
				}
			}
		}
		return possibleRequestedNames;
	}

	/**
	 * @param configurationClass
	 * @return A Map that maps a the name of a parameter from the get* or is*
	 *         methods of a configuration class to a set of Strings under which
	 *         this parameter may be known in the properties file.
	 *
	 *         For example the getOutputDatabase method is for the parameter
	 *         outputDatabase which may be represented in the properties file as
	 *         "outputDatabase" or "output.database". The alternatives can be
	 *         specified as an Option annotation in the configuration interface
	 *         like this
	 *
	 * @Option(longName="output.databases") List<String> getOutputDatabases();
	 *
	 *                                      or this:
	 *
	 * @Option(shortName="c") List<File> getConf();
	 *
	 */
	public Map<String, Set<String>> createParameterAliasesMap(
			Class<T> configurationClass) {

		List<Method> getMethods = getGetMethods(configurationClass);

		Map<String, Set<String>> parameterAliasesMap = new HashMap<String, Set<String>>();

		for (Method getMethod : getMethods) {

			parameterAliasesMap.put(getVariableRequested(getMethod),
					getAliases(getMethod));
		}

		return parameterAliasesMap;
	}

	/**
	 * @param configurationClass
	 * @return A list of get methods. The get methods returned are the ones
	 *         meant for accessing configuration parameters.
	 */
	public List<Method> getGetMethods(Class<T> configurationClass) {

		Method[] methods = configurationClass.getMethods();

		// These get methods are not about configuration parameters.
		Set<String> specialGetMethodNames = new HashSet<String>();

		// Java methods that start with get, but have nothing to do with
		// accessing parameters.
		//
		specialGetMethodNames.add("getInvocationHandler");
		specialGetMethodNames.add("getProxyClass");
		specialGetMethodNames.add("getClass");
		//
		// Special method, when called and delegated to jewelcli causes it to
		// autogenerate a help message. It doese not provide access to
		// parameters so should be ignored when dealing with them.
		//
		specialGetMethodNames.add("getHelp");

		List<Method> methodList = new ArrayList<Method>();

		for (Method method : methods) {

			String methodName = method.getName();

			boolean isGetMethodForConfiguration = methodName.startsWith("get")
					&& !(specialGetMethodNames.contains(methodName));

			if (isGetMethodForConfiguration) {
				methodList.add(method);
			}
		}
		return methodList;
	}
}