/* !!! Verify that internal RBTDB cannot leak somehow. */ static void ATTR_NONNULLS free_ldapdb(ldapdb_t *ldapdb) { #ifdef RBTDB_DEBUG isc_result_t result; dns_dbversion_t *version = NULL; dns_name_t *zone_name = dns_db_origin(&ldapdb->common); ld_string_t *file_name = NULL; CHECK(zr_get_zone_path(ldapdb->common.mctx, ldap_instance_getsettings_local(ldapdb->ldap_inst), zone_name, "ldapdb.dump", &file_name)); dns_db_currentversion(ldapdb->rbtdb, &version); log_info("dump to '%s' started", str_buf(file_name)); result = dns_db_dump2(ldapdb->rbtdb, version, str_buf(file_name), dns_masterformat_text); log_info("dump to '%s' finished: %s", str_buf(file_name), isc_result_totext(result)); dns_db_closeversion(ldapdb->rbtdb, &version, ISC_FALSE); cleanup: if (result != ISC_R_SUCCESS) { log_error_r("dump to '%s' failed", (file_name && str_buf(file_name)) ? str_buf(file_name) : "<NULL>"); } str_destroy(&file_name); #endif dns_db_detach(&ldapdb->rbtdb); dns_name_free(&ldapdb->common.origin, ldapdb->common.mctx); RUNTIME_CHECK(isc_mutex_destroy(&ldapdb->newversion_lock) == ISC_R_SUCCESS); isc_mem_putanddetach(&ldapdb->common.mctx, ldapdb, sizeof(*ldapdb)); }
std::wstring multistr2widestr(const unsigned int from_code_page, const std::string& s) { std::wstring ws; do { if (s.empty()) { break; } int need_ch_len = MultiByteToWideChar(from_code_page, 0, s.c_str(), s.size(), NULL, 0); if (0 == need_ch_len) { print_last_err("MultiByteToWideChar fail when query need size"); break; } boost::scoped_array<wchar_t> str_buf(new wchar_t[need_ch_len]); memset(str_buf.get(), 0, need_ch_len * sizeof(wchar_t)); need_ch_len = MultiByteToWideChar(from_code_page, 0, s.c_str(), s.size(), str_buf.get(), need_ch_len); if (0 == need_ch_len) { print_last_err("MultiByteToWideChar fail"); break; } ws.append(str_buf.get(), need_ch_len); } while (false); return ws; }
string DNS::resolve(string hostname) { unsigned short query_type; if(is_Ip_addr(hostname)) { if(is_valiad_IP(hostname)) { query_type = DNS_PTR; } else { printf("Invalid IP address\n"); return ""; } } else { query_type = DNS_A; } unique_ptr<char> buf(new char[1024]); pair<int,int> size_pair = makePkt(hostname,buf.get(),query_type); int pkt_size = size_pair.first; int question_size = size_pair.second; int count = 0; vector<string> server_ips = getDNSServer(); while(count++ < 3) { string server_ip = server_ips[count%server_ips.size()]; if(!s.sock_send(buf.get(),pkt_size,(char*)server_ip.c_str(),"53")) continue; if(s.sock_recv()) break; } EnterCriticalSection(&statistic_lock); stat.retx.push_back(count); LeaveCriticalSection(&statistic_lock); string result; unique_ptr<char> str_buf(new char[4096]); if(count >= 3) { EnterCriticalSection(&statistic_lock); stat.local_dns_timeout++; LeaveCriticalSection(&statistic_lock); sprintf(str_buf.get(),"Local DNS timeout\n"); result = (str_buf.get()); return result; } make_result_string(s.get_recv_buf(),sizeof(fixedDNSheader) + question_size,str_buf.get()); result = (str_buf.get()); return result; }
extern "C" CDECL void upcall_log_str(rust_task *task, uint32_t level, rust_str *str) { LOG_UPCALL_ENTRY(task); if (task->dom->log_lvl >= level) { const char *c = str_buf(task, str); task->dom->log(task, level, "rust: %s", c); } }
void OnTypeChanged(UINT uNotifyCode, int nID, CWindow wndCtl) { hal::win_c_str<std::wstring> str_buf(MAX_PATH); wndCtl.GetWindowText(str_buf, numeric_cast<int>(str_buf.size())); if (str_buf.str() == hal::app().res_wstr(HAL_NEWT_ADD_PEERS_WEB)) { ::EnableWindow(GetDlgItem(HAL_NEWT_ADD_DHT_PORT_TEXT), false); ::EnableWindow(GetDlgItem(HAL_NEWT_ADD_DHT_PORT), false); } else { ::EnableWindow(GetDlgItem(HAL_NEWT_ADD_DHT_PORT_TEXT), true); ::EnableWindow(GetDlgItem(HAL_NEWT_ADD_DHT_PORT), true); } }
std::string widestr2multistr(const unsigned int to_code_page, const std::wstring& ws, const char *default_char /*= NULL*/) { std::string s; do { if (ws.empty()) { break; } //lpUsedDefaultChar: For the CP_UTF7 and CP_UTF8 settings for CodePage, this parameter must be set to a null pointer //Otherwise, the function fails with ERROR_INVALID_PARAMETER. //see MSDN const char *final_default_char = default_char; if (to_code_page == CP_UTF7 || to_code_page == CP_UTF8) { final_default_char = NULL; } int need_ch_len = WideCharToMultiByte(to_code_page, 0, ws.c_str(), ws.size(), NULL, 0, final_default_char, NULL); if (0 == need_ch_len) { print_last_err("WideCharToMultiByte fail when query need size"); break; } boost::scoped_array<char> str_buf(new char[need_ch_len]); memset(str_buf.get(), 0, need_ch_len * sizeof(char)); need_ch_len = WideCharToMultiByte(to_code_page, 0, ws.c_str(), ws.size(), str_buf.get(), need_ch_len, final_default_char, NULL); if (0 == need_ch_len) { print_last_err("WideCharToMultiByte fail"); break; } s.append(str_buf.get(), need_ch_len); } while (false); return s; }
//------------------------------------------------------------------------------ Wdt::Wdt( const BufferS_t &buffer ) { if ( buffer.size() <= 0 ) { quitApp( "[WDT] buffer invalid" ); return; } // create an istream of our buffer std::stringbuf str_buf( buffer ); std::istream i_str( &str_buf ); uint32_t chunk_size = 0; // read in chunk by chunk chunk_size = readChunkHead( i_str, "MVER", (char*)&_mverChunk, sizeof( MverChunk_s ) ); chunk_size = readChunkHead( i_str, "MPHD", (char*)&_mphdChunk, sizeof( MphdChunk_s ) ); chunk_size = readChunkHead( i_str, "MAIN", (char*)&_mainChunk, sizeof( MainChunk_s ) ); // I could just say 64*64, but it's there to check that everything went right size_t count = _mainChunk.size / sizeof( MainChunk_s::AsyncObject_s ); size_t num_adts = 0; _asyncObjects.resize( count ); // read flags from buffer for ( size_t i = 0; i < count; i++ ) { i_str.read( (char*)&_asyncObjects[i], sizeof( MainChunk_s::AsyncObject_s ) ); if ( _asyncObjects[i].flags & 0x1 ) { num_adts++; } } _adtCoords.resize( num_adts ); int i = 0; for ( int y = 0; y < 64; y++ ) { for ( int x = 0; x < 64; x++ ) { // get all tiles with flag & 1 if ( _asyncObjects[y*64+x].flags & 0x1 ) { _adtCoords[i].x = x; _adtCoords[i].y = y; i++; } } } }
inline std::string ToUpperOrdinal(std::string const& str) { if (str.empty()) { return str; } std::vector<char> str_buf(std::begin(str), std::end(str)); str_buf.push_back(0); HADESMEM_DETAIL_ASSERT(str_buf.size() < (std::numeric_limits<DWORD>::max)()); DWORD const num_converted = ::CharUpperBuffA(str_buf.data(), static_cast<DWORD>(str_buf.size())); if (num_converted != str_buf.size()) { DWORD const last_error = ::GetLastError(); HADESMEM_DETAIL_THROW_EXCEPTION(Error{} << ErrorString{"CharUpperBuff failed."} << ErrorCodeWinRet{num_converted} << ErrorCodeWinLast{last_error}); } return str_buf.data(); }
extern "C" CDECL void upcall_log_str(rust_task *task, rust_str *str) { LOG_UPCALL_ENTRY(task); const char *c = str_buf(task, str); task->log(rust_log::UPCALL | rust_log::ULOG, "rust: %s", c); }
main(int argc, char **argv) { INIT_EXCEPTIONS(); set_new_handler ( FreeStoreException ); int ret = 1; const char *progname = argv[0]; int compressed = 0; #ifdef FISH_DEBUG DBUG_PROCESS(argv[0]); if(getenv("FISH_DBUG")) DBUG_PUSH(getenv("FISH_DBUG")); #endif argv++; argc--; while(argc > 0 && argv[0][0] == '-'){ const char *opt = argv[0]; argv++; argc--; if(strcmp(opt, "-compressed") == 0){ compressed = 1; } else{ usage(progname); } } if(argc == 2){ char *bookcaseDir = argv[0]; char *infobaseDir = argv[1]; try{ BookCaseDB db(bookcaseDir); const char *infolibDir; const char *bcname; split_path(infobaseDir, infolibDir, bcname); OLIAS_DB mmdb_handle; info_lib *mmdb = mmdb_handle.openInfoLib(infolibDir, bcname); // 30 will be enough for now #define COMPRESSED_AGENT_SIZE 30 char comp_agent[ COMPRESSED_AGENT_SIZE ]; if ( compressed ) { for ( int i = 0; i < COMPRESSED_AGENT_SIZE; i++ ) { comp_agent[i] = 0; } ostrstream str_buf( comp_agent, COMPRESSED_AGENT_SIZE ); info_base *bcptr = mmdb->get_info_base(bcname); handler *x = (bcptr->get_obj_dict()).get_handler( form("%s.%s", bcname, "ps.dict")); x->its_oid().asciiOut(str_buf); } hashTable<CC_String, BTCollectable> hd(hash_func); locator_table( db, hd); /* throw exception if duplicate locator is found */ DBTable *nodeMeta = db.table(BookCaseDB::NodeMeta, DB::READ); DBCursor node_cursor( *nodeMeta ); writeCCF(db, mmdb, bcname); writeBooks(db, mmdb, bcname, &node_cursor, compressed, comp_agent, hd); writeLCF(db, mmdb, bcname, hd); hd.clearAndDestroy(); ret = 0; } catch(PosixError&, pe){ fprintf(stderr, "%s: error on %s: %s\n", progname, bookcaseDir, pe.msg()); } catch(Unexpected&, pe) {
isc_result_t acl_from_ldap(isc_mem_t *mctx, const char *aclstr, acl_type_t type, dns_acl_t **aclp) { dns_acl_t *acl = NULL; isc_result_t result; ld_string_t *new_aclstr = NULL; cfg_parser_t *parser = NULL; cfg_obj_t *aclobj = NULL; cfg_aclconfctx_t *aclctx = NULL; /* ACL parser requires "configuration context". The parser looks for * undefined names in this context. We create empty context ("map" type), * i.e. only built-in named lists "any", "none" etc. are supported. */ cfg_obj_t *cctx = NULL; cfg_parser_t *parser_empty = NULL; REQUIRE(aclp != NULL && *aclp == NULL); CHECK(bracket_str(mctx, aclstr, &new_aclstr)); CHECK(cfg_parser_create(mctx, dns_lctx, &parser)); CHECK(cfg_parser_create(mctx, dns_lctx, &parser_empty)); CHECK(cfg_parse_strbuf(parser_empty, "{}", &empty_map_p, &cctx)); switch (type) { case acl_type_query: CHECK(cfg_parse_strbuf(parser, str_buf(new_aclstr), &cfg_type_allow_query, &aclobj)); break; case acl_type_transfer: CHECK(cfg_parse_strbuf(parser, str_buf(new_aclstr), &cfg_type_allow_transfer, &aclobj)); break; default: /* This is a bug */ REQUIRE("Unhandled ACL type in acl_from_ldap" == NULL); } CHECK(cfg_aclconfctx_create(mctx, &aclctx)); CHECK(cfg_acl_fromconfig(aclobj, cctx, dns_lctx, aclctx, mctx, 0, &acl)); *aclp = acl; result = ISC_R_SUCCESS; cleanup: if (result != ISC_R_SUCCESS) log_error_r("%s ACL parsing failed: '%s'", type == acl_type_query ? "query" : "transfer", aclstr); if (aclctx != NULL) cfg_aclconfctx_detach(&aclctx); if (aclobj != NULL) cfg_obj_destroy(parser, &aclobj); if (parser != NULL) cfg_parser_destroy(&parser); if (cctx != NULL) cfg_obj_destroy(parser_empty, &cctx); if (parser_empty != NULL) cfg_parser_destroy(&parser_empty); str_destroy(&new_aclstr); return result; }
isc_result_t acl_configure_zone_ssutable(const char *policy_str, dns_zone_t *zone) { isc_result_t result = ISC_R_SUCCESS; cfg_parser_t *parser = NULL; const cfg_listelt_t *el; cfg_obj_t *policy = NULL; dns_ssutable_t *table = NULL; ld_string_t *new_policy_str = NULL; isc_mem_t *mctx; REQUIRE(zone != NULL); mctx = dns_zone_getmctx(zone); if (policy_str == NULL) goto cleanup; CHECK(bracket_str(mctx, policy_str, &new_policy_str)); CHECK(cfg_parser_create(mctx, dns_lctx, &parser)); result = cfg_parse_strbuf(parser, str_buf(new_policy_str), &cfg_type_update_policy, &policy); if (result != ISC_R_SUCCESS) { dns_zone_log(zone, ISC_LOG_ERROR, "failed to parse policy string"); goto cleanup; } CHECK(dns_ssutable_create(mctx, &table)); for (el = cfg_list_first(policy); el != NULL; el = cfg_list_next(el)) { const cfg_obj_t *stmt; isc_boolean_t grant; unsigned int match_type; dns_fixedname_t fname, fident; dns_rdatatype_t *types; unsigned int n; types = NULL; stmt = cfg_listelt_value(el); CHECK(get_mode(stmt, &grant)); CHECK(get_match_type(stmt, &match_type)); CHECK(get_fixed_name(stmt, "identity", &fident)); /* Use zone name for 'zonesub' match type */ result = get_fixed_name(stmt, "name", &fname); if (result == ISC_R_NOTFOUND && match_type == DNS_SSUMATCHTYPE_SUBDOMAIN) { dns_fixedname_init(&fname); CHECK(dns_name_copy(dns_zone_getorigin(zone), dns_fixedname_name(&fname), &fname.buffer)); } else if (result != ISC_R_SUCCESS) goto cleanup; CHECK(get_types(mctx, stmt, &types, &n)); if (match_type == DNS_SSUMATCHTYPE_WILDCARD && !dns_name_iswildcard(dns_fixedname_name(&fname))) { char name[DNS_NAME_FORMATSIZE]; dns_name_format(dns_fixedname_name(&fname), name, DNS_NAME_FORMATSIZE); dns_zone_log(zone, ISC_LOG_ERROR, "invalid update policy: " "name '%s' is expected to be a wildcard", name); CLEANUP_WITH(DNS_R_BADNAME); } result = dns_ssutable_addrule(table, grant, dns_fixedname_name(&fident), match_type, dns_fixedname_name(&fname), n, types); SAFE_MEM_PUT(mctx, types, n * sizeof(dns_rdatatype_t)); if (result != ISC_R_SUCCESS) goto cleanup; } cleanup: if (result == ISC_R_SUCCESS) dns_zone_setssutable(zone, table); str_destroy(&new_policy_str); if (policy != NULL) cfg_obj_destroy(parser, &policy); if (parser != NULL) cfg_parser_destroy(&parser); if (table != NULL) dns_ssutable_detach(&table); return result; }