Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 of 2.

1 files changed, 81 insertions, 81 deletions

diff --git a/library/cpp/http/fetch/http_socket.cpp b/library/cpp/http/fetch/http_socket.cpp
index 1524ef04a8..7a5b29668c 100644
--- a/library/cpp/http/fetch/http_socket.cpp
+++ b/library/cpp/http/fetch/http_socket.cpp
@@ -7,7 +7,7 @@
 
 #include <gcrypt.h>
 #include <gnutls/gnutls.h>
-#include <util/network/init.h>
+#include <util/network/init.h> 
 #include <util/network/socket.h>
 #include <util/system/mutex.h>
 
@@ -15,75 +15,75 @@
 // HTTPS handler is used as implementation of
 // socketAbstractHandler for work through HTTPS protocol
 
-class socketSecureHandler: public socketRegularHandler {
-protected:
-    bool IsValid_;
-    gnutls_session Session_;
-    gnutls_certificate_credentials Credits_;
-
-public:
-    socketSecureHandler();
-    virtual ~socketSecureHandler();
-
-    virtual bool Good();
-    virtual int Connect(const TAddrList& addrs, TDuration Timeout);
-    virtual void Disconnect();
-    virtual void shutdown();
-    virtual bool send(const char* message, ssize_t messlen);
-    virtual bool peek();
-    virtual ssize_t read(void* buffer, ssize_t buflen);
+class socketSecureHandler: public socketRegularHandler { 
+protected: 
+    bool IsValid_; 
+    gnutls_session Session_; 
+    gnutls_certificate_credentials Credits_; 
+
+public: 
+    socketSecureHandler(); 
+    virtual ~socketSecureHandler(); 
+
+    virtual bool Good(); 
+    virtual int Connect(const TAddrList& addrs, TDuration Timeout); 
+    virtual void Disconnect(); 
+    virtual void shutdown(); 
+    virtual bool send(const char* message, ssize_t messlen); 
+    virtual bool peek(); 
+    virtual ssize_t read(void* buffer, ssize_t buflen); 
 };
 
 /********************************************************/
 /********************************************************/
-static int gcry_pthread_mutex_init(void** priv) {
+static int gcry_pthread_mutex_init(void** priv) { 
     int err = 0;
 
     try {
         TMutex* lock = new TMutex;
         *priv = lock;
-    } catch (...) {
+    } catch (...) { 
         err = -1;
     }
 
     return err;
 }
 
-static int gcry_pthread_mutex_destroy(void** lock) {
+static int gcry_pthread_mutex_destroy(void** lock) { 
     delete static_cast<TMutex*>(*lock);
-
+ 
     return 0;
 }
 
-static int gcry_pthread_mutex_lock(void** lock) {
+static int gcry_pthread_mutex_lock(void** lock) { 
     static_cast<TMutex*>(*lock)->Acquire();
 
     return 0;
 }
 
-static int gcry_pthread_mutex_unlock(void** lock) {
+static int gcry_pthread_mutex_unlock(void** lock) { 
     static_cast<TMutex*>(*lock)->Release();
 
     return 0;
 }
 
 static struct gcry_thread_cbs gcry_threads_pthread =
-    {
-        GCRY_THREAD_OPTION_PTHREAD, NULL,
-        gcry_pthread_mutex_init, gcry_pthread_mutex_destroy,
-        gcry_pthread_mutex_lock, gcry_pthread_mutex_unlock,
-        NULL, NULL, NULL, NULL,
-        NULL, NULL, NULL, NULL};
+    { 
+        GCRY_THREAD_OPTION_PTHREAD, NULL, 
+        gcry_pthread_mutex_init, gcry_pthread_mutex_destroy, 
+        gcry_pthread_mutex_lock, gcry_pthread_mutex_unlock, 
+        NULL, NULL, NULL, NULL, 
+        NULL, NULL, NULL, NULL}; 
 
 /********************************************************/
-struct https_initor {
-    https_initor() {
-        gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
+struct https_initor { 
+    https_initor() { 
+        gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread); 
         gnutls_global_init();
-        InitNetworkSubSystem();
+        InitNetworkSubSystem(); 
     }
 
-    ~https_initor() {
+    ~https_initor() { 
         gnutls_global_deinit();
     }
 };
@@ -91,112 +91,112 @@ struct https_initor {
 static https_initor _initor;
 
 /********************************************************/
-socketSecureHandler::socketSecureHandler()
-    : socketRegularHandler()
-    , IsValid_(false)
-    , Session_()
-    , Credits_()
+socketSecureHandler::socketSecureHandler() 
+    : socketRegularHandler() 
+    , IsValid_(false) 
+    , Session_() 
+    , Credits_() 
 {
 }
 
 /********************************************************/
-socketSecureHandler::~socketSecureHandler() {
-    if (IsValid_)
+socketSecureHandler::~socketSecureHandler() { 
+    if (IsValid_) 
         Disconnect();
 }
 
 /********************************************************/
-bool socketSecureHandler::Good() {
-    return Socket_.Good() && IsValid_;
+bool socketSecureHandler::Good() { 
+    return Socket_.Good() && IsValid_; 
 }
 
 /********************************************************/
-int socketSecureHandler::Connect(const TAddrList& addrs, TDuration Timeout) {
-    IsValid_ = false;
+int socketSecureHandler::Connect(const TAddrList& addrs, TDuration Timeout) { 
+    IsValid_ = false; 
 
     int ret = socketRegularHandler::Connect(addrs, Timeout);
     if (ret)
         return ret;
 
-    gnutls_certificate_allocate_credentials(&Credits_);
-    gnutls_init(&Session_, GNUTLS_CLIENT);
-    gnutls_set_default_priority(Session_);
-    gnutls_credentials_set(Session_, GNUTLS_CRD_CERTIFICATE, Credits_);
+    gnutls_certificate_allocate_credentials(&Credits_); 
+    gnutls_init(&Session_, GNUTLS_CLIENT); 
+    gnutls_set_default_priority(Session_); 
+    gnutls_credentials_set(Session_, GNUTLS_CRD_CERTIFICATE, Credits_); 
 
-    SOCKET fd = Socket_;
-    gnutls_transport_set_ptr(Session_, (gnutls_transport_ptr)fd);
+    SOCKET fd = Socket_; 
+    gnutls_transport_set_ptr(Session_, (gnutls_transport_ptr)fd); 
 
-    ret = gnutls_handshake(Session_);
+    ret = gnutls_handshake(Session_); 
 
-    if (ret < 0) {
+    if (ret < 0) { 
         fprintf(stderr, "*** Handshake failed\n");
         gnutls_perror(ret);
 
-        gnutls_deinit(Session_);
-        if (Credits_) {
-            gnutls_certificate_free_credentials(Credits_);
-            Credits_ = 0;
+        gnutls_deinit(Session_); 
+        if (Credits_) { 
+            gnutls_certificate_free_credentials(Credits_); 
+            Credits_ = 0; 
         }
         return 1;
     }
 
-    IsValid_ = true;
-    return !IsValid_;
+    IsValid_ = true; 
+    return !IsValid_; 
 }
 
 /********************************************************/
-void socketSecureHandler::Disconnect() {
-    if (IsValid_) {
-        gnutls_bye(Session_, GNUTLS_SHUT_RDWR);
-        IsValid_ = false;
-        gnutls_deinit(Session_);
+void socketSecureHandler::Disconnect() { 
+    if (IsValid_) { 
+        gnutls_bye(Session_, GNUTLS_SHUT_RDWR); 
+        IsValid_ = false; 
+        gnutls_deinit(Session_); 
     }
 
-    if (Credits_) {
-        gnutls_certificate_free_credentials(Credits_);
-        Credits_ = 0;
+    if (Credits_) { 
+        gnutls_certificate_free_credentials(Credits_); 
+        Credits_ = 0; 
     }
 
     socketRegularHandler::Disconnect();
 }
 
 /********************************************************/
-void socketSecureHandler::shutdown() {
+void socketSecureHandler::shutdown() { 
 }
 
 /********************************************************/
-bool socketSecureHandler::send(const char* message, ssize_t messlen) {
-    if (!IsValid_)
+bool socketSecureHandler::send(const char* message, ssize_t messlen) { 
+    if (!IsValid_) 
         return false;
-    ssize_t rv = gnutls_record_send(Session_, message, messlen);
+    ssize_t rv = gnutls_record_send(Session_, message, messlen); 
     return rv >= 0;
 }
 
 /********************************************************/
-bool socketSecureHandler::peek() {
+bool socketSecureHandler::peek() { 
     //ssize_t rv = gnutls_record_check_pending(mSession);
     //return rv>0;
     return true;
 }
 
 /********************************************************/
-ssize_t socketSecureHandler::read(void* buffer, ssize_t buflen) {
-    if (!IsValid_)
+ssize_t socketSecureHandler::read(void* buffer, ssize_t buflen) { 
+    if (!IsValid_) 
         return false;
-    return gnutls_record_recv(Session_, (char*)buffer, buflen);
+    return gnutls_record_recv(Session_, (char*)buffer, buflen); 
 }
 
 #endif
 
 /************************************************************/
-socketAbstractHandler* socketHandlerFactory::chooseHandler(const THttpURL& url) {
-    if (url.IsValidGlobal() && url.GetScheme() == THttpURL::SchemeHTTP)
+socketAbstractHandler* socketHandlerFactory::chooseHandler(const THttpURL& url) { 
+    if (url.IsValidGlobal() && url.GetScheme() == THttpURL::SchemeHTTP) 
         return new socketRegularHandler;
 
-#ifdef USE_GNUTLS
-    if (url.IsValidGlobal() && url.GetScheme() == THttpURL::SchemeHTTPS)
+#ifdef USE_GNUTLS 
+    if (url.IsValidGlobal() && url.GetScheme() == THttpURL::SchemeHTTPS) 
         return new socketSecureHandler;
-#endif
+#endif 
 
     return nullptr;
 }