#if defined(HAVE_CONFIG_H)

#include "config.h"

#endif

#include <iostream>

#if defined(HAVE_SYS_SOCKIO_H)

#include <sys/sockio.h>

#endif

#include "rutil/Socket.hxx"

#include "rutil/DnsUtil.hxx"

#include "rutil/Logger.hxx"

#include "rutil/ParseBuffer.hxx"

#include "resip/stack/ConnectionTerminated.hxx"

#include "resip/stack/KeepAlivePong.hxx"

#include "resip/stack/Transport.hxx"

#include "resip/stack/SipMessage.hxx"

#include "resip/stack/TransportFailure.hxx"

#include "resip/stack/Helper.hxx"

#include "resip/stack/SendData.hxx"

#include "rutil/WinLeakCheck.hxx"

using namespace resip;

using namespace std;

#define RESIPROCATE_SUBSYSTEM Subsystem::TRANSPORT

void

Transport::setSipMessageLoggingHandler(std::shared_ptr<SipMessageLoggingHandler> handler)

{

   mSipMessageLoggingHandlers.clear();

   if (handler)

   {

      mSipMessageLoggingHandlers.push_back(handler);

   }

}

void

Transport::addSipMessageLoggingHandler(std::shared_ptr<SipMessageLoggingHandler> handler)

{

   if (handler)

   {

      mSipMessageLoggingHandlers.push_back(handler);

   }

}

void

Transport::setSipMessageLoggingHandlers(const SipMessageLoggingHandlerList& handlers)

{

   mSipMessageLoggingHandlers = handlers;

}

void

Transport::unsetSipMessageLoggingHandler() noexcept

{

   mSipMessageLoggingHandlers.clear();

}

Transport::SipMessageLoggingHandlerList

Transport::getSipMessageLoggingHandlers() const noexcept

{

   return mSipMessageLoggingHandlers;

}

Transport::Exception::Exception(const Data& msg, const Data& file, const int line) :

   BaseException(msg,file,line)

{

}

Transport::Transport(Fifo<TransactionMessage>& rxFifo,

                     const GenericIPAddress& address,

                     const Data& tlsDomain,

                     AfterSocketCreationFuncPtr socketFunc,

                     Compression &compression) :

   mTuple(address),

   mCongestionManager(nullptr),

   mStateMachineFifo(rxFifo, 8),

   mShuttingDown(false),

   mTlsDomain(tlsDomain),

   mSocketFunc(socketFunc),

   mCompression(compression),

   mTransportFlags(0)

{

#ifdef USE_NETNS

   // Needs to be implemented for NETNS

   resip_assert(0);

#endif

   mInterface = Tuple::inet_ntop(mTuple);

}

Transport::Transport(Fifo<TransactionMessage>& rxFifo,

                     int portNum,

                     IpVersion version,

                     const Data& intfc,

                     const Data& tlsDomain,

                     AfterSocketCreationFuncPtr socketFunc,

                     Compression &compression,

                     unsigned transportFlags,

                     const Data& netNs) :

   mInterface(intfc),

   mTuple(intfc, portNum, version, UNKNOWN_TRANSPORT, Data::Empty, netNs),

   mCongestionManager(nullptr),

   mStateMachineFifo(rxFifo,8),

   mShuttingDown(false),

   mTlsDomain(tlsDomain),

   mSocketFunc(socketFunc),

   mCompression(compression),

   mTransportFlags(transportFlags)

{

}

Transport::~Transport()

{

}

void

Transport::onReload()

{

}

void

Transport::drainDscpRefresh()

{

   // Read before the traversal clears the mark state, so a reset still reports

   // the 0 it wrote.

   const int handled = effectiveDscp();

   // The refresh first, so the report reads the class this pass wrote.

   if (mDscpRefreshPending.load())

   {

      applyDscpToOwnSockets();

   }

   if (mDscpReportPending.exchange(false))

   {

      reportDscp(handled);

   }

}

void

Transport::applyDscpToOwnSockets()

{

   // Clear the request before reading the value it was raised for. A setDscp()

   // that lands after this either carries the value this pass is about to

   // write, or raises the request again for the next cycle.

   mDscpRefreshPending.store(false);

   const int wanted = mDscp.load();

   // Before the traversal: with nothing to write and nothing to undo, the

   // user's AfterSocketCreationFunc must not be re-invoked at all.

   if (effectiveDscp(wanted) < 0)

   {

      return;

   }

   invokeAfterSocketCreationFunc();

   // What this pass wrote, not what mDscp says now: a value that changed while

   // the traversal ran has raised its own request.

   mWasMarkRequested.store(wanted >= 0);

}

void

Transport::reportDscp(int wanted) const

{

   if (wanted < 0)

   {

      return;

   }

   const Socket listener = getListenerSocket();

   if (listener == INVALID_SOCKET)

   {

      return;

   }

   const int carried = getSocketTos(listener, ipVersion());

   if (carried < 0)

   {

      ErrLog(<< *this << " cannot read the signaling DSCP class back from its listener");

      return;

   }

   // As a class rather than a byte, so the kernel's own ECN bits do not read

   // as a mismatch.

   if ((carried >> 2) != wanted)

   {

      ErrLog(<< *this << " asked for signaling DSCP " << wanted

             << " but its listener carries " << (carried >> 2)

             << " (ToS byte " << carried << ")");

      return;

   }

   InfoLog(<< *this << " signaling DSCP " << (carried >> 2)

           << " (ToS byte " << carried << ")");

}

void

Transport::error(int e)

{

   if (e != EAGAIN)

   {

      InfoLog(<< errorToString(e));

   }

}

Data

Transport::errorToString(int e)

{

   Data errorString;

   DataStream ds(errorString);

   switch (e)

   {

      case 0:

         ds << "None";

         break;

      case EAGAIN:

         ds << "No data ready to read: " << strError(e);

         break;

      case EINTR:

         ds << "The call was interrupted by a signal before any data was read: " << strError(e);

         break;

      case EIO:

         ds << "I/O error: " << strError(e);

         break;

      case EBADF:

         ds << "fd is not a valid file descriptor or is not open for reading: " << strError(e);

         break;

      case EINVAL:

         ds << "fd is attached to an object which is unsuitable for reading: " << strError(e);

         break;

      case EFAULT:

         ds << "buf is outside your accessible address space: " << strError(e);

         break;

#if defined(WIN32)

      case WSAENETDOWN:

         ds << "The network subsystem has failed.";

         break;

      case WSAEFAULT:

         ds << "The buf or from parameters are not part of the user address space, "

               "or the fromlen parameter is too small to accommodate the peer address.";

         break;

      case WSAEINTR:

         ds << "The (blocking) call was canceled through WSACancelBlockingCall.";

         break;

      case WSAEINPROGRESS:

         ds << "A blocking Windows Sockets 1.1 call is in progress, or the "

               "service provider is still processing a callback function.";

         break;

      case WSAEINVAL:

         ds << "The socket has not been bound with bind, or an unknown flag was specified, "

               "or MSG_OOB was specified for a socket with SO_OOBINLINE enabled, "

               "or (for byte stream-style sockets only) len was zero or negative.";

         break;

      case WSAEISCONN :

         ds << "The socket is connected. This function is not permitted with a connected socket, "

               "whether the socket is connection-oriented or connectionless.";

         break;

      case WSAENETRESET:

         ds << "The connection has been broken due to the keep-alive activity "

               "detecting a failure while the operation was in progress.";

         break;

      case WSAENOTSOCK:

         ds << "The descriptor is not a socket.";

         break;

      case WSAEOPNOTSUPP:

         ds << " MSG_OOB was specified, but the socket is not stream-style such as type "

               "SOCK_STREAM, OOB data is not supported in the communication domain associated with this socket, "

               "or the socket is unidirectional and supports only send operations.";

         break;

      case WSAESHUTDOWN:

         ds << "The socket has been shut down; it is not possible to recvfrom on a socket after "

               "shutdown has been invoked with how set to SD_RECEIVE or SD_BOTH.";

         break;

      case WSAEMSGSIZE:

         ds << "The message was too large to fit into the specified buffer and was truncated.";

         break;

      case WSAETIMEDOUT:

         ds << "The connection has been dropped, because of a network failure or because the "

               "system on the other end went down without notice.";

         break;

      case WSAECONNRESET :

         ds << "Connection reset.";

         break;

      case WSAEWOULDBLOCK:

         ds << "Would block.";

         break;

      case WSAEHOSTUNREACH:

         ds << "A socket operation was attempted to an unreachable host.";

         break;

      case WSANOTINITIALISED:

         ds << "Either the application has not called WSAStartup or WSAStartup failed. "

               "The application may be accessing a socket that the current active task does not own (that is, trying to share a socket between tasks),"

               "or WSACleanup has been called too many times.";

         break;

      case WSAEACCES:

         ds << "An attempt was made to access a socket in a way forbidden by its access permissions.";

         break;

      case WSAENOBUFS:

         ds << "An operation on a socket could not be performed because the system lacked sufficient "

               "buffer space or because a queue was full.";

         break;

      case WSAENOTCONN:

         ds << "A request to send or receive data was disallowed because the socket is not connected "

               "and (when sending on a datagram socket using sendto) no address was supplied.";

         break;

      case WSAECONNABORTED:

         ds << "An established connection was aborted by the software in your host computer, possibly "

               "due to a data transmission time-out or protocol error.";

         break;

      case WSAEADDRNOTAVAIL:

         ds << "The requested address is not valid in its context. This normally results from an attempt to "

               "bind to an address that is not valid for the local computer.";

         break;

      case WSAEAFNOSUPPORT:

         ds << "An address incompatible with the requested protocol was used.";

         break;

      case WSAEDESTADDRREQ:

         ds << "A required address was omitted from an operation on a socket.";

         break;

      case WSAENETUNREACH:

         ds << "A socket operation was attempted to an unreachable network.";

         break;

#endif

      default:

         ds << "Some other error (" << e << "): " << strError(e);

         break;

   }

   ds.flush();

   return errorString;

}

void

Transport::flowTerminated(const Tuple& flow, TransportFailure::FailureReason failureReason, int failureSubCode, const Data& failureString, const std::list<Data> additionalFailureStrings)

{

   mStateMachineFifo.add(new ConnectionTerminated(flow, failureReason, failureSubCode, failureString, additionalFailureStrings));

}

void

Transport::keepAlivePong(const Tuple& flow)

{

   mStateMachineFifo.add(new KeepAlivePong(flow));

}

void

Transport::fail(const Data& tid, TransportFailure::FailureReason reason, int subCode)

{

   if (!tid.empty())

   {

      mStateMachineFifo.add(new TransportFailure(tid, reason, subCode));

   }

}

void 

Transport::setTcpConnectState(const Data& tid, TcpConnectState::State state)

{

    if (!tid.empty())

    {

        mStateMachineFifo.add(new TcpConnectState(tid, state));

    }

}

std::unique_ptr<SendData>

Transport::makeSendData( const Tuple& dest, const Data& d, const Data& tid, const Data &sigcompId)

{

   resip_assert(dest.getPort() != -1);

   std::unique_ptr<SendData> data(new SendData(dest, d, tid, sigcompId));

   return data;

}

void

Transport::makeFailedResponse(const SipMessage& msg,

                              int responseCode,

                              const char * warning)

{

  if (msg.isResponse()) return;

  const Tuple& dest = msg.getSource();

  std::unique_ptr<SipMessage> errMsg(Helper::makeResponse(msg,

                                                        responseCode,

                                                        warning ? warning : "Original request had no Vias"));

  // make send data here w/ blank tid and blast it out.

  // encode message

  Data encoded;

  encoded.clear();

  DataStream encodeStream(encoded);

  errMsg->encode(encodeStream);

  encodeStream.flush();

  resip_assert(!encoded.empty());

  InfoLog(<<"Sending response directly to " << dest << " : " << errMsg->brief() );

  // Calculate compartment ID for outbound message

  Data remoteSigcompId;

   setRemoteSigcompId(*errMsg,remoteSigcompId);

  send(makeSendData(dest, encoded, Data::Empty, remoteSigcompId));

}

std::unique_ptr<SendData>

Transport::make503(SipMessage& msg, uint16_t retryAfter)

{

  std::unique_ptr<SendData> result;

  if (msg.isResponse()) return result;

   try

   {

      if(msg.method()==ACK)

      {

         return result;

      }

   }

   catch(BaseException&)

   {

      // .bwc. Parse failed on the start-line. Stop.

      return result;

   }

  const Tuple& dest = msg.getSource();

   // Calculate compartment ID for outbound message

   Data remoteSigcompId;

   setRemoteSigcompId(msg,remoteSigcompId);

   // .bwc. msg is completely unverified. Handle with caution.

   result=makeSendData(dest, Data::Empty, Data::Empty, remoteSigcompId);

   static const Data retryAfterHeader("Retry-After: ");

   Data value(retryAfter);

   Helper::makeRawResponse(result->data, msg, 503, retryAfterHeader+value+"\r\n");

  return result;

}

std::unique_ptr<SendData>

Transport::make100(SipMessage& msg)

{

  std::unique_ptr<SendData> result;

  if (msg.isResponse()) return result;

   try

   {

      if(msg.method()==ACK)

      {

         return result;

      }

   }

   catch(BaseException&)

   {

      // .bwc. Parse failed on the start-line. Stop.

      return result;

   }

  const Tuple& dest = msg.getSource();

   // Calculate compartment ID for outbound message

   Data remoteSigcompId;

   setRemoteSigcompId(msg,remoteSigcompId);

   // .bwc. msg is completely unverified. Handle with caution.

   result=makeSendData(dest, Data::Empty, Data::Empty, remoteSigcompId);

   Helper::makeRawResponse(result->data, msg, 100);

   return result;

}

void

Transport::setRemoteSigcompId(SipMessage& msg, Data& remoteSigcompId)

{

   if (mCompression.isEnabled())

   {

      try

      {

         const Via &topVia(msg.const_header(h_Vias).front());

         if(topVia.exists(p_comp) && topVia.param(p_comp) == "sigcomp")

         {

            if (topVia.exists(p_sigcompId))

            {

               remoteSigcompId = topVia.param(p_sigcompId);

            }

            else

            {

               // XXX rohc-sigcomp-sip-03 says "sent-by",

               // but this should probably be "received" if present,

               // and "sent-by" otherwise.

               // XXX Also, the spec is ambiguous about whether

               // to include the port in this identifier.

               remoteSigcompId = topVia.sentHost();

            }

         }

      }

      catch(BaseException&)

      {

         // ?bwc? Couldn't grab sigcomp compartment id. We don't even know if

         // the initial request was using sigcomp or not. 

         // What should we do here?

      }

   }

}

void

Transport::stampReceived(SipMessage* message)

{

   // set the received= and rport= parameters in the message if necessary !jf!

   if (message->isRequest() && message->exists(h_Vias) && !message->const_header(h_Vias).empty())

   {

      const Tuple& tuple = message->getSource();

      Data received = Tuple::inet_ntop(tuple);

      if(message->const_header(h_Vias).front().sentHost() != received)  // only add if received address is different from sent-by in Via

      {

         message->header(h_Vias).front().param(p_received) = received;

      }

      //message->header(h_Vias).front().param(p_received) = Tuple::inet_ntop(tuple);

      if (message->const_header(h_Vias).front().exists(p_rport))

      {

         message->header(h_Vias).front().param(p_rport).port() = tuple.getPort();

      }

   }

   DebugLog (<< "incoming from: " << message->getSource());

   StackLog (<< endl << endl << *message);

}

bool

Transport::basicCheck(const SipMessage& msg)

{

   resip::Data reason;

   if (msg.isExternal())

   {

      try

      {

         if (!Helper::validateMessage(msg,&reason))

         {

            InfoLog(<<"Message Failed basicCheck :" << msg.brief());

            if (msg.isRequest() && msg.method()!=ACK )

            {

               // this is VERY low-level b/c we don't have a transaction...

               // here we make a response to warn the offending party.

               makeFailedResponse(msg,400,reason.c_str());

            }

            return false;

         }

         else if (mShuttingDown && msg.isRequest() && msg.method() != ACK)

         {

            InfoLog (<< "Server has been shutdown, reject message with 503");

            // this is VERY low-level b/c we don't have a transaction...

            // here we make a response to warn the offending party.

            makeFailedResponse(msg, 503, "Server has been shutdown");

            return false;

         }

      }

      catch (BaseException& e)

      {

         InfoLog (<< "Cannot make failure response to badly constructed message: " << e);

         return false;

      }

   }

   return true;

}

bool

Transport::setDscp(int dscp)

{

   // Refused once per change, not once per accepted connection.

   if (dscp < -1 || dscp > 63)

   {

      ErrLog(<< *this << " refusing DSCP class " << dscp << ", outside -1..63");

      return false;

   }

   if (mDscp.exchange(dscp) != dscp)

   {

      mDscpRefreshPending.store(true);

   }

   // Raised on every call, not only on a change: a marking that failed is then

   // reported again on the next reload rather than reading as fixed.

   mDscpReportPending.store(true);

   return true;

}

int

Transport::effectiveDscp() const

{

   return effectiveDscp(mDscp.load());

}

int

Transport::effectiveDscp(int wanted) const

{

   if (wanted >= 0)

   {

      return wanted;

   }

   return mWasMarkRequested.load() ? 0 : -1;

}

void

Transport::applySocketOptions(Socket sock) const

{

   const int dscp = effectiveDscp();

   if (dscp >= 0)

   {

      // The return is dropped on purpose: the listener read-back reports the

      // state once, instead of once per socket a refresh touches.

      setSocketDscp(sock, dscp, ipVersion());

      mWasMarkRequested.store(true);

   }

   callSocketFunc(sock);

}

void

Transport::callSocketFunc(Socket sock) const

{

   if (mSocketFunc)

   {

      mSocketFunc(sock, transport(), __FILE__, __LINE__);

   }

}

void

Transport::pushRxMsgUp(SipMessage* message)

{

   for(auto& handler : getSipMessageLoggingHandlers())

   {

       handler->inboundMessage(message->getSource(), message->getReceivedTransportTuple(), *message);

   }

   mStateMachineFifo.add(message);

}

bool

Transport::operator==(const Transport& rhs) const

{

   return ( ( mTuple.isV4() == rhs.isV4()) &&

            ( port() == rhs.port()) &&

            ( memcmp(&boundInterface(),&rhs.boundInterface(),mTuple.length()) == 0) );

}

EncodeStream&

resip::operator<<(EncodeStream& strm, const resip::Transport& rhs)

{

   strm << "Transport: " << rhs.mTuple;

   if (rhs.hasSpecificContact() && !rhs.mInterface.empty()) strm << " on " << rhs.mInterface;

   if (!rhs.mTlsDomain.empty()) strm << " (tlsdomain=" << rhs.mTlsDomain << ")";

   return strm;

}

/* ====================================================================

 * The Vovida Software License, Version 1.0

 *

 * Copyright (c) 2026 SIP Spectrum, Inc. https://www.sipspectrum.com

 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in

 *    the documentation and/or other materials provided with the

 *    distribution.

 *

 * 3. The names "VOCAL", "Vovida Open Communication Application Library",

 *    and "Vovida Open Communication Application Library (VOCAL)" must

 *    not be used to endorse or promote products derived from this

 *    software without prior written permission. For written

 *    permission, please contact vocal@vovida.org.

 *

 * 4. Products derived from this software may not be called "VOCAL", nor

 *    may "VOCAL" appear in their name, without prior written

 *    permission of Vovida Networks, Inc.

 *

 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED

 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND

 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA

 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES

 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH

 * DAMAGE.

 *

 * ====================================================================

 *

 * This software consists of voluntary contributions made by Vovida

 * Networks, Inc. and many individuals on behalf of Vovida Networks,

 * Inc.  For more information on Vovida Networks, Inc., please see

 * <http://www.vovida.org/>.

 *

 * vi: set shiftwidth=3 expandtab:

 */