/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * 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

 *

 * Author: John Abraham <john.abraham@gatech.edu>

 */

#include "ns3/log.h"

#include "ns3/anim-packet.h"

NS_LOG_COMPONENT_DEFINE ("AnimPacket");

namespace ns3 {

uint32_t AnimPacket::greqId = 0;

AnimPacket::AnimPacket ()

{

}

AnimPacket::~AnimPacket ()

{

}

uint32_t AnimPacket::getnewreqId ()

{

  return greqId++;

}

void AnimPacket::SetRequestType (uint8_t reqType)

{

  if ((reqType != 0) && (reqType != 1))

    {

      NS_FATAL_ERROR ("Invalid Request Type");

    }

  m_reqType = (reqType)? true : false;

  NS_LOG_INFO ("Request Type:" << (m_reqType? "true":"false"));

}

void AnimPacket::SetRequestId (void * reqId)

{

  m_reqId = *(reinterpret_cast <uint32_t*> (reqId));

  NS_LOG_INFO ("Request Id:" << m_reqId); 

}

void AnimPacket::SetCommandId (void * commandId)

{

  m_commandId = *(reinterpret_cast <uint32_t*> (commandId));

  NS_LOG_INFO ("Command Id:" << m_commandId);

}

void AnimPacket::SetPayloadLength (void * payloadLength)

{

  m_payloadLength = *(reinterpret_cast <uint32_t*> (payloadLength));

  NS_LOG_INFO ("PayloadLength:" << m_payloadLength);

} 

void AnimPacket::SetPayload (void * data)

{

  uint32_t * p =  reinterpret_cast <uint32_t *> (data);

  for (uint32_t i = 0; i < m_payloadLength; i++)

    {

      m_payload.push_back (static_cast <uint32_t> (*(p + i))); 

    }

  NS_LOG_INFO ("Data:" << GetHexString (m_payload));

}

std::string AnimPacket::GetHexString (uint32_t value)

{

  std::stringstream ss;

  ss << "0x" << std::hex << (uint32_t) value;

  return ss.str ();

}

std::string AnimPacket::GetHexString (std::vector <uint32_t> values)

{

  std::stringstream ss;

  ss << "0x" << std::hex;

  for (uint32_t i = 0; i <values.size (); i++)

    {

      ss << (int) values[i];

    }

  return ss.str ();

}

uint8_t AnimPacket::GetRequestTypeAsByte ()

{

  return (m_reqType ? 1 : 0);

}

uint32_t * AnimPacket::GetRequestId ()

{

  return &m_reqId;

}

uint32_t * AnimPacket::GetCommandId ()

{

  return &m_commandId;

}

uint32_t * AnimPacket::GetPayloadLength ()

{

  return &m_payloadLength;

}

std::vector <uint32_t> * AnimPacket::GetPayload ()

{

  return &m_payload;

}

void AnimPacket::AppendPayload (uint32_t value)

{

  m_payload.push_back (value);

  m_payloadLength = m_payload.size ();

}

void AnimPacket::Print ()

{

  NS_LOG_UNCOND ("Packet details: Type:" << (m_reqType? "Request":"Response")

                 << " Request Id:" << m_reqId

                 << " Command Id:" << m_commandId

                 << " Data Length:" << m_payloadLength

                 << " Data:" << GetHexString (m_payload));

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * 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

 *

 * Author: John Abraham <john.abraham@gatech.edu>

 */

#ifndef _ANIMPACKET_H_

#define _ANIMPACKET_H_

#include "ns3/simulator.h"

namespace ns3 {

#define VALIDATELENGTH ValidateLength(__FUNCTION__, ret, fieldLength)

class AnimPacket {

public:

  AnimPacket ();

  ~AnimPacket ();

  static uint32_t greqId; // Unique Request Id

  static uint32_t getnewreqId ();

  void SetRequestType (uint8_t reqType);

  void SetRequestId (void * reqId);

  void SetCommandId (void * commandId);

  void SetPayloadLength (void * dataLength);

  void SetPayload (void * data);

  void AppendPayload (uint32_t value);

  uint8_t GetRequestTypeAsByte ();

  uint32_t * GetRequestId ();

  uint32_t * GetCommandId ();

  uint32_t * GetPayloadLength ();

  std::vector <uint32_t> * GetPayload ();

  std::string GetHexString (uint32_t value);

  std::string GetHexString (std::vector <uint32_t> values);

  void Print ();

private:

  bool m_reqType;                  // True if Request , False if Response

  uint32_t m_reqId;                // Id to match Request and Responses

  uint32_t m_commandId;            // Command Id

  uint32_t m_payloadLength;        // Payload Length in 32 bit chunks

  std::vector <uint32_t> m_payload;// Payload

}; // class AnimPacket

} // namespace ns3

#endif

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * 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

 *

 * Author: John Abraham <john.abraham@gatech.edu>

 */

#include "ns3/simulator.h"

#include "ns3/anim-socket.h"

#include "ns3/netanim-config.h"

#include "ns3/anim-packet.h"

#include "ns3/log.h"

#include <pthread.h>

#include <string.h>

// Socket related includes

#if defined(HAVE_SYS_SOCKET_H) && defined(HAVE_NETINET_IN_H)

#include <sys/socket.h>

#include <netinet/in.h>

#include <fcntl.h>

#endif

NS_LOG_COMPONENT_DEFINE ("AnimServer");

namespace ns3

{

void * thread_func (void * arg)

{

  AnimServer *server  = static_cast <AnimServer *> (arg);

  NS_ASSERT (server);

  server->Run ();

  return NULL;

}

AnimServer::AnimServer (): m_port (0), m_listeningSocket (-1),

                        m_connectedSocket (-1)

{

  pthread_mutex_init (&queue_mutex, NULL);

  pthread_cond_init (&queue_condition, NULL);

}

AnimServer::AnimServer (uint16_t port): m_port (port), 

                        m_listeningSocket (-1), m_connectedSocket (-1) 

{

  pthread_mutex_init (&queue_mutex, NULL);

  pthread_cond_init (&queue_condition, NULL);

}

bool AnimServer::Start (void)

{

  // Create Server thread

  AnimPacket * p = AnimServer::GenTestPacket ();

  Queue (p);

  int32_t err = pthread_create (&m_tid, NULL, thread_func, this);

  if (err != 0)

    {

      NS_FATAL_ERROR ("Unable to create AnimServer thread");

      return false;

    } 

  NS_LOG_INFO ("AnimServer thread created");

  return true;

}

void AnimServer::Run (void)

{

#if defined(HAVE_SYS_SOCKET_H) && defined(HAVE_NETINET_IN_H)

  int ret = 0;

  fd_set allfdSet;

  fd_set readfdSet;

  struct sockaddr_in servaddr;

  m_listeningSocket = socket (AF_INET, SOCK_STREAM, 0);

  // Set Non-blocking

  int opts = fcntl (m_listeningSocket, O_NONBLOCK);

  if (opts < 0)

    { 

      perror ("AnimServer: Set Non-blocking failed");

      NS_FATAL_ERROR ("AnimServer: Set Non-blocking failed");

    }

  bzero (&servaddr, sizeof (servaddr)); 

  servaddr.sin_family      = AF_INET;

  servaddr.sin_addr.s_addr = htonl (INADDR_ANY);

  servaddr.sin_port        = htons (m_port);

  ret = bind (m_listeningSocket, (struct sockaddr *) &servaddr, sizeof(servaddr));

  if (ret == -1)

    {

      std::string ErrorString ("AnimServer: Bind Failed for port:" + m_port);

      perror (ErrorString.c_str ());

      NS_FATAL_ERROR (ErrorString);

    }

  ret = listen (m_listeningSocket, 10);  //XXXXXX

  if (ret == -1)

    {

      std::string ErrorString = "Listen Failed";

      perror (ErrorString.c_str ());

      NS_FATAL_ERROR (ErrorString);

    }

  NS_LOG_INFO ("Awaiting connections on port:" << m_port);

  FD_ZERO (&allfdSet);

  FD_SET (m_listeningSocket, &allfdSet);

  struct timeval timeout;

  timeout.tv_sec = 1;

  timeout.tv_usec = 0;

  while (1)

    {

      readfdSet = allfdSet;

      // NS_LOG_INFO ("Infinite loop");

      ret = select (m_listeningSocket + 1, &readfdSet, NULL, NULL, &timeout);

      if (ret == -1)

        {

          std::string ErrorString = "Listening Socket Select Failed";

          perror (ErrorString.c_str ());

          NS_FATAL_ERROR (ErrorString);

        }

      if (FD_ISSET (m_listeningSocket, &readfdSet))

        {

          NS_LOG_INFO ("Connection Received"); 

          ProcessNewConnection ();

        }

      if (m_connectedSocket < 0)

        {

          continue;

        }

      else

        {

          SetReadWriteFlags ();

        }

      ProcessRead ();

      ProcessWrite ();

    }

#else

  NS_FATAL_ERROR ("Feature not supported");

#endif

}

void AnimServer::ProcessRead ()

{

  if (m_connectedSocket < 0)

    {

      return;

    }

  if (FD_ISSET (m_connectedSocket, &read_flags))

    {

      NS_LOG_INFO ("Socket Ready for read");

      AnimPacket * p = new AnimPacket ();

      DeSerialize (p);

      p->Print ();

      FD_CLR (m_connectedSocket, &read_flags);

    }

}

void AnimServer::ProcessWrite ()

{

  if (m_connectedSocket <0)

    {

      return;

    }

  if (FD_ISSET (m_connectedSocket, &write_flags))

    {

      NS_LOG_INFO ("Socket Ready for write");

      AnimPacket * p = DeQueue ();

      if (!p)

        {

          return;

        }

      Serialize (p);

    }

}

void AnimServer::ProcessNewConnection ()

{

  struct sockaddr_in cliaddr;

  socklen_t clilen = sizeof (cliaddr);

  m_connectedSocket = accept (m_listeningSocket, (struct sockaddr *) &cliaddr, &clilen); 

  if (m_connectedSocket < 0)

    {

      std::string ErrorString ("Unable to process incoming connection");  

      perror (ErrorString.c_str ());

      NS_FATAL_ERROR (ErrorString);

    }

  NS_LOG_INFO ("New connection Processed"); 

}

void AnimServer::SetReadWriteFlags ()

{

  int ret;

  if (m_connectedSocket < 0)

    {

      return;

    }

  FD_ZERO (&read_flags);

  FD_ZERO (&write_flags);

  FD_SET (m_connectedSocket, &read_flags);

  FD_SET (m_connectedSocket, &write_flags);

  struct timeval timeout;

  timeout.tv_sec = 1;

  timeout.tv_usec = 0;

  ret = select (m_connectedSocket + 1, &read_flags,&write_flags, NULL, &timeout);

  if (ret == -1)

    {

      std::string ErrorString = "Connected Socket Select Failed";

      perror (ErrorString.c_str ());

      NS_FATAL_ERROR (ErrorString);

    }

  NS_LOG_INFO ("Setting Read Write Flags complete");

}

void AnimServer::Stop (bool waitCompletion)

{

  void *ret;

  pthread_join (m_tid, &ret);

}

void AnimServer::Queue (AnimPacket *p)

{

  NS_ASSERT (p);

  NS_LOG_FUNCTION (this);

  pthread_mutex_lock (&queue_mutex);

  NS_LOG_DEBUG (__FUNCTION__ << "Queue locked");

  //pthread_cond_wait (&queue_condition, &queue_mutex);

  q.push (p);  

  NS_LOG_DEBUG ("Queue push complete");

  pthread_mutex_unlock (&queue_mutex);

  NS_LOG_DEBUG ("Queue unlocked");

}

AnimPacket * AnimServer::DeQueue ()

{

  NS_LOG_FUNCTION (this);

  pthread_mutex_lock (&queue_mutex);

  NS_LOG_DEBUG (__FUNCTION__ << "Queue locked");

  AnimPacket * p = q.front ();

  q.pop ();

  NS_LOG_DEBUG ("Queue pop complete");

  //pthread_cond_signal (&queue_condition);

  pthread_mutex_unlock (&queue_mutex);  

  NS_LOG_DEBUG ("Queue unlocked");

  return p;

}

const uint32_t AnimServer::magicStart = 0xDEADFEE1;

const uint32_t AnimServer::magicEnd = 0xDEADF00D;

void AnimServer::ReadMagicStart ()

{

  int ret = 0;

  NS_ASSERT (readp);

  uint8_t fieldLength = 4;

  uint8_t rdbuf [4];

  if ((ret = read (m_connectedSocket, rdbuf, fieldLength)) <= 0)

    {

      NS_LOG_ERROR ("Read Magic Start Failed. Closing socket");

      close (m_connectedSocket);

      return;

    }  

  VALIDATELENGTH;

  if (memcmp (rdbuf, &AnimServer::magicStart, fieldLength))

    {

      NS_LOG_ERROR ("AnimPacketMagicStart Not available.Closing socket");

      close (m_connectedSocket);

      return;

    }

  NS_LOG_INFO ("Got Magic Start");

}

void AnimServer::ReadMagicEnd ()

{

  int ret = 0;

  NS_ASSERT (readp);

  uint8_t fieldLength = 4;

  uint8_t rdbuf[4];

  if ((ret = read (m_connectedSocket, rdbuf, fieldLength)) <= 0)

    {

      NS_LOG_ERROR ("Read Magic End Failed. Closing socket");

      close (m_connectedSocket);

      return;

    }

  VALIDATELENGTH;

  if (memcmp (rdbuf, &AnimServer::magicEnd, fieldLength))

    {

      NS_LOG_ERROR ("AnimPacketMagicEnd Not available.Closing socket");

      close (m_connectedSocket);

      return;

    }

  NS_LOG_INFO ("Got Magic End");

}

void AnimServer::ReadRequestResponseType () 

{

  int ret = 0;

  NS_ASSERT (readp);

  uint8_t fieldLength = 1;

  uint8_t rdbuf[1];

  if ((ret = read (m_connectedSocket, rdbuf, fieldLength)) <= 0)

    {

      NS_LOG_ERROR ("Read Request Reponsei Type Failed. Closing socket");

      close (m_connectedSocket);

      return;

    }

  VALIDATELENGTH;

  readp->SetRequestType (rdbuf[0]);

}

void AnimServer::ReadRequestId ()

{

  int ret = 0;

  NS_ASSERT (readp);

  uint8_t fieldLength = 4;

  uint8_t rdbuf[4]; 

  if ((ret = read (m_connectedSocket, rdbuf, fieldLength)) <= 0)

    {

      NS_LOG_ERROR ("Read Request Id Failed. Closing socket");

      close (m_connectedSocket);

      return;

    }

  VALIDATELENGTH;

  readp->SetRequestId (rdbuf);

}

void AnimServer::ReadCommandId ()

{

  int ret = 0;

  NS_ASSERT (readp);

  uint8_t fieldLength = 4;

  uint8_t rdbuf[4]; 

  if ((ret = read (m_connectedSocket, rdbuf, fieldLength)) <= 0)

    {

      NS_LOG_ERROR ("Read Command Id Failed. Closing socket");

      close (m_connectedSocket);

      return;

    }

  VALIDATELENGTH;

  readp->SetCommandId (rdbuf);

}

void AnimServer::ReadPayloadLength ()

{

  int ret = 0;

  NS_ASSERT (readp);

  uint8_t fieldLength = 4;

  uint8_t rdbuf[4]; 

  if ((ret = read (m_connectedSocket, rdbuf, fieldLength)) <= 0)

    {

      NS_LOG_ERROR ("Read Payload Length Failed. Closing socket");

      close (m_connectedSocket);

      return;

    }

  VALIDATELENGTH;

  readp->SetPayloadLength (rdbuf);

}

void AnimServer::ReadPayload ()

{

  int ret = 0;

  NS_ASSERT (readp);

  uint8_t fieldLength = (*readp->GetPayloadLength ()) * sizeof (uint32_t);

  uint8_t rdbuf[1500]; 

  if ((ret = read (m_connectedSocket, rdbuf, fieldLength)) <= 0)

    {

      NS_LOG_ERROR ("Read Payload Failed. Closing socket");

      close (m_connectedSocket);

      return;

    }

  VALIDATELENGTH;

  readp->SetPayload (rdbuf);

}

void AnimServer::DeSerialize (AnimPacket *p)

{

  NS_ASSERT (m_connectedSocket >= 0);

  NS_ASSERT (p);

  readp = p;

  ReadMagicStart (); 

  ReadRequestResponseType (); 

  ReadRequestId ();

  ReadCommandId (); 

  ReadPayloadLength (); 

  ReadPayload (); 

  ReadMagicEnd (); 

}

void AnimServer::Serialize (AnimPacket *p)

{

  NS_ASSERT (m_connectedSocket >= 0);

  NS_ASSERT (p);

  writep = p;

  WriteMagicStart (); 

  WriteRequestResponseType (); 

  WriteRequestId ();

  WriteCommandId (); 

  WritePayloadLength (); 

  WritePayload (); 

  WriteMagicEnd (); 

}

void AnimServer::DoWrite (const void * wrbuf, uint8_t fieldLength)

{

  int ret = 0;

  if ((ret = write (m_connectedSocket, reinterpret_cast <const uint8_t *> (wrbuf), 

       fieldLength)) <= 0)

    {

      NS_LOG_ERROR (__FUNCTION__ << " Unexpected Write Failure.Closing socket");

      close (m_connectedSocket); 

    } 

  VALIDATELENGTH;

}

void AnimServer::WriteMagicStart ()

{

  NS_LOG_FUNCTION  (this);

  DoWrite (&magicStart, 4);

}

void AnimServer::WriteMagicEnd ()

{

  NS_LOG_FUNCTION (this);

  DoWrite (&magicEnd, 4);

}

void AnimServer::WriteRequestResponseType ()

{

  NS_LOG_FUNCTION (this);

  const char wrbuf[1] = {writep->GetRequestTypeAsByte ()}; 

  DoWrite (wrbuf, 1);

}

void AnimServer::WriteRequestId ()

{

  NS_LOG_FUNCTION (this);

  DoWrite (writep->GetRequestId (), 4);

}

void AnimServer::WriteCommandId ()

{

  NS_LOG_FUNCTION (this);

  DoWrite (writep->GetCommandId (), 4);

}

void AnimServer::WritePayloadLength ()

{

  NS_LOG_FUNCTION (this);

  DoWrite (writep->GetPayloadLength (), 4);

}

void AnimServer::WritePayload ()

{

  NS_LOG_FUNCTION (this);

  uint32_t numWords = *writep->GetPayloadLength ();

  std::vector <uint32_t> * data = writep->GetPayload (); 

  NS_ASSERT (data);

  uint32_t size = (*data).size ();

  for (uint32_t i = 0; ((i < numWords) && (i < size)); i++)

    {

      DoWrite (&((*data)[i]), 4);

    }

}

void AnimServer::ValidateLength (std::string fname, int ret,

                                       uint32_t validLength)

{

  if (static_cast <uint32_t> (ret) != validLength)

    {

      close (m_connectedSocket);

      NS_FATAL_ERROR (fname << ": Bytes expected:" << validLength

                      << " Bytes got:" << ret << " Socket close");

      return;

    }

  else

    {

      return;

    }

}

AnimPacket * AnimServer::GenTestPacket ()

{

  AnimPacket * p = new AnimPacket ();

  p->SetRequestType (1);

  uint32_t ReqId = 3;

  p->SetRequestId (&ReqId);

  uint32_t CommandId = 45;

  p->SetCommandId (&CommandId);

  p->AppendPayload (4);

  p->AppendPayload (5);

  p->AppendPayload (6);

  return p;

}

} // namespace ns3

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * 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

 *

 * Author: John Abraham <john.abraham@gatech.edu>

 */

#ifndef _ANIMSOCKET_H_

#define _ANIMSOCKET_H_

#include "ns3/simulator.h"

#include "ns3/anim-packet.h"

#include <pthread.h>

#if defined(HAVE_SYS_SOCKET_H) && defined(HAVE_NETINET_IN_H)

#include <sys/socket.h>

#include <netinet/in.h>

#include <fcntl.h>

#endif

#include <queue>

namespace ns3 {

#define VALIDATELENGTH ValidateLength(__FUNCTION__, ret, fieldLength)

class AnimServer

{

public:

  AnimServer ();

  AnimServer (uint16_t port);

  bool Start ();

  void Run ();

  void Stop (bool waitCompletion = false);

  void Queue (AnimPacket *p);

  AnimPacket * DeQueue ();

  static const uint32_t  magicStart;

  static const uint32_t  magicEnd;

private:

  pthread_t m_tid;   // Thread Id 

  uint16_t m_port;   // Port to listen to

  int m_listeningSocket;

  int m_connectedSocket;

  fd_set read_flags;

  fd_set write_flags;

  void SetReadWriteFlags ();

  void ProcessNewConnection ();

  void ProcessRead ();

  void ProcessWrite ();

  pthread_mutex_t queue_mutex; 

  pthread_cond_t queue_condition;

  std::queue <AnimPacket*> q;

  void DeSerialize (AnimPacket *p);

  void Serialize (AnimPacket * p);

  static AnimPacket * GenTestPacket ();

  void ValidateLength (std::string fname,

                       int ret, uint32_t validLength);

  void ReadMagicStart ();

  void ReadMagicEnd ();

  void ReadRequestResponseType ();

  void ReadRequestId ();

  void ReadCommandId ();

  void ReadPayloadLength ();

  void ReadPayload ();

  void DoWrite (const void * wrbuf, uint8_t fieldLength);

  void WriteMagicStart ();

  void WriteMagicEnd ();

  void WriteRequestResponseType ();

  void WriteRequestId ();

  void WriteCommandId ();

  void WritePayloadLength ();

  void WritePayload ();

  AnimPacket * readp;

  AnimPacket * writep;

};  // class AnimServer

}   // namespace ns3

#endif

  server.Stop ();

#else

 NS_FATAL_ERROR ("AnimationInterface");

bool AnimationInterface::StartAnimServer ()

{

  server = AnimServer (mport);

  server.Start ();

  return true;

}

#include "ns3/anim-socket.h"

  /**

   * \brief Start Anim Server

   *

   */

  bool StartAnimServer ();

  AnimServer server;    // Anim Server

			  'model/anim-socket.cc',

                          'model/anim-packet.cc'

			  'model/anim-socket.h',

                          'model/anim-packet.h'