string SipResponse::ToString() const
{
ostringstream stream;
stream << "SIP/2.0 " << StatusCode() << " " << ReasonPhrase() << "\r\n" << SipMessage::ToString();
return stream.str();
}
//-----------------------------------------------------------------------------
StatusCode RootHistCnv::PersSvc::initialize()
//-----------------------------------------------------------------------------
{
MsgStream log( msgSvc(), name() );
StatusCode status = ConversionSvc::initialize();
if( status.isFailure() ) return status;
// Get my properties from the JobOptionsSvc
if (setProperties().isFailure()) {
log << MSG::ERROR << "Could not set my properties" << endmsg;
return StatusCode::FAILURE;
}
if (m_outputEnabled) {
// Initialize ROOT if output file name is defined
if( undefFileName != m_defFileName ) {
m_hfile = TFile::Open(m_defFileName.c_str(),"RECREATE","GAUDI Histograms");
} else {
m_hfile = 0;
}
log << MSG::INFO << "Writing ROOT histograms to: " << m_defFileName
<< endmsg;
}
else {
log << MSG::INFO << "Writing ROOT histograms disabled." << endmsg;
}
return StatusCode(StatusCode::SUCCESS,true);
}
//=============================================================================
// Fill the tuple
//=============================================================================
StatusCode TupleToolTrackPosition::fill( const LHCb::Particle *, const LHCb::Particle * part,
const std::string & head, Tuples::Tuple & tuple )
{
const std::string prefix=fullName(head);
if ( msgLevel(MSG::DEBUG) ) debug() << "==> Fill" << endmsg;
bool test=true;
double X=-999999;
double Y=-999999;
if( part && part->proto() && part->proto()->track() )
{
if ( msgLevel(MSG::VERBOSE) ) verbose() << "extrapolating track to Z="<< m_Z << endmsg;
LHCb::State aState=LHCb::State();
//const LHCb::Track aTrack= *(part->proto()->track());
StatusCode sc=m_extrapolator->stateFromTrajectory(aState,*(part->proto()->track()),m_Z);
if(sc.isSuccess())
{
X=aState.x();
Y=aState.y();
}
}
test &= tuple->column( prefix+"_X", X );
test &= tuple->column( prefix+"_Y", Y );
return StatusCode(test);
}
/// Define transient data store
StatusCode PersistencySvc::setDataProvider(IDataProviderSvc* pDataSvc) {
m_dataSvc = pDataSvc;
for ( Services::iterator i = m_cnvServices.begin(); i != m_cnvServices.end(); i++ ) {
(*i).second.conversionSvc()->setDataProvider(m_dataSvc).ignore();
}
return StatusCode(StatusCode::SUCCESS,true);
}
// From CHTTPClientTransaction
void CTestClientHttpSimplePost::OnResponseHeaders()
{
// Check whether the status code matches
if(iParams.StatusCode() != StatusCode())
{
iObserver.EndTest(KErrCorrupt);
}
}
bool Response::SendHeaders(Socket* aSocket) {
string headers;
headers.append("HTTP/1.1 ");
headers.append(StatusCode(mode));
headers.append("\r\n");
headers.append("Connection: close\r\n");
headers.append(GetDate());
headers.append("\r\n");
headers.append("Server: HttpMediaServer/0.1\r\n");
if (ContainsKey(parser.GetParams(), "delay")) {
const map<string,string> params = parser.GetParams();
string delayStr = params.find("delay")->second;
double delay = atof(delayStr.c_str());
if (delay > 0.0) {
Sleep((unsigned)(delay+0.5));
}
}
if (!parser.IsLive()) {
if (mode == GET_ENTIRE_FILE) {
headers.append("Accept-Ranges: bytes\r\n");
headers.append("Content-Length: ");
headers.append(ToString(fileLength));
headers.append("\r\n");
} else if (mode == GET_FILE_RANGE) {
headers.append("Accept-Ranges: bytes\r\n");
headers.append("Content-Length: ");
headers.append(ToString(rangeEnd - rangeStart));
headers.append("\r\n");
headers.append("Content-Range: bytes ");
headers.append(ToString(rangeStart));
headers.append("-");
headers.append(ToString(rangeEnd));
headers.append("/");
headers.append(ToString(fileLength));
headers.append("\r\n");
}
}
//headers.append("Last-Modified: Wed, 10 Nov 2009 04:58:08 GMT\r\n");
headers.append("Content-Type: ");
if (parser.HasSpecifiedMimeType()) {
headers.append(parser.GetSpecifiedMimeType());
} else {
headers.append(ExtractContentType(path, mode));
}
headers.append("\r\n\r\n");
cout << "Sending Headers " << parser.id << std::endl << headers;
return aSocket->Send(headers.c_str(), (int)headers.size()) != -1;
}
//=============================================================================
// Fill
//=============================================================================
StatusCode TupleToolSelResults::fill( Tuples::Tuple& tup)
{
const std::string prefix = fullName();
bool test = true;
for ( std::vector<std::string>::const_iterator s = m_selections.begin() ;
s != m_selections.end(); ++s )
{
test &= tup->column(prefix+(*s),m_selTool->isSelected(*s));
if (!test)
{
err() << "Cannot fill variable name " << prefix+(*s) << endmsg ;
break;
}
}
return StatusCode(test) ;
}
void server::HttpServer::check_request(server::HttpServerSession* session)
{
if(session->ProtocolVersion != HTTP_1_0)
{
if(session->incoming_headers["host"].size() == 0)
{
throw Exception(StatusCode("No host provided. Routing failed.", 500));
}
}
if(server::configuration().tryBool("request_logging_enable"));
log("Processed request for:\n\tPath: "
+ session->UnprocessedPath
+ std::string("\n\tRequest Type: ")
+ ((session->RequestType == GET) ? "GET" : "POST")
+ std::string("\n\tProtocol Version: ")
+ ((session->ProtocolVersion == HTTP_1_0) ? "HTTP/1.0 (HTTP 1.0)" : "HTTP/1.1 (HTTP 1.1)")
+ std::string("\n")
);
}
void server::HttpServer::process_request(server::HttpServerSession* session)
{
//This text buffer holds individual HTTP status lines
char flbuf[MAX_HTTP_LINE_LENGTH];
flbuf[MAX_HTTP_LINE_LENGTH] = '\0';
//This reads the first line from the client
if(session->connection->readline(flbuf, MAX_HTTP_LINE_LENGTH, '\n') >= MAX_HTTP_LINE_LENGTH - 1)
{
throw Exception(StatusCode("First line/GET request too long", MAX_HTTP_LINE_LENGTH));
}
//Convert to std string and then pad
std::string str = flbuf;
//Pop back extra '\r' or '\n's
if(str.back() == '\r' || str.back() == '\n') str.pop_back();
server::ipad(str);
//Break down the string into its parts
std::vector<std::string> parts = server::split(str, ' ');
//Chech if we dont have all the parts
if(parts.size() < 3) throw Exception(StatusCode("Could not understand first line.", parts.size()));
//Begin processing first line
if(parts[0] == "POST") session->RequestType = POST;
else if(parts[0] == "GET") session->RequestType = GET;
else throw Exception(StatusCode("Unimplemented function.", -1));
//Process the path
parse_get_queries(session, parts);
//Remove whitespace
server::ipad(parts[2]);
//Process the protocol version
if(parts[2] == "HTTP/1.0") session->ProtocolVersion = HTTP_1_0;
else if(parts[2] == "HTTP/1.1") session->ProtocolVersion = HTTP_1_1;
else throw Exception(StatusCode("Unknown HTTP protocol version.", -1));
//Download headers
while(true)
{
//Download the header line
if(session->connection->readline(flbuf, MAX_HTTP_LINE_LENGTH, '\n') == MAX_HTTP_LINE_LENGTH)
throw Exception(StatusCode("Header field length too long", MAX_HTTP_LINE_LENGTH));
//Turn the char pointer into a standard string
str = flbuf;
if(str.back() == '\r' || str.back() == '\n') str.pop_back();
//Pad the whitespace from the header away
server::ipad(str);
//Escape, if needed
if(str.size() == 0) break;
//Find the position of the colon
long pos = server::find(str, ':');
if(pos <= 0) continue;
//Separate the key from the value
std::string key = server::tolower(server::pad(str.substr(0, pos)));
std::string value = str.substr(pos + 1, str.size());
server::ipad(value);
//Add a cookie
if(key == "cookie")
{
//Split the header line into each separate cookie
std::vector<std::string> cookies = server::split(value, ';');
for(size_t i = 0; i < cookies.size(); i++)
{
//Find the position of the '='
pos = server::find(cookies[i], '=');
//Separate the name from it's value
key = cookies[i].substr(0, pos);
value = cookies[i].substr(pos + 1, cookies[i].size());
//Remove whitespace. It's dirty
server::ipad(key);
server::ipad(value);
//Set the cookie into the session object
session->incoming_cookies[server::decodeURI(key)] = server::HttpCookie(server::decodeURI(value));
}
}
else
{
//Save the header line
session->incoming_headers[key] = value;
}
}
parse_post_queries(session);
}
void server::HttpServer::send_response(server::HttpServerSession* session)
{
//Write back the first line
session->connection->write((session->ProtocolVersion == HTTP_1_0) ? "HTTP/1.0 " : "HTTP/1.1 ");
session->connection->write(server::toString(session->ResponseStatusCode));
session->connection->write(" " + server::getHTTPStatus(session->ResponseStatusCode) + "\r\n");
//Write back the headers
for(std::map<std::string, std::string>::const_iterator it = session->headers.begin(); it != session->headers.end(); ++it)
{
session->connection->write(it->first + ": " + it->second + "\r\n");
}
//Send all cookies
for(std::map<std::string, std::string>::const_iterator it =
session->cookies.begin();
it != session->cookies.end();
++it
)
{
session->connection->write("Set-Cookie: " + server::encodeURI(it->first) + "=" + server::encodeURI(it->second) + "\r\n");
}
session->connection->write("\r\n");
if(session->Response.type == STRING)
{
session->connection->write(session->Response.stype);
}
else
{
fseek(session->Response.ftype, 0, SEEK_END);
size_t len = ftell(session->Response.ftype);
fseek(session->Response.ftype, 0, SEEK_SET);
int ffd = fileno(session->Response.ftype);
if(ffd < 0)
{
throw Exception(StatusCode("Unable to read the file to be sent!", ffd));
}
#ifndef _WIN32
int ret = sendfile(session->connection->fd, fileno(session->Response.ftype), 0, len);
#else
int ret = 0;
#endif
if(ret < 0)
{
throw Exception(StatusCode("Unable to complete file transfer!", ret));
}
else if(ret < len)
{
//Holds 16 KB chunks of data
char buffer[16384];
size_t nreps = len / 16384;
size_t carry = len % 16384;
for(size_t i = 0; i < nreps; i++)
{
if(fread(buffer, 16384, 1, session->Response.ftype) > 0)
{
session->connection->write(buffer, 16384);
}
}
if(fread(buffer, carry, 1, session->Response.ftype) > 0)
{
session->connection->write(buffer, carry);
}
}
session->connection->write("\r\n\r\n");
}
}
void server::HttpServer::check_session_response(server::HttpServerSession* session)
{
if(session->headers["content-type"].size() == 0) session->headers["content-type"] = "text/html";
if(session->Response.type == FILE)
{
if(session->Response.ftype == NULL || ftell(session->Response.ftype) < 0) throw Exception(StatusCode("Attempting to send a file; file not open. Aborting.", -1));
fseek(session->Response.ftype, 0, SEEK_END);
session->headers["content-length"] = server::toString(ftell(session->Response.ftype));
fseek(session->Response.ftype, 0, SEEK_SET);
}
else
{
session->headers["content-length"] = server::toString(session->Response.stype.size());
}
session->headers["date"] = server::getHTTPTimestamp();
}
void server::HttpServer::parse_post_queries(server::HttpServerSession* session)
{
//Only download request if clarified that we have a POST request
if(session->RequestType == POST)
{
//If the POST request type is application/x-www-form-urlencoded
if(server::tolower(session->incoming_headers["content-type"]) == "application/x-www-form-urlencoded")
{
//Check to make sure the content length is significant
if(session->incoming_headers["content-length"].size() != 0)
{
//Gather the content length
size_t len = std::atoll(session->incoming_headers["content-length"].c_str());
//Pick whether to choose file or string
server::HttpLocationType ftype = STRING;
//Stores the key and the value
std::string key;
std::string value;
//Position of the current stream
size_t i = 0;
while(i < len)
{
while(i < len && key.back() != '=')
{
key += (char) session->connection->read();
i++;
}
key.pop_back();
while(i < len && value.back() != '&')
{
value += (char) session->connection->read();
i++;
}
server::HttpPost pt;
pt.type = ftype;
pt.value = server::decodeURI(value);
session->post[server::decodeURI(key)] = pt;
}
}
}
///If we got a multipart request...
else if(server::tolower(session->incoming_headers["content-type"]).find("multipart/form-data") != std::string::npos)
{
throw Exception(StatusCode("Unable to parse POST request; Multipart POST request processing is under development!", -1));
/****************************************
* UNDER DEVELOPMENT *
****************************************/
if(session->incoming_headers["content-length"].size() != 0)
{
size_t reqsize = atoll(session->incoming_headers["content-length"].c_str());
std::string boundary = "";
std::vector<std::string> pts = server::split(session->incoming_headers["content-type"], ';');
for(size_t i = 0; i < pts.size(); i++)
{
server::tolower(pts[i]);
std::vector<std::string> d2x = server::split(pts[i], '=');
if(d2x.size() < 2)
{
throw Exception(StatusCode("Unable to process POST data. Invalid POST data!", -1));
}
else
{
boundary = server::pad(d2x[1]);
}
}
size_t nrec = 0;
std::string rdbuf = "";
while(nrec++ < reqsize && rdbuf.back() != '\n' && rdbuf[rdbuf.size() - 2] != '\r')
{
rdbuf += (char) session->connection->read();
}
if(rdbuf.back() == '\r' || rdbuf.back() == '\n')
{
rdbuf.pop_back();
}
}
/***************************************
* FINISH UNDER DEVELOPMENT *
***************************************/
}
}
}
/// Set conversion service the converter is connected to
StatusCode PersistencySvc::setConversionSvc(IConversionSvc* svc) {
m_cnvDefault = svc;
return StatusCode(StatusCode::SUCCESS,true);
}
