Restoring authorship annotation for Andrey Fomichev <andrey.fomichev@gmail.com>. Commit 1 of 2.

11 files changed, 427 insertions, 427 deletions

diff --git a/util/folder/dirut.cpp b/util/folder/dirut.cpp
index ffc9b09f96..b405baa83e 100644
--- a/util/folder/dirut.cpp
+++ b/util/folder/dirut.cpp
@@ -394,11 +394,11 @@ void RemoveDirWithContents(TString dirName) {
         }
     }
 }
-
+ 
 int mkpath(char* path, int mode) {
     return NFs::MakeDirectoryRecursive(path, NFs::EFilePermission(mode)) ? 0 : -1;
-}
-
+} 
+ 
 // Implementation of realpath in FreeBSD (version 9.0 and less) and GetFullPathName in Windows
 // did not require last component of the file name to exist (other implementations will fail
 // if it does not). Use RealLocation if that behaviour is required.
diff --git a/util/folder/dirut.h b/util/folder/dirut.h
index 2537027b12..b60847c894 100644
--- a/util/folder/dirut.h
+++ b/util/folder/dirut.h
@@ -40,7 +40,7 @@ char* mkdtemp(char* path);
 bool IsDir(const TString& path);
 
 int mkpath(char* path, int mode = 0777);
-
+ 
 TString GetHomeDir();
 
 void MakeDirIfNotExist(const char* path, int mode = 0777);
diff --git a/util/generic/buffer.h b/util/generic/buffer.h
index 9576467404..9cfebdf009 100644
--- a/util/generic/buffer.h
+++ b/util/generic/buffer.h
@@ -49,7 +49,7 @@ public:
     inline void Reset() noexcept {
         TBuffer().Swap(*this);
     }
-
+ 
     inline void Assign(const char* data, size_t len) {
         Clear();
         Append(data, len);
@@ -180,7 +180,7 @@ public:
             Append(fillChar);
         }
     }
-
+ 
     inline char* data() noexcept {
         return Data();
     }
diff --git a/util/generic/buffer_ut.cpp b/util/generic/buffer_ut.cpp
index 437d7122ec..5922636b4b 100644
--- a/util/generic/buffer_ut.cpp
+++ b/util/generic/buffer_ut.cpp
@@ -41,19 +41,19 @@ Y_UNIT_TEST_SUITE(TBufferTest) {
 
         buf.Append(content, sizeof(content));
         buf.Clear();
-
+ 
         UNIT_ASSERT(buf.Capacity() != 0);
-
+ 
         buf.Append(content, sizeof(content));
         buf.Reset();
-
+ 
         UNIT_ASSERT_EQUAL(buf.Capacity(), 0);
     }
-
+ 
     Y_UNIT_TEST(TestResize) {
         char content[] = "some text";
         TBuffer buf;
-
+ 
         buf.Resize(10);
         UNIT_ASSERT_VALUES_EQUAL(buf.size(), 10u);
 
@@ -127,23 +127,23 @@ Y_UNIT_TEST_SUITE(TBufferTest) {
 
 #if 0
 Y_UNIT_TEST(TestAlignUp) {
-    char content[] = "some text";
-    TBuffer buf;
-
-    buf.Append(content, sizeof(content));
-    buf.AlignUp(4, '!');
-
-    UNIT_ASSERT(buf.Size() % 4 == 0);
+    char content[] = "some text"; 
+    TBuffer buf; 
+ 
+    buf.Append(content, sizeof(content)); 
+    buf.AlignUp(4, '!'); 
+ 
+    UNIT_ASSERT(buf.Size() % 4 == 0); 
     UNIT_ASSERT_VALUES_EQUAL(TString(~buf, +buf), "some text!!!");
-
-    char addContent[] = "1234";
-    buf.Append(addContent, sizeof(addContent));
-    buf.AlignUp(4, 'X');
-    UNIT_ASSERT(buf.Size() % 4 == 0);
+ 
+    char addContent[] = "1234"; 
+    buf.Append(addContent, sizeof(addContent)); 
+    buf.AlignUp(4, 'X'); 
+    UNIT_ASSERT(buf.Size() % 4 == 0); 
     UNIT_ASSERT_VALUES_EQUAL(TString(~buf, +buf), "some text!!!1234");
-}
+} 
 #endif
-
+ 
 #if 0
 Y_UNIT_TEST(TestSpeed) {
     const char data[] = "1234567890qwertyuiop";
diff --git a/util/memory/pool.h b/util/memory/pool.h
index 13c8b6b9ed..08e724e68e 100644
--- a/util/memory/pool.h
+++ b/util/memory/pool.h
@@ -75,7 +75,7 @@ private:
         inline const char* Data() const noexcept {
             return (const char*)(this + 1);
         }
-
+ 
         inline char* Data() noexcept {
             return (char*)(this + 1);
         }
@@ -83,7 +83,7 @@ private:
         inline size_t DataSize() const noexcept {
             return Cur_ - Data();
         }
-
+ 
         inline void ResetChunk() noexcept {
             size_t total = DataSize() + Left();
             Cur_ = Data();
@@ -94,7 +94,7 @@ private:
         char* Cur_;
         size_t Left_;
     };
-
+ 
     using TChunkList = TIntrusiveList<TChunk>;
 
 public:
@@ -256,9 +256,9 @@ public:
     inline void Traverse(TOp& op) const noexcept {
         for (TChunkList::TConstIterator i = Chunks_.Begin(); i != Chunks_.End(); ++i) {
             op(i->Data(), i->DataSize());
-        }
+        } 
     }
-
+ 
     inline IAllocator* RealAllocator() const noexcept {
         return Alloc_;
     }
diff --git a/util/network/hostip.cpp b/util/network/hostip.cpp
index cb8d43bf90..1acc3abfbf 100644
--- a/util/network/hostip.cpp
+++ b/util/network/hostip.cpp
@@ -2,7 +2,7 @@
 #include "hostip.h"
 
 #include <util/system/defaults.h>
-#include <util/system/byteorder.h>
+#include <util/system/byteorder.h> 
 
 #if defined(_unix_) || defined(_cygwin_)
     #include <netdb.h>
@@ -18,9 +18,9 @@
     #endif
 #endif
 
-int NResolver::GetHostIP(const char* hostname, ui32* ip, size_t* slots) {
-    size_t i = 0;
-    size_t ipsFound = 0;
+int NResolver::GetHostIP(const char* hostname, ui32* ip, size_t* slots) { 
+    size_t i = 0; 
+    size_t ipsFound = 0; 
 
 #ifdef AGENT_USE_GETADDRINFO
     int ret = 0;
@@ -33,7 +33,7 @@ int NResolver::GetHostIP(const char* hostname, ui32* ip, size_t* slots) {
     if (gai_ret == 0 && gai_res->ai_addr) {
         struct addrinfo* cur = gai_res;
         for (i = 0; i < *slots && cur; i++, cur = cur->ai_next, ipsFound++) {
-            ip[i] = *(ui32*)(&((sockaddr_in*)(cur->ai_addr))->sin_addr);
+            ip[i] = *(ui32*)(&((sockaddr_in*)(cur->ai_addr))->sin_addr); 
         }
     } else {
         if (gai_ret == EAI_NONAME || gai_ret == EAI_SERVICE) {
@@ -61,10 +61,10 @@ int NResolver::GetHostIP(const char* hostname, ui32* ip, size_t* slots) {
 
     char** cur = hostent->h_addr_list;
     for (i = 0; i < *slots && *cur; i++, cur++, ipsFound++)
-        ip[i] = *(ui32*)*cur;
+        ip[i] = *(ui32*)*cur; 
 #endif
     for (i = 0; i < ipsFound; i++) {
-        ip[i] = InetToHost(ip[i]);
+        ip[i] = InetToHost(ip[i]); 
     }
     *slots = ipsFound;
 
diff --git a/util/network/hostip.h b/util/network/hostip.h
index cf63e4846a..ae71087017 100644
--- a/util/network/hostip.h
+++ b/util/network/hostip.h
@@ -3,8 +3,8 @@
 #include <util/system/defaults.h>
 
 namespace NResolver {
-    // resolve hostname and fills up to *slots slots in ip array;
-    // actual number of slots filled is returned in *slots;
+    // resolve hostname and fills up to *slots slots in ip array; 
+    // actual number of slots filled is returned in *slots; 
     int GetHostIP(const char* hostname, ui32* ip, size_t* slots);
     int GetDnsError();
 
diff --git a/util/network/sock.h b/util/network/sock.h
index b10be2f715..ae9018adba 100644
--- a/util/network/sock.h
+++ b/util/network/sock.h
@@ -1,276 +1,276 @@
 #pragma once
-
+ 
 #include <util/folder/path.h>
-#include <util/system/defaults.h>
-#include <util/string/cast.h>
+#include <util/system/defaults.h> 
+#include <util/string/cast.h> 
 #include <util/stream/output.h>
 #include <util/system/sysstat.h>
-
+ 
 #if defined(_win_) || defined(_cygwin_)
     #include <util/system/file.h>
-#else
+#else 
     #include <sys/un.h>
     #include <sys/stat.h>
-#endif //_win_
-
-#include "init.h"
-#include "ip.h"
-#include "socket.h"
-
+#endif //_win_ 
+ 
+#include "init.h" 
+#include "ip.h" 
+#include "socket.h" 
+ 
 constexpr ui16 DEF_LOCAL_SOCK_MODE = 00644;
-
-// Base abstract class for socket address
+ 
+// Base abstract class for socket address 
 struct ISockAddr {
     virtual ~ISockAddr() = default;
-    // Max size of the address that we can store (arg of recvfrom)
-    virtual socklen_t Size() const = 0;
-    // Real length of the address (arg of sendto)
-    virtual socklen_t Len() const = 0;
-    // cast to sockaddr* to pass to any syscall
-    virtual sockaddr* SockAddr() = 0;
-    virtual const sockaddr* SockAddr() const = 0;
-    // address in human readable form
+    // Max size of the address that we can store (arg of recvfrom) 
+    virtual socklen_t Size() const = 0; 
+    // Real length of the address (arg of sendto) 
+    virtual socklen_t Len() const = 0; 
+    // cast to sockaddr* to pass to any syscall 
+    virtual sockaddr* SockAddr() = 0; 
+    virtual const sockaddr* SockAddr() const = 0; 
+    // address in human readable form 
     virtual TString ToString() const = 0;
-
-protected:
-    // below are the implemetation methods that can be called by T*Socket classes
-    friend class TBaseSocket;
-    friend class TDgramSocket;
-    friend class TStreamSocket;
-
-    virtual int ResolveAddr() const {
-        // usually it's nothing to do here
-        return 0;
-    }
-    virtual int Bind(SOCKET s, ui16 mode) const = 0;
-};
-
+ 
+protected: 
+    // below are the implemetation methods that can be called by T*Socket classes 
+    friend class TBaseSocket; 
+    friend class TDgramSocket; 
+    friend class TStreamSocket; 
+ 
+    virtual int ResolveAddr() const { 
+        // usually it's nothing to do here 
+        return 0; 
+    } 
+    virtual int Bind(SOCKET s, ui16 mode) const = 0; 
+}; 
+ 
 #if defined(_win_) || defined(_cygwin_)
     #define YAF_LOCAL AF_INET
 struct TSockAddrLocal: public ISockAddr {
-    TSockAddrLocal() {
-        Clear();
-    }
-
-    TSockAddrLocal(const char* path) {
-        Set(path);
-    }
-
-    socklen_t Size() const {
-        return sizeof(sockaddr_in);
-    }
-
-    socklen_t Len() const {
-        return Size();
-    }
-
+    TSockAddrLocal() { 
+        Clear(); 
+    } 
+ 
+    TSockAddrLocal(const char* path) { 
+        Set(path); 
+    } 
+ 
+    socklen_t Size() const { 
+        return sizeof(sockaddr_in); 
+    } 
+ 
+    socklen_t Len() const { 
+        return Size(); 
+    } 
+ 
     inline void Clear() noexcept {
-        Zero(in);
-        Zero(Path);
-    }
-
+        Zero(in); 
+        Zero(Path); 
+    } 
+ 
     inline void Set(const char* path) noexcept {
-        Clear();
-        in.sin_family = AF_INET;
-        in.sin_addr.s_addr = IpFromString("127.0.0.1");
-        in.sin_port = 0;
-        strlcpy(Path, path, PathSize);
-    }
-
-    sockaddr* SockAddr() {
-        return (struct sockaddr*)(&in);
-    }
-
-    const sockaddr* SockAddr() const {
-        return (const struct sockaddr*)(&in);
-    }
-
+        Clear(); 
+        in.sin_family = AF_INET; 
+        in.sin_addr.s_addr = IpFromString("127.0.0.1"); 
+        in.sin_port = 0; 
+        strlcpy(Path, path, PathSize); 
+    } 
+ 
+    sockaddr* SockAddr() { 
+        return (struct sockaddr*)(&in); 
+    } 
+ 
+    const sockaddr* SockAddr() const { 
+        return (const struct sockaddr*)(&in); 
+    } 
+ 
     TString ToString() const {
         return TString(Path);
-    }
-
+    } 
+ 
     TFsPath ToPath() const {
         return TFsPath(Path);
     }
 
-    int ResolveAddr() const {
-        if (in.sin_port == 0) {
-            int ret = 0;
-            // 1. open file
-            TFileHandle f(Path, OpenExisting | RdOnly);
-            if (!f.IsOpen())
-                return -errno;
-
-            // 2. read the port from file
-            ret = f.Read(&in.sin_port, sizeof(in.sin_port));
-            if (ret != sizeof(in.sin_port))
-                return -(errno ? errno : EFAULT);
-        }
-
-        return 0;
-    }
-
-    int Bind(SOCKET s, ui16 mode) const {
+    int ResolveAddr() const { 
+        if (in.sin_port == 0) { 
+            int ret = 0; 
+            // 1. open file 
+            TFileHandle f(Path, OpenExisting | RdOnly); 
+            if (!f.IsOpen()) 
+                return -errno; 
+ 
+            // 2. read the port from file 
+            ret = f.Read(&in.sin_port, sizeof(in.sin_port)); 
+            if (ret != sizeof(in.sin_port)) 
+                return -(errno ? errno : EFAULT); 
+        } 
+ 
+        return 0; 
+    } 
+ 
+    int Bind(SOCKET s, ui16 mode) const { 
         Y_UNUSED(mode);
         int ret = 0;
         // 1. open file
         TFileHandle f(Path, CreateAlways | WrOnly);
         if (!f.IsOpen())
             return -errno;
-
+ 
         // 2. find port and bind to it
         in.sin_port = 0;
         ret = bind(s, SockAddr(), Len());
         if (ret != 0)
             return -WSAGetLastError();
-
+ 
         int size = Size();
         ret = getsockname(s, (struct sockaddr*)(&in), &size);
         if (ret != 0)
             return -WSAGetLastError();
-
+ 
         // 3. write port to file
         ret = f.Write(&(in.sin_port), sizeof(in.sin_port));
         if (ret != sizeof(in.sin_port))
             return -errno;
-
+ 
         return 0;
-    }
-
+    } 
+ 
     static constexpr size_t PathSize = 128;
-    mutable struct sockaddr_in in;
-    char Path[PathSize];
-};
-#else
+    mutable struct sockaddr_in in; 
+    char Path[PathSize]; 
+}; 
+#else 
     #define YAF_LOCAL AF_LOCAL
 struct TSockAddrLocal: public sockaddr_un, public ISockAddr {
-    TSockAddrLocal() {
-        Clear();
-    }
-
-    TSockAddrLocal(const char* path) {
-        Set(path);
-    }
-
+    TSockAddrLocal() { 
+        Clear(); 
+    } 
+ 
+    TSockAddrLocal(const char* path) { 
+        Set(path); 
+    } 
+ 
     socklen_t Size() const override {
-        return sizeof(sockaddr_un);
-    }
-
+        return sizeof(sockaddr_un); 
+    } 
+ 
     socklen_t Len() const override {
-        return strlen(sun_path) + 2;
-    }
-
+        return strlen(sun_path) + 2; 
+    } 
+ 
     inline void Clear() noexcept {
-        Zero(*(sockaddr_un*)this);
-    }
-
+        Zero(*(sockaddr_un*)this); 
+    } 
+ 
     inline void Set(const char* path) noexcept {
-        Clear();
-        sun_family = AF_UNIX;
-        strlcpy(sun_path, path, sizeof(sun_path));
-    }
-
+        Clear(); 
+        sun_family = AF_UNIX; 
+        strlcpy(sun_path, path, sizeof(sun_path)); 
+    } 
+ 
     sockaddr* SockAddr() override {
         return (struct sockaddr*)(struct sockaddr_un*)this;
-    }
-
+    } 
+ 
     const sockaddr* SockAddr() const override {
         return (const struct sockaddr*)(const struct sockaddr_un*)this;
-    }
-
+    } 
+ 
     TString ToString() const override {
         return TString(sun_path);
-    }
-
+    } 
+ 
     TFsPath ToPath() const {
         return TFsPath(sun_path);
     }
 
     int Bind(SOCKET s, ui16 mode) const override {
-        (void)unlink(sun_path);
-
-        int ret = bind(s, SockAddr(), Len());
-        if (ret < 0)
-            return -errno;
-
+        (void)unlink(sun_path); 
+ 
+        int ret = bind(s, SockAddr(), Len()); 
+        if (ret < 0) 
+            return -errno; 
+ 
         ret = Chmod(sun_path, mode);
-        if (ret < 0)
-            return -errno;
-        return 0;
-    }
-};
-#endif // _win_
-
+        if (ret < 0) 
+            return -errno; 
+        return 0; 
+    } 
+}; 
+#endif // _win_ 
+ 
 struct TSockAddrInet: public sockaddr_in, public ISockAddr {
-    TSockAddrInet() {
-        Clear();
-    }
-
-    TSockAddrInet(TIpHost ip, TIpPort port) {
-        Set(ip, port);
-    }
-
+    TSockAddrInet() { 
+        Clear(); 
+    } 
+ 
+    TSockAddrInet(TIpHost ip, TIpPort port) { 
+        Set(ip, port); 
+    } 
+ 
     TSockAddrInet(const char* ip, TIpPort port) {
         Set(IpFromString(ip), port);
     }
 
     socklen_t Size() const override {
-        return sizeof(sockaddr_in);
-    }
-
+        return sizeof(sockaddr_in); 
+    } 
+ 
     socklen_t Len() const override {
-        return Size();
-    }
-
+        return Size(); 
+    } 
+ 
     inline void Clear() noexcept {
-        Zero(*(sockaddr_in*)this);
-    }
-
+        Zero(*(sockaddr_in*)this); 
+    } 
+ 
     inline void Set(TIpHost ip, TIpPort port) noexcept {
-        Clear();
-        sin_family = AF_INET;
-        sin_addr.s_addr = ip;
-        sin_port = HostToInet(port);
-    }
-
+        Clear(); 
+        sin_family = AF_INET; 
+        sin_addr.s_addr = ip; 
+        sin_port = HostToInet(port); 
+    } 
+ 
     sockaddr* SockAddr() override {
         return (struct sockaddr*)(struct sockaddr_in*)this;
-    }
-
+    } 
+ 
     const sockaddr* SockAddr() const override {
         return (const struct sockaddr*)(const struct sockaddr_in*)this;
-    }
-
+    } 
+ 
     TString ToString() const override {
-        return IpToString(sin_addr.s_addr) + ":" + ::ToString(InetToHost(sin_port));
-    }
-
+        return IpToString(sin_addr.s_addr) + ":" + ::ToString(InetToHost(sin_port)); 
+    } 
+ 
     int Bind(SOCKET s, ui16 mode) const override {
         Y_UNUSED(mode);
-        int ret = bind(s, SockAddr(), Len());
-        if (ret < 0)
-            return -errno;
-
+        int ret = bind(s, SockAddr(), Len()); 
+        if (ret < 0) 
+            return -errno; 
+ 
         socklen_t len = Len();
         if (getsockname(s, (struct sockaddr*)(SockAddr()), &len) < 0)
             return -WSAGetLastError();
 
-        return 0;
-    }
-
+        return 0; 
+    } 
+ 
     TIpHost GetIp() const noexcept {
-        return sin_addr.s_addr;
-    }
-
+        return sin_addr.s_addr; 
+    } 
+ 
     TIpPort GetPort() const noexcept {
-        return InetToHost(sin_port);
-    }
+        return InetToHost(sin_port); 
+    } 
 
     void SetPort(TIpPort port) noexcept {
         sin_port = HostToInet(port);
     }
-};
-
+}; 
+ 
 struct TSockAddrInet6: public sockaddr_in6, public ISockAddr {
     TSockAddrInet6() {
         Clear();
@@ -345,113 +345,113 @@ using TSockAddrInetStream = TSockAddrInet;
 using TSockAddrInetDgram = TSockAddrInet;
 using TSockAddrInet6Stream = TSockAddrInet6;
 using TSockAddrInet6Dgram = TSockAddrInet6;
-
+ 
 class TBaseSocket: public TSocketHolder {
-protected:
-    TBaseSocket(SOCKET fd)
-        : TSocketHolder(fd)
-    {
-    }
-
-public:
+protected: 
+    TBaseSocket(SOCKET fd) 
+        : TSocketHolder(fd) 
+    { 
+    } 
+ 
+public: 
     int Bind(const ISockAddr* addr, ui16 mode = DEF_LOCAL_SOCK_MODE) {
         return addr->Bind((SOCKET) * this, mode);
-    }
-
-    void CheckSock() {
+    } 
+ 
+    void CheckSock() { 
         if ((SOCKET) * this == INVALID_SOCKET)
-            ythrow TSystemError() << "no socket";
-    }
-
-    static ssize_t Check(ssize_t ret, const char* op = "") {
-        if (ret < 0)
+            ythrow TSystemError() << "no socket"; 
+    } 
+ 
+    static ssize_t Check(ssize_t ret, const char* op = "") { 
+        if (ret < 0) 
             ythrow TSystemError(-(int)ret) << "socket operation " << op;
-        return ret;
-    }
-};
-
+        return ret; 
+    } 
+}; 
+ 
 class TDgramSocket: public TBaseSocket {
-protected:
-    TDgramSocket(SOCKET fd)
-        : TBaseSocket(fd)
-    {
-    }
-
-public:
+protected: 
+    TDgramSocket(SOCKET fd) 
+        : TBaseSocket(fd) 
+    { 
+    } 
+ 
+public: 
     ssize_t SendTo(const void* msg, size_t len, const ISockAddr* toAddr) {
-        ssize_t ret = toAddr->ResolveAddr();
+        ssize_t ret = toAddr->ResolveAddr(); 
         if (ret < 0) {
             return -LastSystemError();
         }
-
+ 
         ret = sendto((SOCKET) * this, (const char*)msg, (int)len, 0, toAddr->SockAddr(), toAddr->Len());
         if (ret < 0) {
             return -LastSystemError();
         }
-
-        return ret;
-    }
-
+ 
+        return ret; 
+    } 
+ 
     ssize_t RecvFrom(void* buf, size_t len, ISockAddr* fromAddr) {
-        socklen_t fromSize = fromAddr->Size();
+        socklen_t fromSize = fromAddr->Size(); 
         const ssize_t ret = recvfrom((SOCKET) * this, (char*)buf, (int)len, 0, fromAddr->SockAddr(), &fromSize);
-        if (ret < 0) {
+        if (ret < 0) { 
             return -LastSystemError();
-        }
-
-        return ret;
-    }
-};
-
+        } 
+ 
+        return ret; 
+    } 
+}; 
+ 
 class TStreamSocket: public TBaseSocket {
-protected:
+protected: 
     explicit TStreamSocket(SOCKET fd)
-        : TBaseSocket(fd)
-    {
-    }
-
-public:
+        : TBaseSocket(fd) 
+    { 
+    } 
+ 
+public: 
     TStreamSocket()
         : TBaseSocket(INVALID_SOCKET)
     {
     }
 
-    ssize_t Send(const void* msg, size_t len, int flags = 0) {
+    ssize_t Send(const void* msg, size_t len, int flags = 0) { 
         const ssize_t ret = send((SOCKET) * this, (const char*)msg, (int)len, flags);
-        if (ret < 0)
-            return -errno;
-
-        return ret;
-    }
-
-    ssize_t Recv(void* buf, size_t len, int flags = 0) {
+        if (ret < 0) 
+            return -errno; 
+ 
+        return ret; 
+    } 
+ 
+    ssize_t Recv(void* buf, size_t len, int flags = 0) { 
         const ssize_t ret = recv((SOCKET) * this, (char*)buf, (int)len, flags);
-        if (ret < 0)
-            return -errno;
-
-        return ret;
-    }
-
+        if (ret < 0) 
+            return -errno; 
+ 
+        return ret; 
+    } 
+ 
     int Connect(const ISockAddr* addr) {
-        int ret = addr->ResolveAddr();
-        if (ret < 0)
-            return -errno;
-
+        int ret = addr->ResolveAddr(); 
+        if (ret < 0) 
+            return -errno; 
+ 
         ret = connect((SOCKET) * this, addr->SockAddr(), addr->Len());
-        if (ret < 0)
-            return -errno;
-
-        return ret;
-    }
-
-    int Listen(int backlog) {
+        if (ret < 0) 
+            return -errno; 
+ 
+        return ret; 
+    } 
+ 
+    int Listen(int backlog) { 
         int ret = listen((SOCKET) * this, backlog);
-        if (ret < 0)
-            return -errno;
-
-        return ret;
-    }
-
+        if (ret < 0) 
+            return -errno; 
+ 
+        return ret; 
+    } 
+ 
     int Accept(TStreamSocket* acceptedSock, ISockAddr* acceptedAddr = nullptr) {
         SOCKET s = INVALID_SOCKET;
         if (acceptedAddr) {
@@ -462,40 +462,40 @@ public:
         }
 
         if (s == INVALID_SOCKET)
-            return -errno;
-
-        TSocketHolder sock(s);
-        acceptedSock->Swap(sock);
-        return 0;
-    }
-};
-
+            return -errno; 
+ 
+        TSocketHolder sock(s); 
+        acceptedSock->Swap(sock); 
+        return 0; 
+    } 
+}; 
+ 
 class TLocalDgramSocket: public TDgramSocket {
-public:
-    TLocalDgramSocket(SOCKET fd)
-        : TDgramSocket(fd)
-    {
-    }
-
-    TLocalDgramSocket()
-        : TDgramSocket(socket(YAF_LOCAL, SOCK_DGRAM, 0))
-    {
-    }
-};
-
+public: 
+    TLocalDgramSocket(SOCKET fd) 
+        : TDgramSocket(fd) 
+    { 
+    } 
+ 
+    TLocalDgramSocket() 
+        : TDgramSocket(socket(YAF_LOCAL, SOCK_DGRAM, 0)) 
+    { 
+    } 
+}; 
+ 
 class TInetDgramSocket: public TDgramSocket {
-public:
-    TInetDgramSocket(SOCKET fd)
-        : TDgramSocket(fd)
-    {
-    }
-
-    TInetDgramSocket()
-        : TDgramSocket(socket(AF_INET, SOCK_DGRAM, 0))
-    {
-    }
-};
-
+public: 
+    TInetDgramSocket(SOCKET fd) 
+        : TDgramSocket(fd) 
+    { 
+    } 
+ 
+    TInetDgramSocket() 
+        : TDgramSocket(socket(AF_INET, SOCK_DGRAM, 0)) 
+    { 
+    } 
+}; 
+ 
 class TInet6DgramSocket: public TDgramSocket {
 public:
     TInet6DgramSocket(SOCKET fd)
@@ -510,30 +510,30 @@ public:
 };
 
 class TLocalStreamSocket: public TStreamSocket {
-public:
-    TLocalStreamSocket(SOCKET fd)
-        : TStreamSocket(fd)
-    {
-    }
-
-    TLocalStreamSocket()
-        : TStreamSocket(socket(YAF_LOCAL, SOCK_STREAM, 0))
-    {
-    }
-};
-
+public: 
+    TLocalStreamSocket(SOCKET fd) 
+        : TStreamSocket(fd) 
+    { 
+    } 
+ 
+    TLocalStreamSocket() 
+        : TStreamSocket(socket(YAF_LOCAL, SOCK_STREAM, 0)) 
+    { 
+    } 
+}; 
+ 
 class TInetStreamSocket: public TStreamSocket {
-public:
-    TInetStreamSocket(SOCKET fd)
-        : TStreamSocket(fd)
-    {
-    }
-
-    TInetStreamSocket()
-        : TStreamSocket(socket(AF_INET, SOCK_STREAM, 0))
-    {
-    }
-};
+public: 
+    TInetStreamSocket(SOCKET fd) 
+        : TStreamSocket(fd) 
+    { 
+    } 
+ 
+    TInetStreamSocket() 
+        : TStreamSocket(socket(AF_INET, SOCK_STREAM, 0)) 
+    { 
+    } 
+}; 
 
 class TInet6StreamSocket: public TStreamSocket {
 public:
diff --git a/util/network/sock_ut.cpp b/util/network/sock_ut.cpp
index fd8c783747..83f4a19d50 100644
--- a/util/network/sock_ut.cpp
+++ b/util/network/sock_ut.cpp
@@ -2,7 +2,7 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/threading/future/legacy_future.h>
-
+ 
 #include <util/system/fs.h>
 
 Y_UNIT_TEST_SUITE(TSocketTest) {
@@ -16,25 +16,25 @@ Y_UNIT_TEST_SUITE(TSocketTest) {
         TInetDgramSocket servSock;
         cliSock.CheckSock();
         servSock.CheckSock();
-
+ 
         TBaseSocket::Check(cliSock.Bind(&cliAddr));
         TBaseSocket::Check(servSock.Bind(&servAddr));
-
+ 
         // client
         const char reqStr[] = "Hello, world!!!";
         TBaseSocket::Check(cliSock.SendTo(reqStr, sizeof(reqStr), &servAddr));
-
+ 
         // server
         TBaseSocket::Check(servSock.RecvFrom(buf, 256, &servFromAddr));
         UNIT_ASSERT(strcmp(reqStr, buf) == 0);
         const char repStr[] = "The World's greatings to you";
         TBaseSocket::Check(servSock.SendTo(repStr, sizeof(repStr), &servFromAddr));
-
+ 
         // client
         TBaseSocket::Check(cliSock.RecvFrom(buf, 256, &cliFromAddr));
         UNIT_ASSERT(strcmp(repStr, buf) == 0);
     }
-
+ 
     void RunLocalDgramTest(const char* localServerSockName, const char* localClientSockName) {
         char buf[256];
         TSockAddrLocalDgram servAddr(localServerSockName);
@@ -45,25 +45,25 @@ Y_UNIT_TEST_SUITE(TSocketTest) {
         TLocalDgramSocket servSock;
         cliSock.CheckSock();
         servSock.CheckSock();
-
+ 
         TBaseSocket::Check(cliSock.Bind(&cliAddr), "bind client");
         TBaseSocket::Check(servSock.Bind(&servAddr), "bind server");
-
+ 
         // client
         const char reqStr[] = "Hello, world!!!";
         TBaseSocket::Check(cliSock.SendTo(reqStr, sizeof(reqStr), &servAddr), "send from client");
-
+ 
         // server
         TBaseSocket::Check(servSock.RecvFrom(buf, 256, &servFromAddr), "receive from client");
         UNIT_ASSERT(strcmp(reqStr, buf) == 0);
         const char repStr[] = "The World's greatings to you";
         TBaseSocket::Check(servSock.SendTo(repStr, sizeof(repStr), &servFromAddr), "send to client");
-
+ 
         // client
         TBaseSocket::Check(cliSock.RecvFrom(buf, 256, &cliFromAddr), "receive from server");
         UNIT_ASSERT(strcmp(repStr, buf) == 0);
     }
-
+ 
     Y_UNIT_TEST(LocalDgramTest) {
         const char* localServerSockName = "./serv_sock";
         const char* localClientSockName = "./cli_sock";
@@ -71,7 +71,7 @@ Y_UNIT_TEST_SUITE(TSocketTest) {
         NFs::Remove(localServerSockName);
         NFs::Remove(localClientSockName);
     }
-
+ 
     template <class A, class S>
     void RunInetStreamTest(const char* ip) {
         char buf[256];
@@ -89,28 +89,28 @@ Y_UNIT_TEST_SUITE(TSocketTest) {
         CheckedSetSockOpt(servSock, SOL_SOCKET, SO_REUSEADDR, yes, "servSock, SO_REUSEADDR");
         TBaseSocket::Check(servSock.Bind(&servAddr), "bind");
         TBaseSocket::Check(servSock.Listen(10), "listen");
-
+ 
         // client
         TBaseSocket::Check(cliSock.Connect(&servAddr), "connect");
-
+ 
         // server
         TBaseSocket::Check(servSock.Accept(&newSock, &newAddr), "accept");
-
+ 
         // client
         const char reqStr[] = "Hello, world!!!";
         TBaseSocket::Check(cliSock.Send(reqStr, sizeof(reqStr)), "send");
-
+ 
         // server - new
         TBaseSocket::Check(newSock.Recv(buf, 256), "recv");
         UNIT_ASSERT(strcmp(reqStr, buf) == 0);
         const char repStr[] = "The World's greatings to you";
         TBaseSocket::Check(newSock.Send(repStr, sizeof(repStr)), "send");
-
+ 
         // client
         TBaseSocket::Check(cliSock.Recv(buf, 256), "recv");
         UNIT_ASSERT(strcmp(repStr, buf) == 0);
     }
-
+ 
     Y_UNIT_TEST(InetStreamTest) {
         RunInetStreamTest<TSockAddrInetStream, TInetStreamSocket>("127.0.0.1");
     }
@@ -129,11 +129,11 @@ Y_UNIT_TEST_SUITE(TSocketTest) {
         cliSock.CheckSock();
         servSock.CheckSock();
         newSock.CheckSock();
-
+ 
         // server
         TBaseSocket::Check(servSock.Bind(&servAddr), "bind");
         TBaseSocket::Check(servSock.Listen(10), "listen");
-
+ 
         NThreading::TLegacyFuture<void> f([&]() {
             // server
             TBaseSocket::Check(servSock.Accept(&newSock, &newAddr), "accept");
@@ -141,28 +141,28 @@ Y_UNIT_TEST_SUITE(TSocketTest) {
 
         // client
         TBaseSocket::Check(cliSock.Connect(&servAddr), "connect");
-
+ 
         f.Get();
-
+ 
         // client
         const char reqStr[] = "Hello, world!!!";
         TBaseSocket::Check(cliSock.Send(reqStr, sizeof(reqStr)), "send");
-
+ 
         // server - new
         TBaseSocket::Check(newSock.Recv(buf, 256), "recv");
         UNIT_ASSERT(strcmp(reqStr, buf) == 0);
         const char repStr[] = "The World's greatings to you";
         TBaseSocket::Check(newSock.Send(repStr, sizeof(repStr)), "send");
-
+ 
         // client
         TBaseSocket::Check(cliSock.Recv(buf, 256), "recv");
         UNIT_ASSERT(strcmp(repStr, buf) == 0);
     }
-
+ 
     Y_UNIT_TEST(LocalStreamTest) {
         const char* localServerSockName = "./serv_sock2";
         RunLocalStreamTest(localServerSockName);
         NFs::Remove(localServerSockName);
     }
-
+ 
 }
diff --git a/util/network/socket.h b/util/network/socket.h
index 40c8648b40..688f7966fd 100644
--- a/util/network/socket.h
+++ b/util/network/socket.h
@@ -400,7 +400,7 @@ public:
     const TSocket& GetSocket() const noexcept {
         return S_;
     }
-
+ 
 private:
     size_t DoRead(void* buf, size_t len) override;
 
@@ -419,7 +419,7 @@ public:
     const TSocket& GetSocket() const noexcept {
         return S_;
     }
-
+ 
 private:
     void DoWrite(const void* buf, size_t len) override;
     void DoWriteV(const TPart* parts, size_t count) override;
diff --git a/util/system/sigset.h b/util/system/sigset.h
index 8dd02fd817..ff9fa44c15 100644
--- a/util/system/sigset.h
+++ b/util/system/sigset.h
@@ -1,78 +1,78 @@
 #pragma once
-
-// Functions for manipulating signal sets
-
+ 
+// Functions for manipulating signal sets 
+ 
 #include "compat.h"
-
-#if defined _unix_
+ 
+#if defined _unix_ 
     #include <pthread.h>
-#elif defined _win_
+#elif defined _win_ 
     // Flags for sigprocmask:
     #define SIG_BLOCK 1
     #define SIG_UNBLOCK 2
     #define SIG_SETMASK 3
-
+ 
 using sigset_t = ui32;
-
-#else
+ 
+#else 
     #error not supported yet
-#endif
-
+#endif 
+ 
 inline int SigEmptySet(sigset_t* set) {
-#if defined _unix_
+#if defined _unix_ 
     return sigemptyset(set);
-#else
+#else 
     Y_UNUSED(set);
     return 0;
-#endif
-}
-
+#endif 
+} 
+ 
 inline int SigFillSet(sigset_t* set) {
-#if defined _unix_
+#if defined _unix_ 
     return sigfillset(set);
-#else
+#else 
     Y_UNUSED(set);
     return 0;
-#endif
-}
-
+#endif 
+} 
+ 
 inline int SigAddSet(sigset_t* set, int signo) {
-#if defined _unix_
+#if defined _unix_ 
     return sigaddset(set, signo);
-#else
+#else 
     Y_UNUSED(set);
     Y_UNUSED(signo);
     return 0;
-#endif
-}
-
+#endif 
+} 
+ 
 inline int SigDelSet(sigset_t* set, int signo) {
-#if defined _unix_
+#if defined _unix_ 
     return sigdelset(set, signo);
-#else
+#else 
     Y_UNUSED(set);
     Y_UNUSED(signo);
     return 0;
-#endif
-}
-
+#endif 
+} 
+ 
 inline int SigIsMember(const sigset_t* set, int signo) {
-#if defined _unix_
+#if defined _unix_ 
     return sigismember(const_cast<sigset_t*>(set), signo);
-#else
+#else 
     Y_UNUSED(set);
     Y_UNUSED(signo);
     return 0;
-#endif
-}
-
+#endif 
+} 
+ 
 inline int SigProcMask(int how, const sigset_t* set, sigset_t* oset) {
-#if defined _unix_
-    return pthread_sigmask(how, set, oset);
-#else
+#if defined _unix_ 
+    return pthread_sigmask(how, set, oset); 
+#else 
     Y_UNUSED(set);
     Y_UNUSED(oset);
     Y_UNUSED(how);
-    return 0;
-#endif
-}
+    return 0; 
+#endif 
+}