orthanc: Core/HttpServer/MongooseServer.cpp comparison

comparison Core/HttpServer/MongooseServer.cpp @ 2134:ddc75c6c712d

Avoid hard crash if not enough memory

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Wed, 09 Nov 2016 12:04:09 +0100
parents	15ae532af70e
children	dd609a99d39a

comparison

equal deleted inserted replaced

-:15ae532af70e
+:ddc75c6c712d
 }
 }
 }
-static void InternalCallback(struct mg_connection *connection,
+static void InternalCallback(HttpOutput& output /* out */,
+HttpMethod& method /* out */,
+MongooseServer& server,
+struct mg_connection *connection,
 const struct mg_request_info *request)
 {
-MongooseServer* that = reinterpret_cast<MongooseServer*>(request->user_data);
-MongooseOutputStream stream(connection);
-HttpOutput output(stream, that->IsKeepAliveEnabled());
 // Check remote calls
-if (!that->IsRemoteAccessAllowed() &&
+if (!server.IsRemoteAccessAllowed() &&
 request->remote_ip != LOCALHOST)
 {
 output.SendUnauthorized(ORTHANC_REALM);
 return;
 }
 std::transform(name.begin(), name.end(), name.begin(), ::tolower);
 headers.insert(std::make_pair(name, value));
 VLOG(1) << "HTTP header: [" << name << "]: [" << value << "]";
 }
-if (that->IsHttpCompressionEnabled())
+if (server.IsHttpCompressionEnabled())
 {
 ConfigureHttpCompression(output, headers);
 }
 HttpToolbox::ParseGetArguments(argumentsGET, request->query_string);
 }
 // Compute the HTTP method, taking method faking into consideration
-HttpMethod method = HttpMethod_Get;
+method = HttpMethod_Get;
 if (!ExtractMethod(method, request, headers, argumentsGET))
 {
 output.SendStatus(HttpStatus_400_BadRequest);
 return;
 }
 // Authenticate this connection
-if (that->IsAuthenticationEnabled() && !IsAccessGranted(*that, headers))
+if (server.IsAuthenticationEnabled() &&
+!IsAccessGranted(server, headers))
 {
 output.SendUnauthorized(ORTHANC_REALM);
 return;
 }
 reinterpret_cast<const uint8_t*>(&request->remote_ip) [1],
 reinterpret_cast<const uint8_t*>(&request->remote_ip) [0]);
 std::string username = GetAuthenticatedUsername(headers);
-const IIncomingHttpRequestFilter *filter = that->GetIncomingHttpRequestFilter();
+const IIncomingHttpRequestFilter *filter = server.GetIncomingHttpRequestFilter();
 if (filter != NULL)
 {
 if (!filter->IsAllowed(method, request->uri, remoteIp, username.c_str(), headers))
 {
 //output.SendUnauthorized(ORTHANC_REALM);
 {
 std::string contentType = ct->second;
 if (contentType.size() >= multipartLength &&
 !memcmp(contentType.c_str(), multipart, multipartLength))
 {
-status = ParseMultipartPost(body, connection, headers, contentType, that->GetChunkStore());
+status = ParseMultipartPost(body, connection, headers, contentType, server.GetChunkStore());
 }
 else
 {
 status = ReadBody(body, connection, headers);
 }
 UriComponents uri;
 try
 {
 Toolbox::SplitUriComponents(uri, request->uri);
 }
-catch (OrthancException)
+catch (OrthancException&)
 {
 output.SendStatus(HttpStatus_400_BadRequest);
 return;
 }
 LOG(INFO) << EnumerationToString(method) << " " << Toolbox::FlattenUri(uri);
+bool found = false;
+if (server.HasHandler())
+{
+found = server.GetHandler().Handle(output, RequestOrigin_RestApi, remoteIp, username.c_str(),
+method, uri, headers, argumentsGET, body.c_str(), body.size());
+}
+if (!found)
+{
+throw OrthancException(ErrorCode_UnknownResource);
+}
+}
+static void ProtectedCallback(struct mg_connection *connection,
+const struct mg_request_info *request)
+{
 try
 {
-bool found = false;
+MongooseServer* server = reinterpret_cast<MongooseServer*>(request->user_data);
+if (server == NULL)
+{
+MongooseOutputStream stream(connection);
+HttpOutput output(stream, false /* assume no keep-alive */);
+output.SendStatus(HttpStatus_500_InternalServerError);
+return;
+}
+MongooseOutputStream stream(connection);
+HttpOutput output(stream, server->IsKeepAliveEnabled());
+HttpMethod method = HttpMethod_Get;
 try
 {
-if (that->HasHandler())
+try
 {
-found = that->GetHandler().Handle(output, RequestOrigin_RestApi, remoteIp, username.c_str(),
+InternalCallback(output, method, *server, connection, request);
-method, uri, headers, argumentsGET, body.c_str(), body.size());
+}
-}
+catch (OrthancException&)
-}
+{
-catch (boost::bad_lexical_cast&)
+throw;  // Pass the exception to the main handler below
-{
+}
-throw OrthancException(ErrorCode_BadParameterType);
+// Now convert native exceptions as OrthancException
-}
+catch (boost::bad_lexical_cast&)
-catch (std::runtime_error&)
+{
-{
+LOG(ERROR) << "Syntax error in some user-supplied data";
-// Presumably an error while parsing the JSON body
+throw OrthancException(ErrorCode_BadParameterType);
-throw OrthancException(ErrorCode_BadRequest);
+}
-}
+catch (std::runtime_error&)
-/*catch (std::bad_alloc&)
+{
-{
+// Presumably an error while parsing the JSON body
-throw OrthancException(ErrorCode_NotEnoughMemory);
+throw OrthancException(ErrorCode_BadRequest);
-}*/
+}
+catch (std::bad_alloc&)
-if (!found)
+{
-{
+LOG(ERROR) << "The server hosting Orthanc is running out of memory";
-throw OrthancException(ErrorCode_UnknownResource);
+throw OrthancException(ErrorCode_NotEnoughMemory);
 }
-}
+catch (...)
-catch (OrthancException& e)
+{
-{
+LOG(ERROR) << "An unhandled exception was generated inside the HTTP server";
-// Using this candidate handler results in an exception
+throw OrthancException(ErrorCode_InternalError);
-try
+}
-{
+}
-if (that->GetExceptionFormatter() == NULL)
+catch (OrthancException& e)
 {
-LOG(ERROR) << "Exception in the HTTP handler: " << e.What();
+assert(server != NULL);
-output.SendStatus(e.GetHttpStatus());
-}
+// Using this candidate handler results in an exception
-else
+try
 {
-that->GetExceptionFormatter()->Format(output, e, method, request->uri);
+if (server->GetExceptionFormatter() == NULL)
-}
+{
-}
+LOG(ERROR) << "Exception in the HTTP handler: " << e.What();
-catch (OrthancException&)
+output.SendStatus(e.GetHttpStatus());
-{
+}
-// An exception here reflects the fact that the status code
+else
-// was already set by the HTTP handler.
+{
-}
+server->GetExceptionFormatter()->Format(output, e, method, request->uri);
+}
-return;
+}
+catch (OrthancException&)
+{
+// An exception here reflects the fact that the status code
+// was already set by the HTTP handler.
+}
+}
+}
+catch (...)
+{
+// We should never arrive at this point, where it is even impossible to send an answer
+LOG(ERROR) << "Catastrophic error inside the HTTP server, giving up";
 }
 }
 #if MONGOOSE_USE_CALLBACKS == 0
 struct mg_connection *connection,
 const struct mg_request_info *request)
 {
 if (event == MG_NEW_REQUEST)
 {
-InternalCallback(connection, request);
+ProtectedCallback(connection, request);
 // Mark as processed
 return (void*) "";
 }
 else
 #elif MONGOOSE_USE_CALLBACKS == 1
 static int Callback(struct mg_connection *connection)
 {
 struct mg_request_info *request = mg_get_request_info(connection);
-InternalCallback(connection, request);
+ProtectedCallback(connection, request);
 return 1;  // Do not let Mongoose handle the request by itself
 }
 #else

Mercurial > hg > orthanc

comparison Core/HttpServer/MongooseServer.cpp @ 2134:ddc75c6c712d