bool eventlog_init_keys(void) { /* Find all of the eventlogs, add keys for each of them */ const char **elogs = lp_eventlog_list(); char *evtlogpath = NULL; char *evtfilepath = NULL; struct regsubkey_ctr *subkeys; REGVAL_CTR *values; uint32 uiMaxSize; uint32 uiRetention; uint32 uiCategoryCount; UNISTR2 data; TALLOC_CTX *ctx = talloc_tos(); WERROR werr; while (elogs && *elogs) { werr = regsubkey_ctr_init(ctx, &subkeys); if (!W_ERROR_IS_OK(werr)) { DEBUG( 0, ( "talloc() failure!\n" ) ); return False; } regdb_fetch_keys(KEY_EVENTLOG, subkeys); regsubkey_ctr_addkey( subkeys, *elogs ); if ( !regdb_store_keys( KEY_EVENTLOG, subkeys ) ) { TALLOC_FREE(subkeys); return False; } TALLOC_FREE(subkeys); /* add in the key of form KEY_EVENTLOG/Application */ DEBUG( 5, ( "Adding key of [%s] to path of [%s]\n", *elogs, KEY_EVENTLOG ) ); evtlogpath = talloc_asprintf(ctx, "%s\\%s", KEY_EVENTLOG, *elogs); if (!evtlogpath) { return false; } /* add in the key of form KEY_EVENTLOG/Application/Application */ DEBUG( 5, ( "Adding key of [%s] to path of [%s]\n", *elogs, evtlogpath ) ); werr = regsubkey_ctr_init(ctx, &subkeys); if (!W_ERROR_IS_OK(werr)) { DEBUG( 0, ( "talloc() failure!\n" ) ); return False; } regdb_fetch_keys( evtlogpath, subkeys ); regsubkey_ctr_addkey( subkeys, *elogs ); if ( !regdb_store_keys( evtlogpath, subkeys ) ) { TALLOC_FREE(subkeys); return False; } TALLOC_FREE( subkeys ); /* now add the values to the KEY_EVENTLOG/Application form key */ if (!(values = TALLOC_ZERO_P(ctx, REGVAL_CTR))) { DEBUG( 0, ( "talloc() failure!\n" ) ); return False; } DEBUG( 5, ( "Storing values to eventlog path of [%s]\n", evtlogpath ) ); regdb_fetch_values( evtlogpath, values ); if (!regval_ctr_key_exists(values, "MaxSize")) { /* assume we have none, add them all */ /* hard code some initial values */ /* uiDisplayNameId = 0x00000100; */ uiMaxSize = 0x00080000; uiRetention = 0x93A80; regval_ctr_addvalue(values, "MaxSize", REG_DWORD, (char *)&uiMaxSize, sizeof(uint32)); regval_ctr_addvalue(values, "Retention", REG_DWORD, (char *)&uiRetention, sizeof(uint32)); init_unistr2(&data, *elogs, UNI_STR_TERMINATE); regval_ctr_addvalue(values, "PrimaryModule", REG_SZ, (char *)data.buffer, data.uni_str_len * sizeof(uint16)); init_unistr2(&data, *elogs, UNI_STR_TERMINATE); regval_ctr_addvalue(values, "Sources", REG_MULTI_SZ, (char *)data.buffer, data.uni_str_len * sizeof(uint16)); evtfilepath = talloc_asprintf(ctx, "%%SystemRoot%%\\system32\\config\\%s.tdb", *elogs); if (!evtfilepath) { TALLOC_FREE(values); } init_unistr2(&data, evtfilepath, UNI_STR_TERMINATE); regval_ctr_addvalue(values, "File", REG_EXPAND_SZ, (char *)data.buffer, data.uni_str_len * sizeof(uint16)); regdb_store_values(evtlogpath, values); } TALLOC_FREE(values); /* now do the values under KEY_EVENTLOG/Application/Application */ TALLOC_FREE(evtlogpath); evtlogpath = talloc_asprintf(ctx, "%s\\%s\\%s", KEY_EVENTLOG, *elogs, *elogs); if (!evtlogpath) { return false; } if (!(values = TALLOC_ZERO_P(ctx, REGVAL_CTR))) { DEBUG( 0, ( "talloc() failure!\n" ) ); return False; } DEBUG( 5, ( "Storing values to eventlog path of [%s]\n", evtlogpath)); regdb_fetch_values(evtlogpath, values); if (!regval_ctr_key_exists( values, "CategoryCount")) { /* hard code some initial values */ uiCategoryCount = 0x00000007; regval_ctr_addvalue( values, "CategoryCount", REG_DWORD, ( char * ) &uiCategoryCount, sizeof( uint32 ) ); init_unistr2( &data, "%SystemRoot%\\system32\\eventlog.dll", UNI_STR_TERMINATE ); regval_ctr_addvalue( values, "CategoryMessageFile", REG_EXPAND_SZ, ( char * ) data.buffer, data.uni_str_len * sizeof( uint16 ) ); regdb_store_values( evtlogpath, values ); } TALLOC_FREE(values); elogs++; } return true; }
static BOOL init_registry_data( void ) { pstring path, base, remaining; fstring keyname, subkeyname; REGSUBKEY_CTR *subkeys; REGVAL_CTR *values; int i; const char *p, *p2; UNISTR2 data; /* * There are potentially quite a few store operations which are all * indiviually wrapped in tdb transactions. Wrapping them in a single * transaction gives just a single transaction_commit() to actually do * its fsync()s. See tdb/common/transaction.c for info about nested * transaction behaviour. */ if ( tdb_transaction_start( tdb_reg ) == -1 ) { DEBUG(0, ("init_registry_data: tdb_transaction_start " "failed\n")); return False; } /* loop over all of the predefined paths and add each component */ for ( i=0; builtin_registry_paths[i] != NULL; i++ ) { DEBUG(6,("init_registry_data: Adding [%s]\n", builtin_registry_paths[i])); pstrcpy( path, builtin_registry_paths[i] ); pstrcpy( base, "" ); p = path; while ( next_token(&p, keyname, "\\", sizeof(keyname)) ) { /* build up the registry path from the components */ if ( *base ) pstrcat( base, "\\" ); pstrcat( base, keyname ); /* get the immediate subkeyname (if we have one ) */ *subkeyname = '\0'; if ( *p ) { pstrcpy( remaining, p ); p2 = remaining; if ( !next_token(&p2, subkeyname, "\\", sizeof(subkeyname)) ) fstrcpy( subkeyname, p2 ); } DEBUG(10,("init_registry_data: Storing key [%s] with subkey [%s]\n", base, *subkeyname ? subkeyname : "NULL")); /* we don't really care if the lookup succeeds or not since we are about to update the record. We just want any subkeys already present */ if ( !(subkeys = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR )) ) { DEBUG(0,("talloc() failure!\n")); goto fail; } regdb_fetch_keys( base, subkeys ); if ( *subkeyname ) regsubkey_ctr_addkey( subkeys, subkeyname ); if ( !regdb_store_keys( base, subkeys )) goto fail; TALLOC_FREE( subkeys ); } } /* loop over all of the predefined values and add each component */ for ( i=0; builtin_registry_values[i].path != NULL; i++ ) { if ( !(values = TALLOC_ZERO_P( NULL, REGVAL_CTR )) ) { DEBUG(0,("talloc() failure!\n")); goto fail; } regdb_fetch_values( builtin_registry_values[i].path, values ); /* preserve existing values across restarts. Only add new ones */ if ( !regval_ctr_key_exists( values, builtin_registry_values[i].valuename ) ) { switch( builtin_registry_values[i].type ) { case REG_DWORD: regval_ctr_addvalue( values, builtin_registry_values[i].valuename, REG_DWORD, (char*)&builtin_registry_values[i].data.dw_value, sizeof(uint32) ); break; case REG_SZ: init_unistr2( &data, builtin_registry_values[i].data.string, UNI_STR_TERMINATE); regval_ctr_addvalue( values, builtin_registry_values[i].valuename, REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) ); break; default: DEBUG(0,("init_registry_data: invalid value type in builtin_registry_values [%d]\n", builtin_registry_values[i].type)); } regdb_store_values( builtin_registry_values[i].path, values ); } TALLOC_FREE( values ); } if (tdb_transaction_commit( tdb_reg ) == -1) { DEBUG(0, ("init_registry_data: Could not commit " "transaction\n")); return False; } return True; fail: if (tdb_transaction_cancel( tdb_reg ) == -1) { smb_panic("init_registry_data: tdb_transaction_cancel " "failed\n"); } return False; }