1 /*

     2  *    Copyright 2004-2006 Intel Corporation

     3  * 

     4  *    Licensed under the Apache License, Version 2.0 (the "License");

     5  *    you may not use this file except in compliance with the License.

     6  *    You may obtain a copy of the License at

     7  * 

     8  *        http://www.apache.org/licenses/LICENSE-2.0

     9  * 

    10  *    Unless required by applicable law or agreed to in writing, software

    11  *    distributed under the License is distributed on an "AS IS" BASIS,

    12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    13  *    See the License for the specific language governing permissions and

    14  *    limitations under the License.

    15  */

    16 

    17 #ifndef _UDP_CONVERGENCE_LAYER_H_

    18 #define _UDP_CONVERGENCE_LAYER_H_

    19 

    20 #include <oasys/io/UDPClient.h>

    21 #include <oasys/thread/Thread.h>

    22 #include <oasys/io/RateLimitedSocket.h>

    23 

    24 #include "IPConvergenceLayer.h"

    25 

    26 namespace dtn {

    27 

    28 class UDPConvergenceLayer : public IPConvergenceLayer {

    29 public:

    30     /**

    31      * Maximum bundle size

    32      */

    33     static const u_int MAX_BUNDLE_LEN = 65507;

    34 

    35     /**

    36      * Default port used by the udp cl.

    37      */

    38     static const u_int16_t UDPCL_DEFAULT_PORT = 4556;

    39     

    40     /**

    41      * Constructor.

    42      */

    43     UDPConvergenceLayer();

    44         

    45     /**

    46      * Bring up a new interface.

    47      */

    48     bool interface_up(Interface* iface, int argc, const char* argv[]);

    49 

    50     /**

    51      * Bring down the interface.

    52      */

    53     bool interface_down(Interface* iface);

    54     

    55     /**

    56      * Dump out CL specific interface information.

    57      */

    58     void dump_interface(Interface* iface, oasys::StringBuffer* buf);

    59 

    60     /**

    61      * Create any CL-specific components of the Link.

    62      */

    63     bool init_link(const LinkRef& link, int argc, const char* argv[]);

    64 

    65     /**

    66      * Delete any CL-specific components of the Link.

    67      */

    68     void delete_link(const LinkRef& link);

    69 

    70     /**

    71      * Dump out CL specific link information.

    72      */

    73     void dump_link(const LinkRef& link, oasys::StringBuffer* buf);

    74     

    75     /**

    76      * Open the connection to a given contact and send/listen for 

    77      * bundles over this contact.

    78      */

    79     bool open_contact(const ContactRef& contact);

    80     

    81     /**

    82      * Close the connnection to the contact.

    83      */

    84     bool close_contact(const ContactRef& contact);

    85 

    86     /**

    87      * Send the bundle out the link.

    88      */

    89     void bundle_queued(const LinkRef& link, const BundleRef& bundle);

    90 

    91     /**

    92      * Tunable parameter structure.

    93      *

    94      * Per-link and per-interface settings are configurable via

    95      * arguments to the 'link add' and 'interface add' commands.

    96      *

    97      * The parameters are stored in each Link's CLInfo slot, as well

    98      * as part of the Receiver helper class.

    99      */

   100     class Params : public CLInfo {

   101     public:

   102         /**

   103          * Virtual from SerializableObject

   104          */

   105         virtual void serialize( oasys::SerializeAction *a );

   106 

   107         in_addr_t local_addr_;		///< Local address to bind to

   108         u_int16_t local_port_;		///< Local port to bind to

   109         in_addr_t remote_addr_;		///< Peer address to connect to

   110         u_int16_t remote_port_;		///< Peer port to connect to

   111 

   112         u_int32_t rate_;		///< Rate (in bps)

   113         u_int32_t bucket_depth_;	///< Token bucket depth (in bits)

   114     };

   115     

   116     /**

   117      * Default parameters.

   118      */

   119     static Params defaults_;

   120 

   121 protected:

   122     bool parse_params(Params* params, int argc, const char** argv,

   123                       const char** invalidp);

   124     /**

   125      * Helper class (and thread) that listens on a registered

   126      * interface for incoming data.

   127      */

   128     class Receiver : public CLInfo,

   129                      public oasys::UDPClient,

   130                      public oasys::Thread

   131     {

   132     public:

   133         /**

   134          * Constructor.

   135          */

   136         Receiver(UDPConvergenceLayer::Params* params);

   137 

   138         /**

   139          * Destructor.

   140          */

   141         virtual ~Receiver() {}

   142         

   143         /**

   144          * Loop forever, issuing blocking calls to IPSocket::recvfrom(),

   145          * then calling the process_data function when new data does

   146          * arrive

   147          * 

   148          * Note that unlike in the Thread base class, this run() method is

   149          * public in case we don't want to actually create a new thread

   150          * for this guy, but instead just want to run the main loop.

   151          */

   152         void run();

   153 

   154         UDPConvergenceLayer::Params params_;

   155         

   156     protected:

   157         /**

   158          * Handler to process an arrived packet.

   159          */

   160         void process_data(u_char* bp, size_t len);

   161     };

   162 

   163     /*

   164      * Helper class that wraps the sender-side per-contact state.

   165      */

   166     class Sender : public CLInfo, public Logger {

   167     public:

   168         /**

   169          * Destructor.

   170          */

   171         virtual ~Sender() {}

   172 

   173         /**

   174          * Initialize the sender (the "real" constructor).

   175          */

   176         bool init(Params* params, in_addr_t addr, u_int16_t port);

   177         

   178     private:

   179         friend class UDPConvergenceLayer;

   180         

   181         /**

   182          * Constructor.

   183          */

   184         Sender(const ContactRef& contact);

   185         

   186         /**

   187          * Send one bundle.

   188          * @return the length of the bundle sent or -1 on error

   189          */

   190         int send_bundle(const BundleRef& bundle);

   191 

   192         /**

   193          * Pointer to the link parameters.

   194          */

   195         Params* params_;

   196 

   197         /**

   198          * The udp client socket.

   199          */

   200         oasys::UDPClient socket_;

   201 

   202         /**

   203          * Rate-limited socket that's optionally enabled.

   204          */

   205         oasys::RateLimitedSocket rate_socket_;

   206         

   207         /**

   208          * The contact that we're representing.

   209          */

   210         ContactRef contact_;

   211 

   212         /**

   213          * Temporary buffer for formatting bundles. Note that the

   214          * fixed-length buffer is big enough since UDP packets can't

   215          * be any bigger than that.

   216          */

   217         u_char buf_[UDPConvergenceLayer::MAX_BUNDLE_LEN];

   218     };   

   219 };

   220 

   221 } // namespace dtn

   222 

   223 #endif /* _UDP_CONVERGENCE_LAYER_H_ */