Using the standard macro makes it easier to move code into common, as
TALLOC_ZERO_P isn't standard talloc.
114 files changed:
- if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_request))) {
+ if (!(req = talloc_zero(mem_ctx, struct dns_request))) {
return ERROR_DNS_NO_MEMORY;
}
return ERROR_DNS_NO_MEMORY;
}
struct dns_question *q;
DNS_ERROR err;
struct dns_question *q;
DNS_ERROR err;
- if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_request)) ||
+ if (!(req = talloc_zero(mem_ctx, struct dns_request)) ||
!(req->questions = talloc_array(req, struct dns_question *, 1)) ||
!(req->questions[0] = talloc(req->questions,
struct dns_question))) {
!(req->questions = talloc_array(req, struct dns_question *, 1)) ||
!(req->questions[0] = talloc(req->questions,
struct dns_question))) {
struct dns_zone *z;
DNS_ERROR err;
struct dns_zone *z;
DNS_ERROR err;
- if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_update_request)) ||
+ if (!(req = talloc_zero(mem_ctx, struct dns_update_request)) ||
!(req->zones = talloc_array(req, struct dns_zone *, 1)) ||
!(req->zones[0] = talloc(req->zones, struct dns_zone))) {
TALLOC_FREE(req);
!(req->zones = talloc_array(req, struct dns_zone *, 1)) ||
!(req->zones[0] = talloc(req->zones, struct dns_zone))) {
TALLOC_FREE(req);
DNS_ERROR err;
uint16 len;
DNS_ERROR err;
uint16 len;
- if (!(buf = TALLOC_ZERO_P(mem_ctx, struct dns_buffer))) {
+ if (!(buf = talloc_zero(mem_ctx, struct dns_buffer))) {
return ERROR_DNS_NO_MEMORY;
}
return ERROR_DNS_NO_MEMORY;
}
struct dns_buffer *buf;
ssize_t received;
struct dns_buffer *buf;
ssize_t received;
- if (!(buf = TALLOC_ZERO_P(mem_ctx, struct dns_buffer))) {
+ if (!(buf = talloc_zero(mem_ctx, struct dns_buffer))) {
return ERROR_DNS_NO_MEMORY;
}
return ERROR_DNS_NO_MEMORY;
}
return ERROR_DNS_INVALID_NAME;
}
return ERROR_DNS_INVALID_NAME;
}
- if (!(result = TALLOC_ZERO_P(mem_ctx, struct dns_domain_label))) {
+ if (!(result = talloc_zero(mem_ctx, struct dns_domain_label))) {
return ERROR_DNS_NO_MEMORY;
}
return ERROR_DNS_NO_MEMORY;
}
NTSTATUS status;
struct gp_extension_reg_info_entry *entry = NULL;
NTSTATUS status;
struct gp_extension_reg_info_entry *entry = NULL;
- entry = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info_entry);
+ entry = talloc_zero(mem_ctx, struct gp_extension_reg_info_entry);
NT_STATUS_HAVE_NO_MEMORY(entry);
status = GUID_from_string(ext_guid, &entry->guid);
NT_STATUS_HAVE_NO_MEMORY(entry);
status = GUID_from_string(ext_guid, &entry->guid);
- new_gpo = TALLOC_ZERO_P(mem_ctx, struct GROUP_POLICY_OBJECT);
+ new_gpo = talloc_zero(mem_ctx, struct GROUP_POLICY_OBJECT);
ADS_ERROR_HAVE_NO_MEMORY(new_gpo);
status = ads_get_gpo(ads, mem_ctx, gp_link->link_names[i],
ADS_ERROR_HAVE_NO_MEMORY(new_gpo);
status = ads_get_gpo(ads, mem_ctx, gp_link->link_names[i],
ADS_ERROR_HAVE_NO_MEMORY(gpo_list);
ADS_ERROR_HAVE_NO_MEMORY(gpo_list);
- gpo = TALLOC_ZERO_P(mem_ctx, struct GROUP_POLICY_OBJECT);
+ gpo = talloc_zero(mem_ctx, struct GROUP_POLICY_OBJECT);
ADS_ERROR_HAVE_NO_MEMORY(gpo);
gpo->name = talloc_strdup(mem_ctx, "Local Policy");
ADS_ERROR_HAVE_NO_MEMORY(gpo);
gpo->name = talloc_strdup(mem_ctx, "Local Policy");
textdomain_init();
#endif
textdomain_init();
#endif
- r = TALLOC_ZERO_P(NULL, struct pwb_context);
+ r = talloc_zero(NULL, struct pwb_context);
if (!r) {
return PAM_BUF_ERR;
}
if (!r) {
return PAM_BUF_ERR;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct auth_methods *result;
{
struct auth_methods *result;
- result = TALLOC_ZERO_P(auth_context, struct auth_methods);
+ result = talloc_zero(auth_context, struct auth_methods);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
- info3 = TALLOC_ZERO_P(mem_ctx, struct netr_SamInfo3);
+ info3 = talloc_zero(mem_ctx, struct netr_SamInfo3);
if (info3 == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
if (info3 == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
{
struct auth_serversupplied_info *result;
{
struct auth_serversupplied_info *result;
- result = TALLOC_ZERO_P(mem_ctx, struct auth_serversupplied_info);
+ result = talloc_zero(mem_ctx, struct auth_serversupplied_info);
if (result == NULL) {
DEBUG(0, ("talloc failed\n"));
return NULL;
if (result == NULL) {
DEBUG(0, ("talloc failed\n"));
return NULL;
DEBUG(10, ("Create local NT token for %s\n",
sid_string_dbg(user_sid)));
DEBUG(10, ("Create local NT token for %s\n",
sid_string_dbg(user_sid)));
- if (!(result = TALLOC_ZERO_P(mem_ctx, struct security_token))) {
+ if (!(result = talloc_zero(mem_ctx, struct security_token))) {
DEBUG(0, ("talloc failed\n"));
return NULL;
}
DEBUG(0, ("talloc failed\n"));
return NULL;
}
#define TALLOC(ctx, size) talloc_named_const(ctx, size, __location__)
#define TALLOC_MEMDUP(ctx, ptr, size) _talloc_memdup(ctx, ptr, size, __location__)
#define TALLOC_ZERO(ctx, size) _talloc_zero(ctx, size, __location__)
#define TALLOC(ctx, size) talloc_named_const(ctx, size, __location__)
#define TALLOC_MEMDUP(ctx, ptr, size) _talloc_memdup(ctx, ptr, size, __location__)
#define TALLOC_ZERO(ctx, size) _talloc_zero(ctx, size, __location__)
-#define TALLOC_ZERO_P(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
#define TALLOC_ZERO_ARRAY(ctx, type, count) (type *)_talloc_zero_array(ctx, sizeof(type), count, #type)
#define TALLOC_SIZE(ctx, size) talloc_named_const(ctx, size, __location__)
#define TALLOC_ZERO_SIZE(ctx, size) _talloc_zero(ctx, size, __location__)
#define TALLOC_ZERO_ARRAY(ctx, type, count) (type *)_talloc_zero_array(ctx, sizeof(type), count, #type)
#define TALLOC_SIZE(ctx, size) talloc_named_const(ctx, size, __location__)
#define TALLOC_ZERO_SIZE(ctx, size) _talloc_zero(ctx, size, __location__)
{
struct ctdb_packet_context *result;
{
struct ctdb_packet_context *result;
- if (!(result = TALLOC_ZERO_P(mem_ctx, struct ctdb_packet_context))) {
+ if (!(result = talloc_zero(mem_ctx, struct ctdb_packet_context))) {
struct ctdbd_connection *conn;
NTSTATUS status;
struct ctdbd_connection *conn;
NTSTATUS status;
- if (!(conn = TALLOC_ZERO_P(mem_ctx, struct ctdbd_connection))) {
+ if (!(conn = talloc_zero(mem_ctx, struct ctdbd_connection))) {
DEBUG(0, ("talloc failed\n"));
return NT_STATUS_NO_MEMORY;
}
DEBUG(0, ("talloc failed\n"));
return NT_STATUS_NO_MEMORY;
}
- if (!(crec = TALLOC_ZERO_P(result, struct db_ctdb_rec))) {
+ if (!(crec = talloc_zero(result, struct db_ctdb_rec))) {
DEBUG(0, ("talloc failed\n"));
TALLOC_FREE(result);
return NULL;
DEBUG(0, ("talloc failed\n"));
TALLOC_FREE(result);
return NULL;
- if (!(result = TALLOC_ZERO_P(mem_ctx, struct db_context))) {
+ if (!(result = talloc_zero(mem_ctx, struct db_context))) {
DEBUG(0, ("talloc failed\n"));
TALLOC_FREE(result);
return NULL;
DEBUG(0, ("talloc failed\n"));
TALLOC_FREE(result);
return NULL;
struct db_context *result = NULL;
struct db_file_ctx *ctx;
struct db_context *result = NULL;
struct db_file_ctx *ctx;
- if (!(result = TALLOC_ZERO_P(mem_ctx, struct db_context))) {
+ if (!(result = talloc_zero(mem_ctx, struct db_context))) {
DEBUG(0, ("talloc failed\n"));
return NULL;
}
DEBUG(0, ("talloc failed\n"));
return NULL;
}
- result->private_data = TALLOC_ZERO_P(result, struct db_rbt_ctx);
+ result->private_data = talloc_zero(result, struct db_rbt_ctx);
if (result->private_data == NULL) {
TALLOC_FREE(result);
if (result->private_data == NULL) {
TALLOC_FREE(result);
struct db_context *result = NULL;
struct db_tdb_ctx *db_tdb;
struct db_context *result = NULL;
struct db_tdb_ctx *db_tdb;
- result = TALLOC_ZERO_P(mem_ctx, struct db_context);
+ result = talloc_zero(mem_ctx, struct db_context);
if (result == NULL) {
DEBUG(0, ("talloc failed\n"));
goto fail;
if (result == NULL) {
DEBUG(0, ("talloc failed\n"));
goto fail;
- if ( !(tdb_node = TALLOC_ZERO_P( NULL, ELOG_TDB)) ) {
+ if ( !(tdb_node = talloc_zero( NULL, ELOG_TDB)) ) {
DEBUG(0,("elog_open_tdb: talloc() failure!\n"));
tdb_close( tdb );
return NULL;
DEBUG(0,("elog_open_tdb: talloc() failure!\n"));
tdb_close( tdb );
return NULL;
state = (struct tevent_poll_private *)ev->additional_data;
if (state == NULL) {
state = (struct tevent_poll_private *)ev->additional_data;
if (state == NULL) {
- state = TALLOC_ZERO_P(ev, struct tevent_poll_private);
+ state = talloc_zero(ev, struct tevent_poll_private);
ev->additional_data = (void *)state;
if (state == NULL) {
DEBUG(10, ("talloc failed\n"));
ev->additional_data = (void *)state;
if (state == NULL) {
DEBUG(10, ("talloc failed\n"));
{
struct memcache *result;
{
struct memcache *result;
- result = TALLOC_ZERO_P(mem_ctx, struct memcache);
+ result = talloc_zero(mem_ctx, struct memcache);
if (result == NULL) {
return NULL;
}
if (result == NULL) {
return NULL;
}
struct messaging_context *ctx;
NTSTATUS status;
struct messaging_context *ctx;
NTSTATUS status;
- if (!(ctx = TALLOC_ZERO_P(mem_ctx, struct messaging_context))) {
+ if (!(ctx = talloc_zero(mem_ctx, struct messaging_context))) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_MEMORY;
}
- ctx = TALLOC_ZERO_P(result, struct messaging_tdb_context);
+ ctx = talloc_zero(result, struct messaging_tdb_context);
if (!ctx) {
DEBUG(0, ("talloc failed\n"));
TALLOC_FREE(result);
if (!ctx) {
DEBUG(0, ("talloc failed\n"));
TALLOC_FREE(result);
DATA_BLOB blob;
enum ndr_err_code ndr_err;
DATA_BLOB blob;
enum ndr_err_code ndr_err;
- if (!(result = TALLOC_ZERO_P(mem_ctx, struct messaging_array))) {
+ if (!(result = talloc_zero(mem_ctx, struct messaging_array))) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_MEMORY;
}
return WERR_CAN_NOT_COMPLETE;
}
return WERR_CAN_NOT_COMPLETE;
}
- p = TALLOC_ZERO_P(ctx, struct client_ipc_connection);
+ p = talloc_zero(ctx, struct client_ipc_connection);
if (p == NULL) {
return WERR_NOMEM;
}
if (p == NULL) {
return WERR_NOMEM;
}
struct LOCALGROUP_INFO_1002 *info1002;
union samr_AliasInfo *info = NULL;
struct LOCALGROUP_INFO_1002 *info1002;
union samr_AliasInfo *info = NULL;
- info = TALLOC_ZERO_P(mem_ctx, union samr_AliasInfo);
+ info = talloc_zero(mem_ctx, union samr_AliasInfo);
W_ERROR_HAVE_NO_MEMORY(info);
switch (level) {
W_ERROR_HAVE_NO_MEMORY(info);
switch (level) {
return W_ERROR_V(WERR_INVALID_PARAM);
}
return W_ERROR_V(WERR_INVALID_PARAM);
}
- priv = TALLOC_ZERO_P(ctx, struct libnetapi_private_ctx);
+ priv = talloc_zero(ctx, struct libnetapi_private_ctx);
if (!priv) {
return W_ERROR_V(WERR_NOMEM);
}
if (!priv) {
return W_ERROR_V(WERR_NOMEM);
}
- value = TALLOC_ZERO_P(tmp_ctx, struct registry_value);
+ value = talloc_zero(tmp_ctx, struct registry_value);
if (value == NULL) {
err = SBC_ERR_NOMEM;
goto done;
if (value == NULL) {
err = SBC_ERR_NOMEM;
goto done;
- ctx->data = TALLOC_ZERO_P(ctx, struct reg_private_data);
+ ctx->data = talloc_zero(ctx, struct reg_private_data);
werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
if (!W_ERROR_IS_OK(werr)) {
werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
if (!W_ERROR_IS_OK(werr)) {
- tmp_service = TALLOC_ZERO_P(tmp_ctx, struct smbconf_service);
+ tmp_service = talloc_zero(tmp_ctx, struct smbconf_service);
if (tmp_service == NULL) {
err = SBC_ERR_NOMEM;
goto done;
if (tmp_service == NULL) {
err = SBC_ERR_NOMEM;
goto done;
const char *location,
struct smbldap_state **smbldap_state)
{
const char *location,
struct smbldap_state **smbldap_state)
{
- *smbldap_state = TALLOC_ZERO_P(mem_ctx, struct smbldap_state);
+ *smbldap_state = talloc_zero(mem_ctx, struct smbldap_state);
if (!*smbldap_state) {
DEBUG(0, ("talloc() failed for ldapsam private_data!\n"));
return NT_STATUS_NO_MEMORY;
if (!*smbldap_state) {
DEBUG(0, ("talloc() failed for ldapsam private_data!\n"));
return NT_STATUS_NO_MEMORY;
{
struct user_auth_info *result;
{
struct user_auth_info *result;
- result = TALLOC_ZERO_P(mem_ctx, struct user_auth_info);
+ result = talloc_zero(mem_ctx, struct user_auth_info);
if (result == NULL) {
return NULL;
}
if (result == NULL) {
return NULL;
}
if (!ptoken)
return NULL;
if (!ptoken)
return NULL;
- token = TALLOC_ZERO_P(mem_ctx, struct security_token);
+ token = talloc_zero(mem_ctx, struct security_token);
if (token == NULL) {
DEBUG(0, ("talloc failed\n"));
return NULL;
if (token == NULL) {
DEBUG(0, ("talloc failed\n"));
return NULL;
return NT_STATUS_INVALID_PARAMETER;
}
return NT_STATUS_INVALID_PARAMETER;
}
- token = TALLOC_ZERO_P(mem_ctx, struct security_token);
+ token = talloc_zero(mem_ctx, struct security_token);
NT_STATUS_HAVE_NO_MEMORY(token);
for (i=0; i < token_1->num_sids; i++) {
NT_STATUS_HAVE_NO_MEMORY(token);
for (i=0; i < token_1->num_sids; i++) {
if (!in_val) return NULL;
if (!in_val) return NULL;
- value = TALLOC_ZERO_P(ctx, struct berval);
+ value = talloc_zero(ctx, struct berval);
if (value == NULL)
return NULL;
if (in_val->bv_len == 0) return value;
if (value == NULL)
return NULL;
if (in_val->bv_len == 0) return value;
*mods = (ADS_MODLIST)modlist;
}
*mods = (ADS_MODLIST)modlist;
}
- if (!(modlist[curmod] = TALLOC_ZERO_P(ctx, LDAPMod)))
+ if (!(modlist[curmod] = talloc_zero(ctx, LDAPMod)))
return ADS_ERROR(LDAP_NO_MEMORY);
modlist[curmod]->mod_type = talloc_strdup(ctx, name);
if (mod_op & LDAP_MOD_BVALUES) {
return ADS_ERROR(LDAP_NO_MEMORY);
modlist[curmod]->mod_type = talloc_strdup(ctx, name);
if (mod_op & LDAP_MOD_BVALUES) {
ZERO_STRUCTP(*reg_entry);
ZERO_STRUCTP(*reg_entry);
- data = TALLOC_ZERO_P(mem_ctx, struct registry_value);
+ data = talloc_zero(mem_ctx, struct registry_value);
if (!data)
return false;
data->type = r->type;
data->data = data_blob_talloc(data, r->data, r->size);
if (!data)
return false;
data->type = r->type;
data->data = data_blob_talloc(data, r->data, r->size);
- entry = TALLOC_ZERO_P(mem_ctx, struct gp_registry_entry);
+ entry = talloc_zero(mem_ctx, struct gp_registry_entry);
if (!entry)
return false;
if (!entry)
return false;
{ NULL, REG_NONE, NULL }
};
{ NULL, REG_NONE, NULL }
};
- info = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info);
+ info = talloc_zero(mem_ctx, struct gp_extension_reg_info);
NT_STATUS_HAVE_NO_MEMORY(info);
status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
NT_STATUS_HAVE_NO_MEMORY(info);
status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
{ NULL, REG_NONE, NULL },
};
{ NULL, REG_NONE, NULL },
};
- info = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info);
+ info = talloc_zero(mem_ctx, struct gp_extension_reg_info);
NT_STATUS_HAVE_NO_MEMORY(info);
status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
NT_STATUS_HAVE_NO_MEMORY(info);
status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
struct gp_registry_entry *entry = NULL;
struct registry_value *data = NULL;
struct gp_registry_entry *entry = NULL;
struct registry_value *data = NULL;
- entry = TALLOC_ZERO_P(mem_ctx, struct gp_registry_entry);
+ entry = talloc_zero(mem_ctx, struct gp_registry_entry);
NT_STATUS_HAVE_NO_MEMORY(entry);
NT_STATUS_HAVE_NO_MEMORY(entry);
- data = TALLOC_ZERO_P(mem_ctx, struct registry_value);
+ data = talloc_zero(mem_ctx, struct registry_value);
NT_STATUS_HAVE_NO_MEMORY(data);
data->type = data_type;
NT_STATUS_HAVE_NO_MEMORY(data);
data->type = data_type;
{ NULL, REG_NONE, NULL }
};
{ NULL, REG_NONE, NULL }
};
- info = TALLOC_ZERO_P(mem_ctx, struct gp_extension_reg_info);
+ info = talloc_zero(mem_ctx, struct gp_extension_reg_info);
NT_STATUS_HAVE_NO_MEMORY(info);
status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
NT_STATUS_HAVE_NO_MEMORY(info);
status = gp_ext_info_add_entry(mem_ctx, GP_EXT_NAME,
{
struct security_token *token = NULL;
{
struct security_token *token = NULL;
- token = TALLOC_ZERO_P(mem_ctx, struct security_token);
+ token = talloc_zero(mem_ctx, struct security_token);
if (!token) {
DEBUG(1,("talloc failed\n"));
return NULL;
if (!token) {
DEBUG(1,("talloc failed\n"));
return NULL;
- tmp_ctx = TALLOC_ZERO_P(mem_ctx, struct gp_registry_context);
+ tmp_ctx = talloc_zero(mem_ctx, struct gp_registry_context);
W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
if (token) {
W_ERROR_HAVE_NO_MEMORY(tmp_ctx);
if (token) {
int num_token_sids = 0;
struct security_token *tmp_token = NULL;
int num_token_sids = 0;
struct security_token *tmp_token = NULL;
- tmp_token = TALLOC_ZERO_P(mem_ctx, struct security_token);
+ tmp_token = talloc_zero(mem_ctx, struct security_token);
W_ERROR_HAVE_NO_MEMORY(tmp_token);
path = gp_reg_groupmembership_path(mem_ctx, object_sid, flags);
W_ERROR_HAVE_NO_MEMORY(tmp_token);
path = gp_reg_groupmembership_path(mem_ctx, object_sid, flags);
return WERR_INVALID_PARAM;
}
return WERR_INVALID_PARAM;
}
- gpo = TALLOC_ZERO_P(mem_ctx, struct GROUP_POLICY_OBJECT);
+ gpo = talloc_zero(mem_ctx, struct GROUP_POLICY_OBJECT);
W_ERROR_HAVE_NO_MEMORY(gpo);
werr = gp_read_reg_gpovals(mem_ctx, key, gpo);
W_ERROR_HAVE_NO_MEMORY(gpo);
werr = gp_read_reg_gpovals(mem_ctx, key, gpo);
{
struct dssync_context *ctx;
{
struct dssync_context *ctx;
- ctx = TALLOC_ZERO_P(mem_ctx, struct dssync_context);
+ ctx = talloc_zero(mem_ctx, struct dssync_context);
NT_STATUS_HAVE_NO_MEMORY(ctx);
talloc_set_destructor(ctx, libnet_dssync_free_context);
NT_STATUS_HAVE_NO_MEMORY(ctx);
talloc_set_destructor(ctx, libnet_dssync_free_context);
- nc = TALLOC_ZERO_P(mem_ctx, struct drsuapi_DsReplicaObjectIdentifier);
+ nc = talloc_zero(mem_ctx, struct drsuapi_DsReplicaObjectIdentifier);
if (!nc) {
status = NT_STATUS_NO_MEMORY;
goto fail;
if (!nc) {
status = NT_STATUS_NO_MEMORY;
goto fail;
if (!ctx->single_object_replication &&
!ctx->force_full_replication && utdv)
{
if (!ctx->single_object_replication &&
!ctx->force_full_replication && utdv)
{
- cursors = TALLOC_ZERO_P(mem_ctx,
+ cursors = talloc_zero(mem_ctx,
struct drsuapi_DsReplicaCursorCtrEx);
if (!cursors) {
status = NT_STATUS_NO_MEMORY;
struct drsuapi_DsReplicaCursorCtrEx);
if (!cursors) {
status = NT_STATUS_NO_MEMORY;
struct dcerpc_binding_handle *b = ctx->cli->binding_handle;
if (!ctx->single_object_replication) {
struct dcerpc_binding_handle *b = ctx->cli->binding_handle;
if (!ctx->single_object_replication) {
- new_utdv = TALLOC_ZERO_P(mem_ctx, struct replUpToDateVectorBlob);
+ new_utdv = talloc_zero(mem_ctx, struct replUpToDateVectorBlob);
if (!new_utdv) {
status = NT_STATUS_NO_MEMORY;
goto out;
if (!new_utdv) {
status = NT_STATUS_NO_MEMORY;
goto out;
- pkb = TALLOC_ZERO_P(mem_ctx, struct package_PrimaryKerberosBlob);
+ pkb = talloc_zero(mem_ctx, struct package_PrimaryKerberosBlob);
if (!pkb) {
status = NT_STATUS_NO_MEMORY;
goto done;
if (!pkb) {
status = NT_STATUS_NO_MEMORY;
goto done;
struct libnet_keytab_context *r;
struct libnet_keytab_context *r;
- r = TALLOC_ZERO_P(mem_ctx, struct libnet_keytab_context);
+ r = talloc_zero(mem_ctx, struct libnet_keytab_context);
if (!r) {
return ENOMEM;
}
if (!r) {
return ENOMEM;
}
- ctx = TALLOC_ZERO_P(mem_ctx, struct samsync_context);
+ ctx = talloc_zero(mem_ctx, struct samsync_context);
NT_STATUS_HAVE_NO_MEMORY(ctx);
if (domain_sid) {
NT_STATUS_HAVE_NO_MEMORY(ctx);
if (domain_sid) {
- str = TALLOC_ZERO_P(mem_ctx, struct netr_AcctLockStr);
+ str = talloc_zero(mem_ctx, struct netr_AcctLockStr);
if (!str) {
return NT_STATUS_NO_MEMORY;
}
if (!str) {
return NT_STATUS_NO_MEMORY;
}
- r = TALLOC_ZERO_P(mem_ctx, struct samsync_ldif_context);
+ r = talloc_zero(mem_ctx, struct samsync_ldif_context);
NT_STATUS_HAVE_NO_MEMORY(r);
/* Get the ldap suffix */
NT_STATUS_HAVE_NO_MEMORY(r);
/* Get the ldap suffix */
blob = p.smb.body.trans.data;
blob = p.smb.body.trans.data;
- r = TALLOC_ZERO_P(mem_ctx, struct netlogon_samlogon_response);
+ r = talloc_zero(mem_ctx, struct netlogon_samlogon_response);
if (!r) {
return false;
}
if (!r) {
return false;
}
- cli = TALLOC_ZERO_P(NULL, struct cli_state);
+ cli = talloc_zero(NULL, struct cli_state);
if (!cli) {
return NULL;
}
if (!cli) {
return NULL;
}
- if ((tmp_list_ent=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
+ if ((tmp_list_ent=talloc_zero(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
DEBUG(0,("TALLOC_ZERO() failed\n"));
talloc_destroy(mem_ctx);
return NT_STATUS_NO_MEMORY;
}
DEBUG(0,("TALLOC_ZERO() failed\n"));
talloc_destroy(mem_ctx);
return NT_STATUS_NO_MEMORY;
}
- if ((tmp_list_ent->quotas=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
+ if ((tmp_list_ent->quotas=talloc_zero(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
DEBUG(0,("TALLOC_ZERO() failed\n"));
talloc_destroy(mem_ctx);
return NT_STATUS_NO_MEMORY;
DEBUG(0,("TALLOC_ZERO() failed\n"));
talloc_destroy(mem_ctx);
return NT_STATUS_NO_MEMORY;
- if ((tmp_list_ent=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
+ if ((tmp_list_ent=talloc_zero(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
DEBUG(0,("TALLOC_ZERO() failed\n"));
talloc_destroy(mem_ctx);
goto cleanup;
}
DEBUG(0,("TALLOC_ZERO() failed\n"));
talloc_destroy(mem_ctx);
goto cleanup;
}
- if ((tmp_list_ent->quotas=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
+ if ((tmp_list_ent->quotas=talloc_zero(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
DEBUG(0,("TALLOC_ZERO() failed\n"));
talloc_destroy(mem_ctx);
goto cleanup;
DEBUG(0,("TALLOC_ZERO() failed\n"));
talloc_destroy(mem_ctx);
goto cleanup;
return NT_STATUS_NOT_FOUND;
}
return NT_STATUS_NOT_FOUND;
}
- info = TALLOC_ZERO_P(mem_ctx, struct netr_DsRGetDCNameInfo);
+ info = talloc_zero(mem_ctx, struct netr_DsRGetDCNameInfo);
if (!info) {
return NT_STATUS_NO_MEMORY;
}
if (!info) {
return NT_STATUS_NO_MEMORY;
}
{
struct netr_DsRGetDCNameInfo *info;
{
struct netr_DsRGetDCNameInfo *info;
- info = TALLOC_ZERO_P(mem_ctx, struct netr_DsRGetDCNameInfo);
+ info = talloc_zero(mem_ctx, struct netr_DsRGetDCNameInfo);
NT_STATUS_HAVE_NO_MEMORY(info);
if (dc_unc) {
NT_STATUS_HAVE_NO_MEMORY(info);
if (dc_unc) {
{
struct NETLOGON_SAM_LOGON_RESPONSE_NT40 logon1;
{
struct NETLOGON_SAM_LOGON_RESPONSE_NT40 logon1;
- r = TALLOC_ZERO_P(mem_ctx, struct netlogon_samlogon_response);
+ r = talloc_zero(mem_ctx, struct netlogon_samlogon_response);
NT_STATUS_HAVE_NO_MEMORY(r);
ZERO_STRUCT(logon1);
NT_STATUS_HAVE_NO_MEMORY(r);
ZERO_STRUCT(logon1);
- info3 = TALLOC_ZERO_P(mem_ctx, struct netr_SamInfo3);
+ info3 = talloc_zero(mem_ctx, struct netr_SamInfo3);
if (!info3) {
goto done;
}
if (!info3) {
goto done;
}
struct tevent_fd *fde;
NTSTATUS status;
struct tevent_fd *fde;
NTSTATUS status;
- result = TALLOC_ZERO_P(mem_ctx, struct nb_packet_server);
+ result = talloc_zero(mem_ctx, struct nb_packet_server);
if (result == NULL) {
status = NT_STATUS_NO_MEMORY;
goto fail;
if (result == NULL) {
status = NT_STATUS_NO_MEMORY;
goto fail;
}
DEBUG(6,("accepted socket %d\n", sock));
}
DEBUG(6,("accepted socket %d\n", sock));
- client = TALLOC_ZERO_P(server, struct nb_packet_client);
+ client = talloc_zero(server, struct nb_packet_client);
if (client == NULL) {
DEBUG(10, ("talloc failed\n"));
close(sock);
if (client == NULL) {
DEBUG(10, ("talloc failed\n"));
close(sock);
- state = TALLOC_ZERO_P(client, struct nb_packet_client_state);
+ state = talloc_zero(client, struct nb_packet_client_state);
if (state == NULL) {
DEBUG(10, ("talloc failed\n"));
return;
if (state == NULL) {
DEBUG(10, ("talloc failed\n"));
return;
state->query.mailslot_namelen = strlen(mailslot_name);
}
state->query.mailslot_namelen = strlen(mailslot_name);
}
- state->reader = TALLOC_ZERO_P(state, struct nb_packet_reader);
+ state->reader = talloc_zero(state, struct nb_packet_reader);
if (tevent_req_nomem(state->reader, req)) {
return tevent_req_post(req, ev);
}
if (tevent_req_nomem(state->reader, req)) {
return tevent_req_post(req, ev);
}
uint32 i;
struct server_id last_pid;
uint32 i;
struct server_id last_pid;
- if (!(state = TALLOC_ZERO_P(NULL, struct brl_revalidate_state))) {
+ if (!(state = talloc_zero(NULL, struct brl_revalidate_state))) {
DEBUG(0, ("talloc failed\n"));
return;
}
DEBUG(0, ("talloc failed\n"));
return;
}
- pdtl = TALLOC_ZERO_P(lck, struct delete_token_list);
+ pdtl = talloc_zero(lck, struct delete_token_list);
if (pdtl == NULL) {
DEBUG(0,("parse_delete_tokens_list: talloc failed"));
return -1;
if (pdtl == NULL) {
DEBUG(0,("parse_delete_tokens_list: talloc failed"));
return -1;
memcpy(&pdtl->name_hash, p, sizeof(pdtl->name_hash));
p += sizeof(pdtl->name_hash);
memcpy(&pdtl->name_hash, p, sizeof(pdtl->name_hash));
p += sizeof(pdtl->name_hash);
- pdtl->delete_token = TALLOC_ZERO_P(pdtl, struct security_unix_token);
+ pdtl->delete_token = talloc_zero(pdtl, struct security_unix_token);
if (pdtl->delete_token == NULL) {
DEBUG(0,("parse_delete_tokens_list: talloc failed"));
return -1;
if (pdtl->delete_token == NULL) {
DEBUG(0,("parse_delete_tokens_list: talloc failed"));
return -1;
{
struct delete_token_list *dtl;
{
struct delete_token_list *dtl;
- dtl = TALLOC_ZERO_P(lck, struct delete_token_list);
+ dtl = talloc_zero(lck, struct delete_token_list);
if (dtl == NULL) {
return false;
}
if (dtl == NULL) {
return false;
}
- data = TALLOC_ZERO_P(NULL, struct aio_child_list);
+ data = talloc_zero(NULL, struct aio_child_list);
if (data == NULL) {
return NULL;
}
if (data == NULL) {
return NULL;
}
fdpair[0] = fdpair[1] = -1;
fdpair[0] = fdpair[1] = -1;
- result = TALLOC_ZERO_P(children, struct aio_child);
+ result = talloc_zero(children, struct aio_child);
NT_STATUS_HAVE_NO_MEMORY(result);
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fdpair) == -1) {
NT_STATUS_HAVE_NO_MEMORY(result);
if (socketpair(AF_UNIX, SOCK_STREAM, 0, fdpair) == -1) {
- pd = TALLOC_ZERO_P(handle, struct vfs_full_audit_private_data);
+ pd = talloc_zero(handle, struct vfs_full_audit_private_data);
if (!pd) {
SMB_VFS_NEXT_DISCONNECT(handle);
return -1;
if (!pd) {
SMB_VFS_NEXT_DISCONNECT(handle);
return -1;
rf_sock->ref_count++;
} else {
/* New connection. */
rf_sock->ref_count++;
} else {
/* New connection. */
- rf_sock = TALLOC_ZERO_P(NULL, struct refcounted_sock);
+ rf_sock = talloc_zero(NULL, struct refcounted_sock);
if (rf_sock == NULL) {
SMB_VFS_NEXT_DISCONNECT(handle);
errno = ENOMEM;
if (rf_sock == NULL) {
SMB_VFS_NEXT_DISCONNECT(handle);
errno = ENOMEM;
- tsmd = TALLOC_ZERO_P(handle, struct tsmsm_struct);
+ tsmd = talloc_zero(handle, struct tsmsm_struct);
if (!tsmd) {
SMB_VFS_NEXT_DISCONNECT(handle);
DEBUG(0,("tsmsm_connect: out of memory!\n"));
if (!tsmd) {
SMB_VFS_NEXT_DISCONNECT(handle);
DEBUG(0,("tsmsm_connect: out of memory!\n"));
enum ndr_err_code ndr_err;
struct tdb_xattrs *result;
enum ndr_err_code ndr_err;
struct tdb_xattrs *result;
- if (!(result = TALLOC_ZERO_P(mem_ctx, struct tdb_xattrs))) {
+ if (!(result = talloc_zero(mem_ctx, struct tdb_xattrs))) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_MEMORY;
}
fstring source_name;
struct dgram_packet *dgram = &p->packet.dgram;
fstring source_name;
struct dgram_packet *dgram = &p->packet.dgram;
- state = TALLOC_ZERO_P(ctx, struct nmbd_proxy_logon_state);
+ state = talloc_zero(ctx, struct nmbd_proxy_logon_state);
if (!state) {
DEBUG(0,("failed to allocate nmbd_proxy_logon_state\n"));
return;
if (!state) {
DEBUG(0,("failed to allocate nmbd_proxy_logon_state\n"));
return;
- if ( !(user = TALLOC_ZERO_P( ctx, struct samu )) ) {
+ if ( !(user = talloc_zero( ctx, struct samu )) ) {
DEBUG(0,("samuser_new: Talloc failed!\n"));
return NULL;
}
DEBUG(0,("samuser_new: Talloc failed!\n"));
return NULL;
}
/* TODO: Setup private data and free */
/* TODO: Setup private data and free */
- if ( !(ldap_state = TALLOC_ZERO_P(*pdb_method, struct ldapsam_privates)) ) {
+ if ( !(ldap_state = talloc_zero(*pdb_method, struct ldapsam_privates)) ) {
DEBUG(0, ("pdb_init_ldapsam_common: talloc() failed for ldapsam private_data!\n"));
return NT_STATUS_NO_MEMORY;
}
DEBUG(0, ("pdb_init_ldapsam_common: talloc() failed for ldapsam private_data!\n"));
return NT_STATUS_NO_MEMORY;
}
/* Setup private data and free function */
/* Setup private data and free function */
- if ( !(privates = TALLOC_ZERO_P( *pdb_method, struct smbpasswd_privates )) ) {
+ if ( !(privates = talloc_zero( *pdb_method, struct smbpasswd_privates )) ) {
DEBUG(0, ("talloc() failed for smbpasswd private_data!\n"));
return NT_STATUS_NO_MEMORY;
}
DEBUG(0, ("talloc() failed for smbpasswd private_data!\n"));
return NT_STATUS_NO_MEMORY;
}
}
/* Setup a synthetic smb_filename struct */
}
/* Setup a synthetic smb_filename struct */
- smb_fname_new = TALLOC_ZERO_P(mem_ctx, struct smb_filename);
+ smb_fname_new = talloc_zero(mem_ctx, struct smb_filename);
if (!smb_fname_new) {
ret = WERR_NOMEM;
goto out;
if (!smb_fname_new) {
ret = WERR_NOMEM;
goto out;
SMB_ASSERT(strchr(name, '\\') == NULL);
SMB_ASSERT(strchr(name, '\\') == NULL);
- if (!(regkey = TALLOC_ZERO_P(mem_ctx, struct registry_key)) ||
+ if (!(regkey = talloc_zero(mem_ctx, struct registry_key)) ||
!(regkey->token = dup_nt_token(regkey, token)) ||
!(regkey->token = dup_nt_token(regkey, token)) ||
- !(regkey->key = TALLOC_ZERO_P(regkey, struct registry_key_handle)))
+ !(regkey->key = talloc_zero(regkey, struct registry_key_handle)))
{
result = WERR_NOMEM;
goto done;
{
result = WERR_NOMEM;
goto done;
context for internal private data.
There is no longer a regval_ctr_intit() and regval_ctr_destroy()
context for internal private data.
There is no longer a regval_ctr_intit() and regval_ctr_destroy()
- pair of functions. Simply TALLOC_ZERO_P() and TALLOC_FREE() the
+ pair of functions. Simply talloc_zero() and TALLOC_FREE() the
object.
**********************************************************************/
object.
**********************************************************************/
return NT_STATUS_INVALID_PARAMETER;
}
return NT_STATUS_INVALID_PARAMETER;
}
- token = TALLOC_ZERO_P(mem_ctx, struct security_token);
+ token = talloc_zero(mem_ctx, struct security_token);
if (token == NULL) {
DEBUG(1, ("talloc failed\n"));
status = NT_STATUS_NO_MEMORY;
if (token == NULL) {
DEBUG(1, ("talloc failed\n"));
status = NT_STATUS_NO_MEMORY;
REGF_HBIN *hbin;
uint32 record_size, curr_off, block_size, header;
REGF_HBIN *hbin;
uint32 record_size, curr_off, block_size, header;
- if ( !(hbin = TALLOC_ZERO_P(file->mem_ctx, REGF_HBIN)) )
+ if ( !(hbin = talloc_zero(file->mem_ctx, REGF_HBIN)) )
return NULL;
hbin->file_off = offset;
hbin->free_off = -1;
return NULL;
hbin->file_off = offset;
hbin->free_off = -1;
- if ( !(nk->sec_desc = TALLOC_ZERO_P( file->mem_ctx, REGF_SK_REC )) )
+ if ( !(nk->sec_desc = talloc_zero( file->mem_ctx, REGF_SK_REC )) )
return False;
nk->sec_desc->sk_off = nk->sk_off;
if ( !hbin_prs_sk_rec( "sk_rec", sub_hbin, depth, nk->sec_desc ))
return False;
nk->sec_desc->sk_off = nk->sk_off;
if ( !hbin_prs_sk_rec( "sk_rec", sub_hbin, depth, nk->sec_desc ))
if ( !file )
return NULL;
if ( !file )
return NULL;
- if ( !(nk = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) ) {
+ if ( !(nk = talloc_zero( file->mem_ctx, REGF_NK_REC )) ) {
DEBUG(0,("regfio_rootkey: talloc() failed!\n"));
return NULL;
}
DEBUG(0,("regfio_rootkey: talloc() failed!\n"));
return NULL;
}
return NULL;
nk->subkey_index++;
return NULL;
nk->subkey_index++;
- if ( !(subkey = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) )
+ if ( !(subkey = talloc_zero( file->mem_ctx, REGF_NK_REC )) )
return NULL;
if ( !hbin_prs_key( file, hbin, subkey ) )
return NULL;
if ( !hbin_prs_key( file, hbin, subkey ) )
REGF_HBIN *hbin;
SMB_STRUCT_STAT sbuf;
REGF_HBIN *hbin;
SMB_STRUCT_STAT sbuf;
- if ( !(hbin = TALLOC_ZERO_P( file->mem_ctx, REGF_HBIN )) )
+ if ( !(hbin = talloc_zero( file->mem_ctx, REGF_HBIN )) )
return NULL;
memcpy( hbin->header, "hbin", sizeof(HBIN_HDR_SIZE) );
return NULL;
memcpy( hbin->header, "hbin", sizeof(HBIN_HDR_SIZE) );
REGF_HBIN *vlist_hbin = NULL;
uint32 size;
REGF_HBIN *vlist_hbin = NULL;
uint32 size;
- if ( !(nk = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) )
+ if ( !(nk = talloc_zero( file->mem_ctx, REGF_NK_REC )) )
return NULL;
memcpy( nk->header, "nk", REC_HDR_SIZE );
return NULL;
memcpy( nk->header, "nk", REC_HDR_SIZE );
- if ( !(nk->sec_desc = TALLOC_ZERO_P( file->mem_ctx, REGF_SK_REC )) )
+ if ( !(nk->sec_desc = talloc_zero( file->mem_ctx, REGF_SK_REC )) )
return NULL;
/* now we have to store the security descriptor in the list and
return NULL;
/* now we have to store the security descriptor in the list and
- logon = TALLOC_ZERO_P(mem_ctx, union netr_LogonLevel);
+ logon = talloc_zero(mem_ctx, union netr_LogonLevel);
if (!logon) {
return NT_STATUS_NO_MEMORY;
}
if (!logon) {
return NT_STATUS_NO_MEMORY;
}
struct samr_Password lmpassword;
struct samr_Password ntpassword;
struct samr_Password lmpassword;
struct samr_Password ntpassword;
- password_info = TALLOC_ZERO_P(mem_ctx, struct netr_PasswordInfo);
+ password_info = talloc_zero(mem_ctx, struct netr_PasswordInfo);
if (!password_info) {
return NT_STATUS_NO_MEMORY;
}
if (!password_info) {
return NT_STATUS_NO_MEMORY;
}
ZERO_STRUCT(lm);
ZERO_STRUCT(nt);
ZERO_STRUCT(lm);
ZERO_STRUCT(nt);
- network_info = TALLOC_ZERO_P(mem_ctx, struct netr_NetworkInfo);
+ network_info = talloc_zero(mem_ctx, struct netr_NetworkInfo);
if (!network_info) {
return NT_STATUS_NO_MEMORY;
}
if (!network_info) {
return NT_STATUS_NO_MEMORY;
}
ZERO_STRUCT(lm);
ZERO_STRUCT(nt);
ZERO_STRUCT(lm);
ZERO_STRUCT(nt);
- logon = TALLOC_ZERO_P(mem_ctx, union netr_LogonLevel);
+ logon = talloc_zero(mem_ctx, union netr_LogonLevel);
if (!logon) {
return NT_STATUS_NO_MEMORY;
}
if (!logon) {
return NT_STATUS_NO_MEMORY;
}
- network_info = TALLOC_ZERO_P(mem_ctx, struct netr_NetworkInfo);
+ network_info = talloc_zero(mem_ctx, struct netr_NetworkInfo);
if (!network_info) {
return NT_STATUS_NO_MEMORY;
}
if (!network_info) {
return NT_STATUS_NO_MEMORY;
}
ZERO_STRUCT(lm);
ZERO_STRUCT(nt);
ZERO_STRUCT(lm);
ZERO_STRUCT(nt);
- logon = TALLOC_ZERO_P(mem_ctx, union netr_LogonLevel);
+ logon = talloc_zero(mem_ctx, union netr_LogonLevel);
if (!logon) {
return NT_STATUS_NO_MEMORY;
}
if (!logon) {
return NT_STATUS_NO_MEMORY;
}
- network_info = TALLOC_ZERO_P(mem_ctx, struct netr_NetworkInfo);
+ network_info = talloc_zero(mem_ctx, struct netr_NetworkInfo);
if (!network_info) {
return NT_STATUS_NO_MEMORY;
}
if (!network_info) {
return NT_STATUS_NO_MEMORY;
}
- result = TALLOC_ZERO_P(mem_ctx, struct rpc_pipe_client);
+ result = talloc_zero(mem_ctx, struct rpc_pipe_client);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
/* create tower for asking the epmapper */
/* create tower for asking the epmapper */
- map_binding = TALLOC_ZERO_P(tmp_ctx, struct dcerpc_binding);
+ map_binding = talloc_zero(tmp_ctx, struct dcerpc_binding);
if (map_binding == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
if (map_binding == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
map_binding->host = host; /* needed? */
map_binding->endpoint = "0"; /* correct? needed? */
map_binding->host = host; /* needed? */
map_binding->endpoint = "0"; /* correct? needed? */
- map_tower = TALLOC_ZERO_P(tmp_ctx, struct epm_twr_t);
+ map_tower = talloc_zero(tmp_ctx, struct epm_twr_t);
if (map_tower == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
if (map_tower == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
}
towers.twr = res_towers;
}
towers.twr = res_towers;
- entry_handle = TALLOC_ZERO_P(tmp_ctx, struct policy_handle);
+ entry_handle = talloc_zero(tmp_ctx, struct policy_handle);
if (entry_handle == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
if (entry_handle == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
return NT_STATUS_INVALID_HANDLE;
}
return NT_STATUS_INVALID_HANDLE;
}
- result = TALLOC_ZERO_P(NULL, struct rpc_pipe_client);
+ result = talloc_zero(NULL, struct rpc_pipe_client);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
return WERR_ACCESS_DENIED;
}
return WERR_ACCESS_DENIED;
}
- jn = TALLOC_ZERO_P(ctx, struct junction_map);
+ jn = talloc_zero(ctx, struct junction_map);
if (!jn) {
return WERR_NOMEM;
}
if (!jn) {
return WERR_NOMEM;
}
return WERR_ACCESS_DENIED;
}
return WERR_ACCESS_DENIED;
}
- jn = TALLOC_ZERO_P(ctx, struct junction_map);
+ jn = talloc_zero(ctx, struct junction_map);
if (!jn) {
return WERR_NOMEM;
}
if (!jn) {
return WERR_NOMEM;
}
TALLOC_CTX *ctx = talloc_tos();
bool ret;
TALLOC_CTX *ctx = talloc_tos();
bool ret;
- jn = TALLOC_ZERO_P(ctx, struct junction_map);
+ jn = talloc_zero(ctx, struct junction_map);
if (!jn) {
return WERR_NOMEM;
}
if (!jn) {
return WERR_NOMEM;
}
switch (r->in.level) {
case 1:
switch (r->in.level) {
case 1:
- r->out.info->info1 = TALLOC_ZERO_P(ctx,struct dfs_Info1);
+ r->out.info->info1 = talloc_zero(ctx,struct dfs_Info1);
if (!r->out.info->info1) {
return WERR_NOMEM;
}
ret = init_reply_dfs_info_1(ctx, jn, r->out.info->info1);
break;
case 2:
if (!r->out.info->info1) {
return WERR_NOMEM;
}
ret = init_reply_dfs_info_1(ctx, jn, r->out.info->info1);
break;
case 2:
- r->out.info->info2 = TALLOC_ZERO_P(ctx,struct dfs_Info2);
+ r->out.info->info2 = talloc_zero(ctx,struct dfs_Info2);
if (!r->out.info->info2) {
return WERR_NOMEM;
}
ret = init_reply_dfs_info_2(ctx, jn, r->out.info->info2);
break;
case 3:
if (!r->out.info->info2) {
return WERR_NOMEM;
}
ret = init_reply_dfs_info_2(ctx, jn, r->out.info->info2);
break;
case 3:
- r->out.info->info3 = TALLOC_ZERO_P(ctx,struct dfs_Info3);
+ r->out.info->info3 = talloc_zero(ctx,struct dfs_Info3);
if (!r->out.info->info3) {
return WERR_NOMEM;
}
ret = init_reply_dfs_info_3(ctx, jn, r->out.info->info3);
break;
case 100:
if (!r->out.info->info3) {
return WERR_NOMEM;
}
ret = init_reply_dfs_info_3(ctx, jn, r->out.info->info3);
break;
case 100:
- r->out.info->info100 = TALLOC_ZERO_P(ctx,struct dfs_Info100);
+ r->out.info->info100 = talloc_zero(ctx,struct dfs_Info100);
if (!r->out.info->info100) {
return WERR_NOMEM;
}
if (!r->out.info->info100) {
return WERR_NOMEM;
}
DEBUG(10,("fill_dsrole_dominfo_basic: enter\n"));
DEBUG(10,("fill_dsrole_dominfo_basic: enter\n"));
- basic = TALLOC_ZERO_P(ctx, struct dssetup_DsRolePrimaryDomInfoBasic);
+ basic = talloc_zero(ctx, struct dssetup_DsRolePrimaryDomInfoBasic);
if (!basic) {
DEBUG(0,("fill_dsrole_dominfo_basic: out of memory\n"));
return WERR_NOMEM;
if (!basic) {
DEBUG(0,("fill_dsrole_dominfo_basic: out of memory\n"));
return WERR_NOMEM;
if ( !elog_validate_logname( logname ) )
return NT_STATUS_OBJECT_PATH_INVALID;
if ( !elog_validate_logname( logname ) )
return NT_STATUS_OBJECT_PATH_INVALID;
- if ( !(elog = TALLOC_ZERO_P( NULL, EVENTLOG_INFO )) )
+ if ( !(elog = talloc_zero( NULL, EVENTLOG_INFO )) )
return NT_STATUS_NO_MEMORY;
talloc_set_destructor(elog, eventlog_info_destructor);
return NT_STATUS_NO_MEMORY;
talloc_set_destructor(elog, eventlog_info_destructor);
/* return NT_STATUS_ACCESS_DENIED; */
}
/* return NT_STATUS_ACCESS_DENIED; */
}
- info = TALLOC_ZERO_P(p->mem_ctx, union lsa_PolicyInformation);
+ info = talloc_zero(p->mem_ctx, union lsa_PolicyInformation);
if (!info) {
return NT_STATUS_NO_MEMORY;
}
if (!info) {
return NT_STATUS_NO_MEMORY;
}
}
sids = talloc_array(p->mem_ctx, const struct dom_sid *, num_sids);
}
sids = talloc_array(p->mem_ctx, const struct dom_sid *, num_sids);
- ref = TALLOC_ZERO_P(p->mem_ctx, struct lsa_RefDomainList);
+ ref = talloc_zero(p->mem_ctx, struct lsa_RefDomainList);
if (sids == NULL || ref == NULL) {
return NT_STATUS_NO_MEMORY;
if (sids == NULL || ref == NULL) {
return NT_STATUS_NO_MEMORY;
flags = lsa_lookup_level_to_flags(r->in.level);
flags = lsa_lookup_level_to_flags(r->in.level);
- domains = TALLOC_ZERO_P(p->mem_ctx, struct lsa_RefDomainList);
+ domains = talloc_zero(p->mem_ctx, struct lsa_RefDomainList);
if (!domains) {
return NT_STATUS_NO_MEMORY;
}
if (!domains) {
return NT_STATUS_NO_MEMORY;
}
struct lsa_TransSidArray *sid_array = NULL;
uint32_t i;
struct lsa_TransSidArray *sid_array = NULL;
uint32_t i;
- sid_array = TALLOC_ZERO_P(p->mem_ctx, struct lsa_TransSidArray);
+ sid_array = talloc_zero(p->mem_ctx, struct lsa_TransSidArray);
if (!sid_array) {
return NT_STATUS_NO_MEMORY;
}
if (!sid_array) {
return NT_STATUS_NO_MEMORY;
}
flags = LOOKUP_NAME_ALL;
}
flags = LOOKUP_NAME_ALL;
}
- domains = TALLOC_ZERO_P(p->mem_ctx, struct lsa_RefDomainList);
+ domains = talloc_zero(p->mem_ctx, struct lsa_RefDomainList);
if (!domains) {
return NT_STATUS_NO_MEMORY;
}
if (!domains) {
return NT_STATUS_NO_MEMORY;
}
- info = TALLOC_ZERO_P(p->mem_ctx, union lsa_TrustedDomainInfo);
+ info = talloc_zero(p->mem_ctx, union lsa_TrustedDomainInfo);
if (!info) {
return NT_STATUS_NO_MEMORY;
}
if (!info) {
return NT_STATUS_NO_MEMORY;
}
DEBUG(10,("_lsa_LookupPrivDisplayName: display name = %s\n", description));
DEBUG(10,("_lsa_LookupPrivDisplayName: display name = %s\n", description));
- lsa_name = TALLOC_ZERO_P(p->mem_ctx, struct lsa_StringLarge);
+ lsa_name = talloc_zero(p->mem_ctx, struct lsa_StringLarge);
if (!lsa_name) {
return NT_STATUS_NO_MEMORY;
}
if (!lsa_name) {
return NT_STATUS_NO_MEMORY;
}
- *r->out.privs = priv_set = TALLOC_ZERO_P(p->mem_ctx, struct lsa_PrivilegeSet);
+ *r->out.privs = priv_set = talloc_zero(p->mem_ctx, struct lsa_PrivilegeSet);
if (!priv_set) {
return NT_STATUS_NO_MEMORY;
}
if (!priv_set) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_SUCH_PRIVILEGE;
}
return NT_STATUS_NO_SUCH_PRIVILEGE;
}
- lsa_name = TALLOC_ZERO_P(p->mem_ctx, struct lsa_StringLarge);
+ lsa_name = talloc_zero(p->mem_ctx, struct lsa_StringLarge);
if (!lsa_name) {
return NT_STATUS_NO_MEMORY;
}
if (!lsa_name) {
return NT_STATUS_NO_MEMORY;
}
switch (r->in.level) {
case 1:
switch (r->in.level) {
case 1:
- info1 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_1);
+ info1 = talloc_zero(p->mem_ctx, struct netr_NETLOGON_INFO_1);
W_ERROR_HAVE_NO_MEMORY(info1);
info1->flags = flags;
W_ERROR_HAVE_NO_MEMORY(info1);
info1->flags = flags;
r->out.query->info1 = info1;
break;
case 2:
r->out.query->info1 = info1;
break;
case 2:
- info2 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_2);
+ info2 = talloc_zero(p->mem_ctx, struct netr_NETLOGON_INFO_2);
W_ERROR_HAVE_NO_MEMORY(info2);
info2->flags = flags;
W_ERROR_HAVE_NO_MEMORY(info2);
info2->flags = flags;
r->out.query->info2 = info2;
break;
case 3:
r->out.query->info2 = info2;
break;
case 3:
- info3 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_3);
+ info3 = talloc_zero(p->mem_ctx, struct netr_NETLOGON_INFO_3);
W_ERROR_HAVE_NO_MEMORY(info3);
info3->flags = flags;
W_ERROR_HAVE_NO_MEMORY(info3);
info3->flags = flags;
r->out.query->info3 = info3;
break;
case 4:
r->out.query->info3 = info3;
break;
case 4:
- info4 = TALLOC_ZERO_P(p->mem_ctx, struct netr_NETLOGON_INFO_4);
+ info4 = talloc_zero(p->mem_ctx, struct netr_NETLOGON_INFO_4);
W_ERROR_HAVE_NO_MEMORY(info4);
info4->trusted_dc_name = dc_name;
W_ERROR_HAVE_NO_MEMORY(info4);
info4->trusted_dc_name = dc_name;
switch (r->in.validation_level) {
case 2:
switch (r->in.validation_level) {
case 2:
- r->out.validation->sam2 = TALLOC_ZERO_P(p->mem_ctx, struct netr_SamInfo2);
+ r->out.validation->sam2 = talloc_zero(p->mem_ctx, struct netr_SamInfo2);
if (!r->out.validation->sam2) {
return NT_STATUS_NO_MEMORY;
}
break;
case 3:
if (!r->out.validation->sam2) {
return NT_STATUS_NO_MEMORY;
}
break;
case 3:
- r->out.validation->sam3 = TALLOC_ZERO_P(p->mem_ctx, struct netr_SamInfo3);
+ r->out.validation->sam3 = talloc_zero(p->mem_ctx, struct netr_SamInfo3);
if (!r->out.validation->sam3) {
return NT_STATUS_NO_MEMORY;
}
break;
case 6:
if (!r->out.validation->sam3) {
return NT_STATUS_NO_MEMORY;
}
break;
case 6:
- r->out.validation->sam6 = TALLOC_ZERO_P(p->mem_ctx, struct netr_SamInfo6);
+ r->out.validation->sam6 = talloc_zero(p->mem_ctx, struct netr_SamInfo6);
if (!r->out.validation->sam6) {
return NT_STATUS_NO_MEMORY;
}
if (!r->out.validation->sam6) {
return NT_STATUS_NO_MEMORY;
}
DEBUG(4,("Create pipe requested %s\n",
get_pipe_name_from_syntax(talloc_tos(), syntax)));
DEBUG(4,("Create pipe requested %s\n",
get_pipe_name_from_syntax(talloc_tos(), syntax)));
- p = TALLOC_ZERO_P(mem_ctx, struct pipes_struct);
+ p = talloc_zero(mem_ctx, struct pipes_struct);
if (!p) {
DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
if (!p) {
DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
struct rpc_pipe_client *result;
NTSTATUS status;
struct rpc_pipe_client *result;
NTSTATUS status;
- result = TALLOC_ZERO_P(mem_ctx, struct rpc_pipe_client);
+ result = talloc_zero(mem_ctx, struct rpc_pipe_client);
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (result == NULL) {
return NT_STATUS_NO_MEMORY;
}
- samr_array = TALLOC_ZERO_P(p->mem_ctx, struct samr_SamArray);
+ samr_array = talloc_zero(p->mem_ctx, struct samr_SamArray);
if (!samr_array) {
return NT_STATUS_NO_MEMORY;
}
if (!samr_array) {
return NT_STATUS_NO_MEMORY;
}
DEBUG(5,("_samr_EnumDomainGroups: %d\n", __LINE__));
DEBUG(5,("_samr_EnumDomainGroups: %d\n", __LINE__));
- samr_array = TALLOC_ZERO_P(p->mem_ctx, struct samr_SamArray);
+ samr_array = talloc_zero(p->mem_ctx, struct samr_SamArray);
if (!samr_array) {
return NT_STATUS_NO_MEMORY;
}
if (!samr_array) {
return NT_STATUS_NO_MEMORY;
}
DEBUG(5,("_samr_EnumDomainAliases: sid %s\n",
sid_string_dbg(&dinfo->sid)));
DEBUG(5,("_samr_EnumDomainAliases: sid %s\n",
sid_string_dbg(&dinfo->sid)));
- samr_array = TALLOC_ZERO_P(p->mem_ctx, struct samr_SamArray);
+ samr_array = talloc_zero(p->mem_ctx, struct samr_SamArray);
if (!samr_array) {
return NT_STATUS_NO_MEMORY;
}
if (!samr_array) {
return NT_STATUS_NO_MEMORY;
}
- alias_info = TALLOC_ZERO_P(p->mem_ctx, union samr_AliasInfo);
+ alias_info = talloc_zero(p->mem_ctx, union samr_AliasInfo);
if (!alias_info) {
return NT_STATUS_NO_MEMORY;
}
if (!alias_info) {
return NT_STATUS_NO_MEMORY;
}
time_t u_expire, u_min_age;
uint32 account_policy_temp;
time_t u_expire, u_min_age;
uint32 account_policy_temp;
- dominfo = TALLOC_ZERO_P(p->mem_ctx, struct samr_DomInfo1);
+ dominfo = talloc_zero(p->mem_ctx, struct samr_DomInfo1);
if (!dominfo) {
return NT_STATUS_NO_MEMORY;
}
if (!dominfo) {
return NT_STATUS_NO_MEMORY;
}
- reject = TALLOC_ZERO_P(p->mem_ctx,
+ reject = talloc_zero(p->mem_ctx,
struct userPwdChangeFailureInformation);
if (!reject) {
return NT_STATUS_NO_MEMORY;
struct userPwdChangeFailureInformation);
if (!reject) {
return NT_STATUS_NO_MEMORY;
return NT_STATUS_INVALID_PARAMETER;
}
return NT_STATUS_INVALID_PARAMETER;
}
- r = TALLOC_ZERO_P(mem_ctx, struct lsa_BinaryString);
+ r = talloc_zero(mem_ctx, struct lsa_BinaryString);
if (!r) {
return NT_STATUS_NO_MEMORY;
}
if (!r) {
return NT_STATUS_NO_MEMORY;
}
DEBUG(5,("_samr_QueryUserInfo: sid:%s\n",
sid_string_dbg(&uinfo->sid)));
DEBUG(5,("_samr_QueryUserInfo: sid:%s\n",
sid_string_dbg(&uinfo->sid)));
- user_info = TALLOC_ZERO_P(p->mem_ctx, union samr_UserInfo);
+ user_info = talloc_zero(p->mem_ctx, union samr_UserInfo);
if (!user_info) {
return NT_STATUS_NO_MEMORY;
}
if (!user_info) {
return NT_STATUS_NO_MEMORY;
}
- rids = TALLOC_ZERO_P(p->mem_ctx, struct samr_RidWithAttributeArray);
+ rids = talloc_zero(p->mem_ctx, struct samr_RidWithAttributeArray);
if (!rids) {
return NT_STATUS_NO_MEMORY;
}
if (!rids) {
return NT_STATUS_NO_MEMORY;
}
- dom_info = TALLOC_ZERO_P(p->mem_ctx, union samr_DomainInfo);
+ dom_info = talloc_zero(p->mem_ctx, union samr_DomainInfo);
if (!dom_info) {
return NT_STATUS_NO_MEMORY;
}
if (!dom_info) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_INVALID_PARAMETER;
}
return NT_STATUS_INVALID_PARAMETER;
}
- sid = TALLOC_ZERO_P(p->mem_ctx, struct dom_sid2);
+ sid = talloc_zero(p->mem_ctx, struct dom_sid2);
if (!sid) {
return NT_STATUS_NO_MEMORY;
}
if (!sid) {
return NT_STATUS_NO_MEMORY;
}
- sam = TALLOC_ZERO_P(p->mem_ctx, struct samr_SamArray);
+ sam = talloc_zero(p->mem_ctx, struct samr_SamArray);
if (!sam) {
return NT_STATUS_NO_MEMORY;
}
if (!sam) {
return NT_STATUS_NO_MEMORY;
}
- rids = TALLOC_ZERO_P(p->mem_ctx, struct samr_RidAttrArray);
+ rids = talloc_zero(p->mem_ctx, struct samr_RidAttrArray);
if (!rids) {
return NT_STATUS_NO_MEMORY;
}
if (!rids) {
return NT_STATUS_NO_MEMORY;
}
group_name = talloc_strdup(r, map.nt_name);
group_description = talloc_strdup(r, map.comment);
group_name = talloc_strdup(r, map.nt_name);
group_description = talloc_strdup(r, map.comment);
- info = TALLOC_ZERO_P(p->mem_ctx, union samr_GroupInfo);
+ info = talloc_zero(p->mem_ctx, union samr_GroupInfo);
if (!info) {
return NT_STATUS_NO_MEMORY;
}
if (!info) {
return NT_STATUS_NO_MEMORY;
}
alloc_entries = num_entries - resume_handle;
switch (info_ctr->level) {
case 0:
alloc_entries = num_entries - resume_handle;
switch (info_ctr->level) {
case 0:
- ctr.ctr0 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr0);
+ ctr.ctr0 = talloc_zero(ctx, struct srvsvc_NetShareCtr0);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr0);
ctr.ctr0->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr0);
ctr.ctr0->count = alloc_entries;
- ctr.ctr1 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1);
+ ctr.ctr1 = talloc_zero(ctx, struct srvsvc_NetShareCtr1);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1);
ctr.ctr1->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1);
ctr.ctr1->count = alloc_entries;
- ctr.ctr2 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr2);
+ ctr.ctr2 = talloc_zero(ctx, struct srvsvc_NetShareCtr2);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr2);
ctr.ctr2->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr2);
ctr.ctr2->count = alloc_entries;
- ctr.ctr501 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr501);
+ ctr.ctr501 = talloc_zero(ctx, struct srvsvc_NetShareCtr501);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr501);
ctr.ctr501->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr501);
ctr.ctr501->count = alloc_entries;
- ctr.ctr502 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr502);
+ ctr.ctr502 = talloc_zero(ctx, struct srvsvc_NetShareCtr502);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr502);
ctr.ctr502->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr502);
ctr.ctr502->count = alloc_entries;
- ctr.ctr1004 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1004);
+ ctr.ctr1004 = talloc_zero(ctx, struct srvsvc_NetShareCtr1004);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1004);
ctr.ctr1004->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1004);
ctr.ctr1004->count = alloc_entries;
- ctr.ctr1005 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1005);
+ ctr.ctr1005 = talloc_zero(ctx, struct srvsvc_NetShareCtr1005);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1005);
ctr.ctr1005->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1005);
ctr.ctr1005->count = alloc_entries;
- ctr.ctr1006 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1006);
+ ctr.ctr1006 = talloc_zero(ctx, struct srvsvc_NetShareCtr1006);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1006);
ctr.ctr1006->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1006);
ctr.ctr1006->count = alloc_entries;
- ctr.ctr1007 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1007);
+ ctr.ctr1007 = talloc_zero(ctx, struct srvsvc_NetShareCtr1007);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1007);
ctr.ctr1007->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1007);
ctr.ctr1007->count = alloc_entries;
- ctr.ctr1501 = TALLOC_ZERO_P(ctx, struct srvsvc_NetShareCtr1501);
+ ctr.ctr1501 = talloc_zero(ctx, struct srvsvc_NetShareCtr1501);
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1501);
ctr.ctr1501->count = alloc_entries;
W_ERROR_HAVE_NO_MEMORY(ctr.ctr1501);
ctr.ctr1501->count = alloc_entries;
DEBUG(5,("_srvsvc_NetRemoteTOD: %d\n", __LINE__));
DEBUG(5,("_srvsvc_NetRemoteTOD: %d\n", __LINE__));
- if ( !(tod = TALLOC_ZERO_P(p->mem_ctx, struct srvsvc_NetRemoteTODInfo)) )
+ if ( !(tod = talloc_zero(p->mem_ctx, struct srvsvc_NetRemoteTODInfo)) )
return WERR_NOMEM;
*r->out.info = tod;
return WERR_NOMEM;
*r->out.info = tod;
sd_size = ndr_size_security_descriptor(psd, 0);
sd_size = ndr_size_security_descriptor(psd, 0);
- sd_buf = TALLOC_ZERO_P(p->mem_ctx, struct sec_desc_buf);
+ sd_buf = talloc_zero(p->mem_ctx, struct sec_desc_buf);
if (!sd_buf) {
werr = WERR_NOMEM;
goto error_exit;
if (!sd_buf) {
werr = WERR_NOMEM;
goto error_exit;
WERROR result = WERR_OK;
struct service_control_op *s_op;
WERROR result = WERR_OK;
struct service_control_op *s_op;
- if ( !(info = TALLOC_ZERO_P( NULL, SERVICE_INFO )) )
+ if ( !(info = talloc_zero( NULL, SERVICE_INFO )) )
return WERR_NOMEM;
/* the Service Manager has a NULL name */
return WERR_NOMEM;
/* the Service Manager has a NULL name */
files_struct *fsp,
size_t buflen)
{
files_struct *fsp,
size_t buflen)
{
- struct aio_extra *aio_ex = TALLOC_ZERO_P(mem_ctx, struct aio_extra);
+ struct aio_extra *aio_ex = talloc_zero(mem_ctx, struct aio_extra);
if (!aio_ex) {
return NULL;
if (!aio_ex) {
return NULL;
if (sconn->using_smb2) {
/* SMB2 */
if (sconn->using_smb2) {
/* SMB2 */
- if (!(conn=TALLOC_ZERO_P(NULL, connection_struct)) ||
+ if (!(conn=talloc_zero(NULL, connection_struct)) ||
!(conn->params = talloc(conn, struct share_params))) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
TALLOC_FREE(conn);
!(conn->params = talloc(conn, struct share_params))) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
TALLOC_FREE(conn);
- if (!(conn=TALLOC_ZERO_P(NULL, connection_struct)) ||
+ if (!(conn=talloc_zero(NULL, connection_struct)) ||
!(conn->params = talloc(conn, struct share_params))) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
TALLOC_FREE(conn);
!(conn->params = talloc(conn, struct share_params))) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
TALLOC_FREE(conn);
const char *mask,
uint32 attr)
{
const char *mask,
uint32 attr)
{
- struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
+ struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
struct smbd_server_connection *sconn = conn->sconn;
if (!dirp) {
struct smbd_server_connection *sconn = conn->sconn;
if (!dirp) {
const char *mask,
uint32 attr)
{
const char *mask,
uint32 attr)
{
- struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
+ struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
struct smbd_server_connection *sconn = conn->sconn;
if (!dirp) {
struct smbd_server_connection *sconn = conn->sconn;
if (!dirp) {
TALLOC_FREE(smbd_msg_state);
TALLOC_FREE(smbd_msg_state);
- smbd_msg_state = TALLOC_ZERO_P(NULL, struct msg_state);
+ smbd_msg_state = talloc_zero(NULL, struct msg_state);
if (smbd_msg_state == NULL) {
reply_nterror(req, NT_STATUS_NO_MEMORY);
if (smbd_msg_state == NULL) {
reply_nterror(req, NT_STATUS_NO_MEMORY);
char *oldcwd;
const char *vfs_user;
char *oldcwd;
const char *vfs_user;
- conn = TALLOC_ZERO_P(ctx, connection_struct);
+ conn = talloc_zero(ctx, connection_struct);
if (conn == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (conn == NULL) {
return NT_STATUS_NO_MEMORY;
}
/* needed for smbd_vfs_init() */
/* needed for smbd_vfs_init() */
- if (!(conn->params = TALLOC_ZERO_P(conn, struct share_params))) {
+ if (!(conn->params = talloc_zero(conn, struct share_params))) {
DEBUG(0, ("TALLOC failed\n"));
TALLOC_FREE(conn);
return NT_STATUS_NO_MEMORY;
DEBUG(0, ("TALLOC failed\n"));
TALLOC_FREE(conn);
return NT_STATUS_NO_MEMORY;
*self_referralp = True;
jucn->referral_count = 1;
*self_referralp = True;
jucn->referral_count = 1;
- if((ref = TALLOC_ZERO_P(ctx, struct referral)) == NULL) {
+ if((ref = talloc_zero(ctx, struct referral)) == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_MEMORY;
}
*/
jucn->referral_count = 1;
*/
jucn->referral_count = 1;
- if ((ref = TALLOC_ZERO_P(ctx, struct referral)) == NULL) {
+ if ((ref = talloc_zero(ctx, struct referral)) == NULL) {
TALLOC_FREE(pdp);
return NT_STATUS_NO_MEMORY;
}
TALLOC_FREE(pdp);
return NT_STATUS_NO_MEMORY;
}
- junction = TALLOC_ZERO_P(ctx, struct junction_map);
+ junction = talloc_zero(ctx, struct junction_map);
if (!junction) {
*pstatus = NT_STATUS_NO_MEMORY;
talloc_destroy(ctx);
if (!junction) {
*pstatus = NT_STATUS_NO_MEMORY;
talloc_destroy(ctx);
jucn[cnt].comment = "";
jucn[cnt].referral_count = 1;
jucn[cnt].comment = "";
jucn[cnt].referral_count = 1;
- ref = jucn[cnt].referral_list = TALLOC_ZERO_P(ctx, struct referral);
+ ref = jucn[cnt].referral_list = talloc_zero(ctx, struct referral);
if (jucn[cnt].referral_list == NULL) {
goto out;
}
if (jucn[cnt].referral_list == NULL) {
goto out;
}
SMB_ASSERT(fsp->notify == NULL);
SMB_ASSERT(fsp->notify == NULL);
- if (!(fsp->notify = TALLOC_ZERO_P(NULL, struct notify_change_buf))) {
+ if (!(fsp->notify = talloc_zero(NULL, struct notify_change_buf))) {
DEBUG(0, ("talloc failed\n"));
return NT_STATUS_NO_MEMORY;
}
DEBUG(0, ("talloc failed\n"));
return NT_STATUS_NO_MEMORY;
}
notify->seqnum = seqnum;
talloc_free(notify->array);
notify->seqnum = seqnum;
talloc_free(notify->array);
- notify->array = TALLOC_ZERO_P(notify, struct notify_array);
+ notify->array = talloc_zero(notify, struct notify_array);
NT_STATUS_HAVE_NO_MEMORY(notify->array);
if (!rec) {
NT_STATUS_HAVE_NO_MEMORY(notify->array);
if (!rec) {
depth = count_chars(e.path, '/');
depth = count_chars(e.path, '/');
- listel = TALLOC_ZERO_P(notify, struct notify_list);
+ listel = talloc_zero(notify, struct notify_list);
if (listel == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
if (listel == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
DEBUG(15,("quota entry for id[%s] path[%s]\n",
sid_string_dbg(&sid), fsp->conn->connectpath));
DEBUG(15,("quota entry for id[%s] path[%s]\n",
sid_string_dbg(&sid), fsp->conn->connectpath));
- if ((tmp_list_ent=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
+ if ((tmp_list_ent=talloc_zero(mem_ctx,SMB_NTQUOTA_LIST))==NULL) {
DEBUG(0,("TALLOC_ZERO() failed\n"));
*qt_list = NULL;
talloc_destroy(mem_ctx);
return (-1);
}
DEBUG(0,("TALLOC_ZERO() failed\n"));
*qt_list = NULL;
talloc_destroy(mem_ctx);
return (-1);
}
- if ((tmp_list_ent->quotas=TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
+ if ((tmp_list_ent->quotas=talloc_zero(mem_ctx,SMB_NTQUOTA_STRUCT))==NULL) {
DEBUG(0,("TALLOC_ZERO() failed\n"));
*qt_list = NULL;
talloc_destroy(mem_ctx);
DEBUG(0,("TALLOC_ZERO() failed\n"));
*qt_list = NULL;
talloc_destroy(mem_ctx);
if (!mem_ctx)
return False;
if (!mem_ctx)
return False;
- qt_handle = TALLOC_ZERO_P(mem_ctx,SMB_NTQUOTA_HANDLE);
+ qt_handle = talloc_zero(mem_ctx,SMB_NTQUOTA_HANDLE);
if (qt_handle==NULL) {
DEBUG(0,("TALLOC_ZERO() failed\n"));
return NULL;
if (qt_handle==NULL) {
DEBUG(0,("TALLOC_ZERO() failed\n"));
return NULL;
- shadow_data = TALLOC_ZERO_P(talloc_tos(),
+ shadow_data = talloc_zero(talloc_tos(),
struct shadow_copy_data);
if (shadow_data == NULL) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
struct shadow_copy_data);
if (shadow_data == NULL) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
struct fd_handle fh;
NTSTATUS status;
struct fd_handle fh;
NTSTATUS status;
- conn = TALLOC_ZERO_P(ctx, connection_struct);
+ conn = talloc_zero(ctx, connection_struct);
if (conn == NULL) {
DEBUG(0, ("talloc failed\n"));
return NULL;
if (conn == NULL) {
DEBUG(0, ("talloc failed\n"));
return NULL;
int msg_len = smb_len(req->inbuf) + 4;
struct pending_message_list *msg;
int msg_len = smb_len(req->inbuf) + 4;
struct pending_message_list *msg;
- msg = TALLOC_ZERO_P(NULL, struct pending_message_list);
+ msg = talloc_zero(NULL, struct pending_message_list);
if(msg == NULL) {
DEBUG(0,("push_message: malloc fail (1)\n"));
if(msg == NULL) {
DEBUG(0,("push_message: malloc fail (1)\n"));
- shadow_data = TALLOC_ZERO_P(talloc_tos(),
+ shadow_data = talloc_zero(talloc_tos(),
struct shadow_copy_data);
if (tevent_req_nomem(shadow_data, req)) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
struct shadow_copy_data);
if (tevent_req_nomem(shadow_data, req)) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
size_t converted_size, offset = 0;
while (offset + 2 < data_size) {
size_t converted_size, offset = 0;
while (offset + 2 < data_size) {
- struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
+ struct ea_list *eal = talloc_zero(ctx, struct ea_list);
unsigned int namelen = CVAL(pdata,offset);
offset++; /* Go past the namelen byte. */
unsigned int namelen = CVAL(pdata,offset);
offset++; /* Go past the namelen byte. */
struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
{
struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
{
- struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
+ struct ea_list *eal = talloc_zero(ctx, struct ea_list);
uint16 val_len;
unsigned int namelen;
size_t converted_size;
uint16 val_len;
unsigned int namelen;
size_t converted_size;
DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object));
DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object));
- handle = TALLOC_ZERO_P(conn, vfs_handle_struct);
+ handle = talloc_zero(conn, vfs_handle_struct);
if (!handle) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
goto fail;
if (!handle) {
DEBUG(0,("TALLOC_ZERO() failed!\n"));
goto fail;
/* some basic initialization stuff */
sec_init();
/* some basic initialization stuff */
sec_init();
- vfs.conn = TALLOC_ZERO_P(NULL, connection_struct);
+ vfs.conn = talloc_zero(NULL, connection_struct);
vfs.conn->params = talloc(vfs.conn, struct share_params);
for (i=0; i < 1024; i++)
vfs.files[i] = NULL;
vfs.conn->params = talloc(vfs.conn, struct share_params);
for (i=0; i < 1024; i++)
vfs.files[i] = NULL;
{
struct srvsvc_NetShareCtr1 *ctr1;
{
struct srvsvc_NetShareCtr1 *ctr1;
- ctr1 = TALLOC_ZERO_P(mem_ctx, struct srvsvc_NetShareCtr1);
+ ctr1 = talloc_zero(mem_ctx, struct srvsvc_NetShareCtr1);
W_ERROR_HAVE_NO_MEMORY(ctr1);
ctr1->count = 1;
W_ERROR_HAVE_NO_MEMORY(ctr1);
ctr1->count = 1;
{
struct srvsvc_NetShareCtr2 *ctr2;
{
struct srvsvc_NetShareCtr2 *ctr2;
- ctr2 = TALLOC_ZERO_P(mem_ctx, struct srvsvc_NetShareCtr2);
+ ctr2 = talloc_zero(mem_ctx, struct srvsvc_NetShareCtr2);
W_ERROR_HAVE_NO_MEMORY(ctr2);
ctr2->count = 1;
W_ERROR_HAVE_NO_MEMORY(ctr2);
ctr2->count = 1;
{
struct srvsvc_NetShareCtr502 *ctr502;
{
struct srvsvc_NetShareCtr502 *ctr502;
- ctr502 = TALLOC_ZERO_P(mem_ctx, struct srvsvc_NetShareCtr502);
+ ctr502 = talloc_zero(mem_ctx, struct srvsvc_NetShareCtr502);
W_ERROR_HAVE_NO_MEMORY(ctr502);
ctr502->count = 1;
W_ERROR_HAVE_NO_MEMORY(ctr502);
ctr502->count = 1;
- sd = TALLOC_ZERO_P(mem_ctx, struct KeySecurityData);
+ sd = talloc_zero(mem_ctx, struct KeySecurityData);
if (!sd) {
status = NT_STATUS_NO_MEMORY;
goto out;
if (!sd) {
status = NT_STATUS_NO_MEMORY;
goto out;
char *config_option;
const char *schema_mode = NULL;
char *config_option;
const char *schema_mode = NULL;
- ctx = TALLOC_ZERO_P(dom, struct idmap_ad_context);
+ ctx = talloc_zero(dom, struct idmap_ad_context);
if (ctx == NULL) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
if (ctx == NULL) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
if (e->state != NULL) {
dom = talloc_get_type(e->state, struct idmap_domain);
} else {
if (e->state != NULL) {
dom = talloc_get_type(e->state, struct idmap_domain);
} else {
- dom = TALLOC_ZERO_P(e, struct idmap_domain);
+ dom = talloc_zero(e, struct idmap_domain);
if (dom == NULL) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
if (dom == NULL) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
ctx = talloc_get_type(dom->private_data,
struct idmap_ad_context);
} else {
ctx = talloc_get_type(dom->private_data,
struct idmap_ad_context);
} else {
- ctx = TALLOC_ZERO_P(dom, struct idmap_ad_context);
+ ctx = talloc_zero(dom, struct idmap_ad_context);
if (ctx == NULL) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
if (ctx == NULL) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
return NT_STATUS_INVALID_PARAMETER;
}
return NT_STATUS_INVALID_PARAMETER;
}
- if ((gc = TALLOC_ZERO_P(NULL, struct gc_info)) == NULL) {
+ if ((gc = talloc_zero(NULL, struct gc_info)) == NULL) {
nt_status = NT_STATUS_NO_MEMORY;
BAIL_ON_NTSTATUS_ERROR(nt_status);
}
nt_status = NT_STATUS_NO_MEMORY;
BAIL_ON_NTSTATUS_ERROR(nt_status);
}
- dc = TALLOC_ZERO_P(NULL, struct dc_info);
+ dc = talloc_zero(NULL, struct dc_info);
BAIL_ON_PTR_ERROR(dc, nt_status);
dc->dns_name = talloc_strdup(dc, domain);
BAIL_ON_PTR_ERROR(dc, nt_status);
dc->dns_name = talloc_strdup(dc, domain);
- if ((gc = TALLOC_ZERO_P(NULL, struct gc_info)) == NULL) {
+ if ((gc = talloc_zero(NULL, struct gc_info)) == NULL) {
nt_status = NT_STATUS_NO_MEMORY;
BAIL_ON_NTSTATUS_ERROR(nt_status);
}
nt_status = NT_STATUS_NO_MEMORY;
BAIL_ON_NTSTATUS_ERROR(nt_status);
}
/* Each cell struct is a TALLOC_CTX* */
/* Each cell struct is a TALLOC_CTX* */
- c = TALLOC_ZERO_P(NULL, struct likewise_cell);
+ c = talloc_zero(NULL, struct likewise_cell);
if (!c) {
DEBUG(0,("cell_new: memory allocation failure!\n"));
return NULL;
if (!c) {
DEBUG(0,("cell_new: memory allocation failure!\n"));
return NULL;
- cfg = TALLOC_ZERO_P(ctx, struct autorid_global_config);
+ cfg = talloc_zero(ctx, struct autorid_global_config);
if (!cfg) {
return NULL;
}
if (!cfg) {
return NULL;
}
- config = TALLOC_ZERO_P(frame, struct autorid_global_config);
+ config = talloc_zero(dom, struct autorid_global_config);
if (!config) {
DEBUG(0, ("Out of memory!\n"));
status = NT_STATUS_NO_MEMORY;
if (!config) {
DEBUG(0, ("Out of memory!\n"));
status = NT_STATUS_NO_MEMORY;
return NT_STATUS_FILE_IS_OFFLINE;
}
return NT_STATUS_FILE_IS_OFFLINE;
}
- ctx = TALLOC_ZERO_P(dom, struct idmap_ldap_context);
+ ctx = talloc_zero(dom, struct idmap_ldap_context);
if ( ! ctx) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
if ( ! ctx) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
struct idmap_rid_context *ctx;
char *config_option = NULL;
struct idmap_rid_context *ctx;
char *config_option = NULL;
- ctx = TALLOC_ZERO_P(dom, struct idmap_rid_context);
+ ctx = talloc_zero(dom, struct idmap_rid_context);
if (ctx == NULL) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
if (ctx == NULL) {
DEBUG(0, ("Out of memory!\n"));
return NT_STATUS_NO_MEMORY;
{
struct nss_domain_entry *nss_domain;
{
struct nss_domain_entry *nss_domain;
- nss_domain = TALLOC_ZERO_P(nss_domain_list, struct nss_domain_entry);
+ nss_domain = talloc_zero(nss_domain_list, struct nss_domain_entry);
if (!nss_domain) {
DEBUG(0, ("nss_domain_list_add_domain: talloc() failure!\n"));
return NT_STATUS_NO_MEMORY;
if (!nss_domain) {
DEBUG(0, ("nss_domain_list_add_domain: talloc() failure!\n"));
return NT_STATUS_NO_MEMORY;
return tevent_req_post(req, ev);
}
return tevent_req_post(req, ev);
}
- state->res_domains = TALLOC_ZERO_P(state, struct lsa_RefDomainList);
+ state->res_domains = talloc_zero(state, struct lsa_RefDomainList);
if (tevent_req_nomem(state->res_domains, req)) {
return tevent_req_post(req, ev);
}
if (tevent_req_nomem(state->res_domains, req)) {
return tevent_req_post(req, ev);
}
return tevent_req_post(req, ev);
}
return tevent_req_post(req, ev);
}
- state->res_names = TALLOC_ZERO_P(state, struct lsa_TransNameArray);
+ state->res_names = talloc_zero(state, struct lsa_TransNameArray);
if (tevent_req_nomem(state->res_names, req)) {
return tevent_req_post(req, ev);
}
if (tevent_req_nomem(state->res_names, req)) {
return tevent_req_post(req, ev);
}
/* Create new connection structure */
/* Create new connection structure */
- if ((state = TALLOC_ZERO_P(NULL, struct winbindd_cli_state)) == NULL) {
+ if ((state = talloc_zero(NULL, struct winbindd_cli_state)) == NULL) {
return winbindd_replace_memory_creds_internal(memcredp, pass);
}
return winbindd_replace_memory_creds_internal(memcredp, pass);
}
- memcredp = TALLOC_ZERO_P(NULL, struct WINBINDD_MEMORY_CREDS);
+ memcredp = talloc_zero(NULL, struct WINBINDD_MEMORY_CREDS);
if (!memcredp) {
return NT_STATUS_NO_MEMORY;
}
if (!memcredp) {
return NT_STATUS_NO_MEMORY;
}
child->domain->startup = False;
}
child->domain->startup = False;
}
- pfds = TALLOC_ZERO_P(talloc_tos(), struct pollfd);
+ pfds = talloc_zero(talloc_tos(), struct pollfd);
if (pfds == NULL) {
DEBUG(1, ("talloc failed\n"));
_exit(1);
if (pfds == NULL) {
DEBUG(1, ("talloc failed\n"));
_exit(1);
if (NT_STATUS_IS_ERR(result)) {
return result;
}
if (NT_STATUS_IS_ERR(result)) {
return result;
}
- names = TALLOC_ZERO_P(mem_ctx, struct lsa_TransNameArray);
+ names = talloc_zero(mem_ctx, struct lsa_TransNameArray);
if (names == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (names == NULL) {
return NT_STATUS_NO_MEMORY;
}
- names = TALLOC_ZERO_P(mem_ctx, struct lsa_TransNameArray);
+ names = talloc_zero(mem_ctx, struct lsa_TransNameArray);
if (names == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (names == NULL) {
return NT_STATUS_NO_MEMORY;
}
struct trustdom_state *state;
struct tevent_req *req;
struct trustdom_state *state;
struct tevent_req *req;
- state = TALLOC_ZERO_P(NULL, struct trustdom_state);
+ state = talloc_zero(NULL, struct trustdom_state);
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
return;
if (state == NULL) {
DEBUG(0, ("talloc failed\n"));
return;
git.samba.org / sfrench / samba-autobuild / .git / commitdiff