XrdHttpReq.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of XrdHTTP: A pragmatic implementation of the
// HTTP/WebDAV protocol for the Xrootd framework
//
// Copyright (c) 2013 by European Organization for Nuclear Research (CERN)
// Author: Fabrizio Furano <furano@cern.ch>
// File Date: Nov 2012
//------------------------------------------------------------------------------
// XRootD is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// XRootD is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
//------------------------------------------------------------------------------
 
 
 
 
 
 
 
#ifndef XRDHTTPREQ_HH
#define XRDHTTPREQ_HH
 
 
#include "XrdOuc/XrdOucString.hh"
 
#include "XProtocol/XProtocol.hh"
#include "XrdXrootd/XrdXrootdBridge.hh"
#include "XrdHttpChecksumHandler.hh"
#include "XrdHttpReadRangeHandler.hh"
 
#include <vector>
#include <string>
#include <map>
 
//#include <libxml/parser.h>
//#include <libxml/tree.h>
 
 
 
 
struct DirListInfo {
  std::string path;
  long long size;
  long id;
  long flags;
  long modtime;
};
 
 
class XrdHttpProtocol;
class XrdOucEnv;
 
class XrdHttpReq : public XrdXrootd::Bridge::Result {
private:
  // HTTP response parameters to be sent back to the user
  int httpStatusCode;
  std::string httpStatusText;
 
  // The value of the user agent, if specified
  std::string m_user_agent;
 
  // Whether transfer encoding was requested.
  bool m_transfer_encoding_chunked;
  long long m_current_chunk_offset;
  long long m_current_chunk_size;
 
  // Whether trailer headers were enabled
  bool m_trailer_headers{false};
 
  // Whether the client understands our special status trailer.
  // The status trailer allows us to report when an IO error occurred
  // after a response body has started
  bool m_status_trailer{false};
 
  int parseHost(char *);
 
  void parseScitag(const std::string & val);
 
  //xmlDocPtr xmlbody; /* the resulting document tree */
  XrdHttpProtocol *prot;
 
  void clientMarshallReadAheadList(int nitems);
  void clientUnMarshallReadAheadList(int nitems);
 
 
  void getfhandle();
 
  // Process the checksum response and return a header that should
  // be included in the response.
  int PostProcessChecksum(std::string &digest_header);
 
  int PostProcessHTTPReq(bool final = false);
 
  // Parse a resource string, typically a filename, setting the resource field and the opaque data
  void parseResource(char *url);
  // Map an XRootD error code to an appropriate HTTP status code and message
  void mapXrdErrorToHttpStatus();
  
  // Sanitize the resource from http[s]://[host]/ questionable prefix
  void sanitizeResourcePfx();
 
  // parses the iovN data pointers elements as either a kXR_read or kXR_readv
  // response and fills out a XrdHttpIOList with the corresponding length and
  // buffer pointers. File offsets from kXR_readv responses are not recorded.
  void getReadResponse(XrdHttpIOList &received);
 
  // notifies the range handler of receipt of bytes and sends the client
  // the data.
  int sendReadResponseSingleRange(const XrdHttpIOList &received);
 
  // notifies the range handler of receipt of bytes and sends the client
  // the data and necessary headers, assuming multipart/byteranges content type.
  int sendReadResponsesMultiRanges(const XrdHttpIOList &received);
 
  static void extractChecksumFromList(const std::string & checksumList, std::vector<std::string> & extractedChecksum);
 
  static void determineXRootDChecksumFromUserDigest(const std::string & userDigest, std::vector<std::string> & xrootdChecksums);
 
public:
  XrdHttpReq(XrdHttpProtocol *protinstance, const XrdHttpReadRangeHandler::Configuration &rcfg) :
      readRangeHandler(rcfg), keepalive(true) {
 
    prot = protinstance;
    length = 0;
    //xmlbody = 0;
    depth = 0;
    opaque = 0;
    writtenbytes = 0;
    fopened = false;
    headerok = false;
    mScitag = -1;
  };
 
  virtual ~XrdHttpReq();
 
  virtual void reset();
 
  int parseLine(char *line, int len);
 
  int parseFirstLine(char *line, int len);
 
  int parseBody(char *body, long long len);
 
  int ReqReadV(const XrdHttpIOList &cl);
  std::vector<readahead_list> ralist;
 
  std::string buildPartialHdr(long long bytestart, long long byteend, long long filesize, char *token);
 
  std::string buildPartialHdrEnd(char *token);
 
  // Appends the opaque info that we have
  // NOTE: this function assumes that the strings are unquoted, and will quote them
  void appendOpaque(XrdOucString &s, XrdSecEntity *secent, char *hash, time_t tnow);
 
  void addCgi(const std::string & key, const std::string & value);
 
  // Return the current user agent; if none has been specified, returns an empty string
  const std::string &userAgent() const {return m_user_agent;}
 
  // ----------------
  // Description of the request. The header/body parsing
  // is supposed to populate these fields, for fast access while
  // processing the request
 
 
  enum ReqType {
    rtUnset = -1,
    rtUnknown = 0,
    rtMalformed,
    rtGET,
    rtHEAD,
    rtPUT,
    rtOPTIONS,
    rtPATCH,
    rtDELETE,
    rtPROPFIND,
    rtMKCOL,
    rtMOVE,
    rtPOST
  };
 
  ReqType request;
  std::string requestverb;
  
  // We have to keep the headers for possible further processing
  // by external plugins
  std::map<std::string, std::string> allheaders;
  
  XrdOucString resource;
  XrdOucEnv *opaque;
  XrdOucString resourceplusopaque;
  
  
  bool headerok;
 
  XrdHttpReadRangeHandler   readRangeHandler;
  bool                      readClosing;
 
  bool keepalive;
  long long length;  // Total size from client for PUT; total length of response TO client for GET.
  int depth;
  bool sendcontinue;
 
  std::string host;
  std::string destination;
 
  std::string m_req_digest;
 
  XrdHttpChecksumHandler::XrdHttpChecksumRawPtr m_req_cksum = nullptr;
 
  XrdOucString m_resource_with_digest;
  std::string m_digest_header;
 
  std::string hdr2cgistr;
  bool m_appended_hdr2cgistr;
  
  //
  // Area for coordinating request and responses to/from the bridge
  //
 
 
  unsigned int rwOpDone, rwOpPartialDone;
 
  ClientRequest xrdreq;
 
  XResponseType xrdresp;
  XErrorCode xrderrcode;
  std::string etext;
  XrdOucString redirdest;
 
  const struct iovec *iovP; 
  int iovN; 
  int iovL; 
  bool final; 
 
  // The latest stat info got from the xrd layer
  long long filesize;
  long fileflags;
  long filemodtime;
  long filectime;
  char fhandle[4];
  bool fopened;
 
  std::string stringresp;
 
  int reqstate;
 
  long long writtenbytes;
 
  int mScitag;
 
 
 
 
 
  int ProcessHTTPReq();
 
 
  // ------------
  // Items inherited from the Bridge class
  //
 
  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
 
  virtual bool Data(XrdXrootd::Bridge::Context &info, 
          const
          struct iovec *iovP, 
          int iovN, 
          int iovL, 
          bool final 
          );
 
  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
 
  virtual bool Done(XrdXrootd::Bridge::Context &info); 
 
 
  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
 
  virtual bool Error(XrdXrootd::Bridge::Context &info, 
          int ecode, 
          const char *etext 
          );
 
  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
 
  virtual int File(XrdXrootd::Bridge::Context &info, 
          int dlen 
  );
 
  //-----------------------------------------------------------------------------
  //-----------------------------------------------------------------------------
 
  virtual bool Redir(XrdXrootd::Bridge::Context &info, 
          int port, 
          const char *hname 
          );
 
};
 
 
 
void trim(std::string &str);
 
#endif  /* XRDHTTPREQ_HH */