XRootD
Loading...
Searching...
No Matches
XrdHttpReq.hh
Go to the documentation of this file.
1//------------------------------------------------------------------------------
2// This file is part of XrdHTTP: A pragmatic implementation of the
3// HTTP/WebDAV protocol for the Xrootd framework
4//
5// Copyright (c) 2013 by European Organization for Nuclear Research (CERN)
6// Author: Fabrizio Furano <furano@cern.ch>
7// File Date: Nov 2012
8//------------------------------------------------------------------------------
9// XRootD is free software: you can redistribute it and/or modify
10// it under the terms of the GNU Lesser General Public License as published by
11// the Free Software Foundation, either version 3 of the License, or
12// (at your option) any later version.
13//
14// XRootD is distributed in the hope that it will be useful,
15// but WITHOUT ANY WARRANTY; without even the implied warranty of
16// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17// GNU General Public License for more details.
18//
19// You should have received a copy of the GNU Lesser General Public License
20// along with XRootD. If not, see <http://www.gnu.org/licenses/>.
21//------------------------------------------------------------------------------
22
23
24
25
26
27
28
37
38#ifndef XRDHTTPREQ_HH
39#define XRDHTTPREQ_HH
40
41
43
48
49#include <vector>
50#include <string>
51#include <map>
52
53//#include <libxml/parser.h>
54//#include <libxml/tree.h>
55
56
57
58
60 std::string path;
61 long long size;
62 long id;
63 long flags;
64 long modtime;
65};
66
67
68class XrdHttpProtocol;
69class XrdOucEnv;
70
72private:
73 // HTTP response parameters to be sent back to the user
74 int httpStatusCode;
75 std::string httpStatusText;
76
77 // The value of the user agent, if specified
78 std::string m_user_agent;
79
80 // Whether transfer encoding was requested.
81 bool m_transfer_encoding_chunked;
82 long long m_current_chunk_offset;
83 long long m_current_chunk_size;
84
85 // Whether trailer headers were enabled
86 bool m_trailer_headers{false};
87
88 // Whether the client understands our special status trailer.
89 // The status trailer allows us to report when an IO error occurred
90 // after a response body has started
91 bool m_status_trailer{false};
92
93 int parseHost(char *);
94
95 void parseScitag(const std::string & val);
96
97 //xmlDocPtr xmlbody; /* the resulting document tree */
98 XrdHttpProtocol *prot;
99
100 void clientMarshallReadAheadList(int nitems);
101 void clientUnMarshallReadAheadList(int nitems);
102
103
104 void getfhandle();
105
106 // Process the checksum response and return a header that should
107 // be included in the response.
108 int PostProcessChecksum(std::string &digest_header);
109
110 // Process the listing request of a GET request against a directory
111 // - final_: True if this is the last entry in the listing.
112 int PostProcessListing(bool final_);
113
114 // Send the response for a GET request for a file read (i.e., not a directory)
115 // Invoked after the open is successful but before the first read is issued.
116 int ReturnGetHeaders();
117
123 int PostProcessHTTPReq(bool final = false);
124
125 // Parse a resource string, typically a filename, setting the resource field and the opaque data
126 void parseResource(char *url);
127 // Map an XRootD error code to an appropriate HTTP status code and message
128 void mapXrdErrorToHttpStatus();
129
130 // Sanitize the resource from http[s]://[host]/ questionable prefix
131 void sanitizeResourcePfx();
132
133 // parses the iovN data pointers elements as either a kXR_read or kXR_readv
134 // response and fills out a XrdHttpIOList with the corresponding length and
135 // buffer pointers. File offsets from kXR_readv responses are not recorded.
136 void getReadResponse(XrdHttpIOList &received);
137
138 // notifies the range handler of receipt of bytes and sends the client
139 // the data.
140 int sendReadResponseSingleRange(const XrdHttpIOList &received);
141
142 // notifies the range handler of receipt of bytes and sends the client
143 // the data and necessary headers, assuming multipart/byteranges content type.
144 int sendReadResponsesMultiRanges(const XrdHttpIOList &received);
145
146 // If requested by the client, sends any I/O errors that occur during the transfer
147 // into a footer.
148 void sendFooterError(const std::string &);
149
155 static void extractChecksumFromList(const std::string & checksumList, std::vector<std::string> & extractedChecksum);
156
163 static void determineXRootDChecksumFromUserDigest(const std::string & userDigest, std::vector<std::string> & xrootdChecksums);
164
165public:
167 readRangeHandler(rcfg), keepalive(true) {
168
169 prot = protinstance;
170 length = 0;
171 //xmlbody = 0;
172 depth = 0;
173 opaque = 0;
174 writtenbytes = 0;
175 fopened = false;
176 headerok = false;
177 mScitag = -1;
178 };
179
180 virtual ~XrdHttpReq();
181
182 virtual void reset();
183
185 int parseLine(char *line, int len);
186
188 int parseFirstLine(char *line, int len);
189
191 int parseBody(char *body, long long len);
192
194 int ReqReadV(const XrdHttpIOList &cl);
195 std::vector<readahead_list> ralist;
196
198 std::string buildPartialHdr(long long bytestart, long long byteend, long long filesize, char *token);
199
201 std::string buildPartialHdrEnd(char *token);
202
203 // Appends the opaque info that we have
204 // NOTE: this function assumes that the strings are unquoted, and will quote them
205 void appendOpaque(XrdOucString &s, XrdSecEntity *secent, char *hash, time_t tnow);
206
207 void addCgi(const std::string & key, const std::string & value);
208
209 // Return the current user agent; if none has been specified, returns an empty string
210 const std::string &userAgent() const {return m_user_agent;}
211
212 // ----------------
213 // Description of the request. The header/body parsing
214 // is supposed to populate these fields, for fast access while
215 // processing the request
216
218
234
237 std::string requestverb;
238
239 // We have to keep the headers for possible further processing
240 // by external plugins
241 std::map<std::string, std::string> allheaders;
242
249
250
253
257
259 long long length; // Total size from client for PUT; total length of response TO client for GET.
260 int depth;
262
264 std::string host;
266 std::string destination;
267
269 std::string m_req_digest;
270
273
279 std::string m_digest_header;
280
282 std::string hdr2cgistr;
284
285 //
286 // Area for coordinating request and responses to/from the bridge
287 //
288
289
292
295
299 std::string etext;
301
303 const struct iovec *iovP;
304 int iovN;
305 int iovL;
306 bool final;
307
308 // The latest stat info got from the xrd layer
309 long long filesize;
313 char fhandle[4];
315
317 std::string stringresp;
318
321
323 long long writtenbytes;
324
326
327
328
329
330
336 int ProcessHTTPReq();
337
338
339 // ------------
340 // Items inherited from the Bridge class
341 //
342
343 //-----------------------------------------------------------------------------
369 //-----------------------------------------------------------------------------
370
371 virtual bool Data(XrdXrootd::Bridge::Context &info,
372 const
373 struct iovec *iovP,
374 int iovN,
375 int iovL,
376 bool final
377 );
378
379 //-----------------------------------------------------------------------------
389 //-----------------------------------------------------------------------------
390
391 virtual bool Done(XrdXrootd::Bridge::Context &info);
392
393
394 //-----------------------------------------------------------------------------
407 //-----------------------------------------------------------------------------
408
409 virtual bool Error(XrdXrootd::Bridge::Context &info,
410 int ecode,
411 const char *etext
412 );
413
414 //-----------------------------------------------------------------------------
427 //-----------------------------------------------------------------------------
428
429 virtual int File(XrdXrootd::Bridge::Context &info,
430 int dlen
431 );
432
433 //-----------------------------------------------------------------------------
446 //-----------------------------------------------------------------------------
447
448 virtual bool Redir(XrdXrootd::Bridge::Context &info,
449 int port,
450 const char *hname
451 );
452
453};
454
455
456
457void trim(std::string &str);
458
459#endif /* XRDHTTPREQ_HH */
460
XErrorCode
Definition XProtocol.hh:989
XResponseType
Definition XProtocol.hh:898
long long size
Definition XrdHttpReq.hh:61
void trim(std::string &str)
Definition XrdHttpReq.cc:76
std::string path
Definition XrdHttpReq.hh:60
std::vector< XrdOucIOVec2 > XrdHttpIOList
XrdOucString File
XrdHttpChecksumHandlerImpl::XrdHttpChecksumRawPtr XrdHttpChecksumRawPtr
int reqstate
State machine to talk to the bridge.
char fhandle[4]
int ReqReadV(const XrdHttpIOList &cl)
Prepare the buffers for sending a readv request.
unsigned int rwOpPartialDone
ReqType
These are the HTTP/DAV requests that we support.
int parseBody(char *body, long long len)
Parse the body of a request, assuming that it's XML and that it's entirely in memory.
Definition XrdHttpReq.cc:94
std::vector< readahead_list > ralist
long long length
std::string destination
The destination field specified in the req.
XrdOucString resource
The resource specified by the request, stripped of opaque data.
bool headerok
Tells if we have finished reading the header.
std::string m_digest_header
The computed digest for the HTTP response header.
std::string etext
std::string stringresp
If we want to give a string as a response, we compose it here.
const std::string & userAgent() const
XResponseType xrdresp
The last response data we got.
std::string requestverb
ReqType request
The request we got.
int ProcessHTTPReq()
long long writtenbytes
In a long write, we track where we have arrived.
XrdOucEnv * opaque
The opaque data, after parsing.
int iovL
byte count
const struct iovec * iovP
The latest data chunks got from the xrd layer. These are valid only inside the callbacks!
virtual ~XrdHttpReq()
std::string m_req_digest
The requested digest type.
XrdOucString resourceplusopaque
The resource specified by the request, including all the opaque data.
virtual bool Data(XrdXrootd::Bridge::Context &info, const struct iovec *iovP, int iovN, int iovL, bool final)
std::string hdr2cgistr
Additional opaque info that may come from the hdr2cgi directive.
virtual bool Done(XrdXrootd::Bridge::Context &info)
the result context
std::string host
The host field specified in the req.
long filemodtime
int parseFirstLine(char *line, int len)
Parse the first line of the header.
XrdOucString redirdest
int parseLine(char *line, int len)
Parse the header.
std::string buildPartialHdrEnd(char *token)
Build the closing part for a multipart response.
XrdHttpChecksumHandler::XrdHttpChecksumRawPtr m_req_cksum
The checksum that was ran for this request.
bool m_appended_hdr2cgistr
void appendOpaque(XrdOucString &s, XrdSecEntity *secent, char *hash, time_t tnow)
int iovN
array count
XrdHttpReq(XrdHttpProtocol *protinstance, const XrdHttpReadRangeHandler::Configuration &rcfg)
XrdOucString m_resource_with_digest
long long filesize
bool readClosing
virtual bool Redir(XrdXrootd::Bridge::Context &info, int port, const char *hname)
XErrorCode xrderrcode
std::map< std::string, std::string > allheaders
unsigned int rwOpDone
To coordinate multipart responses across multiple calls.
void addCgi(const std::string &key, const std::string &value)
bool sendcontinue
ClientRequest xrdreq
The last issued xrd request, often pending.
std::string buildPartialHdr(long long bytestart, long long byteend, long long filesize, char *token)
Build a partial header for a multipart response.
XrdHttpReadRangeHandler readRangeHandler
Tracking the next ranges of data to read during GET.
virtual void reset()