void HTTPMessage::setTransferEncoding(const std::string& transferEncoding)
{
if (icompare(transferEncoding, IDENTITY_TRANSFER_ENCODING) == 0)
erase(TRANSFER_ENCODING);
else
set(TRANSFER_ENCODING, transferEncoding);
}
int icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n, const std::string& str2, std::string::size_type pos2)
{
std::string::size_type sz2 = str2.size();
if (pos2 > sz2) pos2 = sz2;
if (pos2 + n > sz2) n = sz2 - pos2;
return icompare(str1, pos1, n, str2.begin() + pos2, str2.begin() + pos2 + n);
}
int UTF8::icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n1, const std::string& str2, std::string::size_type pos2, std::string::size_type n2)
{
std::string::size_type sz2 = str2.size();
if (pos2 > sz2) pos2 = sz2;
if (pos2 + n2 > sz2) n2 = sz2 - pos2;
return icompare(str1, pos1, n1, str2.begin() + pos2, str2.begin() + pos2 + n2);
}
void IniFileConfigurationNew::removeRaw(const std::string& key)
{
std::string prefix = key;
if (!prefix.empty()) prefix += '.';
std::string::size_type psize = prefix.size();
IStringMap::iterator it = _map.begin();
IStringMap::iterator itCur;
while (it != _map.end())
{
itCur = it++;
if ((icompare(itCur->first, key) == 0) || (icompare(itCur->first, psize, prefix) == 0))
{
_map.erase(itCur);
}
}
}
bool HTTPMessage::getKeepAlive() const
{
const std::string& connection = get(CONNECTION, EMPTY);
if (!connection.empty())
return icompare(connection, CONNECTION_CLOSE) != 0;
else
return getVersion() == HTTP_1_1;
}
bool iEndsWith(const std::string &str, const std::string &suffix) {
if (str.size() < suffix.size()) {
return false;
}
auto tstr = str.substr(str.size() - suffix.size());
return icompare(tstr, suffix) == 0;
}
HTTPCookie::HTTPCookie(const NameValueCollection& nvc):
_version(0),
_secure(false),
_maxAge(-1),
_httpOnly(false)
{
for (NameValueCollection::ConstIterator it = nvc.begin(); it != nvc.end(); ++it)
{
const std::string& name = it->first;
const std::string& value = it->second;
if (icompare(name, "comment") == 0)
{
setComment(value);
}
else if (icompare(name, "domain") == 0)
{
setDomain(value);
}
else if (icompare(name, "path") == 0)
{
setPath(value);
}
else if (icompare(name, "max-age") == 0)
{
setMaxAge(NumberParser::parse(value));
}
else if (icompare(name, "secure") == 0)
{
setSecure(true);
}
else if (icompare(name, "expires") == 0)
{
int tzd;
DateTime exp = DateTimeParser::parse(value, tzd);
Timestamp now;
setMaxAge((int) ((exp.timestamp() - now) / Timestamp::resolution()));
}
else if (icompare(name, "version") == 0)
{
setVersion(NumberParser::parse(value));
}
else if (icompare(name, "HttpOnly") == 0)
{
setHttpOnly(true);
}
else
{
setName(name);
setValue(value);
}
}
}
bool FileChannel::setNoPurge(const std::string& value)
{
if (value.empty() || 0 == icompare(value, "none"))
{
delete _pPurgeStrategy;
_pPurgeStrategy = 0;
_purgeAge = "none";
return true;
}
else return false;
}
WebSocketImpl* WebSocket::accept(HTTPServerRequest& request, HTTPServerResponse& response)
{
if (icompare(request.get("Connection", ""), "Upgrade") == 0 &&
icompare(request.get("Upgrade", ""), "websocket") == 0)
{
std::string version = request.get("Sec-WebSocket-Version", "");
if (version.empty()) throw WebSocketException("Missing Sec-WebSocket-Version in handshake request", WS_ERR_HANDSHAKE_NO_VERSION);
if (version != WEBSOCKET_VERSION) throw WebSocketException("Unsupported WebSocket version requested", version, WS_ERR_HANDSHAKE_UNSUPPORTED_VERSION);
std::string key = request.get("Sec-WebSocket-Key", "");
Poco::trimInPlace(key);
if (key.empty()) throw WebSocketException("Missing Sec-WebSocket-Key in handshake request", WS_ERR_HANDSHAKE_NO_KEY);
response.setStatusAndReason(HTTPResponse::HTTP_SWITCHING_PROTOCOLS);
response.set("Upgrade", "websocket");
response.set("Connection", "Upgrade");
response.set("Sec-WebSocket-Accept", computeAccept(key));
response.setContentLength(0);
response.send().flush();
return new WebSocketImpl(static_cast<StreamSocketImpl*>(static_cast<HTTPServerRequestImpl&>(request).detachSocket().impl()), false);
}
else throw WebSocketException("No WebSocket handshake", WS_ERR_NO_HANDSHAKE);
}
HTTPCookie::HTTPCookie(const NameValueCollection& nvc):
_version(0),
_secure(false),
_maxAge(-1),
_httpOnly(false)
{
for (NameValueCollection::ConstIterator it = nvc.begin(); it != nvc.end(); ++it) {
const std::string& name = it->first;
const std::string& value = it->second;
if (icompare(name, "comment") == 0) {
setComment(value);
}
else if (icompare(name, "domain") == 0) {
setDomain(value);
}
else if (icompare(name, "path") == 0) {
setPath(value);
}
else if (icompare(name, "priority") == 0) {
setPriority(value);
}
else if (icompare(name, "max-age") == 0) {
throw NotImplementedException("HTTPCookie::HTTPCookie max-age");
}
else if (icompare(name, "secure") == 0) {
setSecure(true);
}
else if (icompare(name, "expires") == 0) {
throw NotImplementedException("HTTPCookie::HTTPCookie expires");
}
else if (icompare(name, "version") == 0) {
throw NotImplementedException("HTTPCookie::HTTPCookie version");
}
else if (icompare(name, "HttpOnly") == 0) {
setHttpOnly(true);
}
else {
setName(name);
setValue(value);
}
}
}
void DirectHandler::handleValue(const JSONEntity& val)
{
if (0 == icompare(_key, "action"))
{
handleAction(val.toString());
}
else if (0 == icompare(_key, "method"))
{
handleMethod(val.toString());
}
else if (0 == icompare(_key, "data"))
{
handleData(val);
}
else if (0 == icompare(_key, "type"))
{
handleType(val.toString());
}
else if (0 == icompare(_key, "tid"))
{
handleTID(val.toInteger());
}
}
void OAuth20Credentials::extractBearerToken(const HTTPRequest& request)
{
if (request.hasCredentials())
{
std::string authScheme;
std::string authInfo;
request.getCredentials(authScheme, authInfo);
if (icompare(authScheme, _scheme) == 0)
{
_bearerToken = authInfo;
}
else throw NotAuthenticatedException("No bearer token in Authorization header", authScheme);
}
else throw NotAuthenticatedException("No Authorization header found");
}
int Logger::parseLevel(const std::string& level)
{
if (icompare(level, "none") == 0)
return 0;
else if (icompare(level, "fatal") == 0)
return Message::PRIO_FATAL;
else if (icompare(level, "critical") == 0)
return Message::PRIO_CRITICAL;
else if (icompare(level, "error") == 0)
return Message::PRIO_ERROR;
else if (icompare(level, "warning") == 0)
return Message::PRIO_WARNING;
else if (icompare(level, "notice") == 0)
return Message::PRIO_NOTICE;
else if (icompare(level, "information") == 0)
return Message::PRIO_INFORMATION;
else if (icompare(level, "debug") == 0)
return Message::PRIO_DEBUG;
else if (icompare(level, "trace") == 0)
return Message::PRIO_TRACE;
else
throw InvalidArgumentException("Not a valid log level", level);
}
void FileChannel::setPurgeAge(const std::string& age)
{
delete _pPurgeStrategy;
_pPurgeStrategy = 0;
_purgeAge = "none";
if (age.empty() || 0 == icompare(age, "none"))
return;
std::string::const_iterator it = age.begin();
std::string::const_iterator end = age.end();
int n = 0;
while (it != end && Ascii::isSpace(*it))
++it;
while (it != end && Ascii::isDigit(*it))
{
n *= 10;
n += *it++ - '0';
}
while (it != end && Ascii::isSpace(*it))
++it;
std::string unit;
while (it != end && Ascii::isAlpha(*it))
unit += *it++;
Timespan::TimeDiff factor = Timespan::SECONDS;
if (unit == "minutes")
factor = Timespan::MINUTES;
else if (unit == "hours")
factor = Timespan::HOURS;
else if (unit == "days")
factor = Timespan::DAYS;
else if (unit == "weeks")
factor = 7*Timespan::DAYS;
else if (unit == "months")
factor = 30 * Timespan::DAYS;
else if (unit != "seconds")
throw InvalidArgumentException("purgeAge", age);
if (0 == n)
throw InvalidArgumentException("Zero is not valid purge age.");
_pPurgeStrategy = new PurgeByAgeStrategy(Timespan(factor * n));
_purgeAge = age;
}
void WindowsColorConsoleChannel::setProperty(const std::string& name, const std::string& value)
{
if (name == "enableColors")
{
_enableColors = icompare(value, "true") == 0;
}
else if (name == "traceColor")
{
_colors[Message::PRIO_TRACE] = parseColor(value);
}
else if (name == "debugColor")
{
_colors[Message::PRIO_DEBUG] = parseColor(value);
}
else if (name == "informationColor")
{
_colors[Message::PRIO_INFORMATION] = parseColor(value);
}
else if (name == "noticeColor")
{
_colors[Message::PRIO_NOTICE] = parseColor(value);
}
else if (name == "warningColor")
{
_colors[Message::PRIO_WARNING] = parseColor(value);
}
else if (name == "errorColor")
{
_colors[Message::PRIO_ERROR] = parseColor(value);
}
else if (name == "criticalColor")
{
_colors[Message::PRIO_CRITICAL] = parseColor(value);
}
else if (name == "fatalColor")
{
_colors[Message::PRIO_FATAL] = parseColor(value);
}
else
{
Channel::setProperty(name, value);
}
}
void LevelFilterChannel::setLevel(const std::string& value)
{
if (icompare(value, "fatal") == 0)
setLevel(Message::PRIO_FATAL);
else if (icompare(value, "critical") == 0)
setLevel(Message::PRIO_CRITICAL);
else if (icompare(value, "error") == 0)
setLevel(Message::PRIO_ERROR);
else if (icompare(value, "warning") == 0)
setLevel(Message::PRIO_WARNING);
else if (icompare(value, "notice") == 0)
setLevel(Message::PRIO_NOTICE);
else if (icompare(value, "information") == 0)
setLevel(Message::PRIO_INFORMATION);
else if (icompare(value, "debug") == 0)
setLevel(Message::PRIO_DEBUG);
else if (icompare(value, "trace") == 0)
setLevel(Message::PRIO_TRACE);
else
throw InvalidArgumentException("Not a valid log value", value);
}
bool FileImpl::isDeviceImpl() const
{
return
_path.compare(0, 4, "\\\\.\\") == 0 ||
icompare(_path, "CON") == 0 ||
icompare(_path, "PRN") == 0 ||
icompare(_path, "AUX") == 0 ||
icompare(_path, "NUL") == 0 ||
( (icompare(_path, 0, 3, "LPT") == 0 || icompare(_path, 0, 3, "COM") == 0) &&
_path.size() == 4 &&
_path[3] > 0x30 &&
isdigit(_path[3])
);
}
void FileChannel::setPurgeCount(const std::string& count)
{
delete _pPurgeStrategy;
_pPurgeStrategy = 0;
_purgeAge = "none";
if (count.empty() || 0 == icompare(count, "none"))
return;
std::string::const_iterator it = count.begin();
std::string::const_iterator end = count.end();
int n = 0;
while (it != end && Ascii::isSpace(*it)) ++it;
while (it != end && Ascii::isDigit(*it)) { n *= 10; n += *it++ - '0'; }
if (0 == n)
throw InvalidArgumentException("Zero is not valid purge count.");
while (it != end && Ascii::isSpace(*it)) ++it;
delete _pPurgeStrategy;
_pPurgeStrategy = new PurgeByCountStrategy(n);
_purgeCount = count;
}
bool HTTPDigestCredentials::verifyAuthParams(const HTTPRequest& request, const HTTPAuthenticationParams& params) const
{
const std::string& nonce = params.get(NONCE_PARAM);
const std::string& realm = params.getRealm();
const std::string& qop = params.get(QOP_PARAM, DEFAULT_QOP);
std::string response;
MD5Engine engine;
if (qop.empty())
{
const std::string ha1 = digest(engine, _username, realm, _password);
const std::string ha2 = digest(engine, request.getMethod(), request.getURI());
response = digest(engine, ha1, nonce, ha2);
}
else if (icompare(qop, AUTH_PARAM) == 0)
{
const std::string& cnonce = params.get(CNONCE_PARAM);
const std::string& nc = params.get(NC_PARAM);
const std::string ha1 = digest(engine, _username, realm, _password);
const std::string ha2 = digest(engine, request.getMethod(), request.getURI());
response = digest(engine, ha1, nonce, nc, cnonce, qop, ha2);
}
return response == params.get(RESPONSE_PARAM);
}
void Option::process(const std::string& option, std::string& arg) const
{
std::string::size_type pos = option.find_first_of(":=");
std::string::size_type len = pos == std::string::npos ? option.length() : pos;
if (icompare(option, 0, len, _fullName, 0, len) == 0)
{
if (takesArgument())
{
if (argumentRequired() && pos == std::string::npos)
throw MissingArgumentException(_fullName + " requires " + argumentName());
if (pos != std::string::npos)
arg.assign(option, pos + 1, option.length() - pos - 1);
else
arg.clear();
}
else if (pos != std::string::npos)
{
throw UnexpectedArgumentException(option);
}
else arg.clear();
}
else if (!_shortName.empty() && option.compare(0, _shortName.length(), _shortName) == 0)
{
if (takesArgument())
{
if (argumentRequired() && option.length() == _shortName.length())
throw MissingArgumentException(_shortName + " requires " + argumentName());
arg.assign(option, _shortName.length(), option.length() - _shortName.length());
}
else if (option.length() != _shortName.length())
{
throw UnexpectedArgumentException(option);
}
else arg.clear();
}
else throw UnknownOptionException(option);
}
void IniFileConfiguration::enumerate(const std::string& key, Keys& range) const
{
std::set<std::string> keys;
std::string prefix = key;
if (!prefix.empty()) prefix += '.';
std::string::size_type psize = prefix.size();
for (IStringMap::const_iterator it = _map.begin(); it != _map.end(); ++it)
{
if (icompare(it->first, psize, prefix) == 0)
{
std::string subKey;
std::string::size_type end = it->first.find('.', psize);
if (end == std::string::npos)
subKey = it->first.substr(psize);
else
subKey = it->first.substr(psize, end - psize);
if (keys.find(subKey) == keys.end())
{
range.push_back(subKey);
keys.insert(subKey);
}
}
}
}
bool NumberParser::tryParseBool(const std::string& s, bool& value)
{
int n;
if (NumberParser::tryParse(s, n))
{
value = (n != 0);
return true;
}
if (icompare(s, "true") == 0)
{
value = true;
return true;
}
else if (icompare(s, "yes") == 0)
{
value = true;
return true;
}
else if (icompare(s, "on") == 0)
{
value = true;
return true;
}
if (icompare(s, "false") == 0)
{
value = false;
return true;
}
else if (icompare(s, "no") == 0)
{
value = false;
return true;
}
else if (icompare(s, "off") == 0)
{
value = false;
return true;
}
return false;
}
bool AbstractConfiguration::parseBool(const std::string& value)
{
int n;
if (NumberParser::tryParse(value, n))
return n != 0;
else if (icompare(value, "true") == 0)
return true;
else if (icompare(value, "yes") == 0)
return true;
else if (icompare(value, "on") == 0)
return true;
else if (icompare(value, "false") == 0)
return false;
else if (icompare(value, "no") == 0)
return false;
else if (icompare(value, "off") == 0)
return false;
else
throw SyntaxException("Cannot convert to boolean", value);
}
bool FileImpl::canExecuteImpl() const
{
Path p(_path);
return icompare(p.getExtension(), "exe") == 0;
}
/*************************************************************************
*
*N query_table
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function returns the set of selected rows of a VPF table
* based upon the evaluation of the given selection expression string.
*
* The expression is strictly evaluated left to right. No nesting
* is supported, so parentheses are not allowed. The expression
* must match the form:
* <field><log op><value> [ <join> <field><log op><value>]
* where,
* <field> is a valid field name of the table.
* <log op> is one of the following: =, <, >, <=, >=, <> (not equal).
* <value> is a valid value for the field.
* <join> is either " AND " or " OR ".
* Any number of clauses (<field><log op><value>) may be joined
* together with AND or OR to form the expression.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* expression <input>==(char *) selection expression string.
* table <input>==(vpf_table_type) VPF table structure.
* return <output>==(set_type) set of selected rows.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* External Variables:
*X
* None
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Functions Called:
*F
* set_type set_init( rspf_int32 n ) SET.C
* void set_insert( rspf_int32 element, set_type set ) SET.C
* linked_list_type parse_expression( char *expression,
* vpf_table_type table ) VPFQUERY.C
* row_type read_next_row( vpf_table_type table ) VPFREAD.C
* position_type ll_first( linked_list_type list ) LINKLIST.C
* int ll_end( position_type position ) LINKLIST.C
* void ll_element( position_type position, void *element ) LINKLIST.C
* void *get_table_element( rspf_int32 field_number,
* row_type row,
* vpf_table_type table,
* void *value,
* rspf_int32 *count ) VPFREAD.C
* void display_message( char *info ) USER DEFINED
* static int strcompare( char *val1, char *val2, char op ) VPFQUERY.C
* static int icompare( rspf_int32 val1, rspf_int32 val2, char op ) VPFQUERY.C
* static int fcompare( float val1, float val2, char op ) VPFQUERY.C
* void ll_reset( linked_list_type list ) LINKLIST.C
void free_row( row_type row, vpf_table_type table) VPFREAD.C
*E
*************************************************************************/
set_type query_table( char *expression, vpf_table_type table )
{
row_type row;
position_type pos;
expr_type expr;
register rspf_int32 i;
int boolval=FALSE, booltemp=0, join = OR;
rspf_int32 lval, lval2, count;
float fval, fval2;
char tval, tval2, *tptr;
linked_list_type exprlist;
set_type select_set;
select_set = set_init(table.nrows+1);
if (strcmp(expression,"*")==0) {
set_on(select_set);
return select_set;
}
exprlist = parse_expression( expression, table );
if (!exprlist) return select_set;
if (table.storage == DISK)
fseek( table.fp, index_pos(1,table), SEEK_SET );
for (i=1;i<=table.nrows;i++) {
if (table.storage == DISK)
row = read_next_row(table);
else
row = get_row( i, table );
pos = ll_first(exprlist);
while (!ll_end(pos)) {
ll_element( pos, &expr );
switch (table.header[expr.field].type) {
case 'I':
if (table.header[expr.field].count == 1) {
get_table_element( expr.field, row, table, &lval, &count );
lval2 = atol(expr.value);
booltemp = icompare( lval, lval2, expr.op );
} else {
display_message(
"Selection may not be performed upon arrays");
i=table.nrows+1;
}
break;
case 'T':
if (table.header[expr.field].count == 1) {
get_table_element( expr.field, row, table, &tval, &count );
tval2 = expr.value[0];
booltemp = comp( &tval, &tval2, sizeof(tval), expr.op );
} else {
tptr = (char *)get_table_element( expr.field, row, table,
NULL, &count );
booltemp = strcompare( tptr, expr.value, expr.op );
free(tptr);
}
break;
case 'F':
if (table.header[expr.field].count == 1) {
get_table_element( expr.field, row, table, &fval, &count );
if (!is_vpf_null_float(fval)) {
fval2 = (float)atof(expr.value);
booltemp = fcompare( fval, fval2, expr.op );
} else booltemp = FALSE;
} else {
display_message(
"Selection may not be performed upon arrays");
i=table.nrows+3;
}
break;
default:
display_message("Field type not supported for query");
i=table.nrows+3;
break;
}
if (i>table.nrows) break;
if (join==OR)
boolval = boolval || booltemp;
else
boolval = boolval && booltemp;
join = expr.join;
pos = pos->next;
}
free_row( row, table );
if (boolval) set_insert(i,select_set);
boolval = FALSE;
join = OR;
if (i==table.nrows+3) break;
}
ll_reset(exprlist);
return select_set;
}
int icompare(const std::string& str1, std::string::size_type pos, std::string::size_type n, const std::string& str2)
{
return icompare(str1, pos, n, str2.begin(), str2.end());
}
int icompare(const std::string& str1, std::string::size_type n, const std::string& str2)
{
if (n > str2.size()) n = str2.size();
return icompare(str1, 0, n, str2.begin(), str2.begin() + n);
}
int icompare(const std::string& str1, std::string::size_type n1, const std::string& str2, std::string::size_type n2)
{
if (n2 > str2.size()) n2 = str2.size();
return icompare(str1, 0, n1, str2.begin(), str2.begin() + n2);
}
int icompare(const std::string& str1, const std::string& str2)
{
return icompare(str1, 0, str1.size(), str2.begin(), str2.end());
}
int icompare(const std::string& str, const std::string::value_type* ptr)
{
return icompare(str, 0, str.size(), ptr);
}
