Mercurial > hg > orthanc
annotate OrthancFramework/Sources/HttpServer/HttpServer.cpp @ 4337:7707fa761b71
OrthancImport.py sample
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Wed, 02 Dec 2020 11:01:59 +0100 |
| parents | a01b1c9cbef4 |
| children | e1e918e790e8 |
| rev | line source |
|---|---|
| 0 | 1 /** |
| 59 | 2 * Orthanc - A Lightweight, RESTful DICOM Store |
| 1900 | 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics |
|
1288
6e7e5ed91c2d
upgrade to year 2015
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1213
diff
changeset
|
4 * Department, University Hospital of Liege, Belgium |
|
3640
94f4a18a79cc
upgrade to year 2020
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3537
diff
changeset
|
5 * Copyright (C) 2017-2020 Osimis S.A., Belgium |
| 0 | 6 * |
| 7 * This program is free software: you can redistribute it and/or | |
|
4119
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
8 * modify it under the terms of the GNU Lesser General Public License |
|
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
9 * as published by the Free Software Foundation, either version 3 of |
|
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
10 * the License, or (at your option) any later version. |
| 136 | 11 * |
| 0 | 12 * This program is distributed in the hope that it will be useful, but |
| 13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
|
4119
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
15 * Lesser General Public License for more details. |
| 0 | 16 * |
|
4119
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
17 * You should have received a copy of the GNU Lesser General Public |
|
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
18 * License along with this program. If not, see |
|
bf7b9edf6b81
re-licensing the OrthancFramework to LGPL, in order to license Stone of Orthanc under LGPL
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4044
diff
changeset
|
19 * <http://www.gnu.org/licenses/>. |
| 0 | 20 **/ |
| 21 | |
| 22 | |
| 23 // http://en.highscore.de/cpp/boost/stringhandling.html | |
| 24 | |
|
824
a811bdf8b8eb
precompiled headers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
809
diff
changeset
|
25 #include "../PrecompiledHeaders.h" |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
26 #include "HttpServer.h" |
| 0 | 27 |
|
3357
c0aa5f1cf2f5
new class: FileBuffer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3356
diff
changeset
|
28 #include "../ChunkedBuffer.h" |
|
c0aa5f1cf2f5
new class: FileBuffer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3356
diff
changeset
|
29 #include "../FileBuffer.h" |
|
1486
f967bdf8534e
refactoring to Logging.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1446
diff
changeset
|
30 #include "../Logging.h" |
| 2895 | 31 #include "../OrthancException.h" |
|
3357
c0aa5f1cf2f5
new class: FileBuffer
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3356
diff
changeset
|
32 #include "../TemporaryFile.h" |
|
1486
f967bdf8534e
refactoring to Logging.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1446
diff
changeset
|
33 #include "HttpToolbox.h" |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
34 #include "IHttpHandler.h" |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
35 |
|
4226
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
36 #if ORTHANC_ENABLE_PUGIXML == 1 |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
37 # include "IWebDavBucket.h" |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
38 #endif |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
39 |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
40 #if ORTHANC_ENABLE_MONGOOSE == 1 |
| 3069 | 41 # include <mongoose.h> |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
42 |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
43 #elif ORTHANC_ENABLE_CIVETWEB == 1 |
| 3069 | 44 # include <civetweb.h> |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
45 # define MONGOOSE_USE_CALLBACKS 1 |
|
3178
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
46 # if !defined(CIVETWEB_HAS_DISABLE_KEEP_ALIVE) |
|
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
47 # error Macro CIVETWEB_HAS_DISABLE_KEEP_ALIVE must be defined |
|
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
48 # endif |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
49 # if !defined(CIVETWEB_HAS_WEBDAV_WRITING) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
50 # error Macro CIVETWEB_HAS_WEBDAV_WRITING must be defined |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
51 # endif |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
52 #else |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
53 # error "Either Mongoose or Civetweb must be enabled to compile this file" |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
54 #endif |
|
1486
f967bdf8534e
refactoring to Logging.h
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1446
diff
changeset
|
55 |
| 0 | 56 #include <algorithm> |
| 57 #include <boost/algorithm/string.hpp> | |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
58 #include <boost/algorithm/string/predicate.hpp> |
|
3672
ea8c1c0e81eb
Fix issue #65 (Logging improvements)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
59 #include <boost/filesystem.hpp> |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
60 #include <boost/lexical_cast.hpp> |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
61 #include <boost/thread.hpp> |
| 0 | 62 #include <iostream> |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
63 #include <stdio.h> |
| 0 | 64 #include <string.h> |
| 65 | |
|
2137
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
66 #if !defined(ORTHANC_ENABLE_SSL) |
|
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
67 # error The macro ORTHANC_ENABLE_SSL must be defined |
|
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
68 #endif |
|
595cf22b3e7e
safety checks of macros
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2136
diff
changeset
|
69 |
|
2136
dd609a99d39a
uniformization of the macro naming
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2134
diff
changeset
|
70 #if ORTHANC_ENABLE_SSL == 1 |
|
3801
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
71 # include <openssl/opensslv.h> |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
72 # include <openssl/err.h> |
|
748
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
73 #endif |
| 0 | 74 |
| 59 | 75 #define ORTHANC_REALM "Orthanc Secure Area" |
|
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
76 |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
77 |
| 59 | 78 namespace Orthanc |
| 0 | 79 { |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
80 static const char MULTIPART_FORM[] = "multipart/form-data; boundary="; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
81 static unsigned int MULTIPART_FORM_LENGTH = sizeof(MULTIPART_FORM) / sizeof(char) - 1; |
| 0 | 82 |
| 83 | |
| 84 namespace | |
| 85 { | |
| 86 // Anonymous namespace to avoid clashes between compilation modules | |
| 911 | 87 class MongooseOutputStream : public IHttpOutputStream |
| 0 | 88 { |
| 89 private: | |
| 90 struct mg_connection* connection_; | |
| 91 | |
| 911 | 92 public: |
| 4201 | 93 explicit MongooseOutputStream(struct mg_connection* connection) : |
| 94 connection_(connection) | |
| 911 | 95 { |
| 96 } | |
| 97 | |
| 909 | 98 virtual void Send(bool isHeader, const void* buffer, size_t length) |
| 0 | 99 { |
| 217 | 100 if (length > 0) |
| 101 { | |
|
1430
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1363
diff
changeset
|
102 int status = mg_write(connection_, buffer, length); |
|
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1363
diff
changeset
|
103 if (status != static_cast<int>(length)) |
|
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1363
diff
changeset
|
104 { |
|
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1363
diff
changeset
|
105 // status == 0 when the connection has been closed, -1 on error |
|
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1363
diff
changeset
|
106 throw OrthancException(ErrorCode_NetworkProtocol); |
|
ad94a3583b07
Plugins can send answers as multipart messages
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1363
diff
changeset
|
107 } |
| 217 | 108 } |
| 0 | 109 } |
|
908
e078ea944089
refactoring HttpOutput
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
901
diff
changeset
|
110 |
| 911 | 111 virtual void OnHttpStatusReceived(HttpStatus status) |
|
908
e078ea944089
refactoring HttpOutput
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
901
diff
changeset
|
112 { |
| 911 | 113 // Ignore this |
|
908
e078ea944089
refactoring HttpOutput
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
901
diff
changeset
|
114 } |
|
3154
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
115 |
|
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
116 virtual void DisableKeepAlive() |
|
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
117 { |
|
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
118 #if ORTHANC_ENABLE_MONGOOSE == 1 |
|
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
119 throw OrthancException(ErrorCode_NotImplemented, |
|
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
120 "Only available if using CivetWeb"); |
|
3178
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
121 |
|
3154
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
122 #elif ORTHANC_ENABLE_CIVETWEB == 1 |
|
3178
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
123 # if CIVETWEB_HAS_DISABLE_KEEP_ALIVE == 1 |
|
3154
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
124 mg_disable_keep_alive(connection_); |
|
3178
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
125 # else |
|
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
126 # warning The function "mg_disable_keep_alive()" is not available, DICOMweb might run slowly |
|
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
127 throw OrthancException(ErrorCode_NotImplemented, |
|
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
128 "Only available if using a patched version of CivetWeb"); |
|
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
129 # endif |
|
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
130 |
|
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
131 #else |
|
6d558598d713
Fix build with unpatched versions of Civetweb (missing "mg_disable_keep_alive()")
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3154
diff
changeset
|
132 # error Please support your embedded Web server here |
|
3154
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
133 #endif |
|
6e8822be2f08
Fix compatibility with DICOMweb plugin (allow multipart answers over HTTP Keep-Alive)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3145
diff
changeset
|
134 } |
| 0 | 135 }; |
| 136 | |
| 137 | |
| 138 enum PostDataStatus | |
| 139 { | |
| 140 PostDataStatus_Success, | |
| 141 PostDataStatus_NoLength, | |
| 142 PostDataStatus_Pending, | |
| 143 PostDataStatus_Failure | |
| 144 }; | |
| 145 } | |
| 146 | |
| 147 | |
| 148 // TODO Move this to external file | |
| 149 | |
| 150 | |
| 151 class ChunkedFile : public ChunkedBuffer | |
| 152 { | |
| 153 private: | |
| 154 std::string filename_; | |
| 155 | |
| 156 public: | |
| 4201 | 157 explicit ChunkedFile(const std::string& filename) : |
| 0 | 158 filename_(filename) |
| 159 { | |
| 160 } | |
| 161 | |
| 162 const std::string& GetFilename() const | |
| 163 { | |
| 164 return filename_; | |
| 165 } | |
| 166 }; | |
| 167 | |
| 168 | |
| 169 | |
| 3836 | 170 class ChunkStore : public boost::noncopyable |
| 0 | 171 { |
| 172 private: | |
| 173 typedef std::list<ChunkedFile*> Content; | |
| 174 Content content_; | |
| 175 unsigned int numPlaces_; | |
| 176 | |
| 177 boost::mutex mutex_; | |
| 178 std::set<std::string> discardedFiles_; | |
| 179 | |
| 180 void Clear() | |
| 181 { | |
| 182 for (Content::iterator it = content_.begin(); | |
| 656 | 183 it != content_.end(); ++it) |
| 0 | 184 { |
| 185 delete *it; | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 Content::iterator Find(const std::string& filename) | |
| 190 { | |
| 191 for (Content::iterator it = content_.begin(); | |
| 656 | 192 it != content_.end(); ++it) |
| 0 | 193 { |
| 194 if ((*it)->GetFilename() == filename) | |
| 195 { | |
| 196 return it; | |
| 197 } | |
| 198 } | |
| 199 | |
| 200 return content_.end(); | |
| 201 } | |
| 202 | |
| 203 void Remove(const std::string& filename) | |
| 204 { | |
| 205 Content::iterator it = Find(filename); | |
| 206 if (it != content_.end()) | |
| 207 { | |
| 208 delete *it; | |
| 209 content_.erase(it); | |
| 210 } | |
| 211 } | |
| 212 | |
| 213 public: | |
| 214 ChunkStore() | |
| 215 { | |
| 216 numPlaces_ = 10; | |
| 217 } | |
| 218 | |
| 219 ~ChunkStore() | |
| 220 { | |
| 221 Clear(); | |
| 222 } | |
| 223 | |
| 224 PostDataStatus Store(std::string& completed, | |
| 225 const char* chunkData, | |
| 226 size_t chunkSize, | |
| 227 const std::string& filename, | |
| 228 size_t filesize) | |
| 229 { | |
| 230 boost::mutex::scoped_lock lock(mutex_); | |
| 231 | |
| 232 std::set<std::string>::iterator wasDiscarded = discardedFiles_.find(filename); | |
| 233 if (wasDiscarded != discardedFiles_.end()) | |
| 234 { | |
| 235 discardedFiles_.erase(wasDiscarded); | |
| 236 return PostDataStatus_Failure; | |
| 237 } | |
| 238 | |
| 239 ChunkedFile* f; | |
| 240 Content::iterator it = Find(filename); | |
| 241 if (it == content_.end()) | |
| 242 { | |
| 243 f = new ChunkedFile(filename); | |
| 244 | |
| 245 // Make some room | |
| 246 if (content_.size() >= numPlaces_) | |
| 247 { | |
| 248 discardedFiles_.insert(content_.front()->GetFilename()); | |
| 249 delete content_.front(); | |
| 250 content_.pop_front(); | |
| 251 } | |
| 252 | |
| 253 content_.push_back(f); | |
| 254 } | |
| 255 else | |
| 256 { | |
| 257 f = *it; | |
| 258 } | |
| 259 | |
| 260 f->AddChunk(chunkData, chunkSize); | |
| 261 | |
| 262 if (f->GetNumBytes() > filesize) | |
| 263 { | |
| 264 Remove(filename); | |
| 265 } | |
| 266 else if (f->GetNumBytes() == filesize) | |
| 267 { | |
| 268 f->Flatten(completed); | |
| 269 Remove(filename); | |
| 270 return PostDataStatus_Success; | |
| 271 } | |
| 272 | |
| 273 return PostDataStatus_Pending; | |
| 274 } | |
| 275 | |
| 276 /*void Print() | |
| 277 { | |
| 278 boost::mutex::scoped_lock lock(mutex_); | |
| 279 | |
| 280 printf("ChunkStore status:\n"); | |
| 281 for (Content::const_iterator i = content_.begin(); | |
| 282 i != content_.end(); i++) | |
| 283 { | |
| 284 printf(" [%s]: %d\n", (*i)->GetFilename().c_str(), (*i)->GetNumBytes()); | |
| 285 } | |
| 286 printf("-----\n"); | |
| 287 }*/ | |
| 288 }; | |
| 289 | |
| 290 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
291 struct HttpServer::PImpl |
| 0 | 292 { |
| 293 struct mg_context *context_; | |
| 294 ChunkStore chunkStore_; | |
| 4201 | 295 |
| 296 PImpl() : | |
| 297 context_(NULL) | |
| 298 { | |
| 299 } | |
| 0 | 300 }; |
| 301 | |
| 302 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
303 ChunkStore& HttpServer::GetChunkStore() |
| 0 | 304 { |
| 305 return pimpl_->chunkStore_; | |
| 306 } | |
| 307 | |
| 308 | |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
309 static PostDataStatus ReadBodyWithContentLength(std::string& body, |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
310 struct mg_connection *connection, |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
311 const std::string& contentLength) |
| 0 | 312 { |
|
4152
36257d6f348f
Support of multipart messages larger than 2GB in the embedded HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4119
diff
changeset
|
313 size_t length; |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
314 try |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
315 { |
| 4201 | 316 int64_t tmp = boost::lexical_cast<int64_t>(contentLength); |
| 317 if (tmp < 0) | |
| 318 { | |
| 319 return PostDataStatus_NoLength; | |
| 320 } | |
| 321 | |
| 322 length = static_cast<size_t>(tmp); | |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
323 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
324 catch (boost::bad_lexical_cast&) |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
325 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
326 return PostDataStatus_NoLength; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
327 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
328 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
329 body.resize(length); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
330 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
331 size_t pos = 0; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
332 while (length > 0) |
| 0 | 333 { |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
334 int r = mg_read(connection, &body[pos], length); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
335 if (r <= 0) |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
336 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
337 return PostDataStatus_Failure; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
338 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
339 |
|
4152
36257d6f348f
Support of multipart messages larger than 2GB in the embedded HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4119
diff
changeset
|
340 assert(static_cast<size_t>(r) <= length); |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
341 length -= r; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
342 pos += r; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
343 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
344 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
345 return PostDataStatus_Success; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
346 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
347 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
348 |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
349 static PostDataStatus ReadBodyWithoutContentLength(std::string& body, |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
350 struct mg_connection *connection) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
351 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
352 // Store the individual chunks in a temporary file, then read it |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
353 // back into the memory buffer "body" |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
354 FileBuffer buffer; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
355 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
356 std::string tmp(1024 * 1024, 0); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
357 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
358 for (;;) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
359 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
360 int r = mg_read(connection, &tmp[0], tmp.size()); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
361 if (r < 0) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
362 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
363 return PostDataStatus_Failure; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
364 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
365 else if (r == 0) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
366 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
367 break; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
368 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
369 else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
370 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
371 buffer.Append(tmp.c_str(), r); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
372 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
373 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
374 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
375 buffer.Read(body); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
376 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
377 return PostDataStatus_Success; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
378 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
379 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
380 |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
381 static PostDataStatus ReadBodyToString(std::string& body, |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
382 struct mg_connection *connection, |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
383 const HttpToolbox::Arguments& headers) |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
384 { |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
385 HttpToolbox::Arguments::const_iterator contentLength = headers.find("content-length"); |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
386 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
387 if (contentLength != headers.end()) |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
388 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
389 // "Content-Length" is available |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
390 return ReadBodyWithContentLength(body, connection, contentLength->second); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
391 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
392 else |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
393 { |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
394 // No Content-Length |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
395 return ReadBodyWithoutContentLength(body, connection); |
| 0 | 396 } |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
397 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
398 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
399 |
| 3414 | 400 static PostDataStatus ReadBodyToStream(IHttpHandler::IChunkedRequestReader& stream, |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
401 struct mg_connection *connection, |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
402 const HttpToolbox::Arguments& headers) |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
403 { |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
404 HttpToolbox::Arguments::const_iterator contentLength = headers.find("content-length"); |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
405 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
406 if (contentLength != headers.end()) |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
407 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
408 // "Content-Length" is available |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
409 std::string body; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
410 PostDataStatus status = ReadBodyWithContentLength(body, connection, contentLength->second); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
411 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
412 if (status == PostDataStatus_Success && |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
413 !body.empty()) |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
414 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
415 stream.AddBodyChunk(body.c_str(), body.size()); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
416 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
417 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
418 return status; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
419 } |
|
3356
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
420 else |
|
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
421 { |
|
3404
e280ced38a4c
ErrorCode_UnsupportedMediaType
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3395
diff
changeset
|
422 // No Content-Length: This is a chunked transfer. Stream the HTTP connection. |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
423 std::string tmp(1024 * 1024, 0); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
424 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
425 for (;;) |
|
3356
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
426 { |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
427 int r = mg_read(connection, &tmp[0], tmp.size()); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
428 if (r < 0) |
|
3356
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
429 { |
|
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
430 return PostDataStatus_Failure; |
|
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
431 } |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
432 else if (r == 0) |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
433 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
434 break; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
435 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
436 else |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
437 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
438 stream.AddBodyChunk(tmp.c_str(), r); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
439 } |
|
3356
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
440 } |
|
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
441 |
|
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
442 return PostDataStatus_Success; |
|
f744730c294b
Orthanc now accepts chunked transfer encoding
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3330
diff
changeset
|
443 } |
| 0 | 444 } |
| 445 | |
| 446 | |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
447 static PostDataStatus ParseMultipartForm(std::string &completedFile, |
| 0 | 448 struct mg_connection *connection, |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
449 const HttpToolbox::Arguments& headers, |
| 0 | 450 const std::string& contentType, |
| 451 ChunkStore& chunkStore) | |
| 452 { | |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
453 std::string boundary = "--" + contentType.substr(MULTIPART_FORM_LENGTH); |
| 0 | 454 |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
455 std::string body; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
456 PostDataStatus status = ReadBodyToString(body, connection, headers); |
| 0 | 457 |
| 458 if (status != PostDataStatus_Success) | |
| 459 { | |
| 460 return status; | |
| 461 } | |
| 462 | |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
463 /*for (HttpToolbox::Arguments::const_iterator i = headers.begin(); i != headers.end(); i++) |
| 0 | 464 { |
| 465 std::cout << "Header [" << i->first << "] = " << i->second << "\n"; | |
| 466 } | |
| 467 printf("CHUNK\n");*/ | |
| 468 | |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
469 typedef HttpToolbox::Arguments::const_iterator ArgumentIterator; |
| 0 | 470 |
| 471 ArgumentIterator requestedWith = headers.find("x-requested-with"); | |
| 472 ArgumentIterator fileName = headers.find("x-file-name"); | |
| 473 ArgumentIterator fileSizeStr = headers.find("x-file-size"); | |
| 474 | |
|
338
3a3b3ba8c1e0
fix for uploads through internet explorer 7
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
333
diff
changeset
|
475 if (requestedWith != headers.end() && |
| 0 | 476 requestedWith->second != "XMLHttpRequest") |
| 477 { | |
| 478 return PostDataStatus_Failure; | |
| 479 } | |
| 480 | |
| 481 size_t fileSize = 0; | |
| 482 if (fileSizeStr != headers.end()) | |
| 483 { | |
| 484 try | |
| 485 { | |
| 486 fileSize = boost::lexical_cast<size_t>(fileSizeStr->second); | |
| 487 } | |
|
2836
7133ad478eea
fix Debian warnings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2790
diff
changeset
|
488 catch (boost::bad_lexical_cast&) |
| 0 | 489 { |
| 490 return PostDataStatus_Failure; | |
| 491 } | |
| 492 } | |
| 493 | |
| 494 typedef boost::find_iterator<std::string::iterator> FindIterator; | |
| 10 | 495 typedef boost::iterator_range<char*> Range; |
| 0 | 496 |
| 497 //chunkStore.Print(); | |
| 498 | |
| 3445 | 499 // TODO - Refactor using class "MultipartStreamReader" |
| 0 | 500 try |
| 501 { | |
| 502 FindIterator last; | |
| 503 for (FindIterator it = | |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
504 make_find_iterator(body, boost::first_finder(boundary)); |
| 0 | 505 it!=FindIterator(); |
| 506 ++it) | |
| 507 { | |
| 508 if (last != FindIterator()) | |
| 509 { | |
| 10 | 510 Range part(&last->back(), &it->front()); |
| 0 | 511 Range content = boost::find_first(part, "\r\n\r\n"); |
| 345 | 512 if (/*content != Range()*/!content.empty()) |
| 0 | 513 { |
| 514 Range c(&content.back() + 1, &it->front() - 2); | |
| 515 size_t chunkSize = c.size(); | |
| 516 | |
| 517 if (chunkSize > 0) | |
| 518 { | |
| 519 const char* chunkData = &c.front(); | |
| 520 | |
| 521 if (fileName == headers.end()) | |
| 522 { | |
| 523 // This file is stored in a single chunk | |
| 524 completedFile.resize(chunkSize); | |
| 4201 | 525 memcpy(&completedFile[0], chunkData, chunkSize); |
| 0 | 526 return PostDataStatus_Success; |
| 527 } | |
| 528 else | |
| 529 { | |
| 530 return chunkStore.Store(completedFile, chunkData, chunkSize, fileName->second, fileSize); | |
| 531 } | |
| 532 } | |
| 10 | 533 } |
| 0 | 534 } |
| 535 | |
| 536 last = it; | |
| 537 } | |
| 538 } | |
|
2836
7133ad478eea
fix Debian warnings
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2790
diff
changeset
|
539 catch (std::length_error&) |
| 0 | 540 { |
| 541 return PostDataStatus_Failure; | |
| 542 } | |
| 543 | |
| 544 return PostDataStatus_Pending; | |
| 545 } | |
| 546 | |
| 547 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
548 static bool IsAccessGranted(const HttpServer& that, |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
549 const HttpToolbox::Arguments& headers) |
| 23 | 550 { |
|
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
551 bool granted = false; |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
552 |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
553 HttpToolbox::Arguments::const_iterator auth = headers.find("authorization"); |
|
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
554 if (auth != headers.end()) |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
555 { |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
556 std::string s = auth->second; |
| 1213 | 557 if (s.size() > 6 && |
| 558 s.substr(0, 6) == "Basic ") | |
|
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
559 { |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
560 std::string b64 = s.substr(6); |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
561 granted = that.IsValidBasicHttpAuthentication(b64); |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
562 } |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
563 } |
| 23 | 564 |
|
1202
476a17cfdf42
Fix crash when bad HTTP credentials are provided
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1122
diff
changeset
|
565 return granted; |
| 23 | 566 } |
| 567 | |
| 568 | |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
569 static std::string GetAuthenticatedUsername(const HttpToolbox::Arguments& headers) |
|
409
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
570 { |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
571 HttpToolbox::Arguments::const_iterator auth = headers.find("authorization"); |
|
409
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
572 |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
573 if (auth == headers.end()) |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
574 { |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
575 return ""; |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
576 } |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
577 |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
578 std::string s = auth->second; |
| 1213 | 579 if (s.size() <= 6 || |
| 580 s.substr(0, 6) != "Basic ") | |
|
409
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
581 { |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
582 return ""; |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
583 } |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
584 |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
585 std::string b64 = s.substr(6); |
|
809
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
749
diff
changeset
|
586 std::string decoded; |
|
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
749
diff
changeset
|
587 Toolbox::DecodeBase64(decoded, b64); |
|
409
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
588 size_t semicolons = decoded.find(':'); |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
589 |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
590 if (semicolons == std::string::npos) |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
591 { |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
592 // Bad-formatted request |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
593 return ""; |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
594 } |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
595 else |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
596 { |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
597 return decoded.substr(0, semicolons); |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
598 } |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
599 } |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
600 |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
601 |
|
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
602 static bool ExtractMethod(HttpMethod& method, |
| 414 | 603 const struct mg_request_info *request, |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
604 const HttpToolbox::Arguments& headers, |
|
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
605 const HttpToolbox::GetArguments& argumentsGET) |
| 414 | 606 { |
| 607 std::string overriden; | |
| 608 | |
| 609 // Check whether some PUT/DELETE faking is done | |
| 610 | |
| 611 // 1. Faking with Google's approach | |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
612 HttpToolbox::Arguments::const_iterator methodOverride = |
| 414 | 613 headers.find("x-http-method-override"); |
| 614 | |
| 615 if (methodOverride != headers.end()) | |
| 616 { | |
| 617 overriden = methodOverride->second; | |
| 618 } | |
| 619 else if (!strcmp(request->request_method, "GET")) | |
| 620 { | |
| 621 // 2. Faking with Ruby on Rail's approach | |
| 622 // GET /my/resource?_method=delete <=> DELETE /my/resource | |
|
1363
feaf2840917c
Plugins now receive duplicated GET arguments in their REST callbacks
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
623 for (size_t i = 0; i < argumentsGET.size(); i++) |
| 414 | 624 { |
|
1363
feaf2840917c
Plugins now receive duplicated GET arguments in their REST callbacks
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
625 if (argumentsGET[i].first == "_method") |
|
feaf2840917c
Plugins now receive duplicated GET arguments in their REST callbacks
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
626 { |
|
feaf2840917c
Plugins now receive duplicated GET arguments in their REST callbacks
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
627 overriden = argumentsGET[i].second; |
|
feaf2840917c
Plugins now receive duplicated GET arguments in their REST callbacks
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
628 break; |
|
feaf2840917c
Plugins now receive duplicated GET arguments in their REST callbacks
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1288
diff
changeset
|
629 } |
| 414 | 630 } |
| 631 } | |
| 632 | |
| 633 if (overriden.size() > 0) | |
| 634 { | |
| 635 // A faking has been done within this request | |
| 636 Toolbox::ToUpperCase(overriden); | |
| 637 | |
| 4295 | 638 CLOG(INFO, HTTP) << "HTTP method faking has been detected for " << overriden; |
| 416 | 639 |
| 414 | 640 if (overriden == "PUT") |
| 641 { | |
|
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
642 method = HttpMethod_Put; |
| 416 | 643 return true; |
| 414 | 644 } |
| 645 else if (overriden == "DELETE") | |
| 646 { | |
|
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
647 method = HttpMethod_Delete; |
| 416 | 648 return true; |
| 414 | 649 } |
| 650 else | |
| 651 { | |
| 652 return false; | |
| 653 } | |
| 654 } | |
| 655 | |
| 656 // No PUT/DELETE faking was present | |
| 657 if (!strcmp(request->request_method, "GET")) | |
| 658 { | |
|
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
659 method = HttpMethod_Get; |
| 414 | 660 } |
| 661 else if (!strcmp(request->request_method, "POST")) | |
| 662 { | |
|
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
663 method = HttpMethod_Post; |
| 414 | 664 } |
| 665 else if (!strcmp(request->request_method, "DELETE")) | |
| 666 { | |
|
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
667 method = HttpMethod_Delete; |
| 414 | 668 } |
| 669 else if (!strcmp(request->request_method, "PUT")) | |
| 670 { | |
|
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
671 method = HttpMethod_Put; |
| 414 | 672 } |
| 673 else | |
| 674 { | |
| 675 return false; | |
| 676 } | |
| 677 | |
| 678 return true; | |
| 679 } | |
| 680 | |
| 681 | |
| 1517 | 682 static void ConfigureHttpCompression(HttpOutput& output, |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
683 const HttpToolbox::Arguments& headers) |
| 1517 | 684 { |
| 685 // Look if the client wishes HTTP compression | |
| 686 // https://en.wikipedia.org/wiki/HTTP_compression | |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
687 HttpToolbox::Arguments::const_iterator it = headers.find("accept-encoding"); |
| 1517 | 688 if (it != headers.end()) |
| 689 { | |
| 690 std::vector<std::string> encodings; | |
| 691 Toolbox::TokenizeString(encodings, it->second, ','); | |
| 692 | |
| 693 for (size_t i = 0; i < encodings.size(); i++) | |
| 694 { | |
| 695 std::string s = Toolbox::StripSpaces(encodings[i]); | |
| 696 | |
| 697 if (s == "deflate") | |
| 698 { | |
| 699 output.SetDeflateAllowed(true); | |
| 700 } | |
| 701 else if (s == "gzip") | |
| 702 { | |
| 703 output.SetGzipAllowed(true); | |
| 704 } | |
| 705 } | |
| 706 } | |
| 707 } | |
| 708 | |
| 709 | |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
710 #if ORTHANC_ENABLE_PUGIXML == 1 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
711 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
712 # if CIVETWEB_HAS_WEBDAV_WRITING == 0 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
713 static void AnswerWebDavReadOnly(HttpOutput& output, |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
714 const std::string& uri) |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
715 { |
| 4295 | 716 CLOG(ERROR, HTTP) << "Orthanc was compiled without support for read-write access to WebDAV: " << uri; |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
717 output.SendStatus(HttpStatus_403_Forbidden); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
718 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
719 # endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
720 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
721 static bool HandleWebDav(HttpOutput& output, |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
722 const HttpServer::WebDavBuckets& buckets, |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
723 const std::string& method, |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
724 const HttpToolbox::Arguments& headers, |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
725 const std::string& uri, |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
726 struct mg_connection *connection /* to read the PUT body if need be */) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
727 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
728 if (buckets.empty()) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
729 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
730 return false; // Speed up things if WebDAV is not used |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
731 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
732 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
733 /** |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
734 * The "buckets" maps an URI relative to the root of the |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
735 * bucket, to the content of the bucket. The root URI does *not* |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
736 * contain a trailing slash. |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
737 **/ |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
738 |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
739 if (method == "OPTIONS") |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
740 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
741 // Remove the trailing slash, if any (necessary for davfs2) |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
742 std::string s = uri; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
743 if (!s.empty() && |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
744 s[s.size() - 1] == '/') |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
745 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
746 s.resize(s.size() - 1); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
747 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
748 |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
749 HttpServer::WebDavBuckets::const_iterator bucket = buckets.find(s); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
750 if (bucket == buckets.end()) |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
751 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
752 return false; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
753 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
754 else |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
755 { |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
756 output.AddHeader("DAV", "1,2"); // Necessary for Windows XP |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
757 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
758 #if CIVETWEB_HAS_WEBDAV_WRITING == 1 |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
759 output.AddHeader("Allow", "GET, PUT, DELETE, OPTIONS, PROPFIND, HEAD, LOCK, UNLOCK, PROPPATCH, MKCOL"); |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
760 #else |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
761 output.AddHeader("Allow", "GET, PUT, DELETE, OPTIONS, PROPFIND, HEAD"); |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
762 #endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
763 |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
764 output.SendStatus(HttpStatus_200_Ok); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
765 return true; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
766 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
767 } |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
768 else if (method == "GET" || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
769 method == "PROPFIND" || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
770 method == "PROPPATCH" || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
771 method == "PUT" || |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
772 method == "DELETE" || |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
773 method == "HEAD" || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
774 method == "LOCK" || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
775 method == "UNLOCK" || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
776 method == "MKCOL") |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
777 { |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
778 // Locate the WebDAV bucket of interest, if any |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
779 for (HttpServer::WebDavBuckets::const_iterator bucket = buckets.begin(); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
780 bucket != buckets.end(); ++bucket) |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
781 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
782 assert(!bucket->first.empty() && |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
783 bucket->first[bucket->first.size() - 1] != '/' && |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
784 bucket->second != NULL); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
785 |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
786 if (uri == bucket->first || |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
787 boost::starts_with(uri, bucket->first + "/")) |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
788 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
789 std::string s = uri.substr(bucket->first.size()); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
790 if (s.empty()) |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
791 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
792 s = "/"; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
793 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
794 |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
795 std::vector<std::string> path; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
796 Toolbox::SplitUriComponents(path, s); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
797 |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
798 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
799 /** |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
800 * WebDAV - PROPFIND |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
801 **/ |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
802 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
803 if (method == "PROPFIND") |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
804 { |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
805 HttpToolbox::Arguments::const_iterator i = headers.find("depth"); |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
806 if (i == headers.end()) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
807 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
808 throw OrthancException(ErrorCode_NetworkProtocol, "WebDAV PROPFIND without depth"); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
809 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
810 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
811 int depth = boost::lexical_cast<int>(i->second); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
812 if (depth != 0 && |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
813 depth != 1) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
814 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
815 throw OrthancException( |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
816 ErrorCode_NetworkProtocol, |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
817 "WebDAV PROPFIND at unsupported depth (can only be 0 or 1): " + i->second); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
818 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
819 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
820 std::string answer; |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
821 |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
822 MimeType mime; |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
823 std::string content; |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
824 boost::posix_time::ptime modificationTime = boost::posix_time::second_clock::universal_time(); |
| 4246 | 825 |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
826 if (bucket->second->IsExistingFolder(path)) |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
827 { |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
828 if (depth == 0) |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
829 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
830 IWebDavBucket::Collection c; |
| 4246 | 831 c.Format(answer, uri); |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
832 } |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
833 else if (depth == 1) |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
834 { |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
835 IWebDavBucket::Collection c; |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
836 |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
837 if (!bucket->second->ListCollection(c, path)) |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
838 { |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
839 output.SendStatus(HttpStatus_404_NotFound); |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
840 return true; |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
841 } |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
842 |
| 4246 | 843 c.Format(answer, uri); |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
844 } |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
845 else |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
846 { |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
847 throw OrthancException(ErrorCode_InternalError); |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
848 } |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
849 } |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
850 else if (!path.empty() && |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
851 bucket->second->GetFileContent(mime, content, modificationTime, path)) |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
852 { |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
853 if (depth == 0 || |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
854 depth == 1) |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
855 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
856 std::unique_ptr<IWebDavBucket::File> f(new IWebDavBucket::File(path.back())); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
857 f->SetContentLength(content.size()); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
858 f->SetModificationTime(modificationTime); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
859 f->SetMimeType(mime); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
860 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
861 IWebDavBucket::Collection c; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
862 c.AddResource(f.release()); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
863 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
864 std::vector<std::string> p; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
865 Toolbox::SplitUriComponents(p, uri); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
866 if (p.empty()) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
867 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
868 throw OrthancException(ErrorCode_InternalError); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
869 } |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
870 |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
871 p.resize(p.size() - 1); |
| 4246 | 872 c.Format(answer, Toolbox::FlattenUri(p)); |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
873 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
874 else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
875 { |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
876 throw OrthancException(ErrorCode_InternalError); |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
877 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
878 } |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
879 else |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
880 { |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
881 output.SendStatus(HttpStatus_404_NotFound); |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
882 return true; |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
883 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
884 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
885 output.AddHeader("Content-Type", "application/xml; charset=UTF-8"); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
886 output.SendStatus(HttpStatus_207_MultiStatus, answer); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
887 return true; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
888 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
889 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
890 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
891 /** |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
892 * WebDAV - GET and HEAD |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
893 **/ |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
894 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
895 else if (method == "GET" || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
896 method == "HEAD") |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
897 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
898 MimeType mime; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
899 std::string content; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
900 boost::posix_time::ptime modificationTime; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
901 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
902 if (bucket->second->GetFileContent(mime, content, modificationTime, path)) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
903 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
904 output.AddHeader("Content-Type", EnumerationToString(mime)); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
905 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
906 // "Last-Modified" is necessary on Windows XP. The "Z" |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
907 // suffix is mandatory on Windows >= 7. |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
908 output.AddHeader("Last-Modified", boost::posix_time::to_iso_extended_string(modificationTime) + "Z"); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
909 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
910 if (method == "GET") |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
911 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
912 output.Answer(content); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
913 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
914 else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
915 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
916 output.SendStatus(HttpStatus_200_Ok); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
917 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
918 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
919 else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
920 { |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
921 output.SendStatus(HttpStatus_404_NotFound); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
922 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
923 |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
924 return true; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
925 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
926 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
927 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
928 /** |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
929 * WebDAV - PUT |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
930 **/ |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
931 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
932 else if (method == "PUT") |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
933 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
934 #if CIVETWEB_HAS_WEBDAV_WRITING == 1 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
935 std::string body; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
936 if (ReadBodyToString(body, connection, headers) == PostDataStatus_Success) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
937 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
938 if (bucket->second->StoreFile(body, path)) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
939 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
940 //output.SendStatus(HttpStatus_200_Ok); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
941 output.SendStatus(HttpStatus_201_Created); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
942 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
943 else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
944 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
945 output.SendStatus(HttpStatus_403_Forbidden); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
946 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
947 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
948 else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
949 { |
| 4295 | 950 CLOG(ERROR, HTTP) << "Cannot read the content of a file to be stored in WebDAV"; |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
951 output.SendStatus(HttpStatus_400_BadRequest); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
952 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
953 #else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
954 AnswerWebDavReadOnly(output, uri); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
955 #endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
956 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
957 return true; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
958 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
959 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
960 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
961 /** |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
962 * WebDAV - DELETE |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
963 **/ |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
964 |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
965 else if (method == "DELETE") |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
966 { |
| 4252 | 967 if (bucket->second->DeleteItem(path)) |
|
4232
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
968 { |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
969 output.SendStatus(HttpStatus_204_NoContent); |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
970 } |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
971 else |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
972 { |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
973 output.SendStatus(HttpStatus_403_Forbidden); |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
974 } |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
975 return true; |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
976 } |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
977 |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
978 |
|
688435755466
added DELETE in WebDAV, first working virtual filesystem
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4229
diff
changeset
|
979 /** |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
980 * WebDAV - MKCOL |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
981 **/ |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
982 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
983 else if (method == "MKCOL") |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
984 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
985 #if CIVETWEB_HAS_WEBDAV_WRITING == 1 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
986 if (bucket->second->CreateFolder(path)) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
987 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
988 //output.SendStatus(HttpStatus_200_Ok); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
989 output.SendStatus(HttpStatus_201_Created); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
990 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
991 else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
992 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
993 output.SendStatus(HttpStatus_403_Forbidden); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
994 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
995 #else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
996 AnswerWebDavReadOnly(output, uri); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
997 #endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
998 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
999 return true; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1000 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1001 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1002 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1003 /** |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1004 * WebDAV - Faking PROPPATCH, LOCK and UNLOCK |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1005 **/ |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1006 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1007 else if (method == "PROPPATCH") |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1008 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1009 #if CIVETWEB_HAS_WEBDAV_WRITING == 1 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1010 IWebDavBucket::AnswerFakedProppatch(output, uri); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1011 #else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1012 AnswerWebDavReadOnly(output, uri); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1013 #endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1014 return true; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1015 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1016 else if (method == "LOCK") |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1017 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1018 #if CIVETWEB_HAS_WEBDAV_WRITING == 1 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1019 IWebDavBucket::AnswerFakedLock(output, uri); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1020 #else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1021 AnswerWebDavReadOnly(output, uri); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1022 #endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1023 return true; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1024 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1025 else if (method == "UNLOCK") |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1026 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1027 #if CIVETWEB_HAS_WEBDAV_WRITING == 1 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1028 IWebDavBucket::AnswerFakedUnlock(output); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1029 #else |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1030 AnswerWebDavReadOnly(output, uri); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1031 #endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1032 return true; |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1033 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1034 else |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1035 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1036 throw OrthancException(ErrorCode_InternalError); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1037 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1038 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1039 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1040 |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1041 return false; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1042 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1043 else |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1044 { |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1045 /** |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1046 * WebDAV - Unapplicable method (such as POST and DELETE) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1047 **/ |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1048 |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1049 return false; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1050 } |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1051 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1052 #endif /* ORTHANC_ENABLE_PUGIXML == 1 */ |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1053 |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1054 |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1055 static void InternalCallback(HttpOutput& output /* out */, |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1056 HttpMethod& method /* out */, |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1057 HttpServer& server, |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1058 struct mg_connection *connection, |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1059 const struct mg_request_info *request) |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1060 { |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1061 bool localhost; |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1062 |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1063 #if ORTHANC_ENABLE_MONGOOSE == 1 |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1064 static const long LOCALHOST = (127ll << 24) + 1ll; |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1065 localhost = (request->remote_ip == LOCALHOST); |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1066 #elif ORTHANC_ENABLE_CIVETWEB == 1 |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1067 // The "remote_ip" field of "struct mg_request_info" is tagged as |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1068 // deprecated in Civetweb, using "remote_addr" instead. |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1069 localhost = (std::string(request->remote_addr) == "127.0.0.1"); |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1070 #else |
| 3069 | 1071 # error |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1072 #endif |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1073 |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1074 // Check remote calls |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1075 if (!server.IsRemoteAccessAllowed() && |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1076 !localhost) |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1077 { |
|
2790
c7313e1f7644
MongooseServer::SetRealm()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2635
diff
changeset
|
1078 output.SendUnauthorized(server.GetRealm()); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1079 return; |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1080 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1081 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1082 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1083 // Extract the HTTP headers |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
1084 HttpToolbox::Arguments headers; |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1085 for (int i = 0; i < request->num_headers; i++) |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1086 { |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1087 std::string name = request->http_headers[i].name; |
|
1977
ad95331c526a
trace log of http headers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1963
diff
changeset
|
1088 std::string value = request->http_headers[i].value; |
|
ad95331c526a
trace log of http headers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1963
diff
changeset
|
1089 |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1090 std::transform(name.begin(), name.end(), name.begin(), ::tolower); |
|
1977
ad95331c526a
trace log of http headers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1963
diff
changeset
|
1091 headers.insert(std::make_pair(name, value)); |
|
4294
0923247e69f6
log categories: rest -> http + added lua & jobs
Alain Mazy <alain@mazy.be>
parents:
4273
diff
changeset
|
1092 CLOG(TRACE, HTTP) << "HTTP header: [" << name << "]: [" << value << "]"; |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1093 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1094 |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1095 if (server.IsHttpCompressionEnabled()) |
| 1517 | 1096 { |
| 1097 ConfigureHttpCompression(output, headers); | |
| 1098 } | |
| 1099 | |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1100 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1101 // Extract the GET arguments |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
1102 HttpToolbox::GetArguments argumentsGET; |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1103 if (!strcmp(request->request_method, "GET")) |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1104 { |
|
1441
f3672356c121
refactoring: IHttpHandler and HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1438
diff
changeset
|
1105 HttpToolbox::ParseGetArguments(argumentsGET, request->query_string); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1106 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1107 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1108 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1109 // Authenticate this connection |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1110 if (server.IsAuthenticationEnabled() && |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1111 !IsAccessGranted(server, headers)) |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1112 { |
|
2790
c7313e1f7644
MongooseServer::SetRealm()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2635
diff
changeset
|
1113 output.SendUnauthorized(server.GetRealm()); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1114 return; |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1115 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1116 |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1117 |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1118 #if ORTHANC_ENABLE_MONGOOSE == 1 |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1119 // Apply the filter, if it is installed |
|
1571
3232f1c995a5
provide the origin of the requests to HTTP handlers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1570
diff
changeset
|
1120 char remoteIp[24]; |
|
3232f1c995a5
provide the origin of the requests to HTTP handlers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1570
diff
changeset
|
1121 sprintf(remoteIp, "%d.%d.%d.%d", |
|
3232f1c995a5
provide the origin of the requests to HTTP handlers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1570
diff
changeset
|
1122 reinterpret_cast<const uint8_t*>(&request->remote_ip) [3], |
|
3232f1c995a5
provide the origin of the requests to HTTP handlers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1570
diff
changeset
|
1123 reinterpret_cast<const uint8_t*>(&request->remote_ip) [2], |
|
3232f1c995a5
provide the origin of the requests to HTTP handlers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1570
diff
changeset
|
1124 reinterpret_cast<const uint8_t*>(&request->remote_ip) [1], |
|
3232f1c995a5
provide the origin of the requests to HTTP handlers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1570
diff
changeset
|
1125 reinterpret_cast<const uint8_t*>(&request->remote_ip) [0]); |
|
3068
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1126 |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1127 const char* requestUri = request->uri; |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1128 |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1129 #elif ORTHANC_ENABLE_CIVETWEB == 1 |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1130 const char* remoteIp = request->remote_addr; |
|
3068
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1131 const char* requestUri = request->local_uri; |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1132 #else |
| 3069 | 1133 # error |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1134 #endif |
|
1571
3232f1c995a5
provide the origin of the requests to HTTP handlers
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1570
diff
changeset
|
1135 |
|
3068
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1136 if (requestUri == NULL) |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1137 { |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1138 requestUri = ""; |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1139 } |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1140 |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1141 // Decompose the URI into its components |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1142 UriComponents uri; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1143 try |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1144 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1145 Toolbox::SplitUriComponents(uri, requestUri); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1146 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1147 catch (OrthancException&) |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1148 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1149 output.SendStatus(HttpStatus_400_BadRequest); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1150 return; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1151 } |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1152 |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1153 |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1154 // Compute the HTTP method, taking method faking into consideration |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1155 method = HttpMethod_Get; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1156 |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1157 #if ORTHANC_ENABLE_PUGIXML == 1 |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1158 bool isWebDav = false; |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1159 #endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1160 |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1161 HttpMethod filterMethod; |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1162 |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1163 |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1164 if (ExtractMethod(method, request, headers, argumentsGET)) |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1165 { |
| 4295 | 1166 CLOG(INFO, HTTP) << EnumerationToString(method) << " " << Toolbox::FlattenUri(uri); |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1167 filterMethod = method; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1168 } |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1169 #if ORTHANC_ENABLE_PUGIXML == 1 |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1170 else if (!strcmp(request->request_method, "OPTIONS") || |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1171 !strcmp(request->request_method, "PROPFIND") || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1172 !strcmp(request->request_method, "HEAD")) |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1173 { |
| 4295 | 1174 CLOG(INFO, HTTP) << "Incoming read-only WebDAV request: " |
| 1175 << request->request_method << " " << requestUri; | |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1176 filterMethod = HttpMethod_Get; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1177 isWebDav = true; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1178 } |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1179 else if (!strcmp(request->request_method, "PROPPATCH") || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1180 !strcmp(request->request_method, "LOCK") || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1181 !strcmp(request->request_method, "UNLOCK") || |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1182 !strcmp(request->request_method, "MKCOL")) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1183 { |
| 4295 | 1184 CLOG(INFO, HTTP) << "Incoming read-write WebDAV request: " |
| 1185 << request->request_method << " " << requestUri; | |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1186 filterMethod = HttpMethod_Put; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1187 isWebDav = true; |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1188 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1189 #endif /* ORTHANC_ENABLE_PUGIXML == 1 */ |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1190 else |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1191 { |
| 4295 | 1192 CLOG(INFO, HTTP) << "Unknown HTTP method: " << request->request_method; |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1193 output.SendStatus(HttpStatus_400_BadRequest); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1194 return; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1195 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1196 |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1197 |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1198 // Check that this connection is allowed by the user's authentication filter |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1199 const std::string username = GetAuthenticatedUsername(headers); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1200 |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1201 IIncomingHttpRequestFilter *filter = server.GetIncomingHttpRequestFilter(); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1202 if (filter != NULL) |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1203 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1204 if (!filter->IsAllowed(filterMethod, requestUri, remoteIp, |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1205 username.c_str(), headers, argumentsGET)) |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1206 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1207 //output.SendUnauthorized(server.GetRealm()); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1208 output.SendStatus(HttpStatus_403_Forbidden); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1209 return; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1210 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1211 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1212 |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1213 |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1214 #if ORTHANC_ENABLE_PUGIXML == 1 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1215 if (HandleWebDav(output, server.GetWebDavBuckets(), request->request_method, |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1216 headers, requestUri, connection)) |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1217 { |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1218 return; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1219 } |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1220 else if (isWebDav) |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1221 { |
| 4295 | 1222 CLOG(INFO, HTTP) << "No WebDAV bucket is registered against URI: " |
| 1223 << request->request_method << " " << requestUri; | |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1224 output.SendStatus(HttpStatus_404_NotFound); |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1225 return; |
|
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1226 } |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1227 #endif |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1228 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1229 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1230 bool found = false; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1231 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1232 // Extract the body of the request for PUT and POST, or process |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1233 // the body as a stream |
|
1446
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1443
diff
changeset
|
1234 |
|
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1443
diff
changeset
|
1235 // TODO Avoid unneccessary memcopy of the body |
|
8dc80ba768aa
refactoring: IHttpHandler does not use std::string to hold the request body
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1443
diff
changeset
|
1236 |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1237 std::string body; |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1238 if (method == HttpMethod_Post || |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1239 method == HttpMethod_Put) |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1240 { |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1241 PostDataStatus status; |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1242 |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1243 bool isMultipartForm = false; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1244 |
|
4330
a01b1c9cbef4
moving generic type definitions from IHttpHandler to HttpToolbox
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4301
diff
changeset
|
1245 HttpToolbox::Arguments::const_iterator ct = headers.find("content-type"); |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1246 if (ct != headers.end() && |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1247 ct->second.size() >= MULTIPART_FORM_LENGTH && |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1248 !memcmp(ct->second.c_str(), MULTIPART_FORM, MULTIPART_FORM_LENGTH)) |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1249 { |
| 3445 | 1250 /** |
| 1251 * The user uses the "upload" form of Orthanc Explorer, for | |
| 1252 * file uploads through a HTML form. | |
| 1253 **/ | |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1254 status = ParseMultipartForm(body, connection, headers, ct->second, server.GetChunkStore()); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1255 isMultipartForm = true; |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1256 } |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1257 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1258 if (!isMultipartForm) |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1259 { |
|
3712
2a170a8f1faf
replacing std::auto_ptr by std::unique_ptr
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3672
diff
changeset
|
1260 std::unique_ptr<IHttpHandler::IChunkedRequestReader> stream; |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1261 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1262 if (server.HasHandler()) |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1263 { |
| 3414 | 1264 found = server.GetHandler().CreateChunkedRequestReader |
| 1265 (stream, RequestOrigin_RestApi, remoteIp, username.c_str(), method, uri, headers); | |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1266 } |
| 3414 | 1267 |
| 1268 if (found) | |
| 1269 { | |
| 1270 if (stream.get() == NULL) | |
| 1271 { | |
| 1272 throw OrthancException(ErrorCode_InternalError); | |
| 1273 } | |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1274 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1275 status = ReadBodyToStream(*stream, connection, headers); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1276 |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1277 if (status == PostDataStatus_Success) |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1278 { |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1279 stream->Execute(output); |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1280 } |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1281 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1282 else |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1283 { |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1284 status = ReadBodyToString(body, connection, headers); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1285 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1286 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1287 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1288 switch (status) |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1289 { |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1290 case PostDataStatus_NoLength: |
|
1113
ba5c0908600c
Refactoring of HttpOutput ("Content-Length" header is now always sent)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1112
diff
changeset
|
1291 output.SendStatus(HttpStatus_411_LengthRequired); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1292 return; |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1293 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1294 case PostDataStatus_Failure: |
|
1113
ba5c0908600c
Refactoring of HttpOutput ("Content-Length" header is now always sent)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1112
diff
changeset
|
1295 output.SendStatus(HttpStatus_400_BadRequest); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1296 return; |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1297 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1298 case PostDataStatus_Pending: |
| 1521 | 1299 output.AnswerEmpty(); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1300 return; |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1301 |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1302 case PostDataStatus_Success: |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1303 break; |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1304 |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1305 default: |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1306 throw OrthancException(ErrorCode_InternalError); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1307 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1308 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1309 |
|
3395
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1310 if (!found && |
|
0ce9b4f5fdf5
new abstraction: IHttpHandler::CreateStreamHandler()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3357
diff
changeset
|
1311 server.HasHandler()) |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1312 { |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1313 found = server.GetHandler().Handle(output, RequestOrigin_RestApi, remoteIp, username.c_str(), |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1314 method, uri, headers, argumentsGET, body.c_str(), body.size()); |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1315 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1316 |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1317 if (!found) |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1318 { |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1319 throw OrthancException(ErrorCode_UnknownResource); |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1320 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1321 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1322 |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1323 |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1324 static void ProtectedCallback(struct mg_connection *connection, |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1325 const struct mg_request_info *request) |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1326 { |
|
1443
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1327 try |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1328 { |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1329 #if ORTHANC_ENABLE_MONGOOSE == 1 |
|
3068
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1330 void *that = request->user_data; |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1331 const char* requestUri = request->uri; |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1332 #elif ORTHANC_ENABLE_CIVETWEB == 1 |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1333 // https://github.com/civetweb/civetweb/issues/409 |
|
3068
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1334 void *that = mg_get_user_data(mg_get_context(connection)); |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1335 const char* requestUri = request->local_uri; |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1336 #else |
| 3069 | 1337 # error |
|
3068
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1338 #endif |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1339 |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1340 if (requestUri == NULL) |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1341 { |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1342 requestUri = ""; |
|
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1343 } |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1344 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1345 HttpServer* server = reinterpret_cast<HttpServer*>(that); |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1346 |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1347 if (server == NULL) |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1348 { |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1349 MongooseOutputStream stream(connection); |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1350 HttpOutput output(stream, false /* assume no keep-alive */); |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1351 output.SendStatus(HttpStatus_500_InternalServerError); |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1352 return; |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1353 } |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1354 |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1355 MongooseOutputStream stream(connection); |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1356 HttpOutput output(stream, server->IsKeepAliveEnabled()); |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1357 HttpMethod method = HttpMethod_Get; |
| 1569 | 1358 |
| 1359 try | |
| 1570 | 1360 { |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1361 try |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1362 { |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1363 InternalCallback(output, method, *server, connection, request); |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1364 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1365 catch (OrthancException&) |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1366 { |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1367 throw; // Pass the exception to the main handler below |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1368 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1369 // Now convert native exceptions as OrthancException |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1370 catch (boost::bad_lexical_cast&) |
| 1570 | 1371 { |
|
2954
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2903
diff
changeset
|
1372 throw OrthancException(ErrorCode_BadParameterType, |
|
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2903
diff
changeset
|
1373 "Syntax error in some user-supplied data"); |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1374 } |
|
3672
ea8c1c0e81eb
Fix issue #65 (Logging improvements)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1375 catch (boost::filesystem::filesystem_error& e) |
|
ea8c1c0e81eb
Fix issue #65 (Logging improvements)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1376 { |
|
ea8c1c0e81eb
Fix issue #65 (Logging improvements)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1377 throw OrthancException(ErrorCode_InternalError, |
|
ea8c1c0e81eb
Fix issue #65 (Logging improvements)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1378 "Error while accessing the filesystem: " + e.path1().string()); |
|
ea8c1c0e81eb
Fix issue #65 (Logging improvements)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1379 } |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1380 catch (std::runtime_error&) |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1381 { |
|
3672
ea8c1c0e81eb
Fix issue #65 (Logging improvements)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1382 throw OrthancException(ErrorCode_BadRequest, |
|
ea8c1c0e81eb
Fix issue #65 (Logging improvements)
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3640
diff
changeset
|
1383 "Presumably an error while parsing the JSON body"); |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1384 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1385 catch (std::bad_alloc&) |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1386 { |
|
2954
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2903
diff
changeset
|
1387 throw OrthancException(ErrorCode_NotEnoughMemory, |
|
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2903
diff
changeset
|
1388 "The server hosting Orthanc is running out of memory"); |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1389 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1390 catch (...) |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1391 { |
|
2954
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2903
diff
changeset
|
1392 throw OrthancException(ErrorCode_InternalError, |
|
d924f9bb61cc
taking advantage of details in OrthancException
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2903
diff
changeset
|
1393 "An unhandled exception was generated inside the HTTP server"); |
| 1570 | 1394 } |
| 1395 } | |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1396 catch (OrthancException& e) |
| 1570 | 1397 { |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1398 assert(server != NULL); |
| 1569 | 1399 |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1400 // Using this candidate handler results in an exception |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1401 try |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1402 { |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1403 if (server->GetExceptionFormatter() == NULL) |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1404 { |
| 4295 | 1405 CLOG(ERROR, HTTP) << "Exception in the HTTP handler: " << e.What(); |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1406 output.SendStatus(e.GetHttpStatus()); |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1407 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1408 else |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1409 { |
|
3068
ad37c21ec4db
fix compatibility with civetweb 1.11
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3060
diff
changeset
|
1410 server->GetExceptionFormatter()->Format(output, e, method, requestUri); |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1411 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1412 } |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1413 catch (OrthancException&) |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1414 { |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1415 // An exception here reflects the fact that the status code |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1416 // was already set by the HTTP handler. |
|
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1417 } |
| 1570 | 1418 } |
|
1443
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1419 } |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1420 catch (...) |
|
1443
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1421 { |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1422 // We should never arrive at this point, where it is even impossible to send an answer |
| 4295 | 1423 CLOG(ERROR, HTTP) << "Catastrophic error inside the HTTP server, giving up"; |
|
1443
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1424 } |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1425 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1426 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1427 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1428 #if MONGOOSE_USE_CALLBACKS == 0 |
| 0 | 1429 static void* Callback(enum mg_event event, |
| 1430 struct mg_connection *connection, | |
| 1431 const struct mg_request_info *request) | |
| 1432 { | |
| 1433 if (event == MG_NEW_REQUEST) | |
| 1434 { | |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1435 ProtectedCallback(connection, request); |
| 0 | 1436 |
| 1437 // Mark as processed | |
| 1438 return (void*) ""; | |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1439 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1440 else |
| 0 | 1441 { |
| 1442 return NULL; | |
| 1443 } | |
| 1444 } | |
| 1445 | |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1446 #elif MONGOOSE_USE_CALLBACKS == 1 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1447 static int Callback(struct mg_connection *connection) |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1448 { |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1449 const struct mg_request_info *request = mg_get_request_info(connection); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1450 |
|
2134
ddc75c6c712d
Avoid hard crash if not enough memory
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2133
diff
changeset
|
1451 ProtectedCallback(connection, request); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1452 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1453 return 1; // Do not let Mongoose handle the request by itself |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1454 } |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1455 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1456 #else |
| 3069 | 1457 # error Please set MONGOOSE_USE_CALLBACKS |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1458 #endif |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1459 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1460 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1461 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1462 |
| 0 | 1463 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1464 bool HttpServer::IsRunning() const |
| 0 | 1465 { |
| 1466 return (pimpl_->context_ != NULL); | |
| 1467 } | |
| 1468 | |
| 1469 | |
| 4201 | 1470 HttpServer::HttpServer() : |
| 1471 pimpl_(new PImpl), | |
| 1472 handler_(NULL), | |
| 1473 remoteAllowed_(false), | |
| 1474 authentication_(false), | |
| 1475 sslVerifyPeers_(false), | |
| 1476 ssl_(false), | |
| 1477 port_(8000), | |
| 1478 filter_(NULL), | |
| 1479 keepAlive_(false), | |
| 1480 httpCompression_(true), | |
| 1481 exceptionFormatter_(NULL), | |
| 1482 realm_(ORTHANC_REALM), | |
| 1483 threadsCount_(50), // Default value in mongoose | |
| 1484 tcpNoDelay_(true), | |
| 1485 requestTimeout_(30) // Default value in mongoose/civetweb (30 seconds) | |
| 0 | 1486 { |
|
3145
239331e4ee0b
log about what HTTP server is running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3138
diff
changeset
|
1487 #if ORTHANC_ENABLE_MONGOOSE == 1 |
| 4295 | 1488 CLOG(INFO, HTTP) << "This Orthanc server uses Mongoose as its embedded HTTP server"; |
|
3145
239331e4ee0b
log about what HTTP server is running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3138
diff
changeset
|
1489 #endif |
|
239331e4ee0b
log about what HTTP server is running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3138
diff
changeset
|
1490 |
|
239331e4ee0b
log about what HTTP server is running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3138
diff
changeset
|
1491 #if ORTHANC_ENABLE_CIVETWEB == 1 |
| 4295 | 1492 CLOG(INFO, HTTP) << "This Orthanc server uses CivetWeb as its embedded HTTP server"; |
|
3145
239331e4ee0b
log about what HTTP server is running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3138
diff
changeset
|
1493 #endif |
|
239331e4ee0b
log about what HTTP server is running
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3138
diff
changeset
|
1494 |
|
2136
dd609a99d39a
uniformization of the macro naming
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2134
diff
changeset
|
1495 #if ORTHANC_ENABLE_SSL == 1 |
| 749 | 1496 // Check for the Heartbleed exploit |
|
748
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
1497 // https://en.wikipedia.org/wiki/OpenSSL#Heartbleed_bug |
|
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
1498 if (OPENSSL_VERSION_NUMBER < 0x1000107fL /* openssl-1.0.1g */ && |
|
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
1499 OPENSSL_VERSION_NUMBER >= 0x1000100fL /* openssl-1.0.1 */) |
|
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
1500 { |
| 4295 | 1501 CLOG(WARNING, HTTP) << "This version of OpenSSL is vulnerable to the Heartbleed exploit"; |
|
748
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
1502 } |
|
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
1503 #endif |
| 0 | 1504 } |
| 1505 | |
| 1506 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1507 HttpServer::~HttpServer() |
| 0 | 1508 { |
| 1509 Stop(); | |
|
4226
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1510 |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1511 #if ORTHANC_ENABLE_PUGIXML == 1 |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1512 for (WebDavBuckets::iterator it = webDavBuckets_.begin(); it != webDavBuckets_.end(); ++it) |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1513 { |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1514 assert(it->second != NULL); |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1515 delete it->second; |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1516 } |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1517 #endif |
| 0 | 1518 } |
| 1519 | |
| 1520 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1521 void HttpServer::SetPortNumber(uint16_t port) |
| 0 | 1522 { |
| 1523 Stop(); | |
| 1524 port_ = port; | |
| 1525 } | |
| 1526 | |
| 4298 | 1527 uint16_t HttpServer::GetPortNumber() const |
| 1528 { | |
| 1529 return port_; | |
| 1530 } | |
| 1531 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1532 void HttpServer::Start() |
| 0 | 1533 { |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1534 #if ORTHANC_ENABLE_MONGOOSE == 1 |
| 4295 | 1535 CLOG(INFO, HTTP) << "Starting embedded Web server using Mongoose"; |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1536 #elif ORTHANC_ENABLE_CIVETWEB == 1 |
| 4295 | 1537 CLOG(INFO, HTTP) << "Starting embedded Web server using Civetweb"; |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1538 #else |
| 3069 | 1539 # error |
|
2377
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1540 #endif |
|
32bea64e070b
Experimental support of actively maintained Civetweb to replace Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2268
diff
changeset
|
1541 |
| 0 | 1542 if (!IsRunning()) |
| 1543 { | |
| 1544 std::string port = boost::lexical_cast<std::string>(port_); | |
|
2903
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1545 std::string numThreads = boost::lexical_cast<std::string>(threadsCount_); |
|
3537
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1546 std::string requestTimeoutMilliseconds = boost::lexical_cast<std::string>(requestTimeout_ * 1000); |
|
4301
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1547 std::string keepAliveTimeoutMilliseconds = boost::lexical_cast<std::string>(CIVETWEB_KEEP_ALIVE_TIMEOUT_SECONDS * 1000); |
| 0 | 1548 |
| 23 | 1549 if (ssl_) |
| 1550 { | |
| 1551 port += "s"; | |
| 1552 } | |
| 1553 | |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1554 std::vector<const char*> options; |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1555 |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1556 // Set the TCP port for the HTTP server |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1557 options.push_back("listening_ports"); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1558 options.push_back(port.c_str()); |
|
1110
becde5351e47
preparing to update mongoose
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1100
diff
changeset
|
1559 |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1560 // Optimization reported by Chris Hafey |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1561 // https://groups.google.com/d/msg/orthanc-users/CKueKX0pJ9E/_UCbl8T-VjIJ |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1562 options.push_back("enable_keep_alive"); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1563 options.push_back(keepAlive_ ? "yes" : "no"); |
|
1110
becde5351e47
preparing to update mongoose
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1100
diff
changeset
|
1564 |
| 2579 | 1565 #if ORTHANC_ENABLE_CIVETWEB == 1 |
|
4301
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1566 /** |
|
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1567 * The "keep_alive_timeout_ms" cannot use milliseconds, as the |
|
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1568 * value of "timeout" in the HTTP header "Keep-Alive" must be |
|
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1569 * expressed in seconds (at least for the Java client). |
|
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1570 * https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Keep-Alive |
|
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1571 * https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md#enable_keep_alive-no |
|
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1572 * https://github.com/civetweb/civetweb/blob/master/docs/UserManual.md#keep_alive_timeout_ms-500-or-0 |
|
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1573 **/ |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1574 options.push_back("keep_alive_timeout_ms"); |
|
4301
6919242d2265
Fix keep-alive in the embedded HTTP server by setting the "Keep-Alive" HTTP header
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4298
diff
changeset
|
1575 options.push_back(keepAlive_ ? keepAliveTimeoutMilliseconds.c_str() : "0"); |
|
2577
6783a7c02990
keep_alive_timeout_ms for civetweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1576 #endif |
|
2903
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1577 |
|
3136
f948deef53d9
using tcp_nodelay in civetweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3069
diff
changeset
|
1578 #if ORTHANC_ENABLE_CIVETWEB == 1 |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1579 // Disable TCP Nagle's algorithm to maximize speed (this |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1580 // option is not available in Mongoose). |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1581 // https://groups.google.com/d/topic/civetweb/35HBR9seFjU/discussion |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1582 // https://eklitzke.org/the-caveats-of-tcp-nodelay |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1583 options.push_back("tcp_nodelay"); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1584 options.push_back(tcpNoDelay_ ? "1" : "0"); |
|
3136
f948deef53d9
using tcp_nodelay in civetweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3069
diff
changeset
|
1585 #endif |
|
f948deef53d9
using tcp_nodelay in civetweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3069
diff
changeset
|
1586 |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1587 // Set the number of threads |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1588 options.push_back("num_threads"); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1589 options.push_back(numThreads.c_str()); |
|
2577
6783a7c02990
keep_alive_timeout_ms for civetweb
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2447
diff
changeset
|
1590 |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1591 // Set the timeout for the HTTP server |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1592 options.push_back("request_timeout_ms"); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1593 options.push_back(requestTimeoutMilliseconds.c_str()); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1594 |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1595 // Set the client authentication |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1596 options.push_back("ssl_verify_peer"); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1597 options.push_back(sslVerifyPeers_ ? "yes" : "no"); |
|
3537
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1598 |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1599 if (sslVerifyPeers_) |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1600 { |
|
4190
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1601 // Set the trusted client certificates (for X509 mutual authentication) |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1602 options.push_back("ssl_ca_file"); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1603 options.push_back(trustedClientCertificates_.c_str()); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1604 } |
|
4190
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1605 |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1606 if (ssl_) |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1607 { |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1608 // Set the SSL certificate, if any |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1609 options.push_back("ssl_certificate"); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1610 options.push_back(certificate_.c_str()); |
| 0 | 1611 }; |
| 1612 | |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1613 assert(options.size() % 2 == 0); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1614 options.push_back(NULL); |
|
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1615 |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1616 #if MONGOOSE_USE_CALLBACKS == 0 |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1617 pimpl_->context_ = mg_start(&Callback, this, &options[0]); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1618 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1619 #elif MONGOOSE_USE_CALLBACKS == 1 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1620 struct mg_callbacks callbacks; |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1621 memset(&callbacks, 0, sizeof(callbacks)); |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1622 callbacks.begin_request = Callback; |
|
4193
ff24a06b3474
fix HttpServer options if sslVerifyPeers_ == false and ssl_ == true
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4190
diff
changeset
|
1623 pimpl_->context_ = mg_start(&callbacks, this, &options[0]); |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1624 |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1625 #else |
| 3069 | 1626 # error Please set MONGOOSE_USE_CALLBACKS |
|
1112
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1627 #endif |
|
a119f9ae3640
upgrade to Mongoose 3.8
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1110
diff
changeset
|
1628 |
| 0 | 1629 if (!pimpl_->context_) |
| 1630 { | |
|
3801
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1631 bool isSslError = false; |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1632 |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1633 #if ORTHANC_ENABLE_SSL == 1 |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1634 for (;;) |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1635 { |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1636 unsigned long code = ERR_get_error(); |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1637 if (code == 0) |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1638 { |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1639 break; |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1640 } |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1641 else |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1642 { |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1643 isSslError = true; |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1644 char message[1024]; |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1645 ERR_error_string_n(code, message, sizeof(message) - 1); |
| 4295 | 1646 CLOG(ERROR, HTTP) << "OpenSSL error: " << message; |
|
3801
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1647 } |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1648 } |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1649 #endif |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1650 |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1651 if (isSslError) |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1652 { |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1653 throw OrthancException(ErrorCode_SslInitialization); |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1654 } |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1655 else |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1656 { |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1657 throw OrthancException(ErrorCode_HttpPortInUse, |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1658 " (port = " + boost::lexical_cast<std::string>(port_) + ")"); |
|
9fe1d64a748c
upgrade to civetweb 1.12, error reporting if OpenSSL failure
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3712
diff
changeset
|
1659 } |
| 0 | 1660 } |
|
2633
40c7926b75f8
log about remote access allowed
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2579
diff
changeset
|
1661 |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1662 #if ORTHANC_ENABLE_PUGIXML == 1 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1663 for (WebDavBuckets::iterator it = webDavBuckets_.begin(); it != webDavBuckets_.end(); ++it) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1664 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1665 assert(it->second != NULL); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1666 it->second->Start(); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1667 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1668 #endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1669 |
| 4295 | 1670 CLOG(WARNING, HTTP) << "HTTP server listening on port: " << GetPortNumber() |
| 1671 << " (HTTPS encryption is " | |
| 1672 << (IsSslEnabled() ? "enabled" : "disabled") | |
| 1673 << ", remote access is " | |
| 1674 << (IsRemoteAccessAllowed() ? "" : "not ") | |
| 1675 << "allowed)"; | |
| 0 | 1676 } |
| 1677 } | |
| 1678 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1679 void HttpServer::Stop() |
| 0 | 1680 { |
| 1681 if (IsRunning()) | |
| 1682 { | |
| 1683 mg_stop(pimpl_->context_); | |
|
4228
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1684 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1685 #if ORTHANC_ENABLE_PUGIXML == 1 |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1686 for (WebDavBuckets::iterator it = webDavBuckets_.begin(); it != webDavBuckets_.end(); ++it) |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1687 { |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1688 assert(it->second != NULL); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1689 it->second->Stop(); |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1690 } |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1691 #endif |
|
c8c0bbaaace3
write access to webdav
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4227
diff
changeset
|
1692 |
| 0 | 1693 pimpl_->context_ = NULL; |
| 1694 } | |
| 1695 } | |
| 1696 | |
| 1697 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1698 void HttpServer::ClearUsers() |
|
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1699 { |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1700 Stop(); |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1701 registeredUsers_.clear(); |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1702 } |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1703 |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1704 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1705 void HttpServer::RegisterUser(const char* username, |
|
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1706 const char* password) |
| 23 | 1707 { |
| 1708 Stop(); | |
| 24 | 1709 |
| 1710 std::string tag = std::string(username) + ":" + std::string(password); | |
|
809
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
749
diff
changeset
|
1711 std::string encoded; |
|
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
749
diff
changeset
|
1712 Toolbox::EncodeBase64(encoded, tag); |
|
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
749
diff
changeset
|
1713 registeredUsers_.insert(encoded); |
| 23 | 1714 } |
| 1715 | |
| 4298 | 1716 bool HttpServer::IsAuthenticationEnabled() const |
| 1717 { | |
| 1718 return authentication_; | |
| 1719 } | |
| 1720 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1721 void HttpServer::SetSslEnabled(bool enabled) |
| 23 | 1722 { |
| 1723 Stop(); | |
| 1724 | |
|
2136
dd609a99d39a
uniformization of the macro naming
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2134
diff
changeset
|
1725 #if ORTHANC_ENABLE_SSL == 0 |
| 23 | 1726 if (enabled) |
| 1727 { | |
|
1674
4fc502d469f4
fix build if SSL is disabled
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1649
diff
changeset
|
1728 throw OrthancException(ErrorCode_SslDisabled); |
| 23 | 1729 } |
| 1730 else | |
| 1731 { | |
| 1732 ssl_ = false; | |
| 1733 } | |
| 1734 #else | |
| 1735 ssl_ = enabled; | |
| 1736 #endif | |
| 1737 } | |
| 1738 | |
|
4190
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1739 void HttpServer::SetSslVerifyPeers(bool enabled) |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1740 { |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1741 Stop(); |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1742 |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1743 #if ORTHANC_ENABLE_SSL == 0 |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1744 if (enabled) |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1745 { |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1746 throw OrthancException(ErrorCode_SslDisabled); |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1747 } |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1748 else |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1749 { |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1750 sslVerifyPeers_ = false; |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1751 } |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1752 #else |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1753 sslVerifyPeers_ = enabled; |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1754 #endif |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1755 } |
|
1115
da56a7916e8a
Experimental "KeepAlive" configuration option to enable HTTP Keep-Alive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1113
diff
changeset
|
1756 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1757 void HttpServer::SetKeepAliveEnabled(bool enabled) |
|
1115
da56a7916e8a
Experimental "KeepAlive" configuration option to enable HTTP Keep-Alive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1113
diff
changeset
|
1758 { |
|
da56a7916e8a
Experimental "KeepAlive" configuration option to enable HTTP Keep-Alive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1113
diff
changeset
|
1759 Stop(); |
|
da56a7916e8a
Experimental "KeepAlive" configuration option to enable HTTP Keep-Alive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1113
diff
changeset
|
1760 keepAlive_ = enabled; |
| 4295 | 1761 CLOG(INFO, HTTP) << "HTTP keep alive is " << (enabled ? "enabled" : "disabled"); |
|
3137
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1762 |
|
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1763 #if ORTHANC_ENABLE_MONGOOSE == 1 |
|
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1764 if (enabled) |
|
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1765 { |
| 4295 | 1766 CLOG(WARNING, HTTP) << "You should disable HTTP keep alive, as you are using Mongoose"; |
|
3137
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1767 } |
|
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1768 #endif |
|
1115
da56a7916e8a
Experimental "KeepAlive" configuration option to enable HTTP Keep-Alive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1113
diff
changeset
|
1769 } |
|
da56a7916e8a
Experimental "KeepAlive" configuration option to enable HTTP Keep-Alive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1113
diff
changeset
|
1770 |
| 4298 | 1771 const std::string &HttpServer::GetSslCertificate() const |
| 1772 { | |
| 1773 return certificate_; | |
| 1774 } | |
| 1775 | |
|
1115
da56a7916e8a
Experimental "KeepAlive" configuration option to enable HTTP Keep-Alive
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1113
diff
changeset
|
1776 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1777 void HttpServer::SetAuthenticationEnabled(bool enabled) |
|
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1778 { |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1779 Stop(); |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1780 authentication_ = enabled; |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1781 } |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1782 |
| 4298 | 1783 bool HttpServer::IsSslEnabled() const |
| 1784 { | |
| 1785 return ssl_; | |
| 1786 } | |
| 1787 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1788 void HttpServer::SetSslCertificate(const char* path) |
| 23 | 1789 { |
| 1790 Stop(); | |
| 1791 certificate_ = path; | |
| 1792 } | |
|
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1793 |
| 4298 | 1794 bool HttpServer::IsRemoteAccessAllowed() const |
| 1795 { | |
| 1796 return remoteAllowed_; | |
| 1797 } | |
| 1798 | |
|
4190
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1799 void HttpServer::SetSslTrustedClientCertificates(const char* path) |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1800 { |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1801 Stop(); |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1802 trustedClientCertificates_ = path; |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1803 } |
|
9ce5c89328f5
New configuration options to enable HTTP peers identification through certificates
Alain Mazy <alain@mazy.be>
parents:
4152
diff
changeset
|
1804 |
| 4298 | 1805 bool HttpServer::IsKeepAliveEnabled() const |
| 1806 { | |
| 1807 return keepAlive_; | |
| 1808 } | |
| 1809 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1810 void HttpServer::SetRemoteAccessAllowed(bool allowed) |
|
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
1811 { |
|
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
1812 Stop(); |
|
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
1813 remoteAllowed_ = allowed; |
|
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
1814 } |
|
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
1815 |
| 4298 | 1816 bool HttpServer::IsHttpCompressionEnabled() const |
| 1817 { | |
| 1818 return httpCompression_;; | |
| 1819 } | |
| 1820 | |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1821 void HttpServer::SetHttpCompressionEnabled(bool enabled) |
| 1517 | 1822 { |
| 1823 Stop(); | |
| 1824 httpCompression_ = enabled; | |
| 4295 | 1825 CLOG(WARNING, HTTP) << "HTTP compression is " << (enabled ? "enabled" : "disabled"); |
| 1517 | 1826 } |
| 4298 | 1827 |
| 1828 IIncomingHttpRequestFilter *HttpServer::GetIncomingHttpRequestFilter() const | |
| 1829 { | |
| 1830 return filter_; | |
| 1831 } | |
|
1592
d73124f6b439
configuration option HttpDescribeErrors
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1582
diff
changeset
|
1832 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1833 void HttpServer::SetIncomingHttpRequestFilter(IIncomingHttpRequestFilter& filter) |
|
409
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
1834 { |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
1835 Stop(); |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
1836 filter_ = &filter; |
|
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
1837 } |
|
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
1838 |
|
1645
1558b3226b18
IHttpExceptionFormatter
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1644
diff
changeset
|
1839 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1840 void HttpServer::SetHttpExceptionFormatter(IHttpExceptionFormatter& formatter) |
|
1645
1558b3226b18
IHttpExceptionFormatter
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1644
diff
changeset
|
1841 { |
|
1558b3226b18
IHttpExceptionFormatter
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1644
diff
changeset
|
1842 Stop(); |
|
1558b3226b18
IHttpExceptionFormatter
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1644
diff
changeset
|
1843 exceptionFormatter_ = &formatter; |
|
1558b3226b18
IHttpExceptionFormatter
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1644
diff
changeset
|
1844 } |
|
1558b3226b18
IHttpExceptionFormatter
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1644
diff
changeset
|
1845 |
| 4298 | 1846 IHttpExceptionFormatter *HttpServer::GetExceptionFormatter() |
| 1847 { | |
| 1848 return exceptionFormatter_; | |
| 1849 } | |
| 1850 | |
| 1851 const std::string &HttpServer::GetRealm() const | |
| 1852 { | |
| 1853 return realm_; | |
| 1854 } | |
| 1855 | |
| 1856 void HttpServer::SetRealm(const std::string &realm) | |
| 1857 { | |
| 1858 realm_ = realm; | |
| 1859 } | |
| 1860 | |
|
1645
1558b3226b18
IHttpExceptionFormatter
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1644
diff
changeset
|
1861 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1862 bool HttpServer::IsValidBasicHttpAuthentication(const std::string& basic) const |
|
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1863 { |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1864 return registeredUsers_.find(basic) != registeredUsers_.end(); |
|
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
1865 } |
|
1443
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1866 |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1867 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1868 void HttpServer::Register(IHttpHandler& handler) |
|
1443
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1869 { |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1870 Stop(); |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1871 handler_ = &handler; |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1872 } |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1873 |
| 4298 | 1874 bool HttpServer::HasHandler() const |
| 1875 { | |
| 1876 return handler_ != NULL; | |
| 1877 } | |
| 1878 | |
|
1443
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1879 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1880 IHttpHandler& HttpServer::GetHandler() const |
|
1443
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1881 { |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1882 if (handler_ == NULL) |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1883 { |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1884 throw OrthancException(ErrorCode_InternalError); |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1885 } |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1886 |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1887 return *handler_; |
|
895ab369d63c
refactoring: OrthancHttpHandler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
1441
diff
changeset
|
1888 } |
|
2903
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1889 |
|
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1890 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1891 void HttpServer::SetThreadsCount(unsigned int threads) |
|
2903
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1892 { |
| 4201 | 1893 if (threads == 0) |
|
2903
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1894 { |
|
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1895 throw OrthancException(ErrorCode_ParameterOutOfRange); |
|
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1896 } |
|
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1897 |
|
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1898 Stop(); |
|
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1899 threadsCount_ = threads; |
|
3180
07a2f637b76d
new option: "HttpThreadsCount" to set the number of threads in the embedded HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3178
diff
changeset
|
1900 |
| 4295 | 1901 CLOG(INFO, HTTP) << "The embedded HTTP server will use " << threads << " threads"; |
|
2903
1153b1a128fe
MongooseServer::SetThreadsCount()
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
2895
diff
changeset
|
1902 } |
|
3137
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1903 |
| 4298 | 1904 unsigned int HttpServer::GetThreadsCount() const |
| 1905 { | |
| 1906 return threadsCount_; | |
| 1907 } | |
| 1908 | |
|
3537
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1909 |
|
3138
ab46e537f92e
renamed class MongooseServer as HttpServer, CivetWeb made default HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3137
diff
changeset
|
1910 void HttpServer::SetTcpNoDelay(bool tcpNoDelay) |
|
3137
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1911 { |
|
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1912 Stop(); |
|
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1913 tcpNoDelay_ = tcpNoDelay; |
| 4295 | 1914 CLOG(INFO, HTTP) << "TCP_NODELAY for the HTTP sockets is set to " |
| 1915 << (tcpNoDelay ? "true" : "false"); | |
|
3137
5a3b961e9524
New configuration option: 'TcpNoDelay' to disable Nagle's algorithm in HTTP server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3136
diff
changeset
|
1916 } |
|
3537
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1917 |
| 4298 | 1918 bool HttpServer::IsTcpNoDelay() const |
| 1919 { | |
| 1920 return tcpNoDelay_; | |
| 1921 } | |
| 1922 | |
|
3537
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1923 |
|
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1924 void HttpServer::SetRequestTimeout(unsigned int seconds) |
|
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1925 { |
| 4201 | 1926 if (seconds == 0) |
|
3537
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1927 { |
|
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1928 throw OrthancException(ErrorCode_ParameterOutOfRange, |
|
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1929 "Request timeout must be a stricly positive integer"); |
|
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1930 } |
|
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1931 |
|
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1932 Stop(); |
|
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1933 requestTimeout_ = seconds; |
| 4295 | 1934 CLOG(INFO, HTTP) << "Request timeout in the HTTP server is set to " << seconds << " seconds"; |
|
3537
9cc09f4c0fa9
New configuration option: "HttpRequestTimeout"
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
3445
diff
changeset
|
1935 } |
|
4226
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1936 |
| 4298 | 1937 unsigned int HttpServer::GetRequestTimeout() const |
| 1938 { | |
| 1939 return requestTimeout_; | |
| 1940 } | |
| 1941 | |
| 1942 | |
| 1943 #if ORTHANC_ENABLE_PUGIXML == 1 | |
| 1944 HttpServer::WebDavBuckets& HttpServer::GetWebDavBuckets() | |
| 1945 { | |
| 1946 return webDavBuckets_; | |
| 1947 } | |
| 1948 #endif | |
| 1949 | |
|
4226
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1950 |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1951 #if ORTHANC_ENABLE_PUGIXML == 1 |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1952 void HttpServer::Register(const std::vector<std::string>& root, |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1953 IWebDavBucket* bucket) |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1954 { |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1955 std::unique_ptr<IWebDavBucket> protection(bucket); |
| 4229 | 1956 |
|
4226
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1957 if (bucket == NULL) |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1958 { |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1959 throw OrthancException(ErrorCode_NullPointer); |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1960 } |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1961 |
| 4229 | 1962 Stop(); |
| 1963 | |
| 1964 #if CIVETWEB_HAS_WEBDAV_WRITING == 0 | |
| 1965 if (webDavBuckets_.size() == 0) | |
| 1966 { | |
| 4295 | 1967 CLOG(WARNING, HTTP) << "Your version of the Orthanc framework was compiled " |
| 1968 << "without support for writing into WebDAV collections"; | |
| 4229 | 1969 } |
| 1970 #endif | |
| 1971 | |
|
4227
7fff7e683d65
basic implementation of WebDAV handler
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4226
diff
changeset
|
1972 const std::string s = Toolbox::FlattenUri(root); |
|
4226
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1973 |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1974 if (webDavBuckets_.find(s) != webDavBuckets_.end()) |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1975 { |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1976 throw OrthancException(ErrorCode_ParameterOutOfRange, |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1977 "Cannot register two WebDAV buckets at the same root: " + s); |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1978 } |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1979 else |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1980 { |
| 4295 | 1981 CLOG(INFO, HTTP) << "Branching WebDAV bucket at: " << s; |
|
4226
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1982 webDavBuckets_[s] = protection.release(); |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1983 } |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1984 } |
|
7bd5eab3ba25
prototyping IWebDavBucket
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
4201
diff
changeset
|
1985 #endif |
| 0 | 1986 } |