PydtnBundle.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// pydtn 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 pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "simlpy/interpreter_hooks.h"
#include "parsers.h"
#include "PydtnBundle.h"
#include "WrapNode.h"
#include "simlpy/Clock.h"

#include <iostream>
#include <sstream>
#include <netinet/in.h>

#include "simlpy/SimulationException.h"


static PyObject* create_PydtnBundle( DTN::Bundle* b );

static PyObject*
PydtnBundle_new( PyTypeObject* type, PyObject* args, PyObject* kwds )
{
   if ( 0 == kwds )
   {
      PyErr_SetString(PyExc_TypeError,"expected keyword arguments");
      return 0;
   }
   static char* kwlist[] = { "src",
                             "dest",
                             "data",
                             "lifetime",
                             "app",
                             "isData",
                             "isACK",
                             "isNoACK",
                             "isBcast",
                             "isCustodial",
                             0};
   PyObject* srcObj;
   PyObject* destObj;
   char* data = "";
   PyObject* lifetime = 0;
   char* app = "";
   char isData = 1;
   char isACK = 0;
   char isNoACK = 0;
   char isBcast = 0;
   char isCustodial = 1;
   if ( ! PyArg_ParseTupleAndKeywords( args, kwds, "OO|sOsbbbbb", kwlist,
                                       &srcObj, &destObj,
                                       &data, &lifetime, &app,
                                       &isData,
                                       &isACK,
                                       &isNoACK,
                                       &isBcast,
                                       &isCustodial ) )
   {
      return 0;
   }

   WrapNode* src = 0;
   WrapNode* dest = 0;
   Time lt;
   uint32_t seq;
   try
   {
      src = parse_node( srcObj );
      dest = parse_node( destObj );
      if ( ( 0 == lifetime ) || ( Py_None == lifetime ) )
      {
         // get the lifetime from src
         lt = src->bundleLifetime();
      }
      else
      {
         lt = parse_time( lifetime );
      }
      seq = src->node().nextSeq();
   }
   catch ( ... )
   {
      return 0;
   }
   lt += Clock::time();

   DTN::Bundle::BundleType t = 0;
   if ( isData )      t |= DTN::Bundle::kData;
   if ( isACK )       t |= DTN::Bundle::kACK;
   if ( isNoACK )     t |= DTN::Bundle::kNoACK;
   if ( isCustodial ) t |= DTN::Bundle::kCustodial;
   if ( isBcast )     t |= DTN::Bundle::kBcast;

   DTN::ByteString udata;
   DTN::ByteString uapp;

   for ( unsigned int i = 0 ; i < ::strlen(data) ; ++i )
   {
      udata += data[i];
   }
   for ( unsigned int i = 0 ; i < ::strlen(app) ; ++i )
   {
      uapp += app[i];
   }

   DTN::Bundle* b = new DTN::Bundle( seq,
                                     src->addr(),
                                     dest->addr(),
                                     udata,
                                     Clock::time().tv,
                                     lt.tv,
                                     t,
                                     uapp );
   return create_PydtnBundle(b);
}

static void
PydtnBundle_dealloc( PydtnBundle* self )
{
   if ( 0 != self->b ) delete self->b;
   self->ob_type->tp_free((PyObject*)self);
}

static PyObject*
PydtnBundle_repr( PyObject* self )
{
   if ( 0 == self ) return 0;
   DTN::Bundle* b = ((PydtnBundle*)self)->b;
   std::stringstream r;
   r << "{";
   r << " 'source' : '"      << stringify(b->source())               << "'," ;
   r << " 'seqNum' : "       << ::ntohl(b->seqNum())                 << "," ;
   r << " 'destination' : '" << stringify(b->destination())          << "'," ;
   r << " 'size' : "         << b->size()                            << "," ;
   r << " 'custodian' : '"   << stringify(b->custodian())            << "'," ;
   r << " 'send' : '"        << stringify(b->send())                 << "'," ;
   r << " 'recv' : '"        << stringify(b->recv())                 << "'," ;
   r << " 'created' : "      << b->created()                         << "," ;
   r << " 'expiry' : "       << b->expiry()                          << "," ;
   r << " 'app' : '"         << stringify(b->app())                  << "'," ;
   r << " 'hopCount' : "     << b->hopCount()                        << "," ;
   r << " 'expired' : '"     << ( b->expired() ? "True" : "False" )  << "'," ;
   r << " 'isData' : '"      << ( (b->type() & DTN::Bundle::kData) ?
                                  "True" : "False" )                 << "'," ;
   r << " 'isACK' : '"       << ( (b->type() & DTN::Bundle::kACK) ?
                                  "True" : "False" )                 << "'," ;
   r << " 'isNoACK' : '"     << ( (b->type() & DTN::Bundle::kNoACK) ?
                                  "True" : "False" )                 << "'," ;
   r << " 'isCustodial' : '" << ( (b->type() & DTN::Bundle::kCustodial) ?
                                  "True" : "False" )                 << "'," ;
   r << " 'isBcast' : '"     << ( (b->type() & DTN::Bundle::kBcast) ?
                                  "True" : "False" )                 << "'," ;
   r << " 'payload' : '"     << stringify(b->payload())              << "' ";
   r << "}";
   return construct_string(r.str());
}

static PyObject*
PydtnBundle_size( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_ulong( self->b->size() );
}

static PyObject*
PydtnBundle_seqNum( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_ulong( ::ntohl(self->b->seqNum()) );
}

static PyObject*
PydtnBundle_source( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_string(stringify(self->b->source()));
}

static PyObject*
PydtnBundle_destination( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_string(stringify(self->b->destination()));
}

static PyObject*
PydtnBundle_custodian( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_string(stringify(self->b->custodian()));
}

static PyObject*
PydtnBundle_send( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_string(stringify(self->b->send()));
}

static PyObject*
PydtnBundle_recv( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_string(stringify(self->b->recv()));
}

static PyObject*
PydtnBundle_payload( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_string(stringify(self->b->payload()));
}

static PyObject*
PydtnBundle_created( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_time(self->b->created());
}

static PyObject*
PydtnBundle_expiry( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_time(self->b->expiry());
}

static PyObject*
PydtnBundle_app( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_string(stringify(self->b->app()));
}

static PyObject*
PydtnBundle_hopCount( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_ulong( self->b->hopCount() );
}

static PyObject*
PydtnBundle_expired( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_boolean( self->b->expired() );
}

static PyObject*
PydtnBundle_isData( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_boolean( DTN::Bundle::kData & self->b->type() );
}

static PyObject*
PydtnBundle_isACK( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_boolean( DTN::Bundle::kACK & self->b->type() );
}

static PyObject*
PydtnBundle_isNoACK( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_boolean( DTN::Bundle::kNoACK & self->b->type() );
}

static PyObject*
PydtnBundle_isCustodial( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_boolean( DTN::Bundle::kCustodial & self->b->type() );
}

static PyObject*
PydtnBundle_isBcast( PydtnBundle* self )
{
   if ( 0 == self ) return 0;
   if ( 0 == self->b ) return 0;
   return construct_boolean( DTN::Bundle::kBcast & self->b->type() );
}

static char PydtnBundle_doc[] = "Python-accessible version of a bundle.\n\
   \n\
   This is a non-modifiable version of a bundle.  Bundles may be\n\
   created by the backend and passed to python, or they may be\n\
   created in python with the following syntax:\n\
   \n\
      b = pydtn.Bundle( **kwargs )\n\
   \n\
   where **kwargs includes the following (defaults in brackets):\n\
   \n\
      src         = <source node>\n\
      dest        = <destination node>\n\
      data        = <payload data string>   [\"\"]\n\
      lifetime    = <bundle lifetime>       [src.get('bundle_lifetime')]\n\
      app         = <application identifier [\"\"]\n\
      isData      = <boolean>               [True]\n\
      isACK       = <boolean>               [False]\n\
      isNoACK     = <boolean>               [False]\n\
      isBcast     = <boolean>               [False]\n\
      isCustodial = <boolean>               [True]\n\
   \n";

static PyMethodDef PydtnBundle_methods[] =
{
   { "size",        (PyCFunction)PydtnBundle_size,        METH_NOARGS,
     "returns the total size of the bundle" },
   { "seqNum",      (PyCFunction)PydtnBundle_seqNum,      METH_NOARGS,
     "returns the bundle sequence number from the source" },
   { "source",      (PyCFunction)PydtnBundle_source,      METH_NOARGS,
     "returns the bundle's source address" },
   { "destination", (PyCFunction)PydtnBundle_destination, METH_NOARGS,
     "returns the bundle's destination address" },
   { "custodian",   (PyCFunction)PydtnBundle_custodian,   METH_NOARGS,
     "returns the address of the current custodian" },
   { "send",        (PyCFunction)PydtnBundle_send,        METH_NOARGS,
     "returns the address of the last-hop sender" },
   { "recv",        (PyCFunction)PydtnBundle_recv,        METH_NOARGS,
     "returns the address of the last-hop receiver" },
   { "payload",     (PyCFunction)PydtnBundle_payload,     METH_NOARGS,
     "returns the bundle payload (ie, the actual data)" },
   { "created",     (PyCFunction)PydtnBundle_created,     METH_NOARGS,
     "returns the time at which the bundle was created" },
   { "expiry",      (PyCFunction)PydtnBundle_expiry,      METH_NOARGS,
     "returns the time at which the bundle will expire" },
   { "app",         (PyCFunction)PydtnBundle_app,         METH_NOARGS,
     "returns the application identifier" },
   { "hopCount",    (PyCFunction)PydtnBundle_hopCount,    METH_NOARGS,
     "returns the number of hops the bundle has taken in the network" },
   { "expired",     (PyCFunction)PydtnBundle_expired,     METH_NOARGS,
     "(boolean) Has the bundle expired?" },
   { "isData",      (PyCFunction)PydtnBundle_isData,      METH_NOARGS,
     "(boolean) Is this a data bundle?" },
   { "isACK",       (PyCFunction)PydtnBundle_isACK,       METH_NOARGS,
     "(boolean) Is this an acknowledgment?" },
   { "isNoACK",     (PyCFunction)PydtnBundle_isNoACK,     METH_NOARGS,
     "(boolean) Should the destination avoid generating an ACK?" },
   { "isCustodial", (PyCFunction)PydtnBundle_isCustodial, METH_NOARGS,
     "(boolean) Does this bundle want custody transfer?" },
   { "isBcast",     (PyCFunction)PydtnBundle_isBcast,     METH_NOARGS,
     "(boolean) Is this a broadcast bundle?" },
   {0} // sentinel
};

static PyMemberDef PydtnBundle_members[] =
{
   {0} // sentinel
};

static PyTypeObject PydtnBundleType = {
   PyObject_HEAD_INIT(0)
   0,                               // ob_size
   "pydtn.Bundle",                  // tp_name
   sizeof(PydtnBundle),             // tp_basicsize
   0,                               // tp_itemsize
   (destructor)PydtnBundle_dealloc, // tp_dealloc
   0,                               // tp_print
   0,                               // tp_getattr
   0,                               // tp_setattr
   0,                               // tp_compare
   PydtnBundle_repr,                // tp_repr
   0,                               // tp_as_number
   0,                               // tp_as_sequence
   0,                               // tp_as_mapping
   0,                               // tp_hash
   0,                               // tp_call
   0,                               // tp_str
   0,                               // tp_getattro
   0,                               // tp_setattro
   0,                               // tp_as_buffer
   Py_TPFLAGS_DEFAULT,              // tp_flags
   PydtnBundle_doc,                 // tp_doc
   0,                               // tp_traverse
   0,                               // tp_clear
   0,                               // tp_richcompare
   0,                               // tp_weaklistoffset
   0,                               // tp_iter
   0,                               // tp_iternext
   PydtnBundle_methods,             // tp_methods
   PydtnBundle_members,             // tp_members
   0,                               // tp_getset
   0,                               // tp_base
   0,                               // tp_dict
   0,                               // tp_descr_get
   0,                               // tp_descr_set
   0,                               // tp_dictoffset
   0,                               // tp_init
   0,                               // tp_alloc
   PydtnBundle_new,                 // tp_new
};

static PyObject*
create_PydtnBundle( DTN::Bundle* b )
{
   if ( 0 == b )
   {
      std::cerr << "Null pointer passed to pydtn.Bundle creator" << std::endl;
      return 0;
   }
   PydtnBundle* self =
      (PydtnBundle*)PydtnBundleType.tp_alloc(&PydtnBundleType,0);
   if ( 0 == self )
   {
      std::cerr << "Could not allocate a new pydtn.Bundle" << std::endl;
      return 0;
   }
   self->b = b;
   Py_INCREF(self);
   return (PyObject*)self;
}

void
addType_PydtnBundle( PyObject* m )
{
   if ( 0 == m ) return;
   if ( PyType_Ready(&PydtnBundleType) < 0 ) return;
   Py_INCREF(&PydtnBundleType);
   PyModule_AddObject(m,"Bundle",(PyObject*)&PydtnBundleType);
}

PyObject*
PydtnBundle_wrapBundle( const DTN::Bundle& b )
{
   return create_PydtnBundle( b.clone() );
}

int
PydtnBundle_Check( PyObject* o )
{
   if ( 0 == o ) return 0;
   return PyObject_TypeCheck(o,&PydtnBundleType);
}

---