Restoring authorship annotation for Anton Samokhvalov <[email protected]>. Commit 2 of 2.

1 files changed, 77 insertions, 77 deletions

diff --git a/library/cpp/ipv6_address/ipv6_address.cpp b/library/cpp/ipv6_address/ipv6_address.cpp
index f34075e808c..be8fcbae13b 100644
--- a/library/cpp/ipv6_address/ipv6_address.cpp
+++ b/library/cpp/ipv6_address/ipv6_address.cpp
@@ -35,53 +35,53 @@ namespace {
     }
 }
 
-void TIpv6Address::InitFrom(const in6_addr& addr) { 
-    const ui64* const ui64Ptr = reinterpret_cast<const ui64*>(&addr); 
-    const ui64 raw[2] = {SwapBytes(*ui64Ptr), SwapBytes(*(ui64Ptr + 1))}; 
+void TIpv6Address::InitFrom(const in6_addr& addr) {
+    const ui64* const ui64Ptr = reinterpret_cast<const ui64*>(&addr);
+    const ui64 raw[2] = {SwapBytes(*ui64Ptr), SwapBytes(*(ui64Ptr + 1))};
     Ip = FromMemMSF(reinterpret_cast<const char*>(raw));
-    Type_ = Ipv6; 
+    Type_ = Ipv6;
 }
-void TIpv6Address::InitFrom(const in_addr& addr) { 
+void TIpv6Address::InitFrom(const in_addr& addr) {
     unsigned long swapped = SwapBytes(addr.s_addr);
     Ip = ui128{0, swapped};
     Type_ = Ipv4;
 }
 
-void TIpv6Address::InitFrom(const sockaddr_in6& Addr) { 
+void TIpv6Address::InitFrom(const sockaddr_in6& Addr) {
     InitFrom(Addr.sin6_addr);
     ScopeId_ = Addr.sin6_scope_id;
 }
-void TIpv6Address::InitFrom(const sockaddr_in& Addr) { 
+void TIpv6Address::InitFrom(const sockaddr_in& Addr) {
     InitFrom(Addr.sin_addr);
 }
 
-TIpv6Address::TIpv6Address(const NAddr::IRemoteAddr& addr) { 
-    if (addr.Addr()->sa_family == AF_INET) { // IPv4 
-        const sockaddr_in* Tmp = reinterpret_cast<const sockaddr_in*>(addr.Addr()); 
+TIpv6Address::TIpv6Address(const NAddr::IRemoteAddr& addr) {
+    if (addr.Addr()->sa_family == AF_INET) { // IPv4
+        const sockaddr_in* Tmp = reinterpret_cast<const sockaddr_in*>(addr.Addr());
         InitFrom(*Tmp);
     } else { // IPv6
-        const sockaddr_in6* Tmp = reinterpret_cast<const sockaddr_in6*>(addr.Addr()); 
+        const sockaddr_in6* Tmp = reinterpret_cast<const sockaddr_in6*>(addr.Addr());
         InitFrom(*Tmp);
     }
 }
-TIpv6Address::TIpv6Address(const sockaddr_in6& Addr) { 
+TIpv6Address::TIpv6Address(const sockaddr_in6& Addr) {
     InitFrom(Addr);
 }
-TIpv6Address::TIpv6Address(const sockaddr_in& Addr) { 
+TIpv6Address::TIpv6Address(const sockaddr_in& Addr) {
     InitFrom(Addr);
 }
-TIpv6Address::TIpv6Address(const in6_addr& addr, ui32 Scope) { 
+TIpv6Address::TIpv6Address(const in6_addr& addr, ui32 Scope) {
     InitFrom(addr);
     ScopeId_ = Scope;
 }
-TIpv6Address::TIpv6Address(const in_addr& addr) { 
+TIpv6Address::TIpv6Address(const in_addr& addr) {
     InitFrom(addr);
 }
 
 TIpv6Address TIpv6Address::FromString(TStringBuf str, bool& ok) noexcept {
     const TIpType ipType = FigureOutType(str);
 
-    if (ipType == Ipv6) { 
+    if (ipType == Ipv6) {
         ui32 scopeId = 0;
         if (size_t pos = str.find('%'); pos != TStringBuf::npos) {
             ::TryFromString(str.substr(pos + 1), scopeId);
@@ -110,69 +110,69 @@ TIpv6Address TIpv6Address::FromString(TStringBuf str, bool& ok) noexcept {
     }
 }
 
-TString TIpv6Address::ToString(bool* ok) const noexcept { 
+TString TIpv6Address::ToString(bool* ok) const noexcept {
     return ToString(true, ok);
 }
-TString TIpv6Address::ToString(bool PrintScopeId, bool* ok) const noexcept { 
+TString TIpv6Address::ToString(bool PrintScopeId, bool* ok) const noexcept {
     TString result;
-    bool isOk = true; 
+    bool isOk = true;
 
-    if (Type_ == TIpv6Address::Ipv4) { 
+    if (Type_ == TIpv6Address::Ipv4) {
         result.resize(INET_ADDRSTRLEN + 2);
         in_addr addr;
         ToInAddr(addr);
         isOk = inet_ntop(AF_INET, &addr, result.begin(), INET_ADDRSTRLEN);
         result.resize(result.find('\0'));
-    } else if (Type_ == TIpv6Address::Ipv6) { 
+    } else if (Type_ == TIpv6Address::Ipv6) {
         result.resize(INET6_ADDRSTRLEN + 2);
         in6_addr addr;
         ToIn6Addr(addr);
         isOk = inet_ntop(AF_INET6, &addr, result.begin(), INET6_ADDRSTRLEN);
         result.resize(result.find('\0'));
-        if (PrintScopeId) 
+        if (PrintScopeId)
             result += "%" + ::ToString(ScopeId_);
     } else {
         result = "null";
-        isOk = true; 
+        isOk = true;
     }
 
-    if (ok) { 
+    if (ok) {
         *ok = isOk;
     }
 
     return result;
 }
 
-void TIpv6Address::ToSockaddrAndSocklen(sockaddr_in& sockAddrIPv4, 
-                                        sockaddr_in6& sockAddrIPv6, // in 
-                                        const sockaddr*& sockAddrPtr, 
-                                        socklen_t& sockAddrSize, 
-                                        ui16 Port) const { // out 
+void TIpv6Address::ToSockaddrAndSocklen(sockaddr_in& sockAddrIPv4,
+                                        sockaddr_in6& sockAddrIPv6, // in
+                                        const sockaddr*& sockAddrPtr,
+                                        socklen_t& sockAddrSize,
+                                        ui16 Port) const { // out
 
-    if (Type_ == Ipv4) { 
+    if (Type_ == Ipv4) {
         memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4));
         sockAddrIPv4.sin_family = AF_INET;
-        sockAddrIPv4.sin_port = htons(Port); 
+        sockAddrIPv4.sin_port = htons(Port);
         ToInAddr(sockAddrIPv4.sin_addr);
 
         sockAddrSize = sizeof(sockAddrIPv4);
-        sockAddrPtr = reinterpret_cast<sockaddr*>(&sockAddrIPv4); 
+        sockAddrPtr = reinterpret_cast<sockaddr*>(&sockAddrIPv4);
 
-    } else if (Type_ == Ipv6) { 
+    } else if (Type_ == Ipv6) {
         memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6));
         sockAddrIPv6.sin6_family = AF_INET6;
-        sockAddrIPv6.sin6_port = htons(Port); 
+        sockAddrIPv6.sin6_port = htons(Port);
         ToIn6Addr(sockAddrIPv6.sin6_addr);
         sockAddrIPv6.sin6_scope_id = ScopeId_;
         sockAddrIPv6.sin6_flowinfo = 0;
 
         sockAddrSize = sizeof(sockAddrIPv6);
-        sockAddrPtr = reinterpret_cast<sockaddr*>(&sockAddrIPv6); 
+        sockAddrPtr = reinterpret_cast<sockaddr*>(&sockAddrIPv6);
     } else
         Y_VERIFY(false);
 }
 
-void TIpv6Address::ToInAddr(in_addr& Addr4) const { 
+void TIpv6Address::ToInAddr(in_addr& Addr4) const {
     Y_VERIFY(Type_ == TIpv6Address::Ipv4);
 
     Zero(Addr4);
@@ -181,22 +181,22 @@ void TIpv6Address::ToInAddr(in_addr& Addr4) const {
     Y_VERIFY(GetHigh(Ip) == 0, " ");
     Addr4.s_addr = SwapBytes(Value);
 }
-void TIpv6Address::ToIn6Addr(in6_addr& Addr6) const { 
+void TIpv6Address::ToIn6Addr(in6_addr& Addr6) const {
     Y_VERIFY(Type_ == TIpv6Address::Ipv6);
 
     Zero(Addr6);
     ui64 Raw[2] = {GetHigh(Ip), GetLow(Ip)};
-    *Raw = SwapBytes(*Raw); 
-    Raw[1] = SwapBytes(1 [Raw]); 
+    *Raw = SwapBytes(*Raw);
+    Raw[1] = SwapBytes(1 [Raw]);
     memcpy(&Addr6, Raw, sizeof(Raw));
 }
 
-void TIpv6Address::Save(IOutputStream* out) const { 
+void TIpv6Address::Save(IOutputStream* out) const {
     ::Save(out, Ip);
     ::Save(out, static_cast<ui8>(Type_));
     ::Save(out, ScopeId_);
 }
-void TIpv6Address::Load(IInputStream* in) { 
+void TIpv6Address::Load(IInputStream* in) {
     ::Load(in, Ip);
     ui8 num;
     ::Load(in, num);
@@ -210,21 +210,21 @@ bool TIpv6Address::Isv4MappedTov6() const noexcept {
     /// the IPv4-mapped IPv6 addresses.  In these addresses, the first 80 bits are zero, the next 16 bits are one,
     /// and the remaining 32 bits are the IPv4 address.
 
-    if (Type_ != Ipv6) 
+    if (Type_ != Ipv6)
         return false;
 
     if (GetHigh(Ip) != 0)
         return false; // First 64 bit are not zero -> it is not ipv4-mapped-ipv6 address
 
     const ui64 Low = GetLow(Ip) >> 32;
-    if (Low != 0x0000ffff) 
+    if (Low != 0x0000ffff)
         return false;
 
     return true;
 }
 
 TIpv6Address TIpv6Address::TryToExtractIpv4From6() const noexcept {
-    if (Isv4MappedTov6() == false) 
+    if (Isv4MappedTov6() == false)
         return TIpv6Address();
 
     const ui64 NewLow = GetLow(Ip) & 0x00000000ffffffff;
@@ -233,7 +233,7 @@ TIpv6Address TIpv6Address::TryToExtractIpv4From6() const noexcept {
 }
 
 TIpv6Address TIpv6Address::Normalized() const noexcept {
-    if (Isv4MappedTov6() == false) 
+    if (Isv4MappedTov6() == false)
         return *this;
 
     TIpv6Address Result = TryToExtractIpv4From6();
@@ -241,7 +241,7 @@ TIpv6Address TIpv6Address::Normalized() const noexcept {
     return Result;
 }
 
-IOutputStream& operator<<(IOutputStream& Out, const TIpv6Address::TIpType Type) noexcept { 
+IOutputStream& operator<<(IOutputStream& Out, const TIpv6Address::TIpType Type) noexcept {
     switch (Type) {
     case TIpv6Address::Ipv4:
         Out << "Ipv4";
@@ -255,10 +255,10 @@ IOutputStream& operator<<(IOutputStream& Out, const TIpv6Address::TIpType Type)
     }
 }
 
-IOutputStream& operator<<(IOutputStream& out, const TIpv6Address& ipv6Address) noexcept { 
-    bool ok; 
-    const TString& strIp = ipv6Address.ToString(&ok); 
-    if (!ok) { 
+IOutputStream& operator<<(IOutputStream& out, const TIpv6Address& ipv6Address) noexcept {
+    bool ok;
+    const TString& strIp = ipv6Address.ToString(&ok);
+    if (!ok) {
         return out << "Can not convert ip to string";
     } else {
         return out << strIp;
@@ -271,29 +271,29 @@ TString THostAddressAndPort::ToString() const noexcept {
     return Str.Str();
 }
 
-IOutputStream& operator<<(IOutputStream& Out, const THostAddressAndPort& HostAddressAndPort) noexcept { 
+IOutputStream& operator<<(IOutputStream& Out, const THostAddressAndPort& HostAddressAndPort) noexcept {
     Out << HostAddressAndPort.Ip << ":" << HostAddressAndPort.Port;
     return Out;
 }
 
 namespace {
-    class TRemoteAddr: public NAddr::IRemoteAddr { 
+    class TRemoteAddr: public NAddr::IRemoteAddr {
     public:
-        TRemoteAddr(const TIpv6Address& Address, TIpPort Port); 
-        const sockaddr* Addr() const override; 
-        socklen_t Len() const override; 
+        TRemoteAddr(const TIpv6Address& Address, TIpPort Port);
+        const sockaddr* Addr() const override;
+        socklen_t Len() const override;
 
     private:
-        sockaddr_in SockAddrIPv4; 
-        sockaddr_in6 SockAddrIPv6; 
-        const sockaddr* SockAddrPtr = nullptr; 
-        socklen_t SockAddrSize = 0; 
+        sockaddr_in SockAddrIPv4;
+        sockaddr_in6 SockAddrIPv6;
+        const sockaddr* SockAddrPtr = nullptr;
+        socklen_t SockAddrSize = 0;
     };
 
-    TRemoteAddr::TRemoteAddr(const TIpv6Address& Address, TIpPort Port) { 
+    TRemoteAddr::TRemoteAddr(const TIpv6Address& Address, TIpPort Port) {
         Address.ToSockaddrAndSocklen(SockAddrIPv4, SockAddrIPv6, SockAddrPtr, SockAddrSize, Port);
     }
-    const sockaddr* TRemoteAddr::Addr() const { 
+    const sockaddr* TRemoteAddr::Addr() const {
         return SockAddrPtr;
     }
     socklen_t TRemoteAddr::Len() const {
@@ -301,13 +301,13 @@ namespace {
     }
 }
 
-NAddr::IRemoteAddr* ToIRemoteAddr(const TIpv6Address& Address, TIpPort Port) { 
+NAddr::IRemoteAddr* ToIRemoteAddr(const TIpv6Address& Address, TIpPort Port) {
     return new TRemoteAddr(Address, Port);
 }
 
-std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromString(const TString& RawStr, 
-                                                                                  TIpPort DefaultPort, 
-                                                                                  bool& Ok) noexcept { 
+std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromString(const TString& RawStr,
+                                                                                  TIpPort DefaultPort,
+                                                                                  bool& Ok) noexcept {
     // Cout << "ParseHostAndMayBePortFromString: " << RawStr << ", Port: " << DefaultPort << Endl;
 
     using TRes = std::tuple<THostAddressAndPort, TString, TIpPort>;
@@ -315,7 +315,7 @@ std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromStrin
     // ---------------------------------------------------------------------
 
     const size_t BracketColPos = RawStr.find("]:");
-    if (BracketColPos != TString::npos) { 
+    if (BracketColPos != TString::npos) {
         // [ipv6]:port
         if (!RawStr.StartsWith('[')) {
             Ok = false;
@@ -324,13 +324,13 @@ std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromStrin
         const TStringBuf StrIpv6(RawStr.begin() + 1, RawStr.begin() + BracketColPos);
         const TStringBuf StrPort(RawStr.begin() + BracketColPos + 2, RawStr.end());
 
-        bool IpConverted; 
+        bool IpConverted;
         const TIpv6Address Ip = TIpv6Address::FromString(StrIpv6, IpConverted);
         if (!IpConverted) {
             Ok = false;
             return {};
         }
-        if (Ip.Type() != TIpv6Address::Ipv6) { 
+        if (Ip.Type() != TIpv6Address::Ipv6) {
             Ok = false;
             return {};
         }
@@ -347,7 +347,7 @@ std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromStrin
 
     // ---------------------------------------------------------------------
 
-    if (RawStr.StartsWith('[')) { 
+    if (RawStr.StartsWith('[')) {
         // [ipv6]
         if (!RawStr.EndsWith(']')) {
             Ok = false;
@@ -355,7 +355,7 @@ std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromStrin
         }
         const TStringBuf StrIpv6(RawStr.begin() + 1, RawStr.end() - 1);
 
-        bool IpConverted; 
+        bool IpConverted;
         const TIpv6Address Ip = TIpv6Address::FromString(StrIpv6, IpConverted);
         if (!IpConverted || Ip.Type() != TIpv6Address::Ipv6) {
             Ok = false;
@@ -370,15 +370,15 @@ std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromStrin
     // ---------------------------------------------------------------------
 
     const size_t ColPos = RawStr.find(':');
-    if (ColPos != TString::npos) { 
+    if (ColPos != TString::npos) {
         // host:port
         // ipv4:port
         // ipv6
 
         {
-            bool IpConverted; 
+            bool IpConverted;
             const TIpv6Address Ipv6 = TIpv6Address::FromString(RawStr, IpConverted);
-            if (IpConverted && Ipv6.Type() == TIpv6Address::Ipv6) { 
+            if (IpConverted && Ipv6.Type() == TIpv6Address::Ipv6) {
                 // ipv6
                 Ok = true;
                 TRes Res{{Ipv6, DefaultPort}, {}, {}};
@@ -395,9 +395,9 @@ std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromStrin
 
         const TStringBuf StrIpv4OrHost(RawStr.begin(), RawStr.begin() + ColPos);
         {
-            bool IpConverted; 
+            bool IpConverted;
             const TIpv6Address Ipv4 = TIpv6Address::FromString(StrIpv4OrHost, IpConverted);
-            if (IpConverted && Ipv4.Type() == TIpv6Address::Ipv4) { 
+            if (IpConverted && Ipv4.Type() == TIpv6Address::Ipv4) {
                 // ipv4:port
                 Ok = true;
                 TRes Res{{Ipv4, Port}, {}, {}};
@@ -417,9 +417,9 @@ std::tuple<THostAddressAndPort, TString, TIpPort> ParseHostAndMayBePortFromStrin
 
     {
         // ipv4
-        bool IpConverted; 
+        bool IpConverted;
         const TIpv6Address Ipv4 = TIpv6Address::FromString(RawStr, IpConverted);
-        if (IpConverted && Ipv4.Type() == TIpv6Address::Ipv4) { 
+        if (IpConverted && Ipv4.Type() == TIpv6Address::Ipv4) {
             Ok = true;
             TRes Res{{Ipv4, DefaultPort}, {}, {}};
             return Res;