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); }