ROOT logo
// @(#)root/net:$Id: TUDPSocket.cxx 41908 2011-11-11 14:43:28Z pcanal $
// Author: Marcelo Sousa   26/10/2011

/*************************************************************************
 * Copyright (C) 1995-2011, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TUDPSocket                                                           //
//                                                                      //
// This class implements UDP client sockets. A socket is an endpoint    //
// for communication between two machines.                              //
// The actual work is done via the TSystem class (either TUnixSystem    //
// or TWinNTSystem).                                                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "Bytes.h"
#include "Compression.h"
#include "NetErrors.h"
#include "TEnv.h"
#include "TError.h"
#include "TMessage.h"
#include "TUDPSocket.h"
#include "TPluginManager.h"
#include "TROOT.h"
#include "TString.h"
#include "TSystem.h"
#include "TUrl.h"
#include "TVirtualAuth.h"
#include "TStreamerInfo.h"
#include "TProcessID.h"

ULong64_t TUDPSocket::fgBytesSent = 0;
ULong64_t TUDPSocket::fgBytesRecv = 0;


ClassImp(TUDPSocket)

//______________________________________________________________________________
TUDPSocket::TUDPSocket(TInetAddress addr, const char *service)
         : TNamed(addr.GetHostName(), service)
{
   // Create a socket. Connect to the named service at address addr.
   // Use tcpwindowsize to specify the size of the receive buffer, it has
   // to be specified here to make sure the window scale option is set (for
   // tcpwindowsize > 65KB and for platforms supporting window scaling).
   // Returns when connection has been accepted by remote side. Use IsValid()
   // to check the validity of the socket. Every socket is added to the TROOT
   // sockets list which will make sure that any open sockets are properly
   // closed on program termination.

   R__ASSERT(gROOT);
   R__ASSERT(gSystem);

   fService = service;
   fSecContext = 0;
   fRemoteProtocol= -1;
   fServType = kSOCKD;
   if (fService.Contains("root"))
      fServType = kROOTD;
   if (fService.Contains("proof"))
      fServType = kPROOFD;
   fAddress = addr;
   fAddress.fPort = gSystem->GetServiceByName(service);
   fBytesSent = 0;
   fBytesRecv = 0;
   fCompress = 0;
   fUUIDs = 0;
   fLastUsageMtx = 0;
   ResetBit(TUDPSocket::kBrokenConn);

   if (fAddress.GetPort() != -1) {
      fSocket = gSystem->OpenConnection(addr.GetHostName(), fAddress.GetPort(),
                                        -1, "upd");

      if (fSocket != -1) {
         R__LOCKGUARD2(gROOTMutex);
         gROOT->GetListOfSockets()->Add(this);
      }
   } else
      fSocket = -1;

}


//______________________________________________________________________________
TUDPSocket::TUDPSocket(TInetAddress addr, Int_t port)
         : TNamed(addr.GetHostName(), "")
{
   // Create a socket. Connect to the specified port # at address addr.
   // Use tcpwindowsize to specify the size of the receive buffer, it has
   // to be specified here to make sure the window scale option is set (for
   // tcpwindowsize > 65KB and for platforms supporting window scaling).
   // Returns when connection has been accepted by remote side. Use IsValid()
   // to check the validity of the socket. Every socket is added to the TROOT
   // sockets list which will make sure that any open sockets are properly
   // closed on program termination.

   R__ASSERT(gROOT);
   R__ASSERT(gSystem);

   fService = gSystem->GetServiceByPort(port);
   fSecContext = 0;
   fRemoteProtocol= -1;
   fServType = kSOCKD;
   if (fService.Contains("root"))
      fServType = kROOTD;
   if (fService.Contains("proof"))
      fServType = kPROOFD;
   fAddress = addr;
   fAddress.fPort = port;
   SetTitle(fService);
   fBytesSent = 0;
   fBytesRecv = 0;
   fCompress = 0;
   fUUIDs = 0;
   fLastUsageMtx = 0;
   ResetBit(TUDPSocket::kBrokenConn);

   fSocket = gSystem->OpenConnection(addr.GetHostName(), fAddress.GetPort(),
                                     -1, "upd");
   if (fSocket == -1)
      fAddress.fPort = -1;
   else {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Add(this);
   }
}

//______________________________________________________________________________
TUDPSocket::TUDPSocket(const char *host, const char *service)
         : TNamed(host, service)
{
   // Create a socket. Connect to named service on the remote host.
   // Use tcpwindowsize to specify the size of the receive buffer, it has
   // to be specified here to make sure the window scale option is set (for
   // tcpwindowsize > 65KB and for platforms supporting window scaling).
   // Returns when connection has been accepted by remote side. Use IsValid()
   // to check the validity of the socket. Every socket is added to the TROOT
   // sockets list which will make sure that any open sockets are properly
   // closed on program termination.

   R__ASSERT(gROOT);
   R__ASSERT(gSystem);

   fService = service;
   fSecContext = 0;
   fRemoteProtocol= -1;
   fServType = kSOCKD;
   if (fService.Contains("root"))
      fServType = kROOTD;
   if (fService.Contains("proof"))
      fServType = kPROOFD;
   fAddress = gSystem->GetHostByName(host);
   fAddress.fPort = gSystem->GetServiceByName(service);
   SetName(fAddress.GetHostName());
   fBytesSent = 0;
   fBytesRecv = 0;
   fCompress = 0;
   fUUIDs = 0;
   fLastUsageMtx = 0;
   ResetBit(TUDPSocket::kBrokenConn);

   if (fAddress.GetPort() != -1) {
      fSocket = gSystem->OpenConnection(host, fAddress.GetPort(), -1, "upd");
      if (fSocket != -1) {
         R__LOCKGUARD2(gROOTMutex);
         gROOT->GetListOfSockets()->Add(this);
      }
   } else
      fSocket = -1;
}

//______________________________________________________________________________
TUDPSocket::TUDPSocket(const char *url, Int_t port)
         : TNamed(TUrl(url).GetHost(), "")
{
   // Create a socket; see CreateAuthSocket for the form of url.
   // Connect to the specified port # on the remote host.
   // If user is specified in url, try authentication as user.
   // Use tcpwindowsize to specify the size of the receive buffer, it has
   // to be specified here to make sure the window scale option is set (for
   // tcpwindowsize > 65KB and for platforms supporting window scaling).
   // Returns when connection has been accepted by remote side. Use IsValid()
   // to check the validity of the socket. Every socket is added to the TROOT
   // sockets list which will make sure that any open sockets are properly
   // closed on program termination.

   R__ASSERT(gROOT);
   R__ASSERT(gSystem);

   fUrl = TString(url);
   TString host(TUrl(fUrl).GetHost());

   fService = gSystem->GetServiceByPort(port);
   fSecContext = 0;
   fRemoteProtocol= -1;
   fServType = kSOCKD;
   if (fUrl.Contains("root"))
      fServType = kROOTD;
   if (fUrl.Contains("proof"))
      fServType = kPROOFD;
   fAddress = gSystem->GetHostByName(host);
   fAddress.fPort = port;
   SetName(fAddress.GetHostName());
   SetTitle(fService);
   fBytesSent = 0;
   fBytesRecv = 0;
   fCompress = 0;
   fUUIDs = 0;
   fLastUsageMtx = 0;
   ResetBit(TUDPSocket::kBrokenConn);

   fSocket = gSystem->OpenConnection(host, fAddress.GetPort(), -1, "udp");
   if (fSocket == -1) {
      fAddress.fPort = -1;
   } else {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Add(this);
   }
}

//______________________________________________________________________________
TUDPSocket::TUDPSocket(const char *sockpath) : TNamed(sockpath, "")
{
   // Create a socket in the Unix domain on 'sockpath'.
   // Returns when connection has been accepted by the server. Use IsValid()
   // to check the validity of the socket. Every socket is added to the TROOT
   // sockets list which will make sure that any open sockets are properly
   // closed on program termination.

   R__ASSERT(gROOT);
   R__ASSERT(gSystem);

   fUrl = sockpath;

   fService = "unix";
   fSecContext = 0;
   fRemoteProtocol= -1;
   fServType = kSOCKD;
   fAddress.fPort = -1;
   fName.Form("unix:%s", sockpath);
   SetTitle(fService);
   fBytesSent = 0;
   fBytesRecv = 0;
   fCompress  = 0;
   fUUIDs = 0;
   fLastUsageMtx  = 0;
   ResetBit(TUDPSocket::kBrokenConn);

   fSocket = gSystem->OpenConnection(sockpath, -1, -1, "udp");
   if (fSocket > 0) {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Add(this);
   }
}

//______________________________________________________________________________
TUDPSocket::TUDPSocket(Int_t desc) : TNamed("", "")
{
   // Create a socket. The socket will adopt previously opened TCP socket with
   // descriptor desc.

   R__ASSERT(gROOT);
   R__ASSERT(gSystem);

   fSecContext     = 0;
   fRemoteProtocol = 0;
   fService        = (char *)kSOCKD;
   fServType       = kSOCKD;
   fBytesSent      = 0;
   fBytesRecv      = 0;
   fCompress       = 0;
   fUUIDs          = 0;
   fLastUsageMtx   = 0;
   ResetBit(TUDPSocket::kBrokenConn);

   if (desc >= 0) {
      fSocket  = desc;
      fAddress = gSystem->GetPeerName(fSocket);
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Add(this);
   } else
      fSocket = -1;
}

//______________________________________________________________________________
TUDPSocket::TUDPSocket(Int_t desc, const char *sockpath) : TNamed(sockpath, "")
{
   // Create a socket. The socket will adopt previously opened Unix socket with
   // descriptor desc. The sockpath arg is for info purposes only. Use
   // this method to adopt e.g. a socket created via socketpair().

   R__ASSERT(gROOT);
   R__ASSERT(gSystem);

   fUrl = sockpath;

   fService = "unix";
   fSecContext = 0;
   fRemoteProtocol= -1;
   fServType = kSOCKD;
   fAddress.fPort = -1;
   fName.Form("unix:%s", sockpath);
   SetTitle(fService);
   fBytesSent = 0;
   fBytesRecv = 0;
   fCompress  = 0;
   fUUIDs = 0;
   fLastUsageMtx  = 0;
   ResetBit(TUDPSocket::kBrokenConn);

   if (desc >= 0) {
      fSocket  = desc;
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Add(this);
   } else
      fSocket = -1;
}


//______________________________________________________________________________
TUDPSocket::TUDPSocket(const TUDPSocket &s) : TNamed(s)
{
   // TUDPSocket copy ctor.

   fSocket         = s.fSocket;
   fService        = s.fService;
   fAddress        = s.fAddress;
   fLocalAddress   = s.fLocalAddress;
   fBytesSent      = s.fBytesSent;
   fBytesRecv      = s.fBytesRecv;
   fCompress       = s.fCompress;
   fSecContext     = s.fSecContext;
   fRemoteProtocol = s.fRemoteProtocol;
   fServType       = s.fServType;
   fUUIDs          = 0;
   fLastUsageMtx   = 0;
   ResetBit(TUDPSocket::kBrokenConn);

   if (fSocket != -1) {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Add(this);
   }
}

//______________________________________________________________________________
void TUDPSocket::Close(Option_t *option)
{
   // Close the socket. If option is "force", calls shutdown(id,2) to
   // shut down the connection. This will close the connection also
   // for the parent of this process. Also called via the dtor (without
   // option "force", call explicitely Close("force") if this is desired).

   Bool_t force = option ? (!strcmp(option, "force") ? kTRUE : kFALSE) : kFALSE;

   if (fSocket != -1) {
      gSystem->CloseConnection(fSocket, force);
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Remove(this);
   }
   fSocket = -1;

   SafeDelete(fUUIDs);
   SafeDelete(fLastUsageMtx);
}

//______________________________________________________________________________
TInetAddress TUDPSocket::GetLocalInetAddress()
{
   // Return internet address of local host to which the socket is bound.
   // In case of error TInetAddress::IsValid() returns kFALSE.

   if (IsValid()) {
      if (fLocalAddress.GetPort() == -1)
         fLocalAddress = gSystem->GetSockName(fSocket);
      return fLocalAddress;
   }
   return TInetAddress();
}

//______________________________________________________________________________
Int_t TUDPSocket::GetLocalPort()
{
   // Return the local port # to which the socket is bound.
   // In case of error return -1.

   if (IsValid()) {
      if (fLocalAddress.GetPort() == -1)
         GetLocalInetAddress();
      return fLocalAddress.GetPort();
   }
   return -1;
}

//______________________________________________________________________________
Int_t TUDPSocket::Select(Int_t interest, Long_t timeout)
{
   // Waits for this socket to change status. If interest=kRead,
   // the socket will be watched to see if characters become available for
   // reading; if interest=kWrite the socket will be watched to
   // see if a write will not block.
   // The argument 'timeout' specifies a maximum time to wait in millisec.
   // Default no timeout.
   // Returns 1 if a change of status of interest has been detected within
   // timeout; 0 in case of timeout; < 0 if an error occured.

   Int_t rc = 1;

   // Associate a TFileHandler to this socket
   TFileHandler fh(fSocket, interest);

   // Wait for an event now
   rc = gSystem->Select(&fh, timeout);

   return rc;
}

//______________________________________________________________________________
Int_t TUDPSocket::Send(Int_t kind)
{
   // Send a single message opcode. Use kind (opcode) to set the
   // TMessage "what" field. Returns the number of bytes that were sent
   // (always sizeof(Int_t)) and -1 in case of error. In case the kind has
   // been or'ed with kMESS_ACK, the call will only return after having
   // received an acknowledgement, making the sending process synchronous.

   TMessage mess(kind);

   Int_t nsent;
   if ((nsent = Send(mess)) < 0)
      return -1;

   return nsent;
}

//______________________________________________________________________________
Int_t TUDPSocket::Send(Int_t status, Int_t kind)
{
   // Send a status and a single message opcode. Use kind (opcode) to set the
   // TMessage "what" field. Returns the number of bytes that were sent
   // (always 2*sizeof(Int_t)) and -1 in case of error. In case the kind has
   // been or'ed with kMESS_ACK, the call will only return after having
   // received an acknowledgement, making the sending process synchronous.

   TMessage mess(kind);
   mess << status;

   Int_t nsent;
   if ((nsent = Send(mess)) < 0)
      return -1;

   return nsent;
}

//______________________________________________________________________________
Int_t TUDPSocket::Send(const char *str, Int_t kind)
{
   // Send a character string buffer. Use kind to set the TMessage "what" field.
   // Returns the number of bytes in the string str that were sent and -1 in
   // case of error. In case the kind has been or'ed with kMESS_ACK, the call
   // will only return after having received an acknowledgement, making the
   // sending process synchronous.

   TMessage mess(kind);
   if (str) mess.WriteString(str);

   Int_t nsent;
   if ((nsent = Send(mess)) < 0)
      return -1;

   return nsent - sizeof(Int_t);    // - TMessage::What()
}

//______________________________________________________________________________
Int_t TUDPSocket::Send(const TMessage &mess)
{
   // Send a TMessage object. Returns the number of bytes in the TMessage
   // that were sent and -1 in case of error. In case the TMessage::What
   // has been or'ed with kMESS_ACK, the call will only return after having
   // received an acknowledgement, making the sending process synchronous.
   // Returns -4 in case of kNoBlock and errno == EWOULDBLOCK.
   // Returns -5 if pipe broken or reset by peer (EPIPE || ECONNRESET).
   // support for streaming TStreamerInfo added by Rene Brun May 2008
   // support for streaming TProcessID added by Rene Brun June 2008

   TSystem::ResetErrno();

   if (fSocket == -1) return -1;

   if (mess.IsReading()) {
      Error("Send", "cannot send a message used for reading");
      return -1;
   }

   // send streamer infos in case schema evolution is enabled in the TMessage
   SendStreamerInfos(mess);

   // send the process id's so TRefs work
   SendProcessIDs(mess);

   mess.SetLength();   //write length in first word of buffer

   if (GetCompressionLevel() > 0 && mess.GetCompressionLevel() == 0)
      const_cast<TMessage&>(mess).SetCompressionSettings(fCompress);

   if (mess.GetCompressionLevel() > 0)
      const_cast<TMessage&>(mess).Compress();

   char *mbuf = mess.Buffer();
   Int_t mlen = mess.Length();
   if (mess.CompBuffer()) {
      mbuf = mess.CompBuffer();
      mlen = mess.CompLength();
   }

   ResetBit(TUDPSocket::kBrokenConn);
   Int_t nsent;
   if ((nsent = gSystem->SendRaw(fSocket, mbuf, mlen, 0)) <= 0) {
      if (nsent == -5) {
         // Connection reset by peer or broken
         SetBit(TUDPSocket::kBrokenConn);
         Close();
      }
      return nsent;
   }

   fBytesSent  += nsent;
   fgBytesSent += nsent;

   // If acknowledgement is desired, wait for it
   if (mess.What() & kMESS_ACK) {
      TSystem::ResetErrno();
      ResetBit(TUDPSocket::kBrokenConn);
      char buf[2];
      Int_t n = 0;
      if ((n = gSystem->RecvRaw(fSocket, buf, sizeof(buf), 0)) < 0) {
         if (n == -5) {
            // Connection reset by peer or broken
            SetBit(TUDPSocket::kBrokenConn);
            Close();
         } else
            n = -1;
         return n;
      }
      if (strncmp(buf, "ok", 2)) {
         Error("Send", "bad acknowledgement");
         return -1;
      }
      fBytesRecv  += 2;
      fgBytesRecv += 2;
   }

   Touch();  // update usage timestamp

   return nsent - sizeof(UInt_t);  //length - length header
}

//______________________________________________________________________________
Int_t TUDPSocket::SendObject(const TObject *obj, Int_t kind)
{
   // Send an object. Returns the number of bytes sent and -1 in case of error.
   // In case the "kind" has been or'ed with kMESS_ACK, the call will only
   // return after having received an acknowledgement, making the sending
   // synchronous.

   //stream object to message buffer
   TMessage mess(kind);
   mess.WriteObject(obj);

   //now sending the object itself
   Int_t nsent;
   if ((nsent = Send(mess)) < 0)
      return -1;

   return nsent;
}

//______________________________________________________________________________
Int_t TUDPSocket::SendRaw(const void *buffer, Int_t length, ESendRecvOptions opt)
{
   // Send a raw buffer of specified length. Using option kOob one can send
   // OOB data. Returns the number of bytes sent or -1 in case of error.
   // Returns -4 in case of kNoBlock and errno == EWOULDBLOCK.
   // Returns -5 if pipe broken or reset by peer (EPIPE || ECONNRESET).

   TSystem::ResetErrno();

   if (fSocket == -1) return -1;

   ResetBit(TUDPSocket::kBrokenConn);
   Int_t nsent;
   if ((nsent = gSystem->SendRaw(fSocket, buffer, length, (int) opt)) <= 0) {
      if (nsent == -5) {
         // Connection reset or broken: close
         SetBit(TUDPSocket::kBrokenConn);
         Close();
      }
      return nsent;
   }

   fBytesSent  += nsent;
   fgBytesSent += nsent;

   Touch();  // update usage timestamp

   return nsent;
}

//______________________________________________________________________________
void TUDPSocket::SendStreamerInfos(const TMessage &mess)
{
   // Check if TStreamerInfo must be sent. The list of TStreamerInfo of classes
   // in the object in the message is in the fInfos list of the message.
   // We send only the TStreamerInfos not yet sent on this socket.

   if (mess.fInfos && mess.fInfos->GetEntries()) {
      TIter next(mess.fInfos);
      TStreamerInfo *info;
      TList *minilist = 0;
      while ((info = (TStreamerInfo*)next())) {
         Int_t uid = info->GetNumber();
         if (fBitsInfo.TestBitNumber(uid))
            continue; //TStreamerInfo had already been sent
         fBitsInfo.SetBitNumber(uid);
         if (!minilist)
            minilist = new TList();
         if (gDebug > 0)
            Info("SendStreamerInfos", "sending TStreamerInfo: %s, version = %d",
                 info->GetName(),info->GetClassVersion());
         minilist->Add(info);
      }
      if (minilist) {
         TMessage messinfo(kMESS_STREAMERINFO);
         messinfo.WriteObject(minilist);
         delete minilist;
         if (messinfo.fInfos)
            messinfo.fInfos->Clear();
         if (Send(messinfo) < 0)
            Warning("SendStreamerInfos", "problems sending TStreamerInfo's ...");
      }
   }
}

//______________________________________________________________________________
void TUDPSocket::SendProcessIDs(const TMessage &mess)
{
   // Check if TProcessIDs must be sent. The list of TProcessIDs
   // in the object in the message is found by looking in the TMessage bits.
   // We send only the TProcessIDs not yet send on this socket.

   if (mess.TestBitNumber(0)) {
      TObjArray *pids = TProcessID::GetPIDs();
      Int_t npids = pids->GetEntries();
      TProcessID *pid;
      TList *minilist = 0;
      for (Int_t ipid = 0; ipid < npids; ipid++) {
         pid = (TProcessID*)pids->At(ipid);
         if (!pid || !mess.TestBitNumber(pid->GetUniqueID()+1))
            continue;
         //check if a pid with this title has already been sent through the socket
         //if not add it to the fUUIDs list
         if (!fUUIDs) {
            fUUIDs = new TList();
         } else {
            if (fUUIDs->FindObject(pid->GetTitle()))
               continue;
         }
         fUUIDs->Add(new TObjString(pid->GetTitle()));
         if (!minilist)
            minilist = new TList();
         if (gDebug > 0)
            Info("SendProcessIDs", "sending TProcessID: %s", pid->GetTitle());
         minilist->Add(pid);
      }
      if (minilist) {
         TMessage messpid(kMESS_PROCESSID);
         messpid.WriteObject(minilist);
         delete minilist;
         if (Send(messpid) < 0)
            Warning("SendProcessIDs", "problems sending TProcessID's ...");
      }
   }
}

//______________________________________________________________________________
Int_t TUDPSocket::Recv(char *str, Int_t max)
{
   // Receive a character string message of maximum max length. The expected
   // message must be of type kMESS_STRING. Returns length of received string
   // (can be 0 if otherside of connection is closed) or -1 in case of error
   // or -4 in case a non-blocking socket would block (i.e. there is nothing
   // to be read).

   Int_t n, kind;

   ResetBit(TUDPSocket::kBrokenConn);
   if ((n = Recv(str, max, kind)) <= 0) {
      if (n == -5) {
         SetBit(TUDPSocket::kBrokenConn);
         n = -1;
      }
      return n;
   }

   if (kind != kMESS_STRING) {
      Error("Recv", "got message of wrong kind (expected %d, got %d)",
            kMESS_STRING, kind);
      return -1;
   }

   return n;
}

//______________________________________________________________________________
Int_t TUDPSocket::Recv(char *str, Int_t max, Int_t &kind)
{
   // Receive a character string message of maximum max length. Returns in
   // kind the message type. Returns length of received string+4 (can be 0 if
   // other side of connection is closed) or -1 in case of error or -4 in
   // case a non-blocking socket would block (i.e. there is nothing to be read).

   Int_t     n;
   TMessage *mess;

   ResetBit(TUDPSocket::kBrokenConn);
   if ((n = Recv(mess)) <= 0) {
      if (n == -5) {
         SetBit(TUDPSocket::kBrokenConn);
         n = -1;
      }
      return n;
   }

   kind = mess->What();
   if (str) {
      if (mess->BufferSize() > (Int_t)sizeof(Int_t)) // if mess contains more than kind
         mess->ReadString(str, max);
      else
         str[0] = 0;
   }

   delete mess;

   return n;   // number of bytes read (len of str + sizeof(kind)
}

//______________________________________________________________________________
Int_t TUDPSocket::Recv(Int_t &status, Int_t &kind)
{
   // Receives a status and a message type. Returns length of received
   // integers, 2*sizeof(Int_t) (can be 0 if other side of connection
   // is closed) or -1 in case of error or -4 in case a non-blocking
   // socket would block (i.e. there is nothing to be read).

   Int_t     n;
   TMessage *mess;

   ResetBit(TUDPSocket::kBrokenConn);
   if ((n = Recv(mess)) <= 0) {
      if (n == -5) {
         SetBit(TUDPSocket::kBrokenConn);
         n = -1;
      }
      return n;
   }

   kind = mess->What();
   (*mess) >> status;

   delete mess;

   return n;   // number of bytes read (2 * sizeof(Int_t)
}

//______________________________________________________________________________
Int_t TUDPSocket::Recv(TMessage *&mess)
{
   // Receive a TMessage object. The user must delete the TMessage object.
   // Returns length of message in bytes (can be 0 if other side of connection
   // is closed) or -1 in case of error or -4 in case a non-blocking socket
   // would block (i.e. there is nothing to be read) or -5 if pipe broken
   // or reset by peer (EPIPE || ECONNRESET). In those case mess == 0.

   TSystem::ResetErrno();

   if (fSocket == -1) {
      mess = 0;
      return -1;
   }

oncemore:
   ResetBit(TUDPSocket::kBrokenConn);
   Int_t  n;
   UInt_t len;
   if ((n = gSystem->RecvRaw(fSocket, &len, sizeof(UInt_t), 0)) <= 0) {
      if (n == 0 || n == -5) {
         // Connection closed, reset or broken
         SetBit(TUDPSocket::kBrokenConn);
         Close();
      }
      mess = 0;
      return n;
   }
   len = net2host(len);  //from network to host byte order

   ResetBit(TUDPSocket::kBrokenConn);
   char *buf = new char[len+sizeof(UInt_t)];
   if ((n = gSystem->RecvRaw(fSocket, buf+sizeof(UInt_t), len, 0)) <= 0) {
      if (n == 0 || n == -5) {
         // Connection closed, reset or broken
         SetBit(TUDPSocket::kBrokenConn);
         Close();
      }
      delete [] buf;
      mess = 0;
      return n;
   }

   fBytesRecv  += n + sizeof(UInt_t);
   fgBytesRecv += n + sizeof(UInt_t);

   mess = new TMessage(buf, len+sizeof(UInt_t));

   // receive any streamer infos
   if (RecvStreamerInfos(mess))
      goto oncemore;

   // receive any process ids
   if (RecvProcessIDs(mess))
      goto oncemore;

   if (mess->What() & kMESS_ACK) {
      ResetBit(TUDPSocket::kBrokenConn);
      char ok[2] = { 'o', 'k' };
      Int_t n2 = 0;
      if ((n2 = gSystem->SendRaw(fSocket, ok, sizeof(ok), 0)) < 0) {
         if (n2 == -5) {
            // Connection reset or broken
            SetBit(TUDPSocket::kBrokenConn);
            Close();
         }
         delete mess;
         mess = 0;
         return n2;
      }
      mess->SetWhat(mess->What() & ~kMESS_ACK);

      fBytesSent  += 2;
      fgBytesSent += 2;
   }

   Touch();  // update usage timestamp

   return n;
}

//______________________________________________________________________________
Int_t TUDPSocket::RecvRaw(void *buffer, Int_t length, ESendRecvOptions opt)
{
   // Receive a raw buffer of specified length bytes. Using option kPeek
   // one can peek at incoming data. Returns number of received bytes.
   // Returns -1 in case of error. In case of opt == kOob: -2 means
   // EWOULDBLOCK and -3 EINVAL. In case of non-blocking mode (kNoBlock)
   // -4 means EWOULDBLOCK. Returns -5 if pipe broken or reset by
   // peer (EPIPE || ECONNRESET).

   TSystem::ResetErrno();

   if (fSocket == -1) return -1;
   if (length == 0) return 0;

   ResetBit(TUDPSocket::kBrokenConn);
   Int_t n;
   if ((n = gSystem->RecvRaw(fSocket, buffer, length, (int) opt)) <= 0) {
      if (n == 0 || n == -5) {
         // Connection closed, reset or broken
         SetBit(TUDPSocket::kBrokenConn);
         Close();
      }
      return n;
   }

   fBytesRecv  += n;
   fgBytesRecv += n;

   Touch();  // update usage timestamp

   return n;
}

//______________________________________________________________________________
Bool_t TUDPSocket::RecvStreamerInfos(TMessage *mess)
{
   // Receive a message containing streamer infos. In case the message contains
   // streamer infos they are imported, the message will be deleted and the
   // method returns kTRUE.

   if (mess->What() == kMESS_STREAMERINFO) {
      TList *list = (TList*)mess->ReadObject(TList::Class());
      TIter next(list);
      TStreamerInfo *info;
      TObjLink *lnk = list->FirstLink();
      // First call BuildCheck for regular class
      while (lnk) {
         info = (TStreamerInfo*)lnk->GetObject();
         TObject *element = info->GetElements()->UncheckedAt(0);
         Bool_t isstl = element && strcmp("This",element->GetName())==0;
         if (!isstl) {
            info->BuildCheck();
            if (gDebug > 0)
               Info("RecvStreamerInfos", "importing TStreamerInfo: %s, version = %d",
                    info->GetName(), info->GetClassVersion());
         }
         lnk = lnk->Next();
      }
      // Then call BuildCheck for stl class
      lnk = list->FirstLink();
      while (lnk) {
         info = (TStreamerInfo*)lnk->GetObject();
         TObject *element = info->GetElements()->UncheckedAt(0);
         Bool_t isstl = element && strcmp("This",element->GetName())==0;
         if (isstl) {
            info->BuildCheck();
            if (gDebug > 0)
               Info("RecvStreamerInfos", "importing TStreamerInfo: %s, version = %d",
                    info->GetName(), info->GetClassVersion());
         }
         lnk = lnk->Next();
     }
      delete list;
      delete mess;

      return kTRUE;
   }
   return kFALSE;
}

//______________________________________________________________________________
Bool_t TUDPSocket::RecvProcessIDs(TMessage *mess)
{
   // Receive a message containing process ids. In case the message contains
   // process ids they are imported, the message will be deleted and the
   // method returns kTRUE.

   if (mess->What() == kMESS_PROCESSID) {
      TList *list = (TList*)mess->ReadObject(TList::Class());
      TIter next(list);
      TProcessID *pid;
      while ((pid = (TProcessID*)next())) {
         // check that a similar pid is not already registered in fgPIDs
         TObjArray *pidslist = TProcessID::GetPIDs();
         TIter nextpid(pidslist);
         TProcessID *p;
         while ((p = (TProcessID*)nextpid())) {
            if (!strcmp(p->GetTitle(), pid->GetTitle())) {
               delete pid;
               pid = 0;
               break;
            }
         }
         if (pid) {
            if (gDebug > 0)
               Info("RecvProcessIDs", "importing TProcessID: %s", pid->GetTitle());
            pid->IncrementCount();
            pidslist->Add(pid);
            Int_t ind = pidslist->IndexOf(pid);
            pid->SetUniqueID((UInt_t)ind);
         }
      }
      delete list;
      delete mess;

      return kTRUE;
   }
   return kFALSE;
}

//______________________________________________________________________________
Int_t TUDPSocket::SetOption(ESockOptions opt, Int_t val)
{
   // Set socket options.

   if (fSocket == -1) return -1;

   return gSystem->SetSockOpt(fSocket, opt, val);
}

//______________________________________________________________________________
Int_t TUDPSocket::GetOption(ESockOptions opt, Int_t &val)
{
   // Get socket options. Returns -1 in case of error.

   if (fSocket == -1) return -1;

   return gSystem->GetSockOpt(fSocket, opt, &val);
}

//______________________________________________________________________________
Int_t TUDPSocket::GetErrorCode() const
{
   // Returns error code. Meaning depends on context where it is called.
   // If no error condition returns 0 else a value < 0.
   // For example see TServerSocket ctor.

   if (!IsValid())
      return fSocket;

   return 0;
}

//______________________________________________________________________________
void TUDPSocket::SetCompressionAlgorithm(Int_t algorithm)
{
   // See comments for function SetCompressionSettings
   if (algorithm < 0 || algorithm >= ROOT::kUndefinedCompressionAlgorithm) algorithm = 0;
   if (fCompress < 0) {
      // if the level is not defined yet use 1 as a default
      fCompress = 100 * algorithm + 1;
   } else {
      int level = fCompress % 100;
      fCompress = 100 * algorithm + level;
   }
}

//______________________________________________________________________________
void TUDPSocket::SetCompressionLevel(Int_t level)
{
   // See comments for function SetCompressionSettings
   if (level < 0) level = 0;
   if (level > 99) level = 99;
   if (fCompress < 0) {
      // if the algorithm is not defined yet use 0 as a default
      fCompress = level;
   } else {
      int algorithm = fCompress / 100;
      if (algorithm >= ROOT::kUndefinedCompressionAlgorithm) algorithm = 0;
      fCompress = 100 * algorithm + level;
   }
}

//______________________________________________________________________________
void TUDPSocket::SetCompressionSettings(Int_t settings)
{
   // Used to specify the compression level and algorithm:
   //  settings = 100 * algorithm + level
   //
   //  level = 0, objects written to this file will not be compressed.
   //  level = 1, minimal compression level but fast.
   //  ....
   //  level = 9, maximal compression level but slower and might use more memory.
   // (For the currently supported algorithms, the maximum level is 9)
   // If compress is negative it indicates the compression level is not set yet.
   //
   // The enumeration ROOT::ECompressionAlgorithm associates each
   // algorithm with a number. There is a utility function to help
   // to set the value of the argument. For example,
   //   ROOT::CompressionSettings(ROOT::kLZMA, 1)
   // will build an integer which will set the compression to use
   // the LZMA algorithm and compression level 1.  These are defined
   // in the header file Compression.h.
   //
   // Note that the compression settings may be changed at any time.
   // The new compression settings will only apply to branches created
   // or attached after the setting is changed and other objects written
   // after the setting is changed.

   fCompress = settings;
}

//______________________________________________________________________________
void TUDPSocket::NetError(const char *where, Int_t err)
{
   // Print error string depending on error code.

   // Make sure it is in range
   err = (err < kErrError) ? ((err > -1) ? err : 0) : kErrError;

   if (gDebug > 0)
      ::Error(where, "%s", gRootdErrStr[err]);
}

//______________________________________________________________________________
ULong64_t TUDPSocket::GetSocketBytesSent()
{
   // Get total number of bytes sent via all sockets.

   return fgBytesSent;
}

//______________________________________________________________________________
ULong64_t TUDPSocket::GetSocketBytesRecv()
{
   // Get total number of bytes received via all sockets.

   return fgBytesRecv;
}

 TUDPSocket.cxx:1
 TUDPSocket.cxx:2
 TUDPSocket.cxx:3
 TUDPSocket.cxx:4
 TUDPSocket.cxx:5
 TUDPSocket.cxx:6
 TUDPSocket.cxx:7
 TUDPSocket.cxx:8
 TUDPSocket.cxx:9
 TUDPSocket.cxx:10
 TUDPSocket.cxx:11
 TUDPSocket.cxx:12
 TUDPSocket.cxx:13
 TUDPSocket.cxx:14
 TUDPSocket.cxx:15
 TUDPSocket.cxx:16
 TUDPSocket.cxx:17
 TUDPSocket.cxx:18
 TUDPSocket.cxx:19
 TUDPSocket.cxx:20
 TUDPSocket.cxx:21
 TUDPSocket.cxx:22
 TUDPSocket.cxx:23
 TUDPSocket.cxx:24
 TUDPSocket.cxx:25
 TUDPSocket.cxx:26
 TUDPSocket.cxx:27
 TUDPSocket.cxx:28
 TUDPSocket.cxx:29
 TUDPSocket.cxx:30
 TUDPSocket.cxx:31
 TUDPSocket.cxx:32
 TUDPSocket.cxx:33
 TUDPSocket.cxx:34
 TUDPSocket.cxx:35
 TUDPSocket.cxx:36
 TUDPSocket.cxx:37
 TUDPSocket.cxx:38
 TUDPSocket.cxx:39
 TUDPSocket.cxx:40
 TUDPSocket.cxx:41
 TUDPSocket.cxx:42
 TUDPSocket.cxx:43
 TUDPSocket.cxx:44
 TUDPSocket.cxx:45
 TUDPSocket.cxx:46
 TUDPSocket.cxx:47
 TUDPSocket.cxx:48
 TUDPSocket.cxx:49
 TUDPSocket.cxx:50
 TUDPSocket.cxx:51
 TUDPSocket.cxx:52
 TUDPSocket.cxx:53
 TUDPSocket.cxx:54
 TUDPSocket.cxx:55
 TUDPSocket.cxx:56
 TUDPSocket.cxx:57
 TUDPSocket.cxx:58
 TUDPSocket.cxx:59
 TUDPSocket.cxx:60
 TUDPSocket.cxx:61
 TUDPSocket.cxx:62
 TUDPSocket.cxx:63
 TUDPSocket.cxx:64
 TUDPSocket.cxx:65
 TUDPSocket.cxx:66
 TUDPSocket.cxx:67
 TUDPSocket.cxx:68
 TUDPSocket.cxx:69
 TUDPSocket.cxx:70
 TUDPSocket.cxx:71
 TUDPSocket.cxx:72
 TUDPSocket.cxx:73
 TUDPSocket.cxx:74
 TUDPSocket.cxx:75
 TUDPSocket.cxx:76
 TUDPSocket.cxx:77
 TUDPSocket.cxx:78
 TUDPSocket.cxx:79
 TUDPSocket.cxx:80
 TUDPSocket.cxx:81
 TUDPSocket.cxx:82
 TUDPSocket.cxx:83
 TUDPSocket.cxx:84
 TUDPSocket.cxx:85
 TUDPSocket.cxx:86
 TUDPSocket.cxx:87
 TUDPSocket.cxx:88
 TUDPSocket.cxx:89
 TUDPSocket.cxx:90
 TUDPSocket.cxx:91
 TUDPSocket.cxx:92
 TUDPSocket.cxx:93
 TUDPSocket.cxx:94
 TUDPSocket.cxx:95
 TUDPSocket.cxx:96
 TUDPSocket.cxx:97
 TUDPSocket.cxx:98
 TUDPSocket.cxx:99
 TUDPSocket.cxx:100
 TUDPSocket.cxx:101
 TUDPSocket.cxx:102
 TUDPSocket.cxx:103
 TUDPSocket.cxx:104
 TUDPSocket.cxx:105
 TUDPSocket.cxx:106
 TUDPSocket.cxx:107
 TUDPSocket.cxx:108
 TUDPSocket.cxx:109
 TUDPSocket.cxx:110
 TUDPSocket.cxx:111
 TUDPSocket.cxx:112
 TUDPSocket.cxx:113
 TUDPSocket.cxx:114
 TUDPSocket.cxx:115
 TUDPSocket.cxx:116
 TUDPSocket.cxx:117
 TUDPSocket.cxx:118
 TUDPSocket.cxx:119
 TUDPSocket.cxx:120
 TUDPSocket.cxx:121
 TUDPSocket.cxx:122
 TUDPSocket.cxx:123
 TUDPSocket.cxx:124
 TUDPSocket.cxx:125
 TUDPSocket.cxx:126
 TUDPSocket.cxx:127
 TUDPSocket.cxx:128
 TUDPSocket.cxx:129
 TUDPSocket.cxx:130
 TUDPSocket.cxx:131
 TUDPSocket.cxx:132
 TUDPSocket.cxx:133
 TUDPSocket.cxx:134
 TUDPSocket.cxx:135
 TUDPSocket.cxx:136
 TUDPSocket.cxx:137
 TUDPSocket.cxx:138
 TUDPSocket.cxx:139
 TUDPSocket.cxx:140
 TUDPSocket.cxx:141
 TUDPSocket.cxx:142
 TUDPSocket.cxx:143
 TUDPSocket.cxx:144
 TUDPSocket.cxx:145
 TUDPSocket.cxx:146
 TUDPSocket.cxx:147
 TUDPSocket.cxx:148
 TUDPSocket.cxx:149
 TUDPSocket.cxx:150
 TUDPSocket.cxx:151
 TUDPSocket.cxx:152
 TUDPSocket.cxx:153
 TUDPSocket.cxx:154
 TUDPSocket.cxx:155
 TUDPSocket.cxx:156
 TUDPSocket.cxx:157
 TUDPSocket.cxx:158
 TUDPSocket.cxx:159
 TUDPSocket.cxx:160
 TUDPSocket.cxx:161
 TUDPSocket.cxx:162
 TUDPSocket.cxx:163
 TUDPSocket.cxx:164
 TUDPSocket.cxx:165
 TUDPSocket.cxx:166
 TUDPSocket.cxx:167
 TUDPSocket.cxx:168
 TUDPSocket.cxx:169
 TUDPSocket.cxx:170
 TUDPSocket.cxx:171
 TUDPSocket.cxx:172
 TUDPSocket.cxx:173
 TUDPSocket.cxx:174
 TUDPSocket.cxx:175
 TUDPSocket.cxx:176
 TUDPSocket.cxx:177
 TUDPSocket.cxx:178
 TUDPSocket.cxx:179
 TUDPSocket.cxx:180
 TUDPSocket.cxx:181
 TUDPSocket.cxx:182
 TUDPSocket.cxx:183
 TUDPSocket.cxx:184
 TUDPSocket.cxx:185
 TUDPSocket.cxx:186
 TUDPSocket.cxx:187
 TUDPSocket.cxx:188
 TUDPSocket.cxx:189
 TUDPSocket.cxx:190
 TUDPSocket.cxx:191
 TUDPSocket.cxx:192
 TUDPSocket.cxx:193
 TUDPSocket.cxx:194
 TUDPSocket.cxx:195
 TUDPSocket.cxx:196
 TUDPSocket.cxx:197
 TUDPSocket.cxx:198
 TUDPSocket.cxx:199
 TUDPSocket.cxx:200
 TUDPSocket.cxx:201
 TUDPSocket.cxx:202
 TUDPSocket.cxx:203
 TUDPSocket.cxx:204
 TUDPSocket.cxx:205
 TUDPSocket.cxx:206
 TUDPSocket.cxx:207
 TUDPSocket.cxx:208
 TUDPSocket.cxx:209
 TUDPSocket.cxx:210
 TUDPSocket.cxx:211
 TUDPSocket.cxx:212
 TUDPSocket.cxx:213
 TUDPSocket.cxx:214
 TUDPSocket.cxx:215
 TUDPSocket.cxx:216
 TUDPSocket.cxx:217
 TUDPSocket.cxx:218
 TUDPSocket.cxx:219
 TUDPSocket.cxx:220
 TUDPSocket.cxx:221
 TUDPSocket.cxx:222
 TUDPSocket.cxx:223
 TUDPSocket.cxx:224
 TUDPSocket.cxx:225
 TUDPSocket.cxx:226
 TUDPSocket.cxx:227
 TUDPSocket.cxx:228
 TUDPSocket.cxx:229
 TUDPSocket.cxx:230
 TUDPSocket.cxx:231
 TUDPSocket.cxx:232
 TUDPSocket.cxx:233
 TUDPSocket.cxx:234
 TUDPSocket.cxx:235
 TUDPSocket.cxx:236
 TUDPSocket.cxx:237
 TUDPSocket.cxx:238
 TUDPSocket.cxx:239
 TUDPSocket.cxx:240
 TUDPSocket.cxx:241
 TUDPSocket.cxx:242
 TUDPSocket.cxx:243
 TUDPSocket.cxx:244
 TUDPSocket.cxx:245
 TUDPSocket.cxx:246
 TUDPSocket.cxx:247
 TUDPSocket.cxx:248
 TUDPSocket.cxx:249
 TUDPSocket.cxx:250
 TUDPSocket.cxx:251
 TUDPSocket.cxx:252
 TUDPSocket.cxx:253
 TUDPSocket.cxx:254
 TUDPSocket.cxx:255
 TUDPSocket.cxx:256
 TUDPSocket.cxx:257
 TUDPSocket.cxx:258
 TUDPSocket.cxx:259
 TUDPSocket.cxx:260
 TUDPSocket.cxx:261
 TUDPSocket.cxx:262
 TUDPSocket.cxx:263
 TUDPSocket.cxx:264
 TUDPSocket.cxx:265
 TUDPSocket.cxx:266
 TUDPSocket.cxx:267
 TUDPSocket.cxx:268
 TUDPSocket.cxx:269
 TUDPSocket.cxx:270
 TUDPSocket.cxx:271
 TUDPSocket.cxx:272
 TUDPSocket.cxx:273
 TUDPSocket.cxx:274
 TUDPSocket.cxx:275
 TUDPSocket.cxx:276
 TUDPSocket.cxx:277
 TUDPSocket.cxx:278
 TUDPSocket.cxx:279
 TUDPSocket.cxx:280
 TUDPSocket.cxx:281
 TUDPSocket.cxx:282
 TUDPSocket.cxx:283
 TUDPSocket.cxx:284
 TUDPSocket.cxx:285
 TUDPSocket.cxx:286
 TUDPSocket.cxx:287
 TUDPSocket.cxx:288
 TUDPSocket.cxx:289
 TUDPSocket.cxx:290
 TUDPSocket.cxx:291
 TUDPSocket.cxx:292
 TUDPSocket.cxx:293
 TUDPSocket.cxx:294
 TUDPSocket.cxx:295
 TUDPSocket.cxx:296
 TUDPSocket.cxx:297
 TUDPSocket.cxx:298
 TUDPSocket.cxx:299
 TUDPSocket.cxx:300
 TUDPSocket.cxx:301
 TUDPSocket.cxx:302
 TUDPSocket.cxx:303
 TUDPSocket.cxx:304
 TUDPSocket.cxx:305
 TUDPSocket.cxx:306
 TUDPSocket.cxx:307
 TUDPSocket.cxx:308
 TUDPSocket.cxx:309
 TUDPSocket.cxx:310
 TUDPSocket.cxx:311
 TUDPSocket.cxx:312
 TUDPSocket.cxx:313
 TUDPSocket.cxx:314
 TUDPSocket.cxx:315
 TUDPSocket.cxx:316
 TUDPSocket.cxx:317
 TUDPSocket.cxx:318
 TUDPSocket.cxx:319
 TUDPSocket.cxx:320
 TUDPSocket.cxx:321
 TUDPSocket.cxx:322
 TUDPSocket.cxx:323
 TUDPSocket.cxx:324
 TUDPSocket.cxx:325
 TUDPSocket.cxx:326
 TUDPSocket.cxx:327
 TUDPSocket.cxx:328
 TUDPSocket.cxx:329
 TUDPSocket.cxx:330
 TUDPSocket.cxx:331
 TUDPSocket.cxx:332
 TUDPSocket.cxx:333
 TUDPSocket.cxx:334
 TUDPSocket.cxx:335
 TUDPSocket.cxx:336
 TUDPSocket.cxx:337
 TUDPSocket.cxx:338
 TUDPSocket.cxx:339
 TUDPSocket.cxx:340
 TUDPSocket.cxx:341
 TUDPSocket.cxx:342
 TUDPSocket.cxx:343
 TUDPSocket.cxx:344
 TUDPSocket.cxx:345
 TUDPSocket.cxx:346
 TUDPSocket.cxx:347
 TUDPSocket.cxx:348
 TUDPSocket.cxx:349
 TUDPSocket.cxx:350
 TUDPSocket.cxx:351
 TUDPSocket.cxx:352
 TUDPSocket.cxx:353
 TUDPSocket.cxx:354
 TUDPSocket.cxx:355
 TUDPSocket.cxx:356
 TUDPSocket.cxx:357
 TUDPSocket.cxx:358
 TUDPSocket.cxx:359
 TUDPSocket.cxx:360
 TUDPSocket.cxx:361
 TUDPSocket.cxx:362
 TUDPSocket.cxx:363
 TUDPSocket.cxx:364
 TUDPSocket.cxx:365
 TUDPSocket.cxx:366
 TUDPSocket.cxx:367
 TUDPSocket.cxx:368
 TUDPSocket.cxx:369
 TUDPSocket.cxx:370
 TUDPSocket.cxx:371
 TUDPSocket.cxx:372
 TUDPSocket.cxx:373
 TUDPSocket.cxx:374
 TUDPSocket.cxx:375
 TUDPSocket.cxx:376
 TUDPSocket.cxx:377
 TUDPSocket.cxx:378
 TUDPSocket.cxx:379
 TUDPSocket.cxx:380
 TUDPSocket.cxx:381
 TUDPSocket.cxx:382
 TUDPSocket.cxx:383
 TUDPSocket.cxx:384
 TUDPSocket.cxx:385
 TUDPSocket.cxx:386
 TUDPSocket.cxx:387
 TUDPSocket.cxx:388
 TUDPSocket.cxx:389
 TUDPSocket.cxx:390
 TUDPSocket.cxx:391
 TUDPSocket.cxx:392
 TUDPSocket.cxx:393
 TUDPSocket.cxx:394
 TUDPSocket.cxx:395
 TUDPSocket.cxx:396
 TUDPSocket.cxx:397
 TUDPSocket.cxx:398
 TUDPSocket.cxx:399
 TUDPSocket.cxx:400
 TUDPSocket.cxx:401
 TUDPSocket.cxx:402
 TUDPSocket.cxx:403
 TUDPSocket.cxx:404
 TUDPSocket.cxx:405
 TUDPSocket.cxx:406
 TUDPSocket.cxx:407
 TUDPSocket.cxx:408
 TUDPSocket.cxx:409
 TUDPSocket.cxx:410
 TUDPSocket.cxx:411
 TUDPSocket.cxx:412
 TUDPSocket.cxx:413
 TUDPSocket.cxx:414
 TUDPSocket.cxx:415
 TUDPSocket.cxx:416
 TUDPSocket.cxx:417
 TUDPSocket.cxx:418
 TUDPSocket.cxx:419
 TUDPSocket.cxx:420
 TUDPSocket.cxx:421
 TUDPSocket.cxx:422
 TUDPSocket.cxx:423
 TUDPSocket.cxx:424
 TUDPSocket.cxx:425
 TUDPSocket.cxx:426
 TUDPSocket.cxx:427
 TUDPSocket.cxx:428
 TUDPSocket.cxx:429
 TUDPSocket.cxx:430
 TUDPSocket.cxx:431
 TUDPSocket.cxx:432
 TUDPSocket.cxx:433
 TUDPSocket.cxx:434
 TUDPSocket.cxx:435
 TUDPSocket.cxx:436
 TUDPSocket.cxx:437
 TUDPSocket.cxx:438
 TUDPSocket.cxx:439
 TUDPSocket.cxx:440
 TUDPSocket.cxx:441
 TUDPSocket.cxx:442
 TUDPSocket.cxx:443
 TUDPSocket.cxx:444
 TUDPSocket.cxx:445
 TUDPSocket.cxx:446
 TUDPSocket.cxx:447
 TUDPSocket.cxx:448
 TUDPSocket.cxx:449
 TUDPSocket.cxx:450
 TUDPSocket.cxx:451
 TUDPSocket.cxx:452
 TUDPSocket.cxx:453
 TUDPSocket.cxx:454
 TUDPSocket.cxx:455
 TUDPSocket.cxx:456
 TUDPSocket.cxx:457
 TUDPSocket.cxx:458
 TUDPSocket.cxx:459
 TUDPSocket.cxx:460
 TUDPSocket.cxx:461
 TUDPSocket.cxx:462
 TUDPSocket.cxx:463
 TUDPSocket.cxx:464
 TUDPSocket.cxx:465
 TUDPSocket.cxx:466
 TUDPSocket.cxx:467
 TUDPSocket.cxx:468
 TUDPSocket.cxx:469
 TUDPSocket.cxx:470
 TUDPSocket.cxx:471
 TUDPSocket.cxx:472
 TUDPSocket.cxx:473
 TUDPSocket.cxx:474
 TUDPSocket.cxx:475
 TUDPSocket.cxx:476
 TUDPSocket.cxx:477
 TUDPSocket.cxx:478
 TUDPSocket.cxx:479
 TUDPSocket.cxx:480
 TUDPSocket.cxx:481
 TUDPSocket.cxx:482
 TUDPSocket.cxx:483
 TUDPSocket.cxx:484
 TUDPSocket.cxx:485
 TUDPSocket.cxx:486
 TUDPSocket.cxx:487
 TUDPSocket.cxx:488
 TUDPSocket.cxx:489
 TUDPSocket.cxx:490
 TUDPSocket.cxx:491
 TUDPSocket.cxx:492
 TUDPSocket.cxx:493
 TUDPSocket.cxx:494
 TUDPSocket.cxx:495
 TUDPSocket.cxx:496
 TUDPSocket.cxx:497
 TUDPSocket.cxx:498
 TUDPSocket.cxx:499
 TUDPSocket.cxx:500
 TUDPSocket.cxx:501
 TUDPSocket.cxx:502
 TUDPSocket.cxx:503
 TUDPSocket.cxx:504
 TUDPSocket.cxx:505
 TUDPSocket.cxx:506
 TUDPSocket.cxx:507
 TUDPSocket.cxx:508
 TUDPSocket.cxx:509
 TUDPSocket.cxx:510
 TUDPSocket.cxx:511
 TUDPSocket.cxx:512
 TUDPSocket.cxx:513
 TUDPSocket.cxx:514
 TUDPSocket.cxx:515
 TUDPSocket.cxx:516
 TUDPSocket.cxx:517
 TUDPSocket.cxx:518
 TUDPSocket.cxx:519
 TUDPSocket.cxx:520
 TUDPSocket.cxx:521
 TUDPSocket.cxx:522
 TUDPSocket.cxx:523
 TUDPSocket.cxx:524
 TUDPSocket.cxx:525
 TUDPSocket.cxx:526
 TUDPSocket.cxx:527
 TUDPSocket.cxx:528
 TUDPSocket.cxx:529
 TUDPSocket.cxx:530
 TUDPSocket.cxx:531
 TUDPSocket.cxx:532
 TUDPSocket.cxx:533
 TUDPSocket.cxx:534
 TUDPSocket.cxx:535
 TUDPSocket.cxx:536
 TUDPSocket.cxx:537
 TUDPSocket.cxx:538
 TUDPSocket.cxx:539
 TUDPSocket.cxx:540
 TUDPSocket.cxx:541
 TUDPSocket.cxx:542
 TUDPSocket.cxx:543
 TUDPSocket.cxx:544
 TUDPSocket.cxx:545
 TUDPSocket.cxx:546
 TUDPSocket.cxx:547
 TUDPSocket.cxx:548
 TUDPSocket.cxx:549
 TUDPSocket.cxx:550
 TUDPSocket.cxx:551
 TUDPSocket.cxx:552
 TUDPSocket.cxx:553
 TUDPSocket.cxx:554
 TUDPSocket.cxx:555
 TUDPSocket.cxx:556
 TUDPSocket.cxx:557
 TUDPSocket.cxx:558
 TUDPSocket.cxx:559
 TUDPSocket.cxx:560
 TUDPSocket.cxx:561
 TUDPSocket.cxx:562
 TUDPSocket.cxx:563
 TUDPSocket.cxx:564
 TUDPSocket.cxx:565
 TUDPSocket.cxx:566
 TUDPSocket.cxx:567
 TUDPSocket.cxx:568
 TUDPSocket.cxx:569
 TUDPSocket.cxx:570
 TUDPSocket.cxx:571
 TUDPSocket.cxx:572
 TUDPSocket.cxx:573
 TUDPSocket.cxx:574
 TUDPSocket.cxx:575
 TUDPSocket.cxx:576
 TUDPSocket.cxx:577
 TUDPSocket.cxx:578
 TUDPSocket.cxx:579
 TUDPSocket.cxx:580
 TUDPSocket.cxx:581
 TUDPSocket.cxx:582
 TUDPSocket.cxx:583
 TUDPSocket.cxx:584
 TUDPSocket.cxx:585
 TUDPSocket.cxx:586
 TUDPSocket.cxx:587
 TUDPSocket.cxx:588
 TUDPSocket.cxx:589
 TUDPSocket.cxx:590
 TUDPSocket.cxx:591
 TUDPSocket.cxx:592
 TUDPSocket.cxx:593
 TUDPSocket.cxx:594
 TUDPSocket.cxx:595
 TUDPSocket.cxx:596
 TUDPSocket.cxx:597
 TUDPSocket.cxx:598
 TUDPSocket.cxx:599
 TUDPSocket.cxx:600
 TUDPSocket.cxx:601
 TUDPSocket.cxx:602
 TUDPSocket.cxx:603
 TUDPSocket.cxx:604
 TUDPSocket.cxx:605
 TUDPSocket.cxx:606
 TUDPSocket.cxx:607
 TUDPSocket.cxx:608
 TUDPSocket.cxx:609
 TUDPSocket.cxx:610
 TUDPSocket.cxx:611
 TUDPSocket.cxx:612
 TUDPSocket.cxx:613
 TUDPSocket.cxx:614
 TUDPSocket.cxx:615
 TUDPSocket.cxx:616
 TUDPSocket.cxx:617
 TUDPSocket.cxx:618
 TUDPSocket.cxx:619
 TUDPSocket.cxx:620
 TUDPSocket.cxx:621
 TUDPSocket.cxx:622
 TUDPSocket.cxx:623
 TUDPSocket.cxx:624
 TUDPSocket.cxx:625
 TUDPSocket.cxx:626
 TUDPSocket.cxx:627
 TUDPSocket.cxx:628
 TUDPSocket.cxx:629
 TUDPSocket.cxx:630
 TUDPSocket.cxx:631
 TUDPSocket.cxx:632
 TUDPSocket.cxx:633
 TUDPSocket.cxx:634
 TUDPSocket.cxx:635
 TUDPSocket.cxx:636
 TUDPSocket.cxx:637
 TUDPSocket.cxx:638
 TUDPSocket.cxx:639
 TUDPSocket.cxx:640
 TUDPSocket.cxx:641
 TUDPSocket.cxx:642
 TUDPSocket.cxx:643
 TUDPSocket.cxx:644
 TUDPSocket.cxx:645
 TUDPSocket.cxx:646
 TUDPSocket.cxx:647
 TUDPSocket.cxx:648
 TUDPSocket.cxx:649
 TUDPSocket.cxx:650
 TUDPSocket.cxx:651
 TUDPSocket.cxx:652
 TUDPSocket.cxx:653
 TUDPSocket.cxx:654
 TUDPSocket.cxx:655
 TUDPSocket.cxx:656
 TUDPSocket.cxx:657
 TUDPSocket.cxx:658
 TUDPSocket.cxx:659
 TUDPSocket.cxx:660
 TUDPSocket.cxx:661
 TUDPSocket.cxx:662
 TUDPSocket.cxx:663
 TUDPSocket.cxx:664
 TUDPSocket.cxx:665
 TUDPSocket.cxx:666
 TUDPSocket.cxx:667
 TUDPSocket.cxx:668
 TUDPSocket.cxx:669
 TUDPSocket.cxx:670
 TUDPSocket.cxx:671
 TUDPSocket.cxx:672
 TUDPSocket.cxx:673
 TUDPSocket.cxx:674
 TUDPSocket.cxx:675
 TUDPSocket.cxx:676
 TUDPSocket.cxx:677
 TUDPSocket.cxx:678
 TUDPSocket.cxx:679
 TUDPSocket.cxx:680
 TUDPSocket.cxx:681
 TUDPSocket.cxx:682
 TUDPSocket.cxx:683
 TUDPSocket.cxx:684
 TUDPSocket.cxx:685
 TUDPSocket.cxx:686
 TUDPSocket.cxx:687
 TUDPSocket.cxx:688
 TUDPSocket.cxx:689
 TUDPSocket.cxx:690
 TUDPSocket.cxx:691
 TUDPSocket.cxx:692
 TUDPSocket.cxx:693
 TUDPSocket.cxx:694
 TUDPSocket.cxx:695
 TUDPSocket.cxx:696
 TUDPSocket.cxx:697
 TUDPSocket.cxx:698
 TUDPSocket.cxx:699
 TUDPSocket.cxx:700
 TUDPSocket.cxx:701
 TUDPSocket.cxx:702
 TUDPSocket.cxx:703
 TUDPSocket.cxx:704
 TUDPSocket.cxx:705
 TUDPSocket.cxx:706
 TUDPSocket.cxx:707
 TUDPSocket.cxx:708
 TUDPSocket.cxx:709
 TUDPSocket.cxx:710
 TUDPSocket.cxx:711
 TUDPSocket.cxx:712
 TUDPSocket.cxx:713
 TUDPSocket.cxx:714
 TUDPSocket.cxx:715
 TUDPSocket.cxx:716
 TUDPSocket.cxx:717
 TUDPSocket.cxx:718
 TUDPSocket.cxx:719
 TUDPSocket.cxx:720
 TUDPSocket.cxx:721
 TUDPSocket.cxx:722
 TUDPSocket.cxx:723
 TUDPSocket.cxx:724
 TUDPSocket.cxx:725
 TUDPSocket.cxx:726
 TUDPSocket.cxx:727
 TUDPSocket.cxx:728
 TUDPSocket.cxx:729
 TUDPSocket.cxx:730
 TUDPSocket.cxx:731
 TUDPSocket.cxx:732
 TUDPSocket.cxx:733
 TUDPSocket.cxx:734
 TUDPSocket.cxx:735
 TUDPSocket.cxx:736
 TUDPSocket.cxx:737
 TUDPSocket.cxx:738
 TUDPSocket.cxx:739
 TUDPSocket.cxx:740
 TUDPSocket.cxx:741
 TUDPSocket.cxx:742
 TUDPSocket.cxx:743
 TUDPSocket.cxx:744
 TUDPSocket.cxx:745
 TUDPSocket.cxx:746
 TUDPSocket.cxx:747
 TUDPSocket.cxx:748
 TUDPSocket.cxx:749
 TUDPSocket.cxx:750
 TUDPSocket.cxx:751
 TUDPSocket.cxx:752
 TUDPSocket.cxx:753
 TUDPSocket.cxx:754
 TUDPSocket.cxx:755
 TUDPSocket.cxx:756
 TUDPSocket.cxx:757
 TUDPSocket.cxx:758
 TUDPSocket.cxx:759
 TUDPSocket.cxx:760
 TUDPSocket.cxx:761
 TUDPSocket.cxx:762
 TUDPSocket.cxx:763
 TUDPSocket.cxx:764
 TUDPSocket.cxx:765
 TUDPSocket.cxx:766
 TUDPSocket.cxx:767
 TUDPSocket.cxx:768
 TUDPSocket.cxx:769
 TUDPSocket.cxx:770
 TUDPSocket.cxx:771
 TUDPSocket.cxx:772
 TUDPSocket.cxx:773
 TUDPSocket.cxx:774
 TUDPSocket.cxx:775
 TUDPSocket.cxx:776
 TUDPSocket.cxx:777
 TUDPSocket.cxx:778
 TUDPSocket.cxx:779
 TUDPSocket.cxx:780
 TUDPSocket.cxx:781
 TUDPSocket.cxx:782
 TUDPSocket.cxx:783
 TUDPSocket.cxx:784
 TUDPSocket.cxx:785
 TUDPSocket.cxx:786
 TUDPSocket.cxx:787
 TUDPSocket.cxx:788
 TUDPSocket.cxx:789
 TUDPSocket.cxx:790
 TUDPSocket.cxx:791
 TUDPSocket.cxx:792
 TUDPSocket.cxx:793
 TUDPSocket.cxx:794
 TUDPSocket.cxx:795
 TUDPSocket.cxx:796
 TUDPSocket.cxx:797
 TUDPSocket.cxx:798
 TUDPSocket.cxx:799
 TUDPSocket.cxx:800
 TUDPSocket.cxx:801
 TUDPSocket.cxx:802
 TUDPSocket.cxx:803
 TUDPSocket.cxx:804
 TUDPSocket.cxx:805
 TUDPSocket.cxx:806
 TUDPSocket.cxx:807
 TUDPSocket.cxx:808
 TUDPSocket.cxx:809
 TUDPSocket.cxx:810
 TUDPSocket.cxx:811
 TUDPSocket.cxx:812
 TUDPSocket.cxx:813
 TUDPSocket.cxx:814
 TUDPSocket.cxx:815
 TUDPSocket.cxx:816
 TUDPSocket.cxx:817
 TUDPSocket.cxx:818
 TUDPSocket.cxx:819
 TUDPSocket.cxx:820
 TUDPSocket.cxx:821
 TUDPSocket.cxx:822
 TUDPSocket.cxx:823
 TUDPSocket.cxx:824
 TUDPSocket.cxx:825
 TUDPSocket.cxx:826
 TUDPSocket.cxx:827
 TUDPSocket.cxx:828
 TUDPSocket.cxx:829
 TUDPSocket.cxx:830
 TUDPSocket.cxx:831
 TUDPSocket.cxx:832
 TUDPSocket.cxx:833
 TUDPSocket.cxx:834
 TUDPSocket.cxx:835
 TUDPSocket.cxx:836
 TUDPSocket.cxx:837
 TUDPSocket.cxx:838
 TUDPSocket.cxx:839
 TUDPSocket.cxx:840
 TUDPSocket.cxx:841
 TUDPSocket.cxx:842
 TUDPSocket.cxx:843
 TUDPSocket.cxx:844
 TUDPSocket.cxx:845
 TUDPSocket.cxx:846
 TUDPSocket.cxx:847
 TUDPSocket.cxx:848
 TUDPSocket.cxx:849
 TUDPSocket.cxx:850
 TUDPSocket.cxx:851
 TUDPSocket.cxx:852
 TUDPSocket.cxx:853
 TUDPSocket.cxx:854
 TUDPSocket.cxx:855
 TUDPSocket.cxx:856
 TUDPSocket.cxx:857
 TUDPSocket.cxx:858
 TUDPSocket.cxx:859
 TUDPSocket.cxx:860
 TUDPSocket.cxx:861
 TUDPSocket.cxx:862
 TUDPSocket.cxx:863
 TUDPSocket.cxx:864
 TUDPSocket.cxx:865
 TUDPSocket.cxx:866
 TUDPSocket.cxx:867
 TUDPSocket.cxx:868
 TUDPSocket.cxx:869
 TUDPSocket.cxx:870
 TUDPSocket.cxx:871
 TUDPSocket.cxx:872
 TUDPSocket.cxx:873
 TUDPSocket.cxx:874
 TUDPSocket.cxx:875
 TUDPSocket.cxx:876
 TUDPSocket.cxx:877
 TUDPSocket.cxx:878
 TUDPSocket.cxx:879
 TUDPSocket.cxx:880
 TUDPSocket.cxx:881
 TUDPSocket.cxx:882
 TUDPSocket.cxx:883
 TUDPSocket.cxx:884
 TUDPSocket.cxx:885
 TUDPSocket.cxx:886
 TUDPSocket.cxx:887
 TUDPSocket.cxx:888
 TUDPSocket.cxx:889
 TUDPSocket.cxx:890
 TUDPSocket.cxx:891
 TUDPSocket.cxx:892
 TUDPSocket.cxx:893
 TUDPSocket.cxx:894
 TUDPSocket.cxx:895
 TUDPSocket.cxx:896
 TUDPSocket.cxx:897
 TUDPSocket.cxx:898
 TUDPSocket.cxx:899
 TUDPSocket.cxx:900
 TUDPSocket.cxx:901
 TUDPSocket.cxx:902
 TUDPSocket.cxx:903
 TUDPSocket.cxx:904
 TUDPSocket.cxx:905
 TUDPSocket.cxx:906
 TUDPSocket.cxx:907
 TUDPSocket.cxx:908
 TUDPSocket.cxx:909
 TUDPSocket.cxx:910
 TUDPSocket.cxx:911
 TUDPSocket.cxx:912
 TUDPSocket.cxx:913
 TUDPSocket.cxx:914
 TUDPSocket.cxx:915
 TUDPSocket.cxx:916
 TUDPSocket.cxx:917
 TUDPSocket.cxx:918
 TUDPSocket.cxx:919
 TUDPSocket.cxx:920
 TUDPSocket.cxx:921
 TUDPSocket.cxx:922
 TUDPSocket.cxx:923
 TUDPSocket.cxx:924
 TUDPSocket.cxx:925
 TUDPSocket.cxx:926
 TUDPSocket.cxx:927
 TUDPSocket.cxx:928
 TUDPSocket.cxx:929
 TUDPSocket.cxx:930
 TUDPSocket.cxx:931
 TUDPSocket.cxx:932
 TUDPSocket.cxx:933
 TUDPSocket.cxx:934
 TUDPSocket.cxx:935
 TUDPSocket.cxx:936
 TUDPSocket.cxx:937
 TUDPSocket.cxx:938
 TUDPSocket.cxx:939
 TUDPSocket.cxx:940
 TUDPSocket.cxx:941
 TUDPSocket.cxx:942
 TUDPSocket.cxx:943
 TUDPSocket.cxx:944
 TUDPSocket.cxx:945
 TUDPSocket.cxx:946
 TUDPSocket.cxx:947
 TUDPSocket.cxx:948
 TUDPSocket.cxx:949
 TUDPSocket.cxx:950
 TUDPSocket.cxx:951
 TUDPSocket.cxx:952
 TUDPSocket.cxx:953
 TUDPSocket.cxx:954
 TUDPSocket.cxx:955
 TUDPSocket.cxx:956
 TUDPSocket.cxx:957
 TUDPSocket.cxx:958
 TUDPSocket.cxx:959
 TUDPSocket.cxx:960
 TUDPSocket.cxx:961
 TUDPSocket.cxx:962
 TUDPSocket.cxx:963
 TUDPSocket.cxx:964
 TUDPSocket.cxx:965
 TUDPSocket.cxx:966
 TUDPSocket.cxx:967
 TUDPSocket.cxx:968
 TUDPSocket.cxx:969
 TUDPSocket.cxx:970
 TUDPSocket.cxx:971
 TUDPSocket.cxx:972
 TUDPSocket.cxx:973
 TUDPSocket.cxx:974
 TUDPSocket.cxx:975
 TUDPSocket.cxx:976
 TUDPSocket.cxx:977
 TUDPSocket.cxx:978
 TUDPSocket.cxx:979
 TUDPSocket.cxx:980
 TUDPSocket.cxx:981
 TUDPSocket.cxx:982
 TUDPSocket.cxx:983
 TUDPSocket.cxx:984
 TUDPSocket.cxx:985
 TUDPSocket.cxx:986
 TUDPSocket.cxx:987
 TUDPSocket.cxx:988
 TUDPSocket.cxx:989
 TUDPSocket.cxx:990
 TUDPSocket.cxx:991
 TUDPSocket.cxx:992
 TUDPSocket.cxx:993
 TUDPSocket.cxx:994
 TUDPSocket.cxx:995
 TUDPSocket.cxx:996
 TUDPSocket.cxx:997
 TUDPSocket.cxx:998
 TUDPSocket.cxx:999
 TUDPSocket.cxx:1000
 TUDPSocket.cxx:1001
 TUDPSocket.cxx:1002
 TUDPSocket.cxx:1003
 TUDPSocket.cxx:1004
 TUDPSocket.cxx:1005
 TUDPSocket.cxx:1006
 TUDPSocket.cxx:1007
 TUDPSocket.cxx:1008
 TUDPSocket.cxx:1009
 TUDPSocket.cxx:1010
 TUDPSocket.cxx:1011
 TUDPSocket.cxx:1012
 TUDPSocket.cxx:1013
 TUDPSocket.cxx:1014
 TUDPSocket.cxx:1015
 TUDPSocket.cxx:1016
 TUDPSocket.cxx:1017
 TUDPSocket.cxx:1018
 TUDPSocket.cxx:1019
 TUDPSocket.cxx:1020
 TUDPSocket.cxx:1021
 TUDPSocket.cxx:1022
 TUDPSocket.cxx:1023
 TUDPSocket.cxx:1024
 TUDPSocket.cxx:1025
 TUDPSocket.cxx:1026
 TUDPSocket.cxx:1027
 TUDPSocket.cxx:1028
 TUDPSocket.cxx:1029
 TUDPSocket.cxx:1030
 TUDPSocket.cxx:1031
 TUDPSocket.cxx:1032
 TUDPSocket.cxx:1033
 TUDPSocket.cxx:1034
 TUDPSocket.cxx:1035
 TUDPSocket.cxx:1036
 TUDPSocket.cxx:1037
 TUDPSocket.cxx:1038
 TUDPSocket.cxx:1039
 TUDPSocket.cxx:1040
 TUDPSocket.cxx:1041
 TUDPSocket.cxx:1042
 TUDPSocket.cxx:1043
 TUDPSocket.cxx:1044
 TUDPSocket.cxx:1045
 TUDPSocket.cxx:1046
 TUDPSocket.cxx:1047
 TUDPSocket.cxx:1048
 TUDPSocket.cxx:1049
 TUDPSocket.cxx:1050
 TUDPSocket.cxx:1051
 TUDPSocket.cxx:1052
 TUDPSocket.cxx:1053
 TUDPSocket.cxx:1054
 TUDPSocket.cxx:1055
 TUDPSocket.cxx:1056
 TUDPSocket.cxx:1057
 TUDPSocket.cxx:1058
 TUDPSocket.cxx:1059
 TUDPSocket.cxx:1060
 TUDPSocket.cxx:1061
 TUDPSocket.cxx:1062
 TUDPSocket.cxx:1063
 TUDPSocket.cxx:1064
 TUDPSocket.cxx:1065
 TUDPSocket.cxx:1066
 TUDPSocket.cxx:1067
 TUDPSocket.cxx:1068
 TUDPSocket.cxx:1069
 TUDPSocket.cxx:1070
 TUDPSocket.cxx:1071
 TUDPSocket.cxx:1072
 TUDPSocket.cxx:1073
 TUDPSocket.cxx:1074
 TUDPSocket.cxx:1075
 TUDPSocket.cxx:1076
 TUDPSocket.cxx:1077
 TUDPSocket.cxx:1078
 TUDPSocket.cxx:1079
 TUDPSocket.cxx:1080
 TUDPSocket.cxx:1081
 TUDPSocket.cxx:1082
 TUDPSocket.cxx:1083
 TUDPSocket.cxx:1084
 TUDPSocket.cxx:1085
 TUDPSocket.cxx:1086
 TUDPSocket.cxx:1087
 TUDPSocket.cxx:1088
 TUDPSocket.cxx:1089
 TUDPSocket.cxx:1090
 TUDPSocket.cxx:1091
 TUDPSocket.cxx:1092
 TUDPSocket.cxx:1093
 TUDPSocket.cxx:1094
 TUDPSocket.cxx:1095
 TUDPSocket.cxx:1096
 TUDPSocket.cxx:1097
 TUDPSocket.cxx:1098
 TUDPSocket.cxx:1099
 TUDPSocket.cxx:1100
 TUDPSocket.cxx:1101
 TUDPSocket.cxx:1102
 TUDPSocket.cxx:1103
 TUDPSocket.cxx:1104