sim_interface.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
  Network Simulation Cradle
  Copyright (C) 2003-2005 Sam Jansen
 
  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 program 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 this program; if not, write to the Free Software Foundation, Inc., 59
  Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
*/
 
#ifndef NSC_SIM_INTERFACE_H
#define NSC_SIM_INTERFACE_H
 
#define NSC_VERSION 0x000500
 
struct INetStack
{
  virtual ~INetStack() {}
 
  virtual void init (int hz) = 0;
 
  virtual void if_receive_packet (int if_id, const void *data, int datalen) = 0;
  virtual void if_send_packet (const void *data, int datalen) = 0;
  virtual void if_send_finish (int if_id) = 0;
 
  virtual void if_attach (const char *addr, const char *mask, int mtu) = 0;
  virtual void add_default_gateway (const char *addr) = 0;
 
  virtual int get_id () = 0;
 
  virtual const char *get_name () = 0;
 
  virtual int get_hz () = 0;
 
  virtual void timer_interrupt () = 0;
 
  virtual void increment_ticks () = 0;
 
  virtual void buffer_size (int size) = 0;
 
  virtual struct INetDatagramSocket *new_udp_socket () { return NULL; }
  virtual struct INetStreamSocket *new_tcp_socket () { return NULL; }
  virtual struct INetStreamSocket *new_sctp_socket () { return NULL; }
 
  // The following I've made optional to implement for now. Eases
  // integration of new features.
  virtual int sysctl (const char *sysctl_name, void *oldval, size_t *oldlenp,
                      void *newval, size_t newlen)
  {
    return -1;
  }
 
  // alternate, simpler interface. the stack cradle code is expected
  // to convert the string-value to something that the stack can handle.
  // The idea here is that this is a front-end to the sysctl(2) call,
  // much like the sysctl(8) program.
  virtual int sysctl_set (const char *name, const char *value)
  {
    return -1;
  }
 
  // same as above, cradle code is expected to convert the sysctl value
  // into a string.
  // returns length of the string in value, i.e. retval > len: 'output truncated'.
  virtual int sysctl_get (const char *name, char *value, size_t len)
  {
    return -1;
  }
 
  virtual int sysctl_getnum (size_t idx, char *name, size_t len)
  {
    return -1;
  }
 
  virtual void show_config ()
  {
    ;
  }
 
  virtual bool get_var (const char *var, char *result, int result_len)
  {
    return false;
  }
 
  virtual bool set_var (const char *var, const char *val)
  {
    return false;
  }
 
  virtual void set_diagnostic (int level) {}
 
  virtual int cmd (const char *)
  {
    return 1;
  }
};
 
struct INetStreamSocket
{
  virtual ~INetStreamSocket() {}
 
  virtual void connect (const char *, int) = 0;
  virtual void disconnect () = 0;
  virtual void listen (int) = 0;
  virtual int accept (INetStreamSocket **handler) = 0;
  virtual int send_data (const void *data, int datalen) = 0;
  virtual int read_data (void *buf, int *buflen) = 0;
  virtual int setsockopt (char *optname, void *val, size_t valsize) = 0;
  virtual void print_state (FILE *) = 0;
  virtual bool is_connected () = 0;
  virtual bool is_listening () = 0;
  virtual int getpeername (struct sockaddr *sa, size_t *salen) {
    return -1;
  }
  virtual int getsockname (struct sockaddr *sa, size_t *salen) {
    return -1;
  }
  virtual bool get_var (const char *var, char *result, int result_len)
  {
    return false;
  }
  virtual bool set_var (const char *var, const char *val)
  {
    return false;
  }
};
 
struct INetDatagramSocket
{
  virtual ~INetDatagramSocket() {}
 
  virtual void set_destination (const char *, int) = 0;
  virtual void send_data (const void *data, int datalen) = 0;
};
 
struct ISendCallback
{
  virtual ~ISendCallback() {}
 
  virtual void send_callback (const void *data, int datalen) = 0;
};
 
struct IInterruptCallback
{
  virtual ~IInterruptCallback() {}
 
  virtual void wakeup () = 0;
  virtual void gettime (unsigned int *, unsigned int *) = 0;
};
 
typedef int (*FRandom)();
typedef INetStack *(*FCreateStack)(ISendCallback *, IInterruptCallback *, 
                                   FRandom);
 
#define CREATE_STACK_FUNC(a,b,c) extern "C" INetStack *nsc_create_stack ( \
    ISendCallback *a, IInterruptCallback *b, FRandom c)
 
#endif /* NSC_SIM_INTERFACE_H */