/* !!! 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;
}
