session.h

Go to the documentation of this file.

 
#ifndef ODVA_ETHERNETIP_SESSION_H
#define ODVA_ETHERNETIP_SESSION_H
 
#include <string>
#include <gtest/gtest_prod.h>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/asio.hpp>
 
#include "odva_ethernetip/eip_types.h"
#include "odva_ethernetip/socket/socket.h"
#include "odva_ethernetip/serialization/serializable.h"
#include "odva_ethernetip/serialization/serializable_primitive.h"
#include "odva_ethernetip/encap_packet.h"
#include "odva_ethernetip/cpf_packet.h"
#include "odva_ethernetip/rr_data_response.h"
#include "odva_ethernetip/path.h"
#include "odva_ethernetip/connection.h"
 
using std::string;
using boost::shared_ptr;
using boost::make_shared;
 
namespace eip {
 
using serialization::Serializable;
using serialization::SerializablePrimitive;
using socket::Socket;
 
#define DEFAULT_VENDOR_ID 0x1234
#define DEFAULT_SERIAL_NUM 0x6789
 
class Session
{
public:
 
  Session(shared_ptr<Socket> socket, shared_ptr<Socket> io_socket,
    EIP_UINT vendor_id = DEFAULT_VENDOR_ID, EIP_UDINT serial_num = DEFAULT_SERIAL_NUM);
 
  virtual ~Session();
 
  void open(string hostname, string port = "44818", string io_port = "2222");
 
  void close();
 
  EIP_UDINT getSessionID()
  {
    return session_id_;
  }
 
  void getSingleAttributeSerializable(EIP_USINT class_id, EIP_USINT instance_id,
    EIP_USINT attribute_id, Serializable& result);
 
  template <typename T>
  T getSingleAttribute(EIP_USINT class_id, EIP_USINT instance_id, EIP_USINT attribute_id, T v)
  {
    SerializablePrimitive<T> data;
    getSingleAttributeSerializable(class_id, instance_id, attribute_id, data);
    return data.data;
  }
 
  void setSingleAttributeSerializable(EIP_USINT class_id, EIP_USINT instance_id,
    EIP_USINT attribute_id, shared_ptr<Serializable> data);
 
  template <typename T>
  void setSingleAttribute(EIP_USINT class_id, EIP_USINT instance_id,
    EIP_USINT attribute_id, T v)
  {
    shared_ptr< SerializablePrimitive<T> > data =
      make_shared< SerializablePrimitive<T> > (v);
    setSingleAttributeSerializable(class_id, instance_id, attribute_id, data);
  }
 
  int createConnection(const EIP_CONNECTION_INFO_T& o_to_t,
    const EIP_CONNECTION_INFO_T& t_to_o);
 
  void closeConnection(size_t n);
 
  inline EIP_UINT getVendorID() const
  {
    return my_vendor_id_;
  }
 
  inline EIP_UDINT getSerialNum() const
  {
    return my_serial_num_;
  }
 
  const Connection& getConnection(size_t n)
  {
    return connections_[n];
  }
 
  CPFPacket receiveIOPacket();
 
  void sendIOPacket(CPFPacket& pkt);
 
private:
  FRIEND_TEST(SessionTest, test_create_connection);
 
  shared_ptr<Socket> socket_;
  shared_ptr<Socket> io_socket_;
  EIP_UDINT session_id_;
  EIP_BYTE recv_buffer_[4*1024];
 
  EIP_UINT my_vendor_id_;
  EIP_UDINT my_serial_num_;
  EIP_UINT next_connection_sn_;
  EIP_UDINT next_connection_id_;
 
  vector<Connection> connections_;
 
  void check_packet(EncapPacket& pkt, EIP_UINT exp_cmd);
 
  EncapPacket sendCommand(EncapPacket& req);
 
  RRDataResponse sendRRDataCommand(EIP_USINT service, const Path& path,
    shared_ptr<Serializable> data);
};
 
} // namespace eip
 
#endif  // ODVA_ETHERNETIP_SESSION_H