Clang format slam.

net/http/http_auth_handler_ntlm_portable.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_auth_handler_ntlm.h"
 
 #include <stdlib.h>
 // For gethostname
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 54 matching lines @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #if defined(ARCH_CPU_LITTLE_ENDIAN)
 #define IS_LITTLE_ENDIAN 1
-#undef  IS_BIG_ENDIAN
+#undef IS_BIG_ENDIAN
 #elif defined(ARCH_CPU_BIG_ENDIAN)
 #define IS_BIG_ENDIAN 1
-#undef  IS_LITTLE_ENDIAN
+#undef IS_LITTLE_ENDIAN
 #else
 #error "Unknown endianness"
 #endif
 
-#define NTLM_LOG(x) ((void) 0)
+#define NTLM_LOG(x) ((void)0)
 
 //-----------------------------------------------------------------------------
 // This file contains a cross-platform NTLM authentication implementation. It
 // is based on documentation from: http://davenport.sourceforge.net/ntlm.html
 //-----------------------------------------------------------------------------
 
 enum {
-  NTLM_NegotiateUnicode             = 0x00000001,
-  NTLM_NegotiateOEM                 = 0x00000002,
-  NTLM_RequestTarget                = 0x00000004,
-  NTLM_Unknown1                     = 0x00000008,
-  NTLM_NegotiateSign                = 0x00000010,
-  NTLM_NegotiateSeal                = 0x00000020,
-  NTLM_NegotiateDatagramStyle       = 0x00000040,
-  NTLM_NegotiateLanManagerKey       = 0x00000080,
-  NTLM_NegotiateNetware             = 0x00000100,
-  NTLM_NegotiateNTLMKey             = 0x00000200,
-  NTLM_Unknown2                     = 0x00000400,
-  NTLM_Unknown3                     = 0x00000800,
-  NTLM_NegotiateDomainSupplied      = 0x00001000,
+  NTLM_NegotiateUnicode = 0x00000001,
+  NTLM_NegotiateOEM = 0x00000002,
+  NTLM_RequestTarget = 0x00000004,
+  NTLM_Unknown1 = 0x00000008,
+  NTLM_NegotiateSign = 0x00000010,
+  NTLM_NegotiateSeal = 0x00000020,
+  NTLM_NegotiateDatagramStyle = 0x00000040,
+  NTLM_NegotiateLanManagerKey = 0x00000080,
+  NTLM_NegotiateNetware = 0x00000100,
+  NTLM_NegotiateNTLMKey = 0x00000200,
+  NTLM_Unknown2 = 0x00000400,
+  NTLM_Unknown3 = 0x00000800,
+  NTLM_NegotiateDomainSupplied = 0x00001000,
   NTLM_NegotiateWorkstationSupplied = 0x00002000,
-  NTLM_NegotiateLocalCall           = 0x00004000,
-  NTLM_NegotiateAlwaysSign          = 0x00008000,
-  NTLM_TargetTypeDomain             = 0x00010000,
-  NTLM_TargetTypeServer             = 0x00020000,
-  NTLM_TargetTypeShare              = 0x00040000,
-  NTLM_NegotiateNTLM2Key            = 0x00080000,
-  NTLM_RequestInitResponse          = 0x00100000,
-  NTLM_RequestAcceptResponse        = 0x00200000,
-  NTLM_RequestNonNTSessionKey       = 0x00400000,
-  NTLM_NegotiateTargetInfo          = 0x00800000,
-  NTLM_Unknown4                     = 0x01000000,
-  NTLM_Unknown5                     = 0x02000000,
-  NTLM_Unknown6                     = 0x04000000,
-  NTLM_Unknown7                     = 0x08000000,
-  NTLM_Unknown8                     = 0x10000000,
-  NTLM_Negotiate128                 = 0x20000000,
-  NTLM_NegotiateKeyExchange         = 0x40000000,
-  NTLM_Negotiate56                  = 0x80000000
+  NTLM_NegotiateLocalCall = 0x00004000,
+  NTLM_NegotiateAlwaysSign = 0x00008000,
+  NTLM_TargetTypeDomain = 0x00010000,
+  NTLM_TargetTypeServer = 0x00020000,
+  NTLM_TargetTypeShare = 0x00040000,
+  NTLM_NegotiateNTLM2Key = 0x00080000,
+  NTLM_RequestInitResponse = 0x00100000,
+  NTLM_RequestAcceptResponse = 0x00200000,
+  NTLM_RequestNonNTSessionKey = 0x00400000,
+  NTLM_NegotiateTargetInfo = 0x00800000,
+  NTLM_Unknown4 = 0x01000000,
+  NTLM_Unknown5 = 0x02000000,
+  NTLM_Unknown6 = 0x04000000,
+  NTLM_Unknown7 = 0x08000000,
+  NTLM_Unknown8 = 0x10000000,
+  NTLM_Negotiate128 = 0x20000000,
+  NTLM_NegotiateKeyExchange = 0x40000000,
+  NTLM_Negotiate56 = 0x80000000
 };
 
 // We send these flags with our type 1 message.
 enum {
-  NTLM_TYPE1_FLAGS = (NTLM_NegotiateUnicode |
-                      NTLM_NegotiateOEM |
-                      NTLM_RequestTarget |
-                      NTLM_NegotiateNTLMKey |
-                      NTLM_NegotiateAlwaysSign |
-                      NTLM_NegotiateNTLM2Key)
+  NTLM_TYPE1_FLAGS =
+      (NTLM_NegotiateUnicode | NTLM_NegotiateOEM | NTLM_RequestTarget |
+       NTLM_NegotiateNTLMKey |
+       NTLM_NegotiateAlwaysSign |
+       NTLM_NegotiateNTLM2Key)
 };
 
 static const char NTLM_SIGNATURE[] = "NTLMSSP";
-static const char NTLM_TYPE1_MARKER[] = { 0x01, 0x00, 0x00, 0x00 };
-static const char NTLM_TYPE2_MARKER[] = { 0x02, 0x00, 0x00, 0x00 };
-static const char NTLM_TYPE3_MARKER[] = { 0x03, 0x00, 0x00, 0x00 };
+static const char NTLM_TYPE1_MARKER[] = {0x01, 0x00, 0x00, 0x00};
+static const char NTLM_TYPE2_MARKER[] = {0x02, 0x00, 0x00, 0x00};
+static const char NTLM_TYPE3_MARKER[] = {0x03, 0x00, 0x00, 0x00};
 
 enum {
   NTLM_TYPE1_HEADER_LEN = 32,
   NTLM_TYPE2_HEADER_LEN = 32,
   NTLM_TYPE3_HEADER_LEN = 64,
-
   LM_HASH_LEN = 16,
   LM_RESP_LEN = 24,
-
   NTLM_HASH_LEN = 16,
   NTLM_RESP_LEN = 24
 };
 
 //-----------------------------------------------------------------------------
 
 // The return value of this function controls whether or not the LM hash will
 // be included in response to a NTLM challenge.
 //
 // In Mozilla, this function returns the value of the boolean preference
 // "network.ntlm.send-lm-response".  By default, the preference is disabled
 // since servers should almost never need the LM hash, and the LM hash is what
 // makes NTLM authentication less secure.  See
 // https://bugzilla.mozilla.org/show_bug.cgi?id=250691 for further details.
 //
 // We just return a hardcoded false.
 static bool SendLM() {
   return false;
 }
 
 //-----------------------------------------------------------------------------
 
-#define LogFlags(x) ((void) 0)
-#define LogBuf(a, b, c) ((void) 0)
-#define LogToken(a, b, c) ((void) 0)
+#define LogFlags(x) ((void)0)
+#define LogBuf(a, b, c) ((void)0)
+#define LogToken(a, b, c) ((void)0)
 
 //-----------------------------------------------------------------------------
 
 // Byte order swapping.
 #define SWAP16(x) ((((x) & 0xff) << 8) | (((x) >> 8) & 0xff))
 #define SWAP32(x) ((SWAP16((x) & 0xffff) << 16) | (SWAP16((x) >> 16)))
 
 static void* WriteBytes(void* buf, const void* data, uint32 data_len) {
   memcpy(buf, data, data_len);
   return static_cast<char*>(buf) + data_len;
@@ skipping 19 matching lines @@
 }
 
 #ifdef IS_BIG_ENDIAN
 /**
  * WriteUnicodeLE copies a unicode string from one buffer to another.  The
  * resulting unicode string is in little-endian format.  The input string is
  * assumed to be in the native endianness of the local machine.  It is safe
  * to pass the same buffer as both input and output, which is a handy way to
  * convert the unicode buffer to little-endian on big-endian platforms.
  */
-static void* WriteUnicodeLE(
-    void* buf, const base::char16* str, uint32 str_len) {
+static void* WriteUnicodeLE(void* buf,
+                            const base::char16* str,
+                            uint32 str_len) {
   // Convert input string from BE to LE.
   uint8* cursor = static_cast<uint8*>(buf);
-  const uint8* input  = reinterpret_cast<const uint8*>(str);
+  const uint8* input = reinterpret_cast<const uint8*>(str);
   for (uint32 i = 0; i < str_len; ++i, input += 2, cursor += 2) {
     // Allow for the case where |buf == str|.
     uint8 temp = input[0];
     cursor[0] = input[1];
     cursor[1] = temp;
   }
   return buf;
 }
 #endif
 
 static uint16 ReadUint16(const uint8*& buf) {
-  uint16 x = (static_cast<uint16>(buf[0]))      |
-             (static_cast<uint16>(buf[1]) << 8);
+  uint16 x = (static_cast<uint16>(buf[0])) | (static_cast<uint16>(buf[1]) << 8);
   buf += sizeof(x);
   return x;
 }
 
 static uint32 ReadUint32(const uint8*& buf) {
-  uint32 x = (static_cast<uint32>(buf[0]))       |
-             (static_cast<uint32>(buf[1]) << 8)  |
-             (static_cast<uint32>(buf[2]) << 16) |
-             (static_cast<uint32>(buf[3]) << 24);
+  uint32 x =
+      (static_cast<uint32>(buf[0])) | (static_cast<uint32>(buf[1]) << 8) |
+      (static_cast<uint32>(buf[2]) << 16) | (static_cast<uint32>(buf[3]) << 24);
   buf += sizeof(x);
   return x;
 }
 
 //-----------------------------------------------------------------------------
 
 // LM_Hash computes the LM hash of the given password.
 //
 // param password
 //       unicode password.
 // param hash
 //       16-byte result buffer
 //
 // Note: This function is not being used because our SendLM() function always
 // returns false.
 static void LM_Hash(const base::string16& password, uint8* hash) {
   static const uint8 LM_MAGIC[] = "KGS!@#$%";
 
   // Convert password to OEM character set.  We'll just use the native
   // filesystem charset.
   std::string passbuf = base::SysWideToNativeMB(base::UTF16ToWide(password));
   StringToUpperASCII(&passbuf);
   passbuf.resize(14, '\0');
 
   uint8 k1[8], k2[8];
-  DESMakeKey(reinterpret_cast<const uint8*>(passbuf.data())    , k1);
+  DESMakeKey(reinterpret_cast<const uint8*>(passbuf.data()), k1);
   DESMakeKey(reinterpret_cast<const uint8*>(passbuf.data()) + 7, k2);
   ZapString(&passbuf);
 
   // Use password keys to hash LM magic string twice.
   DESEncrypt(k1, LM_MAGIC, hash);
   DESEncrypt(k2, LM_MAGIC, hash + 8);
 }
 
 // NTLM_Hash computes the NTLM hash of the given password.
 //
 // param password
 //       null-terminated unicode password.
 // param hash
 //       16-byte result buffer
 static void NTLM_Hash(const base::string16& password, uint8* hash) {
 #ifdef IS_BIG_ENDIAN
   uint32 len = password.length();
   uint8* passbuf;
 
   passbuf = static_cast<uint8*>(malloc(len * 2));
   WriteUnicodeLE(passbuf, password.data(), len);
   weak_crypto::MD4Sum(passbuf, len * 2, hash);
 
   ZapBuf(passbuf, len * 2);
   free(passbuf);
 #else
   weak_crypto::MD4Sum(reinterpret_cast<const uint8*>(password.data()),
-                      password.length() * 2, hash);
+                      password.length() * 2,
+                      hash);
 #endif
 }
 
 //-----------------------------------------------------------------------------
 
 // LM_Response generates the LM response given a 16-byte password hash and the
 // challenge from the Type-2 message.
 //
 // param hash
 //       16-byte password hash
 // param challenge
 //       8-byte challenge from Type-2 message
 // param response
 //       24-byte buffer to contain the LM response upon return
 static void LM_Response(const uint8* hash,
                         const uint8* challenge,
                         uint8* response) {
   uint8 keybytes[21], k1[8], k2[8], k3[8];
 
   memcpy(keybytes, hash, 16);
   ZapBuf(keybytes + 16, 5);
 
-  DESMakeKey(keybytes     , k1);
-  DESMakeKey(keybytes +  7, k2);
+  DESMakeKey(keybytes, k1);
+  DESMakeKey(keybytes + 7, k2);
   DESMakeKey(keybytes + 14, k3);
 
   DESEncrypt(k1, challenge, response);
   DESEncrypt(k2, challenge, response + 8);
   DESEncrypt(k3, challenge, response + 16);
 }
 
 //-----------------------------------------------------------------------------
 
 // Returns OK or a network error code.
@@ skipping 31 matching lines @@
   // 16 : supplied domain security buffer (empty)
   cursor = WriteSecBuf(cursor, 0, 0);
 
   // 24 : supplied workstation security buffer (empty)
   cursor = WriteSecBuf(cursor, 0, 0);
 
   return OK;
 }
 
 struct Type2Msg {
-  uint32      flags;         // NTLM_Xxx bitwise combination
-  uint8       challenge[8];  // 8 byte challenge
-  const void* target;        // target string (type depends on flags)
-  uint32      target_len;    // target length in bytes
+  uint32 flags;        // NTLM_Xxx bitwise combination
+  uint8 challenge[8];  // 8 byte challenge
+  const void* target;  // target string (type depends on flags)
+  uint32 target_len;   // target length in bytes
 };
 
 // Returns OK or a network error code.
 // TODO(wtc): This function returns ERR_UNEXPECTED when the input message is
 // invalid.  We should return a better error code.
 static int ParseType2Msg(const void* in_buf, uint32 in_len, Type2Msg* msg) {
   // Make sure in_buf is long enough to contain a meaningful type2 msg.
   //
   // 0  NTLMSSP Signature
   // 8  NTLM Message Type
   // 12 Target Name
   // 20 Flags
   // 24 Challenge
   // 32 end of header, start of optional data blocks
   //
   if (in_len < NTLM_TYPE2_HEADER_LEN)
     return ERR_UNEXPECTED;
 
-  const uint8* cursor = (const uint8*) in_buf;
+  const uint8* cursor = (const uint8*)in_buf;
 
   // verify NTLMSSP signature
   if (memcmp(cursor, NTLM_SIGNATURE, sizeof(NTLM_SIGNATURE)) != 0)
     return ERR_UNEXPECTED;
   cursor += sizeof(NTLM_SIGNATURE);
 
   // verify Type-2 marker
   if (memcmp(cursor, NTLM_TYPE2_MARKER, sizeof(NTLM_TYPE2_MARKER)) != 0)
     return ERR_UNEXPECTED;
   cursor += sizeof(NTLM_TYPE2_MARKER);
 
   // read target name security buffer
   uint32 target_len = ReadUint16(cursor);
-  ReadUint16(cursor);  // discard next 16-bit value
+  ReadUint16(cursor);                  // discard next 16-bit value
   uint32 offset = ReadUint32(cursor);  // get offset from in_buf
   msg->target_len = 0;
   msg->target = NULL;
   // Check the offset / length combo is in range of the input buffer, including
   // integer overflow checking.
   if (offset + target_len > offset && offset + target_len <= in_len) {
     msg->target_len = target_len;
-    msg->target = ((const uint8*) in_buf) + offset;
+    msg->target = ((const uint8*)in_buf) + offset;
   }
 
   // read flags
   msg->flags = ReadUint32(cursor);
 
   // read challenge
   memcpy(msg->challenge, cursor, sizeof(msg->challenge));
   cursor += sizeof(msg->challenge);
 
   NTLM_LOG(("NTLM type 2 message:\n"));
-  LogBuf("target", (const uint8*) msg->target, msg->target_len);
-  LogBuf("flags", (const uint8*) &msg->flags, 4);
+  LogBuf("target", (const uint8*)msg->target, msg->target_len);
+  LogBuf("flags", (const uint8*)&msg->flags, 4);
   LogFlags(msg->flags);
   LogBuf("challenge", msg->challenge, sizeof(msg->challenge));
 
   // We currently do not implement LMv2/NTLMv2 or NTLM2 responses,
   // so we can ignore target information.  We may want to enable
   // support for these alternate mechanisms in the future.
   return OK;
 }
 
 static void GenerateRandom(uint8* output, size_t n) {
@@ skipping 15 matching lines @@
 
   int rv;
   Type2Msg msg;
 
   rv = ParseType2Msg(in_buf, in_len, &msg);
   if (rv != OK)
     return rv;
 
   bool unicode = (msg.flags & NTLM_NegotiateUnicode) != 0;
 
-  // Temporary buffers for unicode strings
+// Temporary buffers for unicode strings
 #ifdef IS_BIG_ENDIAN
   base::string16 ucs_domain_buf, ucs_user_buf;
 #endif
   base::string16 ucs_host_buf;
   // Temporary buffers for oem strings
   std::string oem_domain_buf, oem_user_buf;
   // Pointers and lengths for the string buffers; encoding is unicode if
   // the "negotiate unicode" flag was set in the Type-2 message.
   const void* domain_ptr;
   const void* user_ptr;
   const void* host_ptr;
   uint32 domain_len, user_len, host_len;
 
   //
   // Get domain name.
   //
   if (unicode) {
 #ifdef IS_BIG_ENDIAN
     ucs_domain_buf = domain;
     domain_ptr = ucs_domain_buf.data();
     domain_len = ucs_domain_buf.length() * 2;
     WriteUnicodeLE(const_cast<void*>(domain_ptr),
-                   (const base::char16*) domain_ptr,
+                   (const base::char16*)domain_ptr,
                    ucs_domain_buf.length());
 #else
     domain_ptr = domain.data();
     domain_len = domain.length() * 2;
 #endif
   } else {
     oem_domain_buf = base::SysWideToNativeMB(base::UTF16ToWide(domain));
     domain_ptr = oem_domain_buf.data();
     domain_len = oem_domain_buf.length();
   }
 
   //
   // Get user name.
   //
   if (unicode) {
 #ifdef IS_BIG_ENDIAN
     ucs_user_buf = username;
     user_ptr = ucs_user_buf.data();
     user_len = ucs_user_buf.length() * 2;
-    WriteUnicodeLE(const_cast<void*>(user_ptr), (const base::char16*) user_ptr,
+    WriteUnicodeLE(const_cast<void*>(user_ptr),
+                   (const base::char16*)user_ptr,
                    ucs_user_buf.length());
 #else
     user_ptr = username.data();
     user_len = username.length() * 2;
 #endif
   } else {
     oem_user_buf = base::SysWideToNativeMB(base::UTF16ToWide(username));
     user_ptr = oem_user_buf.data();
     user_len = oem_user_buf.length();
   }
 
   //
   // Get workstation name (use local machine's hostname).
   //
   if (unicode) {
     // hostname is ASCII, so we can do a simple zero-pad expansion:
     ucs_host_buf.assign(hostname.begin(), hostname.end());
     host_ptr = ucs_host_buf.data();
     host_len = ucs_host_buf.length() * 2;
 #ifdef IS_BIG_ENDIAN
-    WriteUnicodeLE(const_cast<void*>(host_ptr), (const base::char16*) host_ptr,
+    WriteUnicodeLE(const_cast<void*>(host_ptr),
+                   (const base::char16*)host_ptr,
                    ucs_host_buf.length());
 #endif
   } else {
     host_ptr = hostname.data();
     host_len = hostname.length();
   }
 
   //
   // Now that we have generated all of the strings, we can allocate out_buf.
   //
@@ skipping 83 matching lines @@
   cursor = WriteDWORD(cursor, msg.flags & NTLM_TYPE1_FLAGS);
 
   return OK;
 }
 
 // NTLM authentication is specified in "NTLM Over HTTP Protocol Specification"
 // [MS-NTHT].
 
 // static
 HttpAuthHandlerNTLM::GenerateRandomProc
-HttpAuthHandlerNTLM::generate_random_proc_ = GenerateRandom;
+    HttpAuthHandlerNTLM::generate_random_proc_ = GenerateRandom;
 
 // static
-HttpAuthHandlerNTLM::HostNameProc
-HttpAuthHandlerNTLM::get_host_name_proc_ = GetHostName;
+HttpAuthHandlerNTLM::HostNameProc HttpAuthHandlerNTLM::get_host_name_proc_ =
+    GetHostName;
 
 HttpAuthHandlerNTLM::HttpAuthHandlerNTLM() {
 }
 
 bool HttpAuthHandlerNTLM::NeedsIdentity() {
   // This gets called for each round-trip.  Only require identity on
   // the first call (when auth_data_ is empty).  On subsequent calls,
   // we use the initially established identity.
   return auth_data_.empty();
 }
 
 bool HttpAuthHandlerNTLM::AllowsDefaultCredentials() {
   // Default credentials are not supported in the portable implementation of
   // NTLM, but are supported in the SSPI implementation.
   return false;
 }
 
 int HttpAuthHandlerNTLM::InitializeBeforeFirstChallenge() {
   return OK;
 }
 
 HttpAuthHandlerNTLM::~HttpAuthHandlerNTLM() {
   credentials_.Zap();
 }
 
 // static
 HttpAuthHandlerNTLM::GenerateRandomProc
-HttpAuthHandlerNTLM::SetGenerateRandomProc(
-    GenerateRandomProc proc) {
+HttpAuthHandlerNTLM::SetGenerateRandomProc(GenerateRandomProc proc) {
   GenerateRandomProc old_proc = generate_random_proc_;
   generate_random_proc_ = proc;
   return old_proc;
 }
 
 // static
 HttpAuthHandlerNTLM::HostNameProc HttpAuthHandlerNTLM::SetHostNameProc(
     HostNameProc proc) {
   HostNameProc old_proc = get_host_name_proc_;
   get_host_name_proc_ = proc;
@@ skipping 14 matching lines @@
 
   // If in_token is non-null, then assume it contains a type 2 message...
   if (in_token) {
     LogToken("in-token", in_token, in_token_len);
     std::string hostname = get_host_name_proc_();
     if (hostname.empty())
       return ERR_UNEXPECTED;
     uint8 rand_buf[8];
     generate_random_proc_(rand_buf, 8);
     rv = GenerateType3Msg(domain_,
-                          credentials_.username(), credentials_.password(),
-                          hostname, rand_buf,
-                          in_token, in_token_len, out_token, out_token_len);
+                          credentials_.username(),
+                          credentials_.password(),
+                          hostname,
+                          rand_buf,
+                          in_token,
+                          in_token_len,
+                          out_token,
+                          out_token_len);
   } else {
     rv = GenerateType1Msg(out_token, out_token_len);
   }
 
   if (rv == OK)
     LogToken("out-token", *out_token, *out_token_len);
 
   return rv;
 }
 
@@ skipping 12 matching lines @@
   // NOTE: Default credentials are not supported for the portable implementation
   // of NTLM.
   scoped_ptr<HttpAuthHandler> tmp_handler(new HttpAuthHandlerNTLM);
   if (!tmp_handler->InitFromChallenge(challenge, target, origin, net_log))
     return ERR_INVALID_RESPONSE;
   handler->swap(tmp_handler);
   return OK;
 }
 
 }  // namespace net