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