test_security.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : octopus security test                                             *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Checks out the login support for octopus.  This just exercises the base  *
*  support which doesn't perform any extra verification on the user.          *
*                                                                             *
*******************************************************************************
* Copyright (c) 2002-$now By Author.  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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/
 
#include <application/application_shell.h>
#include <application/hoople_main.h>
#include <basis/astring.h>
#include <basis/mutex.h>
#include <configuration/application_configuration.h>
#include <loggers/console_logger.h>
#include <loggers/critical_events.h>
#include <loggers/program_wide_logger.h>
#include <octopus/entity_defs.h>
#include <octopus/infoton.h>
#include <octopus/octopus.h>
#include <octopus/tentacle.h>
#include <structures/static_memory_gremlin.h>
#include <sockets/internet_address.h>
//#include <structures/static_memory_gremlin.h>
#include <structures/string_array.h>
#include <tentacles/login_tentacle.h>
#include <tentacles/simple_entity_registry.h>
#include <unit_test/unit_base.h>
 
using namespace application;
using namespace basis;
using namespace configuration;
using namespace loggers;
using namespace mathematics;
using namespace octopi;
using namespace sockets;
using namespace structures;
using namespace textual;
using namespace unit_test;
 
#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger::get(), astring(s))
 
 
astring base_list[] = { "cli", "simp" };
 
SAFE_STATIC_CONST(string_array, simp_classifier, (2, base_list))
 
class simple_infoton : public infoton
{
public:
  astring futzle;
 
  simple_infoton() : infoton(simp_classifier()) {}
 
  virtual void text_form(basis::base_string &state_fill) const {
    state_fill.concatenate_string(astring("futzle=") + futzle);
  }
 
  virtual void pack(byte_array &packed_form) const {
    futzle.pack(packed_form);
  }
  virtual bool unpack(byte_array &packed_form) {
    if (!futzle.unpack(packed_form)) return false;
    return true;
  }
  virtual int packed_size() const { return futzle.length() + 1; }
  virtual clonable *clone() const { return new simple_infoton(*this); }
 
private:
};
 
 
// provides a simple service to allow us to test whether the security is
// working or not.
 
class simple_tentacle : public tentacle
{
public:
  simple_tentacle() : tentacle(simp_classifier(), true) {}
 
  virtual outcome reconstitute(const string_array &classifier,
          byte_array &packed_form, infoton * &reformed) {
    reformed = NULL_POINTER;
    if (classifier != simp_classifier()) return NO_HANDLER;
    reformed = new simple_infoton;
    if (!reformed->unpack(packed_form)) {
      WHACK(reformed);
      return GARBAGE;
    }
    return OKAY;
  }
 
  virtual outcome consume(infoton &to_chow,
          const octopus_request_id &formal(item_id), byte_array &transformed) {
    transformed.reset();
    if (to_chow.classifier() != simp_classifier()) return NO_HANDLER;
    // consume without doing anything.
    return OKAY;
  }
 
  virtual void expunge(const octopus_entity &formal(to_zap)) {}
};
 
 
//hmmm: this test should do a sample login octopus and do a login, reside for
//      a while, log out, do another one, let it time out, try to access
//      something with dead id hoping to be rejected, etc.
 
class test_octopus_security : virtual public unit_base, virtual public application_shell
{
public:
  test_octopus_security() : application_shell() {}
//class_name()
  DEFINE_CLASS_NAME("test_octopus_security");
  virtual int execute();
};
 
int test_octopus_security::execute()
{
  FUNCDEF("execute")
  octopus logos("local", 18 * MEGABYTE);
  simple_tentacle *tenty = new simple_tentacle;
  logos.add_tentacle(tenty);
  tenty = NULL_POINTER;  // octopus has charge of this now.
 
  // turn on security in logos.
  simple_entity_registry *guardian = new simple_entity_registry;
  logos.add_tentacle(new login_tentacle(*guardian), true);
 
  // create an entity to work with.
  octopus_entity jimbo("localhost", application_configuration::process_id(), 128, 982938);
  octopus_request_id req1(jimbo, 1);
 
  // add the user jimbo.
  guardian->add_entity(jimbo, byte_array());
 
  // create a piece of data to try running on tentacle.
  simple_infoton testose;
  simple_infoton *testose_copy = new simple_infoton(testose);
 
  // test that the simple tentacle allows the op.
  outcome ret = logos.evaluate(testose_copy, req1);
  if (ret != tentacle::OKAY)
    deadly_error(class_name(), "first test",
        astring("the operation failed with an error ")
            + tentacle::outcome_name(ret));
 
  // create another entity to work with.
  octopus_entity burfo("localhost", application_configuration::process_id(), 372, 2989);
  octopus_request_id req2(burfo, 1);
 
  // try with an unlicensed user burfo...
  testose_copy = new simple_infoton(testose);
  ret = logos.evaluate(testose_copy, req2);
  if (ret == tentacle::OKAY)
    deadly_error(class_name(), "second test",
        astring("the operation didn't fail when it should have."));
  else if (ret != tentacle::DISALLOWED)
    deadly_error(class_name(), "second test",
        astring("the operation didn't provide the proper outcome, it gave: ")
            + tentacle::outcome_name(ret));
 
  // remove the user jimbo.
  guardian->zap_entity(jimbo);
 
  // test that jimbo fails too now.
  testose_copy = new simple_infoton(testose);
  ret = logos.evaluate(testose_copy, req1);
  if (ret == tentacle::OKAY)
    deadly_error(class_name(), "third test",
        astring("the operation didn't fail when it should have."));
  else if (ret != tentacle::DISALLOWED)
    deadly_error(class_name(), "third test",
        astring("the operation didn't provide the proper outcome, it gave: ")
            + tentacle::outcome_name(ret));
 
  // add the user burfo in now instead.
  guardian->add_entity(burfo, byte_array());
 
  // test that burfo works.
  testose_copy = new simple_infoton(testose);
  ret = logos.evaluate(testose_copy, req2);
  if (ret != tentacle::OKAY)
    deadly_error(class_name(), "fourth test",
        astring("the operation failed with an error ")
        + tentacle::outcome_name(ret));
 
  LOG(astring(class_name()) + ":: security works for those functions tested.");
 
  WHACK(guardian); 
 
  return 0;
}
 
HOOPLE_MAIN(test_octopus_security, )