ArNetPacketSenderTcp.cpp

Go to the documentation of this file.

/*
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
*/

#include "Aria.h"
#include "ArExport.h"
#include "ArNetPacketSenderTcp.h"

AREXPORT ArNetPacketSenderTcp::ArNetPacketSenderTcp() :
  mySocket(NULL),
  myPacketList(),
  myPacket(NULL),
  myAlreadySent(false),
  myBuf(NULL),
  myLength(0)
{
}

AREXPORT ArNetPacketSenderTcp::~ArNetPacketSenderTcp()
{
  ArNetPacket *packet;
  while (myPacketList.begin() != myPacketList.end())
  {
    packet = myPacketList.front();
    myPacketList.pop_front();
    delete packet;
  }
}

AREXPORT void ArNetPacketSenderTcp::setSocket(ArSocket *socket)
{
  myDataMutex.lock();
  mySocket = socket;
  myDataMutex.unlock();
}

AREXPORT ArSocket *ArNetPacketSenderTcp::getSocket(void)
{
  return mySocket;
}

AREXPORT void ArNetPacketSenderTcp::sendPacket(ArNetPacket *packet)
{
  ArNetPacket *sendPacket;
  sendPacket = new ArNetPacket(packet->getLength() + 5);
  sendPacket->duplicatePacket(packet);
  myDataMutex.lock();
  myPacketList.push_back(sendPacket);
  myDataMutex.unlock();
}

AREXPORT bool ArNetPacketSenderTcp::sendData(void)
{
  int ret;
  ArTime start;
  start.setToNow();
  //printf("sendData %g\n", start.mSecSince() / 1000.0);
  myDataMutex.lock();
  while (myPacketList.begin() != myPacketList.end() || myPacket != NULL)
  {
    if (myPacket == NULL)
    {
      //printf("!startedSending %g\n", start.mSecSince() / 1000.0);
      myPacket = myPacketList.front();
      myPacketList.pop_front();
      myAlreadySent = 0;
      myBuf = myPacket->getBuf();
      myLength = myPacket->getLength();

      if (myPacket->getCommand() == 0 || myPacket->getCommand() > 1000)
      {
        ArLog::log(ArLog::Normal, "getCommand is %d when it probably shouldn't be", 
                   myPacket->getCommand());
      }
    }
    if (myLength < 0 || myLength > ArNetPacket::MAX_LENGTH)
    {
      ArLog::log(ArLog::Terse, "ArNetPacketSenderTcp: getLength for command %d packet is bad at %d", myPacket->getCommand(), myLength);
      delete myPacket;
      myPacket = NULL;
      continue;
    }
    ret = mySocket->write(&myBuf[myAlreadySent], myLength - myAlreadySent);
    if (ret < 0)
    {
#ifdef WIN32
      if (WSAGetLastError() == WSAEWOULDBLOCK)
      {
        myDataMutex.unlock();
        return true;
      }
      else 
      {
        ArLog::log(ArLog::Normal, "ArNetPacketSenderTcp: Windows failed write with error %d on packet %d with length of %d", WSAGetLastError(), myPacket->getCommand(), myLength);
        myDataMutex.unlock();
        return false;
      }

#else
      if (errno == EAGAIN)/* || errno == EINTR)*/
      {
        myDataMutex.unlock();
        return true;
      }
      else 
      {
        ArLog::log(ArLog::Normal, "ArNetPacketSenderTcp: Linux failed write with error %d on packet %d with length of %d", errno, myPacket->getCommand(), myLength);
        myDataMutex.unlock();
        return false;
      }
#endif 
    }
    else if (ret == 0)
    {
      // If network connectivity goes down for a length of time, and the
      // socket's buffer fills, we will have this error. An alternative action
      // would be to  retain myAlreadySent at its current value and keep trying to 
      // write data to the socket, in the hope that the network will come back.
      ArLog::log(ArLog::Verbose, "ArNetPacketSenderTcp: Couldn't send packet with command %d and length %d: No data could be sent through socket (%d bytes sent until now).", myPacket->getCommand(), myLength, myAlreadySent);
      myDataMutex.unlock();
      return true;
    }
    else if (ret > 0)
    {
      myAlreadySent += ret;
      if (myAlreadySent == myLength)
      {
        //printf("sent one %g\n", start.mSecSince() / 1000.0);
        delete myPacket;
        myPacket = NULL;
        continue;
      }
    }
    else
    {
      ArLog::log(ArLog::Terse, "ArNetPacketSenderTcp: Bad case in sendData");
      
    }
  }
  myDataMutex.unlock();
  return true;
}

---