services_db.c

samba-3.0.22.tar.gz 编译smb服务器的源码

	
	if ( !(values = TALLOC_ZERO_P( key_service, REGVAL_CTR )) ) {
		DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
		regkey_close_internal( key_service );
		return;
	}

	fill_service_values( name, values );
	store_reg_values( key_service, values );

	/* cleanup the service key*/

	regkey_close_internal( key_service );

	/* now add the security descriptor */

	pstr_sprintf( path, "%s\\%s\\%s", KEY_SERVICES, name, "Security" );
	wresult = regkey_open_internal( &key_secdesc, path, get_root_nt_token(), 
		REG_KEY_ALL );
	if ( !W_ERROR_IS_OK(wresult) ) {
		DEBUG(0,("add_new_svc_name: key lookup failed! [%s] (%s)\n", 
			path, dos_errstr(wresult)));
		regkey_close_internal( key_secdesc );
		return;
	}

	if ( !(values = TALLOC_ZERO_P( key_secdesc, REGVAL_CTR )) ) {
		DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
		regkey_close_internal( key_secdesc );
		return;
	}

	if ( !(sd = construct_service_sd(key_secdesc)) ) {
		DEBUG(0,("add_new_svc_name: Failed to create default sec_desc!\n"));
		regkey_close_internal( key_secdesc );
		return;
	}
	
	/* stream the printer security descriptor */
	
	prs_init( &ps, RPC_MAX_PDU_FRAG_LEN, key_secdesc, MARSHALL);
	
	if ( sec_io_desc("sec_desc", &sd, &ps, 0 ) ) {
		uint32 offset = prs_offset( &ps );
		regval_ctr_addvalue( values, "Security", REG_BINARY, prs_data_p(&ps), offset );
		store_reg_values( key_secdesc, values );
	}
	
	/* finally cleanup the Security key */
	
	prs_mem_free( &ps );
	regkey_close_internal( key_secdesc );

	return;
}

/********************************************************************
********************************************************************/

void svcctl_init_keys( void )
{
	const char **service_list = lp_svcctl_list();
	int i;
	REGSUBKEY_CTR *subkeys;
	REGISTRY_KEY *key = NULL;
	WERROR wresult;
	
	/* bad mojo here if the lookup failed.  Should not happen */
	
	wresult = regkey_open_internal( &key, KEY_SERVICES, get_root_nt_token(), 
		REG_KEY_ALL );

	if ( !W_ERROR_IS_OK(wresult) ) {
		DEBUG(0,("init_services_keys: key lookup failed! (%s)\n", 
			dos_errstr(wresult)));
		return;
	}
	
	/* lookup the available subkeys */	
	
	if ( !(subkeys = TALLOC_ZERO_P( key, REGSUBKEY_CTR )) ) {
		DEBUG(0,("init_services_keys: talloc() failed!\n"));
		regkey_close_internal( key );
		return;
	}
	
	fetch_reg_keys( key, subkeys );
	
	/* the builting services exist */
	
	for ( i=0; builtin_svcs[i].servicename; i++ )
		add_new_svc_name( key, subkeys, builtin_svcs[i].servicename );
		
	for ( i=0; service_list && service_list[i]; i++ ) {
	
		/* only add new services */
		if ( regsubkey_ctr_key_exists( subkeys, service_list[i] ) )
			continue;

		/* Add the new service key and initialize the appropriate values */

		add_new_svc_name( key, subkeys, service_list[i] );
	}

	regkey_close_internal( key );

	/* initialize the control hooks */

	init_service_op_table();

	return;
}

/********************************************************************
 This is where we do the dirty work of filling in things like the
 Display name, Description, etc...Always return a default secdesc 
 in case of any failure.
********************************************************************/

SEC_DESC* svcctl_get_secdesc( TALLOC_CTX *ctx, const char *name, NT_USER_TOKEN *token )
{
	REGISTRY_KEY *key;
	prs_struct ps;
	REGVAL_CTR *values;
	REGISTRY_VALUE *val;
	SEC_DESC *sd = NULL;
	SEC_DESC *ret_sd = NULL;
	pstring path;
	WERROR wresult;
	
	/* now add the security descriptor */

	pstr_sprintf( path, "%s\\%s\\%s", KEY_SERVICES, name, "Security" );
	wresult = regkey_open_internal( &key, path, token, REG_KEY_ALL );
	if ( !W_ERROR_IS_OK(wresult) ) {
		DEBUG(0,("svcctl_get_secdesc: key lookup failed! [%s] (%s)\n", 
			path, dos_errstr(wresult)));
		return NULL;
	}

	if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
		DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
		regkey_close_internal( key );
		return NULL;
	}

	fetch_reg_values( key, values );
	
	if ( !(val = regval_ctr_getvalue( values, "Security" )) ) {
		DEBUG(6,("svcctl_get_secdesc: constructing default secdesc for service [%s]\n", 
			name));
		regkey_close_internal( key );
		return construct_service_sd( ctx );
	}
	

	/* stream the printer security descriptor */
	
	prs_init( &ps, 0, key, UNMARSHALL);
	prs_give_memory( &ps, (char *)regval_data_p(val), regval_size(val), False );
	
	if ( !sec_io_desc("sec_desc", &sd, &ps, 0 ) ) {
		regkey_close_internal( key );
		return construct_service_sd( ctx );
	}
	
	ret_sd = dup_sec_desc( ctx, sd );
	
	/* finally cleanup the Security key */
	
	prs_mem_free( &ps );
	regkey_close_internal( key );

	return ret_sd;
}

/********************************************************************
 Wrapper to make storing a Service sd easier
********************************************************************/

BOOL svcctl_set_secdesc( TALLOC_CTX *ctx, const char *name, SEC_DESC *sec_desc, NT_USER_TOKEN *token )
{
	REGISTRY_KEY *key;
	WERROR wresult;
	pstring path;
	REGVAL_CTR *values;
	prs_struct ps;
	BOOL ret = False;
	
	/* now add the security descriptor */

	pstr_sprintf( path, "%s\\%s\\%s", KEY_SERVICES, name, "Security" );
	wresult = regkey_open_internal( &key, path, token, REG_KEY_ALL );
	if ( !W_ERROR_IS_OK(wresult) ) {
		DEBUG(0,("svcctl_get_secdesc: key lookup failed! [%s] (%s)\n", 
			path, dos_errstr(wresult)));
		return False;
	}

	if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
		DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
		regkey_close_internal( key );
		return False;
	}
	
	/* stream the printer security descriptor */
	
	prs_init( &ps, RPC_MAX_PDU_FRAG_LEN, key, MARSHALL);
	
	if ( sec_io_desc("sec_desc", &sec_desc, &ps, 0 ) ) {
		uint32 offset = prs_offset( &ps );
		regval_ctr_addvalue( values, "Security", REG_BINARY, prs_data_p(&ps), offset );
		ret = store_reg_values( key, values );
	}
	
	/* cleanup */
	
	prs_mem_free( &ps );
	regkey_close_internal( key);

	return ret;
}

/********************************************************************
********************************************************************/

char* svcctl_lookup_dispname( const char *name, NT_USER_TOKEN *token )
{
	static fstring display_name;
	REGISTRY_KEY *key;
	REGVAL_CTR *values;
	REGISTRY_VALUE *val;
	pstring path;
	WERROR wresult;
	
	/* now add the security descriptor */

	pstr_sprintf( path, "%s\\%s", KEY_SERVICES, name );
	wresult = regkey_open_internal( &key, path, token, REG_KEY_READ );
	if ( !W_ERROR_IS_OK(wresult) ) {
		DEBUG(0,("svcctl_lookup_dispname: key lookup failed! [%s] (%s)\n", 
			path, dos_errstr(wresult)));
		goto fail;
	}

	if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
		DEBUG(0,("svcctl_lookup_dispname: talloc() failed!\n"));
		regkey_close_internal( key );
		goto fail;
	}

	fetch_reg_values( key, values );
	
	if ( !(val = regval_ctr_getvalue( values, "DisplayName" )) )
		goto fail;

	rpcstr_pull( display_name, regval_data_p(val), sizeof(display_name), regval_size(val), 0 );

	regkey_close_internal( key );
	
	return display_name;

fail:
	/* default to returning the service name */
	regkey_close_internal( key );
	fstrcpy( display_name, name );
	return display_name;
}

/********************************************************************
********************************************************************/

char* svcctl_lookup_description( const char *name, NT_USER_TOKEN *token )
{
	static fstring description;
	REGISTRY_KEY *key;
	REGVAL_CTR *values;
	REGISTRY_VALUE *val;
	pstring path;
	WERROR wresult;
	
	/* now add the security descriptor */

	pstr_sprintf( path, "%s\\%s", KEY_SERVICES, name );
	wresult = regkey_open_internal( &key, path, token, REG_KEY_READ );
	if ( !W_ERROR_IS_OK(wresult) ) {
		DEBUG(0,("svcctl_lookup_dispname: key lookup failed! [%s] (%s)\n", 
			path, dos_errstr(wresult)));
		return NULL;
	}

	if ( !(values = TALLOC_ZERO_P( key, REGVAL_CTR )) ) {
		DEBUG(0,("svcctl_lookup_dispname: talloc() failed!\n"));
		regkey_close_internal( key );
		return NULL;
	}

	fetch_reg_values( key, values );
	
	if ( !(val = regval_ctr_getvalue( values, "Description" )) )
		fstrcpy( description, "Unix Service");
	else
		rpcstr_pull( description, regval_data_p(val), sizeof(description), regval_size(val), 0 );

	regkey_close_internal( key );
	
	return description;
}


/********************************************************************
********************************************************************/

REGVAL_CTR* svcctl_fetch_regvalues( const char *name, NT_USER_TOKEN *token )
{
	REGISTRY_KEY *key;
	REGVAL_CTR *values;
	pstring path;
	WERROR wresult;
	
	/* now add the security descriptor */

	pstr_sprintf( path, "%s\\%s", KEY_SERVICES, name );
	wresult = regkey_open_internal( &key, path, token, REG_KEY_READ );
	if ( !W_ERROR_IS_OK(wresult) ) {
		DEBUG(0,("svcctl_fetch_regvalues: key lookup failed! [%s] (%s)\n", 
			path, dos_errstr(wresult)));
		return NULL;
	}

	if ( !(values = TALLOC_ZERO_P( NULL, REGVAL_CTR )) ) {
		DEBUG(0,("svcctl_fetch_regvalues: talloc() failed!\n"));
		regkey_close_internal( key );
		return NULL;
	}
	
	fetch_reg_values( key, values );

	regkey_close_internal( key );
	
	return values;
}