zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/HttpParser.cpp

@@ -1,42 +1,42 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceUtil/Config.h>
-#include <Ice/HttpParser.h>
-#include <Ice/LocalException.h>
-#include <IceUtil/StringUtil.h>
+#include "HttpParser.h"
+#include "Ice/Config.h"
+#include "Ice/StringUtil.h"
+
+#include <cassert>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceInternal::WebSocketException::WebSocketException(const string& r) :
-    reason(r)
+namespace
 {
-}
+    // Convert a byte array to a string
+    string bytesToString(const byte* begin, const byte* end)
+    {
+        assert(begin);
+        assert(end);
 
-IceInternal::HttpParser::HttpParser() :
-    _type(TypeUnknown),
-    _versionMajor(0),
-    _versionMinor(0),
-    _status(0),
-    _state(StateInit)
-{
+        // NOLINTNEXTLINE(clang-analyzer-cplusplus.StringChecker)
+        return string{reinterpret_cast<const char*>(begin), reinterpret_cast<const char*>(end)};
+    }
 }
 
-const Ice::Byte*
-IceInternal::HttpParser::isCompleteMessage(const Ice::Byte* begin, const Ice::Byte* end) const
+IceInternal::WebSocketException::WebSocketException(string r) : reason(std::move(r)) {}
+
+const byte*
+IceInternal::HttpParser::isCompleteMessage(const byte* begin, const byte* end) const
 {
-    const Ice::Byte* p = begin;
+    const byte* p = begin;
 
     //
     // Skip any leading CR-LF characters.
     //
-    while(p < end)
+    while (p < end)
     {
         char ch = static_cast<char>(*p);
-        if(ch != '\r' && ch != '\n')
+        if (ch != '\r' && ch != '\n')
         {
             break;
         }
@@ -47,12 +47,12 @@ IceInternal::HttpParser::isCompleteMessage(const Ice::Byte* begin, const Ice::By
     // Look for adjacent CR-LF/CR-LF or LF/LF.
     //
     bool seenFirst = false;
-    while(p < end)
+    while (p < end)
     {
         char ch = static_cast<char>(*p++);
-        if(ch == '\n')
+        if (ch == '\n')
         {
-            if(seenFirst)
+            if (seenFirst)
             {
                 return p;
             }
@@ -61,548 +61,548 @@ IceInternal::HttpParser::isCompleteMessage(const Ice::Byte* begin, const Ice::By
                 seenFirst = true;
             }
         }
-        else if(ch != '\r')
+        else if (ch != '\r')
         {
             seenFirst = false;
         }
     }
 
-    return 0;
+    return nullptr;
 }
 
 bool
-IceInternal::HttpParser::parse(const Ice::Byte* begin, const Ice::Byte* end)
+IceInternal::HttpParser::parse(const byte* begin, const byte* end)
 {
-    const Ice::Byte* p = begin;
-    const Ice::Byte* start = 0;
+    const byte* p = begin;
+    const byte* start = nullptr;
     const string::value_type CR = '\r';
     const string::value_type LF = '\n';
 
-    if(_state == StateComplete)
+    if (_state == StateComplete)
     {
         _state = StateInit;
     }
 
-    while(p != end && _state != StateComplete)
+    while (p != end && _state != StateComplete)
     {
         char c = static_cast<char>(*p);
 
-        switch(_state)
+        switch (_state)
         {
-        case StateInit:
-        {
-            _method.clear();
-            _uri.clear();
-            _versionMajor = -1;
-            _versionMinor = -1;
-            _status = -1;
-            _reason.clear();
-            _headers.clear();
-            _state = StateType;
-            continue;
-        }
-        case StateType:
-        {
-            if(c == CR || c == LF)
+            case StateInit:
             {
-                break;
-            }
-            else if(c == 'H')
-            {
-                //
-                // Could be the start of "HTTP/1.1" or "HEAD".
-                //
-                _state = StateTypeCheck;
-                break;
-            }
-            else
-            {
-                _state = StateRequest;
+                _method.clear();
+                _uri.clear();
+                _versionMajor = -1;
+                _versionMinor = -1;
+                _status = -1;
+                _reason.clear();
+                _headers.clear();
+                _state = StateType;
                 continue;
             }
-        }
-        case StateTypeCheck:
-        {
-            if(c == 'T') // Continuing "H_T_TP/1.1"
+            case StateType:
             {
-                _state = StateResponse;
-            }
-            else if(c == 'E') // Expecting "HEAD"
-            {
-                _state = StateRequest;
-                _method.push_back('H');
-                _method.push_back('E');
+                if (c == CR || c == LF)
+                {
+                    break;
+                }
+                else if (c == 'H')
+                {
+                    //
+                    // Could be the start of "HTTP/1.1" or "HEAD".
+                    //
+                    _state = StateTypeCheck;
+                    break;
+                }
+                else
+                {
+                    _state = StateRequest;
+                    continue;
+                }
             }
-            else
+            case StateTypeCheck:
             {
-                throw WebSocketException("malformed request or response");
+                if (c == 'T') // Continuing "H_T_TP/1.1"
+                {
+                    _state = StateResponse;
+                }
+                else if (c == 'E') // Expecting "HEAD"
+                {
+                    _state = StateRequest;
+                    _method.push_back('H');
+                    _method.push_back('E');
+                }
+                else
+                {
+                    throw WebSocketException("malformed request or response");
+                }
+                break;
             }
-            break;
-        }
-        case StateRequest:
-        {
-            _type = TypeRequest;
-            _state = StateRequestMethod;
-            continue;
-        }
-        case StateRequestMethod:
-        {
-            if(c == ' ' || c == CR || c == LF)
+            case StateRequest:
             {
-                _state = StateRequestMethodSP;
+                _type = TypeRequest;
+                _state = StateRequestMethod;
                 continue;
             }
-            _method.push_back(c);
-            break;
-        }
-        case StateRequestMethodSP:
-        {
-            if(c == ' ')
+            case StateRequestMethod:
             {
+                if (c == ' ' || c == CR || c == LF)
+                {
+                    _state = StateRequestMethodSP;
+                    continue;
+                }
+                _method.push_back(c);
                 break;
             }
-            else if(c == CR || c == LF)
+            case StateRequestMethodSP:
             {
-                throw WebSocketException("malformed request");
-            }
-            _state = StateRequestURI;
-            continue;
-        }
-        case StateRequestURI:
-        {
-            if(c == ' ' || c == CR || c == LF)
-            {
-                _state = StateRequestURISP;
+                if (c == ' ')
+                {
+                    break;
+                }
+                else if (c == CR || c == LF)
+                {
+                    throw WebSocketException("malformed request");
+                }
+                _state = StateRequestURI;
                 continue;
             }
-            _uri.push_back(c);
-            break;
-        }
-        case StateRequestURISP:
-        {
-            if(c == ' ')
+            case StateRequestURI:
             {
+                if (c == ' ' || c == CR || c == LF)
+                {
+                    _state = StateRequestURISP;
+                    continue;
+                }
+                _uri.push_back(c);
                 break;
             }
-            else if(c == CR || c == LF)
-            {
-                throw WebSocketException("malformed request");
-            }
-            _state = StateVersion;
-            continue;
-        }
-        case StateRequestLF:
-        {
-            if(c != LF)
+            case StateRequestURISP:
             {
-                throw WebSocketException("malformed request");
-            }
-            _state = StateHeaderFieldStart;
-            break;
-        }
-        case StateHeaderFieldStart:
-        {
-            //
-            // We've already seen a LF to reach this state.
-            //
-            // Another CR or LF indicates the end of the header fields.
-            //
-            if(c == CR)
-            {
-                _state = StateHeaderFieldEndLF;
-                break;
+                if (c == ' ')
+                {
+                    break;
+                }
+                else if (c == CR || c == LF)
+                {
+                    throw WebSocketException("malformed request");
+                }
+                _state = StateVersion;
+                continue;
             }
-            else if(c == LF)
+            case StateRequestLF:
             {
-                _state = StateComplete;
+                if (c != LF)
+                {
+                    throw WebSocketException("malformed request");
+                }
+                _state = StateHeaderFieldStart;
                 break;
             }
-            else if(c == ' ')
+            case StateHeaderFieldStart:
             {
                 //
-                // Could be a continuation line.
+                // We've already seen a LF to reach this state.
                 //
-                _state = StateHeaderFieldContStart;
-                break;
-            }
-
-            _state = StateHeaderFieldNameStart;
-            continue;
-        }
-        case StateHeaderFieldContStart:
-        {
-            if(c == ' ')
-            {
-                break;
-            }
-
-            _state = StateHeaderFieldCont;
-            start = p;
-            continue;
-        }
-        case StateHeaderFieldCont:
-        {
-            if(c == CR || c == LF)
-            {
-                if(p > start)
+                // Another CR or LF indicates the end of the header fields.
+                //
+                if (c == CR)
                 {
-                    if(_headerName.empty())
-                    {
-                        throw WebSocketException("malformed header");
-                    }
-                    HeaderFields::iterator q = _headers.find(_headerName);
-                    assert(q != _headers.end());
-                    q->second.second = q->second.second + " " + string(start, p);
-                    _state = c == CR ? StateHeaderFieldLF : StateHeaderFieldStart;
+                    _state = StateHeaderFieldEndLF;
+                    break;
                 }
-                else
+                else if (c == LF)
+                {
+                    _state = StateComplete;
+                    break;
+                }
+                else if (c == ' ')
                 {
                     //
-                    // Could mark the end of the header fields.
+                    // Could be a continuation line.
                     //
-                    _state = c == CR ? StateHeaderFieldEndLF : StateComplete;
+                    _state = StateHeaderFieldContStart;
+                    break;
                 }
-            }
 
-            break;
-        }
-        case StateHeaderFieldNameStart:
-        {
-            assert(c != ' ');
-            start = p;
-            _headerName.clear();
-            _state = StateHeaderFieldName;
-            continue;
-        }
-        case StateHeaderFieldName:
-        {
-            if(c == ' ' || c == ':')
-            {
-                _state = StateHeaderFieldNameEnd;
+                _state = StateHeaderFieldNameStart;
                 continue;
             }
-            else if(c == CR || c == LF)
+            case StateHeaderFieldContStart:
             {
-                throw WebSocketException("malformed header");
+                if (c == ' ')
+                {
+                    break;
+                }
+
+                _state = StateHeaderFieldCont;
+                start = p;
+                continue;
             }
-            break;
-        }
-        case StateHeaderFieldNameEnd:
-        {
-            if(_headerName.empty())
+            case StateHeaderFieldCont:
             {
-                _headerName = IceUtilInternal::toLower(string(start, p));
-                HeaderFields::iterator q = _headers.find(_headerName);
-                //
-                // Add a placeholder entry if necessary.
-                //
-                if(q == _headers.end())
+                if (c == CR || c == LF)
                 {
-                    _headers[_headerName] = make_pair(string(start, p), "");
+                    if (p > start)
+                    {
+                        if (_headerName.empty())
+                        {
+                            throw WebSocketException("malformed header");
+                        }
+                        auto q = _headers.find(_headerName);
+                        assert(q != _headers.end());
+                        q->second.second = q->second.second + " " + bytesToString(start, p);
+                        _state = c == CR ? StateHeaderFieldLF : StateHeaderFieldStart;
+                    }
+                    else
+                    {
+                        //
+                        // Could mark the end of the header fields.
+                        //
+                        _state = c == CR ? StateHeaderFieldEndLF : StateComplete;
+                    }
                 }
-            }
 
-            if(c == ' ')
-            {
                 break;
             }
-            else if(c != ':' || p == start)
+            case StateHeaderFieldNameStart:
             {
-                throw WebSocketException("malformed header");
+                assert(c != ' ');
+                start = p;
+                _headerName.clear();
+                _state = StateHeaderFieldName;
+                continue;
             }
-
-            _state = StateHeaderFieldValueStart;
-            break;
-        }
-        case StateHeaderFieldValueStart:
-        {
-            if(c == ' ')
+            case StateHeaderFieldName:
             {
+                if (c == ' ' || c == ':')
+                {
+                    _state = StateHeaderFieldNameEnd;
+                    continue;
+                }
+                else if (c == CR || c == LF)
+                {
+                    throw WebSocketException("malformed header");
+                }
                 break;
             }
-
-            //
-            // Check for "Name:\r\n"
-            //
-            if(c == CR)
+            case StateHeaderFieldNameEnd:
             {
-                _state = StateHeaderFieldLF;
+                if (_headerName.empty())
+                {
+                    _headerName = IceInternal::toLower(bytesToString(start, p));
+                    auto q = _headers.find(_headerName);
+                    //
+                    // Add a placeholder entry if necessary.
+                    //
+                    if (q == _headers.end())
+                    {
+                        _headers[_headerName] = make_pair(bytesToString(start, p), "");
+                    }
+                }
+
+                if (c == ' ')
+                {
+                    break;
+                }
+                else if (c != ':' || p == start)
+                {
+                    throw WebSocketException("malformed header");
+                }
+
+                _state = StateHeaderFieldValueStart;
                 break;
             }
-            else if(c == LF)
+            case StateHeaderFieldValueStart:
             {
-                _state = StateHeaderFieldStart;
-                break;
-            }
+                if (c == ' ')
+                {
+                    break;
+                }
 
-            start = p;
-            _state = StateHeaderFieldValue;
-            continue;
-        }
-        case StateHeaderFieldValue:
-        {
-            if(c == CR || c == LF)
-            {
-                _state = StateHeaderFieldValueEnd;
+                //
+                // Check for "Name:\r\n"
+                //
+                if (c == CR)
+                {
+                    _state = StateHeaderFieldLF;
+                    break;
+                }
+                else if (c == LF)
+                {
+                    _state = StateHeaderFieldStart;
+                    break;
+                }
+
+                start = p;
+                _state = StateHeaderFieldValue;
                 continue;
             }
-            break;
-        }
-        case StateHeaderFieldValueEnd:
-        {
-            assert(c == CR || c == LF);
-            if(p > start)
+            case StateHeaderFieldValue:
             {
-                HeaderFields::iterator q = _headers.find(_headerName);
-                if(q == _headers.end())
+                if (c == CR || c == LF)
                 {
-                    throw WebSocketException("malformed header");
+                    _state = StateHeaderFieldValueEnd;
+                    continue;
                 }
-                else if(q->second.second.empty())
+                break;
+            }
+            case StateHeaderFieldValueEnd:
+            {
+                assert(c == CR || c == LF);
+                if (p > start)
                 {
-                    q->second.second = string(start, p);
+                    auto q = _headers.find(_headerName);
+                    if (q == _headers.end())
+                    {
+                        throw WebSocketException("malformed header");
+                    }
+                    else if (q->second.second.empty())
+                    {
+                        q->second.second = bytesToString(start, p);
+                    }
+                    else
+                    {
+                        q->second.second = q->second.second + ", " + bytesToString(start, p);
+                    }
+                }
+
+                if (c == CR)
+                {
+                    _state = StateHeaderFieldLF;
                 }
                 else
                 {
-                    q->second.second = q->second.second + ", " + string(start, p);
+                    _state = StateHeaderFieldStart;
                 }
+                break;
             }
-
-            if(c == CR)
-            {
-                _state = StateHeaderFieldLF;
-            }
-            else
+            case StateHeaderFieldLF:
             {
+                if (c != LF)
+                {
+                    throw WebSocketException("malformed header");
+                }
                 _state = StateHeaderFieldStart;
+                break;
             }
-            break;
-        }
-        case StateHeaderFieldLF:
-        {
-            if(c != LF)
-            {
-                throw WebSocketException("malformed header");
-            }
-            _state = StateHeaderFieldStart;
-            break;
-        }
-        case StateHeaderFieldEndLF:
-        {
-            if(c != LF)
-            {
-                throw WebSocketException("malformed header");
-            }
-            _state = StateComplete;
-            break;
-        }
-        case StateVersion:
-        {
-            if(c != 'H')
-            {
-                throw WebSocketException("malformed version");
-            }
-            _state = StateVersionH;
-            break;
-        }
-        case StateVersionH:
-        {
-            if(c != 'T')
-            {
-                throw WebSocketException("malformed version");
-            }
-            _state = StateVersionHT;
-            break;
-        }
-        case StateVersionHT:
-        {
-            if(c != 'T')
-            {
-                throw WebSocketException("malformed version");
-            }
-            _state = StateVersionHTT;
-            break;
-        }
-        case StateVersionHTT:
-        {
-            if(c != 'P')
+            case StateHeaderFieldEndLF:
             {
-                throw WebSocketException("malformed version");
+                if (c != LF)
+                {
+                    throw WebSocketException("malformed header");
+                }
+                _state = StateComplete;
+                break;
             }
-            _state = StateVersionHTTP;
-            break;
-        }
-        case StateVersionHTTP:
-        {
-            if(c != '/')
+            case StateVersion:
             {
-                throw WebSocketException("malformed version");
-            }
-            _state = StateVersionMajor;
-            break;
-        }
-        case StateVersionMajor:
-        {
-            if(c == '.')
-            {
-                if(_versionMajor == -1)
+                if (c != 'H')
                 {
                     throw WebSocketException("malformed version");
                 }
-                _state = StateVersionMinor;
+                _state = StateVersionH;
                 break;
             }
-            else if(c < '0' || c > '9')
-            {
-                throw WebSocketException("malformed version");
-            }
-            if(_versionMajor == -1)
-            {
-                _versionMajor = 0;
-            }
-            _versionMajor *= 10;
-            _versionMajor += (c - '0');
-            break;
-        }
-        case StateVersionMinor:
-        {
-            if(c == CR)
+            case StateVersionH:
             {
-                if(_versionMinor == -1 || _type != TypeRequest)
+                if (c != 'T')
                 {
                     throw WebSocketException("malformed version");
                 }
-                _state = StateRequestLF;
+                _state = StateVersionHT;
                 break;
             }
-            else if(c == LF)
+            case StateVersionHT:
             {
-                if(_versionMinor == -1 || _type != TypeRequest)
+                if (c != 'T')
                 {
                     throw WebSocketException("malformed version");
                 }
-                _state = StateHeaderFieldStart;
+                _state = StateVersionHTT;
                 break;
             }
-            else if(c == ' ')
+            case StateVersionHTT:
             {
-                if(_versionMinor == -1 || _type != TypeResponse)
+                if (c != 'P')
                 {
                     throw WebSocketException("malformed version");
                 }
-                _state = StateResponseVersionSP;
+                _state = StateVersionHTTP;
                 break;
             }
-            else if(c < '0' || c > '9')
+            case StateVersionHTTP:
             {
-                throw WebSocketException("malformed version");
+                if (c != '/')
+                {
+                    throw WebSocketException("malformed version");
+                }
+                _state = StateVersionMajor;
+                break;
             }
-            if(_versionMinor == -1)
-            {
-                _versionMinor = 0;
-            }
-            _versionMinor *= 10;
-            _versionMinor += (c - '0');
-            break;
-        }
-        case StateResponse:
-        {
-            _type = TypeResponse;
-            _state = StateVersionHT;
-            continue;
-        }
-        case StateResponseVersionSP:
-        {
-            if(c == ' ')
+            case StateVersionMajor:
             {
+                if (c == '.')
+                {
+                    if (_versionMajor == -1)
+                    {
+                        throw WebSocketException("malformed version");
+                    }
+                    _state = StateVersionMinor;
+                    break;
+                }
+                else if (c < '0' || c > '9')
+                {
+                    throw WebSocketException("malformed version");
+                }
+                if (_versionMajor == -1)
+                {
+                    _versionMajor = 0;
+                }
+                _versionMajor *= 10;
+                _versionMajor += (c - '0');
                 break;
             }
-
-            _state = StateResponseStatus;
-            continue;
-        }
-        case StateResponseStatus:
-        {
-            // TODO: Is reason string optional?
-            if(c == CR)
+            case StateVersionMinor:
             {
-                if(_status == -1)
+                if (c == CR)
                 {
-                    throw WebSocketException("malformed response status");
+                    if (_versionMinor == -1 || _type != TypeRequest)
+                    {
+                        throw WebSocketException("malformed version");
+                    }
+                    _state = StateRequestLF;
+                    break;
+                }
+                else if (c == LF)
+                {
+                    if (_versionMinor == -1 || _type != TypeRequest)
+                    {
+                        throw WebSocketException("malformed version");
+                    }
+                    _state = StateHeaderFieldStart;
+                    break;
                 }
-                _state = StateResponseLF;
+                else if (c == ' ')
+                {
+                    if (_versionMinor == -1 || _type != TypeResponse)
+                    {
+                        throw WebSocketException("malformed version");
+                    }
+                    _state = StateResponseVersionSP;
+                    break;
+                }
+                else if (c < '0' || c > '9')
+                {
+                    throw WebSocketException("malformed version");
+                }
+                if (_versionMinor == -1)
+                {
+                    _versionMinor = 0;
+                }
+                _versionMinor *= 10;
+                _versionMinor += (c - '0');
                 break;
             }
-            else if(c == LF)
+            case StateResponse:
+            {
+                _type = TypeResponse;
+                _state = StateVersionHT;
+                continue;
+            }
+            case StateResponseVersionSP:
             {
-                if(_status == -1)
+                if (c == ' ')
                 {
-                    throw WebSocketException("malformed response status");
+                    break;
                 }
-                _state = StateHeaderFieldStart;
-                break;
+
+                _state = StateResponseStatus;
+                continue;
             }
-            else if(c == ' ')
+            case StateResponseStatus:
             {
-                if(_status == -1)
+                // TODO: Is reason string optional?
+                if (c == CR)
+                {
+                    if (_status == -1)
+                    {
+                        throw WebSocketException("malformed response status");
+                    }
+                    _state = StateResponseLF;
+                    break;
+                }
+                else if (c == LF)
+                {
+                    if (_status == -1)
+                    {
+                        throw WebSocketException("malformed response status");
+                    }
+                    _state = StateHeaderFieldStart;
+                    break;
+                }
+                else if (c == ' ')
+                {
+                    if (_status == -1)
+                    {
+                        throw WebSocketException("malformed response status");
+                    }
+                    _state = StateResponseReasonStart;
+                    break;
+                }
+                else if (c < '0' || c > '9')
                 {
                     throw WebSocketException("malformed response status");
                 }
-                _state = StateResponseReasonStart;
+                if (_status == -1)
+                {
+                    _status = 0;
+                }
+                _status *= 10;
+                _status += (c - '0');
                 break;
             }
-            else if(c < '0' || c > '9')
-            {
-                throw WebSocketException("malformed response status");
-            }
-            if(_status == -1)
+            case StateResponseReasonStart:
             {
-                _status = 0;
+                //
+                // Skip leading spaces.
+                //
+                if (c == ' ')
+                {
+                    break;
+                }
+
+                _state = StateResponseReason;
+                start = p;
+                continue;
             }
-            _status *= 10;
-            _status += (c - '0');
-            break;
-        }
-        case StateResponseReasonStart:
-        {
-            //
-            // Skip leading spaces.
-            //
-            if(c == ' ')
+            case StateResponseReason:
             {
+                if (c == CR || c == LF)
+                {
+                    if (p > start)
+                    {
+                        _reason = bytesToString(start, p);
+                    }
+                    _state = c == CR ? StateResponseLF : StateHeaderFieldStart;
+                }
+
                 break;
             }
-
-            _state = StateResponseReason;
-            start = p;
-            continue;
-        }
-        case StateResponseReason:
-        {
-            if(c == CR || c == LF)
+            case StateResponseLF:
             {
-                if(p > start)
+                if (c != LF)
                 {
-                    _reason = string(start, p);
+                    throw WebSocketException("malformed status line");
                 }
-                _state = c == CR ? StateResponseLF : StateHeaderFieldStart;
+                _state = StateHeaderFieldStart;
+                break;
             }
-
-            break;
-        }
-        case StateResponseLF:
-        {
-            if(c != LF)
+            case StateComplete:
             {
-                throw WebSocketException("malformed status line");
+                assert(false); // Shouldn't reach
             }
-            _state = StateHeaderFieldStart;
-            break;
-        }
-        case StateComplete:
-        {
-            assert(false); // Shouldn't reach
-        }
         }
 
         ++p;
@@ -658,13 +658,13 @@ IceInternal::HttpParser::reason() const
 bool
 IceInternal::HttpParser::getHeader(const string& name, string& value, bool toLower) const
 {
-    HeaderFields::const_iterator q = _headers.find(IceUtilInternal::toLower(name));
-    if(q != _headers.end())
+    auto q = _headers.find(IceInternal::toLower(name));
+    if (q != _headers.end())
     {
-        value = IceUtilInternal::trim(q->second.second);
-        if(toLower)
+        value = IceInternal::trim(q->second.second);
+        if (toLower)
         {
-            value = IceUtilInternal::toLower(value);
+            value = IceInternal::toLower(value);
         }
         return true;
     }
@@ -672,13 +672,13 @@ IceInternal::HttpParser::getHeader(const string& name, string& value, bool toLow
     return false;
 }
 
-map<string, string>
+map<string, string, std::less<>>
 IceInternal::HttpParser::getHeaders() const
 {
-    map<string, string> headers;
-    for(HeaderFields::const_iterator q = _headers.begin(); q != _headers.end(); ++q)
+    map<string, string, std::less<>> headers;
+    for (const auto& header : _headers)
     {
-        headers.insert(make_pair(q->second.first, IceUtilInternal::trim(q->second.second)));
+        headers.insert(make_pair(header.second.first, IceInternal::trim(header.second.second)));
     }
     return headers;
 }