ArSocket.h

/*
ActivMedia Robotics Interface for Applications (ARIA)
Copyright (C) 2004,2005 ActivMedia Robotics, LLC


     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 
ActivMedia Robotics for information about a commercial version of ARIA at 
robots@activmedia.com or 
ActivMedia Robotics, 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"

class ArFunctor;


class ArSocket
{
public:

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

  ArSocket();

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

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

  ~ArSocket();

  static bool init();

  static void shutdown();

  static bool ourInitialized;

  bool copy(int fd, bool doclose);

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


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

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

  bool open(int port, Type type);

  bool create(Type type);

  bool findValidPort(int startPort);

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

  bool connectTo(struct sockaddr_in *sin);

  bool accept(ArSocket *sock);

  bool close();


  int write(const void *buff, size_t len)
    {
      struct timeval tval;
      fd_set fdSet;
      tval.tv_sec = 0;
      tval.tv_usec = 0;
      FD_ZERO(&fdSet);
      FD_SET(myFD, &fdSet);
      if (select(myFD + 1, NULL, &fdSet, NULL, &tval) <= 0)
        return 0;
      
#ifdef WIN32
      return(::send(myFD, (char*)buff, len, 0));
#else
      return(::write(myFD, (char*)buff, len));
#endif
    }


  int read(void *buff, size_t len, unsigned int msWait = 0)
    {
      if (msWait != 0)
      {
        struct timeval tval;
        fd_set fdSet;
        tval.tv_sec = msWait / 1000;
        tval.tv_usec = (msWait % 1000) * 1000;
        FD_ZERO(&fdSet);
        FD_SET(myFD, &fdSet);
        if (select(myFD + 1, &fdSet, NULL, NULL, &tval) <= 0)
          return 0;
      }
      return(::recv(myFD, (char*)buff, len, 0));
    }

  int sendTo(const void *msg, int len)
    {return(::sendto(myFD, (char*)msg, len, 0, (struct sockaddr*)&mySin,
                     sizeof(mySin)));}

  int sendTo(const void *msg, int len, struct sockaddr_in *sin)
    {return(::sendto(myFD, (char*)msg, len, 0, (struct sockaddr*)sin,
                     sizeof(struct sockaddr_in)));}

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

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

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

  static std::string getHostName();

  bool getSockName();

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

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

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

  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

  static unsigned int hostToNetOrder(int i);

  static unsigned int netToHostOrder(int i);

  bool setLinger(int time);

  bool setBroadcast();

  bool setReuseAddress();

  bool setNonBlock();

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

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

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

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

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

#ifndef SWIG

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

  int writeStringPlain(const char *str) { return writeString(str); }
  char *readString(void);
  void setEcho(bool echo) 
  { myStringAutoEcho = false; myStringEcho = echo; }
  bool getEcho(void) { return myStringEcho; }
  void setLogWriteStrings(bool logWriteStrings) 
    { myLogWriteStrings = logWriteStrings; }
  bool getLogWriteStrings(void) { return myLogWriteStrings; }
  const char *getIPString(void) const { return myIPString; }
  void setCloseCallback(ArFunctor *functor) 
    { myCloseFunctor = functor; }
  ArFunctor *getCloseCallback(void) { return myCloseFunctor; }
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;
  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;
  
  // A functor to call when the socket closes
  ArFunctor *myCloseFunctor;
};


#endif // ARSOCKET_H
  

---