Mercurial > hg > orthanc
annotate Core/HttpServer/MongooseServer.cpp @ 809:8ce2f69436ca
do not return strings with base64
author | Sebastien Jodogne <s.jodogne@gmail.com> |
---|---|
date | Wed, 07 May 2014 16:39:53 +0200 |
parents | b8c49473be38 |
children | a811bdf8b8eb |
rev | line source |
---|---|
0 | 1 /** |
59 | 2 * Orthanc - A Lightweight, RESTful DICOM Store |
689 | 3 * Copyright (C) 2012-2014 Medical Physics Department, CHU of Liege, |
0 | 4 * Belgium |
5 * | |
6 * This program is free software: you can redistribute it and/or | |
7 * modify it under the terms of the GNU General Public License as | |
8 * published by the Free Software Foundation, either version 3 of the | |
9 * License, or (at your option) any later version. | |
136 | 10 * |
11 * In addition, as a special exception, the copyright holders of this | |
12 * program give permission to link the code of its release with the | |
13 * OpenSSL project's "OpenSSL" library (or with modified versions of it | |
14 * that use the same license as the "OpenSSL" library), and distribute | |
15 * the linked executables. You must obey the GNU General Public License | |
16 * in all respects for all of the code used other than "OpenSSL". If you | |
17 * modify file(s) with this exception, you may extend this exception to | |
18 * your version of the file(s), but you are not obligated to do so. If | |
19 * you do not wish to do so, delete this exception statement from your | |
20 * version. If you delete this exception statement from all source files | |
21 * in the program, then also delete it here. | |
0 | 22 * |
23 * This program is distributed in the hope that it will be useful, but | |
24 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
26 * General Public License for more details. | |
27 * | |
28 * You should have received a copy of the GNU General Public License | |
29 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
30 **/ | |
31 | |
32 | |
33 // http://en.highscore.de/cpp/boost/stringhandling.html | |
34 | |
35 #include "MongooseServer.h" | |
36 | |
37 #include <algorithm> | |
38 #include <string.h> | |
39 #include <boost/lexical_cast.hpp> | |
40 #include <boost/algorithm/string.hpp> | |
41 #include <iostream> | |
42 #include <string.h> | |
43 #include <stdio.h> | |
44 #include <boost/thread.hpp> | |
108 | 45 #include <glog/logging.h> |
0 | 46 |
59 | 47 #include "../OrthancException.h" |
0 | 48 #include "../ChunkedBuffer.h" |
324 | 49 #include "HttpOutput.h" |
0 | 50 #include "mongoose.h" |
51 | |
748
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
52 #if ORTHANC_SSL_ENABLED == 1 |
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
53 #include <openssl/opensslv.h> |
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
54 #endif |
0 | 55 |
59 | 56 #define ORTHANC_REALM "Orthanc Secure Area" |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
57 |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
58 static const long LOCALHOST = (127ll << 24) + 1ll; |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
59 |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
60 |
59 | 61 namespace Orthanc |
0 | 62 { |
63 static const char multipart[] = "multipart/form-data; boundary="; | |
64 static unsigned int multipartLength = sizeof(multipart) / sizeof(char) - 1; | |
65 | |
66 | |
67 namespace | |
68 { | |
69 // Anonymous namespace to avoid clashes between compilation modules | |
70 class MongooseOutput : public HttpOutput | |
71 { | |
72 private: | |
73 struct mg_connection* connection_; | |
74 | |
75 public: | |
76 MongooseOutput(struct mg_connection* connection) : connection_(connection) | |
77 { | |
78 } | |
79 | |
80 virtual void Send(const void* buffer, size_t length) | |
81 { | |
217 | 82 if (length > 0) |
83 { | |
84 mg_write(connection_, buffer, length); | |
85 } | |
0 | 86 } |
87 }; | |
88 | |
89 | |
90 enum PostDataStatus | |
91 { | |
92 PostDataStatus_Success, | |
93 PostDataStatus_NoLength, | |
94 PostDataStatus_Pending, | |
95 PostDataStatus_Failure | |
96 }; | |
97 } | |
98 | |
99 | |
100 // TODO Move this to external file | |
101 | |
102 | |
103 class ChunkedFile : public ChunkedBuffer | |
104 { | |
105 private: | |
106 std::string filename_; | |
107 | |
108 public: | |
109 ChunkedFile(const std::string& filename) : | |
110 filename_(filename) | |
111 { | |
112 } | |
113 | |
114 const std::string& GetFilename() const | |
115 { | |
116 return filename_; | |
117 } | |
118 }; | |
119 | |
120 | |
121 | |
122 class ChunkStore | |
123 { | |
124 private: | |
125 typedef std::list<ChunkedFile*> Content; | |
126 Content content_; | |
127 unsigned int numPlaces_; | |
128 | |
129 boost::mutex mutex_; | |
130 std::set<std::string> discardedFiles_; | |
131 | |
132 void Clear() | |
133 { | |
134 for (Content::iterator it = content_.begin(); | |
656 | 135 it != content_.end(); ++it) |
0 | 136 { |
137 delete *it; | |
138 } | |
139 } | |
140 | |
141 Content::iterator Find(const std::string& filename) | |
142 { | |
143 for (Content::iterator it = content_.begin(); | |
656 | 144 it != content_.end(); ++it) |
0 | 145 { |
146 if ((*it)->GetFilename() == filename) | |
147 { | |
148 return it; | |
149 } | |
150 } | |
151 | |
152 return content_.end(); | |
153 } | |
154 | |
155 void Remove(const std::string& filename) | |
156 { | |
157 Content::iterator it = Find(filename); | |
158 if (it != content_.end()) | |
159 { | |
160 delete *it; | |
161 content_.erase(it); | |
162 } | |
163 } | |
164 | |
165 public: | |
166 ChunkStore() | |
167 { | |
168 numPlaces_ = 10; | |
169 } | |
170 | |
171 ~ChunkStore() | |
172 { | |
173 Clear(); | |
174 } | |
175 | |
176 PostDataStatus Store(std::string& completed, | |
177 const char* chunkData, | |
178 size_t chunkSize, | |
179 const std::string& filename, | |
180 size_t filesize) | |
181 { | |
182 boost::mutex::scoped_lock lock(mutex_); | |
183 | |
184 std::set<std::string>::iterator wasDiscarded = discardedFiles_.find(filename); | |
185 if (wasDiscarded != discardedFiles_.end()) | |
186 { | |
187 discardedFiles_.erase(wasDiscarded); | |
188 return PostDataStatus_Failure; | |
189 } | |
190 | |
191 ChunkedFile* f; | |
192 Content::iterator it = Find(filename); | |
193 if (it == content_.end()) | |
194 { | |
195 f = new ChunkedFile(filename); | |
196 | |
197 // Make some room | |
198 if (content_.size() >= numPlaces_) | |
199 { | |
200 discardedFiles_.insert(content_.front()->GetFilename()); | |
201 delete content_.front(); | |
202 content_.pop_front(); | |
203 } | |
204 | |
205 content_.push_back(f); | |
206 } | |
207 else | |
208 { | |
209 f = *it; | |
210 } | |
211 | |
212 f->AddChunk(chunkData, chunkSize); | |
213 | |
214 if (f->GetNumBytes() > filesize) | |
215 { | |
216 Remove(filename); | |
217 } | |
218 else if (f->GetNumBytes() == filesize) | |
219 { | |
220 f->Flatten(completed); | |
221 Remove(filename); | |
222 return PostDataStatus_Success; | |
223 } | |
224 | |
225 return PostDataStatus_Pending; | |
226 } | |
227 | |
228 /*void Print() | |
229 { | |
230 boost::mutex::scoped_lock lock(mutex_); | |
231 | |
232 printf("ChunkStore status:\n"); | |
233 for (Content::const_iterator i = content_.begin(); | |
234 i != content_.end(); i++) | |
235 { | |
236 printf(" [%s]: %d\n", (*i)->GetFilename().c_str(), (*i)->GetNumBytes()); | |
237 } | |
238 printf("-----\n"); | |
239 }*/ | |
240 }; | |
241 | |
242 | |
243 struct MongooseServer::PImpl | |
244 { | |
245 struct mg_context *context_; | |
246 ChunkStore chunkStore_; | |
247 }; | |
248 | |
249 | |
250 ChunkStore& MongooseServer::GetChunkStore() | |
251 { | |
252 return pimpl_->chunkStore_; | |
253 } | |
254 | |
255 | |
256 | |
257 HttpHandler* MongooseServer::FindHandler(const UriComponents& forUri) const | |
258 { | |
259 for (Handlers::const_iterator it = | |
656 | 260 handlers_.begin(); it != handlers_.end(); ++it) |
0 | 261 { |
262 if ((*it)->IsServedUri(forUri)) | |
263 { | |
264 return *it; | |
265 } | |
266 } | |
267 | |
268 return NULL; | |
269 } | |
270 | |
271 | |
272 | |
273 | |
416 | 274 static PostDataStatus ReadBody(std::string& postData, |
275 struct mg_connection *connection, | |
276 const HttpHandler::Arguments& headers) | |
0 | 277 { |
278 HttpHandler::Arguments::const_iterator cs = headers.find("content-length"); | |
279 if (cs == headers.end()) | |
280 { | |
281 return PostDataStatus_NoLength; | |
282 } | |
283 | |
284 int length; | |
285 try | |
286 { | |
287 length = boost::lexical_cast<int>(cs->second); | |
288 } | |
289 catch (boost::bad_lexical_cast) | |
290 { | |
291 return PostDataStatus_NoLength; | |
292 } | |
293 | |
294 if (length < 0) | |
295 { | |
296 length = 0; | |
297 } | |
298 | |
299 postData.resize(length); | |
300 | |
301 size_t pos = 0; | |
302 while (length > 0) | |
303 { | |
304 int r = mg_read(connection, &postData[pos], length); | |
305 if (r <= 0) | |
306 { | |
307 return PostDataStatus_Failure; | |
308 } | |
418
b79bf2f4ab2e
execution of lua through REST
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
417
diff
changeset
|
309 |
8 | 310 assert(r <= length); |
0 | 311 length -= r; |
312 pos += r; | |
313 } | |
314 | |
315 return PostDataStatus_Success; | |
316 } | |
317 | |
318 | |
319 | |
320 static PostDataStatus ParseMultipartPost(std::string &completedFile, | |
321 struct mg_connection *connection, | |
322 const HttpHandler::Arguments& headers, | |
323 const std::string& contentType, | |
324 ChunkStore& chunkStore) | |
325 { | |
326 std::string boundary = "--" + contentType.substr(multipartLength); | |
327 | |
328 std::string postData; | |
416 | 329 PostDataStatus status = ReadBody(postData, connection, headers); |
0 | 330 |
331 if (status != PostDataStatus_Success) | |
332 { | |
333 return status; | |
334 } | |
335 | |
336 /*for (HttpHandler::Arguments::const_iterator i = headers.begin(); i != headers.end(); i++) | |
337 { | |
338 std::cout << "Header [" << i->first << "] = " << i->second << "\n"; | |
339 } | |
340 printf("CHUNK\n");*/ | |
341 | |
342 typedef HttpHandler::Arguments::const_iterator ArgumentIterator; | |
343 | |
344 ArgumentIterator requestedWith = headers.find("x-requested-with"); | |
345 ArgumentIterator fileName = headers.find("x-file-name"); | |
346 ArgumentIterator fileSizeStr = headers.find("x-file-size"); | |
347 | |
338
3a3b3ba8c1e0
fix for uploads through internet explorer 7
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
333
diff
changeset
|
348 if (requestedWith != headers.end() && |
0 | 349 requestedWith->second != "XMLHttpRequest") |
350 { | |
351 return PostDataStatus_Failure; | |
352 } | |
353 | |
354 size_t fileSize = 0; | |
355 if (fileSizeStr != headers.end()) | |
356 { | |
357 try | |
358 { | |
359 fileSize = boost::lexical_cast<size_t>(fileSizeStr->second); | |
360 } | |
361 catch (boost::bad_lexical_cast) | |
362 { | |
363 return PostDataStatus_Failure; | |
364 } | |
365 } | |
366 | |
367 typedef boost::find_iterator<std::string::iterator> FindIterator; | |
10 | 368 typedef boost::iterator_range<char*> Range; |
0 | 369 |
370 //chunkStore.Print(); | |
371 | |
372 try | |
373 { | |
374 FindIterator last; | |
375 for (FindIterator it = | |
376 make_find_iterator(postData, boost::first_finder(boundary)); | |
377 it!=FindIterator(); | |
378 ++it) | |
379 { | |
380 if (last != FindIterator()) | |
381 { | |
10 | 382 Range part(&last->back(), &it->front()); |
0 | 383 Range content = boost::find_first(part, "\r\n\r\n"); |
345 | 384 if (/*content != Range()*/!content.empty()) |
0 | 385 { |
386 Range c(&content.back() + 1, &it->front() - 2); | |
387 size_t chunkSize = c.size(); | |
388 | |
389 if (chunkSize > 0) | |
390 { | |
391 const char* chunkData = &c.front(); | |
392 | |
393 if (fileName == headers.end()) | |
394 { | |
395 // This file is stored in a single chunk | |
396 completedFile.resize(chunkSize); | |
397 if (chunkSize > 0) | |
398 { | |
399 memcpy(&completedFile[0], chunkData, chunkSize); | |
400 } | |
401 return PostDataStatus_Success; | |
402 } | |
403 else | |
404 { | |
405 return chunkStore.Store(completedFile, chunkData, chunkSize, fileName->second, fileSize); | |
406 } | |
407 } | |
10 | 408 } |
0 | 409 } |
410 | |
411 last = it; | |
412 } | |
413 } | |
414 catch (std::length_error) | |
415 { | |
416 return PostDataStatus_Failure; | |
417 } | |
418 | |
419 return PostDataStatus_Pending; | |
420 } | |
421 | |
422 | |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
423 static void SendUnauthorized(HttpOutput& output) |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
424 { |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
425 std::string s = "HTTP/1.1 401 Unauthorized\r\n" |
59 | 426 "WWW-Authenticate: Basic realm=\"" ORTHANC_REALM "\"" |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
427 "\r\n\r\n"; |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
428 output.Send(&s[0], s.size()); |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
429 } |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
430 |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
431 |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
432 static bool Authorize(const MongooseServer& that, |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
433 const HttpHandler::Arguments& headers, |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
434 HttpOutput& output) |
23 | 435 { |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
436 bool granted = false; |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
437 |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
438 HttpHandler::Arguments::const_iterator auth = headers.find("authorization"); |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
439 if (auth != headers.end()) |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
440 { |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
441 std::string s = auth->second; |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
442 if (s.substr(0, 6) == "Basic ") |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
443 { |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
444 std::string b64 = s.substr(6); |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
445 granted = that.IsValidBasicHttpAuthentication(b64); |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
446 } |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
447 } |
23 | 448 |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
449 if (!granted) |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
450 { |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
451 SendUnauthorized(output); |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
452 return false; |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
453 } |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
454 else |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
455 { |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
456 return true; |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
457 } |
23 | 458 } |
459 | |
460 | |
409
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
461 static std::string GetAuthenticatedUsername(const HttpHandler::Arguments& headers) |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
462 { |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
463 HttpHandler::Arguments::const_iterator auth = headers.find("authorization"); |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
464 |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
465 if (auth == headers.end()) |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
466 { |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
467 return ""; |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
468 } |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
469 |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
470 std::string s = auth->second; |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
471 if (s.substr(0, 6) != "Basic ") |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
472 { |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
473 return ""; |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
474 } |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
475 |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
476 std::string b64 = s.substr(6); |
809
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
749
diff
changeset
|
477 std::string decoded; |
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
749
diff
changeset
|
478 Toolbox::DecodeBase64(decoded, b64); |
409
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
479 size_t semicolons = decoded.find(':'); |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
480 |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
481 if (semicolons == std::string::npos) |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
482 { |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
483 // Bad-formatted request |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
484 return ""; |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
485 } |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
486 else |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
487 { |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
488 return decoded.substr(0, semicolons); |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
489 } |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
490 } |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
491 |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
492 |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
493 static bool ExtractMethod(HttpMethod& method, |
414 | 494 const struct mg_request_info *request, |
495 const HttpHandler::Arguments& headers, | |
496 const HttpHandler::Arguments& argumentsGET) | |
497 { | |
498 std::string overriden; | |
499 | |
500 // Check whether some PUT/DELETE faking is done | |
501 | |
502 // 1. Faking with Google's approach | |
503 HttpHandler::Arguments::const_iterator methodOverride = | |
504 headers.find("x-http-method-override"); | |
505 | |
506 if (methodOverride != headers.end()) | |
507 { | |
508 overriden = methodOverride->second; | |
509 } | |
510 else if (!strcmp(request->request_method, "GET")) | |
511 { | |
512 // 2. Faking with Ruby on Rail's approach | |
513 // GET /my/resource?_method=delete <=> DELETE /my/resource | |
514 methodOverride = argumentsGET.find("_method"); | |
515 if (methodOverride != argumentsGET.end()) | |
516 { | |
517 overriden = methodOverride->second; | |
518 } | |
519 } | |
520 | |
521 if (overriden.size() > 0) | |
522 { | |
523 // A faking has been done within this request | |
524 Toolbox::ToUpperCase(overriden); | |
525 | |
416 | 526 LOG(INFO) << "HTTP method faking has been detected for " << overriden; |
527 | |
414 | 528 if (overriden == "PUT") |
529 { | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
530 method = HttpMethod_Put; |
416 | 531 return true; |
414 | 532 } |
533 else if (overriden == "DELETE") | |
534 { | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
535 method = HttpMethod_Delete; |
416 | 536 return true; |
414 | 537 } |
538 else | |
539 { | |
540 return false; | |
541 } | |
542 } | |
543 | |
544 // No PUT/DELETE faking was present | |
545 if (!strcmp(request->request_method, "GET")) | |
546 { | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
547 method = HttpMethod_Get; |
414 | 548 } |
549 else if (!strcmp(request->request_method, "POST")) | |
550 { | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
551 method = HttpMethod_Post; |
414 | 552 } |
553 else if (!strcmp(request->request_method, "DELETE")) | |
554 { | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
555 method = HttpMethod_Delete; |
414 | 556 } |
557 else if (!strcmp(request->request_method, "PUT")) | |
558 { | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
559 method = HttpMethod_Put; |
414 | 560 } |
561 else | |
562 { | |
563 return false; | |
564 } | |
565 | |
566 return true; | |
567 } | |
568 | |
569 | |
0 | 570 |
571 static void* Callback(enum mg_event event, | |
572 struct mg_connection *connection, | |
573 const struct mg_request_info *request) | |
574 { | |
575 if (event == MG_NEW_REQUEST) | |
576 { | |
656 | 577 MongooseServer* that = reinterpret_cast<MongooseServer*>(request->user_data); |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
578 MongooseOutput output(connection); |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
579 |
414 | 580 // Check remote calls |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
581 if (!that->IsRemoteAccessAllowed() && |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
582 request->remote_ip != LOCALHOST) |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
583 { |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
584 SendUnauthorized(output); |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
585 return (void*) ""; |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
586 } |
0 | 587 |
588 | |
414 | 589 // Extract the HTTP headers |
590 HttpHandler::Arguments headers; | |
0 | 591 for (int i = 0; i < request->num_headers; i++) |
592 { | |
593 std::string name = request->http_headers[i].name; | |
594 std::transform(name.begin(), name.end(), name.begin(), ::tolower); | |
595 headers.insert(std::make_pair(name, request->http_headers[i].value)); | |
596 } | |
597 | |
414 | 598 |
599 // Extract the GET arguments | |
600 HttpHandler::Arguments argumentsGET; | |
601 if (!strcmp(request->request_method, "GET")) | |
602 { | |
603 HttpHandler::ParseGetQuery(argumentsGET, request->query_string); | |
604 } | |
605 | |
606 | |
607 // Compute the HTTP method, taking method faking into consideration | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
608 HttpMethod method; |
414 | 609 if (!ExtractMethod(method, request, headers, argumentsGET)) |
610 { | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
611 output.SendHeader(HttpStatus_400_BadRequest); |
414 | 612 return (void*) ""; |
613 } | |
614 | |
615 | |
23 | 616 // Authenticate this connection |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
617 if (that->IsAuthenticationEnabled() && |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
618 !Authorize(*that, headers, output)) |
23 | 619 { |
620 return (void*) ""; | |
621 } | |
622 | |
409
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
623 |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
624 // Apply the filter, if it is installed |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
625 const IIncomingHttpRequestFilter *filter = that->GetIncomingHttpRequestFilter(); |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
626 if (filter != NULL) |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
627 { |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
628 std::string username = GetAuthenticatedUsername(headers); |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
629 |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
630 char remoteIp[24]; |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
631 sprintf(remoteIp, "%d.%d.%d.%d", |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
632 reinterpret_cast<const uint8_t*>(&request->remote_ip) [3], |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
633 reinterpret_cast<const uint8_t*>(&request->remote_ip) [2], |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
634 reinterpret_cast<const uint8_t*>(&request->remote_ip) [1], |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
635 reinterpret_cast<const uint8_t*>(&request->remote_ip) [0]); |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
636 |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
637 if (!filter->IsAllowed(method, request->uri, remoteIp, username.c_str())) |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
638 { |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
639 SendUnauthorized(output); |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
640 return (void*) ""; |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
641 } |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
642 } |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
643 |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
644 |
414 | 645 // Extract the body of the request for PUT and POST |
646 std::string body; | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
647 if (method == HttpMethod_Post || |
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
648 method == HttpMethod_Put) |
0 | 649 { |
416 | 650 PostDataStatus status; |
651 | |
0 | 652 HttpHandler::Arguments::const_iterator ct = headers.find("content-type"); |
653 if (ct == headers.end()) | |
654 { | |
416 | 655 // No content-type specified. Assume no multi-part content occurs at this point. |
656 status = ReadBody(body, connection, headers); | |
0 | 657 } |
658 else | |
659 { | |
416 | 660 std::string contentType = ct->second; |
661 if (contentType.size() >= multipartLength && | |
662 !memcmp(contentType.c_str(), multipart, multipartLength)) | |
663 { | |
664 status = ParseMultipartPost(body, connection, headers, contentType, that->GetChunkStore()); | |
665 } | |
666 else | |
667 { | |
668 status = ReadBody(body, connection, headers); | |
669 } | |
0 | 670 } |
671 | |
672 switch (status) | |
673 { | |
416 | 674 case PostDataStatus_NoLength: |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
675 output.SendHeader(HttpStatus_411_LengthRequired); |
416 | 676 return (void*) ""; |
0 | 677 |
416 | 678 case PostDataStatus_Failure: |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
679 output.SendHeader(HttpStatus_400_BadRequest); |
416 | 680 return (void*) ""; |
0 | 681 |
416 | 682 case PostDataStatus_Pending: |
683 output.AnswerBufferWithContentType(NULL, 0, ""); | |
684 return (void*) ""; | |
0 | 685 |
416 | 686 default: |
687 break; | |
0 | 688 } |
689 } | |
690 | |
414 | 691 |
692 // Call the proper handler for this URI | |
0 | 693 UriComponents uri; |
415 | 694 try |
695 { | |
696 Toolbox::SplitUriComponents(uri, request->uri); | |
697 } | |
698 catch (OrthancException) | |
699 { | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
700 output.SendHeader(HttpStatus_400_BadRequest); |
415 | 701 return (void*) ""; |
702 } | |
703 | |
0 | 704 |
705 HttpHandler* handler = that->FindHandler(uri); | |
706 if (handler) | |
707 { | |
708 try | |
709 { | |
477 | 710 LOG(INFO) << EnumerationToString(method) << " " << Toolbox::FlattenUri(uri); |
414 | 711 handler->Handle(output, method, uri, headers, argumentsGET, body); |
0 | 712 } |
59 | 713 catch (OrthancException& e) |
0 | 714 { |
108 | 715 LOG(ERROR) << "MongooseServer Exception [" << e.What() << "]"; |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
716 output.SendHeader(HttpStatus_500_InternalServerError); |
0 | 717 } |
327
4564e908bba9
handling of bad lexical casts in http server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
324
diff
changeset
|
718 catch (boost::bad_lexical_cast&) |
4564e908bba9
handling of bad lexical casts in http server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
324
diff
changeset
|
719 { |
4564e908bba9
handling of bad lexical casts in http server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
324
diff
changeset
|
720 LOG(ERROR) << "MongooseServer Exception: Bad lexical cast"; |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
721 output.SendHeader(HttpStatus_400_BadRequest); |
333 | 722 } |
723 catch (std::runtime_error&) | |
724 { | |
725 LOG(ERROR) << "MongooseServer Exception: Presumably a bad JSON request"; | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
726 output.SendHeader(HttpStatus_400_BadRequest); |
327
4564e908bba9
handling of bad lexical casts in http server
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
324
diff
changeset
|
727 } |
0 | 728 } |
729 else | |
730 { | |
473
c9a5d72f8481
changing the namespace of HTTP enumerations
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
418
diff
changeset
|
731 output.SendHeader(HttpStatus_404_NotFound); |
0 | 732 } |
733 | |
734 // Mark as processed | |
735 return (void*) ""; | |
736 } | |
737 else | |
738 { | |
739 return NULL; | |
740 } | |
741 } | |
742 | |
743 | |
744 bool MongooseServer::IsRunning() const | |
745 { | |
746 return (pimpl_->context_ != NULL); | |
747 } | |
748 | |
749 | |
750 MongooseServer::MongooseServer() : pimpl_(new PImpl) | |
751 { | |
752 pimpl_->context_ = NULL; | |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
753 remoteAllowed_ = false; |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
754 authentication_ = false; |
23 | 755 ssl_ = false; |
0 | 756 port_ = 8000; |
417 | 757 filter_ = NULL; |
748
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
758 |
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
759 #if ORTHANC_SSL_ENABLED == 1 |
749 | 760 // 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
|
761 // 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
|
762 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
|
763 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
|
764 { |
749 | 765 LOG(WARNING) << "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
|
766 } |
de9763f63510
upgrade to openssl-1.0.1g because of heartbeat exploit
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
689
diff
changeset
|
767 #endif |
0 | 768 } |
769 | |
770 | |
771 MongooseServer::~MongooseServer() | |
772 { | |
773 Stop(); | |
774 ClearHandlers(); | |
775 } | |
776 | |
777 | |
128 | 778 void MongooseServer::SetPortNumber(uint16_t port) |
0 | 779 { |
780 Stop(); | |
781 port_ = port; | |
782 } | |
783 | |
784 void MongooseServer::Start() | |
785 { | |
786 if (!IsRunning()) | |
787 { | |
788 std::string port = boost::lexical_cast<std::string>(port_); | |
789 | |
23 | 790 if (ssl_) |
791 { | |
792 port += "s"; | |
793 } | |
794 | |
0 | 795 const char *options[] = { |
796 "listening_ports", port.c_str(), | |
23 | 797 ssl_ ? "ssl_certificate" : NULL, |
798 certificate_.c_str(), | |
0 | 799 NULL |
800 }; | |
801 | |
802 pimpl_->context_ = mg_start(&Callback, this, options); | |
803 if (!pimpl_->context_) | |
804 { | |
59 | 805 throw OrthancException("Unable to launch the Mongoose server"); |
0 | 806 } |
807 } | |
808 } | |
809 | |
810 void MongooseServer::Stop() | |
811 { | |
812 if (IsRunning()) | |
813 { | |
814 mg_stop(pimpl_->context_); | |
815 pimpl_->context_ = NULL; | |
816 } | |
817 } | |
818 | |
819 | |
820 void MongooseServer::RegisterHandler(HttpHandler* handler) | |
821 { | |
822 Stop(); | |
823 | |
824 handlers_.push_back(handler); | |
825 } | |
826 | |
827 | |
828 void MongooseServer::ClearHandlers() | |
829 { | |
830 Stop(); | |
831 | |
832 for (Handlers::iterator it = | |
656 | 833 handlers_.begin(); it != handlers_.end(); ++it) |
0 | 834 { |
835 delete *it; | |
836 } | |
837 } | |
838 | |
23 | 839 |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
840 void MongooseServer::ClearUsers() |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
841 { |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
842 Stop(); |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
843 registeredUsers_.clear(); |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
844 } |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
845 |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
846 |
23 | 847 void MongooseServer::RegisterUser(const char* username, |
848 const char* password) | |
849 { | |
850 Stop(); | |
24 | 851 |
852 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
|
853 std::string encoded; |
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
749
diff
changeset
|
854 Toolbox::EncodeBase64(encoded, tag); |
8ce2f69436ca
do not return strings with base64
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
749
diff
changeset
|
855 registeredUsers_.insert(encoded); |
23 | 856 } |
857 | |
858 void MongooseServer::SetSslEnabled(bool enabled) | |
859 { | |
860 Stop(); | |
861 | |
59 | 862 #if ORTHANC_SSL_ENABLED == 0 |
23 | 863 if (enabled) |
864 { | |
59 | 865 throw OrthancException("Orthanc has been built without SSL support"); |
23 | 866 } |
867 else | |
868 { | |
869 ssl_ = false; | |
870 } | |
871 #else | |
872 ssl_ = enabled; | |
873 #endif | |
874 } | |
875 | |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
876 void MongooseServer::SetAuthenticationEnabled(bool enabled) |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
877 { |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
878 Stop(); |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
879 authentication_ = enabled; |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
880 } |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
881 |
23 | 882 void MongooseServer::SetSslCertificate(const char* path) |
883 { | |
884 Stop(); | |
885 certificate_ = path; | |
886 } | |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
887 |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
888 void MongooseServer::SetRemoteAccessAllowed(bool allowed) |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
889 { |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
890 Stop(); |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
891 remoteAllowed_ = allowed; |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
892 } |
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
893 |
409
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
894 void MongooseServer::SetIncomingHttpRequestFilter(IIncomingHttpRequestFilter& filter) |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
895 { |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
896 Stop(); |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
897 filter_ = &filter; |
63f707278fc8
lua filtering of incoming http requests
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
398
diff
changeset
|
898 } |
34
96e57b863dd9
option to disallow remote access
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
25
diff
changeset
|
899 |
25
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
900 bool MongooseServer::IsValidBasicHttpAuthentication(const std::string& basic) const |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
901 { |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
902 return registeredUsers_.find(basic) != registeredUsers_.end(); |
dd1489098265
basic http authentication
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
24
diff
changeset
|
903 } |
0 | 904 } |