const String SAX2AttributesImpl::getValue(const String & qName) const
{
unsigned int i;
unsigned int size = (unsigned int)attrs.size();
for(i = 0; i < size; i++)
{
String lQName( Unmarshaller::newString( attrs[i].qname ) );
if(qName == lQName)
{
String lValue( Unmarshaller::newString( attrs[i].value ) );
return lValue;
}
}
return "";
}
/*
Generate a value given an integer, using formatting defined within this class.
The formatting mainly applies if formatting as a string. For example, what is
the number base? should a sign always be included? are leading zeros requried?
The formatting could include properties related to other types. For example, generate
an error if attempting to convert a negative integer to an unsigned integer.
*/
QVariant QEIntegerFormatting::formatValue( const long &integerValue, generic::generic_types valueType ) {
switch( valueType ) {
case generic::GENERIC_STRING :
{
QString string = QString::number( integerValue, radix);
QVariant sValue( string );
return sValue;
}
case generic::GENERIC_SHORT :
case generic::GENERIC_LONG :
{
QVariant lValue( (qlonglong)integerValue );
return lValue;
}
case generic::GENERIC_UNSIGNED_SHORT :
case generic::GENERIC_UNSIGNED_CHAR :
case generic::GENERIC_UNSIGNED_LONG :
{
qulonglong unsignedIntegerValue;
( integerValue < 0 ) ? unsignedIntegerValue=0 : unsignedIntegerValue=integerValue;
QVariant ulValue( unsignedIntegerValue );
return ulValue;
}
case generic::GENERIC_FLOAT :
case generic::GENERIC_DOUBLE :
{
QVariant dValue( (double)integerValue );
return dValue;
}
case generic::GENERIC_UNKNOWN :
default :
{
//qDebug() << "QEIntegerFormatting::formatValue() Unknown value 'Generic' type: " << valueType;
QVariant unknown;
return unknown;
}
}
//qDebug() << "QEIntegerFormatting::formatValue() Unknown value 'Generic' type: " << valueType;
QVariant unknown;
return unknown;
}
void FastCGITransport::onHeadersComplete() {
m_requestURI = getRawHeader("REQUEST_URI");
m_remoteHost = getRawHeader("REMOTE_HOST");
m_remoteAddr = getRawHeader("REMOTE_ADDR");
m_serverName = getRawHeader("SERVER_NAME");
m_serverAddr = getRawHeader("SERVER_ADDR");
m_extendedMethod = getRawHeader("REQUEST_METHOD");
m_httpVersion = getRawHeader("HTTP_VERSION");
m_documentRoot = getRawHeader("DOCUMENT_ROOT") + "/";
try {
int remote_port = std::stoi(getRawHeader("REMOTE_PORT"));
if (remote_port < std::numeric_limits<decltype(m_remotePort)>::min() ||
remote_port > std::numeric_limits<decltype(m_remotePort)>::max()) {
m_remotePort = 0;
}
m_remotePort = remote_port;
} catch (std::invalid_argument&) {
m_remotePort = 0;
} catch (std::out_of_range&) {
m_remotePort = 0;
}
auto value = getRawHeader("HTTPS");
if (!value.empty()) {
std::string lValue(value);
boost::to_lower(lValue);
// IIS sets this value but sets it to off when SSL is off.
if (lValue.compare("off") != 0) {
setSSL();
}
}
try {
m_serverPort = std::stoi(getRawHeader("SERVER_PORT"));
} catch (std::invalid_argument&) {
m_serverPort = 0;
} catch (std::out_of_range&) {
m_serverPort = 0;
}
if (m_extendedMethod == "GET") {
m_method = Method::GET;
} else if (m_extendedMethod == "POST") {
m_method = Method::POST;
} else if (m_extendedMethod == "HEAD") {
m_method = Method::HEAD;
} else {
m_method = Method::Unknown;
}
try {
m_requestSize = std::stoi(getRawHeader("CONTENT_LENGTH"));
} catch (std::invalid_argument&) {
m_requestSize = 0;
} catch (std::out_of_range&) {
m_requestSize = 0;
}
std::string pathTranslated = getRawHeader("PATH_TRANSLATED");
std::string documentRoot = getRawHeader("DOCUMENT_ROOT");
// use PATH_TRANSLATED - DOCUMENT_ROOT if it is valid instead of SCRIPT_NAME
// for mod_fastcgi support
if (!pathTranslated.empty() && !documentRoot.empty() &&
pathTranslated.find(documentRoot) == 0) {
m_serverObject = pathTranslated.substr(documentRoot.length());
} else {
m_serverObject = getRawHeader("SCRIPT_NAME");
}
std::string queryString = getRawHeader("QUERY_STRING");
if (!queryString.empty()) {
m_serverObject += "?" + queryString;
}
m_connection->handleRequest(m_id);
}
/*
Generate a value given a floating point number, using formatting defined within this class.
The formatting mainly applies if formatting as a string. For example, was is
the number base? should a sign always be included? are leading zeros requried?
The formatting could include properties related to other types. For example, generate
an error if attempting to convert a negative floating point number to an unsigned integer.
*/
QVariant QEFloatingFormatting::formatValue( const double &floatingValue, generic::generic_types valueType ) {
switch( valueType ) {
case generic::GENERIC_DOUBLE :
case generic::GENERIC_FLOAT :
{
QVariant dValue( floatingValue );
return dValue;
}
case generic::GENERIC_LONG :
{
qlonglong integerValue;
if( floatingValue < (double)LONG_MIN )
integerValue = LONG_MIN;
else if( floatingValue > (double)LONG_MAX )
integerValue = LONG_MAX;
else
integerValue = (qlonglong)floatingValue;
QVariant lValue( integerValue );
return lValue;
}
case generic::GENERIC_SHORT :
{
qlonglong integerValue;
if( floatingValue < (double)SHRT_MIN )
integerValue = SHRT_MIN;
else if( floatingValue > (double)SHRT_MAX )
integerValue = SHRT_MAX;
else
integerValue = (qlonglong)floatingValue;
QVariant lValue( integerValue );
return lValue;
}
case generic::GENERIC_UNSIGNED_LONG :
{
qulonglong unsignedIntegerValue;
if( floatingValue < 0 )
unsignedIntegerValue = 0;
else if( floatingValue > (double)ULONG_MAX )
unsignedIntegerValue = ULONG_MAX;
else
unsignedIntegerValue = (qulonglong)floatingValue;
QVariant ulValue( unsignedIntegerValue );
return ulValue;
}
case generic::GENERIC_UNSIGNED_SHORT :
{
qulonglong unsignedIntegerValue;
if( floatingValue < 0 )
unsignedIntegerValue = 0;
else if( floatingValue > (double)USHRT_MAX )
unsignedIntegerValue = USHRT_MAX;
else
unsignedIntegerValue = (qulonglong)floatingValue;
QVariant ulValue( unsignedIntegerValue );
return ulValue;
}
case generic::GENERIC_UNSIGNED_CHAR :
{
qulonglong unsignedIntegerValue;
if( floatingValue < 0 )
unsignedIntegerValue = 0;
else if( floatingValue > (double)UCHAR_MAX )
unsignedIntegerValue = UCHAR_MAX;
else
unsignedIntegerValue = (qulonglong)floatingValue;
QVariant ulValue( unsignedIntegerValue );
return ulValue;
}
case generic::GENERIC_STRING :
{
QString string = QString::number( floatingValue, getFormatChar(), precision );
QVariant sValue( string );
return sValue;
}
case generic::GENERIC_UNKNOWN :
{
}
default :
{
//qDebug() << "QEFloatingFormatting::formatValue() Unknown value 'Generic' type: " << valueType;
QVariant unknown;
return unknown;
}
}
//qDebug() << "QEFloatingFormatting::formatValue() Unknown value 'Generic' type: " << valueType;
QVariant unknown;
return unknown;
}
