ArSocket.h

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     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

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/

#ifndef ARSOCKET_H
#define ARSOCKET_H


#ifndef WIN32
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <stdarg.h>
#endif


#include <string>
#include "ariaTypedefs.h"
#include "ArMutex.h"

class ArFunctor;



class ArSocket
{
public:

  enum Type {UDP, TCP, Unknown};
  enum Error {NoErr, NetFail, ConBadHost, ConNoRoute, ConRefused};

  AREXPORT ArSocket();

  AREXPORT ArSocket(const char *host, int port, Type type);

  AREXPORT ArSocket(int port, bool doClose, Type type);

  AREXPORT ~ArSocket();

  AREXPORT static bool init();

  AREXPORT static void shutdown();

  AREXPORT static bool ourInitialized;

  AREXPORT bool copy(int fd, bool doclose);

  AREXPORT void copy(ArSocket *s)
    {myFD=s->myFD; myDoClose=false; mySin=s->mySin;}


  AREXPORT void transfer(ArSocket *s)
    {myFD=s->myFD; myDoClose=true; s->myDoClose=false; mySin=s->mySin;
     myType=s->myType; strcpy(myIPString, s->myIPString); }

  AREXPORT bool connect(const char *host, int port, Type type = TCP);

  AREXPORT bool open(int port, Type type, const char *openOnIP = NULL);

  AREXPORT bool create(Type type);

  AREXPORT bool findValidPort(int startPort, const char *openOnIP = NULL);

  AREXPORT bool connectTo(const char *host, int port);

  AREXPORT bool connectTo(struct sockaddr_in *sin);

  AREXPORT bool accept(ArSocket *sock);

  AREXPORT bool close();

  AREXPORT int write(const void *buff, size_t len);

  AREXPORT int read(void *buff, size_t len, unsigned int msWait = 0);

  AREXPORT int sendTo(const void *msg, int len);

  AREXPORT int sendTo(const void *msg, int len, struct sockaddr_in *sin);

  AREXPORT int recvFrom(void *msg, int len, sockaddr_in *sin);

  AREXPORT static bool hostAddr(const char *host, struct in_addr &addr);

  AREXPORT static bool addrHost(struct in_addr &addr, char *host);

  AREXPORT static std::string getHostName();

  AREXPORT bool getSockName();

  struct sockaddr_in * sockAddrIn() {return(&mySin);}

  struct in_addr * inAddr() {return(&mySin.sin_addr);}

  unsigned short int inPort() {return(mySin.sin_port);}

  AREXPORT static void inToA(struct in_addr *addr, char *buff);

  static const size_t sockAddrLen() {return(sizeof(struct sockaddr_in));}

#ifdef WIN32

  static const size_t maxHostNameLen() {return(MAXGETHOSTSTRUCT);}
#else

  static const size_t maxHostNameLen() {return(MAXHOSTNAMELEN);}
#endif

  AREXPORT static unsigned int hostToNetOrder(int i);

  AREXPORT static unsigned int netToHostOrder(int i);

  AREXPORT bool setLinger(int time);

  AREXPORT bool setBroadcast();

  AREXPORT bool setReuseAddress();

  AREXPORT bool setNonBlock();

  AREXPORT void setDoClose(bool yesno) {myDoClose=yesno;}

  AREXPORT int getFD() const {return(myFD);}

  AREXPORT Type getType() const {return(myType);}

  AREXPORT const std::string & getErrorStr() const {return(myErrorStr);}

  AREXPORT Error getError() const {return(myError);}

#ifndef SWIG

  AREXPORT int writeString(const char *str, ...);
#endif

  AREXPORT int writeStringPlain(const char *str) { return writeString(str); }
  AREXPORT char *readString(void);
  AREXPORT void setEcho(bool echo) 
  { myStringAutoEcho = false; myStringEcho = echo; }
  AREXPORT bool getEcho(void) { return myStringEcho; }
  AREXPORT void setLogWriteStrings(bool logWriteStrings) 
    { myLogWriteStrings = logWriteStrings; }
  AREXPORT bool getLogWriteStrings(void) { return myLogWriteStrings; }
  AREXPORT const char *getIPString(void) const { return myIPString; }
  AREXPORT void setCloseCallback(ArFunctor *functor) 
    { myCloseFunctor = functor; }
  AREXPORT ArFunctor *getCloseCallback(void) { return myCloseFunctor; }
  long getSends(void) { return mySends; }
  long getBytesSent(void) { return myBytesSent; }
  long getRecvs(void) { return myRecvs; }
  long getBytesRecvd(void) { return myBytesRecvd; }
  void resetTracking(void) 
    { mySends = 0; myBytesSent = 0; myRecvs = 0; myBytesRecvd = 0; }
  
  AREXPORT bool setNoDelay(bool flag);

protected:
  void setIPString(void);
  void doStringEcho(void);
  // internal crossplatform init (mostly for string reading stuff)
  void internalInit(void);

  Type myType;
  Error myError;
  std::string myErrorStr;
  bool myDoClose;
  int myFD;
  bool myNonBlocking;
  struct sockaddr_in mySin;

  bool myLogWriteStrings;
  ArMutex myReadStringMutex;
  ArMutex myWriteStringMutex;
  bool myStringAutoEcho;
  bool myStringEcho;
  char myStringBuf[1100];
  size_t myStringPos;
  char myStringBufEmpty[1];
  size_t myStringPosLast;
  char myIPString[128];
  bool myStringGotEscapeChars;
  bool myStringGotComplete;
  bool myStringHaveEchoed;

  long mySends;
  long myBytesSent;
  long myRecvs;
  long myBytesRecvd;
  
  // A functor to call when the socket closes
  ArFunctor *myCloseFunctor;
};


#endif // ARSOCKET_H
  

---