static ngx_int_t ngx_http_index_handler(ngx_http_request_t *r) { u_char *p, *name; size_t len, root, reserve, allocated; ngx_int_t rc; ngx_str_t path, uri; ngx_uint_t i, dir_tested; ngx_http_index_t *index; ngx_open_file_info_t of; ngx_http_script_code_pt code; ngx_http_script_engine_t e; ngx_http_core_loc_conf_t *clcf; ngx_http_index_loc_conf_t *ilcf; ngx_http_script_len_code_pt lcode; if (r->uri.data[r->uri.len - 1] != '/') { return NGX_DECLINED; } if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD|NGX_HTTP_POST))) { return NGX_DECLINED; } ilcf = ngx_http_get_module_loc_conf(r, ngx_http_index_module); clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module); allocated = 0; root = 0; dir_tested = 0; name = NULL; /* suppress MSVC warning */ path.data = NULL; index = ilcf->indices->elts; for (i = 0; i < ilcf->indices->nelts; i++) { if (index[i].lengths == NULL) { if (index[i].name.data[0] == '/') { return ngx_http_internal_redirect(r, &index[i].name, &r->args); } reserve = ilcf->max_index_len; len = index[i].name.len; } else { ngx_memzero(&e, sizeof(ngx_http_script_engine_t)); e.ip = index[i].lengths->elts; e.request = r; e.flushed = 1; /* 1 is for terminating '\0' as in static names */ len = 1; while (*(uintptr_t *) e.ip) { lcode = *(ngx_http_script_len_code_pt *) e.ip; len += lcode(&e); } /* 16 bytes are preallocation */ reserve = len + 16; } if (reserve > allocated) { name = ngx_http_map_uri_to_path(r, &path, &root, reserve); if (name == NULL) { return NGX_ERROR; } allocated = path.data + path.len - name; } if (index[i].values == NULL) { /* index[i].name.len includes the terminating '\0' */ ngx_memcpy(name, index[i].name.data, index[i].name.len); path.len = (name + index[i].name.len - 1) - path.data; } else { e.ip = index[i].values->elts; e.pos = name; while (*(uintptr_t *) e.ip) { code = *(ngx_http_script_code_pt *) e.ip; code((ngx_http_script_engine_t *) &e); } if (*name == '/') { uri.len = len - 1; uri.data = name; return ngx_http_internal_redirect(r, &uri, &r->args); } path.len = e.pos - path.data; *e.pos = '\0'; } ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "open index \"%V\"", &path); ngx_memzero(&of, sizeof(ngx_open_file_info_t)); of.read_ahead = clcf->read_ahead; of.directio = clcf->directio; of.valid = clcf->open_file_cache_valid; of.min_uses = clcf->open_file_cache_min_uses; of.test_only = 1; of.errors = clcf->open_file_cache_errors; of.events = clcf->open_file_cache_events; if (ngx_http_set_disable_symlinks(r, clcf, &path, &of) != NGX_OK) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool) != NGX_OK) { ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, of.err, "%s \"%s\" failed", of.failed, path.data); if (of.err == 0) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } #if (NGX_HAVE_OPENAT) if (of.err == NGX_EMLINK || of.err == NGX_ELOOP) { return NGX_HTTP_FORBIDDEN; } #endif if (of.err == NGX_ENOTDIR || of.err == NGX_ENAMETOOLONG || of.err == NGX_EACCES) { return ngx_http_index_error(r, clcf, path.data, of.err); } if (!dir_tested) { rc = ngx_http_index_test_dir(r, clcf, path.data, name - 1); if (rc != NGX_OK) { return rc; } dir_tested = 1; } if (of.err == NGX_ENOENT) { continue; } ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err, "%s \"%s\" failed", of.failed, path.data); return NGX_HTTP_INTERNAL_SERVER_ERROR; } uri.len = r->uri.len + len - 1; if (!clcf->alias) { uri.data = path.data + root; } else { uri.data = ngx_pnalloc(r->pool, uri.len); if (uri.data == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } p = ngx_copy(uri.data, r->uri.data, r->uri.len); ngx_memcpy(p, name, len - 1); } return ngx_http_internal_redirect(r, &uri, &r->args); } return NGX_DECLINED; }
//------------------------------------------------------------------------------ // Name: //------------------------------------------------------------------------------ IDebugEvent::Message PlatformEvent::error_description() const { Q_ASSERT(is_error()); const edb::address_t fault_address = reinterpret_cast<edb::address_t>(fault_address_); switch(code()) { case SIGSEGV: return Message( tr("Illegal Access Fault"), tr( "<p>The debugged application encountered a segmentation fault.<br />The address <strong>0x%1</strong> could not be accessed.</p>" "<p>If you would like to pass this exception to the application press Shift+[F7/F8/F9]</p>").arg(edb::v1::format_pointer(fault_address)) ); case SIGILL: return Message( tr("Illegal Instruction Fault"), tr( "<p>The debugged application attempted to execute an illegal instruction.</p>" "<p>If you would like to pass this exception to the application press Shift+[F7/F8/F9]</p>") ); case SIGFPE: switch(fault_code_) { case FPE_INTDIV: return Message( tr("Divide By Zero"), tr( "<p>The debugged application tried to divide an integer value by an integer divisor of zero.</p>" "<p>If you would like to pass this exception to the application press Shift+[F7/F8/F9]</p>") ); default: return Message( tr("Floating Point Exception"), tr( "<p>The debugged application encountered a floating-point exception.</p>" "<p>If you would like to pass this exception to the application press Shift+[F7/F8/F9]</p>") ); } case SIGABRT: return Message( tr("Application Aborted"), tr( "<p>The debugged application has aborted.</p>" "<p>If you would like to pass this exception to the application press Shift+[F7/F8/F9]</p>") ); case SIGBUS: return Message( tr("Bus Error"), tr( "<p>The debugged application tried to read or write data that is misaligned.</p>" "<p>If you would like to pass this exception to the application press Shift+[F7/F8/F9]</p>") ); #ifdef SIGSTKFLT case SIGSTKFLT: return Message( tr("Stack Fault"), tr( "<p>The debugged application encountered a stack fault.</p>" "<p>If you would like to pass this exception to the application press Shift+[F7/F8/F9]</p>") ); #endif case SIGPIPE: return Message( tr("Broken Pipe Fault"), tr( "<p>The debugged application encountered a broken pipe fault.</p>" "<p>If you would like to pass this exception to the application press Shift+[F7/F8/F9]</p>") ); default: return Message(); } }
TEST(CollectionOptions, UnknownOptionRejectedIfCreateOptionNotPresent) { CollectionOptions options; auto status = options.parse(fromjson("{invalidOption: 1}")); ASSERT_NOT_OK(status); ASSERT_EQ(status.code(), ErrorCodes::InvalidOptions); }
/** * Return whether there are non-local databases. If there was an error becauses the wrong mongod * version was used for these datafiles, a DBException with status ErrorCodes::MustDowngrade is * thrown. */ bool repairDatabasesAndCheckVersion(OperationContext* opCtx) { auto const storageEngine = opCtx->getServiceContext()->getStorageEngine(); Lock::GlobalWrite lk(opCtx); std::vector<std::string> dbNames = storageEngine->listDatabases(); // Rebuilding indexes must be done before a database can be opened, except when using repair, // which rebuilds all indexes when it is done. if (!storageGlobalParams.readOnly && !storageGlobalParams.repair) { // Determine whether this is a replica set node running in standalone mode. If we're in // repair mode, we cannot set the flag yet as it needs to open a database and look through a // collection. Rebuild the necessary indexes after setting the flag. setReplSetMemberInStandaloneMode(opCtx); rebuildIndexes(opCtx, storageEngine); } bool ensuredCollectionProperties = false; // Repair all databases first, so that we do not try to open them if they are in bad shape auto databaseHolder = DatabaseHolder::get(opCtx); if (storageGlobalParams.repair) { invariant(!storageGlobalParams.readOnly); if (MONGO_FAIL_POINT(exitBeforeDataRepair)) { log() << "Exiting because 'exitBeforeDataRepair' fail point was set."; quickExit(EXIT_ABRUPT); } // Ensure that the local database is repaired first, if it exists, so that we can open it // before any other database to be able to determine if this is a replica set node running // in standalone mode before rebuilding any indexes. auto dbNamesIt = std::find(dbNames.begin(), dbNames.end(), NamespaceString::kLocalDb); if (dbNamesIt != dbNames.end()) { std::swap(dbNames.front(), *dbNamesIt); invariant(dbNames.front() == NamespaceString::kLocalDb); } stdx::function<void(const std::string& dbName)> onRecordStoreRepair = [opCtx](const std::string& dbName) { if (dbName == NamespaceString::kLocalDb) { setReplSetMemberInStandaloneMode(opCtx); } }; for (const auto& dbName : dbNames) { LOG(1) << " Repairing database: " << dbName; fassertNoTrace(18506, repairDatabase(opCtx, storageEngine, dbName, onRecordStoreRepair)); } // All collections must have UUIDs before restoring the FCV document to a version that // requires UUIDs. uassertStatusOK(ensureCollectionProperties(opCtx, dbNames)); ensuredCollectionProperties = true; // Attempt to restore the featureCompatibilityVersion document if it is missing. NamespaceString fcvNSS(NamespaceString::kServerConfigurationNamespace); auto db = databaseHolder->getDb(opCtx, fcvNSS.db()); Collection* versionColl; BSONObj featureCompatibilityVersion; if (!db || !(versionColl = db->getCollection(opCtx, fcvNSS)) || !Helpers::findOne(opCtx, versionColl, BSON("_id" << FeatureCompatibilityVersionParser::kParameterName), featureCompatibilityVersion)) { uassertStatusOK(restoreMissingFeatureCompatibilityVersionDocument(opCtx, dbNames)); } } if (!ensuredCollectionProperties) { uassertStatusOK(ensureCollectionProperties(opCtx, dbNames)); } if (!storageGlobalParams.readOnly) { // We open the "local" database before calling hasReplSetConfigDoc() to ensure the in-memory // catalog entries for the 'kSystemReplSetNamespace' collection have been populated if the // collection exists. If the "local" database didn't exist at this point yet, then it will // be created. If the mongod is running in a read-only mode, then it is fine to not open the // "local" database and populate the catalog entries because we won't attempt to drop the // temporary collections anyway. Lock::DBLock dbLock(opCtx, NamespaceString::kSystemReplSetNamespace.db(), MODE_X); databaseHolder->openDb(opCtx, NamespaceString::kSystemReplSetNamespace.db()); } if (storageGlobalParams.repair) { if (MONGO_FAIL_POINT(exitBeforeRepairInvalidatesConfig)) { log() << "Exiting because 'exitBeforeRepairInvalidatesConfig' fail point was set."; quickExit(EXIT_ABRUPT); } // This must be done after opening the "local" database as it modifies the replica set // config. auto repairObserver = StorageRepairObserver::get(opCtx->getServiceContext()); repairObserver->onRepairDone(opCtx); if (repairObserver->isDataModified()) { warning() << "Modifications made by repair:"; const auto& mods = repairObserver->getModifications(); for (const auto& mod : mods) { warning() << " " << mod; } if (hasReplSetConfigDoc(opCtx)) { warning() << "WARNING: Repair may have modified replicated data. This node will no " "longer be able to join a replica set without a full re-sync"; } } } const repl::ReplSettings& replSettings = repl::ReplicationCoordinator::get(opCtx)->getSettings(); // On replica set members we only clear temp collections on DBs other than "local" during // promotion to primary. On pure slaves, they are only cleared when the oplog tells them // to. The local DB is special because it is not replicated. See SERVER-10927 for more // details. const bool shouldClearNonLocalTmpCollections = !(hasReplSetConfigDoc(opCtx) || replSettings.usingReplSets()); // To check whether a featureCompatibilityVersion document exists. bool fcvDocumentExists = false; // To check whether we have databases other than local. bool nonLocalDatabases = false; // Refresh list of database names to include newly-created admin, if it exists. dbNames = storageEngine->listDatabases(); for (const auto& dbName : dbNames) { if (dbName != "local") { nonLocalDatabases = true; } LOG(1) << " Recovering database: " << dbName; auto db = databaseHolder->openDb(opCtx, dbName); invariant(db); // First thing after opening the database is to check for file compatibility, // otherwise we might crash if this is a deprecated format. auto status = storageEngine->currentFilesCompatible(opCtx); if (!status.isOK()) { if (status.code() == ErrorCodes::CanRepairToDowngrade) { // Convert CanRepairToDowngrade statuses to MustUpgrade statuses to avoid logging a // potentially confusing and inaccurate message. // // TODO SERVER-24097: Log a message informing the user that they can start the // current version of mongod with --repair and then proceed with normal startup. status = {ErrorCodes::MustUpgrade, status.reason()}; } severe() << "Unable to start mongod due to an incompatibility with the data files and" " this version of mongod: " << redact(status); severe() << "Please consult our documentation when trying to downgrade to a previous" " major release"; quickExit(EXIT_NEED_UPGRADE); MONGO_UNREACHABLE; } // If the server configuration collection already contains a valid // featureCompatibilityVersion document, cache it in-memory as a server parameter. if (dbName == "admin") { if (Collection* versionColl = db->getCollection(opCtx, NamespaceString::kServerConfigurationNamespace)) { BSONObj featureCompatibilityVersion; if (Helpers::findOne( opCtx, versionColl, BSON("_id" << FeatureCompatibilityVersionParser::kParameterName), featureCompatibilityVersion)) { auto swVersion = FeatureCompatibilityVersionParser::parse(featureCompatibilityVersion); // Note this error path captures all cases of an FCV document existing, // but with any value other than "4.0" or "4.2". This includes unexpected // cases with no path forward such as the FCV value not being a string. uassert(ErrorCodes::MustDowngrade, str::stream() << "UPGRADE PROBLEM: Found an invalid " "featureCompatibilityVersion document (ERROR: " << swVersion.getStatus() << "). If the current featureCompatibilityVersion is below " "4.0, see the documentation on upgrading at " << feature_compatibility_version_documentation::kUpgradeLink << ".", swVersion.isOK()); fcvDocumentExists = true; auto version = swVersion.getValue(); serverGlobalParams.featureCompatibility.setVersion(version); FeatureCompatibilityVersion::updateMinWireVersion(); // On startup, if the version is in an upgrading or downrading state, print a // warning. if (version == ServerGlobalParams::FeatureCompatibility::Version::kUpgradingTo42) { log() << "** WARNING: A featureCompatibilityVersion upgrade did not " << "complete. " << startupWarningsLog; log() << "** The current featureCompatibilityVersion is " << FeatureCompatibilityVersionParser::toString(version) << "." << startupWarningsLog; log() << "** To fix this, use the setFeatureCompatibilityVersion " << "command to resume upgrade to 4.2." << startupWarningsLog; } else if (version == ServerGlobalParams::FeatureCompatibility::Version:: kDowngradingTo40) { log() << "** WARNING: A featureCompatibilityVersion downgrade did not " << "complete. " << startupWarningsLog; log() << "** The current featureCompatibilityVersion is " << FeatureCompatibilityVersionParser::toString(version) << "." << startupWarningsLog; log() << "** To fix this, use the setFeatureCompatibilityVersion " << "command to resume downgrade to 4.0." << startupWarningsLog; } } } } if (replSettings.usingReplSets()) { // We only care about _id indexes and drop-pending collections if we are in a replset. db->checkForIdIndexesAndDropPendingCollections(opCtx); // Ensure oplog is capped (mongodb does not guarantee order of inserts on noncapped // collections) if (db->name() == "local") { checkForCappedOplog(opCtx, db); } } if (!storageGlobalParams.readOnly && (shouldClearNonLocalTmpCollections || dbName == "local")) { db->clearTmpCollections(opCtx); } } // Fail to start up if there is no featureCompatibilityVersion document and there are non-local // databases present. if (!fcvDocumentExists && nonLocalDatabases) { severe() << "Unable to start up mongod due to missing featureCompatibilityVersion document."; severe() << "Please run with --repair to restore the document."; fassertFailedNoTrace(40652); } LOG(1) << "done repairDatabases"; return nonLocalDatabases; }
//------------------------------------------------------------------------------ // Name: //------------------------------------------------------------------------------ bool PlatformEvent::is_stop() const { return stopped() && code() == SIGSTOP; }
//! Assign bit value at given square //! @param sq square to assign value at //! @param val boolean value to assign void set(Square sq, bool val) { if (val) data_ |= data_type(1) << code(sq); else data_ &= ~(data_type(1) << code(sq)); }
// Inform CodeBuffer that incoming code and relocation will be code // Should not be called if start_a_stub() returned NULL void AbstractAssembler::end_a_stub() { assert(_code_section == code()->stubs(), "not in stubs?"); sync(); set_code_section(code()->insts()); }
DValue * DtoInlineAsmExpr(Loc loc, FuncDeclaration * fd, Expressions * arguments) { Logger::println("DtoInlineAsmExpr @ %s", loc.toChars()); LOG_SCOPE; TemplateInstance* ti = fd->toParent()->isTemplateInstance(); assert(ti && "invalid inline __asm expr"); assert(arguments->dim >= 2 && "invalid __asm call"); // get code param Expression* e = static_cast<Expression*>(arguments->data[0]); Logger::println("code exp: %s", e->toChars()); StringExp* se = static_cast<StringExp*>(e); if (e->op != TOKstring || se->sz != 1) { e->error("__asm code argument is not a char[] string literal"); fatal(); } std::string code(static_cast<char*>(se->string), se->len); // get constraints param e = static_cast<Expression*>(arguments->data[1]); Logger::println("constraint exp: %s", e->toChars()); se = static_cast<StringExp*>(e); if (e->op != TOKstring || se->sz != 1) { e->error("__asm constraints argument is not a char[] string literal"); fatal(); } std::string constraints(static_cast<char*>(se->string), se->len); // build runtime arguments size_t n = arguments->dim; LLSmallVector<llvm::Value*, 8> args; args.reserve(n-2); std::vector<LLType*> argtypes; argtypes.reserve(n-2); for (size_t i = 2; i < n; i++) { e = static_cast<Expression*>(arguments->data[i]); args.push_back(e->toElem(gIR)->getRVal()); argtypes.push_back(args.back()->getType()); } // build asm function type Type* type = fd->type->nextOf()->toBasetype(); LLType* ret_type = DtoType(type); llvm::FunctionType* FT = llvm::FunctionType::get(ret_type, argtypes, false); // build asm call bool sideeffect = true; llvm::InlineAsm* ia = llvm::InlineAsm::get(FT, code, constraints, sideeffect); llvm::Value* rv = gIR->ir->CreateCall(ia, args, ""); // work around missing tuple support for users of the return value if (type->ty == Tstruct) { // make a copy llvm::Value* mem = DtoAlloca(type, ".__asm_tuple_ret"); TypeStruct* ts = static_cast<TypeStruct*>(type); size_t n = ts->sym->fields.dim; for (size_t i = 0; i < n; i++) { llvm::Value* v = gIR->ir->CreateExtractValue(rv, i, ""); llvm::Value* gep = DtoGEPi(mem, 0, i); DtoStore(v, gep); } return new DVarValue(fd->type->nextOf(), mem); } // return call as im value return new DImValue(fd->type->nextOf(), rv); }
bool codeToTree() { std::string code( "?C1LDOPU<C4U!ALDOPU?aDOPU<a5O!EBO!N" ); std::stringstream ss; ss << std::setprecision(4) << std::fixed; ss << "?V"; ss << 10.0f; ss << "=V"; ss << 11.0f; ss << "!AU!N"; std::string predefineValue(ss.str()); std::string errorNodeCode( "VNTREZ" ); std::string errorExtractorCode( "?V10=Vab" ); try { auto tree = Factory::treeFromCode(code); std::string treeCode(tree.getIaCode()); if (treeCode != code) { std::cout << "IACode is different !!" << std::endl; return false; } } catch (Factory::FactoryException& fe) { std::cout << fe.what() << std::endl; return false; } try { auto tree = Factory::treeFromCode(predefineValue); auto treeCode = tree.getIaCode(); if (treeCode != predefineValue) { std::cout << "IACode is different for predefine value" << std::endl; return false; } } catch (Factory::FactoryException& fe) { std::cout << fe.what() << std::endl; return false; } try { auto tree = Factory::treeFromCode(errorNodeCode); std::cout << "No error found in error node code" << std::endl; return false; } catch (Factory::FactoryException&) { std::cout << "Error found in error node code (it's normal)" << std::endl; } try { auto tree = Factory::treeFromCode(errorExtractorCode); std::cout << "No error found in error extractor code" << std::endl; return false; } catch (Factory::FactoryException&) { std::cout << "Error found in error extractor code (it's normal)" << std::endl; } return true; }
String SystemException::message(){ char buf[XVR2_ERRNO_DESCRIPTION_MAXLEN]; strerror_r(code(), buf, XVR2_ERRNO_DESCRIPTION_MAXLEN); return String(buf); }
StatusWith<ShardType> ShardingCatalogManagerImpl::_validateHostAsShard( OperationContext* txn, std::shared_ptr<RemoteCommandTargeter> targeter, const std::string* shardProposedName, const ConnectionString& connectionString) { // Check whether any host in the connection is already part of the cluster. Grid::get(txn)->shardRegistry()->reload(txn); for (const auto& hostAndPort : connectionString.getServers()) { std::shared_ptr<Shard> shard; shard = Grid::get(txn)->shardRegistry()->getShardNoReload(hostAndPort.toString()); if (shard) { return {ErrorCodes::OperationFailed, str::stream() << "'" << hostAndPort.toString() << "' " << "is already a member of the existing shard '" << shard->getConnString().toString() << "' (" << shard->getId() << ")."}; } } // Check for mongos and older version mongod connections, and whether the hosts // can be found for the user specified replset. auto swCommandResponse = _runCommandForAddShard(txn, targeter.get(), "admin", BSON("isMaster" << 1)); if (!swCommandResponse.isOK()) { if (swCommandResponse.getStatus() == ErrorCodes::RPCProtocolNegotiationFailed) { // Mongos to mongos commands are no longer supported in the wire protocol // (because mongos does not support OP_COMMAND), similarly for a new mongos // and an old mongod. So the call will fail in such cases. // TODO: If/When mongos ever supports opCommands, this logic will break because // cmdStatus will be OK. return {ErrorCodes::RPCProtocolNegotiationFailed, str::stream() << targeter->connectionString().toString() << " does not recognize the RPC protocol being used. This is" << " likely because it contains a node that is a mongos or an old" << " version of mongod."}; } else { return swCommandResponse.getStatus(); } } // Check for a command response error auto resIsMasterStatus = std::move(swCommandResponse.getValue().commandStatus); if (!resIsMasterStatus.isOK()) { return {resIsMasterStatus.code(), str::stream() << "Error running isMaster against " << targeter->connectionString().toString() << ": " << causedBy(resIsMasterStatus)}; } auto resIsMaster = std::move(swCommandResponse.getValue().response); // Check whether there is a master. If there isn't, the replica set may not have been // initiated. If the connection is a standalone, it will return true for isMaster. bool isMaster; Status status = bsonExtractBooleanField(resIsMaster, "ismaster", &isMaster); if (!status.isOK()) { return Status(status.code(), str::stream() << "isMaster returned invalid 'ismaster' " << "field when attempting to add " << connectionString.toString() << " as a shard: " << status.reason()); } if (!isMaster) { return {ErrorCodes::NotMaster, str::stream() << connectionString.toString() << " does not have a master. If this is a replica set, ensure that it has a" << " healthy primary and that the set has been properly initiated."}; } const string providedSetName = connectionString.getSetName(); const string foundSetName = resIsMaster["setName"].str(); // Make sure the specified replica set name (if any) matches the actual shard's replica set if (providedSetName.empty() && !foundSetName.empty()) { return {ErrorCodes::OperationFailed, str::stream() << "host is part of set " << foundSetName << "; " << "use replica set url format " << "<setname>/<server1>,<server2>, ..."}; } if (!providedSetName.empty() && foundSetName.empty()) { return {ErrorCodes::OperationFailed, str::stream() << "host did not return a set name; " << "is the replica set still initializing? " << resIsMaster}; } // Make sure the set name specified in the connection string matches the one where its hosts // belong into if (!providedSetName.empty() && (providedSetName != foundSetName)) { return {ErrorCodes::OperationFailed, str::stream() << "the provided connection string (" << connectionString.toString() << ") does not match the actual set name " << foundSetName}; } // Is it a config server? if (resIsMaster.hasField("configsvr")) { return {ErrorCodes::OperationFailed, str::stream() << "Cannot add " << connectionString.toString() << " as a shard since it is a config server"}; } // If the shard is part of a replica set, make sure all the hosts mentioned in the connection // string are part of the set. It is fine if not all members of the set are mentioned in the // connection string, though. if (!providedSetName.empty()) { std::set<string> hostSet; BSONObjIterator iter(resIsMaster["hosts"].Obj()); while (iter.more()) { hostSet.insert(iter.next().String()); // host:port } if (resIsMaster["passives"].isABSONObj()) { BSONObjIterator piter(resIsMaster["passives"].Obj()); while (piter.more()) { hostSet.insert(piter.next().String()); // host:port } } if (resIsMaster["arbiters"].isABSONObj()) { BSONObjIterator piter(resIsMaster["arbiters"].Obj()); while (piter.more()) { hostSet.insert(piter.next().String()); // host:port } } vector<HostAndPort> hosts = connectionString.getServers(); for (size_t i = 0; i < hosts.size(); i++) { const string host = hosts[i].toString(); // host:port if (hostSet.find(host) == hostSet.end()) { return {ErrorCodes::OperationFailed, str::stream() << "in seed list " << connectionString.toString() << ", host " << host << " does not belong to replica set " << foundSetName << "; found " << resIsMaster.toString()}; } } } string actualShardName; if (shardProposedName) { actualShardName = *shardProposedName; } else if (!foundSetName.empty()) { // Default it to the name of the replica set actualShardName = foundSetName; } // Disallow adding shard replica set with name 'config' if (actualShardName == "config") { return {ErrorCodes::BadValue, "use of shard replica set with name 'config' is not allowed"}; } // Retrieve the most up to date connection string that we know from the replica set monitor (if // this is a replica set shard, otherwise it will be the same value as connectionString). ConnectionString actualShardConnStr = targeter->connectionString(); ShardType shard; shard.setName(actualShardName); shard.setHost(actualShardConnStr.toString()); return shard; }
ATF_TC_BODY(bpfjit_copx_ret_preinited_mem, tc) { static struct bpf_insn insns[] = { BPF_STMT(BPF_LD+BPF_IMM, 13), BPF_STMT(BPF_ST, 2), BPF_STMT(BPF_LD+BPF_IMM, 137), BPF_STMT(BPF_ST, 1), BPF_STMT(BPF_LDX+BPF_IMM, 0), // retM BPF_STMT(BPF_MISC+BPF_COPX, 0), BPF_STMT(BPF_RET+BPF_A, 0) }; bpfjit_func_t code; uint8_t pkt[1] = { 0 }; uint32_t mem[ctx.extwords]; void *arg = (void*)(uintptr_t)3; /* Pre-inited words. */ mem[0] = 0; mem[3] = 3; bpf_args_t args = { .pkt = pkt, .buflen = sizeof(pkt), .wirelen = sizeof(pkt), .arg = arg, .mem = mem, }; size_t insn_count = sizeof(insns) / sizeof(insns[0]); RZ(rump_init()); rump_schedule(); code = rumpns_bpfjit_generate_code(&ctx, insns, insn_count); rump_unschedule(); ATF_REQUIRE(code != NULL); ATF_CHECK(code(&ctx, &args) == 3); rump_schedule(); rumpns_bpfjit_free_code(code); rump_unschedule(); } ATF_TP_ADD_TCS(tp) { /* * For every new test please also add a similar test * to ../../lib/libbpfjit/t_extmem.c */ //ATF_TP_ADD_TC(tp, bpfjit_extmem_load_default); ATF_TP_ADD_TC(tp, bpfjit_extmem_load_preinited); ATF_TP_ADD_TC(tp, bpfjit_extmem_invalid_load); ATF_TP_ADD_TC(tp, bpfjit_extmem_store); ATF_TP_ADD_TC(tp, bpfjit_extmem_side_effect); ATF_TP_ADD_TC(tp, bpfjit_extmem_invalid_store); ATF_TP_ADD_TC(tp, bpfjit_cop_ret_mem); ATF_TP_ADD_TC(tp, bpfjit_cop_ret_preinited_mem); ATF_TP_ADD_TC(tp, bpfjit_copx_ret_mem); ATF_TP_ADD_TC(tp, bpfjit_copx_ret_preinited_mem); return atf_no_error(); }
std::string Patch::patchCode() const { return code(_table_name); }
static ngx_int_t create_request(ngx_http_request_t *r) { u_char ch; const char * helper_agent_request_socket_password_data; unsigned int helper_agent_request_socket_password_len; u_char buf[sizeof("4294967296")]; size_t len, size, key_len, val_len, content_length; const u_char *app_type_string; size_t app_type_string_len; int server_name_len; ngx_str_t escaped_uri; ngx_str_t *union_station_filters = NULL; u_char min_instances_string[12]; u_char max_requests_string[12]; u_char max_preloader_idle_time_string[12]; u_char *end; void *tmp; ngx_uint_t i, n; ngx_buf_t *b; ngx_chain_t *cl, *body; ngx_list_part_t *part; ngx_table_elt_t *header; ngx_http_script_code_pt code; ngx_http_script_engine_t e, le; ngx_http_core_srv_conf_t *cscf; passenger_loc_conf_t *slcf; passenger_context_t *context; ngx_http_script_len_code_pt lcode; #if (NGX_HTTP_SSL) ngx_http_ssl_srv_conf_t *ssl_conf; #endif cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module); slcf = ngx_http_get_module_loc_conf(r, ngx_http_passenger_module); context = ngx_http_get_module_ctx(r, ngx_http_passenger_module); if (context == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } switch (context->app_type) { case AP_CLASSIC_RAILS: app_type_string = (const u_char *) "classic-rails"; app_type_string_len = sizeof("classic-rails"); break; case AP_RACK: app_type_string = (const u_char *) "rack"; app_type_string_len = sizeof("rack"); break; case AP_WSGI: app_type_string = (const u_char *) "wsgi"; app_type_string_len = sizeof("wsgi"); break; default: app_type_string = (const u_char *) "rack"; app_type_string_len = sizeof("rack"); break; } /* * Nginx unescapes URI's before passing them to Phusion Passenger, * but backend processes expect the escaped version. * http://code.google.com/p/phusion-passenger/issues/detail?id=404 */ escaped_uri.len = 2 * ngx_escape_uri(NULL, r->uri.data, r->uri.len, NGX_ESCAPE_URI) + r->uri.len; escaped_uri.data = ngx_pnalloc(r->pool, escaped_uri.len + 1); escaped_uri.data[escaped_uri.len] = '\0'; ngx_escape_uri(escaped_uri.data, r->uri.data, r->uri.len, NGX_ESCAPE_URI); /************************************************** * Determine the request header length. **************************************************/ /* Length of the Content-Length header. */ if (r->headers_in.content_length_n < 0) { content_length = 0; } else { content_length = r->headers_in.content_length_n; } uint_to_str(content_length, buf, sizeof(buf)); /* +1 for trailing null */ len = sizeof("CONTENT_LENGTH") + ngx_strlen(buf) + 1; /* DOCUMENT_ROOT, SCRIPT_NAME, RAILS_RELATIVE_URL_ROOT, PATH_INFO and REQUEST_URI. */ len += sizeof("DOCUMENT_ROOT") + context->public_dir.len + 1; if (context->base_uri.len > 0) { len += sizeof("SCRIPT_NAME") + context->base_uri.len + 1; len += sizeof("RAILS_RELATIVE_URL_ROOT") + context->base_uri.len + 1; len += sizeof("PATH_INFO") + escaped_uri.len - context->base_uri.len + 1; } else { len += sizeof("SCRIPT_NAME") + sizeof(""); len += sizeof("PATH_INFO") + escaped_uri.len + 1; } len += sizeof("REQUEST_URI") + escaped_uri.len + 1; if (r->args.len > 0) { len += 1 + r->args.len; } /* SERVER_NAME; must be equal to HTTP_HOST without the port part */ if (r->headers_in.host != NULL) { tmp = memchr(r->headers_in.host->value.data, ':', r->headers_in.host->value.len); if (tmp == NULL) { server_name_len = r->headers_in.host->value.len; } else { server_name_len = (int) ((const u_char *) tmp - r->headers_in.host->value.data); } } else { server_name_len = cscf->server_name.len; } len += sizeof("SERVER_NAME") + server_name_len + 1; /* Various other HTTP headers. */ if (r->headers_in.content_type != NULL && r->headers_in.content_type->value.len > 0) { len += sizeof("CONTENT_TYPE") + r->headers_in.content_type->value.len + 1; } #if (NGX_HTTP_SSL) ssl_conf = ngx_http_get_module_srv_conf(r, ngx_http_ssl_module); if (ssl_conf->enable) { len += sizeof("HTTPS") + sizeof("on"); } #endif /* Lengths of Passenger application pool options. */ ANALYZE_BOOLEAN_CONFIG_LENGTH("PASSENGER_FRIENDLY_ERROR_PAGES", slcf, friendly_error_pages); ANALYZE_BOOLEAN_CONFIG_LENGTH("UNION_STATION_SUPPORT", slcf, union_station_support); ANALYZE_BOOLEAN_CONFIG_LENGTH("PASSENGER_DEBUGGER", slcf, debugger); ANALYZE_BOOLEAN_CONFIG_LENGTH("PASSENGER_SHOW_VERSION_IN_HEADER", slcf, show_version_in_header); ANALYZE_STR_CONFIG_LENGTH("PASSENGER_RUBY", slcf, ruby); len += sizeof("PASSENGER_ENV") + slcf->environment.len + 1; len += sizeof("PASSENGER_SPAWN_METHOD") + slcf->spawn_method.len + 1; len += sizeof("PASSENGER_APP_TYPE") + app_type_string_len; ANALYZE_STR_CONFIG_LENGTH("PASSENGER_APP_GROUP_NAME", slcf, app_group_name); ANALYZE_STR_CONFIG_LENGTH("PASSENGER_APP_RIGHTS", slcf, app_rights); ANALYZE_STR_CONFIG_LENGTH("PASSENGER_USER", slcf, user); ANALYZE_STR_CONFIG_LENGTH("PASSENGER_GROUP", slcf, group); ANALYZE_STR_CONFIG_LENGTH("UNION_STATION_KEY", slcf, union_station_key); end = ngx_snprintf(min_instances_string, sizeof(min_instances_string) - 1, "%d", (slcf->min_instances == (ngx_int_t) -1) ? 1 : slcf->min_instances); *end = '\0'; len += sizeof("PASSENGER_MIN_INSTANCES") + ngx_strlen(min_instances_string) + 1; end = ngx_snprintf(max_requests_string, sizeof(max_requests_string) - 1, "%d", (slcf->max_requests == (ngx_int_t) -1) ? 0 : slcf->max_requests); *end = '\0'; len += sizeof("PASSENGER_MAX_REQUESTS") + ngx_strlen(max_requests_string) + 1; end = ngx_snprintf(max_preloader_idle_time_string, sizeof(max_preloader_idle_time_string) - 1, "%d", (slcf->max_preloader_idle_time == (ngx_int_t) -1) ? -1 : slcf->max_preloader_idle_time); *end = '\0'; len += sizeof("PASSENGER_MAX_PRELOADER_IDLE_TIME") + ngx_strlen(max_preloader_idle_time_string) + 1; if (slcf->union_station_filters != NGX_CONF_UNSET_PTR && slcf->union_station_filters->nelts > 0) { len += sizeof("UNION_STATION_FILTERS"); union_station_filters = (ngx_str_t *) slcf->union_station_filters->elts; for (i = 0; i < slcf->union_station_filters->nelts; i++) { if (i != 0) { len++; } len += union_station_filters[i].len; } len++; } /***********************/ /***********************/ /* Lengths of various CGI variables. */ if (slcf->vars_len) { ngx_memzero(&le, sizeof(ngx_http_script_engine_t)); ngx_http_script_flush_no_cacheable_variables(r, slcf->flushes); le.flushed = 1; le.ip = slcf->vars_len->elts; le.request = r; while (*(uintptr_t *) le.ip) { lcode = *(ngx_http_script_len_code_pt *) le.ip; key_len = lcode(&le); for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) { lcode = *(ngx_http_script_len_code_pt *) le.ip; } le.ip += sizeof(uintptr_t); len += key_len + val_len; } } /* Lengths of HTTP headers. */ if (slcf->upstream_config.pass_request_headers) { part = &r->headers_in.headers.part; header = part->elts; for (i = 0; /* void */; i++) { if (i >= part->nelts) { if (part->next == NULL) { break; } part = part->next; header = part->elts; i = 0; } len += sizeof("HTTP_") - 1 + header[i].key.len + 1 + header[i].value.len + 1; } } /************************************************** * Build the request header data. **************************************************/ helper_agent_request_socket_password_data = agents_starter_get_request_socket_password(passenger_agents_starter, &helper_agent_request_socket_password_len); size = helper_agent_request_socket_password_len + /* netstring length + ":" + trailing "," */ /* note: 10 == sizeof("4294967296") - 1 */ len + 10 + 1 + 1; b = ngx_create_temp_buf(r->pool, size); if (b == NULL) { return NGX_ERROR; } cl = ngx_alloc_chain_link(r->pool); if (cl == NULL) { return NGX_ERROR; } cl->buf = b; /* Build SCGI header netstring length part. */ b->last = ngx_copy(b->last, helper_agent_request_socket_password_data, helper_agent_request_socket_password_len); b->last = ngx_snprintf(b->last, 10, "%ui", len); *b->last++ = (u_char) ':'; /* Build CONTENT_LENGTH header. This must always be sent, even if 0. */ b->last = ngx_copy(b->last, "CONTENT_LENGTH", sizeof("CONTENT_LENGTH")); b->last = ngx_snprintf(b->last, 10, "%ui", content_length); *b->last++ = (u_char) 0; /* Build DOCUMENT_ROOT, SCRIPT_NAME, RAILS_RELATIVE_URL_ROOT, PATH_INFO and REQUEST_URI. */ b->last = ngx_copy(b->last, "DOCUMENT_ROOT", sizeof("DOCUMENT_ROOT")); b->last = ngx_copy(b->last, context->public_dir.data, context->public_dir.len + 1); if (context->base_uri.len > 0) { b->last = ngx_copy(b->last, "SCRIPT_NAME", sizeof("SCRIPT_NAME")); b->last = ngx_copy(b->last, context->base_uri.data, context->base_uri.len + 1); b->last = ngx_copy(b->last, "RAILS_RELATIVE_URL_ROOT", sizeof("RAILS_RELATIVE_URL_ROOT")); b->last = ngx_copy(b->last, context->base_uri.data, context->base_uri.len + 1); b->last = ngx_copy(b->last, "PATH_INFO", sizeof("PATH_INFO")); b->last = ngx_copy(b->last, escaped_uri.data + context->base_uri.len, escaped_uri.len - context->base_uri.len); b->last = ngx_copy(b->last, "", 1); } else { b->last = ngx_copy(b->last, "SCRIPT_NAME", sizeof("SCRIPT_NAME")); b->last = ngx_copy(b->last, "", sizeof("")); b->last = ngx_copy(b->last, "PATH_INFO", sizeof("PATH_INFO")); b->last = ngx_copy(b->last, escaped_uri.data, escaped_uri.len); b->last = ngx_copy(b->last, "", 1); } b->last = ngx_copy(b->last, "REQUEST_URI", sizeof("REQUEST_URI")); b->last = ngx_copy(b->last, escaped_uri.data, escaped_uri.len); if (r->args.len > 0) { b->last = ngx_copy(b->last, "?", 1); b->last = ngx_copy(b->last, r->args.data, r->args.len); } b->last = ngx_copy(b->last, "", 1); /* SERVER_NAME */ b->last = ngx_copy(b->last, "SERVER_NAME", sizeof("SERVER_NAME")); if (r->headers_in.host != NULL) { b->last = ngx_copy(b->last, r->headers_in.host->value.data, server_name_len); } else { b->last = ngx_copy(b->last, cscf->server_name.data, server_name_len); } b->last = ngx_copy(b->last, "", 1); /* Various other HTTP headers. */ if (r->headers_in.content_type != NULL && r->headers_in.content_type->value.len > 0) { b->last = ngx_copy(b->last, "CONTENT_TYPE", sizeof("CONTENT_TYPE")); b->last = ngx_copy(b->last, r->headers_in.content_type->value.data, r->headers_in.content_type->value.len); b->last = ngx_copy(b->last, "", 1); } #if (NGX_HTTP_SSL) ssl_conf = ngx_http_get_module_srv_conf(r, ngx_http_ssl_module); if (ssl_conf->enable) { b->last = ngx_copy(b->last, "HTTPS", sizeof("HTTPS")); b->last = ngx_copy(b->last, "on", sizeof("on")); } #endif /* Build Passenger application pool option headers. */ SERIALIZE_BOOLEAN_CONFIG_DATA("PASSENGER_FRIENDLY_ERROR_PAGES", slcf, friendly_error_pages); SERIALIZE_BOOLEAN_CONFIG_DATA("UNION_STATION_SUPPORT", slcf, union_station_support); SERIALIZE_BOOLEAN_CONFIG_DATA("PASSENGER_DEBUGGER", slcf, debugger); SERIALIZE_BOOLEAN_CONFIG_DATA("PASSENGER_SHOW_VERSION_IN_HEADER", slcf, show_version_in_header); SERIALIZE_STR_CONFIG_DATA("PASSENGER_RUBY", slcf, ruby); b->last = ngx_copy(b->last, "PASSENGER_ENV", sizeof("PASSENGER_ENV")); b->last = ngx_copy(b->last, slcf->environment.data, slcf->environment.len + 1); b->last = ngx_copy(b->last, "PASSENGER_SPAWN_METHOD", sizeof("PASSENGER_SPAWN_METHOD")); b->last = ngx_copy(b->last, slcf->spawn_method.data, slcf->spawn_method.len + 1); SERIALIZE_STR_CONFIG_DATA("PASSENGER_APP_GROUP_NAME", slcf, app_group_name); SERIALIZE_STR_CONFIG_DATA("PASSENGER_APP_RIGHTS", slcf, app_rights); SERIALIZE_STR_CONFIG_DATA("PASSENGER_USER", slcf, user); SERIALIZE_STR_CONFIG_DATA("PASSENGER_GROUP", slcf, group); SERIALIZE_STR_CONFIG_DATA("UNION_STATION_KEY", slcf, union_station_key); b->last = ngx_copy(b->last, "PASSENGER_APP_TYPE", sizeof("PASSENGER_APP_TYPE")); b->last = ngx_copy(b->last, app_type_string, app_type_string_len); b->last = ngx_copy(b->last, "PASSENGER_MIN_INSTANCES", sizeof("PASSENGER_MIN_INSTANCES")); b->last = ngx_copy(b->last, min_instances_string, ngx_strlen(min_instances_string) + 1); b->last = ngx_copy(b->last, "PASSENGER_MAX_REQUESTS", sizeof("PASSENGER_MAX_REQUESTS")); b->last = ngx_copy(b->last, max_requests_string, ngx_strlen(max_requests_string) + 1); b->last = ngx_copy(b->last, "PASSENGER_MAX_PRELOADER_IDLE_TIME", sizeof("PASSENGER_MAX_PRELOADER_IDLE_TIME")); b->last = ngx_copy(b->last, max_preloader_idle_time_string, ngx_strlen(max_preloader_idle_time_string) + 1); if (slcf->union_station_filters != NGX_CONF_UNSET_PTR && slcf->union_station_filters->nelts > 0) { b->last = ngx_copy(b->last, "UNION_STATION_FILTERS", sizeof("UNION_STATION_FILTERS")); for (i = 0; i < slcf->union_station_filters->nelts; i++) { if (i != 0) { b->last = ngx_copy(b->last, "\1", 1); } b->last = ngx_copy(b->last, union_station_filters[i].data, union_station_filters[i].len); } b->last = ngx_copy(b->last, "\0", 1); } /***********************/ /***********************/ if (slcf->vars_len) { ngx_memzero(&e, sizeof(ngx_http_script_engine_t)); e.ip = slcf->vars->elts; e.pos = b->last; e.request = r; e.flushed = 1; le.ip = slcf->vars_len->elts; while (*(uintptr_t *) le.ip) { lcode = *(ngx_http_script_len_code_pt *) le.ip; (void) lcode(&le); for (val_len = 0; *(uintptr_t *) le.ip; val_len += lcode(&le)) { lcode = *(ngx_http_script_len_code_pt *) le.ip; } le.ip += sizeof(uintptr_t); while (*(uintptr_t *) e.ip) { code = *(ngx_http_script_code_pt *) e.ip; code((ngx_http_script_engine_t *) &e); } e.ip += sizeof(uintptr_t); } b->last = e.pos; } if (slcf->upstream_config.pass_request_headers) { part = &r->headers_in.headers.part; header = part->elts; for (i = 0; /* void */; i++) { if (i >= part->nelts) { if (part->next == NULL) { break; } part = part->next; header = part->elts; i = 0; } b->last = ngx_cpymem(b->last, "HTTP_", sizeof("HTTP_") - 1); for (n = 0; n < header[i].key.len; n++) { ch = header[i].key.data[n]; if (ch >= 'a' && ch <= 'z') { ch &= ~0x20; } else if (ch == '-') { ch = '_'; } *b->last++ = ch; } *b->last++ = (u_char) 0; b->last = ngx_copy(b->last, header[i].value.data, header[i].value.len); *b->last++ = (u_char) 0; } } *b->last++ = (u_char) ','; if (slcf->upstream_config.pass_request_body) { body = r->upstream->request_bufs; r->upstream->request_bufs = cl; while (body) { b = ngx_alloc_buf(r->pool); if (b == NULL) { return NGX_ERROR; } ngx_memcpy(b, body->buf, sizeof(ngx_buf_t)); cl->next = ngx_alloc_chain_link(r->pool); if (cl->next == NULL) { return NGX_ERROR; } cl = cl->next; cl->buf = b; body = body->next; } b->flush = 1; } else { r->upstream->request_bufs = cl; } cl->next = NULL; return NGX_OK; }
static ngx_int_t ngx_http_internal_redirect_handler(ngx_http_request_t *r) { u_char *p; ngx_uint_t i; ngx_str_t uri, args; ngx_http_script_code_pt code; ngx_http_script_engine_t e; ngx_http_variable_value_t stack[10]; ngx_http_internal_redirect_entry_t *redirects; ngx_http_internal_redirect_main_conf_t *imcf; ngx_http_internal_redirect_loc_conf_t *ilcf; ngx_http_core_main_conf_t *cmcf; ngx_http_phase_handler_t *ph, *cur_ph, *last_ph, tmp; imcf = ngx_http_get_module_main_conf(r, ngx_http_internal_redirect_module); if (!imcf->postponed) { imcf->postponed = 1; cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module); ph = cmcf->phase_engine.handlers; cur_ph = &ph[r->phase_handler]; last_ph = &ph[cur_ph->next - 1]; if (cur_ph < last_ph) { tmp = *cur_ph; ngx_memmove(cur_ph, cur_ph + 1, (last_ph - cur_ph) * sizeof(ngx_http_phase_handler_t)); *last_ph = tmp; r->phase_handler--; /* redo the current ph */ return NGX_DECLINED; } } ilcf = ngx_http_get_module_loc_conf(r, ngx_http_internal_redirect_module); if (ilcf->redirects == NULL) { return NGX_DECLINED; } redirects = ilcf->redirects->elts; for (i = 0; i < ilcf->redirects->nelts; i++) { ngx_memzero(&e, sizeof(ngx_http_script_engine_t)); ngx_memzero(&stack, sizeof(stack)); e.sp = stack; e.ip = redirects[i].codes->elts; e.request = r; e.quote = 1; e.log = 1; e.status = NGX_DECLINED; while (*(uintptr_t *) e.ip) { code = *(ngx_http_script_code_pt *) e.ip; code(&e); } e.sp--; if (e.sp->len && (e.sp->len != 1 || e.sp->data[0] != '0')) { break; } } if (i == ilcf->redirects->nelts) { return NGX_DECLINED; } if (redirects[i].code) { return redirects[i].code; } if (redirects[i].lengths) { if (ngx_http_script_run(r, &uri, redirects[i].lengths->elts, 0, redirects->values->elts) == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } } else { uri = redirects[i].name; } if (uri.data[0] == '@') { (void) ngx_http_named_location(r, &uri); } else { if (uri.data[0] != '/') { p = ngx_pcalloc(r->pool, uri.len + 1); if (p == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } uri.len++; *p = '/'; ngx_memcpy(p + 1, uri.data, uri.len); uri.data = p; } ngx_http_split_args(r, &uri, &args); (void) ngx_http_internal_redirect(r, &uri, &args); } ngx_http_finalize_request(r, NGX_DONE); return NGX_DONE; }
FiberSection2d::FiberSection2d(int tag, int num, UniaxialMaterial **mats, SectionIntegration &si): SectionForceDeformation(tag, SEC_TAG_FiberSection2d), numFibers(num), sizeFibers(num), theMaterials(0), matData(0), QzBar(0.0), ABar(0.0), yBar(0.0), sectionIntegr(0), e(2), s(0), ks(0), dedh(2) { if (numFibers != 0) { theMaterials = new UniaxialMaterial *[numFibers]; if (theMaterials == 0) { opserr << "FiberSection2d::FiberSection2d -- failed to allocate Material pointers"; exit(-1); } matData = new double [numFibers*2]; if (matData == 0) { opserr << "FiberSection2d::FiberSection2d -- failed to allocate double array for material data\n"; exit(-1); } } sectionIntegr = si.getCopy(); if (sectionIntegr == 0) { opserr << "Error: FiberSection2d::FiberSection2d: could not create copy of section integration object" << endln; exit(-1); } static double fiberLocs[10000]; sectionIntegr->getFiberLocations(numFibers, fiberLocs); static double fiberArea[10000]; sectionIntegr->getFiberWeights(numFibers, fiberArea); for (int i = 0; i < numFibers; i++) { ABar += fiberArea[i]; QzBar += fiberLocs[i]*fiberArea[i]; theMaterials[i] = mats[i]->getCopy(); if (theMaterials[i] == 0) { opserr << "FiberSection2d::FiberSection2d -- failed to get copy of a Material\n"; exit(-1); } } yBar = QzBar/ABar; s = new Vector(sData, 2); ks = new Matrix(kData, 2, 2); sData[0] = 0.0; sData[1] = 0.0; kData[0] = 0.0; kData[1] = 0.0; kData[2] = 0.0; kData[3] = 0.0; code(0) = SECTION_RESPONSE_P; code(1) = SECTION_RESPONSE_MZ; }
main(){for(;~scanf("%s",a),*a-'0';printf("%d\n",code(a)));}
void Filler::treat_region(GRegion* gr){ int NumSmooth = CTX::instance()->mesh.smoothCrossField; std::cout << "NumSmooth = " << NumSmooth << std::endl ; if(NumSmooth && (gr->dim() == 3)){ double scale = gr->bounds().diag()*1e-2; Frame_field::initRegion(gr,NumSmooth); Frame_field::saveCrossField("cross0.pos",scale); Frame_field::smoothRegion(gr,NumSmooth); Frame_field::saveCrossField("cross1.pos",scale); } #if defined(HAVE_RTREE) unsigned int i; int j; int count; int limit; bool ok2; double x,y,z; SPoint3 point; Node *node,*individual,*parent; MVertex* vertex; MElement* element; MElementOctree* octree; deMeshGRegion deleter; Wrapper wrapper; GFace* gf; std::queue<Node*> fifo; std::vector<Node*> spawns; std::vector<Node*> garbage; std::vector<MVertex*> boundary_vertices; std::set<MVertex*> temp; std::list<GFace*> faces; std::map<MVertex*,int> limits; std::set<MVertex*>::iterator it; std::list<GFace*>::iterator it2; std::map<MVertex*,int>::iterator it3; RTree<Node*,double,3,double> rtree; Frame_field::init_region(gr); Size_field::init_region(gr); Size_field::solve(gr); octree = new MElementOctree(gr->model()); garbage.clear(); boundary_vertices.clear(); temp.clear(); new_vertices.clear(); faces.clear(); limits.clear(); faces = gr->faces(); for(it2=faces.begin();it2!=faces.end();it2++){ gf = *it2; limit = code(gf->tag()); for(i=0;i<gf->getNumMeshElements();i++){ element = gf->getMeshElement(i); for(j=0;j<element->getNumVertices();j++){ vertex = element->getVertex(j); temp.insert(vertex); limits.insert(std::pair<MVertex*,int>(vertex,limit)); } } } /*for(i=0;i<gr->getNumMeshElements();i++){ element = gr->getMeshElement(i); for(j=0;j<element->getNumVertices();j++){ vertex = element->getVertex(j); temp.insert(vertex); } }*/ for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()==0){ boundary_vertices.push_back(*it); } } for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()==1){ boundary_vertices.push_back(*it); } } for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()==2){ boundary_vertices.push_back(*it); } } /*for(it=temp.begin();it!=temp.end();it++){ if((*it)->onWhat()->dim()<3){ boundary_vertices.push_back(*it); } }*/ //std::ofstream file("nodes.pos"); //file << "View \"test\" {\n"; for(i=0;i<boundary_vertices.size();i++){ x = boundary_vertices[i]->x(); y = boundary_vertices[i]->y(); z = boundary_vertices[i]->z(); node = new Node(SPoint3(x,y,z)); compute_parameters(node,gr); node->set_layer(0); it3 = limits.find(boundary_vertices[i]); node->set_limit(it3->second); rtree.Insert(node->min,node->max,node); fifo.push(node); //print_node(node,file); } count = 1; while(!fifo.empty()){ parent = fifo.front(); fifo.pop(); garbage.push_back(parent); if(parent->get_limit()!=-1 && parent->get_layer()>=parent->get_limit()){ continue; } spawns.clear(); spawns.resize(6); for(i=0;i<6;i++){ spawns[i] = new Node(); } create_spawns(gr,octree,parent,spawns); for(i=0;i<6;i++){ ok2 = 0; individual = spawns[i]; point = individual->get_point(); x = point.x(); y = point.y(); z = point.z(); if(inside_domain(octree,x,y,z)){ compute_parameters(individual,gr); individual->set_layer(parent->get_layer()+1); individual->set_limit(parent->get_limit()); if(far_from_boundary(octree,individual)){ wrapper.set_ok(1); wrapper.set_individual(individual); wrapper.set_parent(parent); rtree.Search(individual->min,individual->max,rtree_callback,&wrapper); if(wrapper.get_ok()){ fifo.push(individual); rtree.Insert(individual->min,individual->max,individual); vertex = new MVertex(x,y,z,gr,0); new_vertices.push_back(vertex); ok2 = 1; //print_segment(individual->get_point(),parent->get_point(),file); } } } if(!ok2) delete individual; } if(count%100==0){ printf("%d\n",count); } count++; } //file << "};\n"; int option = CTX::instance()->mesh.algo3d; CTX::instance()->mesh.algo3d = ALGO_3D_DELAUNAY; deleter(gr); std::vector<GRegion*> regions; regions.push_back(gr); meshGRegion mesher(regions); //? mesher(gr); //? MeshDelaunayVolume(regions); CTX::instance()->mesh.algo3d = option; for(i=0;i<garbage.size();i++) delete garbage[i]; for(i=0;i<new_vertices.size();i++) delete new_vertices[i]; new_vertices.clear(); delete octree; rtree.RemoveAll(); Size_field::clear(); Frame_field::clear(); #endif }
int photoalbum::os::gazetteer(int argc, const char *argv[]) { bool show_help = false; std::string data_file, mapdb; std::vector<std::string> regions; std::vector<commandline::option> options{ commandline::parameter("data", data_file, "Gazetteer data file"), commandline::flag("help", show_help, "Show this help message"), commandline::parameter("mapdb", mapdb, "Map SQLite database"), commandline::list("regions", regions, "Regions to replace") }; commandline::parse(argc, argv, options); if(show_help) { commandline::print(argc, argv, options); return 0; } if(mapdb.empty()) { std::cerr << "error: database not specified" << std::endl; return 1; } std::ifstream in(data_file); if(!in.is_open()) { std::cerr << "Error opening " << data_file << " for reading." << std::endl; return 1; } sqlite::connection conn(mapdb); db::map::create(conn); // Ready to start importing gazetteer data. // Assume we are replacing regions on the command line. if(regions.empty()) db::clear_gazetteer(conn); else db::clear_gazetteer(regions, conn); json::list records; std::string line; while(std::getline(in, line)) { // The data set may have DOS line endings. if(line.size() && line.at(line.size()-1) == '\r') line.resize(line.size()-1); typedef boost::tokenizer<boost::escaped_list_separator<char> > tokenizer; tokenizer t(line, boost::escaped_list_separator<char>("\\", ":", "\"")); std::vector<json::object> values; std::copy(t.begin(), t.end(), std::back_inserter(values)); if(values.size() != 20) { std::cerr << "warning: wrong number of values in gazetteer row " << values.size() << std::endl; continue; } json::object obj; map::gazetteer_record record(obj); fill_container(values, record); // Insert the record only if it is in a region of interest. std::string code(record.km_ref(), 0, 2); if( regions.size() && std::find(regions.begin(), regions.end(), code) == regions.end() ) continue; //db::insert(record, conn); records.append(obj); } db::insert_gazetteer_records(records, conn); std::cerr << "inserted " << records.size() << "records" << std::endl; return 0; }
// constructors: TimoshenkoSection2d::TimoshenkoSection2d(int tag, int num, Fiber **fibers): SectionForceDeformation(tag, SEC_TAG_TimoshenkoSection2d), numFibers(num), theMaterials(0), matData(0), yh(0.0), zh(0.0), yBar(0.0), zBar(0.0), e(3), eCommit(3), s(0), ks(0) { if (numFibers != 0) { theMaterials = new NDMaterial*[numFibers]; if (theMaterials == 0) { opserr << "TimoshenkoSection2d::TimoshenkoSection2d -- failed to allocate Material pointers\n"; exit(-1); } matData = new double [numFibers*3]; if (matData == 0) { opserr << "TimoshenkoSection2d::TimoshenkoSection2d -- failed to allocate double array for material data\n"; exit(-1); } double Qz = 0.0; double Qy = 0.0; double a = 0.0; double yHmin=0, zHmin=0, yHmax=0, zHmax=0; NDMaterial *theMat; for (int i = 0; i < numFibers; i++) { double yLoc, zLoc, Area; fibers[i]->getFiberLocation(yLoc, zLoc); Area = fibers[i]->getArea(); theMat = fibers[i]->getNDMaterial(); if (theMat == 0) { opserr << "TimoshenkoSection3d::TimoshenkoSection3d -- failed to get fiber information" << endln; } Qz += yLoc*Area; Qy += zLoc*Area; a += Area; matData[i*3] = yLoc; matData[i*3+1] = zLoc; matData[i*3+2] = Area; theMaterials[i] = theMat->getCopy("BeamFiber2d") ; // theMat.getCopy("TimoshenkoFiber"); if (theMaterials[i] == 0) opserr << "TimoshenkoSection2d::TimoshenkoSection2d -- failed to get copy of beam fiber" << endln; if (yLoc < yHmin ) yHmin=yLoc; if (zLoc < zHmin ) zHmin=zLoc; if (yLoc > yHmax ) yHmax=yLoc; if (zLoc > zHmax ) zHmax=zLoc; } yBar = Qz/a; zBar = Qy/a; zh = yHmax - yHmin; yh = zHmax - zHmin; } s = new Vector(sData, 3); ks = new Matrix(kData, 3, 3); for (int i=0; i<9; i++) kData[i] = 0.0; for (int i=0; i<3; i++) sData[i] = 0.0; code(0) = SECTION_RESPONSE_P; code(1) = SECTION_RESPONSE_MZ; code(2) = SECTION_RESPONSE_VY; }
void swcode(Swtch swp, int b[], int lb, int ub) { int hilab, lolab, l, u, k = (lb + ub)/2; long *v = swp->values; if (k > lb && k < ub) { lolab = genlabel(1); hilab = genlabel(1); } else if (k > lb) { lolab = genlabel(1); hilab = swp->deflab->u.l.label; } else if (k < ub) { lolab = swp->deflab->u.l.label; hilab = genlabel(1); } else lolab = hilab = swp->deflab->u.l.label; l = b[k]; u = b[k+1] - 1; if (u - l + 1 <= 3) { int i; for (i = l; i <= u; i++) cmp(EQ, swp->sym, v[i], swp->labels[i]->u.l.label); if (k > lb && k < ub) cmp(GT, swp->sym, v[u], hilab); else if (k > lb) cmp(GT, swp->sym, v[u], hilab); else if (k < ub) cmp(LT, swp->sym, v[l], lolab); else assert(lolab == hilab), branch(lolab); walk(NULL, 0, 0); } else { Tree e; Type ty = signedint(swp->sym->type); Symbol table = genident(STATIC, array(voidptype, u - l + 1, 0), GLOBAL); (*IR->defsymbol)(table); cmp(LT, swp->sym, v[l], lolab); cmp(GT, swp->sym, v[u], hilab); e = (*optree['-'])(SUB, cast(idtree(swp->sym), ty), cnsttree(ty, v[l])); if (e->type->size < signedptr->size) e = cast(e, longtype); walk(tree(JUMP, voidtype, rvalue((*optree['+'])(ADD, pointer(idtree(table)), e)), NULL), 0, 0); code(Switch); codelist->u.swtch.table = table; codelist->u.swtch.sym = swp->sym; codelist->u.swtch.deflab = swp->deflab; codelist->u.swtch.size = u - l + 1; codelist->u.swtch.values = &v[l]; codelist->u.swtch.labels = &swp->labels[l]; if (v[u] - v[l] + 1 >= 10000) warning("switch generates a huge table\n"); } if (k > lb) { assert(lolab != swp->deflab->u.l.label); definelab(lolab); swcode(swp, b, lb, k - 1); } if (k < ub) { assert(hilab != swp->deflab->u.l.label); definelab(hilab); swcode(swp, b, k + 1, ub); } }
void MainWindow::preProcessFile(QString filepath) { QFile file(filepath); if (file.open(QFile::ReadOnly)) { posList.clear(); float totalLineCount = 0; QTextStream code(&file); while ((code.atEnd() == false)) { totalLineCount++; code.readLine(); } if (totalLineCount == 0) totalLineCount = 1; code.seek(0); double x = 0; double y = 0; double i = 0; double j = 0; bool arc = false; bool cw = false; bool mm = true; int index = 0; int g = 0; bool zeroInsert = false; do { QString strline = code.readLine(); index++; GCode::trimToEnd(strline, '('); GCode::trimToEnd(strline, ';'); GCode::trimToEnd(strline, '%'); strline = strline.trimmed(); if (strline.size() == 0) {}//ignore comments else { strline = strline.toUpper(); strline.replace("M6", "M06"); strline.replace(QRegExp("([A-Z])"), " \\1"); strline.replace(QRegExp("\\s+"), " "); //if (strline.contains("G", Qt::CaseInsensitive)) { if (processGCode(strline, x, y, i, j, arc, cw, mm, g)) { if (!zeroInsert) { // insert 0,0 position posList.append(PosItem(0, 0, 0, 0, false, false, mm, 0)); zeroInsert = true; } posList.append(PosItem(x, y, i, j, arc, cw, mm, index)); //printf("Got G command:%s (%f,%f)\n", strline.toLocal8Bit().constData(), x, y); } } } } while (code.atEnd() == false); file.close(); emit setItems(posList); } else printf("Can't open file\n"); }
//------------------------------------------------------------------------------ // Name: //------------------------------------------------------------------------------ bool PlatformEvent::is_kill() const { return stopped() && code() == SIGKILL; }
Bytecodes::Code java_code_at_bci(int bci) { address bcp = code() + bci; return Bytecodes::java_code_at(NULL, bcp); }
//------------------------------------------------------------------------------ // Name: //------------------------------------------------------------------------------ bool PlatformEvent::is_trap() const { return stopped() && code() == SIGTRAP; }
oop read_oop() { return code()->oop_at(read_int()); }
TEST(CollectionOptions, UnknownTopLevelOptionFailsToParse) { CollectionOptions options; auto status = options.parse(fromjson("{invalidOption: 1}")); ASSERT_NOT_OK(status); ASSERT_EQ(status.code(), ErrorCodes::InvalidOptions); }
/// Return true if the object represents an error. explicit operator bool() const { return none != code(); }
static ngx_uint_t construct_request_buffer(ngx_http_request_t *r, passenger_loc_conf_t *slcf, passenger_context_t *context, buffer_construction_state *state, ngx_buf_t *b) { #define PUSH_STATIC_STR(str) \ do { \ if (b != NULL) { \ b->last = ngx_copy(b->last, (const u_char *) str, \ sizeof(str) - 1); \ } \ total_size += sizeof(str) - 1; \ } while (0) ngx_uint_t total_size = 0; ngx_str_t *union_station_filters; ngx_uint_t i; ngx_list_part_t *part; ngx_table_elt_t *header; size_t len; ngx_http_script_len_code_pt lcode; ngx_http_script_code_pt code; ngx_http_script_engine_t e, le; if (b != NULL) { b->last = ngx_copy(b->last, state->method.data, state->method.len); } total_size += state->method.len; if (b != NULL) { b->last = ngx_copy(b->last, state->escaped_uri.data, state->escaped_uri.len); } total_size += state->escaped_uri.len; if (r->args.len > 0) { if (b != NULL) { b->last = ngx_copy(b->last, "?", 1); b->last = ngx_copy(b->last, r->args.data, r->args.len); } total_size += r->args.len + 1; } PUSH_STATIC_STR(" HTTP/1.1\r\nConnection: close\r\n"); part = &r->headers_in.headers.part; header = part->elts; for (i = 0; /* void */; i++) { if (i >= part->nelts) { if (part->next == NULL) { break; } part = part->next; header = part->elts; i = 0; } if (ngx_hash_find(&slcf->headers_set_hash, header[i].hash, header[i].lowcase_key, header[i].key.len) || header_is_transfer_encoding(&header[i].key)) { continue; } if (b != NULL) { b->last = ngx_copy(b->last, header[i].key.data, header[i].key.len); b->last = ngx_copy(b->last, ": ", 2); b->last = ngx_copy(b->last, header[i].value.data, header[i].value.len); b->last = ngx_copy(b->last, "\r\n", 2); } total_size += header[i].key.len + header[i].value.len + 4; } if (r->headers_in.chunked) { PUSH_STATIC_STR("Content-Length: "); if (b != NULL) { b->last = ngx_copy(b->last, state->content_length.data, state->content_length.len); } total_size += state->content_length.len; PUSH_STATIC_STR("\r\n"); } if (slcf->headers_set_len) { ngx_memzero(&le, sizeof(ngx_http_script_engine_t)); ngx_http_script_flush_no_cacheable_variables(r, slcf->flushes); le.ip = slcf->headers_set_len->elts; le.request = r; le.flushed = 1; while (*(uintptr_t *) le.ip) { while (*(uintptr_t *) le.ip) { lcode = *(ngx_http_script_len_code_pt *) le.ip; total_size += lcode(&le); } le.ip += sizeof(uintptr_t); } if (b != NULL) { ngx_memzero(&e, sizeof(ngx_http_script_engine_t)); e.ip = slcf->headers_set->elts; e.pos = b->last; e.request = r; e.flushed = 1; le.ip = slcf->headers_set_len->elts; while (*(uintptr_t *) le.ip) { lcode = *(ngx_http_script_len_code_pt *) le.ip; /* skip the header line name length */ (void) lcode(&le); if (*(ngx_http_script_len_code_pt *) le.ip) { for (len = 0; *(uintptr_t *) le.ip; len += lcode(&le)) { lcode = *(ngx_http_script_len_code_pt *) le.ip; } e.skip = (len == sizeof("\r\n") - 1) ? 1 : 0; } else { e.skip = 0; } le.ip += sizeof(uintptr_t); while (*(uintptr_t *) e.ip) { code = *(ngx_http_script_code_pt *) e.ip; code((ngx_http_script_engine_t *) &e); } e.ip += sizeof(uintptr_t); } b->last = e.pos; } } if (b != NULL) { b->last = ngx_copy(b->last, "!~: ", sizeof("!~: ") - 1); b->last = ngx_copy(b->last, state->core_password.data, state->core_password.len); b->last = ngx_copy(b->last, "\r\n", sizeof("\r\n") - 1); } total_size += (sizeof("!~: \r\n") - 1) + state->core_password.len; PUSH_STATIC_STR("!~DOCUMENT_ROOT: "); if (b != NULL) { b->last = ngx_copy(b->last, context->public_dir.data, context->public_dir.len); } total_size += context->public_dir.len; PUSH_STATIC_STR("\r\n"); if (context->base_uri.len > 0) { PUSH_STATIC_STR("!~SCRIPT_NAME: "); if (b != NULL) { b->last = ngx_copy(b->last, context->base_uri.data, context->base_uri.len); } total_size += context->base_uri.len; PUSH_STATIC_STR("\r\n"); } PUSH_STATIC_STR("!~REMOTE_ADDR: "); if (b != NULL) { b->last = ngx_copy(b->last, r->connection->addr_text.data, r->connection->addr_text.len); } total_size += r->connection->addr_text.len; PUSH_STATIC_STR("\r\n"); PUSH_STATIC_STR("!~REMOTE_PORT: "); if (b != NULL) { b->last = ngx_copy(b->last, state->remote_port.data, state->remote_port.len); } total_size += state->remote_port.len; PUSH_STATIC_STR("\r\n"); if (r->headers_in.user.len > 0) { PUSH_STATIC_STR("!~REMOTE_USER: "******"\r\n"); } if (slcf->app_group_name.data == NULL) { PUSH_STATIC_STR("!~PASSENGER_APP_GROUP_NAME: "); if (b != NULL) { b->last = ngx_copy(b->last, context->public_dir.data, context->public_dir.len); } total_size += context->public_dir.len; if (slcf->environment.data != NULL) { if (b != NULL) { b->last = ngx_copy(b->last, " (", 2); b->last = ngx_copy(b->last, slcf->environment.data, slcf->environment.len); b->last = ngx_copy(b->last, ")", 1); } total_size += (sizeof(" (") - 1) + slcf->environment.len + (sizeof(")") - 1); } PUSH_STATIC_STR("\r\n"); } PUSH_STATIC_STR("!~PASSENGER_APP_TYPE: "); if (b != NULL) { b->last = ngx_copy(b->last, state->app_type.data, state->app_type.len); } total_size += state->app_type.len; PUSH_STATIC_STR("\r\n"); if (slcf->union_station_filters != NGX_CONF_UNSET_PTR && slcf->union_station_filters->nelts > 0) { union_station_filters = (ngx_str_t *) slcf->union_station_filters->elts; for (i = 0; i < slcf->union_station_filters->nelts; i++) { PUSH_STATIC_STR("!~UNION_STATION_FILTERS: "); if (b != NULL) { b->last = ngx_copy(b->last, union_station_filters[i].data, union_station_filters[i].len); } total_size += union_station_filters[i].len; PUSH_STATIC_STR("\r\n"); } } if (b != NULL) { b->last = ngx_copy(b->last, slcf->options_cache.data, slcf->options_cache.len); } total_size += slcf->options_cache.len; if (slcf->env_vars_cache.data != NULL) { PUSH_STATIC_STR("!~PASSENGER_ENV_VARS: "); if (b != NULL) { b->last = ngx_copy(b->last, slcf->env_vars_cache.data, slcf->env_vars_cache.len); } total_size += slcf->env_vars_cache.len; PUSH_STATIC_STR("\r\n"); } /* D = Dechunk response * Prevent Nginx from rechunking the response. * C = Strip 100 Continue header * S = SSL */ PUSH_STATIC_STR("!~FLAGS: DC"); #if (NGX_HTTP_SSL) if (r->http_connection != NULL /* happens in sub-requests */ && r->http_connection->ssl) { PUSH_STATIC_STR("S"); } #endif PUSH_STATIC_STR("\r\n\r\n"); return total_size; #undef PUSH_STATIC_STR }
int CUnicodeUtils::GetCPCode(const CString &codename) { static CodeMap map[]= { { 37, _T("IBM037")},// IBM EBCDIC US-Canada {437, _T("IBM437")},// OEM United States {500, _T("IBM500")},// IBM EBCDIC International {708, _T("ASMO-708")},// Arabic (ASMO 708) {709, _T("Arabic")},// (ASMO-449+, BCON V4) {710, _T("Arabic")},// - Transparent Arabic {720, _T("DOS-720")},// Arabic (Transparent ASMO); Arabic (DOS) {737, _T("ibm737")},// OEM Greek (formerly 437G); Greek (DOS) {775, _T("ibm775")},// OEM Baltic; Baltic (DOS) {850, _T("ibm850")},// OEM Multilingual Latin 1; Western European (DOS) {852, _T("ibm852")},// OEM Latin 2; Central European (DOS) {855, _T("IBM855")},// OEM Cyrillic (primarily Russian) {857, _T("ibm857")},// OEM Turkish; Turkish (DOS) {858, _T("IBM00858")},// OEM Multilingual Latin 1 + Euro symbol {860, _T("IBM860")},// OEM Portuguese; Portuguese (DOS) {861, _T("ibm861")},// OEM Icelandic; Icelandic (DOS) {862, _T("DOS-862")},// OEM Hebrew; Hebrew (DOS) {863, _T("IBM863")},// OEM French Canadian; French Canadian (DOS) {864, _T("IBM864")},// OEM Arabic; Arabic (864) {865, _T("IBM865")},// OEM Nordic; Nordic (DOS) {866, _T("cp866")},// OEM Russian; Cyrillic (DOS) {869, _T("ibm869")},// OEM Modern Greek; Greek, Modern (DOS) {870, _T("IBM870")},// IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2 {874, _T("windows-874")},// ANSI/OEM Thai (same as 28605, ISO 8859-15); Thai (Windows) {875, _T("cp875")},// IBM EBCDIC Greek Modern {932, _T("shift_jis")},// ANSI/OEM Japanese; Japanese (Shift-JIS) {936, _T("gb2312")},// ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312) {949, _T("ks_c_5601-1987")},// ANSI/OEM Korean (Unified Hangul Code) {949, _T("cp949")},// ANSI/OEM Korean (Unified Hangul Code) {950, _T("big5")},// ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5) {1026,_T("IBM1026")},// IBM EBCDIC Turkish (Latin 5) {1047,_T("IBM01047")},// IBM EBCDIC Latin 1/Open System {1140,_T("IBM01140")},// IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro) {1141, _T("IBM01141")},// IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro) {1142, _T("IBM01142")},// IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro) {1143, _T("IBM01143")},// IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro) {1144, _T("IBM01144")},// IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro) {1145, _T("IBM01145")},// IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro) {1146, _T("IBM01146")},// IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro) {1147, _T("IBM01147")},// IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro) {1148, _T("IBM01148")},// IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro) {1149, _T("IBM01149")},// IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro) {1200, _T("utf-16")},// Unicode UTF-16, little endian byte order (BMP of ISO 10646); available only to managed applications {1201, _T("unicodeFFFE")},// Unicode UTF-16, big endian byte order; available only to managed applications {1250, _T("windows-1250")},// ANSI Central European; Central European (Windows) {1251, _T("windows-1251")},// ANSI Cyrillic; Cyrillic (Windows) {1251, _T("cp1251")}, {1251, _T("cp-1251")}, {1251, _T("cp_1251")}, {1252, _T("windows-1252")},// ANSI Latin 1; Western European (Windows) {1253, _T("windows-1253")},// ANSI Greek; Greek (Windows) {1254, _T("windows-1254")},// ANSI Turkish; Turkish (Windows) {1255, _T("windows-1255")},// ANSI Hebrew; Hebrew (Windows) {1256, _T("windows-1256")},// ANSI Arabic; Arabic (Windows) {1257, _T("windows-1257")},// ANSI Baltic; Baltic (Windows) {1258, _T("windows-1258")},// ANSI/OEM Vietnamese; Vietnamese (Windows) {1361, _T("Johab")},// Korean (Johab) {10000,_T("macintosh")},// MAC Roman; Western European (Mac) {10001, _T("x-mac-japanese")},// Japanese (Mac) {10002, _T("x-mac-chinesetrad")},// MAC Traditional Chinese (Big5); Chinese Traditional (Mac) {10003, _T("x-mac-korean")},// Korean (Mac) {10004, _T("x-mac-arabic")},// Arabic (Mac) {10005, _T("x-mac-hebrew")},// Hebrew (Mac) {10006, _T("x-mac-greek")},// Greek (Mac) {10007, _T("x-mac-cyrillic")},// Cyrillic (Mac) {10008, _T("x-mac-chinesesimp")},// MAC Simplified Chinese (GB 2312); Chinese Simplified (Mac) {10010, _T("x-mac-romanian")},// Romanian (Mac) {10017, _T("x-mac-ukrainian")},// Ukrainian (Mac) {10021, _T("x-mac-thai")},// Thai (Mac) {10029, _T("x-mac-ce")},// MAC Latin 2; Central European (Mac) {10079, _T("x-mac-icelandic")},// Icelandic (Mac) {10081, _T("x-mac-turkish")},// Turkish (Mac) {10082, _T("x-mac-croatian")},// Croatian (Mac) {12000, _T("utf-32")},// Unicode UTF-32, little endian byte order; available only to managed applications {12001, _T("utf-32BE")},// Unicode UTF-32, big endian byte order; available only to managed applications {20000, _T("x-Chinese_CNS")},// CNS Taiwan; Chinese Traditional (CNS) {20001, _T("x-cp20001")},// TCA Taiwan {20002, _T("x_Chinese-Eten")},// Eten Taiwan; Chinese Traditional (Eten) {20003, _T("x-cp20003")},// IBM5550 Taiwan {20004, _T("x-cp20004")},// TeleText Taiwan {20005, _T("x-cp20005")},// Wang Taiwan {20105, _T("x-IA5")},// IA5 (IRV International Alphabet No. 5, 7-bit); Western European (IA5) {20106, _T("x-IA5-German")},// IA5 German (7-bit) {20107, _T("x-IA5-Swedish")},// IA5 Swedish (7-bit) {20108, _T("x-IA5-Norwegian")},// IA5 Norwegian (7-bit) {20127, _T("us-ascii")},// US-ASCII (7-bit) {20261, _T("x-cp20261")},// T.61 {20269, _T("x-cp20269")},// ISO 6937 Non-Spacing Accent {20273, _T("IBM273")},// IBM EBCDIC Germany {20277, _T("IBM277")},//IBM EBCDIC Denmark-Norway {20278, _T("IBM278")},// IBM EBCDIC Finland-Sweden {20280, _T("IBM280")},// IBM EBCDIC Italy {20284, _T("IBM284")},// IBM EBCDIC Latin America-Spain {20285, _T("IBM285")},// IBM EBCDIC United Kingdom {20290, _T("IBM290")},// IBM EBCDIC Japanese Katakana Extended {20297, _T("IBM297")},// IBM EBCDIC France {20420, _T("IBM420")},// IBM EBCDIC Arabic {20423, _T("IBM423")},// IBM EBCDIC Greek {20424, _T("IBM424")},// IBM EBCDIC Hebrew {20833, _T("x-EBCDIC-KoreanExtended")},// IBM EBCDIC Korean Extended {20838, _T("IBM-Thai")},// IBM EBCDIC Thai {20866, _T("koi8-r")},// Russian (KOI8-R); Cyrillic (KOI8-R) {20871, _T("IBM871")},// IBM EBCDIC Icelandic {20880, _T("IBM880")},// IBM EBCDIC Cyrillic Russian {20905, _T("IBM905")},// IBM EBCDIC Turkish {20924, _T("IBM00924")},// IBM EBCDIC Latin 1/Open System (1047 + Euro symbol) {20932, _T("EUC-JP")},// Japanese (JIS 0208-1990 and 0121-1990) {20936, _T("x-cp20936")},// Simplified Chinese (GB2312); Chinese Simplified (GB2312-80) {20949, _T("x-cp20949")},// Korean Wansung {21025, _T("cp1025")},// IBM EBCDIC Cyrillic Serbian-Bulgarian {21027, _T("21027")},// (deprecated) {21866, _T("koi8-u")},// Ukrainian (KOI8-U); Cyrillic (KOI8-U) {28591, _T("iso-8859-1")},// ISO 8859-1 Latin 1; Western European (ISO) {28592, _T("iso-8859-2")},// ISO 8859-2 Central European; Central European (ISO) {28593, _T("iso-8859-3")},// ISO 8859-3 Latin 3 {28594, _T("iso-8859-4")},// ISO 8859-4 Baltic {28595, _T("iso-8859-5")},// ISO 8859-5 Cyrillic {28596, _T("iso-8859-6")},// ISO 8859-6 Arabic {28597, _T("iso-8859-7")},// ISO 8859-7 Greek {28598, _T("iso-8859-8")},// ISO 8859-8 Hebrew; Hebrew (ISO-Visual) {28599, _T("iso-8859-9")},// ISO 8859-9 Turkish {28603, _T("iso-8859-13")},// ISO 8859-13 Estonian {28605, _T("iso-8859-15")},// ISO 8859-15 Latin 9 {29001, _T("x-Europa")},// Europa 3 {38598, _T("iso-8859-8-i")},// ISO 8859-8 Hebrew; Hebrew (ISO-Logical) {50220, _T("iso-2022-jp")},// ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS) {50221, _T("csISO2022JP")},// ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana) {50222, _T("iso-2022-jp")},// ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI) {50225, _T("iso-2022-kr")},// ISO 2022 Korean {50227, _T("x-cp50227")},// ISO 2022 Simplified Chinese; Chinese Simplified (ISO 2022) {50229, _T("ISO")},// 2022 Traditional Chinese {50930, _T("EBCDIC")},// Japanese (Katakana) Extended {50931, _T("EBCDIC")},// US-Canada and Japanese {50933, _T("EBCDIC")},// Korean Extended and Korean {50935, _T("EBCDIC")},// Simplified Chinese Extended and Simplified Chinese {50936, _T("EBCDIC")},// Simplified Chinese {50937, _T("EBCDIC")},// US-Canada and Traditional Chinese {50939, _T("EBCDIC")},// Japanese (Latin) Extended and Japanese {51932, _T("euc-jp")},// EUC Japanese {51936, _T("EUC-CN")},// EUC Simplified Chinese; Chinese Simplified (EUC) {51949, _T("euc-kr")},// EUC Korean {51950, _T("EUC")},// Traditional Chinese {52936, _T("hz-gb-2312")},// HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ) {54936, _T("GB18030")},// Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030) {57002, _T("x-iscii-de")},// ISCII Devanagari {57003, _T("x-iscii-be")},// ISCII Bengali {57004, _T("x-iscii-ta")},// ISCII Tamil {57005, _T("x-iscii-te")},// ISCII Telugu {57006, _T("x-iscii-as")},// ISCII Assamese {57007, _T("x-iscii-or")},// ISCII Oriya {57008, _T("x-iscii-ka")},// ISCII Kannada {57009, _T("x-iscii-ma")},// ISCII Malayalam {57010, _T("x-iscii-gu")},// ISCII Gujarati {57011, _T("x-iscii-pa")},// ISCII Punjabi {65000, _T("utf-7")},// Unicode (UTF-7) {65001, _T("utf-8")},// Unicode (UTF-8) {0, nullptr} }; static CodeMap *p=map; if (codename.IsEmpty()) return CP_UTF8; CString code(codename); code.MakeLower(); while (p->m_CodeName) { CString str = p->m_CodeName; str=str.MakeLower(); if (str == code) return p->m_Code; ++p; } return CP_UTF8; }