Debian Codegraph @

src/fileops/httpiovec.cpp

raw
1 /*
2 * This File is part of Davix, The IO library for HTTP based protocols
3 * Copyright (C) CERN 2013
4 * Author: Adrien Devresse <[email protected]>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21
22 #include <davix_internal.hpp>
23 #include "httpiovec.hpp"
24 #include <utils/davix_logger_internal.hpp>
25 #include <utils/stringutils.hpp>
26 #include "libs/IntervalTree.h"
27
28 #include <map>
29
30 #define DBG(message) std::cerr << __FILE__ << ":" << __LINE__ << " -- " << #message << " = " << message << std::endl;
31 using namespace StrUtil;
32
33 // remove trailing crlf
34 template<class InputIterator>
35 dav_size_t trim_crlf (InputIterator first, InputIterator last, dav_size_t s)
36 {
37 dav_size_t ret = s;
38 while (--last >= first) {
39 if(*last == '\n' || *last == '\r'){
40 *last = '\0';
41 ret--;
42 }else{
43 break;
44 }
45 }
46 return ret;
47 }
48
49
50
51 namespace Davix{
52
53 const std::string HttpIoVec_scope(){
54 return "Davix::HttpIOVecOps";
55 }
56
57
58 void HttpIoVecSetupErrorMultiPart(DavixError** err){
59 DavixError::setupError(err, HttpIoVec_scope(), StatusCode::InvalidServerResponse, "Invalid Multi-Part HTTP response");
60 }
61
62 void HttpIoVecSetupErrorMultiPartTooLong(DavixError** err){
63 DavixError::setupError(err, HttpIoVec_scope(), StatusCode::InvalidServerResponse, "Invalid Multi-Part HTTP, Multi-part header too long");
64 }
65
66 void HttpIoVecSetupErrorMultiPartBoundary(const std::string & boundary, DavixError** err){
67 DavixError::setupError(err, HttpIoVec_scope(), StatusCode::InvalidServerResponse, std::string("Invalid boundary for multipart http response :").append(boundary));
68 }
69
70 void HttpIoVecSetupErrorMultiPartSize( DavixError** err, dav_off_t req_offset, dav_size_t req_size, dav_off_t ans_offset, dav_size_t ans_size){
71 std::ostringstream ss;
72 ss << "Invalid server answer for multi part, request offset:"<< req_offset <<" size:"<< req_size << ", answer offset:"<< ans_offset<< " size:"<< ans_size;
73 DavixError::setupError(err, HttpIoVec_scope(), StatusCode::InvalidServerResponse, ss.str());
74 }
75
76 inline char* header_delimiter(char* buffer, dav_size_t len){
77 char* p = std::find(buffer, buffer + len, ':');
78 return (p < buffer + len)?p:NULL;
79 }
80
81 // Vector operation option provider
82 /*int davIOVecProvider(const DavIOVecInput *input_vec, dav_ssize_t & counter, dav_ssize_t number, dav_off_t & begin, dav_off_t & end){
83 if(counter < number){
84 begin = input_vec[counter].diov_offset;
85 end = std::max<dav_off_t>(begin + input_vec[counter].diov_size -1, begin);
86 return ++counter;
87 }
88 return -1;
89 }*/
90
91 int davIOVecProvider(const SortedRanges ranges, dav_size_t & counter, dav_off_t & begin, dav_off_t & end) {
92 if(counter < ranges.size()) {
93 begin = ranges[counter].first;
94 end = ranges[counter].second;
95 return ++counter;
96 }
97 return -1;
98 }
99
100
101 // do a multi-range on selected ranges
102 MultirangeResult HttpIOVecOps::performMultirange(IOChainContext & iocontext,
103 const IntervalTree<ElemChunk> &tree,
104 const SortedRanges & ranges) {
105
106 DavixError * tmp_err=NULL;
107 dav_ssize_t tmp_ret=-1, ret = 0;
108 ptrdiff_t p_diff=0;
109 dav_size_t counter = 0;
110 MultirangeResult::OperationResult opresult = MultirangeResult::SUCCESS;
111
112 // calculate total bytes to be read (approximate, since ranges could overlap)
113 dav_ssize_t bytes_to_read = 0;
114 for(dav_size_t i = 0; i < ranges.size(); i++) {
115 bytes_to_read += (ranges[i].second - ranges[i].first + 1);
116 }
117
118 std::function<int (dav_off_t &, dav_off_t &)> offsetProvider = std::bind(&davIOVecProvider, ranges, std::ref(counter), std::placeholders::_1, std::placeholders::_2);
119
120 // header line need to be inferior to 8K on Apache2 / ngnix
121 // in Addition, some S3 implementation limit the total header size to 4k....
122 // 3900 bytes maximum for the range seems to be a ood compromise
123 std::vector< std::pair<dav_size_t, std::string> > vecRanges = generateRangeHeaders(3900, offsetProvider);
124
125 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, " -> getPartialVec operation for {} vectors", ranges.size());
126
127 for(std::vector< std::pair<dav_size_t, std::string> >::iterator it = vecRanges.begin(); it < vecRanges.end(); ++it){
128 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, " -> getPartialVec request for {} chunks", it->first);
129
130 if(it->first == 1){ // one chunk only : no need of multi part
131 ret += singleRangeRequest(iocontext, tree, ranges[p_diff].first, ranges[p_diff].second - ranges[p_diff].first + 1);
132 p_diff += 1;
133 }else{
134 GetRequest req (iocontext._context, iocontext._uri, &tmp_err);
135 if(tmp_err == NULL){
136 RequestParams request_params(iocontext._reqparams);
137 req.setParameters(request_params);
138 req.addHeaderField(req_header_byte_range, it->second);
139
140 if( req.beginRequest(&tmp_err) == 0){
141 const int retcode = req.getRequestCode();
142
143 // looks like the server supports multi-range requests.. yay
144 if(retcode == 206) {
145 ret = parseMultipartRequest(req, tree, &tmp_err);
146
147 // could not parse multipart response - server's broken?
148 // known to happen with ceph - return code is 206, but only
149 // returns the first range
150 if(ret == -1) {
151 opresult = MultirangeResult::NOMULTIRANGE;
152 req.endRequest(&tmp_err);
153 break;
154 }
155 }
156 // no multi-range.. bad server, bad
157 else if(retcode == 200) {
158 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Multi-range request resulted in getting the whole file.");
159 // we have two options: read the entire file or abort current
160 // request and start a multi-range simulation
161
162 // if this is a huge file, reading the entire contents is
163 // definitely not an option
164 if(req.getAnswerSize() > 1000000 && req.getAnswerSize() > 2*bytes_to_read) {
165 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "File is too large; will not waste bandwidth, bailing out");
166 opresult = MultirangeResult::NOMULTIRANGE;
167 req.endRequest(&tmp_err);
168 }
169 else {
170 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Simulating multi-part response from the contents of the entire file");
171 opresult = MultirangeResult::SUCCESS_BUT_NO_MULTIRANGE;
172 ret = simulateMultiPartRequest(req, tree, &tmp_err);
173 }
174 break;
175 }
176 else if(retcode == 416) {
177 ret = 0;
178 DavixError::clearError(&tmp_err);
179 }
180 else {
181 httpcodeToDavixError(req.getRequestCode(),davix_scope_http_request(),", ", &tmp_err);
182 ret = -1;
183 break;
184 }
185
186 p_diff += it->first;
187 ret += tmp_ret;
188 } else {
189 ret = -1;
190 break;
191 }
192 }
193 }
194 }
195
196 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, " <- getPartialVec operation for {} vectors", ranges.size());
197 checkDavixError(&tmp_err);
198 return MultirangeResult(opresult, ret);
199 }
200
201 /* fire off a single, one-range request */
202 dav_ssize_t HttpIOVecOps::singleRangeRequest(IOChainContext & iocontext,
203 const DavIOVecInput * input,
204 DavIOVecOuput * output) {
205 dav_ssize_t size = _start->pread(iocontext,
206 input->diov_buffer,
207 input->diov_size,
208 input->diov_offset);
209
210 output->diov_size = size;
211 output->diov_buffer = input->diov_buffer;
212 return size;
213 }
214
215 // merge user-provided ranges, add them to intervals
216 typedef std::multimap<dav_off_t, dav_size_t> MergedRanges;
217 static SortedRanges partialMerging(const IntervalTree<ElemChunk> &tree, const dav_size_t mergedist) {
218 MergedRanges merged;
219
220 std::vector<Interval<ElemChunk> > allranges_unsorted;
221 tree.findContained(0, std::numeric_limits<dav_size_t>::max(), allranges_unsorted);
222
223 MergedRanges allranges;
224 for(std::vector<Interval<ElemChunk> >::iterator it = allranges_unsorted.begin(); it != allranges_unsorted.end(); it++)
225 allranges.insert(std::make_pair(it->start, it->stop));
226
227 dav_off_t offset = allranges.begin()->first;
228 dav_off_t end = allranges.begin()->second;
229
230 for(MergedRanges::iterator it = allranges.begin(); it != allranges.end(); it++) {
231 if(end + (dav_off_t) mergedist >= it->first) {
232 end = it->second;
233 }
234 else {
235 merged.insert(std::make_pair(offset, end));
236 offset = it->first;
237 end = it->second;
238 }
239 }
240 merged.insert(std::make_pair(offset, end));
241
242 SortedRanges output;
243 for(MergedRanges::iterator it = merged.begin(); it != merged.end(); it++)
244 output.push_back(*it);
245
246 return output;
247 }
248
249 static IntervalTree<ElemChunk> buildIntervalTree(const DavIOVecInput *in, DavIOVecOuput *out, const dav_size_t count_vec) {
250 std::vector<Interval<ElemChunk> > intervals;
251
252 for(dav_size_t i = 0; i < count_vec; i++) {
253 dav_off_t start = in[i].diov_offset;
254 dav_off_t end = start + in[i].diov_size - 1;
255 ElemChunk elem(in+i, out+i);
256
257 intervals.push_back(Interval<ElemChunk>(start, end, elem));
258 }
259 return IntervalTree<ElemChunk>(intervals);
260 }
261
262 typedef struct thread_data {
263 HttpIOVecOps *ptr;
264 int thread_no;
265 const SortedRanges *ranges;
266 const IntervalTree<ElemChunk> *tree;
267 IOChainContext *iocontext;
268 dav_size_t start, end;
269
270 dav_ssize_t size;
271 std::exception_ptr exc;
272 } thdata;
273
274 void* parallelSingleRange(void *args) {
275
276 thdata *data = (thdata*) args;
277 const SortedRanges & ranges = *data->ranges;
278
279 data->size = 0;
280 for(dav_size_t i = data->start; i < data->end; i++) {
281 try {
282 data->size += data->ptr->singleRangeRequest(*data->iocontext, *data->tree,
283 ranges[i].first,
284 ranges[i].second - ranges[i].first + 1);
285 }
286 catch(const Davix::DavixException &err) {
287 data->exc = std::current_exception();
288 return NULL;
289 }
290 }
291
292 return NULL;
293 }
294
295
296 dav_ssize_t HttpIOVecOps::simulateMultirange(IOChainContext & iocontext,
297 const IntervalTree<ElemChunk> & tree,
298 const SortedRanges & ranges,
299 const uint nconnections) {
300 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Simulating a multi-range request with {} vectors", ranges.size());
301 dav_ssize_t size = 0;
302
303 uint num_threads = nconnections;
304 if(num_threads > ranges.size()) {
305 num_threads = ranges.size();
306 }
307 uint queries_per_thread = ranges.size() / num_threads;
308
309 pthread_t threads[num_threads];
310 thdata data[num_threads];
311 for(uint i = 0; i < num_threads; i++) {
312 data[i].ptr = this;
313 data[i].thread_no = i;
314 data[i].ranges = &ranges;
315 data[i].tree = &tree;
316 data[i].iocontext = &iocontext;
317
318 data[i].start = i*queries_per_thread;
319 data[i].end = data[i].start + queries_per_thread;
320
321 if(i == num_threads - 1) {
322 data[i].end = ranges.size();
323 }
324
325 pthread_create(&threads[i], NULL, parallelSingleRange, (void*) &data[i]);
326 }
327
328 for(uint i = 0; i < num_threads; i++) {
329 pthread_join(threads[i], NULL);
330 size += data[i].size;
331 }
332
333 for(uint i = 0; i < num_threads; i++) {
334 if(data[i].exc != std::exception_ptr()) {
335 std::rethrow_exception(data[i].exc);
336 }
337 }
338
339 return size;
340 }
341
342 dav_ssize_t HttpIOVecOps::preadVec(IOChainContext & iocontext, const DavIOVecInput * input_vec,
343 DavIOVecOuput * output_vec,
344 const dav_size_t count_vec){
345 if(count_vec ==0)
346 return 0;
347
348 for(dav_size_t i = 0; i < count_vec; i++) {
349 output_vec[i].diov_size = 0;
350 }
351
352 // size of merge window
353 dav_size_t mergewindow = 2000;
354 if(iocontext._uri.fragmentParamExists("mergewindow")) {
355 mergewindow = atoi(iocontext._uri.getFragmentParam("mergewindow").c_str());
356 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Setting mergewindow to {}", mergewindow);
357 }
358
359 // number of parallel connections in case of a simulation
360 uint nconnections = 3;
361 if(iocontext._uri.fragmentParamExists("nconnections")) {
362 nconnections = atoi(iocontext._uri.getFragmentParam("nconnections").c_str());
363 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Setting number of desired parallel connections to {}", nconnections);
364 }
365
366 IntervalTree<ElemChunk> tree = buildIntervalTree(input_vec, output_vec, count_vec);
367
368 // a lot of servers do not support multirange... should we even try?
369 if(count_vec == 1 || iocontext._uri.getFragmentParam("multirange") == "false") {
370 SortedRanges sorted = partialMerging(tree, mergewindow);
371 return simulateMultirange(iocontext, tree, sorted, nconnections);
372 }
373
374 SortedRanges sorted = partialMerging(tree, mergewindow);
375 MultirangeResult res = performMultirange(iocontext, tree, sorted);
376 if(res.res == MultirangeResult::SUCCESS || res.res == MultirangeResult::SUCCESS_BUT_NO_MULTIRANGE) {
377 return res.size_bytes;
378 }
379 else {
380 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Multi-range request has failed, attempting to recover by using multiple single-range requests");
381 sorted = partialMerging(tree, mergewindow);
382 return simulateMultirange(iocontext, tree, sorted, nconnections);
383 }
384 }
385
386 int http_extract_boundary_from_content_type(const std::string & buffer, std::string & boundary, DavixError** err){
387 dav_size_t pos_bound;
388 static const std::string delimiter = "\";";
389 if( (pos_bound= buffer.find(ans_header_boundary_field)) != std::string::npos){
390 std::vector<std::string> tokens = tokenSplit(buffer.substr(pos_bound + ans_header_boundary_field.size()), delimiter);
391 if( tokens.size() >= 1
392 && tokens[0].size() > 0
393 && tokens[0].size() <= 70){
394 DAVIX_SLOG(DAVIX_LOG_TRACE, DAVIX_LOG_CHAIN, "Multi part boundary: {}", boundary);
395 std::swap(boundary,tokens[0]);
396 return 0;
397 }
398 }
399 return -1;
400 }
401
402
403 int get_multi_part_info(const HttpRequest& req, std::string & boundary, DavixError** err){
404 std::string buffer;
405
406 if( req.getAnswerHeader(ans_header_content_type, buffer) == true // has content type
407 && http_extract_boundary_from_content_type(buffer, boundary, err) == 0){
408 return 0;
409 }
410 return -1;
411 }
412
413 // analyze header and try to find size of the part
414 // return 0 -> not a content length header, return -1 : not a header or error, return 1 : success
415 int find_header_params(char* buffer, dav_size_t buffer_len, dav_size_t* part_size, dav_off_t* part_offset){
416 static const std::string delimiter(" bytes-/\t");
417 char * p = header_delimiter(buffer, buffer_len);
418 if(p == NULL)
419 return -1;
420 std::string header_type(buffer, p - buffer);
421 if( compare_ncase(ans_header_byte_range, 0, p - buffer, buffer) !=0) // check header type
422 return 0;
423
424 std::vector<std::string> tokens = tokenSplit(std::string(p+1),delimiter); // parse header
425 if(tokens.size() < 2)
426 return -1;
427
428 long chunk_size[2];
429 for(int i =0; i <2;++i){
430 chunk_size[i]= strtol(tokens[i].c_str(), &p, 10);
431 if(chunk_size[i] == LONG_MAX || chunk_size[i] < 0 || *p != '\0'){
432 errno =0;
433 return -1;
434 }
435 }
436 if(chunk_size[1] < chunk_size[0])
437 return -1;
438
439 *part_offset= chunk_size[0];
440 *part_size = chunk_size[1]-chunk_size[0]+1;
441 return 1;
442 }
443
444 inline dav_ssize_t parse_multi_part_header_line(HttpRequest& req, char* buffer, DavixError** err){
445 dav_ssize_t ret =0;
446 if( (ret = req.readLine(buffer, DAVIX_READ_BLOCK_SIZE, err)) <0 ){
447 return -1;
448 }
449 ret= trim_crlf(buffer, buffer + ret, ret);
450 return ret;
451 }
452
453 enum BoundaryType { NORMAL_BOUNDARY, TERMINATING_BOUNDARY, NOT_A_BOUNDARY };
454
455 static BoundaryType parseBoundary(char* buffer, const std::string & boundary) {
456 dav_size_t len = strlen(buffer);
457
458 if(len <= 3)
459 return NOT_A_BOUNDARY;
460
461 char *p = buffer;
462 if(*p != '-' || *(p+1) != '-')
463 return NOT_A_BOUNDARY;
464
465 if(strncmp(buffer+2, boundary.c_str(), boundary.size()) != 0)
466 return NOT_A_BOUNDARY;
467
468 if(boundary.size()+2 == len)
469 return NORMAL_BOUNDARY;
470
471 if(boundary.size()+4 == len && *(p+len-2) == '-' && *(p+len-1) == '-')
472 return TERMINATING_BOUNDARY;
473
474 return NOT_A_BOUNDARY;
475 }
476
477 int parse_multi_part_header(HttpRequest& req, const std::string & boundary, ChunkInfo & info,
478 int & n_try, DavixError** err){
479 dav_ssize_t ret =0;
480 char buffer[DAVIX_READ_BLOCK_SIZE+1] = {0};
481
482 if(n_try > 100){
483 HttpIoVecSetupErrorMultiPartTooLong(err);
484 return -1;
485 }
486
487 if( (ret = parse_multi_part_header_line(req, buffer, err)) <0 ){
488 return -1;
489 }
490
491 if(!info.bounded){
492 if(ret == 0) // start with crlf
493 return parse_multi_part_header(req, boundary, info, ++n_try, err);
494
495 BoundaryType type = parseBoundary(buffer, boundary);
496 if(type == NOT_A_BOUNDARY) return -1;
497 if(type == TERMINATING_BOUNDARY) return -2;
498
499 info.bounded = true;
500 return parse_multi_part_header(req, boundary, info, ++n_try, err);
501 }
502
503 if( info.offset == 0 && info.size == 0){
504 if( find_header_params(buffer, ret, &(info.size), &(info.offset)) < 0)
505 return -1;
506 return parse_multi_part_header(req, boundary, info, ++n_try, err);
507 }
508 if(ret == 0) // end crlf
509 return 0;
510
511 HttpIoVecSetupErrorMultiPart(err);
512 return -1;
513 }
514
515 // copy from source to chunk
516 static void copyBytes(const char *source, dav_off_t offset, dav_size_t size, ElemChunk &chunk) {
517 dav_off_t chunkOffset = chunk._in->diov_offset;
518 dav_size_t chunkSize = chunk._in->diov_size;
519
520 // first byte from which we'll start copying
521 dav_off_t common_offset = std::max(offset, chunkOffset);
522
523 // the length for which the two segments intersect
524 dav_size_t intersect_dist = std::min(size - (common_offset-offset), chunkSize - (common_offset-chunkOffset));
525
526 memcpy( (char*) chunk._in->diov_buffer+(common_offset-chunkOffset),
527 source+(common_offset-offset), intersect_dist);
528
529 chunk._ou->diov_buffer = chunk._in->diov_buffer;
530 chunk._ou->diov_size += intersect_dist;
531 }
532
533 // find all matching chunks in tree and fill them
534 static void fillChunks(const char *source, const IntervalTree<ElemChunk> &tree, dav_off_t offset, dav_size_t size) {
535 std::vector<Interval<ElemChunk> > matches;
536 tree.findOverlapping(offset, offset+size-1, matches);
537
538 for(std::vector<Interval<ElemChunk> >::iterator it = matches.begin(); it != matches.end(); it++) {
539 copyBytes(source, offset, size, it->value);
540 }
541
542 if(matches.size() == 0) {
543 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "WARNING: Received byte-range from server does not match any in the interval tree");
544 }
545 }
546
547 dav_ssize_t copyChunk(HttpRequest & req, const IntervalTree<ElemChunk> &tree, dav_off_t offset, dav_size_t size,
548 DavixError** err){
549 DavixError* tmp_err=NULL;
550 dav_ssize_t ret;
551 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Davix::parseMultipartRequest::copyChunk copy {} bytes with offset {}", size, offset);
552
553 std::vector<char> buffer;
554 buffer.resize(size+1);
555
556 ret = req.readSegment(&buffer[0], size, &tmp_err);
557 if(ret != (dav_ssize_t) size || tmp_err) {
558 DavixError::propagateError(err, tmp_err);
559 }
560 else {
561 fillChunks(&buffer[0], tree, offset, size);
562 }
563
564 return ret;
565 }
566
567 dav_ssize_t HttpIOVecOps::singleRangeRequest(IOChainContext & iocontext,
568 const IntervalTree<ElemChunk> & tree,
569 dav_off_t offset, dav_size_t size) {
570 std::vector<char> buffer;
571 buffer.resize(size+1);
572
573 dav_ssize_t s = _start->pread(iocontext, &buffer[0], size, offset);
574 fillChunks(&buffer[0], tree, offset, s);
575 return s;
576 }
577
578 dav_ssize_t HttpIOVecOps::parseMultipartRequest(HttpRequest & _req,
579 const IntervalTree<ElemChunk> & tree,
580 DavixError** err) {
581 std::string boundary;
582 dav_ssize_t ret = 0, tmp_ret =0;
583 DAVIX_SLOG(DAVIX_LOG_TRACE, DAVIX_LOG_CHAIN, "Davix::parseMultipartRequest multi part parsing");
584
585 if(get_multi_part_info(_req, boundary, err) != 0){
586 DAVIX_SLOG(DAVIX_LOG_TRACE, DAVIX_LOG_CHAIN, "Invalid Header Content info for multi part request");
587 return -1;
588 }
589 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Davix::parseMultipartRequest multi-part boundary {}", boundary);
590
591 while(1) {
592 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Davix::parseMultipartRequest parsing a new chunk");
593 ChunkInfo infos;
594 int n_try = 0;
595
596 tmp_ret = parse_multi_part_header(_req, boundary, infos, n_try, err);
597 if(tmp_ret == -2) break; // terminating boundary
598 if(tmp_ret == -1) return -1; // error
599
600 if( (tmp_ret = copyChunk(_req, tree, infos.offset, infos.size, err)) <0 )
601 return -1;
602
603 ret += tmp_ret;
604 DAVIX_SLOG(DAVIX_LOG_DEBUG, DAVIX_LOG_CHAIN, "Davix::parseMultipartRequest chunk parsed with success, next chunk..");
605 }
606
607 // finish with success, dump the remaining part of the query to end the request properly
608 char buffer[255];
609 while( _req.readBlock(buffer, 255, NULL) > 0);
610
611 return ret;
612 }
613
614 dav_ssize_t HttpIOVecOps::simulateMultiPartRequest(HttpRequest & _req, const IntervalTree<ElemChunk> & tree, DavixError** err) {
615 DAVIX_SLOG(DAVIX_LOG_TRACE, DAVIX_LOG_CHAIN, " -> Davix vec : 200 full file, simulate vec io");
616 char buffer[DAVIX_READ_BLOCK_SIZE+1];
617 dav_ssize_t partial_read_size = 0, total_read_size = 0;
618 while( (partial_read_size = _req.readBlock(buffer, DAVIX_READ_BLOCK_SIZE, err)) >0) {
619 fillChunks(buffer, tree, total_read_size, partial_read_size);
620 total_read_size += partial_read_size;
621 }
622
623 return total_read_size;
624 }
625
626
627
628 } // Davix