Example #1
0
  /**
   * Creates the a listen socket on the bfd listen port.
   *
   * @param listenAddr [in] - May be "ANY" (0.0.0.0 or ::)
   *
   * outSocket will be empty on failure.
   *
   *
   */
  void Beacon::makeListenSocket(const IpAddr &listenAddr, Socket &outSocket)
  {
    Socket listenSocket;

    outSocket.Close();
    // Any socket error will get logged, so we don't need to log them again.
    listenSocket.SetLogName(FormatShortStr("BFD %s listen socket", listenAddr.ToString()));
    listenSocket.OpenUDP(listenAddr.Type());
    if (listenSocket.empty())
      return;

    if (!listenSocket.SetTTLOrHops(bfd::TTLValue))
      return;

    if (!listenSocket.SetRecieveTTLOrHops(true))
      return;

    if (!listenSocket.SetReceiveDestinationAddress(true))
      return;

    if (listenAddr.Type() == Addr::IPv6)
    {
      if (!listenSocket.SetIPv6Only(true))
        return;
    }

    if (!listenSocket.Bind(SockAddr(listenAddr, bfd::ListenPort)))
      return;

    // Take ownership
    outSocket.Transfer(listenSocket);
    outSocket.SetLogName(listenSocket.LogName());

    gLog.Optional(Log::App, "Listening for BFD connections on %s", SockAddr(listenAddr, bfd::ListenPort).ToString());
  }
Example #2
0
const char* TimeSpec::SpanToLogText(TimeSpec::Unit unit, int decimals,  TextFlags flags)
{
  double val = ToDecimal() / UnitToSeconds(unit);

  if (0 == (flags & NoTruncation) && val == int64_t(val))
    decimals = 0;

  return FormatShortStr("%.*f %s", decimals, val,  UnitToString(unit, 0 == (flags & LongName)));
}
Example #3
0
const char* sockAddrBase::ToString(bool includePort /*true*/) const
{
  in_port_t port = includePort ? Port() : 0;

  if (IsIPv4())
  {
    if (port == 0)
      return Ip4ToString(getIPv4Storage()->sin_addr);
    else
      return Ip4ToString(getIPv4Storage()->sin_addr, port);
  }
  else if (IsIPv6())
  {
    const sockaddr_in6 *storage = getIPv6Storage();

    if (storage->sin6_scope_id == 0 && !port)
    {
      // Just IPv6 address
      char *buffer;
      size_t bufsize = GetSmallTLSBuffer(&buffer);
      if (!bufsize)
        return "<memerror>";
      if (!inet_ntop(AF_INET6, &storage->sin6_addr, buffer, bufsize))
        return "<Invalid Address>";
      return buffer;
    }
    else
    {
      // composite address
      char ifNameBuf[IF_NAMESIZE];
      char addrStrBuf[INET6_ADDRSTRLEN];
      const char *ifName = NULL;
      const char *addrStr = NULL;

      if (storage->sin6_scope_id)
      {
        ifName = if_indextoname(storage->sin6_scope_id, ifNameBuf);
        if (!ifName)
          ifName = "???";
      }

      addrStr = inet_ntop(AF_INET6, &storage->sin6_addr, addrStrBuf, sizeof(addrStrBuf));
      if (!addrStr)
        addrStr = "<Invalid IPv6>";

      if (port)
      {
        if (ifName)
          return FormatShortStr("[%s%%%s]:%d", addrStr, ifName, (int)port);
        else
          return FormatShortStr("[%s]:%d", addrStr, (int)port);
      }
      else
      {
        if (ifName)
          return FormatShortStr("%s%%%s", addrStr, ifName);
        else
        {
          LogVerify(false); // should never happen
          return FormatShortStr("%s", addrStr);
        }
      }
    }
  }
  else
    return "<Invalid Address>";
}