自学教程：C++ CloseDB函数代码示例

	SQLConn(Module* m, const SQLhost& hi)	: mod(m), host(hi), login(NULL), sock(NULL), context(NULL)	{		if (OpenDB())		{			std::string query("USE " + host.name);			if (tds_submit_query(sock, query.c_str()) == TDS_SUCCEED)			{				if (tds_process_simple_query(sock) != TDS_SUCCEED)				{					LoggingMutex->Lock();					ServerInstance->Logs->Log("m_mssql",LOG_DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);					LoggingMutex->Unlock();					CloseDB();				}			}			else			{				LoggingMutex->Lock();				ServerInstance->Logs->Log("m_mssql",LOG_DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);				LoggingMutex->Unlock();				CloseDB();			}		}		else		{			LoggingMutex->Lock();			ServerInstance->Logs->Log("m_mssql",LOG_DEFAULT, "WARNING: Could not connect to DB with id: " + host.id);			LoggingMutex->Unlock();			CloseDB();		}	}

MYSQL *OpenDB(char *pHost, char *pUser, char *pPasswd, char *pDB, char *pUnixSocket, unsigned long lClientFlag, unsigned int nPort){	MYSQL *pMySql = mysql_init(NULL);	if (!pMySql)	{		SystemErrorInfor("OpenDB", errno);		return NULL;	}	if (!mysql_real_connect(pMySql, pHost, pUser, pPasswd, pDB, nPort, pUnixSocket, lClientFlag))	{		ErrorInfor("OpenDB-1", (char *)mysql_error(pMySql));		CloseDB(pMySql);		return NULL;	}	if (mysql_autocommit(pMySql, 0) != 0)	{		ErrorInfor("OpenDB-2", (char *)mysql_error(pMySql));		CloseDB(pMySql);		return NULL;	}	return pMySql;}

void test_migrate_unqualified_names(void){    DBHandle *db = setup(true);    assert_int_equal(WriteDB(db, "foo", &dummy_event, sizeof(dummy_event)), true);    assert_int_equal(WriteDB(db, "q.bar", &dummy_event, sizeof(dummy_event)), true);    CloseDB(db);    assert_int_equal(OpenDB(&db, dbid_bundles), true);    /* Old entry migrated */    assert_int_equal(HasKeyDB(db, "foo", strlen("foo") + 1), false);    assert_int_equal(HasKeyDB(db, "default.foo", strlen("default.foo") + 1), true);    Event read_value = { 0 };    ReadDB(db, "default.foo", &read_value, sizeof(read_value));    assert_memory_equal(&read_value, &dummy_event, sizeof(dummy_event));    /* New entry preserved */    assert_int_equal(HasKeyDB(db, "q.bar", strlen("q.bar") + 1), true);    memset(&read_value, 0, sizeof(read_value));    ReadDB(db, "q.bar", &read_value, sizeof(read_value));    assert_memory_equal(&read_value, &dummy_event, sizeof(dummy_event));    /* Version marker */    assert_int_equal(HasKeyDB(db, "version", strlen("version") + 1), true);    CloseDB(db);}

static void test_no_migration(void){    DBHandle *db = setup(true);    CloseDB(db);    /* Migration on empty DB should produce single "version" key */    assert_int_equal(OpenDB(&db, dbid_lastseen), true);    DBCursor *cursor;    assert_int_equal(NewDBCursor(db, &cursor), true);    char *key;    void *value;    int ksize, vsize;    while (NextDB(cursor, &key, &ksize, &value, &vsize))    {        assert_int_equal(ksize, strlen("version") + 1);        assert_string_equal(key, "version");        assert_int_equal(vsize, 2);        assert_string_equal(value, "1");    }    assert_int_equal(DeleteDBCursor(cursor), true);    CloseDB(db);}

static bool PurgeCurrentLastSeen(){    CF_DB *db_conn = NULL;    CF_DBC *db_cursor = NULL;    char *key = NULL;    void *value = NULL;    int ksize = 0, vsize = 0;    if (!OpenDB(&db_conn, dbid_lastseen))    {        Log(LOG_LEVEL_ERR, "Unable to open lastseen db");        return false;    }    if (!NewDBCursor(db_conn, &db_cursor))    {        Log(LOG_LEVEL_ERR, "Unable to scan lastseen db");        CloseDB(db_conn);        return false;    }    while (NextDB(db_cursor, &key, &ksize, &value, &vsize))    {        /* Only read the 'quality of connection' entries */        if (key[0] != 'q')        {            continue;        }        time_t then = 0;        if (value != NULL)        {            if (sizeof(KeyHostSeen) < vsize)            {                Log(LOG_LEVEL_ERR, "Invalid entry in lastseen database.");                continue;            }            KeyHostSeen entry = { 0 };            memcpy(&entry, value, vsize);            then = entry.lastseen;        }        if (then - START_TIME > NHOSTS)        {            DBCursorDeleteEntry(db_cursor);            Log(LOG_LEVEL_DEBUG, "Deleting expired entry for %s", key);            continue;        }    }    DeleteDBCursor(db_cursor);    CloseDB(db_conn);    return true;}

void test_migrate_single(const char *expected_old_key,                         const char *expected_quality_key){    /* Test migration of single entry */    DBHandle *db = setup(true);    KeyHostSeen0 khs0 = {        .q = 666777.0,        .expect = 12345.0,        .var = 6543210.0,    };    strcpy(khs0.address, "1.2.3.4");    assert_int_equal(WriteDB(db, expected_old_key, &khs0, sizeof(khs0)), true);    CloseDB(db);    assert_int_equal(OpenDB(&db, dbid_lastseen), true);    /* Old entry migrated */    assert_int_equal(HasKeyDB(db, expected_old_key,                              strlen(expected_old_key) + 1), false);    /* Version marker */    assert_int_equal(HasKeyDB(db, "version", strlen("version") + 1), true);    /* Incoming connection quality */    KeyHostSeen khs;    assert_int_equal(ReadDB(db, expected_quality_key, &khs, sizeof(khs)), true);    assert_int_equal(khs.lastseen, 666777);    assert_double_close(khs.Q.q, 12345.0);    assert_double_close(khs.Q.expect, 12345.0);    assert_double_close(khs.Q.var, 6543210.0);    /* Address mapping */    char address[CF_BUFSIZE];    assert_int_equal(ReadDB(db, KEYHASH_KEY, address, sizeof(address)), true);    assert_string_equal(address, "1.2.3.4");    /* Reverse mapping */    char keyhash[CF_BUFSIZE];    assert_int_equal(ReadDB(db, "a1.2.3.4", keyhash, sizeof(keyhash)), true);    assert_string_equal(keyhash, KEYHASH);    CloseDB(db);}void test_migrate_incoming(void){    test_migrate_single(KEYHASH_IN, QUALITY_IN);}

static void test_setup(void){    snprintf(CFWORKDIR, CF_BUFSIZE, "/tmp/changes_migration_test.XXXXXX");    mkdtemp(CFWORKDIR);    char state_dir[PATH_MAX];    snprintf(state_dir, sizeof(state_dir), "%s/state", CFWORKDIR);    mkdir(state_dir, 0755);    CF_DB *db;    assert_true(OpenDB(&db, dbid_checksums));    // Hand crafted from the old version of NewIndexKey().    char checksum_key[NO_FILES][30] =        {            { 'M','D','5','/0','/0','/0','/0','/0',              '/','e','t','c','/','h','o','s','t','s','/0' },            { 'M','D','5','/0','/0','/0','/0','/0',              '/','e','t','c','/','p','a','s','s','w','d','/0' },            { 'M','D','5','/0','/0','/0','/0','/0',              '/','f','i','l','e','1','/0' },            { 'M','D','5','/0','/0','/0','/0','/0',              '/','f','i','l','e','2','/0' },        };    for (int c = 0; c < NO_FILES; c++)    {        int ksize = CHANGES_HASH_FILE_NAME_OFFSET + strlen(checksum_key[c] + CHANGES_HASH_FILE_NAME_OFFSET) + 1;        int vsize = strlen(CHECKSUM_VALUE[c]) + 1;        assert_true(WriteComplexKeyDB(db, checksum_key[c], ksize,                                      CHECKSUM_VALUE[c], vsize));    }    CloseDB(db);    assert_true(OpenDB(&db, dbid_filestats));    char *filestat_key[NO_FILES] =        {            "/etc/hosts",            "/etc/passwd",            "/file1",            "/file2",        };    filestat_value.st_uid = 4321;    memset(&filestat_value, 0, sizeof(filestat_value));    for (int c = 0; c < NO_FILES; c++)    {        assert_true(WriteDB(db, filestat_key[c],                            &filestat_value, sizeof(filestat_value)));    }    CloseDB(db);}

static void Mon_DumpSlowlyVaryingObservations(void){ CF_DB *dbp; CF_DBC *dbcp; FILE *fout; char *key; void *stored; int ksize, vsize; char name[CF_BUFSIZE];  if (!OpenDB(&dbp, dbid_static))    {    return;    }  snprintf(name, CF_BUFSIZE - 1, "%s%cstate%cstatic_data", CFWORKDIR, FILE_SEPARATOR, FILE_SEPARATOR);  if ((fout = fopen(name, "w")) == NULL)    {    Log(LOG_LEVEL_ERR, "Unable to save discovery data in '%s'. (fopen: %s)", name, GetErrorStr());    CloseDB(dbp);    return;    } /* Acquire a cursor for the database. */  if (!NewDBCursor(dbp, &dbcp))    {    Log(LOG_LEVEL_INFO, "Unable to scan class db");    CloseDB(dbp);    return;    }  while (NextDB(dbcp, &key, &ksize, &stored, &vsize))    {    char buf[CF_MAXVARSIZE], lval[CF_MAXVARSIZE], rval[CF_BUFSIZE];        strncpy(buf, key, CF_MAXVARSIZE - 1);        sscanf(buf, "%s:", lval);        if (stored != NULL)       {       strncpy(rval, stored, CF_BUFSIZE - 1);       fprintf(fout, "%s:%s/n", lval, rval);       }    }  DeleteDBCursor(dbcp); CloseDB(dbp); fclose(fout);}

static Averages *GetCurrentAverages(char *timekey){    CF_DB *dbp;    static Averages entry;    if (!OpenDB(&dbp, dbid_observations))    {        return NULL;    }    memset(&entry, 0, sizeof(entry));    AGE++;    WAGE = AGE / SECONDS_PER_WEEK * CF_MEASURE_INTERVAL;    if (ReadDB(dbp, timekey, &entry, sizeof(Averages)))    {        int i;        for (i = 0; i < CF_OBSERVABLES; i++)        {            Log(LOG_LEVEL_DEBUG, "Previous values (%lf,..) for time index '%s'", entry.Q[i].expect, timekey);        }    }    else    {        Log(LOG_LEVEL_DEBUG, "No previous value for time index '%s'", timekey);    }    CloseDB(dbp);    return &entry;}

BOOL CMyDataBase::ReConnDB(){	CloseDB();	return ConnDB();}

void CloseAllDB(void)/* Closes all open DB handles */{ CF_DB *dbp = NULL;  int i = 0;Debug("CloseAllDB()/n");while (true)   {   if (!GetDBHandle(&dbp))      {      FatalError("CloseAllDB: Could not pop next DB handle");      }      if (dbp == NULL)      {      break;      }      if (!CloseDB(dbp))      {      CfOut(cf_error, "", "!! CloseAllDB: Could not close DB with this handle");      }      i++;   }Debug("Closed %d open DB handles/n", i);}

void test_iter_delete_entry(void **state){    /* Test that deleting entry under cursor does not interrupt iteration */    CF_DB *db;    assert_int_equal(OpenDB(&db, dbid_classes), true);    assert_int_equal(WriteDB(db, "foobar", "abc", 3), true);    assert_int_equal(WriteDB(db, "bazbaz", "def", 3), true);    assert_int_equal(WriteDB(db, "booo", "ghi", 3), true);    CF_DBC *cursor;    assert_int_equal(NewDBCursor(db, &cursor), true);    char *key;    int ksize;    void *value;    int vsize;    assert_int_equal(NextDB(db, cursor, &key, &ksize, &value, &vsize), true);    assert_int_equal(DBCursorDeleteEntry(cursor), true);    assert_int_equal(NextDB(db, cursor, &key, &ksize, &value, &vsize), true);    assert_int_equal(NextDB(db, cursor, &key, &ksize, &value, &vsize), true);    assert_int_equal(DeleteDBCursor(db, cursor), true);    CloseDB(db);}

	bool OpenDB()	{		CloseDB();		TDSCONNECTION* conn = NULL;		login = tds_alloc_login();		tds_set_app(login, "TSQL");		tds_set_library(login,"TDS-Library");		tds_set_host(login, "");		tds_set_server(login, host.host.c_str());		tds_set_server_addr(login, host.host.c_str());		tds_set_user(login, host.user.c_str());		tds_set_passwd(login, host.pass.c_str());		tds_set_port(login, host.port);		tds_set_packet(login, 512);		context = tds_alloc_context(this);		context->msg_handler = HandleMessage;		context->err_handler = HandleError;		sock = tds_alloc_socket(context, 512);		tds_set_parent(sock, NULL);		conn = tds_read_config_info(NULL, login, context->locale);		if (tds_connect(sock, conn) == TDS_SUCCEED)		{			tds_free_connection(conn);			return 1;		}		tds_free_connection(conn);		return 0;	}

bool RemoveHostFromLastSeen(const char *hostname, char *hostkey){    char ip[CF_BUFSIZE];    char digest[CF_BUFSIZE] = { 0 };    if (!hostkey)    {        strcpy(ip, Hostname2IPString(hostname));        IPString2KeyDigest(ip, digest);    }    else    {        snprintf(digest, sizeof(digest), "%s", hostkey);    }    CF_DB *dbp;    char key[CF_BUFSIZE];    if (!OpenDB(&dbp, dbid_lastseen))    {        CfOut(cf_error, "", " !! Unable to open last seen DB");        return false;    }    snprintf(key, CF_BUFSIZE, "-%s", digest);    DeleteComplexKeyDB(dbp, key, strlen(key) + 1);    snprintf(key, CF_BUFSIZE, "+%s", digest);    DeleteComplexKeyDB(dbp, key, strlen(key) + 1);    CloseDB(dbp);    return true;}

static void test_newentry(void **context){    setup();    UpdateLastSawHost("SHA-12345", "127.0.0.64", true, 666);    DBHandle *db;    OpenDB(&db, dbid_lastseen);    KeyHostSeen q;    assert_int_equal(ReadDB(db, "qiSHA-12345", &q, sizeof(q)), true);    assert_int_equal(q.lastseen, 666);    assert_double_close(q.Q.q, 0.0);    assert_double_close(q.Q.dq, 0.0);    assert_double_close(q.Q.expect, 0.0);    assert_double_close(q.Q.var, 0.0);    assert_int_equal(ReadDB(db, "qoSHA-12345", &q, sizeof(q)), false);    char address[CF_BUFSIZE];    assert_int_equal(ReadDB(db, "kSHA-12345", address, sizeof(address)), true);    assert_string_equal(address, "127.0.0.64");    char hostkey[CF_BUFSIZE];    assert_int_equal(ReadDB(db, "a127.0.0.64", hostkey, sizeof(hostkey)), true);    assert_string_equal(hostkey, "SHA-12345");    CloseDB(db);}

static void _MonUpload(const char *file, const char *metafile) {  DBG_Struct *dbg;  char *id,*buf;  size_t size;  if (!g_file_get_contents(file, &buf, &size, NULL)) {    g_warning("cannot read file:%s",file);    exit(1);  }  dbg = GetDBG_monsys();  dbg->dbt = NewNameHash();  if (OpenDB(dbg) != MCP_OK) {    g_warning("OpenDB failure");    exit(1);  }  monblob_setup(dbg, FALSE);  TransactionStart(dbg);  id = monblob_import_mem(dbg, NULL, 0, "monupload.bin", NULL, 0, buf, size);  g_free(buf);  TransactionEnd(dbg);  CloseDB(dbg);  AddMetaData(id, metafile);  xfree(id);}

bool Address2Hostkey(const char *address, char *result){    result[0] = '/0';    if ((strcmp(address, "127.0.0.1") == 0) || (strcmp(address, "::1") == 0) || (strcmp(address, VIPADDRESS) == 0))    {        if (PUBKEY)        {            unsigned char digest[EVP_MAX_MD_SIZE + 1];            HashPubKey(PUBKEY, digest, CF_DEFAULT_DIGEST);            HashPrintSafe(CF_DEFAULT_DIGEST, digest, result);            return true;        }        else        {            return false;        }    }    DBHandle *db;    if (!OpenDB(&db, dbid_lastseen))    {        return false;    }    bool ret = Address2HostkeyInDB(db, address, result);    CloseDB(db);    return ret;}

CAlljoynMob::~CAlljoynMob() {	if (m_pBus) {		delete m_pBus;		m_pBus = NULL;	}	CloseDB();}

	SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)	: ServerInstance(SI), mod(m), host(hi)	{		if (OpenDB() != SQLITE_OK)		{			ServerInstance->Logs->Log("m_sqlite3",DEFAULT, "WARNING: Could not open DB with id: " + host.id);			CloseDB();		}	}

/** * @brief removes all traces of host 'ip' from lastseen DB * * @param[in]     ip : either in (SHA/MD5 format) * @param[in,out] digest: return corresponding digest of input host. *                        If NULL, return nothing * @retval true if entry was deleted, false otherwise */bool DeleteIpFromLastSeen(const char *ip, char *digest){    DBHandle *db;    bool res = false;    if (!OpenDB(&db, dbid_lastseen))    {        Log(LOG_LEVEL_ERR, "Unable to open lastseen database");        return false;    }    char bufkey[CF_BUFSIZE + 1];    char bufhost[CF_BUFSIZE + 1];    strcpy(bufhost, "a");    strlcat(bufhost, ip, CF_BUFSIZE);    char key[CF_BUFSIZE];    if (ReadDB(db, bufhost, &key, sizeof(key)) == true)    {        strcpy(bufkey, "k");        strlcat(bufkey, key, CF_BUFSIZE);        if (HasKeyDB(db, bufkey, strlen(bufkey) + 1) == false)        {            res = false;            goto clean;        }        else        {            if (digest != NULL)            {                strcpy(digest, bufkey);            }            DeleteDB(db, bufkey);            DeleteDB(db, bufhost);            res = true;        }    }    else    {        res = false;        goto clean;    }    strcpy(bufkey, "qi");    strlcat(bufkey, key, CF_BUFSIZE);    DeleteDB(db, bufkey);    strcpy(bufkey, "qo");    strlcat(bufkey, key, CF_BUFSIZE);    DeleteDB(db, bufkey);clean:    CloseDB(db);    return res;}

void test_ignore_wrong_sized(void){    /* Test that malformed values are discarded */    DBHandle *db = setup(true);    const char *value = "+";    assert_int_equal(WriteDB(db, "+++", value, 2), true);    CloseDB(db);    assert_int_equal(OpenDB(&db, dbid_lastseen), true);    assert_int_equal(HasKeyDB(db, "+++", 4), false);    assert_int_equal(HasKeyDB(db, "k++", 4), false);    assert_int_equal(HasKeyDB(db, "qi++", 5), false);    assert_int_equal(HasKeyDB(db, "qo++", 5), false);    assert_int_equal(HasKeyDB(db, "a+", 3), false);    CloseDB(db);}

CADODB::~CADODB(){	try	{		CloseDB();	}	catch (...)	{		// ignore	}}

static void Mon_HistoryUpdate(time_t time, const Averages *newvals){ CF_DB *dbp;  if (!OpenDB(&dbp, dbid_history))    {    return;    }  PutRecordForTime(dbp, time, newvals); CloseDB(dbp);}

static void NotePerformance(char *eventname, time_t t, double value){    CF_DB *dbp;    Event e, newe;    double lastseen;    int lsea = SECONDS_PER_WEEK;    time_t now = time(NULL);    CfDebug("PerformanceEvent(%s,%.1f s)/n", eventname, value);    if (!OpenDB(&dbp, dbid_performance))    {        return;    }    if (ReadDB(dbp, eventname, &e, sizeof(e)))    {        lastseen = now - e.t;        newe.t = t;        newe.Q = QAverage(e.Q, value, 0.3);        /* Have to kickstart variance computation, assume 1% to start  */        if (newe.Q.var <= 0.0009)        {            newe.Q.var = newe.Q.expect / 100.0;        }    }    else    {        lastseen = 0.0;        newe.t = t;        newe.Q.q = value;        newe.Q.dq = 0;        newe.Q.expect = value;        newe.Q.var = 0.001;    }    if (lastseen > (double) lsea)    {        CfDebug("Performance record %s expired/n", eventname);        DeleteDB(dbp, eventname);    }    else    {        CfOut(cf_verbose, "", "Performance(%s): time=%.4lf secs, av=%.4lf +/- %.4lf/n", eventname, value, newe.Q.expect,              sqrt(newe.Q.var));        WriteDB(dbp, eventname, &newe, sizeof(newe));    }    CloseDB(dbp);}

void EvalContextHeapPersistentRemove(const char *context){    CF_DB *dbp;    if (!OpenDB(&dbp, dbid_state))    {        return;    }    DeleteDB(dbp, context);    CfDebug("Deleted any persistent state %s/n", context);    CloseDB(dbp);}

void EvalContextHeapPersistentRemove(const char *context){    CF_DB *dbp;    if (!OpenDB(&dbp, dbid_state))    {        return;    }    DeleteDB(dbp, context);    Log(LOG_LEVEL_DEBUG, "Deleted persistent class '%s'", context);    CloseDB(dbp);}

static void Mon_SaveFilePosition(char *name, long fileptr){ CF_DB *dbp;  if (!OpenDB(&dbp, dbid_static))    {    return;    }  Log(LOG_LEVEL_VERBOSE, "Saving state for %s at %ld", name, fileptr); WriteDB(dbp, name, &fileptr, sizeof(long)); CloseDB(dbp);}

static void test_up_to_date(void){    /* Test that upgrade is not performed if there is already a version     * marker */    DBHandle *db = setup(false);    assert_int_equal(WriteDB(db, "foo", &dummy_event, sizeof(dummy_event)), true);    CloseDB(db);    /* Test that manually inserted key still has unqalified name the next       time the DB is opened, which is an indicator of the DB not being       upgraded */    assert_int_equal(OpenDB(&db, dbid_bundles), true);    Event read_value;    assert_int_equal(ReadDB(db, "foo", &read_value, sizeof(read_value)), true);    assert_int_equal(read_value.t, 1);    CloseDB(db);}

void EvalContextHeapPersistentSave(const char *context, const char *ns, unsigned int ttl_minutes, ContextStatePolicy policy){    CF_DB *dbp;    CfState state;    time_t now = time(NULL);    char name[CF_BUFSIZE];    if (!OpenDB(&dbp, dbid_state))    {        return;    }    snprintf(name, CF_BUFSIZE, "%s%c%s", ns, CF_NS, context);        if (ReadDB(dbp, name, &state, sizeof(state)))    {        if (state.policy == CONTEXT_STATE_POLICY_PRESERVE)        {            if (now < state.expires)            {                CfOut(OUTPUT_LEVEL_VERBOSE, "", " -> Persisent state %s is already in a preserved state --  %jd minutes to go/n",                      name, (intmax_t)((state.expires - now) / 60));                CloseDB(dbp);                return;            }        }    }    else    {        CfOut(OUTPUT_LEVEL_VERBOSE, "", " -> New persistent state %s/n", name);    }    state.expires = now + ttl_minutes * 60;    state.policy = policy;    WriteDB(dbp, name, &state, sizeof(state));    CloseDB(dbp);}