netlink.h

Go to the documentation of this file.

/*****************************************************************************
 * $Id: netlink.h,v 1.10 2003/07/16 11:42:15 schou Exp $
 * Author: Jakob Schou Jensen <schou@sourceforge.net>
 * Licence: GPL
 *
 * Description: Netlink handles communication between rover applications over
 *              network.
 *
 ****************************************************************************/

#ifndef NETLINK_H
#define NETLINK_H

#ifdef ADSO_WINDOWS
#include <winsock.h>
#else
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#endif
#include <queue>
#include <list>
#include <sys/types.h>
#include <SDL/SDL.h>
#include <adsomath.h>
#include <adsofont.h>
#include "vehicle.h"
#include "config.h"
#include "photon.h"
#include "view.h"

using namespace std;

#define STATE_MAX_PHOTONS 4

#define NETLINK_MAGIC ( ('a'<<24) | ('d'<<16) | ('s'<<8) | 'o' )
#define NL_PACKET_VERSION 3

#define NL_DELTATIME_INVALID 0x7fffffff

// NetLink meta messages
#define NLM_CONNECT 1
#define NLM_DISCONNECT 2
#define NLM_ACKNOWLEDGE 3
#define NLM_ACCEPT 4
#define NLM_REJECT 5
#define NLM_ABORT 6

// Netlink connected state messages
#define NL_CB 1024
#define NLC_NIL          (0|NL_CB)
#define NLC_STARTGAME    (1|NL_CB)
#define NLC_DEATHMATCH   (2|NL_CB)
#define NLC_ABORTGAME    (3|NL_CB)
#define NLC_GOT_EPSILON  (4|NL_CB)
#define NLC_SET_EPSILON  (5|NL_CB)
#define NLC_IFAILED      (6|NL_CB)
#define NLC_RESETPOS     (7|NL_CB)
#define NLC_DM_IWIN      (8|NL_CB)
#define NLC_DM_YOUWIN    (9|NL_CB)
#define NLC_RESCUE      (10|NL_CB)
#define NLC_CHAT        (11|NL_CB)
#define NLC_UFO         (12|NL_CB)
#define NLC_PHOTON_HIT  (13|NL_CB)
#define NLC_GAMETYPE    (14|NL_CB)

// NetLink states
#define NLSTATE_INACTIVE 0
#define NLSTATE_IDLE 1
#define NLSTATE_RCON 2
#define NLSTATE_LCON 3
#define NLSTATE_RACK 4
#define NLSTATE_LACC 5
#define NLSTATE_LREJ 6
#define NLSTATE_CONNECTED 7

// NetLink test defines
//#define NLTEST_ENABLE 1
#define NLTEST_PACKET_DELAY 100
#define NLTEST_PACKET_DVAR 10
#define NLTEST_DROP_INTERVAL 1000000

// NetLinkStat

#define NLS_DTA_SIZE 141

class NetLinkStat : public Overlay {
  double pingTime;
  int lostPackets;
  int packetNum;
  int msgSendCount;
  int msgRecvCount;
  int msgResendCount;
  int msgReackCount;
  const char *lastMessage;

  int sendQueueMax;
  int recvQueueMax;
  int sendAckQueueMax;
  int recvAckQueueMax;
  
  // Delta time arrays
  int adt_array[NLS_DTA_SIZE];
  int dt_array[NLS_DTA_SIZE];
  int dtaHead, dtaTail;

 public:
  bool visible;

  void draw();
  void newConnection();
  void addTime(int dt, int adt);
  NetLinkStat(){ pingTime = 0.0; lostPackets = 0; visible = false; }

  friend class NetLink;
};

// NetLinkAddr

#ifdef ADSO_WINDOWS
struct sockaddr_un { // this is a dummy definition, unix sockets will not work in windows
  int sun_family;
  char sun_path[32];
};

typedef int socklen_t;
#endif

class NetLinkAddr {
  sockaddr_un uaddr;
  sockaddr_in iaddr;
  socklen_t addrLen;
  int local,valid;
 public:
  int isValid(){ return valid; }

  sockaddr *getSockAddr(){
    if(local) return (sockaddr*)&uaddr;
    else return (sockaddr*)&iaddr;
  }

  socklen_t *recvSockAddrLen(){
    if(local) addrLen = sizeof(sockaddr_un);
    else addrLen = sizeof(sockaddr_in);
    return &addrLen;
  }

  socklen_t *getSockAddrLen(){
    return &addrLen;
  }

  void unlink(){
    if(local) ::unlink(uaddr.sun_path);
  }

  const char *toString(){
    if(local){
      return uaddr.sun_path;
    }
    else {
      return inet_ntoa(iaddr.sin_addr);
    }
  }

#ifdef ADSO_WINDOWS
  bool operator==(const NetLinkAddr& b){
    if(local!=b.local) return 0;
    if(local){
      if(uaddr.sun_family == b.uaddr.sun_family && 
   strncmp(uaddr.sun_path,b.uaddr.sun_path,addrLen)==0) return 1;
      else return 0;
    }
    else if(iaddr.sin_addr.s_addr == b.iaddr.sin_addr.s_addr 
      && iaddr.sin_port == b.iaddr.sin_port) return 1;
    else return 0;
  }

  bool operator!=(const NetLinkAddr b){ return !operator==(b); }
#else
  friend bool operator==(const NetLinkAddr& a, const NetLinkAddr& b){
    if(a.local!=b.local) return 0;
    if(a.local){
      if(a.uaddr.sun_family == b.uaddr.sun_family && 
   strncmp(a.uaddr.sun_path,b.uaddr.sun_path,a.addrLen)==0) return 1;
      else return 0;
    }
    else if(a.iaddr.sin_addr.s_addr == b.iaddr.sin_addr.s_addr 
      && a.iaddr.sin_port == b.iaddr.sin_port) return 1;
    else return 0;
  }

  friend bool operator!=(const NetLinkAddr& a, const NetLinkAddr& b) { return !(a==b); }
#endif

  NetLinkAddr(){
    valid = 1;
    if(config.localAddr) local = 1;
    else local = 0;

    if(local){
#ifdef ADSO_WINDOWS
      fatal("Can not use unix sockets in windows");
#else
      uaddr.sun_family = AF_UNIX;
#endif
      addrLen = sizeof(sockaddr_un);
    }
    else {
      memset((void*)&iaddr, 0, sizeof(iaddr));
      addrLen = sizeof(sockaddr_in);
      iaddr.sin_family = AF_INET;
      iaddr.sin_addr.s_addr = INADDR_ANY;
      iaddr.sin_port = htons(config.netLinkPort);
    }
  }

  NetLinkAddr(const char *addr_str) {
    valid = 1;
    if(config.localAddr) local = 1;
    else local = 0;

    if(local){
#ifdef ADSO_WINDOWS
      fatal("Can not use unix sockets in windows");
#else
      uaddr.sun_family = AF_UNIX;
#endif
      strcpy(uaddr.sun_path, addr_str);
      addrLen = strlen(uaddr.sun_path) + sizeof(uaddr.sun_family);
    }
    else {
      memset((char *)&iaddr, 0, sizeof (iaddr));
      addrLen = sizeof(sockaddr_in);
      iaddr.sin_family = AF_INET;
      if(config.netLinkRemotePort) iaddr.sin_port = htons(config.netLinkRemotePort);
      else iaddr.sin_port = htons(config.netLinkPort);
      /*if(inet_aton(addr_str,&iaddr.sin_addr)) valid = 1; // the right way
      else valid = 0;*/
      iaddr.sin_addr.s_addr = inet_addr(addr_str); // the windows way
      if(iaddr.sin_addr.s_addr == INADDR_NONE) valid = 0;
    }
  }
};

// State

struct State {
  v3f pos, r_x, r_y, r_z;
  v3f massPos;
  sqm3f R;
  float wheel, cannonBearing, cannonTilt;
  u_int time;
  int deltaTime;
  int photonCount;
  PhotonDef photonList[STATE_MAX_PHOTONS];

  void interpolate(double w, State *a, State *b){
    pos = (1.0-w)*a->pos + w*b->pos;
    r_x = (1.0-w)*a->r_x + w*b->r_x;
    r_y = (1.0-w)*a->r_y + w*b->r_y;
    r_z = (1.0-w)*a->r_z + w*b->r_z;

    wheel = (1.0-w)*a->wheel + w*b->wheel;
    cannonBearing = (1.0-w)*a->cannonBearing + w*b->cannonBearing;
    cannonTilt = (1.0-w)*a->cannonTilt + w*b->cannonTilt;

    /*rb.mass = b->rb.mass;
      rb.Ibodyinv = b->rb.Ibodyinv;*/
    
    massPos = (1.0-w)*a->massPos + w*b->massPos;
    R = a->R*(1.0-w) + b->R*w;
    /*rb.P = (1.0-w)*a->rb.P + w*b->rb.P;
    rb.L = (1.0-w)*a->rb.L + w*b->rb.L;
    
    rb.Iinv = a->rb.Iinv*(1.0-w) + b->rb.Iinv*w;
    rb.vel = (1.0-w)*a->rb.vel + w*b->rb.vel;
    rb.omega = (1.0-w)*a->rb.omega + w*b->rb.omega;
    rb.force = (1.0-w)*a->rb.force + w*b->rb.force;
    rb.torque = (1.0-w)*a->rb.torque + w*b->rb.torque;*/

    time = (u_int)((1.0-w)*a->time + w*b->time);
  }
};

struct StateStream {
  int pos;
  u_int time;
  State state;
};

// Message

struct Message {
  int type;
  char data[64];
  Message(){ type = 0; }
  Message(int t){ type = t; }

  const char *toString(){
    switch(type){
    case NLM_CONNECT: return "Connect";
    case NLM_DISCONNECT: return "Disconnect";
    case NLM_ACKNOWLEDGE: return "Acknowledge";
    case NLM_ACCEPT: return "Accept";
    case NLM_REJECT: return "Reject";
    case NLM_ABORT: return "Abort";

    case NLC_STARTGAME: return "Start game";
    case NLC_DEATHMATCH: return "Death match";
    case NLC_ABORTGAME: return "Abort game";
    case NLC_GOT_EPSILON: return "Got epsilon";
    case NLC_SET_EPSILON: return "Set epsilon";
    case NLC_IFAILED: return "I failed";
    case NLC_RESETPOS: return "Reset pos";
    case NLC_DM_IWIN: return "DM: I win";
    case NLC_DM_YOUWIN: return "DM: you win";
    case NLC_RESCUE: return "Rescue";
    case NLC_CHAT: return "Chat";
    case NLC_UFO: return "Ufo";
    case NLC_PHOTON_HIT: return "Photon hit";
    case NLC_GAMETYPE: return "Game type";
    default: return "<unknown>";
    }
  }
};

struct MsgSetEpsilon : public Message {
  s2f getPos(){ return *((s2f*)data); }
  void setPos(s2f ep){ *((s2f*)data) = ep; }
  MsgSetEpsilon(){ type = NLC_SET_EPSILON; }
  MsgSetEpsilon(s2f ep){ 
    type = NLC_SET_EPSILON; 
    *((s2f*)data) = ep;
  }
};

struct MsgGotEpsilon : public Message {
  float getTime(){ return *((float*)data); }
  void setPos(float time){ *((float*)data) = time; }
  MsgGotEpsilon(){ type = NLC_GOT_EPSILON; }
  MsgGotEpsilon(float time){ 
    type = NLC_GOT_EPSILON; 
    *((float*)data) = time;
  }
};

struct MsgChat : public Message {
  char *getString(){ return data; }
  void setString(char *str){ strncpy(data,str,64); }
  MsgChat(char *str){
    type = NLC_CHAT;
    strncpy(data,str,64);
  }
};

struct MsgUfo : public Message {
  int targetRemote(){ return *data; }
  MsgUfo(int targetLocal){
    type = NLC_UFO;
    *data = targetLocal;
  }
  MsgUfo(){
    type = NLC_UFO;
  }  
};

struct MsgPhotonHit : public Message {
  float remoteVehicleImpact(){ return *((float*)data); }
  float localVehicleImpact(){ return *((float*)(data+4)); }
  void combine(MsgPhotonHit &msg){ 
    *((float*)data) += *((float*)msg.data);
    *((float*)(data+4)) += *((float*)(msg.data+4));
  }
  MsgPhotonHit(float localImpact, float remoteImpact){
    type = NLC_PHOTON_HIT;
    *((float*)(data)) = localImpact;
    *((float*)(data+4)) = remoteImpact;
  }
  MsgPhotonHit(){
    type = NLC_PHOTON_HIT;
  }
};

struct MsgGameType : public Message {
  int deathMatch(){ return *data; }
  MsgGameType(int deathMatch){
    type = NLC_GAMETYPE;
    *data = deathMatch;
  }
  MsgGameType(){
    type = NLC_GAMETYPE;
  }  
};

struct MsgConnect : public Message {
  int isBot(){ return data[0]; }
  char *getName(){ return data+1; }
  MsgConnect(){
    type = NLM_CONNECT;
    data[0] = config.netbot_mode?1:0;
    if(config.userName) strncpy(data+1,config.userName,16);
    else data[1] = 0;
  }
};

struct MsgAccept : public Message {
  int isBot(){ return data[0]; }
  char *getName(){ return data+1; }
  MsgAccept(){
    type = NLM_ACCEPT;
    data[0] = config.netbot_mode?1:0;
    if(config.userName) strncpy(data+1,config.userName,16);
    else data[1] = 0;
  }
};

// Packet

struct Packet {
  int magic;
  int packetVersion;
  int connection_id;
  int acknowledge;
#ifdef NLTEST_ENABLE
  int timeStamp;
#endif
  Message msg;
  int msgNumber;
  StateStream stream;

  Packet(){
    magic = NETLINK_MAGIC;
    packetVersion = NL_PACKET_VERSION;
    acknowledge = 0;
    msg.type = 0;
  }

  Packet(Message m){
    magic = NETLINK_MAGIC;
    packetVersion = NL_PACKET_VERSION;
    acknowledge = 0;
    msg = m;
  }
};

struct TPacket {
  NetLinkAddr dest;
  Packet packet;
  TPacket(NetLinkAddr d, Packet p){
    dest = d;
    packet = p;
  }
};


// NetLink

class NetLink : public Overlay {
  int sockfd;
  NetLinkAddr localAddr;
  NetLinkAddr remoteAddr;

  char remoteName[16];
  int remoteIsBot;

  int state;
  int connection_id;
  int connectInitiator;
  char errorMsg[256];

  int rs_inGame, ls_inGame;
 
  // State stream
  Vehicle *vehicle;
  int streamPos;
  int photonCount;
  PhotonDef photonList[STATE_MAX_PHOTONS];

  // Remote state
  State rs_last, rs_current, rs_next, rs_tmp;
  u_int rs_count;
  int rs_delta_time;
  int remoteStreamPos;

  int msgNumber, remoteMsgNumber, retryMsgNumber;
  list<Message> msgRecvQueue;
  deque<Message> msgSendQueue;
  deque<Message> pendSendAckQueue; // messages that has been sent but need acknowledge
  deque<int> pendRecvAckQueue; // message numbers that needs to be acknowledged
  deque<TPacket> sendQueue;
#ifdef NLTEST_ENABLE
  list<TPacket> inetModelQueue;
#endif

  // net access timing
  u_int lastTime;
  u_int pollTimer, streamTimer, retryTimer;
  u_int ti_poll, ti_stream, ti_retry, ti_uc_retry;  // timer interval
  int retryCount, maxRetries;

  int lastDeltaTime;

  // display timing
  u_int displayTime;
  u_int flashTimer;
  int displayMsgTimer;
  int displayFlash;
  char displayMessage[80];
  int dismsg_disconnect, dismsg_reject, dismsg_error, dismsg_timeout, dismsg_abort;
  int dismsg_packet_error, dismsg_version_error, dismsg_connect_fail, dismsg_invalid_ip;
  int dismsg_gametype;
  int enableDisplay;

 public:
  void update();
  void send(Packet packet, NetLinkAddr addr);
  void send(int type, NetLinkAddr addr);
  void connect(const char *);
  void connect(NetLinkAddr);
  void connectAccept();
  void connectReject();
  void disconnect();
  int hasConnectRequest(){ return state==NLSTATE_RCON; }
  int isConnected(){ return state==NLSTATE_CONNECTED; }
  int isActive(){ return state!=NLSTATE_INACTIVE; }
  int isIdle(){ return state==NLSTATE_IDLE; }
  int isInitiator(){ return connectInitiator; }
  int remoteInGame(){ return state==NLSTATE_CONNECTED && rs_inGame; }
  const char *getRemoteName(){ return remoteName[0] ? remoteName : 0; }
  int isRemoteBot(){ return remoteIsBot; }
  const char *getDisplayMessage(){ return displayMessage; }
  void gameStateEnd(){ rs_inGame = 0; ls_inGame = 0; }
  void gameStateBegin(){ ls_inGame = 1; }
  void setDisplayState(int s){ enableDisplay = s; }
  int resolve(){ return connectInitiator; }
  void stream(Vehicle *v){ vehicle = v; }
  State *getRemoteState();
  void sendMsg(Message);
  int getMsg(Message&);
  int getMsg(Message&,int);
  void clearMessages(int);
  void sendPhoton(v3f x, v3f P, float lifeTimer);
  int init();
  void draw();

  NetLink(){ 
    state = NLSTATE_INACTIVE;

    lastTime = 0;
    streamTimer = 0;
    ti_poll = 10;
    ti_stream = 100;
    ti_retry = 3000;
    ti_uc_retry = 3000;

    maxRetries = 5;
    retryTimer = 0;

    displayTime = lastTime;
    displayFlash = 0;

    vehicle = 0;
    rs_count = 0;

    displayMessage[0] = 0;
    dismsg_disconnect = 0; dismsg_reject = 0; dismsg_error = 0; dismsg_timeout = 0;
    dismsg_packet_error = 0; dismsg_version_error = 0; dismsg_connect_fail = 0;
    dismsg_gametype = 0;
    enableDisplay = 1;
  }

  friend class NetLinkStat;
};

extern NetLink netLink;
extern NetLinkStat netLinkStat;

#endif

---