d_printf("\tcluster_shift %ld\n", (long)finfo.compression_info.out.cluster_shift);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
done:
return ret;
if (!NT_STATUS_IS_OK(status)) {
d_printf("RAW_FILEINFO_ALL_EAS - %s\n", nt_errstr(status));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return 1;
}
finfo.all_eas.out.eas[i].value.length);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
NDR_PRINT_DEBUG(security_descriptor, query.query_secdesc.out.sd);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
done:
return ret;
ZERO_STRUCT(rights);
while (next_token(cmd_ptr,buf,NULL,sizeof(buf))) {
- rights.names = talloc_realloc_p(mem_ctx, rights.names,
+ rights.names = talloc_realloc(mem_ctx, rights.names,
struct lsa_String, rights.count+1);
rights.names[rights.count].string = talloc_strdup(mem_ctx, buf);
rights.count++;
ZERO_STRUCT(rights);
while (next_token(cmd_ptr,buf,NULL,sizeof(buf))) {
- rights.names = talloc_realloc_p(mem_ctx, rights.names,
+ rights.names = talloc_realloc(mem_ctx, rights.names,
struct lsa_String, rights.count+1);
rights.names[rights.count].string = talloc_strdup(mem_ctx, buf);
rights.count++;
if (!NT_STATUS_IS_OK(status)) {
d_printf("Failed to connect to %s - %s\n",
binding, nt_errstr(status));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return False;
}
talloc_steal(mem_ctx, p);
}
} while (NT_STATUS_IS_OK(status) && W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(r.out.result)) {
d_printf("Failed NetShareEnumAll %s - %s/%s\n",
DEBUG( 3, ( "Client started (version %s).\n", SAMBA_VERSION_STRING ) );
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if ((p=strchr_m(query_host,'#'))) {
*p = 0;
}
}
- *strs = talloc_array_p(mem_ctx, const char *, count+1);
+ *strs = talloc_array(mem_ctx, const char *, count+1);
if (! *strs) {
samdb_search_free(sam_ctx, mem_ctx, res);
return -1;
return 0;
}
- *hashes = talloc_array_p(mem_ctx, struct samr_Password, count);
+ *hashes = talloc_array(mem_ctx, struct samr_Password, count);
if (! *hashes) {
return 0;
}
struct samr_Password *lmPwdHash, *ntPwdHash;
if (unicodePwd) {
if (nt_pwd) {
- ntPwdHash = talloc_p(mem_ctx, struct samr_Password);
+ ntPwdHash = talloc(mem_ctx, struct samr_Password);
if (!ntPwdHash) {
return NT_STATUS_NO_MEMORY;
}
if (lm_pwd) {
BOOL lm_hash_ok;
- lmPwdHash = talloc_p(mem_ctx, struct samr_Password);
+ lmPwdHash = talloc(mem_ctx, struct samr_Password);
if (!lmPwdHash) {
return NT_STATUS_NO_MEMORY;
}
const int units_per_week = 168;
const struct ldb_val *val = ldb_msg_find_ldb_val(msg, attr);
ZERO_STRUCT(hours);
- hours.bits = talloc_array_p(mem_ctx, uint8, units_per_week);
+ hours.bits = talloc_array(mem_ctx, uint8, units_per_week);
if (!hours.bits) {
return hours;
}
struct dcerpc_binding *gtk_rpc_binding_dialog_get_binding(GtkRpcBindingDialog *d, TALLOC_CTX *mem_ctx)
{
- struct dcerpc_binding *binding = talloc_p(mem_ctx, struct dcerpc_binding);
+ struct dcerpc_binding *binding = talloc(mem_ctx, struct dcerpc_binding);
ZERO_STRUCT(binding->object);
status = dcerpc_samr_Connect(sam_pipe, mem_ctx, &cr);
if (!NT_STATUS_IS_OK(status)) {
gtk_show_ntstatus(NULL, status);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return GTK_WIDGET(d);
}
status = dcerpc_samr_Close(sam_pipe, mem_ctx, &dr);
if (!NT_STATUS_IS_OK(status)) {
gtk_show_ntstatus(NULL, status);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return GTK_WIDGET ( d );
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return GTK_WIDGET ( d );
}
struct policy_handle handle;
TALLOC_CTX *mem_ctx = talloc_init("dump");
- talloc_destroy(eps_ctx);
+ talloc_free(eps_ctx);
ZERO_STRUCT(handle);
if (!NT_STATUS_IS_OK(status)) {
gtk_show_ntstatus(mainwin, status);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
static void on_refresh_clicked (GtkButton *btn, gpointer user_data)
gtk_main ();
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return 0;
}
-1);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
gtk_widget_set_sensitive(tasks, TRUE);
}
gtk_show_ntstatus(mainwin, status);
at_pipe = NULL;
gtk_widget_destroy(GTK_WIDGET(d));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return;
}
gtk_widget_destroy(GTK_WIDGET(d));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
update_joblist();
}
status = dcerpc_atsvc_JobAdd(at_pipe, mem_ctx, &r);
if(!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
gtk_show_ntstatus(mainwin, status);
return;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
gtk_widget_destroy(d);
d = gtk_message_dialog_new (GTK_WINDOW(mainwin), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "Job Id: %d", r.out.job_id);
mem_ctx = talloc_init("del_job");
status = dcerpc_atsvc_JobDel(at_pipe, mem_ctx, &r);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if(!NT_STATUS_IS_OK(status)) {
gtk_show_ntstatus(mainwin, status);
return;
status = dcerpc_samr_EnumDomainUsers(sam_pipe, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
gtk_show_ntstatus(mainwin, status);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return;
}
if (!r.out.sam || r.out.sam->count == 0) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return;
}
// ret = False;
// }
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
void
gtk_show_ntstatus(mainwin, status);
sam_pipe = NULL;
gtk_widget_destroy(GTK_WIDGET(d));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return;
}
gtk_show_ntstatus(mainwin, status);
sam_pipe = NULL;
gtk_widget_destroy(GTK_WIDGET(d));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return;
}
gtk_widget_set_sensitive (mnu_disconnect, TRUE);
gtk_window_set_title (GTK_WINDOW (mainwin), talloc_asprintf(mem_ctx, "User Manager - Connected to %s", gtk_rpc_binding_dialog_get_host(d)));
gtk_widget_destroy(GTK_WIDGET(d));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
/* Lists, trees, caching, database... */
#include "xfile.h"
-#define TALLOC_DEPRECATED 1
#include "lib/talloc/talloc.h"
#include "nt_status.h"
#include "structs.h"
if (stat(msg_path, &st) != 0) {
/* the msg file isn't available */
free(msg_path);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return False;
}
tdb = tdb_open(path, 0, TDB_DEFAULT, O_RDONLY, 0);
free(path);
free(msg_path);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (!tdb) return False;
current_lang = strdup(lang);
return True;
}
free(path);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
loadtime = tdb_fetch_int32(tdb, "/LOADTIME/");
{
struct ldapsrv_reply *reply;
- reply = talloc_p(call, struct ldapsrv_reply);
+ reply = talloc(call, struct ldapsrv_reply);
if (!reply) {
return NULL;
}
}
if (r->num_attributes >= 1) {
- attrs = talloc_array_p(samdb, const char *, r->num_attributes+1);
+ attrs = talloc_array(samdb, const char *, r->num_attributes+1);
NT_STATUS_HAVE_NO_MEMORY(attrs);
for (j=0; j < r->num_attributes; j++) {
goto queue_reply;
}
ent->num_attributes = res[0]->num_elements;
- ent->attributes = talloc_array_p(ent_r, struct ldap_attribute, ent->num_attributes);
+ ent->attributes = talloc_array(ent_r, struct ldap_attribute, ent->num_attributes);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes);
for (j=0; j < ent->num_attributes; j++) {
ent->attributes[j].name = talloc_steal(ent->attributes, res[0]->elements[j].name);
ent->attributes[j].values = NULL;
ent->attributes[j].num_values = res[0]->elements[j].num_values;
if (ent->attributes[j].num_values == 1) {
- ent->attributes[j].values = talloc_array_p(ent->attributes,
+ ent->attributes[j].values = talloc_array(ent->attributes,
DATA_BLOB, ent->attributes[j].num_values);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes[j].values);
status = convert_values(ent_r,
return status;
}
} else {
- ent->attributes[j].values = talloc_array_p(ent->attributes,
+ ent->attributes[j].values = talloc_array(ent->attributes,
DATA_BLOB, ent->attributes[j].num_values);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes[j].values);
for (y=0; y < ent->attributes[j].num_values; y++) {
goto queue_reply2;
}
ent->num_attributes = res[i]->num_elements;
- ent->attributes = talloc_array_p(ent_r, struct ldap_attribute, ent->num_attributes);
+ ent->attributes = talloc_array(ent_r, struct ldap_attribute, ent->num_attributes);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes);
for (j=0; j < ent->num_attributes; j++) {
ent->attributes[j].name = talloc_steal(ent->attributes, res[i]->elements[j].name);
continue;
}
ent->attributes[j].num_values = res[i]->elements[j].num_values;
- ent->attributes[j].values = talloc_array_p(ent->attributes,
+ ent->attributes[j].values = talloc_array(ent->attributes,
DATA_BLOB, ent->attributes[j].num_values);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes[j].values);
if (ent->attributes[j].num_values == 1) {
}
if (r->num_attributes >= 1) {
- attrs = talloc_array_p(samdb, const char *, r->num_attributes+1);
+ attrs = talloc_array(samdb, const char *, r->num_attributes+1);
NT_STATUS_HAVE_NO_MEMORY(attrs);
for (i=0; i < r->num_attributes; i++) {
goto queue_reply;
}
ent->num_attributes = res[i]->num_elements;
- ent->attributes = talloc_array_p(ent_r, struct ldap_attribute, ent->num_attributes);
+ ent->attributes = talloc_array(ent_r, struct ldap_attribute, ent->num_attributes);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes);
for (j=0; j < ent->num_attributes; j++) {
ent->attributes[j].name = talloc_steal(ent->attributes, res[i]->elements[j].name);
continue;
}
ent->attributes[j].num_values = res[i]->elements[j].num_values;
- ent->attributes[j].values = talloc_array_p(ent->attributes,
+ ent->attributes[j].values = talloc_array(ent->attributes,
DATA_BLOB, ent->attributes[j].num_values);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes[j].values);
for (y=0; y < ent->attributes[j].num_values; y++) {
DEBUG(10, ("hldb_add: dn: [%s]\n", dn->dn));
- msg = talloc_p(local_ctx, struct ldb_message);
+ msg = talloc(local_ctx, struct ldb_message);
NT_STATUS_HAVE_NO_MEMORY(msg);
msg->dn = dn->dn;
if (r->num_attributes > 0) {
msg->num_elements = r->num_attributes;
- msg->elements = talloc_array_p(msg, struct ldb_message_element, msg->num_elements);
+ msg->elements = talloc_array(msg, struct ldb_message_element, msg->num_elements);
NT_STATUS_HAVE_NO_MEMORY(msg->elements);
for (i=0; i < msg->num_elements; i++) {
if (r->attributes[i].num_values > 0) {
msg->elements[i].num_values = r->attributes[i].num_values;
- msg->elements[i].values = talloc_array_p(msg, struct ldb_val, msg->elements[i].num_values);
+ msg->elements[i].values = talloc_array(msg, struct ldb_val, msg->elements[i].num_values);
NT_STATUS_HAVE_NO_MEMORY(msg->elements[i].values);
for (j=0; j < msg->elements[i].num_values; j++) {
DEBUG(10, ("hldb_modify: dn: [%s]\n", dn->dn));
- msg = talloc_p(local_ctx, struct ldb_message);
+ msg = talloc(local_ctx, struct ldb_message);
NT_STATUS_HAVE_NO_MEMORY(msg);
msg->dn = dn->dn;
if (r->num_mods > 0) {
msg->num_elements = r->num_mods;
- msg->elements = talloc_array_p(msg, struct ldb_message_element, r->num_mods);
+ msg->elements = talloc_array(msg, struct ldb_message_element, r->num_mods);
NT_STATUS_HAVE_NO_MEMORY(msg->elements);
for (i=0; i < msg->num_elements; i++) {
msg->elements[i].num_values = r->mods[i].attrib.num_values;
if (msg->elements[i].num_values > 0) {
- msg->elements[i].values = talloc_array_p(msg, struct ldb_val, msg->elements[i].num_values);
+ msg->elements[i].values = talloc_array(msg, struct ldb_val, msg->elements[i].num_values);
NT_STATUS_HAVE_NO_MEMORY(msg->elements[i].values);
for (j=0; j < msg->elements[i].num_values; j++) {
{
char *desc;
- desc = talloc_array_p(schema, char, data->lenght + 1);
+ desc = talloc_array(schema, char, data->lenght + 1);
memcpy(desc, data->data, data->lenght);
desc[data->lenght] = '\0';
{
char *desc;
- desc = talloc_array_p(schema, char, data->lenght + 1);
+ desc = talloc_array(schema, char, data->lenght + 1);
memcpy(desc, data->data, data->lenght);
desc[data->lenght] = '\0';
local_schema = schema;
if (local_schema == NULL) {
- local_schema = talloc_p(mem_ctx, struct ldap_schema);
+ local_schema = talloc(mem_ctx, struct ldap_schema);
ALLOC_CHECK(local_schema);
}
char *p, *start, *separator, *src, *dest, *dn_copy, *dn_end;
int i, size, orig_len;
- dn = talloc_p(mem_ctx, struct ldap_dn);
+ dn = talloc(mem_ctx, struct ldap_dn);
dn->comp_num = 0;
- dn->components = talloc_array_p(dn, struct dn_component *, 1);
- component = talloc_p(dn, struct dn_component);
+ dn->components = talloc_array(dn, struct dn_component *, 1);
+ component = talloc(dn, struct dn_component);
component->attr_num = 0;
orig_len = strlen(orig_dn);
dn_copy = p = talloc_strdup(mem_ctx, orig_dn);
dn_end = dn_copy + orig_len + 1;
do {
- component->attributes = talloc_array_p(component, struct dn_attribute *, 1);
- attribute = talloc_p(component, struct dn_attribute);
+ component->attributes = talloc_array(component, struct dn_attribute *, 1);
+ attribute = talloc(component, struct dn_attribute);
/* skip "spaces" */
while (*p == ' ' || *p == '\n') {
component->attr_num++;
if (*separator == '+') { /* expect other attributes in this component */
- component->attributes = talloc_realloc_p(component, component->attributes, struct dn_attribute *, component->attr_num + 1);
+ component->attributes = talloc_realloc(component, component->attributes, struct dn_attribute *, component->attr_num + 1);
/* allocate new attribute structure */
- attribute = talloc_p(component, struct dn_attribute);
+ attribute = talloc(component, struct dn_attribute);
/* skip spaces past the separator */
p = separator + strspn(p, " \n");
dn->comp_num++;
if (*separator == ',' || *separator == ';') {
- dn->components = talloc_realloc_p(dn, dn->components, struct dn_component *, dn->comp_num + 1);
- component = talloc_p(dn, struct dn_component);
+ dn->components = talloc_realloc(dn, dn->components, struct dn_component *, dn->comp_num + 1);
+ component = talloc(dn, struct dn_component);
component->attr_num = 0;
}
p = separator + 1;
return talloc_reference(mem_ctx, ctx);
}
- ctx = talloc_p(mem_ctx, struct rootdse_db_context);
+ ctx = talloc(mem_ctx, struct rootdse_db_context);
if (ctx == NULL) {
errno = ENOMEM;
return NULL;
if (strcasecmp(attrs->name, "currentTime") == 0)
{
int num_currentTime = 1;
- DATA_BLOB *currentTime = talloc_array_p(mem_ctx, DATA_BLOB, num_currentTime);
+ DATA_BLOB *currentTime = talloc_array(mem_ctx, DATA_BLOB, num_currentTime);
char *str = ldap_timestring(mem_ctx, time(NULL));
NT_STATUS_HAVE_NO_MEMORY(str);
currentTime[0].data = (uint8_t *)str;
if (strcasecmp(attrs->name, "supportedLDAPVersion") == 0)
{
int num_supportedLDAPVersion = 1;
- DATA_BLOB *supportedLDAPVersion = talloc_array_p(mem_ctx, DATA_BLOB, num_supportedLDAPVersion);
+ DATA_BLOB *supportedLDAPVersion = talloc_array(mem_ctx, DATA_BLOB, num_supportedLDAPVersion);
supportedLDAPVersion[0] = ATTR_BLOB_CONST("3");
ATTR_SINGLE_NOVAL(mem_ctx, attrs, supportedLDAPVersion, num_supportedLDAPVersion, "supportedLDAPVersion");
return NT_STATUS_OK;
*/
{
- DATA_BLOB *x = talloc_array_p(mem_ctx, DATA_BLOB, 1);
+ DATA_BLOB *x = talloc_array(mem_ctx, DATA_BLOB, 1);
x[0] = ATTR_BLOB_CONST("0");
ATTR_SINGLE_NOVAL(mem_ctx, attrs, x, 1, attrs->name);
}
NT_STATUS_HAVE_NO_MEMORY(rootdsedb);
if (r->num_attributes >= 1) {
- attrs = talloc_array_p(rootdsedb, const char *, r->num_attributes+1);
+ attrs = talloc_array(rootdsedb, const char *, r->num_attributes+1);
NT_STATUS_HAVE_NO_MEMORY(attrs);
for (j=0; j < r->num_attributes; j++) {
goto queue_reply;
}
ent->num_attributes = res[0]->num_elements;
- ent->attributes = talloc_array_p(ent_r, struct ldap_attribute, ent->num_attributes);
+ ent->attributes = talloc_array(ent_r, struct ldap_attribute, ent->num_attributes);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes);
for (j=0; j < ent->num_attributes; j++) {
ent->attributes[j].name = talloc_steal(ent->attributes, res[0]->elements[j].name);
return status;
}
} else {
- ent->attributes[j].values = talloc_array_p(ent->attributes,
+ ent->attributes[j].values = talloc_array(ent->attributes,
DATA_BLOB, ent->attributes[j].num_values);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes[j].values);
for (y=0; y < ent->attributes[j].num_values; y++) {
DEBUG(10,("ldapsrv_init\n"));
- ldap_service = talloc_p(service, struct ldapsrv_service);
+ ldap_service = talloc(service, struct ldapsrv_service);
if (!ldap_service) {
- DEBUG(0,("talloc_p(service, struct ldapsrv_service) failed\n"));
+ DEBUG(0,("talloc(service, struct ldapsrv_service) failed\n"));
return;
}
ZERO_STRUCTP(ldap_service);
- rootDSE_part = talloc_p(ldap_service, struct ldapsrv_partition);
+ rootDSE_part = talloc(ldap_service, struct ldapsrv_partition);
if (!rootDSE_part) {
- DEBUG(0,("talloc_p(ldap_service, struct ldapsrv_partition) failed\n"));
+ DEBUG(0,("talloc(ldap_service, struct ldapsrv_partition) failed\n"));
return;
}
rootDSE_part->base_dn = ""; /* RootDSE */
ldap_service->rootDSE = rootDSE_part;
DLIST_ADD_END(ldap_service->partitions, rootDSE_part, struct ldapsrv_partition *);
- part = talloc_p(ldap_service, struct ldapsrv_partition);
+ part = talloc(ldap_service, struct ldapsrv_partition);
if (!ldap_service) {
- DEBUG(0,("talloc_p(ldap_service, struct ldapsrv_partition) failed\n"));
+ DEBUG(0,("talloc(ldap_service, struct ldapsrv_partition) failed\n"));
return;
}
part->base_dn = "*"; /* default partition */
return;
}
- call = talloc_p(ldap_conn, struct ldapsrv_call);
+ call = talloc(ldap_conn, struct ldapsrv_call);
if (!call) {
ldapsrv_terminate_connection(ldap_conn, "no memory");
return;
DEBUG(10, ("ldapsrv_accept\n"));
- ldap_conn = talloc_p(conn, struct ldapsrv_connection);
+ ldap_conn = talloc(conn, struct ldapsrv_connection);
if (ldap_conn == NULL)
return;
}
if (r->num_attributes >= 1) {
- attrs = talloc_array_p(samdb, const char *, r->num_attributes+1);
+ attrs = talloc_array(samdb, const char *, r->num_attributes+1);
NT_STATUS_HAVE_NO_MEMORY(attrs);
for (i=0; i < r->num_attributes; i++) {
goto queue_reply;
}
ent->num_attributes = res[i]->num_elements;
- ent->attributes = talloc_array_p(ent_r, struct ldap_attribute, ent->num_attributes);
+ ent->attributes = talloc_array(ent_r, struct ldap_attribute, ent->num_attributes);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes);
for (j=0; j < ent->num_attributes; j++) {
ent->attributes[j].name = talloc_steal(ent->attributes, res[i]->elements[j].name);
continue;
}
ent->attributes[j].num_values = res[i]->elements[j].num_values;
- ent->attributes[j].values = talloc_array_p(ent->attributes,
+ ent->attributes[j].values = talloc_array(ent->attributes,
DATA_BLOB, ent->attributes[j].num_values);
NT_STATUS_HAVE_NO_MEMORY(ent->attributes[j].values);
for (y=0; y < ent->attributes[j].num_values; y++) {
DEBUG(10, ("sldb_add: dn: [%s]\n", dn->dn));
- msg = talloc_p(local_ctx, struct ldb_message);
+ msg = talloc(local_ctx, struct ldb_message);
NT_STATUS_HAVE_NO_MEMORY(msg);
msg->dn = dn->dn;
if (r->num_attributes > 0) {
msg->num_elements = r->num_attributes;
- msg->elements = talloc_array_p(msg, struct ldb_message_element, msg->num_elements);
+ msg->elements = talloc_array(msg, struct ldb_message_element, msg->num_elements);
NT_STATUS_HAVE_NO_MEMORY(msg->elements);
for (i=0; i < msg->num_elements; i++) {
if (r->attributes[i].num_values > 0) {
msg->elements[i].num_values = r->attributes[i].num_values;
- msg->elements[i].values = talloc_array_p(msg, struct ldb_val, msg->elements[i].num_values);
+ msg->elements[i].values = talloc_array(msg, struct ldb_val, msg->elements[i].num_values);
NT_STATUS_HAVE_NO_MEMORY(msg->elements[i].values);
for (j=0; j < msg->elements[i].num_values; j++) {
DEBUG(10, ("sldb_modify: dn: [%s]\n", dn->dn));
- msg = talloc_p(local_ctx, struct ldb_message);
+ msg = talloc(local_ctx, struct ldb_message);
NT_STATUS_HAVE_NO_MEMORY(msg);
msg->dn = dn->dn;
if (r->num_mods > 0) {
msg->num_elements = r->num_mods;
- msg->elements = talloc_array_p(msg, struct ldb_message_element, r->num_mods);
+ msg->elements = talloc_array(msg, struct ldb_message_element, r->num_mods);
NT_STATUS_HAVE_NO_MEMORY(msg->elements);
for (i=0; i < msg->num_elements; i++) {
msg->elements[i].num_values = r->mods[i].attrib.num_values;
if (msg->elements[i].num_values > 0) {
- msg->elements[i].values = talloc_array_p(msg, struct ldb_val, msg->elements[i].num_values);
+ msg->elements[i].values = talloc_array(msg, struct ldb_val, msg->elements[i].num_values);
NT_STATUS_HAVE_NO_MEMORY(msg->elements[i].values);
for (j=0; j < msg->elements[i].num_values; j++) {
int i;
char *hex_string;
- hex_string = talloc_array_p(mem_ctx, char, (blob->length*2)+1);
+ hex_string = talloc_array(mem_ctx, char, (blob->length*2)+1);
if (!hex_string) {
return NULL;
}
}
}
- w = talloc_p(mem_ctx, struct ldb_wrap);
+ w = talloc(mem_ctx, struct ldb_wrap);
if (w == NULL) {
return NULL;
}
}
}
- w = talloc_p(mem_ctx, struct tdb_wrap);
+ w = talloc(mem_ctx, struct tdb_wrap);
if (w == NULL) {
return NULL;
}
DCERPC_IREMOTEACTIVATION_VERSION,
ctx->domain, ctx->user, ctx->password);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
ZERO_STRUCT(bd);
bd.host = server;
WERROR dcom_init(struct dcom_context **ctx, const char *domain, const char *user, const char *pass)
{
- *ctx = talloc_p(NULL, struct dcom_context);
+ *ctx = talloc(NULL, struct dcom_context);
(*ctx)->oxids = NULL;
(*ctx)->domain = talloc_strdup(*ctx, domain);
(*ctx)->user = talloc_strdup(*ctx, user);
/* Add oxid mapping if we couldn't find one */
if (!m) {
- m = talloc_zero_p(ctx, struct dcom_object_exporter);
+ m = talloc_zero(ctx, struct dcom_object_exporter);
m->oxid = oxid;
DLIST_ADD(ctx->oxids, m);
}
r.in.protseq = protseq;
r.in.Interfaces = num_ifaces;
r.in.pIIDs = iid;
- r.out.ifaces = talloc_array_p(ctx, struct pMInterfacePointer, num_ifaces);
+ r.out.ifaces = talloc_array(ctx, struct pMInterfacePointer, num_ifaces);
r.out.pdsaOxidBindings = &dualstring;
status = dcerpc_RemoteActivation(p, ctx, &r);
return r.out.hr;
}
- *ip = talloc_array_p(ctx, struct dcom_interface_p *, num_ifaces);
+ *ip = talloc_array(ctx, struct dcom_interface_p *, num_ifaces);
for (i = 0; i < num_ifaces; i++) {
results[i] = r.out.results[i];
(*ip)[i] = NULL;
}
if (o == NULL) {
- o = talloc_zero_p(ox, struct dcom_object);
+ o = talloc_zero(ox, struct dcom_object);
o->oid = oid;
DLIST_ADD(ox->objects, o);
}
NTSTATUS dcom_ifacep_from_OBJREF(struct dcom_context *ctx, struct dcom_interface_p **_p, struct OBJREF *o)
{
- struct dcom_interface_p *p = talloc_p(ctx, struct dcom_interface_p);
+ struct dcom_interface_p *p = talloc(ctx, struct dcom_interface_p);
p->ctx = ctx;
p->interface = dcom_interface_by_iid(&o->iid);
DEBUG(3, ("No binding data present yet, resolving OXID %llu\n", p->ox->oxid));
- m = talloc_zero_p(p->ctx, struct dcom_oxid_mapping);
+ m = talloc_zero(p->ctx, struct dcom_oxid_mapping);
m->oxid = oxid;
i = 0;
struct dcom_interface_p *dcom_new_local_ifacep(struct dcom_context *ctx, const struct GUID *iid, void *vtable, struct dcom_object *object)
{
- struct dcom_interface_p *ip = talloc_p(ctx, struct dcom_interface_p);
+ struct dcom_interface_p *ip = talloc(ctx, struct dcom_interface_p);
const struct dcom_interface *iface = dcom_interface_by_iid(iid);
if (!iface) {
DEBUG(5, ("Adding DCOM interface %s\n", GUID_string(lcl_ctx, &iface->iid)));
- talloc_destroy(lcl_ctx);
+ talloc_free(lcl_ctx);
- l = talloc_zero_p(interfaces?interfaces:talloc_autofree_context(),
+ l = talloc_zero(interfaces?interfaces:talloc_autofree_context(),
struct interface_list);
l->interface = *iface;
NTSTATUS dcom_register_class(const void *_class)
{
const struct dcom_class *class = _class;
- struct class_list *l = talloc_zero_p(classes?classes:talloc_autofree_context(),
+ struct class_list *l = talloc_zero(classes?classes:talloc_autofree_context(),
struct class_list);
l->class = *class;
size_t i;
size_t list_len = strlen(list);
- char *retstr = talloc_array_p(mem_ctx, char, len + 1);
+ char *retstr = talloc_array(mem_ctx, char, len + 1);
if (!retstr) return NULL;
generate_random_buffer((uint8_t *)retstr, len);
static int idr_pre_get(struct idr_context *idp)
{
while (idp->id_free_cnt < IDR_FREE_MAX) {
- struct idr_layer *new = talloc_zero_p(idp, struct idr_layer);
+ struct idr_layer *new = talloc_zero(idp, struct idr_layer);
if(new == NULL)
return (0);
free_layer(idp, new);
*/
struct idr_context *idr_init(TALLOC_CTX *mem_ctx)
{
- return talloc_zero_p(mem_ctx, struct idr_context);
+ return talloc_zero(mem_ctx, struct idr_context);
}
/*
NTSTATUS status;
struct fd_event fde2;
- rec = talloc_p(msg, struct messaging_rec);
+ rec = talloc(msg, struct messaging_rec);
if (rec == NULL) {
smb_panic("Unable to allocate messaging_rec");
}
{
struct dispatch_fn *d;
- d = talloc_p(msg, struct dispatch_fn);
+ d = talloc(msg, struct dispatch_fn);
d->msg_type = msg_type;
d->private = private;
d->fn = fn;
NTSTATUS status;
struct fd_event fde;
- rec = talloc_p(msg, struct messaging_rec);
+ rec = talloc(msg, struct messaging_rec);
if (rec == NULL) {
return NT_STATUS_NO_MEMORY;
}
NTSTATUS status;
struct fd_event fde;
- msg = talloc_p(mem_ctx, struct messaging_context);
+ msg = talloc(mem_ctx, struct messaging_context);
if (msg == NULL) {
return NULL;
}
if (pattern[i] == '*' || pattern[i] == '<') count++;
}
- max_n = talloc_array_p(NULL, struct max_n, count);
+ max_n = talloc_array(NULL, struct max_n, count);
if (!max_n) {
return -1;
}
}
exit:
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
return NT_STATUS_OBJECT_NAME_COLLISION;
}
- entry = talloc_p(talloc_autofree_context(), struct reg_init_function_entry);
+ entry = talloc(talloc_autofree_context(), struct reg_init_function_entry);
entry->hive_functions = hive_ops;
DLIST_ADD(backends, entry);
int reg_list_predefs(TALLOC_CTX *mem_ctx, char ***predefs, uint32_t **hkeys)
{
int i;
- *predefs = talloc_array_p(mem_ctx, char *, ARRAY_SIZE(predef_names));
- *hkeys = talloc_array_p(mem_ctx, uint32_t, ARRAY_SIZE(predef_names));
+ *predefs = talloc_array(mem_ctx, char *, ARRAY_SIZE(predef_names));
+ *hkeys = talloc_array(mem_ctx, uint32_t, ARRAY_SIZE(predef_names));
for (i = 0; predef_names[i].name; i++) {
(*predefs)[i] = talloc_strdup(mem_ctx, predef_names[i].name);
WERROR reg_close (struct registry_context *ctx)
{
- talloc_destroy(ctx);
+ talloc_free(ctx);
return WERR_OK;
}
return WERR_NOT_SUPPORTED;
}
- rethive = talloc_p(parent_ctx, struct registry_hive);
+ rethive = talloc(parent_ctx, struct registry_hive);
rethive->location = location?talloc_strdup(rethive, location):NULL;
rethive->functions = entry->hive_functions;
rethive->backend_data = NULL;
TALLOC_CTX *mem_ctx = talloc_init("num_subkeys");
for(i = 0; W_ERROR_IS_OK(error = reg_key_get_subkey_by_index(mem_ctx, key, i, &dest)); i++);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
*count = i;
if(W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) error = WERR_OK;
TALLOC_CTX *mem_ctx = talloc_init("num_subkeys");
for(i = 0; W_ERROR_IS_OK(error = key->hive->functions->get_value_by_index(mem_ctx, key, i, &dest)); i++);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
*count = i;
if(W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) error = WERR_OK;
i++;
} while (W_ERROR_IS_OK(error));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return WERR_OK;
}
i++;
} while (W_ERROR_IS_OK(error));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return WERR_OK;
}
BOOL reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str, const char *data_str, struct registry_value **value)
{
int i;
- *value = talloc_p(mem_ctx, struct registry_value);
+ *value = talloc(mem_ctx, struct registry_value);
(*value)->data_type = -1;
/* Find the correct type */
break;
case REG_DWORD:
(*value)->data_len = sizeof(uint32);
- (*value)->data_blk = talloc_p(mem_ctx, uint32);
+ (*value)->data_blk = talloc(mem_ctx, uint32);
*((uint32 *)(*value)->data_blk) = strtol(data_str, NULL, 0);
break;
error = reg_key_del(parent, n);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return error;
}
if (rmdir(child) == 0) ret = WERR_OK; else ret = WERR_GENERAL_FAILURE;
- talloc_destroy(child);
+ talloc_free(child);
return ret;
}
return WERR_BADFILE;
}
closedir(d);
- ret = talloc_p(mem_ctx, struct registry_key);
+ ret = talloc(mem_ctx, struct registry_key);
ret->hive = p->hive;
ret->path = fullpath;
ret->backend_data = unixpath;
if(S_ISDIR(stbuf.st_mode)) {
if(i == idx) {
- (*key) = talloc_p(mem_ctx, struct registry_key);
+ (*key) = talloc(mem_ctx, struct registry_key);
(*key)->name = e->d_name;
(*key)->path = NULL;
(*key)->backend_data = talloc_strdup(mem_ctx, thispath);
{
if(!h->location) return WERR_INVALID_PARAM;
- *key = talloc_p(h, struct registry_key);
+ *key = talloc(h, struct registry_key);
(*key)->backend_data = talloc_strdup(*key, h->location);
return WERR_OK;
}
h->backend_data = (void *)gconf_client_get_default();
if(!h->backend_data) return WERR_FOOBAR;
- *k = talloc_p(h, struct registry_key);
+ *k = talloc(h, struct registry_key);
(*k)->name = talloc_strdup(*k, "");
(*k)->path = talloc_strdup(*k, "");
(*k)->backend_data = talloc_strdup(*k, "/");
return WERR_DEST_NOT_FOUND;
}
- ret = talloc_p(mem_ctx, struct registry_key);
+ ret = talloc(mem_ctx, struct registry_key);
ret->backend_data = fullpath;
*key = ret;
entry = cur->data;
value = gconf_entry_get_value(entry);
- newval = talloc_p(mem_ctx, struct registry_value);
+ newval = talloc(mem_ctx, struct registry_value);
newval->name = talloc_strdup(mem_ctx, strrchr(gconf_entry_get_key(entry), '/')+1);
if(value) {
switch(value->type) {
case GCONF_VALUE_INT:
newval->data_type = REG_DWORD;
- newval->data_blk = talloc_p(mem_ctx, long);
+ newval->data_blk = talloc(mem_ctx, long);
*((long *)newval->data_blk) = gconf_value_get_int(value);
newval->data_len = sizeof(long);
break;
case GCONF_VALUE_FLOAT:
- newval->data_blk = talloc_p(mem_ctx, double);
+ newval->data_blk = talloc(mem_ctx, double);
newval->data_type = REG_BINARY;
*((double *)newval->data_blk) = gconf_value_get_float(value);
newval->data_len = sizeof(double);
break;
case GCONF_VALUE_BOOL:
- newval->data_blk = talloc_p(mem_ctx, BOOL);
+ newval->data_blk = talloc(mem_ctx, BOOL);
newval->data_type = REG_BINARY;
*((BOOL *)newval->data_blk) = gconf_value_get_bool(value);
newval->data_len = sizeof(BOOL);
if(!cur) return WERR_NO_MORE_ITEMS;
- *sub = talloc_p(mem_ctx, struct registry_key);
+ *sub = talloc(mem_ctx, struct registry_key);
(*sub)->name = talloc_strdup(mem_ctx, strrchr((char *)cur->data, '/')+1);
(*sub)->backend_data = talloc_strdup(mem_ctx, cur->data);
case REG_DWORD_LE:
*len = 4;
- *data = talloc_p(mem_ctx, uint32);
+ *data = talloc(mem_ctx, uint32);
SIVAL(*data, 0, strtol(val->data, NULL, 0));
break;
static struct ldb_message *reg_ldb_pack_value(struct ldb_context *ctx, TALLOC_CTX *mem_ctx, const char *name, uint32 type, void *data, int len)
{
struct ldb_val val;
- struct ldb_message *msg = talloc_zero_p(mem_ctx, struct ldb_message);
+ struct ldb_message *msg = talloc_zero(mem_ctx, struct ldb_message);
char *type_s;
ldb_msg_add_string(ctx, msg, "value", talloc_strdup(mem_ctx, name));
el = ldb_msg_find_element(kd->subkeys[idx], "key");
- *subkey = talloc_p(mem_ctx, struct registry_key);
+ *subkey = talloc(mem_ctx, struct registry_key);
talloc_set_destructor(*subkey, reg_close_ldb_key);
(*subkey)->name = talloc_strdup(mem_ctx, el->values[0].data);
- (*subkey)->backend_data = newkd = talloc_zero_p(*subkey, struct ldb_key_data);
+ (*subkey)->backend_data = newkd = talloc_zero(*subkey, struct ldb_key_data);
newkd->dn = talloc_strdup(mem_ctx, kd->subkeys[idx]->dn);
return WERR_OK;
if(idx >= kd->value_count) return WERR_NO_MORE_ITEMS;
- *value = talloc_p(mem_ctx, struct registry_value);
+ *value = talloc(mem_ctx, struct registry_value);
reg_ldb_unpack_value(mem_ctx, kd->values[idx], &(*value)->name, &(*value)->data_type, &(*value)->data_blk, &(*value)->data_len);
return WERR_FOOBAR;
}
- *key = talloc_p(mem_ctx, struct registry_key);
+ *key = talloc(mem_ctx, struct registry_key);
talloc_set_destructor(*key, reg_close_ldb_key);
(*key)->name = talloc_strdup(mem_ctx, strrchr(name, '\\')?strchr(name, '\\'):name);
- (*key)->backend_data = newkd = talloc_zero_p(*key, struct ldb_key_data);
+ (*key)->backend_data = newkd = talloc_zero(*key, struct ldb_key_data);
newkd->dn = talloc_strdup(mem_ctx, msg[0]->dn);
ldb_search_free(c, msg);
ldb_set_debug_stderr(c);
hive->backend_data = c;
- *k = talloc_zero_p(hive, struct registry_key);
+ *k = talloc_zero(hive, struct registry_key);
talloc_set_destructor (*k, reg_close_ldb_key);
talloc_set_destructor (hive, ldb_close_hive);
(*k)->name = talloc_strdup(*k, "");
- (*k)->backend_data = kd = talloc_zero_p(*k, struct ldb_key_data);
+ (*k)->backend_data = kd = talloc_zero(*k, struct ldb_key_data);
kd->dn = talloc_strdup(*k, "hive=");
return WERR_FOOBAR;
}
- *newkey = talloc_zero_p(mem_ctx, struct registry_key);
+ *newkey = talloc_zero(mem_ctx, struct registry_key);
(*newkey)->name = talloc_strdup(mem_ctx, name);
- (*newkey)->backend_data = newkd = talloc_zero_p(*newkey, struct ldb_key_data);
+ (*newkey)->backend_data = newkd = talloc_zero(*newkey, struct ldb_key_data);
newkd->dn = talloc_steal(newkd, msg->dn);
return WERR_OK;
ret = ldb_delete(key->hive->backend_data, childdn);
- talloc_destroy(childdn);
+ talloc_free(childdn);
if (ret < 0) {
DEBUG(1, ("ldb_del_key: %s\n", ldb_errstring(key->hive->backend_data)));
ret = ldb_delete(key->hive->backend_data, childdn);
- talloc_destroy(childdn);
+ talloc_free(childdn);
if (ret < 0) {
DEBUG(1, ("ldb_del_value: %s\n", ldb_errstring(key->hive->backend_data)));
ret = ldb_modify(ctx, msg);
if (ret < 0) {
DEBUG(1, ("ldb_msg_add: %s\n", ldb_errstring(parent->hive->backend_data)));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return WERR_FOOBAR;
}
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return WERR_OK;
}
dat_len = IVAL(&vk_hdr->dat_len,0); /* If top bit, offset contains data */
dat_off = IVAL(&vk_hdr->dat_off,0);
- tmp = talloc_p(mem_ctx, struct registry_value);
+ tmp = talloc(mem_ctx, struct registry_value);
tmp->data_type = dat_type;
if (flag & FLAG_HAS_NAME) {
return WERR_GENERAL_FAILURE;
}
- tmp = talloc_p(mem_ctx, struct registry_key);
+ tmp = talloc(mem_ctx, struct registry_key);
tmp->name = talloc_strdup(mem_ctx, key_name);
tmp->backend_data = nk_hdr;
uint_t regf_id, hbin_id;
HBIN_HDR *hbin_hdr;
- regf = (REGF *)talloc_p(h, REGF);
+ regf = (REGF *)talloc(h, REGF);
memset(regf, 0, sizeof(REGF));
regf->owner_sid_str = NULL; /* FIXME: Fill in */
h->backend_data = regf;
return WERR_NO_MORE_ITEMS;
}
- h = talloc_p(ctx, struct registry_hive);
+ h = talloc(ctx, struct registry_hive);
h->functions = ®_backend_rpc;
h->location = NULL;
h->backend_data = ctx->backend_data;
- (*k) = h->root = talloc_p(h, struct registry_key);
+ (*k) = h->root = talloc(h, struct registry_key);
(*k)->hive = h;
- (*k)->backend_data = mykeydata = talloc_p(*k, struct rpc_key_data);
+ (*k)->backend_data = mykeydata = talloc(*k, struct rpc_key_data);
mykeydata->num_values = -1;
mykeydata->num_subkeys = -1;
return known_hives[n].open((struct dcerpc_pipe *)ctx->backend_data, *k, &(mykeydata->pol));
struct winreg_OpenKey r;
struct rpc_key_data *mykeydata;
- k->backend_data = mykeydata = talloc_p(mem_ctx, struct rpc_key_data);
+ k->backend_data = mykeydata = talloc(mem_ctx, struct rpc_key_data);
mykeydata->num_values = -1;
mykeydata->num_subkeys = -1;
struct rpc_key_data *mykeydata;
struct winreg_OpenKey r;
- *key = talloc_p(mem_ctx, struct registry_key);
+ *key = talloc(mem_ctx, struct registry_key);
(*key)->name = talloc_strdup(mem_ctx, name);
- (*key)->backend_data = mykeydata = talloc_p(mem_ctx, struct rpc_key_data);
+ (*key)->backend_data = mykeydata = talloc(mem_ctx, struct rpc_key_data);
mykeydata->num_values = -1;
mykeydata->num_subkeys = -1;
if(NT_STATUS_IS_OK(status) &&
W_ERROR_IS_OK(r.out.result) && r.out.length) {
- *value = talloc_p(mem_ctx, struct registry_value);
+ *value = talloc(mem_ctx, struct registry_value);
(*value)->name = talloc_strdup(mem_ctx, r.out.name_out.name);
(*value)->data_type = type;
(*value)->data_len = *r.out.length;
init_winreg_String(&r.in.class, NULL);
r.in.handle = parent->backend_data;
- r.out.handle = talloc_p(mem_ctx, struct policy_handle);
+ r.out.handle = talloc(mem_ctx, struct policy_handle);
r.in.options = 0;
r.in.access_mask = access_mask;
r.in.sec_desc = NULL;
}
if (W_ERROR_IS_OK(r.out.result)) {
- *key = talloc_p(mem_ctx, struct registry_key);
+ *key = talloc(mem_ctx, struct registry_key);
(*key)->name = talloc_strdup(*key, name);
(*key)->backend_data = r.out.handle;
}
r.in.handle = &mykeydata->pol;
status = dcerpc_winreg_QueryInfoKey((struct dcerpc_pipe *)(k->hive->backend_data), mem_ctx, &r);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("QueryInfoKey failed - %s\n", nt_errstr(status)));
status = dcerpc_winreg_DeleteKey((struct dcerpc_pipe *)parent->hive->backend_data, mem_ctx, &r);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return r.out.result;
}
NTSTATUS status;
struct dcerpc_pipe *p;
- *ctx = talloc_p(NULL, struct registry_context);
+ *ctx = talloc(NULL, struct registry_context);
/* Default to local smbd if no connection is specified */
if (!location) {
DWORD i;
DWORD offset;
- creg = talloc_p(h, CREG);
+ creg = talloc(h, CREG);
memset(creg, 0, sizeof(CREG));
h->backend_data = creg;
}
#endif
- creg->rgdb_keys = talloc_array_p(h, RGDB_KEY **, creg->creg_hdr->num_rgdb);
+ creg->rgdb_keys = talloc_array(h, RGDB_KEY **, creg->creg_hdr->num_rgdb);
offset = 0;
DEBUG(3, ("Reading %d rgdb entries\n", creg->creg_hdr->num_rgdb));
}
- creg->rgdb_keys[i] = talloc_array_p(h, RGDB_KEY *, rgdb_hdr->max_id+1);
+ creg->rgdb_keys[i] = talloc_array(h, RGDB_KEY *, rgdb_hdr->max_id+1);
memset(creg->rgdb_keys[i], 0, sizeof(RGDB_KEY *) * (rgdb_hdr->max_id+1));
parse_rgdb_block(creg, rgdb_hdr);
}
/* First element in rgkn should be root key */
- *root = talloc_p(h, struct registry_key);
+ *root = talloc(h, struct registry_key);
(*root)->name = NULL;
(*root)->backend_data = LOCN_RGKN(creg, sizeof(RGKN_HDR));
DEBUG(0, ("Can't find %d,%d in RGDB table!\n", child->id.rgdb, child->id.id));
return WERR_FOOBAR;
}
- *key = talloc_p(mem_ctx, struct registry_key);
+ *key = talloc(mem_ctx, struct registry_key);
(*key)->backend_data = child;
(*key)->name = talloc_strndup(mem_ctx, (char *)rgdb_key + sizeof(RGDB_KEY), rgdb_key->name_len);
return WERR_OK;
offset+=sizeof(RGDB_VALUE) + curval->name_len + curval->data_len;
}
- *value = talloc_p(mem_ctx, struct registry_value);
+ *value = talloc(mem_ctx, struct registry_value);
(*value)->name = talloc_strndup(mem_ctx, (char *)curval+sizeof(RGDB_VALUE), curval->name_len);
(*value)->data_len = curval->data_len;
error = reg_open_hive(ctx, backend, location, NULL, k);
- talloc_destroy(backend);
+ talloc_free(backend);
return error;
}
WERROR reg_open_local (struct registry_context **ctx)
{
- *ctx = talloc_p(NULL, struct registry_context);
+ *ctx = talloc(NULL, struct registry_context);
(*ctx)->get_predefined_key = reg_samba_get_predef;
return WERR_OK;
}
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
writediff(t2, t1, out);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
}
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
}
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
break;
} else {
printf("Error creating completion list: %s\n", win_errstr(status));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NULL;
}
}
if (j == 1) { /* No matches at all */
SAFE_FREE(matches);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NULL;
}
} else {
asprintf(&matches[0], "%s%s", base_n, talloc_strndup(mem_ctx, matches[1], samelen));
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
matches[j] = NULL;
return matches;
if(new)curkey = new;
}
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return 0;
}
for(i = 0; W_ERROR_IS_OK(error = reg_key_get_subkey_by_index(mem_ctx, p, i, &subkey)); i++) {
print_tree(l+1, subkey, fullpath, novals);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
DEBUG(0, ("Error occured while fetching subkeys for '%s': %s\n", p->path, win_errstr(error)));
desc = reg_val_description(mem_ctx, value);
printf("%s\n", desc);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
DEBUG(0, ("Error occured while fetching values for '%s': %s\n", p->path, win_errstr(error)));
* --metze
*/
- (*new_sock) = talloc_p(NULL, struct socket_context);
+ (*new_sock) = talloc(NULL, struct socket_context);
if (!(*new_sock)) {
close(new_fd);
return NT_STATUS_NO_MEMORY;
* --metze
*/
- (*new_sock) = talloc_p(NULL, struct socket_context);
+ (*new_sock) = talloc(NULL, struct socket_context);
if (!(*new_sock)) {
close(new_fd);
return NT_STATUS_NO_MEMORY;
}
}
- (*new_sock) = talloc_p(NULL, struct socket_context);
+ (*new_sock) = talloc(NULL, struct socket_context);
if (!(*new_sock)) {
close(new_fd);
return NT_STATUS_NO_MEMORY;
void *root_privileges(void)
{
struct saved_state *s;
- s = talloc_p(NULL, struct saved_state);
+ s = talloc(NULL, struct saved_state);
if (!s) return NULL;
s->uid = geteuid();
if (s->uid != 0) {
sock_out.sin_port = htons(port);
sock_out.sin_family = PF_INET;
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
close(res);
{
char *dup_str = talloc_strdup(mem_ctx, str);
- *strings = talloc_realloc_p(mem_ctx,
+ *strings = talloc_realloc(mem_ctx,
*strings,
const char *, ((*num)+1));
}
upcase_table = map_file(lib_path(mem_ctx, "upcase.dat"), 0x20000);
lowcase_table = map_file(lib_path(mem_ctx, "lowcase.dat"), 0x20000);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (upcase_table == NULL) {
upcase_table = (void *)-1;
}
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;
ldap_controls_free(rcontrols);
done:
- talloc_destroy(ctx);
+ talloc_free(ctx);
/* if/when we decide to utf8-encode attrs, take out this next line */
str_list_free(&search_attrs);
}
done:
- talloc_destroy(ctx);
+ talloc_free(ctx);
/* if/when we decide to utf8-encode attrs, take out this next line */
str_list_free(&search_attrs);
return ADS_ERROR(rc);
*mods = 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) {
}
}
done:
- talloc_destroy(ctx);
+ talloc_free(ctx);
return ret;
}
/* parse secdesc */
if (!sec_io_desc("sd", &psd, &ps, 1)) {
prs_mem_free(&ps);
- talloc_destroy(ctx);
+ talloc_free(ctx);
return;
}
if (psd) ads_disp_sd(psd);
prs_mem_free(&ps);
- talloc_destroy(ctx);
+ talloc_free(ctx);
}
/*
fn(NULL, NULL, data_area); /* completed an entry */
}
- talloc_destroy(ctx);
+ talloc_free(ctx);
}
/**
ads_set_sd_error:
ads_msgfree(ads, res);
prs_mem_free(&ps_wire);
- talloc_destroy(ctx);
+ talloc_free(ctx);
return ret;
}
*num_values = ldap_count_values(values);
- ret = talloc_array_p(mem_ctx, char *, *num_values+1);
+ ret = talloc_array(mem_ctx, char *, *num_values+1);
if (!ret) {
ldap_value_free(values);
return NULL;
for (i=0; values[i]; i++)
/* nop */ ;
- (*sids) = talloc_array_p(mem_ctx, DOM_SID, i);
+ (*sids) = talloc_array(mem_ctx, DOM_SID, i);
if (!(*sids)) {
ldap_value_free_len(values);
return 0;
p = strchr(value, ':');
if (!p) {
- talloc_destroy(ctx);
+ talloc_free(ctx);
DEBUG(1, ("ads_server_info: returned ldap server name did not contain a ':' "
"so was deemed invalid\n"));
return ADS_ERROR(LDAP_DECODING_ERROR);
ads->config.ldap_server_name = strdup(p+1);
p = strchr(ads->config.ldap_server_name, '$');
if (!p || p[1] != '@') {
- talloc_destroy(ctx);
+ talloc_free(ctx);
DEBUG(1, ("ads_server_info: returned ldap server name (%s) does not contain '$@'"
" so was deemed invalid\n", ads->config.ldap_server_name));
SAFE_FREE(ads->config.ldap_server_name);
DEBUG(4,("time offset is %d seconds\n", ads->auth.time_offset));
}
- talloc_destroy(ctx);
+ talloc_free(ctx);
return ADS_SUCCESS;
}
};
if (num_vals) {
- str_values = talloc_array_p(ctx, char *, num_vals + 1);
+ str_values = talloc_array(ctx, char *, num_vals + 1);
cur_str = value->data_p;
for (i=0; i < num_vals; i++) {
pull_ucs2_talloc(ctx, &str_values[i], cur_str);
status = ads_gen_add(ads, new_dn, mods);
done:
- talloc_destroy(ctx);
+ talloc_free(ctx);
return status;
}
status = ads_gen_add(ads, new_dn, mods);
done:
- talloc_destroy(ctx);
+ talloc_free(ctx);
return status;
}
#endif
krb5_cc_default_name(context),
http_timestring(mem_ctx, credsp->times.endtime)));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
/* we will probably need new tickets if the current ones
will expire within 10 seconds.
if (!ops) {
return NULL;
}
- oid_list = talloc_array_p(mem_ctx, const char *, num_backends + 1);
+ oid_list = talloc_array(mem_ctx, const char *, num_backends + 1);
if (!oid_list) {
return NULL;
}
*/
static NTSTATUS gensec_start(TALLOC_CTX *mem_ctx, struct gensec_security **gensec_security)
{
- (*gensec_security) = talloc_p(mem_ctx, struct gensec_security);
+ (*gensec_security) = talloc(mem_ctx, struct gensec_security);
if (!(*gensec_security)) {
return NT_STATUS_NO_MEMORY;
}
struct gensec_security *parent,
struct gensec_security **gensec_security)
{
- (*gensec_security) = talloc_p(mem_ctx, struct gensec_security);
+ (*gensec_security) = talloc(mem_ctx, struct gensec_security);
if (!(*gensec_security)) {
return NT_STATUS_NO_MEMORY;
}
{
struct gensec_gssapi_state *gensec_gssapi_state;
- gensec_gssapi_state = talloc_p(gensec_security, struct gensec_gssapi_state);
+ gensec_gssapi_state = talloc(gensec_security, struct gensec_gssapi_state);
if (!gensec_gssapi_state) {
return NT_STATUS_NO_MEMORY;
}
struct gensec_krb5_state *gensec_krb5_state;
krb5_error_code ret = 0;
- gensec_krb5_state = talloc_p(gensec_security, struct gensec_krb5_state);
+ gensec_krb5_state = talloc(gensec_security, struct gensec_krb5_state);
if (!gensec_krb5_state) {
return NT_STATUS_NO_MEMORY;
}
{
struct gensec_ntlmssp_state *gensec_ntlmssp_state;
- gensec_ntlmssp_state = talloc_p(gensec_security, struct gensec_ntlmssp_state);
+ gensec_ntlmssp_state = talloc(gensec_security, struct gensec_ntlmssp_state);
if (!gensec_ntlmssp_state) {
return NT_STATUS_NO_MEMORY;
}
NTSTATUS ntlmssp_server_start(TALLOC_CTX *mem_ctx, struct ntlmssp_state **ntlmssp_state)
{
- *ntlmssp_state = talloc_p(mem_ctx, struct ntlmssp_state);
+ *ntlmssp_state = talloc(mem_ctx, struct ntlmssp_state);
if (!*ntlmssp_state) {
DEBUG(0,("ntlmssp_server_start: talloc failed!\n"));
return NT_STATUS_NO_MEMORY;
NTSTATUS ntlmssp_client_start(TALLOC_CTX *mem_ctx, struct ntlmssp_state **ntlmssp_state)
{
- *ntlmssp_state = talloc_p(mem_ctx, struct ntlmssp_state);
+ *ntlmssp_state = talloc(mem_ctx, struct ntlmssp_state);
if (!*ntlmssp_state) {
DEBUG(0,("ntlmssp_client_start: talloc failed!\n"));
return NT_STATUS_NO_MEMORY;
DATA_BLOB *pointers;
- pointers = talloc_array_p(mem_ctx, DATA_BLOB, strlen(format));
- intargs = talloc_array_p(pointers, int, strlen(format));
+ pointers = talloc_array(mem_ctx, DATA_BLOB, strlen(format));
+ intargs = talloc_array(pointers, int, strlen(format));
/* first scan the format to work out the header and body size */
va_start(ap, format);
const uint8_t session_key[16],
BOOL initiator)
{
- (*state) = talloc_p(NULL, struct schannel_state);
+ (*state) = talloc(NULL, struct schannel_state);
if (!(*state)) {
return NT_STATUS_NO_MEMORY;
}
{
struct spnego_state *spnego_state;
- spnego_state = talloc_p(gensec_security, struct spnego_state);
+ spnego_state = talloc(gensec_security, struct spnego_state);
if (!spnego_state) {
return NT_STATUS_NO_MEMORY;
}
{
struct spnego_state *spnego_state;
- spnego_state = talloc_p(gensec_security, struct spnego_state);
+ spnego_state = talloc(gensec_security, struct spnego_state);
if (!spnego_state) {
return NT_STATUS_NO_MEMORY;
}
asn1_start_tag(asn1, ASN1_CONTEXT(0));
asn1_start_tag(asn1, ASN1_SEQUENCE(0));
- token->mechTypes = talloc_p(NULL, const char *);
+ token->mechTypes = talloc(NULL, const char *);
for (i = 0; !asn1->has_error &&
0 < asn1_tag_remaining(asn1); i++) {
token->mechTypes = talloc_realloc(NULL,
{
struct smbcli_state *cli;
- cli = talloc_zero_p(mem_ctx, struct smbcli_state);
+ cli = talloc_zero(mem_ctx, struct smbcli_state);
if (cli) {
ZERO_STRUCTP(cli);
}
open_parms.ntcreatex.in.fname = fname;
status = smb_raw_open(tree, mem_ctx, &open_parms);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (NT_STATUS_IS_OK(status)) {
return open_parms.ntcreatex.out.fnum;
open_parms.openx.in.fname = fname;
status = smb_raw_open(tree, mem_ctx, &open_parms);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (NT_STATUS_IS_OK(status)) {
return open_parms.openx.out.fnum;
*avail = fsinfo_parms.dskattr.out.units_free;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
if (tmp_path) {
*tmp_path = strdup(open_parms.ctemp.out.name);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (NT_STATUS_IS_OK(status)) {
return open_parms.ctemp.out.fnum;
}
state.mem_ctx, &first_parms,
(void*)&state, smbcli_list_new_callback);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(state.mem_ctx);
+ talloc_free(state.mem_ctx);
return -1;
}
fn(&state.dirlist[i], Mask, caller_state);
}
- talloc_destroy(state.mem_ctx);
+ talloc_free(state.mem_ctx);
return state.total_received;
}
smbcli_list_old_callback);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(state.mem_ctx);
+ talloc_free(state.mem_ctx);
return -1;
}
break;
}
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(state.mem_ctx);
+ talloc_free(state.mem_ctx);
return -1;
}
received = next_parms.search_next.out.count;
fn(&state.dirlist[i], Mask, caller_state);
}
- talloc_destroy(state.mem_ctx);
+ talloc_free(state.mem_ctx);
return state.total_received;
}
parms.standard.in.fname = fname;
status = smb_raw_pathinfo(tree, mem_ctx, &parms);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (!NT_STATUS_IS_OK(status))
return status;
parms.all_info.in.fname = fname;
status = smb_raw_pathinfo(tree, mem_ctx, &parms);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (!NT_STATUS_IS_OK(status))
return status;
status = smb_raw_fileinfo(tree, mem_ctx, &parms);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
*name = NULL;
return status;
}
*name = strdup(parms.name_info.out.fname.s);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
parms.all_info.in.fnum = fnum;
status = smb_raw_fileinfo(tree, mem_ctx, &parms);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
status = smb_raw_pathinfo(tree, mem_ctx, &parms);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
*alt_name = NULL;
return smbcli_nt_error(tree);
}
*alt_name = strdup(parms.alt_name_info.out.fname.s);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NT_STATUS_OK;
}
if (val && strchr("()&|", *val))
return NULL;
- ret = talloc_p(mem_ctx, struct ldap_parse_tree);
+ ret = talloc(mem_ctx, struct ldap_parse_tree);
if (!ret) {
errno = ENOMEM;
return NULL;
{
struct ldap_parse_tree *ret, *next;
- ret = talloc_p(mem_ctx, struct ldap_parse_tree);
+ ret = talloc(mem_ctx, struct ldap_parse_tree);
if (!ret) {
errno = ENOMEM;
return NULL;
ret->operation = op;
ret->u.list.num_elements = 1;
- ret->u.list.elements = talloc_p(mem_ctx, struct ldap_parse_tree *);
+ ret->u.list.elements = talloc(mem_ctx, struct ldap_parse_tree *);
if (!ret->u.list.elements) {
errno = ENOMEM;
return NULL;
while (*s && (next = ldap_parse_filter(mem_ctx, &s))) {
struct ldap_parse_tree **e;
- e = talloc_realloc_p(ret,
+ e = talloc_realloc(ret,
ret->u.list.elements,
struct ldap_parse_tree *,
ret->u.list.num_elements+1);
{
struct ldap_parse_tree *ret;
- ret = talloc_p(mem_ctx, struct ldap_parse_tree);
+ ret = talloc(mem_ctx, struct ldap_parse_tree);
if (!ret) {
errno = ENOMEM;
return NULL;
ldap_push_filter(&data, tree);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
asn1_push_tag(&data, ASN1_SEQUENCE(0));
for (i=0; asn1_peek_tag(data, ASN1_SEQUENCE(0)); i++) {
asn1_start_tag(data, ASN1_SEQUENCE(0));
- ctrl = talloc_realloc_p(msg->mem_ctx, ctrl, struct ldap_Control, i+1);
+ ctrl = talloc_realloc(msg->mem_ctx, ctrl, struct ldap_Control, i+1);
if (!ctrl) {
return False;
}
{
struct ldap_connection *result;
- result = talloc_p(mem_ctx, struct ldap_connection);
+ result = talloc(mem_ctx, struct ldap_connection);
if (!result) {
return NULL;
{
struct ldap_message *result;
- result = talloc_p(mem_ctx, struct ldap_message);
+ result = talloc(mem_ctx, struct ldap_message);
if (!result) {
return NULL;
done:
if (mem_ctx)
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return result;
}
BOOL add_value_to_attrib(TALLOC_CTX *mem_ctx, struct ldap_val *value,
struct ldap_attribute *attrib)
{
- attrib->values = talloc_realloc_p(mem_ctx,
+ attrib->values = talloc_realloc(mem_ctx,
attrib->values,
DATA_BLOB,
attrib->num_values+1);
struct ldap_attribute **attribs,
int *num_attribs)
{
- *attribs = talloc_realloc_p(mem_ctx,
+ *attribs = talloc_realloc(mem_ctx,
*attribs,
struct ldap_attribute,
*num_attribs+1);
}
if (attrib == NULL) {
- r->attributes = talloc_realloc_p(msg->mem_ctx,
+ r->attributes = talloc_realloc(msg->mem_ctx,
r->attributes,
struct ldap_attribute,
r->num_attributes+1);
struct ldap_mod **mods,
int *num_mods)
{
- *mods = talloc_realloc_p(mem_ctx, *mods, struct ldap_mod, (*num_mods)+1);
+ *mods = talloc_realloc(mem_ctx, *mods, struct ldap_mod, (*num_mods)+1);
if (*mods == NULL)
return False;
return NT_STATUS_INVALID_PARAMETER;
}
- io->query_secdesc.out.sd = talloc_p(mem_ctx, struct security_descriptor);
+ io->query_secdesc.out.sd = talloc(mem_ctx, struct security_descriptor);
if (!io->query_secdesc.out.sd) {
return NT_STATUS_NO_MEMORY;
}
blob2.data = blob->data + ofs;
blob2.length = ea_size - ofs;
- *eas = talloc_realloc_p(mem_ctx, *eas, struct ea_struct, n+1);
+ *eas = talloc_realloc(mem_ctx, *eas, struct ea_struct, n+1);
if (! *eas) return NT_STATUS_NO_MEMORY;
len = ea_pull_struct(&blob2, mem_ctx, &(*eas)[n]);
blob2.data = blob->data + ofs + 4;
blob2.length = blob->length - (ofs + 4);
- *eas = talloc_realloc_p(mem_ctx, *eas, struct ea_struct, n+1);
+ *eas = talloc_realloc(mem_ctx, *eas, struct ea_struct, n+1);
if (! *eas) return NT_STATUS_NO_MEMORY;
len = ea_pull_struct(&blob2, mem_ctx, &(*eas)[n]);
blob2.data = blob->data + ofs;
blob2.length = ea_size - ofs;
- *ea_names = talloc_realloc_p(mem_ctx, *ea_names, struct ea_name, n+1);
+ *ea_names = talloc_realloc(mem_ctx, *ea_names, struct ea_name, n+1);
if (! *ea_names) return NT_STATUS_NO_MEMORY;
len = ea_pull_name(&blob2, mem_ctx, &(*ea_names)[n]);
req = smb_raw_trans2_send(tree, &t2);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return req;
}
req = smb_raw_trans2_send(tree, &t2);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return req;
}
while (blob->length - ofs >= 24) {
uint_t n = parms->stream_info.out.num_streams;
parms->stream_info.out.streams =
- talloc_realloc_p(mem_ctx,
+ talloc_realloc(mem_ctx,
parms->stream_info.out.streams,
struct stream_struct,
n+1);
tp.in.params = data_blob_talloc(mem_ctx, NULL, 4);
if (!tp.in.params.data) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NULL;
}
req = smb_raw_trans2_send(tree, &tp);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return req;
}
tp.in.params = data_blob_talloc(mem_ctx, NULL, 6);
if (!tp.in.params.data) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NULL;
}
req = smb_raw_trans2_send(tree, &tp);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return req;
}
{
struct smbcli_request *req;
- req = talloc_p(transport, struct smbcli_request);
+ req = talloc(transport, struct smbcli_request);
if (!req) {
return NULL;
}
if (!mem_ctx) return NULL;
if (!smb_raw_setinfo_backend(tree, mem_ctx, parms, &blob)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NULL;
}
parms->generic.level,
&blob);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return req;
}
if (!mem_ctx) return NULL;
if (!smb_raw_setinfo_backend(tree, mem_ctx, parms, &blob)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NULL;
}
parms->generic.level,
&blob);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return req;
}
if (sidstr[i] == '-') num_sub_auths++;
}
- ret = talloc_p(mem_ctx, struct dom_sid);
+ ret = talloc(mem_ctx, struct dom_sid);
if (!ret) {
return NULL;
}
- ret->sub_auths = talloc_array_p(mem_ctx, uint32_t, num_sub_auths);
+ ret->sub_auths = talloc_array(mem_ctx, uint32_t, num_sub_auths);
if (!ret->sub_auths) {
return NULL;
}
{
struct dom_sid *ret;
int i;
- ret = talloc_p(mem_ctx, struct dom_sid);
+ ret = talloc(mem_ctx, struct dom_sid);
if (!ret) {
return NULL;
}
- ret->sub_auths = talloc_array_p(ret, uint32_t, dom_sid->num_auths);
+ ret->sub_auths = talloc_array(ret, uint32_t, dom_sid->num_auths);
if (!ret->sub_auths) {
return NULL;
}
{
struct dom_sid *sid;
- sid = talloc_p(mem_ctx, struct dom_sid);
+ sid = talloc(mem_ctx, struct dom_sid);
if (!sid) return NULL;
*sid = *domain_sid;
- sid->sub_auths = talloc_array_p(sid, uint32_t, sid->num_auths+1);
+ sid->sub_auths = talloc_array(sid, uint32_t, sid->num_auths+1);
if (!sid->sub_auths) {
return NULL;
}
{
struct security_descriptor *sd;
- sd = talloc_p(mem_ctx, struct security_descriptor);
+ sd = talloc(mem_ctx, struct security_descriptor);
if (!sd) {
return NULL;
}
const struct security_ace *ace)
{
if (sd->dacl == NULL) {
- sd->dacl = talloc_p(sd, struct security_acl);
+ sd->dacl = talloc(sd, struct security_acl);
if (sd->dacl == NULL) {
return NT_STATUS_NO_MEMORY;
}
sd->dacl->aces = NULL;
}
- sd->dacl->aces = talloc_realloc_p(sd->dacl, sd->dacl->aces,
+ sd->dacl->aces = talloc_realloc(sd->dacl, sd->dacl->aces,
struct security_ace, sd->dacl->num_aces+1);
if (sd->dacl->aces == NULL) {
return NT_STATUS_NO_MEMORY;
va_start(ap, group_sid);
while ((sidstr = va_arg(ap, const char *))) {
struct dom_sid *sid;
- struct security_ace *ace = talloc_p(sd, struct security_ace);
+ struct security_ace *ace = talloc(sd, struct security_ace);
NTSTATUS status;
if (ace == NULL) {
{
struct security_token *st;
- st = talloc_p(mem_ctx, struct security_token);
+ st = talloc(mem_ctx, struct security_token);
if (!st) {
return NULL;
}
ptoken = security_token_initialise(mem_ctx);
NT_STATUS_HAVE_NO_MEMORY(ptoken);
- ptoken->sids = talloc_array_p(ptoken, struct dom_sid *, n_groupSIDs + 5);
+ ptoken->sids = talloc_array(ptoken, struct dom_sid *, n_groupSIDs + 5);
NT_STATUS_HAVE_NO_MEMORY(ptoken->sids);
ptoken->user_sid = talloc_reference(ptoken, user_sid);
}
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
struct nesting *nesting;
asn1_write_uint8(data, tag);
- nesting = talloc_p(NULL, struct nesting);
+ nesting = talloc(NULL, struct nesting);
if (!nesting) {
data->has_error = True;
return False;
data->has_error = True;
return False;
}
- nesting = talloc_p(NULL, struct nesting);
+ nesting = talloc(NULL, struct nesting);
if (!nesting) {
data->has_error = True;
return False;
return NT_STATUS_OK;
}
- lsa = talloc_p(cli, struct smblsa_state);
+ lsa = talloc(cli, struct smblsa_state);
if (lsa == NULL) {
return NT_STATUS_NO_MEMORY;
}
names.names = NULL;
sids.num_sids = 1;
- sids.sids = talloc_p(mem_ctx2, struct lsa_SidPtr);
+ sids.sids = talloc(mem_ctx2, struct lsa_SidPtr);
sids.sids[0].sid = sid;
r.in.handle = &cli->lsa->handle;
memcpy(final_response.data+sizeof(ntlmv2_response),
ntlmv2_client_data.data, ntlmv2_client_data.length);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return final_response;
}
mem_ctx = talloc_init("libnet_context");
- ctx = talloc_p(mem_ctx, struct libnet_context);
+ ctx = talloc(mem_ctx, struct libnet_context);
if (!ctx) {
return NULL;
}
void libnet_context_destroy(struct libnet_context **libnetctx)
{
- talloc_destroy((*libnetctx)->mem_ctx);
+ talloc_free((*libnetctx)->mem_ctx);
(*libnetctx) = NULL;
}
/* prepare samr_LookupNames */
ln.in.domain_handle = &d_handle;
ln.in.num_names = 1;
- ln.in.names = talloc_array_p(mem_ctx, struct samr_String, 1);
+ ln.in.names = talloc_array(mem_ctx, struct samr_String, 1);
if (!ln.in.names) {
r->samr.out.error_string = "Out of Memory";
return NT_STATUS_NO_MEMORY;
/* prepare samr_LookupNames */
ln.in.domain_handle = &d_handle;
ln.in.num_names = 1;
- ln.in.names = talloc_array_p(mem_ctx, struct samr_String, 1);
+ ln.in.names = talloc_array(mem_ctx, struct samr_String, 1);
if (!ln.in.names) {
r->samr.out.error_string = "Out of Memory";
return NT_STATUS_NO_MEMORY;
{
struct ndr_pull *ndr;
- ndr = talloc_zero_p(mem_ctx, struct ndr_pull);
+ ndr = talloc_zero(mem_ctx, struct ndr_pull);
if (!ndr) return NULL;
ndr->data = blob->data;
{
struct ndr_push *ndr;
- ndr = talloc_zero_p(mem_ctx, struct ndr_push);
+ ndr = talloc_zero(mem_ctx, struct ndr_push);
if (!ndr) {
return NULL;
}
ndr->flags = 0;
ndr->alloc_size = NDR_BASE_MARSHALL_SIZE;
- ndr->data = talloc_array_p(ndr, uint8_t, ndr->alloc_size);
+ ndr->data = talloc_array(ndr, uint8_t, ndr->alloc_size);
if (!ndr->data) {
return NULL;
}
{
struct ndr_print *ndr;
- ndr = talloc_p(NULL, struct ndr_print);
+ ndr = talloc(NULL, struct ndr_print);
if (!ndr) return;
ndr->print = ndr_print_debug_helper;
ndr->depth = 1;
{
struct ndr_print *ndr;
- ndr = talloc_p(NULL, struct ndr_print);
+ ndr = talloc(NULL, struct ndr_print);
if (!ndr) return;
ndr->print = ndr_print_debug_helper;
ndr->depth = 1;
{
struct ndr_print *ndr;
- ndr = talloc_p(NULL, struct ndr_print);
+ ndr = talloc(NULL, struct ndr_print);
if (!ndr) return;
ndr->print = ndr_print_debug_helper;
ndr->depth = 1;
uint32_t value)
{
struct ndr_token_list *tok;
- tok = talloc_p(mem_ctx, struct ndr_token_list);
+ tok = talloc(mem_ctx, struct ndr_token_list);
if (tok == NULL) {
return NT_STATUS_NO_MEMORY;
}
NDR_CHECK(ndr_pull_uint16(ndr, &num_entries));
NDR_CHECK(ndr_pull_uint16(ndr, &security_offset));
- ar->stringbindings = talloc_array_p(ndr, struct STRINGBINDING *, num_entries);
+ ar->stringbindings = talloc_array(ndr, struct STRINGBINDING *, num_entries);
ar->stringbindings[0] = NULL;
do {
if (towerid > 0) {
ndr->offset -= 2;
- ar->stringbindings = talloc_realloc_p(ndr, ar->stringbindings, struct STRINGBINDING *, towernum+2);
- ar->stringbindings[towernum] = talloc_p(ndr, struct STRINGBINDING);
+ ar->stringbindings = talloc_realloc(ndr, ar->stringbindings, struct STRINGBINDING *, towernum+2);
+ ar->stringbindings[towernum] = talloc(ndr, struct STRINGBINDING);
NDR_CHECK(ndr_pull_STRINGBINDING(ndr, ndr_flags, ar->stringbindings[towernum]));
towernum++;
}
ar->stringbindings[towernum] = NULL;
towernum = 0;
- ar->securitybindings = talloc_array_p(ndr, struct SECURITYBINDING *, num_entries);
+ ar->securitybindings = talloc_array(ndr, struct SECURITYBINDING *, num_entries);
ar->securitybindings[0] = NULL;
do {
if (towerid > 0) {
ndr->offset -= 2;
- ar->securitybindings = talloc_realloc_p(ndr, ar->securitybindings, struct SECURITYBINDING *, towernum+2);
- ar->securitybindings[towernum] = talloc_p(ndr, struct SECURITYBINDING);
+ ar->securitybindings = talloc_realloc(ndr, ar->securitybindings, struct SECURITYBINDING *, towernum+2);
+ ar->securitybindings[towernum] = talloc(ndr, struct SECURITYBINDING);
NDR_CHECK(ndr_pull_SECURITYBINDING(ndr, ndr_flags, ar->securitybindings[towernum]));
towernum++;
}
NDR_CHECK(ndr_pull_uint16(ndr, &num_entries));
- ar->stringbindings = talloc_array_p(ndr, struct STRINGBINDING *, 1);
+ ar->stringbindings = talloc_array(ndr, struct STRINGBINDING *, 1);
ar->stringbindings[0] = NULL;
do {
if (towerid > 0) {
ndr->offset -= 2;
- ar->stringbindings = talloc_realloc_p(ndr, ar->stringbindings, struct STRINGBINDING *, towernum+2);
- ar->stringbindings[towernum] = talloc_p(ndr, struct STRINGBINDING);
+ ar->stringbindings = talloc_realloc(ndr, ar->stringbindings, struct STRINGBINDING *, towernum+2);
+ ar->stringbindings[towernum] = talloc(ndr, struct STRINGBINDING);
NDR_CHECK(ndr_pull_STRINGBINDING(ndr, ndr_flags, ar->stringbindings[towernum]));
towernum++;
}
*/
NTSTATUS librpc_register_interface(const struct dcerpc_interface_table *interface)
{
- struct dcerpc_interface_list *l = talloc_p(talloc_autofree_context(),
+ struct dcerpc_interface_list *l = talloc(talloc_autofree_context(),
struct dcerpc_interface_list);
if (idl_iface_by_name (interface->name) != NULL) {
{
struct dcerpc_pipe *p;
- p = talloc_p(mem_ctx, struct dcerpc_pipe);
+ p = talloc(mem_ctx, struct dcerpc_pipe);
if (!p) {
return NULL;
}
DATA_BLOB *request_blob,
DATA_BLOB *reply_blob)
{
- struct full_request_state *state = talloc_p(mem_ctx, struct full_request_state);
+ struct full_request_state *state = talloc(mem_ctx, struct full_request_state);
NTSTATUS status;
if (state == NULL) {
p->conn->transport.recv_data = dcerpc_request_recv_data;
- req = talloc_p(mem_ctx, struct rpc_request);
+ req = talloc(mem_ctx, struct rpc_request);
if (req == NULL) {
return NULL;
}
NTSTATUS dcerpc_schannel_session_info(struct gensec_security *gensec_security,
struct auth_session_info **session_info)
{
- (*session_info) = talloc_p(gensec_security, struct auth_session_info);
+ (*session_info) = talloc(gensec_security, struct auth_session_info);
NT_STATUS_HAVE_NO_MEMORY(*session_info);
ZERO_STRUCTP(*session_info);
{
struct dcerpc_schannel_state *dce_schan_state;
- dce_schan_state = talloc_p(gensec_security, struct dcerpc_schannel_state);
+ dce_schan_state = talloc(gensec_security, struct dcerpc_schannel_state);
if (!dce_schan_state) {
return NT_STATUS_NO_MEMORY;
}
NTSTATUS status;
int chan_type = 0;
struct creds_CredentialState *creds;
- creds = talloc_p(p, struct creds_CredentialState);
+ creds = talloc(p, struct creds_CredentialState);
if (!creds) {
return NT_STATUS_NO_MEMORY;
}
struct smb_read_state *state;
struct smbcli_request *req;
- state = talloc_p(smb, struct smb_read_state);
+ state = talloc(smb, struct smb_read_state);
if (state == NULL) {
return NT_STATUS_NO_MEMORY;
}
memcpy(state->data.data, blob->data, blob->length);
}
- state->io = talloc_p(state, union smb_read);
+ state->io = talloc(state, union smb_read);
io = state->io;
io->generic.level = RAW_READ_READX;
uint16 setup[2];
struct smb_trans_state *state;
- state = talloc_p(smb, struct smb_trans_state);
+ state = talloc(smb, struct smb_trans_state);
if (state == NULL) {
return NT_STATUS_NO_MEMORY;
}
state->c = c;
- state->trans = talloc_p(state, struct smb_trans2);
+ state->trans = talloc(state, struct smb_trans2);
trans = state->trans;
trans->in.data = *blob;
/* Over-ride the default session key with the SMB session key */
c->security_state.session_key = smb_session_key;
- smb = talloc_p(c, struct smb_private);
+ smb = talloc(c, struct smb_private);
if (smb == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_CONNECTION_DISCONNECTED;
}
- blob = talloc_p(sock, struct sock_blob);
+ blob = talloc(sock, struct sock_blob);
if (blob == NULL) {
return NT_STATUS_NO_MEMORY;
}
struct fd_event fde;
NTSTATUS status;
- sock = talloc_p(c, struct sock_private);
+ sock = talloc(c, struct sock_private);
if (!sock) {
return NT_STATUS_NO_MEMORY;
}
comma_count = count_chars(options, ',');
- b->options = talloc_array_p(mem_ctx, const char *, comma_count+2);
+ b->options = talloc_array(mem_ctx, const char *, comma_count+2);
if (!b->options) {
return NT_STATUS_NO_MEMORY;
}
}
tower->num_floors = 2 + num_protocols;
- tower->floors = talloc_array_p(mem_ctx, struct epm_floor, tower->num_floors);
+ tower->floors = talloc_array(mem_ctx, struct epm_floor, tower->num_floors);
/* Floor 0 */
tower->floors[0].lhs.protocol = EPM_PROTOCOL_UUID;
if (!c_req) return NT_STATUS_UNSUCCESSFUL; \
{ \
struct async_info *async; \
- async = talloc_p(req, struct async_info); \
+ async = talloc(req, struct async_info); \
if (!async) return NT_STATUS_NO_MEMORY; \
async->parms = io; \
async->req = req; \
char *path;
struct brl_context *brl;
- brl = talloc_p(mem_ctx, struct brl_context);
+ brl = talloc(mem_ctx, struct brl_context);
if (brl == NULL) {
return NULL;
}
char *path;
struct odb_context *odb;
- odb = talloc_p(mem_ctx, struct odb_context);
+ odb = talloc(mem_ctx, struct odb_context);
if (odb == NULL) {
return NULL;
}
{
struct odb_lock *lck;
- lck = talloc_p(mem_ctx, struct odb_lock);
+ lck = talloc(mem_ctx, struct odb_lock);
if (lck == NULL) {
return NULL;
}
struct sidmap_context *sidmap_open(TALLOC_CTX *mem_ctx)
{
struct sidmap_context *sidmap;
- sidmap = talloc_p(mem_ctx, struct sidmap_context);
+ sidmap = talloc(mem_ctx, struct sidmap_context);
if (sidmap == NULL) {
return NULL;
}
{
struct rap_call *call;
- call = talloc_p(mem_ctx, struct rap_call);
+ call = talloc(mem_ctx, struct rap_call);
if (call == NULL)
return NULL;
call->ndr_pull_data = ndr_pull_init_blob(&trans->in.data, mem_ctx);
call->ndr_pull_data->flags = RAPNDR_FLAGS;
- call->heap = talloc_p(mem_ctx, struct rap_string_heap);
+ call->heap = talloc(mem_ctx, struct rap_string_heap);
if (call->heap == NULL)
return NULL;
NDR_CHECK(ndr_push_uint16(data_push, heap->offset));
NDR_CHECK(ndr_push_uint16(data_push, 0));
- heap->strings = talloc_realloc_p(heap->mem_ctx,
+ heap->strings = talloc_realloc(heap->mem_ctx,
heap->strings,
const char *,
heap->num_strings + 1);
int i;
r->out.status = 0;
r->out.available = dcesrv_common_get_count_of_shares(req, NULL);
- r->out.info = talloc_array_p(req,
+ r->out.info = talloc_array(req,
union rap_shareenum_info, r->out.available);
for (i=0;i<r->out.available;i++) {
NTSTATUS status;
char *logname = NULL;
- nprivates = talloc_p(req->tcon, struct nbench_private);
+ nprivates = talloc(req->tcon, struct nbench_private);
if (!nprivates) {
return NT_STATUS_NO_MEMORY;
}
second_stage_t fn)
{
struct ntvfs_map_async *m;
- m = talloc_p(req, struct ntvfs_map_async);
+ m = talloc(req, struct ntvfs_map_async);
if (m == NULL) {
return NT_STATUS_NO_MEMORY;
}
req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
if (write_time != 0) {
- sf = talloc_p(req, union smb_setfileinfo);
+ sf = talloc(req, union smb_setfileinfo);
sf->generic.level = RAW_SFILEINFO_STANDARD;
sf->generic.file.fnum = io2->generic.out.fnum;
sf->standard.in.create_time = 0;
}
if (set_size != 0) {
- sf = talloc_p(req, union smb_setfileinfo);
+ sf = talloc(req, union smb_setfileinfo);
sf->generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
sf->generic.file.fnum = io2->generic.out.fnum;
sf->end_of_file_info.in.size = set_size;
NTSTATUS status;
union smb_open *io2;
- io2 = talloc_zero_p(req, union smb_open);
+ io2 = talloc_zero(req, union smb_open);
if (io2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
io2->generic.in.file_attr = io->t2open.in.file_attrs;
io2->generic.in.fname = io->t2open.in.fname;
- io2->generic.in.ea_list = talloc_p(io2, struct smb_ea_list);
+ io2->generic.in.ea_list = talloc(io2, struct smb_ea_list);
io2->generic.in.ea_list->num_eas = io->t2open.in.num_eas;
io2->generic.in.ea_list->eas = io->t2open.in.eas;
NTSTATUS status;
union smb_fsinfo *fs2;
- fs2 = talloc_p(req, union smb_fsinfo);
+ fs2 = talloc(req, union smb_fsinfo);
if (fs2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
info->stream_info.out.num_streams = info2->generic.out.num_streams;
if (info->stream_info.out.num_streams > 0) {
info->stream_info.out.streams =
- talloc_array_p(req,
+ talloc_array(req,
struct stream_struct,
info->stream_info.out.num_streams);
if (!info->stream_info.out.streams) {
case RAW_FILEINFO_ALL_EAS:
info->all_eas.out.num_eas = info2->generic.out.num_eas;
if (info->all_eas.out.num_eas > 0) {
- info->all_eas.out.eas = talloc_array_p(req,
+ info->all_eas.out.eas = talloc_array(req,
struct ea_struct,
info->all_eas.out.num_eas);
if (!info->all_eas.out.eas) {
NTSTATUS status;
union smb_fileinfo *info2;
- info2 = talloc_p(req, union smb_fileinfo);
+ info2 = talloc(req, union smb_fileinfo);
if (info2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
NTSTATUS status;
union smb_fileinfo *info2;
- info2 = talloc_p(req, union smb_fileinfo);
+ info2 = talloc(req, union smb_fileinfo);
if (info2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
union smb_lock *lck2;
struct smb_lock_entry *locks;
- lck2 = talloc_p(req, union smb_lock);
+ lck2 = talloc(req, union smb_lock);
if (lck2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
- locks = talloc_array_p(lck2, struct smb_lock_entry, 1);
+ locks = talloc_array(lck2, struct smb_lock_entry, 1);
if (locks == NULL) {
return NT_STATUS_NO_MEMORY;
}
case RAW_WRITE_WRITEUNLOCK:
wr->writeunlock.out.nwritten = wr2->generic.out.nwritten;
- lck = talloc_p(wr2, union smb_lock);
+ lck = talloc(wr2, union smb_lock);
if (lck == NULL) {
return NT_STATUS_NO_MEMORY;
}
case RAW_WRITE_WRITECLOSE:
wr->writeclose.out.nwritten = wr2->generic.out.nwritten;
- cl = talloc_p(wr2, union smb_close);
+ cl = talloc(wr2, union smb_close);
if (cl == NULL) {
return NT_STATUS_NO_MEMORY;
}
union smb_write *wr2;
NTSTATUS status;
- wr2 = talloc_p(req, union smb_write);
+ wr2 = talloc(req, union smb_write);
if (wr2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
NTSTATUS status;
uint_t state;
- rd2 = talloc_p(req, union smb_read);
+ rd2 = talloc(req, union smb_read);
if (rd2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
state = req->async_states->state;
req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
- lck = talloc_p(rd2, union smb_lock);
+ lck = talloc(rd2, union smb_lock);
if (lck == NULL) {
status = NT_STATUS_NO_MEMORY;
goto done;
{
union smb_close *cl2;
- cl2 = talloc_p(req, union smb_close);
+ cl2 = talloc(req, union smb_close);
if (cl2 == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
struct ntvfs_async_state *async;
- async = talloc_p(req, struct ntvfs_async_state);
+ async = talloc(req, struct ntvfs_async_state);
if (!async) {
return NT_STATUS_NO_MEMORY;
}
uid_t uid = -1;
gid_t gid = -1;
- acl = talloc_p(req, struct xattr_NTACL);
+ acl = talloc(req, struct xattr_NTACL);
if (acl == NULL) {
return NT_STATUS_NO_MEMORY;
}
NTSTATUS status;
struct security_descriptor *sd;
- acl = talloc_p(req, struct xattr_NTACL);
+ acl = talloc(req, struct xattr_NTACL);
if (acl == NULL) {
return NT_STATUS_NO_MEMORY;
}
NTSTATUS status;
struct security_descriptor *sd;
- acl = talloc_p(req, struct xattr_NTACL);
+ acl = talloc(req, struct xattr_NTACL);
if (acl == NULL) {
return NT_STATUS_NO_MEMORY;
}
return status;
}
- acl = talloc_p(req, struct xattr_NTACL);
+ acl = talloc(req, struct xattr_NTACL);
if (acl == NULL) {
return NT_STATUS_NO_MEMORY;
}
char *pattern;
struct pvfs_dir *dir;
- (*dirp) = talloc_zero_p(mem_ctx, struct pvfs_dir);
+ (*dirp) = talloc_zero(mem_ctx, struct pvfs_dir);
if (*dirp == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (lck->lockx.in.timeout != 0 &&
(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
- pending = talloc_p(f, struct pvfs_pending_lock);
+ pending = talloc(f, struct pvfs_pending_lock);
if (pending == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_INVALID_PARAMETER;
}
- f = talloc_p(req, struct pvfs_file);
+ f = talloc(req, struct pvfs_file);
if (f == NULL) {
return NT_STATUS_NO_MEMORY;
}
- f->handle = talloc_p(f, struct pvfs_file_handle);
+ f->handle = talloc(f, struct pvfs_file_handle);
if (f->handle == NULL) {
return NT_STATUS_NO_MEMORY;
}
flags = O_RDONLY;
}
- f = talloc_p(req, struct pvfs_file);
+ f = talloc(req, struct pvfs_file);
if (f == NULL) {
return NT_STATUS_NO_MEMORY;
}
- f->handle = talloc_p(f, struct pvfs_file_handle);
+ f->handle = talloc(f, struct pvfs_file_handle);
if (f->handle == NULL) {
return NT_STATUS_NO_MEMORY;
}
}
}
- r = talloc_p(req, struct pvfs_open_retry);
+ r = talloc(req, struct pvfs_open_retry);
if (r == NULL) {
return NT_STATUS_NO_MEMORY;
}
return status;
}
- f = talloc_p(req, struct pvfs_file);
+ f = talloc(req, struct pvfs_file);
if (f == NULL) {
return NT_STATUS_NO_MEMORY;
}
- f->handle = talloc_p(f, struct pvfs_file_handle);
+ f->handle = talloc(f, struct pvfs_file_handle);
if (f->handle == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
NTSTATUS status;
int i;
- struct xattr_DosEAs *ealist = talloc_p(mem_ctx, struct xattr_DosEAs);
+ struct xattr_DosEAs *ealist = talloc(mem_ctx, struct xattr_DosEAs);
ZERO_STRUCTP(eas);
status = pvfs_doseas_load(pvfs, name, fd, ealist);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
- eas->eas = talloc_array_p(mem_ctx, struct ea_struct, num_names);
+ eas->eas = talloc_array(mem_ctx, struct ea_struct, num_names);
if (eas->eas == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
NTSTATUS status;
int i;
- struct xattr_DosEAs *ealist = talloc_p(mem_ctx, struct xattr_DosEAs);
+ struct xattr_DosEAs *ealist = talloc(mem_ctx, struct xattr_DosEAs);
ZERO_STRUCTP(eas);
status = pvfs_doseas_load(pvfs, name, fd, ealist);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
- eas->eas = talloc_array_p(mem_ctx, struct ea_struct, ealist->num_eas);
+ eas->eas = talloc_array(mem_ctx, struct ea_struct, ealist->num_eas);
if (eas->eas == NULL) {
return NT_STATUS_NO_MEMORY;
}
}
}
- components = talloc_array_p(name, char *, num_components);
+ components = talloc_array(name, char *, num_components);
p = name->full_name + strlen(pvfs->base_directory);
*p++ = 0;
if (c == '\\') num_components++;
}
- components = talloc_array_p(s, char *, num_components+1);
+ components = talloc_array(s, char *, num_components+1);
if (components == NULL) {
talloc_free(s);
return NT_STATUS_NO_MEMORY;
{
NTSTATUS status;
- *name = talloc_p(mem_ctx, struct pvfs_filename);
+ *name = talloc(mem_ctx, struct pvfs_filename);
if (*name == NULL) {
return NT_STATUS_NO_MEMORY;
}
{
NTSTATUS status;
- *name = talloc_p(mem_ctx, struct pvfs_filename);
+ *name = talloc(mem_ctx, struct pvfs_filename);
if (*name == NULL) {
return NT_STATUS_NO_MEMORY;
}
NTSTATUS status;
char *p;
- *name = talloc_p(mem_ctx, struct pvfs_filename);
+ *name = talloc(mem_ctx, struct pvfs_filename);
if (*name == NULL) {
return NT_STATUS_NO_MEMORY;
}
name = pvfs_list_next(dir, &search->current_index);
if (name == NULL) break;
- file = talloc_p(mem_ctx, union smb_search_data);
+ file = talloc(mem_ctx, union smb_search_data);
if (!file) {
return NT_STATUS_NO_MEMORY;
}
/* we initially make search a child of the request, then if we
need to keep it long term we steal it for the private
structure */
- search = talloc_p(req, struct pvfs_search_state);
+ search = talloc(req, struct pvfs_search_state);
if (!search) {
return NT_STATUS_NO_MEMORY;
}
/* we initially make search a child of the request, then if we
need to keep it long term we steal it for the private
structure */
- search = talloc_p(req, struct pvfs_search_state);
+ search = talloc(req, struct pvfs_search_state);
if (!search) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NOT_SUPPORTED;
}
- ealist = talloc_p(name, struct xattr_DosEAs);
+ ealist = talloc(name, struct xattr_DosEAs);
/* load the current list */
status = pvfs_doseas_load(pvfs, name, fd, ealist);
if (i==ealist->num_eas) {
/* add it */
- ealist->eas = talloc_realloc_p(ealist, ealist->eas,
+ ealist->eas = talloc_realloc(ealist, ealist->eas,
struct xattr_EA,
ealist->num_eas+1);
if (ealist->eas == NULL) {
/* find the hash for this prefix */
v = hash = mangle_hash(ctx, name, prefix_len);
- new_name = talloc_array_p(ctx, char, 13);
+ new_name = talloc_array(ctx, char, 13);
if (new_name == NULL) {
return NULL;
}
{
struct pvfs_mangle_context *ctx;
- ctx = talloc_p(pvfs, struct pvfs_mangle_context);
+ ctx = talloc(pvfs, struct pvfs_mangle_context);
if (ctx == NULL) {
return NT_STATUS_NO_MEMORY;
}
int i;
NTSTATUS status;
- streams = talloc_p(mem_ctx, struct xattr_DosStreams);
+ streams = talloc(mem_ctx, struct xattr_DosStreams);
if (streams == NULL) {
return NT_STATUS_NO_MEMORY;
}
}
info->num_streams = streams->num_streams+1;
- info->streams = talloc_array_p(mem_ctx, struct stream_struct, info->num_streams);
+ info->streams = talloc_array(mem_ctx, struct stream_struct, info->num_streams);
if (!info->streams) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_OK;
}
- streams = talloc_p(name, struct xattr_DosStreams);
+ streams = talloc(name, struct xattr_DosStreams);
if (streams == NULL) {
return NT_STATUS_NO_MEMORY;
}
int i;
NTSTATUS status;
- streams = talloc_p(name, struct xattr_DosStreams);
+ streams = talloc(name, struct xattr_DosStreams);
if (streams == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (i == streams->num_streams) {
struct xattr_DosStream *s;
- streams->streams = talloc_realloc_p(streams, streams->streams,
+ streams->streams = talloc_realloc(streams, streams->streams,
struct xattr_DosStream,
streams->num_streams+1);
if (streams->streams == NULL) {
return status;
}
- streams = talloc_p(name, struct xattr_DosStreams);
+ streams = talloc(name, struct xattr_DosStreams);
if (streams == NULL) {
return NT_STATUS_NO_MEMORY;
}
struct timed_event te;
struct pvfs_wait *pwait;
- pwait = talloc_p(pvfs, struct pvfs_wait);
+ pwait = talloc(pvfs, struct pvfs_wait);
if (pwait == NULL) {
return NULL;
}
char *base_directory;
NTSTATUS status;
- pvfs = talloc_zero_p(tcon, struct pvfs_state);
+ pvfs = talloc_zero(tcon, struct pvfs_state);
if (pvfs == NULL) {
return NT_STATUS_NO_MEMORY;
}
len = strlen(attr_name) + 1;
- blob.data = talloc_realloc_p(mem_ctx, blob.data, uint8_t, blob.length + len);
+ blob.data = talloc_realloc(mem_ctx, blob.data, uint8_t, blob.length + len);
if (blob.data == NULL) {
talloc_free(mem_ctx);
return NT_STATUS_NO_MEMORY;
}
}
- key->dptr = talloc_array_p(mem_ctx, char, 16 + len);
+ key->dptr = talloc_array(mem_ctx, char, 16 + len);
if (key->dptr == NULL) {
return NT_STATUS_NO_MEMORY;
}
uint_t allocated = 0;
char *low_mask;
- dir = talloc_p(mem_ctx, struct svfs_dir);
+ dir = talloc(mem_ctx, struct svfs_dir);
if (!dir) { return NULL; }
dir->count = 0;
if (dir->count >= allocated) {
allocated = (allocated + 100) * 1.2;
- dir->files = talloc_realloc_p(dir, dir->files, struct svfs_dirfile, allocated);
+ dir->files = talloc_realloc(dir, dir->files, struct svfs_dirfile, allocated);
if (!dir->files) {
closedir(odir);
return NULL;
struct smbsrv_tcon *tcon = req->tcon;
struct svfs_private *private;
- private = talloc_p(tcon, struct svfs_private);
+ private = talloc(tcon, struct svfs_private);
private->next_search_handle = 0;
private->connectpath = talloc_strdup(tcon, lp_pathname(tcon->service));
info->generic.out.num_streams = 0;
/* setup a single data stream */
info->generic.out.num_streams = 1 + (dir?dir->count:0);
- info->generic.out.streams = talloc_array_p(req,
+ info->generic.out.streams = talloc_array(req,
struct stream_struct,
info->generic.out.num_streams);
if (!info->generic.out.streams) {
return map_nt_error_from_unix(errno);
}
- f = talloc_p(req->tcon, struct svfs_file);
+ f = talloc(req->tcon, struct svfs_file);
f->fd = fd;
f->name = talloc_strdup(req->tcon, unix_path);
return NT_STATUS_NOT_SUPPORTED;
}
- search = talloc_zero_p(private, struct search_state);
+ search = talloc_zero(private, struct search_state);
if (!search) {
return NT_STATUS_NO_MEMORY;
}
*/
static struct unix_sec_ctx *save_unix_security(TALLOC_CTX *mem_ctx)
{
- struct unix_sec_ctx *sec = talloc_p(mem_ctx, struct unix_sec_ctx);
+ struct unix_sec_ctx *sec = talloc(mem_ctx, struct unix_sec_ctx);
if (sec == NULL) {
return NULL;
}
talloc_free(sec);
return NULL;
}
- sec->groups = talloc_array_p(sec, gid_t, sec->ngroups);
+ sec->groups = talloc_array(sec, gid_t, sec->ngroups);
if (sec->groups == NULL) {
talloc_free(sec);
return NULL;
struct unixuid_private *private = ntvfs->private_data;
int i;
NTSTATUS status;
- *sec = talloc_p(req, struct unix_sec_ctx);
+ *sec = talloc(req, struct unix_sec_ctx);
/* we can't do unix security without a user and group */
if (token->num_sids < 2) {
}
(*sec)->ngroups = token->num_sids - 2;
- (*sec)->groups = talloc_array_p(*sec, gid_t, (*sec)->ngroups);
+ (*sec)->groups = talloc_array(*sec, gid_t, (*sec)->ngroups);
if ((*sec)->groups == NULL) {
return NT_STATUS_NO_MEMORY;
}
struct unixuid_private *private;
NTSTATUS status;
- private = talloc_p(req->tcon, struct unixuid_private);
+ private = talloc(req->tcon, struct unixuid_private);
if (!private) {
return NT_STATUS_NO_MEMORY;
}
if (!lp_talloc)
lp_talloc = talloc_init("lp_talloc");
- ret = talloc_array_p(lp_talloc, char, len + 100); /* leave room for substitution */
+ ret = talloc_array(lp_talloc, char, len + 100); /* leave room for substitution */
if (!ret)
return NULL;
/* check if this endpoint exists
*/
if ((ep=find_endpoint(dce_ctx, &binding))==NULL) {
- ep = talloc_p(dce_ctx, struct dcesrv_endpoint);
+ ep = talloc(dce_ctx, struct dcesrv_endpoint);
if (!ep) {
return NT_STATUS_NO_MEMORY;
}
}
/* talloc a new interface list element */
- ifl = talloc_p(dce_ctx, struct dcesrv_if_list);
+ ifl = talloc(dce_ctx, struct dcesrv_if_list);
if (!ifl) {
return NT_STATUS_NO_MEMORY;
}
pkt.u.fault.cancel_count = 0;
pkt.u.fault.status = fault_code;
- rep = talloc_p(call, struct dcesrv_call_reply);
+ rep = talloc(call, struct dcesrv_call_reply);
if (!rep) {
return NT_STATUS_NO_MEMORY;
}
pkt.u.bind_nak.reject_reason = reason;
pkt.u.bind_nak.num_versions = 0;
- rep = talloc_p(call, struct dcesrv_call_reply);
+ rep = talloc(call, struct dcesrv_call_reply);
if (!rep) {
return NT_STATUS_NO_MEMORY;
}
pkt.u.bind_ack.secondary_address = "";
}
pkt.u.bind_ack.num_results = 1;
- pkt.u.bind_ack.ctx_list = talloc_p(call, struct dcerpc_ack_ctx);
+ pkt.u.bind_ack.ctx_list = talloc(call, struct dcerpc_ack_ctx);
if (!pkt.u.bind_ack.ctx_list) {
return NT_STATUS_NO_MEMORY;
}
return dcesrv_bind_nak(call, 0);
}
- rep = talloc_p(call, struct dcesrv_call_reply);
+ rep = talloc(call, struct dcesrv_call_reply);
if (!rep) {
return NT_STATUS_NO_MEMORY;
}
return;
}
- dcesrv_sock = talloc_p(stream_socket, struct dcesrv_socket_context);
+ dcesrv_sock = talloc(stream_socket, struct dcesrv_socket_context);
if (!dcesrv_sock) {
- DEBUG(0,("talloc_p(stream_socket, struct dcesrv_socket_context) failed\n"));
+ DEBUG(0,("talloc(stream_socket, struct dcesrv_socket_context) failed\n"));
return;
}
return;
}
- dcesrv_sock = talloc_p(stream_socket, struct dcesrv_socket_context);
+ dcesrv_sock = talloc(stream_socket, struct dcesrv_socket_context);
if (!dcesrv_sock) {
- DEBUG(0,("talloc_p(stream_socket, struct dcesrv_socket_context) failed\n"));
+ DEBUG(0,("talloc(stream_socket, struct dcesrv_socket_context) failed\n"));
return;
}
e->ep_description.endpoint = talloc_asprintf(dce_ctx, "%d", port);
}
- dcesrv_sock = talloc_p(stream_socket, struct dcesrv_socket_context);
+ dcesrv_sock = talloc(stream_socket, struct dcesrv_socket_context);
if (!dcesrv_sock) {
- DEBUG(0,("talloc_p(stream_socket, struct dcesrv_socket_context) failed\n"));
+ DEBUG(0,("talloc(stream_socket, struct dcesrv_socket_context) failed\n"));
return;
}
return True;
}
- dce_conn->auth_state.auth_info = talloc_p(dce_conn, struct dcerpc_auth);
+ dce_conn->auth_state.auth_info = talloc(dce_conn, struct dcerpc_auth);
if (!dce_conn->auth_state.auth_info) {
return False;
}
return False;
}
- dce_conn->auth_state.auth_info = talloc_p(dce_conn, struct dcerpc_auth);
+ dce_conn->auth_state.auth_info = talloc(dce_conn, struct dcerpc_auth);
if (!dce_conn->auth_state.auth_info) {
return False;
}
/* FIXME: Loop thru given interfaces and set r->out.results and
* r->out.interfaces */
- r->out.ifaces = talloc_array_p(mem_ctx, struct pMInterfacePointer, r->in.Interfaces);
- r->out.results = talloc_array_p(mem_ctx, WERROR, r->in.Interfaces);
+ r->out.ifaces = talloc_array(mem_ctx, struct pMInterfacePointer, r->in.Interfaces);
+ r->out.results = talloc_array(mem_ctx, WERROR, r->in.Interfaces);
r->out.hr = cr->out.result;
for (i = 0; i < r->in.Interfaces; i++) {
{
struct tdb_wrap *db = openrodb(mem_ctx);
DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
- talloc_destroy(db);
+ talloc_free(db);
}
{
struct tdb_wrap *db = openrodb(mem_ctx);
DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
- talloc_destroy(db);
+ talloc_free(db);
}
{
struct tdb_wrap *db = openrodb(mem_ctx);
DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
- talloc_destroy(db);
+ talloc_free(db);
}
{
struct tdb_wrap *db = openrodb(mem_ctx);
DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
- talloc_destroy(db);
+ talloc_free(db);
}
{
struct tdb_wrap *db = openrodb(mem_ctx);
DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
- talloc_destroy(db);
+ talloc_free(db);
}
{
struct tdb_wrap *db = openrodb(mem_ctx);
DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
- talloc_destroy(db);
+ talloc_free(db);
}
{
struct tdb_wrap *db = openrodb(mem_ctx);
DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
- talloc_destroy(db);
+ talloc_free(db);
}
r->out.bind_info = NULL;
ZERO_STRUCTP(r->out.bind_handle);
- b_state = talloc_p(dce_call->conn, struct drsuapi_bind_state);
+ b_state = talloc(dce_call->conn, struct drsuapi_bind_state);
WERR_TALLOC_CHECK(b_state);
b_state->sam_ctx = samdb_connect(b_state);
handle->data = talloc_steal(handle, b_state);
- bind_info = talloc_p(mem_ctx, struct drsuapi_DsBindInfoCtr);
+ bind_info = talloc(mem_ctx, struct drsuapi_DsBindInfoCtr);
WERR_TALLOC_CHECK(bind_info);
ZERO_STRUCT(site_guid);
int count;
int i;
- ctr1 = talloc_p(mem_ctx, struct drsuapi_DsNameCtr1);
+ ctr1 = talloc(mem_ctx, struct drsuapi_DsNameCtr1);
WERR_TALLOC_CHECK(ctr1);
count = r->in.req.req1.count;
- names = talloc_array_p(mem_ctx, struct drsuapi_DsNameInfo1, count);
+ names = talloc_array(mem_ctx, struct drsuapi_DsNameInfo1, count);
WERR_TALLOC_CHECK(names);
for (i=0; i < count; i++) {
{
union dssetup_DsRoleInfo *info;
- info = talloc_p(mem_ctx, union dssetup_DsRoleInfo);
+ info = talloc(mem_ctx, union dssetup_DsRoleInfo);
W_ERROR_HAVE_NO_MEMORY(info);
switch (r->in.level) {
static NTSTATUS echo_TestCall2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct echo_TestCall2 *r)
{
- r->out.info = talloc_p(mem_ctx, union echo_Info);
+ r->out.info = talloc(mem_ctx, union echo_Info);
if (!r->out.info) {
return NT_STATUS_NO_MEMORY;
}
struct dcerpc_binding description;
for (iface=d->interface_list;iface;iface=iface->next) {
- (*eps) = talloc_realloc_p(mem_ctx,
+ (*eps) = talloc_realloc(mem_ctx,
*eps,
struct dcesrv_ep_iface,
total + 1);
if (!eps) {
/* this is the first call - fill the list. Subsequent calls
will feed from this list, stored in the handle */
- eps = talloc_p(h, struct rpc_eps);
+ eps = talloc(h, struct rpc_eps);
if (!eps) {
return EPMAPPER_STATUS_NO_MEMORY;
}
return EPMAPPER_STATUS_NO_MORE_ENTRIES;
}
- r->out.entries = talloc_array_p(mem_ctx, struct epm_entry_t, num_ents);
+ r->out.entries = talloc_array(mem_ctx, struct epm_entry_t, num_ents);
if (!r->out.entries) {
return EPMAPPER_STATUS_NO_MEMORY;
}
for (i=0;i<num_ents;i++) {
ZERO_STRUCT(r->out.entries[i].object);
r->out.entries[i].annotation = eps->e[i].name;
- r->out.entries[i].tower = talloc_p(mem_ctx, struct epm_twr_t);
+ r->out.entries[i].tower = talloc(mem_ctx, struct epm_twr_t);
if (!r->out.entries[i].tower) {
return EPMAPPER_STATUS_NO_MEMORY;
}
ZERO_STRUCT(*r->out.entry_handle);
r->out.num_towers = 1;
- r->out.towers = talloc_p(mem_ctx, struct epm_twr_p_t);
+ r->out.towers = talloc(mem_ctx, struct epm_twr_p_t);
if (!r->out.towers) {
return EPMAPPER_STATUS_NO_MEMORY;
}
- r->out.towers->twr = talloc_p(mem_ctx, struct epm_twr_t);
+ r->out.towers->twr = talloc(mem_ctx, struct epm_twr_t);
if (!r->out.towers->twr) {
return EPMAPPER_STATUS_NO_MEMORY;
}
{
struct dcesrv_handle *h;
- h = talloc_p(context, struct dcesrv_handle);
+ h = talloc(context, struct dcesrv_handle);
if (!h) {
return NULL;
}
r->out.privs->count < r->in.max_count) {
struct lsa_PrivEntry *e;
- r->out.privs->privs = talloc_realloc_p(r->out.privs,
+ r->out.privs->privs = talloc_realloc(r->out.privs,
r->out.privs->privs,
struct lsa_PrivEntry,
r->out.privs->count+1);
struct lsa_policy_state *state;
const char *sid_str;
- state = talloc_p(mem_ctx, struct lsa_policy_state);
+ state = talloc(mem_ctx, struct lsa_policy_state);
if (!state) {
return NT_STATUS_NO_MEMORY;
}
state = h->data;
- r->out.info = talloc_p(mem_ctx, union lsa_PolicyInformation);
+ r->out.info = talloc(mem_ctx, union lsa_PolicyInformation);
if (!r->out.info) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_MORE_ENTRIES;
}
- r->out.sids->sids = talloc_array_p(r->out.sids, struct lsa_SidPtr, count);
+ r->out.sids->sids = talloc_array(r->out.sids, struct lsa_SidPtr, count);
if (r->out.sids->sids == NULL) {
return NT_STATUS_NO_MEMORY;
}
}
/* convert to lsa_DomainInformation format */
- entries = talloc_array_p(mem_ctx, struct lsa_DomainInformation, count);
+ entries = talloc_array(mem_ctx, struct lsa_DomainInformation, count);
if (!entries) {
return NT_STATUS_NO_MEMORY;
}
}
}
- domains->domains = talloc_realloc_p(domains,
+ domains->domains = talloc_realloc(domains,
domains->domains,
struct lsa_TrustInformation,
domains->count+1);
return status;
}
- r->out.domains = talloc_zero_p(mem_ctx, struct lsa_RefDomainList);
+ r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList);
if (r->out.domains == NULL) {
return NT_STATUS_NO_MEMORY;
}
- r->out.names = talloc_zero_p(mem_ctx, struct lsa_TransNameArray2);
+ r->out.names = talloc_zero(mem_ctx, struct lsa_TransNameArray2);
if (r->out.names == NULL) {
return NT_STATUS_NO_MEMORY;
}
*r->out.count = 0;
- r->out.names->names = talloc_array_p(r->out.names, struct lsa_TranslatedName2,
+ r->out.names->names = talloc_array(r->out.names, struct lsa_TranslatedName2,
r->in.sids->num_sids);
if (r->out.names->names == NULL) {
return NT_STATUS_NO_MEMORY;
}
r->out.domains = r3.out.domains;
- r->out.names = talloc_p(mem_ctx, struct lsa_TransNameArray);
+ r->out.names = talloc(mem_ctx, struct lsa_TransNameArray);
if (r->out.names == NULL) {
return NT_STATUS_NO_MEMORY;
}
r->out.names->count = r3.out.names->count;
- r->out.names->names = talloc_array_p(r->out.names, struct lsa_TranslatedName,
+ r->out.names->names = talloc_array(r->out.names, struct lsa_TranslatedName,
r->out.names->count);
if (r->out.names->names == NULL) {
return NT_STATUS_NO_MEMORY;
state = h->data;
- astate = talloc_p(dce_call->conn, struct lsa_account_state);
+ astate = talloc(dce_call->conn, struct lsa_account_state);
if (astate == NULL) {
return NT_STATUS_NO_MEMORY;
}
astate = h->data;
- r->out.privs = talloc_p(mem_ctx, struct lsa_PrivilegeSet);
+ r->out.privs = talloc(mem_ctx, struct lsa_PrivilegeSet);
r->out.privs->count = 0;
r->out.privs->unknown = 0;
r->out.privs->set = NULL;
return NT_STATUS_OK;
}
- r->out.privs->set = talloc_array_p(r->out.privs,
+ r->out.privs->set = talloc_array(r->out.privs,
struct lsa_LUIDAttribute, el->num_values);
if (r->out.privs->set == NULL) {
return NT_STATUS_NO_MEMORY;
}
r->out.rights->count = el->num_values;
- r->out.rights->names = talloc_array_p(r->out.rights,
+ r->out.rights->names = talloc_array(r->out.rights,
struct lsa_String, r->out.rights->count);
if (r->out.rights->names == NULL) {
return NT_STATUS_NO_MEMORY;
r2.in.handle = &state->handle->wire_handle;
r2.in.sid = sid;
- r2.out.rights = talloc_p(mem_ctx, struct lsa_RightSet);
+ r2.out.rights = talloc(mem_ctx, struct lsa_RightSet);
status = lsa_EnumAccountRights(dce_call, mem_ctx, &r2);
if (!NT_STATUS_IS_OK(status)) {
}
el.num_values = 0;
- el.values = talloc_array_p(mem_ctx, struct ldb_val, rights->count);
+ el.values = talloc_array(mem_ctx, struct ldb_val, rights->count);
if (el.values == NULL) {
return NT_STATUS_NO_MEMORY;
}
astate = h->data;
rights.count = r->in.privs->count;
- rights.names = talloc_array_p(mem_ctx, struct lsa_String, rights.count);
+ rights.names = talloc_array(mem_ctx, struct lsa_String, rights.count);
if (rights.names == NULL) {
return NT_STATUS_NO_MEMORY;
}
astate = h->data;
- rights = talloc_p(mem_ctx, struct lsa_RightSet);
+ rights = talloc(mem_ctx, struct lsa_RightSet);
if (r->in.remove_all == 1 &&
r->in.privs == NULL) {
}
rights->count = r->in.privs->count;
- rights->names = talloc_array_p(mem_ctx, struct lsa_String, rights->count);
+ rights->names = talloc_array(mem_ctx, struct lsa_String, rights->count);
if (rights->names == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_SUCH_PRIVILEGE;
}
- r->out.name = talloc_p(mem_ctx, struct lsa_String);
+ r->out.name = talloc(mem_ctx, struct lsa_String);
if (r->out.name == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_SUCH_PRIVILEGE;
}
- r->out.disp_name = talloc_p(mem_ctx, struct lsa_String);
+ r->out.disp_name = talloc(mem_ctx, struct lsa_String);
if (r->out.disp_name == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_SUCH_USER;
}
- r->out.sids->sids = talloc_array_p(r->out.sids, struct lsa_SidPtr, ret);
+ r->out.sids->sids = talloc_array(r->out.sids, struct lsa_SidPtr, ret);
if (r->out.sids->sids == NULL) {
return NT_STATUS_NO_MEMORY;
}
account_name = talloc_reference(mem_ctx, dce_call->conn->auth_state.session_info->server_info->account_name);
authority_name = talloc_reference(mem_ctx, dce_call->conn->auth_state.session_info->server_info->domain_name);
- _account_name = talloc_p(mem_ctx, struct lsa_String);
+ _account_name = talloc(mem_ctx, struct lsa_String);
NTSTATUS_TALLOC_CHECK(_account_name);
_account_name->string = account_name;
if (r->in.authority_name) {
- _authority_name = talloc_p(mem_ctx, struct lsa_StringPointer);
+ _authority_name = talloc(mem_ctx, struct lsa_StringPointer);
NTSTATUS_TALLOC_CHECK(_authority_name);
- _authority_name->string = talloc_p(mem_ctx, struct lsa_String);
+ _authority_name->string = talloc(mem_ctx, struct lsa_String);
NTSTATUS_TALLOC_CHECK(_authority_name->string);
_authority_name->string->string = authority_name;
}
state = h->data;
- r->out.domains = talloc_zero_p(mem_ctx, struct lsa_RefDomainList);
+ r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList);
if (r->out.domains == NULL) {
return NT_STATUS_NO_MEMORY;
}
- r->out.sids = talloc_zero_p(mem_ctx, struct lsa_TransSidArray3);
+ r->out.sids = talloc_zero(mem_ctx, struct lsa_TransSidArray3);
if (r->out.sids == NULL) {
return NT_STATUS_NO_MEMORY;
}
*r->out.count = 0;
- r->out.sids->sids = talloc_array_p(r->out.sids, struct lsa_TranslatedSid3,
+ r->out.sids->sids = talloc_array(r->out.sids, struct lsa_TranslatedSid3,
r->in.num_names);
if (r->out.sids->sids == NULL) {
return NT_STATUS_NO_MEMORY;
state = h->data;
- r->out.domains = talloc_zero_p(mem_ctx, struct lsa_RefDomainList);
+ r->out.domains = talloc_zero(mem_ctx, struct lsa_RefDomainList);
if (r->out.domains == NULL) {
return NT_STATUS_NO_MEMORY;
}
- r->out.sids = talloc_zero_p(mem_ctx, struct lsa_TransSidArray2);
+ r->out.sids = talloc_zero(mem_ctx, struct lsa_TransSidArray2);
if (r->out.sids == NULL) {
return NT_STATUS_NO_MEMORY;
}
*r->out.count = 0;
- r->out.sids->sids = talloc_array_p(r->out.sids, struct lsa_TranslatedSid2,
+ r->out.sids->sids = talloc_array(r->out.sids, struct lsa_TranslatedSid2,
r->in.num_names);
if (r->out.sids->sids == NULL) {
return NT_STATUS_NO_MEMORY;
}
r->out.domains = r2.out.domains;
- r->out.sids = talloc_p(mem_ctx, struct lsa_TransSidArray);
+ r->out.sids = talloc(mem_ctx, struct lsa_TransSidArray);
if (r->out.sids == NULL) {
return NT_STATUS_NO_MEMORY;
}
r->out.sids->count = r2.out.sids->count;
- r->out.sids->sids = talloc_array_p(r->out.sids, struct lsa_TranslatedSid,
+ r->out.sids->sids = talloc_array(r->out.sids, struct lsa_TranslatedSid,
r->out.sids->count);
if (r->out.sids->sids == NULL) {
return NT_STATUS_NO_MEMORY;
struct server_pipe_state *state;
NTSTATUS status;
- state = talloc_p(dce_call->conn, struct server_pipe_state);
+ state = talloc(dce_call->conn, struct server_pipe_state);
if (state == NULL) {
return NT_STATUS_NO_MEMORY;
}
dce_call->context->private = NULL;
}
- pipe_state = talloc_p(dce_call->context, struct server_pipe_state);
+ pipe_state = talloc(dce_call->context, struct server_pipe_state);
if (!pipe_state) {
return NT_STATUS_NO_MEMORY;
}
if (pipe_state->creds) {
talloc_free(pipe_state->creds);
}
- pipe_state->creds = talloc_p(pipe_state, struct creds_CredentialState);
+ pipe_state->creds = talloc(pipe_state, struct creds_CredentialState);
if (!pipe_state->creds) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- info1 = talloc_p(mem_ctx, struct netr_DomainInfo1);
+ info1 = talloc(mem_ctx, struct netr_DomainInfo1);
if (info1 == NULL) {
return NT_STATUS_NO_MEMORY;
}
ZERO_STRUCTP(info1);
info1->num_trusts = ret2 + 1;
- info1->trusts = talloc_array_p(mem_ctx, struct netr_DomainTrustInfo,
+ info1->trusts = talloc_array(mem_ctx, struct netr_DomainTrustInfo,
info1->num_trusts);
if (info1->trusts == NULL) {
return NT_STATUS_NO_MEMORY;
return WERR_NO_SUCH_DOMAIN;
}
- r->out.info = talloc_p(mem_ctx, struct netr_DrsGetDCNameEx2Info);
+ r->out.info = talloc(mem_ctx, struct netr_DrsGetDCNameEx2Info);
if (!r->out.info) {
return WERR_NOMEM;
}
return WERR_OK;
}
- trusts = talloc_array_p(mem_ctx, struct netr_DomainTrust, ret);
+ trusts = talloc_array(mem_ctx, struct netr_DomainTrust, ret);
if (trusts == NULL) {
return WERR_NOMEM;
}
const struct ldb_val *val;
char *expr=NULL;
- *creds = talloc_zero_p(mem_ctx, struct creds_CredentialState);
+ *creds = talloc_zero(mem_ctx, struct creds_CredentialState);
if (!*creds) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_INVALID_PARAMETER;
}
- private = talloc_p(dce_call->conn, struct dcesrv_remote_private);
+ private = talloc(dce_call->conn, struct dcesrv_remote_private);
if (!private) {
return NT_STATUS_NO_MEMORY;
}
ZERO_STRUCTP(r->out.connect_handle);
- c_state = talloc_p(dce_call->conn, struct samr_connect_state);
+ c_state = talloc(dce_call->conn, struct samr_connect_state);
if (!c_state) {
return NT_STATUS_NO_MEMORY;
}
DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
- sd = talloc_p(mem_ctx, struct sec_desc_buf);
+ sd = talloc(mem_ctx, struct sec_desc_buf);
if (sd == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_OK;
}
- array = talloc_p(mem_ctx, struct samr_SamArray);
+ array = talloc(mem_ctx, struct samr_SamArray);
if (array == NULL) {
return NT_STATUS_NO_MEMORY;
}
array->count = 0;
array->entries = NULL;
- array->entries = talloc_array_p(mem_ctx, struct samr_SamEntry, count - start_i);
+ array->entries = talloc_array(mem_ctx, struct samr_SamEntry, count - start_i);
if (array->entries == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_SUCH_DOMAIN;
}
- d_state = talloc_p(c_state, struct samr_domain_state);
+ d_state = talloc(c_state, struct samr_domain_state);
if (!d_state) {
return NT_STATUS_NO_MEMORY;
}
d_state = h->data;
- r->out.info = talloc_p(mem_ctx, union samr_DomainInfo);
+ r->out.info = talloc(mem_ctx, union samr_DomainInfo);
if (!r->out.info) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- a_state = talloc_p(d_state, struct samr_account_state);
+ a_state = talloc(d_state, struct samr_account_state);
if (!a_state) {
return NT_STATUS_NO_MEMORY;
}
}
/* convert to SamEntry format */
- entries = talloc_array_p(mem_ctx, struct samr_SamEntry, ldb_cnt);
+ entries = talloc_array(mem_ctx, struct samr_SamEntry, ldb_cnt);
if (!entries) {
return NT_STATUS_NO_MEMORY;
}
r->out.num_entries = MIN(r->out.num_entries,
1+(r->in.max_size/SAMR_ENUM_USERS_MULTIPLIER));
- r->out.sam = talloc_p(mem_ctx, struct samr_SamArray);
+ r->out.sam = talloc(mem_ctx, struct samr_SamArray);
if (!r->out.sam) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- a_state = talloc_p(d_state, struct samr_account_state);
+ a_state = talloc(d_state, struct samr_account_state);
if (!a_state) {
return NT_STATUS_NO_MEMORY;
}
}
/* convert to SamEntry format */
- entries = talloc_array_p(mem_ctx, struct samr_SamEntry, count);
+ entries = talloc_array(mem_ctx, struct samr_SamEntry, count);
if (!entries) {
return NT_STATUS_NO_MEMORY;
}
r->out.num_entries = MIN(r->out.num_entries,
1+(r->in.max_size/SAMR_ENUM_USERS_MULTIPLIER));
- r->out.sam = talloc_p(mem_ctx, struct samr_SamArray);
+ r->out.sam = talloc(mem_ctx, struct samr_SamArray);
if (!r->out.sam) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- a_state = talloc_p(d_state, struct samr_account_state);
+ a_state = talloc(d_state, struct samr_account_state);
if (!a_state) {
return NT_STATUS_NO_MEMORY;
}
}
/* convert to SamEntry format */
- entries = talloc_array_p(mem_ctx, struct samr_SamEntry, ldb_cnt);
+ entries = talloc_array(mem_ctx, struct samr_SamEntry, ldb_cnt);
if (!entries) {
return NT_STATUS_NO_MEMORY;
}
r->out.num_entries = count - first;
r->out.num_entries = MIN(r->out.num_entries, 1000);
- r->out.sam = talloc_p(mem_ctx, struct samr_SamArray);
+ r->out.sam = talloc(mem_ctx, struct samr_SamArray);
if (!r->out.sam) {
return NT_STATUS_NO_MEMORY;
}
}
r->out.rids->count = 0;
- r->out.rids->ids = talloc_array_p(mem_ctx, uint32_t, count);
+ r->out.rids->ids = talloc_array(mem_ctx, uint32_t, count);
if (r->out.rids->ids == NULL)
return NT_STATUS_NO_MEMORY;
return NT_STATUS_OK;
}
- r->out.rids.ids = talloc_array_p(mem_ctx, uint32_t, r->in.num_names);
- r->out.types.ids = talloc_array_p(mem_ctx, uint32_t, r->in.num_names);
+ r->out.rids.ids = talloc_array(mem_ctx, uint32_t, r->in.num_names);
+ r->out.types.ids = talloc_array(mem_ctx, uint32_t, r->in.num_names);
if (!r->out.rids.ids || !r->out.types.ids) {
return NT_STATUS_NO_MEMORY;
}
if (r->in.num_rids == 0)
return NT_STATUS_OK;
- names = talloc_array_p(mem_ctx, struct samr_String, r->in.num_rids);
- ids = talloc_array_p(mem_ctx, uint32_t, r->in.num_rids);
+ names = talloc_array(mem_ctx, struct samr_String, r->in.num_rids);
+ ids = talloc_array(mem_ctx, uint32_t, r->in.num_rids);
if ((names == NULL) || (ids == NULL))
return NT_STATUS_NO_MEMORY;
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- a_state = talloc_p(d_state, struct samr_account_state);
+ a_state = talloc(d_state, struct samr_account_state);
if (!a_state) {
return NT_STATUS_NO_MEMORY;
}
msg = res[0];
/* allocate the info structure */
- r->out.info = talloc_p(mem_ctx, union samr_GroupInfo);
+ r->out.info = talloc(mem_ctx, union samr_GroupInfo);
if (r->out.info == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- array = talloc_p(mem_ctx, struct samr_ridArray);
+ array = talloc(mem_ctx, struct samr_ridArray);
if (array == NULL)
return NT_STATUS_NO_MEMORY;
array->count = el->num_values;
- array->rids = talloc_array_p(mem_ctx, uint32,
+ array->rids = talloc_array(mem_ctx, uint32,
el->num_values);
if (array->rids == NULL)
return NT_STATUS_NO_MEMORY;
- array->unknown = talloc_array_p(mem_ctx, uint32,
+ array->unknown = talloc_array(mem_ctx, uint32,
el->num_values);
if (array->unknown == NULL)
return NT_STATUS_NO_MEMORY;
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- a_state = talloc_p(d_state, struct samr_account_state);
+ a_state = talloc(d_state, struct samr_account_state);
if (!a_state) {
return NT_STATUS_NO_MEMORY;
}
msg = res[0];
/* allocate the info structure */
- r->out.info = talloc_p(mem_ctx, union samr_AliasInfo);
+ r->out.info = talloc(mem_ctx, union samr_AliasInfo);
if (r->out.info == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (el != NULL) {
int i;
- sids = talloc_array_p(mem_ctx, struct lsa_SidPtr,
+ sids = talloc_array(mem_ctx, struct lsa_SidPtr,
el->num_values);
if (sids == NULL)
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
- a_state = talloc_p(mem_ctx, struct samr_account_state);
+ a_state = talloc(mem_ctx, struct samr_account_state);
if (!a_state) {
return NT_STATUS_NO_MEMORY;
}
msg = res[0];
/* allocate the info structure */
- r->out.info = talloc_p(mem_ctx, union samr_UserInfo);
+ r->out.info = talloc(mem_ctx, union samr_UserInfo);
if (r->out.info == NULL) {
return NT_STATUS_NO_MEMORY;
}
if (count < 0)
return NT_STATUS_INTERNAL_DB_CORRUPTION;
- array = talloc_p(mem_ctx, struct samr_RidArray);
+ array = talloc(mem_ctx, struct samr_RidArray);
if (array == NULL)
return NT_STATUS_NO_MEMORY;
if (count > 0) {
int i;
- array->rid = talloc_array_p(mem_ctx, struct samr_RidType,
+ array->rid = talloc_array(mem_ctx, struct samr_RidType,
count);
if (array->rid == NULL)
switch (r->in.level) {
case 1:
- entriesGeneral = talloc_array_p(mem_ctx,
+ entriesGeneral = talloc_array(mem_ctx,
struct samr_DispEntryGeneral,
ldb_cnt);
break;
case 2:
case 3:
- entriesFull = talloc_array_p(mem_ctx,
+ entriesFull = talloc_array(mem_ctx,
struct samr_DispEntryFull,
ldb_cnt);
break;
case 4:
case 5:
- entriesAscii = talloc_array_p(mem_ctx,
+ entriesAscii = talloc_array(mem_ctx,
struct samr_DispEntryAscii,
ldb_cnt);
break;
}
/* on failure we need to fill in the reject reasons */
- dominfo = talloc_p(mem_ctx, struct samr_DomInfo1);
+ dominfo = talloc(mem_ctx, struct samr_DomInfo1);
if (dominfo == NULL) {
return status;
}
- reject = talloc_p(mem_ctx, struct samr_ChangeReject);
+ reject = talloc(mem_ctx, struct samr_ChangeReject);
if (reject == NULL) {
return status;
}
}
/* store the password history */
- new_lmPwdHistory = talloc_array_p(mem_ctx, struct samr_Password,
+ new_lmPwdHistory = talloc_array(mem_ctx, struct samr_Password,
pwdHistoryLength);
if (!new_lmPwdHistory) {
return NT_STATUS_NO_MEMORY;
}
- new_ntPwdHistory = talloc_array_p(mem_ctx, struct samr_Password,
+ new_ntPwdHistory = talloc_array(mem_ctx, struct samr_Password,
pwdHistoryLength);
if (!new_ntPwdHistory) {
return NT_STATUS_NO_MEMORY;
struct spoolss_PrinterInfo1 *info;
int i;
- info = talloc_array_p(mem_ctx, struct spoolss_PrinterInfo1, num_msgs);
+ info = talloc_array(mem_ctx, struct spoolss_PrinterInfo1, num_msgs);
if (!info)
return WERR_NOMEM;
struct spoolss_PrinterInfo2 *info;
int i;
- info = talloc_array_p(mem_ctx, struct spoolss_PrinterInfo2, num_msgs);
+ info = talloc_array(mem_ctx, struct spoolss_PrinterInfo2, num_msgs);
if (!info)
return WERR_NOMEM;
struct spoolss_PrinterInfo5 *info;
int i;
- info = talloc_array_p(mem_ctx, struct spoolss_PrinterInfo5, num_msgs);
+ info = talloc_array(mem_ctx, struct spoolss_PrinterInfo5, num_msgs);
if (!info)
return WERR_NOMEM;
goto done;
}
- r->out.buffer = talloc_p(mem_ctx, DATA_BLOB);
+ r->out.buffer = talloc(mem_ctx, DATA_BLOB);
if (!r->out.buffer) {
result = WERR_NOMEM;
return WERR_NOMEM;
}
- state = talloc_p(handle, struct spoolss_openprinter_state);
+ state = talloc(handle, struct spoolss_openprinter_state);
if (!state) {
return WERR_OK;
}
switch (r->in.level) {
case 0:
- r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetCharDevCtr0);
+ r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr0);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
r->out.ctr.ctr0->count = 0;
return WERR_NOT_SUPPORTED;
case 1:
- r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetCharDevCtr1);
+ r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevCtr1);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
r->out.ctr.ctr1->count = 0;
switch (r->in.level) {
case 0:
{
- r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetCharDevQCtr0);
+ r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr0);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
r->out.ctr.ctr0->count = 0;
}
case 1:
{
- r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetCharDevQCtr1);
+ r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetCharDevQCtr1);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
r->out.ctr.ctr1->count = 0;
switch (r->in.level) {
case 0:
{
- r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetConnCtr0);
+ r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetConnCtr0);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
r->out.ctr.ctr0->count = 0;
}
case 1:
{
- r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetConnCtr1);
+ r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetConnCtr1);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
r->out.ctr.ctr1->count = 0;
switch (r->in.level) {
case 2:
{
- r->out.ctr.ctr2 = talloc_p(mem_ctx, struct srvsvc_NetFileCtr2);
+ r->out.ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetFileCtr2);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr2);
r->out.ctr.ctr2->count = 0;
}
case 3:
{
- r->out.ctr.ctr3 = talloc_p(mem_ctx, struct srvsvc_NetFileCtr3);
+ r->out.ctr.ctr3 = talloc(mem_ctx, struct srvsvc_NetFileCtr3);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr3);
r->out.ctr.ctr3->count = 0;
switch (r->in.level) {
case 0:
{
- r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr0);
+ r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetSessCtr0);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
r->out.ctr.ctr0->count = 0;
}
case 1:
{
- r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr1);
+ r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetSessCtr1);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
r->out.ctr.ctr1->count = 0;
}
case 2:
{
- r->out.ctr.ctr2 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr2);
+ r->out.ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetSessCtr2);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr2);
r->out.ctr.ctr2->count = 0;
}
case 10:
{
- r->out.ctr.ctr10 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr10);
+ r->out.ctr.ctr10 = talloc(mem_ctx, struct srvsvc_NetSessCtr10);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr10);
r->out.ctr.ctr2->count = 0;
}
case 502:
{
- r->out.ctr.ctr502 = talloc_p(mem_ctx, struct srvsvc_NetSessCtr502);
+ r->out.ctr.ctr502 = talloc(mem_ctx, struct srvsvc_NetSessCtr502);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr502);
r->out.ctr.ctr2->count = 0;
int i;
struct srvsvc_NetShareCtr0 *ctr0;
- ctr0 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr0);
+ ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
W_ERROR_HAVE_NO_MEMORY(ctr0);
ctr0->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr0->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo0, ctr0->count);
+ ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, ctr0->count);
W_ERROR_HAVE_NO_MEMORY(ctr0->array);
for (i=0; i < ctr0->count; i++) {
int i;
struct srvsvc_NetShareCtr1 *ctr1;
- ctr1 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr1);
+ ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
W_ERROR_HAVE_NO_MEMORY(ctr1);
ctr1->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr1->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo1, ctr1->count);
+ ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, ctr1->count);
W_ERROR_HAVE_NO_MEMORY(ctr1->array);
for (i=0; i < ctr1->count; i++) {
int i;
struct srvsvc_NetShareCtr2 *ctr2;
- ctr2 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr2);
+ ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
W_ERROR_HAVE_NO_MEMORY(ctr2);
ctr2->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr2->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo2, ctr2->count);
+ ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, ctr2->count);
W_ERROR_HAVE_NO_MEMORY(ctr2->array);
for (i=0; i < ctr2->count; i++) {
int i;
struct srvsvc_NetShareCtr501 *ctr501;
- ctr501 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr501);
+ ctr501 = talloc(mem_ctx, struct srvsvc_NetShareCtr501);
W_ERROR_HAVE_NO_MEMORY(ctr501);
ctr501->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr501->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo501, ctr501->count);
+ ctr501->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo501, ctr501->count);
W_ERROR_HAVE_NO_MEMORY(ctr501->array);
for (i=0; i < ctr501->count; i++) {
int i;
struct srvsvc_NetShareCtr502 *ctr502;
- ctr502 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr502);
+ ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
W_ERROR_HAVE_NO_MEMORY(ctr502);
ctr502->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr502->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo502, ctr502->count);
+ ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, ctr502->count);
W_ERROR_HAVE_NO_MEMORY(ctr502->array);
for (i=0; i < ctr502->count; i++) {
WERROR status;
union srvsvc_NetShareInfo info;
- info.info0 = talloc_p(mem_ctx, struct srvsvc_NetShareInfo0);
+ info.info0 = talloc(mem_ctx, struct srvsvc_NetShareInfo0);
W_ERROR_HAVE_NO_MEMORY(info.info0);
status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
WERROR status;
union srvsvc_NetShareInfo info;
- info.info1 = talloc_p(mem_ctx, struct srvsvc_NetShareInfo1);
+ info.info1 = talloc(mem_ctx, struct srvsvc_NetShareInfo1);
W_ERROR_HAVE_NO_MEMORY(info.info1);
status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
WERROR status;
union srvsvc_NetShareInfo info;
- info.info2 = talloc_p(mem_ctx, struct srvsvc_NetShareInfo2);
+ info.info2 = talloc(mem_ctx, struct srvsvc_NetShareInfo2);
W_ERROR_HAVE_NO_MEMORY(info.info2);
status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
WERROR status;
union srvsvc_NetShareInfo info;
- info.info501 = talloc_p(mem_ctx, struct srvsvc_NetShareInfo501);
+ info.info501 = talloc(mem_ctx, struct srvsvc_NetShareInfo501);
W_ERROR_HAVE_NO_MEMORY(info.info501);
status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
WERROR status;
union srvsvc_NetShareInfo info;
- info.info502 = talloc_p(mem_ctx, struct srvsvc_NetShareInfo502);
+ info.info502 = talloc(mem_ctx, struct srvsvc_NetShareInfo502);
W_ERROR_HAVE_NO_MEMORY(info.info502);
status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
WERROR status;
union srvsvc_NetShareInfo info;
- info.info1005 = talloc_p(mem_ctx, struct srvsvc_NetShareInfo1005);
+ info.info1005 = talloc(mem_ctx, struct srvsvc_NetShareInfo1005);
W_ERROR_HAVE_NO_MEMORY(info.info1005);
status = srvsvc_fiel_ShareInfo(dce_call, mem_ctx, snum, r->in.level, &info);
{
struct srvsvc_NetSrvInfo100 *info100;
- info100 = talloc_p(mem_ctx, struct srvsvc_NetSrvInfo100);
+ info100 = talloc(mem_ctx, struct srvsvc_NetSrvInfo100);
W_ERROR_HAVE_NO_MEMORY(info100);
info100->platform_id = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
{
struct srvsvc_NetSrvInfo101 *info101;
- info101 = talloc_p(mem_ctx, struct srvsvc_NetSrvInfo101);
+ info101 = talloc(mem_ctx, struct srvsvc_NetSrvInfo101);
W_ERROR_HAVE_NO_MEMORY(info101);
info101->platform_id = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
switch (r->in.level) {
case 0:
{
- r->out.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetDiskCtr0);
+ r->out.ctr0 = talloc(mem_ctx, struct srvsvc_NetDiskCtr0);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr0);
r->out.ctr0->unknown = 0x1;
switch (r->in.level) {
case 0:
{
- r->out.ctr.ctr0 = talloc_p(mem_ctx, struct srvsvc_NetTransportCtr0);
+ r->out.ctr.ctr0 = talloc(mem_ctx, struct srvsvc_NetTransportCtr0);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
r->out.ctr.ctr0->count = 0;
}
case 1:
{
- r->out.ctr.ctr1 = talloc_p(mem_ctx, struct srvsvc_NetTransportCtr1);
+ r->out.ctr.ctr1 = talloc(mem_ctx, struct srvsvc_NetTransportCtr1);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr1);
r->out.ctr.ctr1->count = 0;
}
case 2:
{
- r->out.ctr.ctr2 = talloc_p(mem_ctx, struct srvsvc_NetTransportCtr2);
+ r->out.ctr.ctr2 = talloc(mem_ctx, struct srvsvc_NetTransportCtr2);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr2);
r->out.ctr.ctr2->count = 0;
}
case 3:
{
- r->out.ctr.ctr3 = talloc_p(mem_ctx, struct srvsvc_NetTransportCtr3);
+ r->out.ctr.ctr3 = talloc(mem_ctx, struct srvsvc_NetTransportCtr3);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr3);
r->out.ctr.ctr3->count = 0;
time_t t;
struct tm tm;
- r->out.info = talloc_p(mem_ctx, struct srvsvc_NetRemoteTODInfo);
+ r->out.info = talloc(mem_ctx, struct srvsvc_NetRemoteTODInfo);
W_ERROR_HAVE_NO_MEMORY(r->out.info);
GetTimeOfDay(&tval);
uint32_t count;
struct srvsvc_NetShareCtr0 *ctr0;
- ctr0 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr0);
+ ctr0 = talloc(mem_ctx, struct srvsvc_NetShareCtr0);
W_ERROR_HAVE_NO_MEMORY(ctr0);
ctr0->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr0->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo0, ctr0->count);
+ ctr0->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo0, ctr0->count);
W_ERROR_HAVE_NO_MEMORY(ctr0->array);
count = ctr0->count;
uint32_t count;
struct srvsvc_NetShareCtr1 *ctr1;
- ctr1 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr1);
+ ctr1 = talloc(mem_ctx, struct srvsvc_NetShareCtr1);
W_ERROR_HAVE_NO_MEMORY(ctr1);
ctr1->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr1->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo1, ctr1->count);
+ ctr1->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo1, ctr1->count);
W_ERROR_HAVE_NO_MEMORY(ctr1->array);
count = ctr1->count;
uint32_t count;
struct srvsvc_NetShareCtr2 *ctr2;
- ctr2 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr2);
+ ctr2 = talloc(mem_ctx, struct srvsvc_NetShareCtr2);
W_ERROR_HAVE_NO_MEMORY(ctr2);
ctr2->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr2->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo2, ctr2->count);
+ ctr2->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo2, ctr2->count);
W_ERROR_HAVE_NO_MEMORY(ctr2->array);
count = ctr2->count;
uint32_t count;
struct srvsvc_NetShareCtr501 *ctr501;
- ctr501 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr501);
+ ctr501 = talloc(mem_ctx, struct srvsvc_NetShareCtr501);
W_ERROR_HAVE_NO_MEMORY(ctr501);
ctr501->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr501->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo501, ctr501->count);
+ ctr501->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo501, ctr501->count);
W_ERROR_HAVE_NO_MEMORY(ctr501->array);
count = ctr501->count;
uint32_t count;
struct srvsvc_NetShareCtr502 *ctr502;
- ctr502 = talloc_p(mem_ctx, struct srvsvc_NetShareCtr502);
+ ctr502 = talloc(mem_ctx, struct srvsvc_NetShareCtr502);
W_ERROR_HAVE_NO_MEMORY(ctr502);
ctr502->count = dcesrv_common_get_count_of_shares(mem_ctx, dce_ctx);
return WERR_OK;
}
- ctr502->array = talloc_array_p(mem_ctx, struct srvsvc_NetShareInfo502, ctr502->count);
+ ctr502->array = talloc_array(mem_ctx, struct srvsvc_NetShareInfo502, ctr502->count);
W_ERROR_HAVE_NO_MEMORY(ctr502->array);
count = ctr502->count;
if (W_ERROR_IS_OK(r->out.result)) {
r->out.key_name_len = strlen(key->name);
- r->out.out_name = talloc_zero_p(mem_ctx, struct winreg_EnumKeyNameResponse);
+ r->out.out_name = talloc_zero(mem_ctx, struct winreg_EnumKeyNameResponse);
r->out.out_name->name = key->name;
- r->out.class = talloc_zero_p(mem_ctx, struct winreg_String);
- r->out.last_changed_time = talloc_zero_p(mem_ctx, struct winreg_Time);
+ r->out.class = talloc_zero(mem_ctx, struct winreg_String);
+ r->out.last_changed_time = talloc_zero(mem_ctx, struct winreg_Time);
}
return r->out.result;
return result;
}
- r->out.type = talloc_p(mem_ctx, uint32_t);
+ r->out.type = talloc(mem_ctx, uint32_t);
*r->out.type = value->data_type;
r->out.name_out.name = value->name;
r->out.value = value->data_blk;
- r->out.size = talloc_p(mem_ctx, uint32_t);
+ r->out.size = talloc(mem_ctx, uint32_t);
r->out.length = r->out.size;
*r->out.size = value->data_len;
r->out.type = &val->data_type;
r->out.length = &val->data_len;
if (!r->in.data) {
- r->out.size = talloc_p(mem_ctx, uint32);
+ r->out.size = talloc(mem_ctx, uint32);
*r->out.size = val->data_len;
} else {
r->out.size = r->in.size;
{
struct wkssvc_NetWkstaInfo100 *info100;
- info100 = talloc_p(mem_ctx, struct wkssvc_NetWkstaInfo100);
+ info100 = talloc(mem_ctx, struct wkssvc_NetWkstaInfo100);
W_ERROR_HAVE_NO_MEMORY(info100);
info100->platform_id = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
{
struct wkssvc_NetWkstaInfo101 *info101;
- info101 = talloc_p(mem_ctx, struct wkssvc_NetWkstaInfo101);
+ info101 = talloc(mem_ctx, struct wkssvc_NetWkstaInfo101);
W_ERROR_HAVE_NO_MEMORY(info101);
info101->platform_id = dcesrv_common_get_platform_id(mem_ctx, dce_ctx);
switch (r->in.level) {
case 0:
- r->out.ctr.ctr0 = talloc_p(mem_ctx, struct wkssvc_NetWkstaTransportCtr0);
+ r->out.ctr.ctr0 = talloc(mem_ctx, struct wkssvc_NetWkstaTransportCtr0);
W_ERROR_HAVE_NO_MEMORY(r->out.ctr.ctr0);
r->out.ctr.ctr0->count = 0;
struct smbsrv_tcon *tcon;
int i;
- tcon = talloc_zero_p(smb_conn, struct smbsrv_tcon);
+ tcon = talloc_zero(smb_conn, struct smbsrv_tcon);
if (!tcon) return NULL;
i = idr_get_new(smb_conn->tree.idtree_tid, tcon, UINT16_MAX);
}
/* parse the request */
- io = talloc_p(req, union smb_open);
+ io = talloc(req, union smb_open);
if (io == NULL) {
return NT_STATUS_NO_MEMORY;
}
DATA_BLOB blob;
blob.data = trans->in.data.data;
blob.length = sd_length;
- io->ntcreatex.in.sec_desc = talloc_p(io, struct security_descriptor);
+ io->ntcreatex.in.sec_desc = talloc(io, struct security_descriptor);
if (io->ntcreatex.in.sec_desc == NULL) {
return NT_STATUS_NO_MEMORY;
}
DATA_BLOB blob;
blob.data = trans->in.data.data + sd_length;
blob.length = ea_length;
- io->ntcreatex.in.ea_list = talloc_p(io, struct smb_ea_list);
+ io->ntcreatex.in.ea_list = talloc(io, struct smb_ea_list);
if (io->ntcreatex.in.ea_list == NULL) {
return NT_STATUS_NO_MEMORY;
}
}
/* parse the request */
- io = talloc_p(req, union smb_fileinfo);
+ io = talloc(req, union smb_fileinfo);
if (io == NULL) {
return NT_STATUS_NO_MEMORY;
}
}
/* parse the request */
- io = talloc_p(req, union smb_setfileinfo);
+ io = talloc(req, union smb_setfileinfo);
if (io == NULL) {
return NT_STATUS_NO_MEMORY;
}
io->set_secdesc.file.fnum = SVAL(trans->in.params.data, 0);
io->set_secdesc.in.secinfo_flags = IVAL(trans->in.params.data, 4);
- io->set_secdesc.in.sd = talloc_p(io, struct security_descriptor);
+ io->set_secdesc.in.sd = talloc(io, struct security_descriptor);
if (io->set_secdesc.in.sd == NULL) {
return NT_STATUS_NO_MEMORY;
}
}
/* parse out the setup words */
- trans.in.setup = talloc_array_p(req, uint16_t, trans.in.setup_count);
+ trans.in.setup = talloc_array(req, uint16_t, trans.in.setup_count);
if (!trans.in.setup) {
req_reply_error(req, NT_STATUS_NO_MEMORY);
return;
{
struct smbsrv_session *sess = NULL;
- sess = talloc_p(smb_conn, struct smbsrv_session);
+ sess = talloc(smb_conn, struct smbsrv_session);
if(sess == NULL) {
- DEBUG(0,("talloc_p(smb_conn->mem_ctx, struct smbsrv_session) failed\n"));
+ DEBUG(0,("talloc(smb_conn->mem_ctx, struct smbsrv_session) failed\n"));
return UID_FIELD_INVALID;
}
{
struct smbsrv_request *req;
- req = talloc_p(smb_conn, struct smbsrv_request);
+ req = talloc(smb_conn, struct smbsrv_request);
if (!req) {
return NULL;
}
/* setup the request context */
req->smb_conn = smb_conn;
- req->async_states = talloc_p(req, struct ntvfs_async_state);
+ req->async_states = talloc(req, struct ntvfs_async_state);
if (!req->async_states) {
talloc_free(req);
return NULL;
return NT_STATUS_NO_MEMORY;
}
- req->in.buffer = talloc_array_p(req, uint8_t, NBT_HDR_SIZE);
+ req->in.buffer = talloc_array(req, uint8_t, NBT_HDR_SIZE);
if (req->in.buffer == NULL) {
talloc_free(req);
return NT_STATUS_NO_MEMORY;
DEBUG(5,("smbsrv_accept\n"));
- smb_conn = talloc_zero_p(conn, struct smbsrv_connection);
+ smb_conn = talloc_zero(conn, struct smbsrv_connection);
if (!smb_conn) return;
/* now initialise a few default values associated with this smb socket */
return NT_STATUS_FOOBAR;
}
- io = talloc_p(req, union smb_open);
+ io = talloc(req, union smb_open);
if (io == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_FOOBAR;
}
- io = talloc_p(req, union smb_mkdir);
+ io = talloc(req, union smb_mkdir);
if (io == NULL) {
return NT_STATUS_NO_MEMORY;
}
return;
}
- tp = talloc_p(req, struct smbsrv_trans_partial);
+ tp = talloc(req, struct smbsrv_trans_partial);
tp->req = talloc_reference(tp, req);
tp->trans = trans;
uint16_t param_count, data_count;
uint16_t param_total, data_total;
- trans = talloc_p(req, struct smb_trans2);
+ trans = talloc(req, struct smb_trans2);
if (trans == NULL) {
req_reply_error(req, NT_STATUS_NO_MEMORY);
return;
}
/* parse out the setup words */
- trans->in.setup = talloc_array_p(req, uint16_t, trans->in.setup_count);
+ trans->in.setup = talloc_array(req, uint16_t, trans->in.setup_count);
if (trans->in.setup_count && !trans->in.setup) {
req_reply_error(req, NT_STATUS_NO_MEMORY);
return;
/* add to the existing request */
if (param_count != 0) {
- trans->in.params.data = talloc_realloc_p(trans,
+ trans->in.params.data = talloc_realloc(trans,
trans->in.params.data,
uint8_t,
param_disp + param_count);
}
if (data_count != 0) {
- trans->in.data.data = talloc_realloc_p(trans,
+ trans->in.data.data = talloc_realloc(trans,
trans->in.data.data,
uint8_t,
data_disp + data_count);
stream_socket = talloc_zero(service, struct server_stream_socket);
if (!stream_socket) {
- DEBUG(0,("talloc_p(mem_ctx, struct server_stream_socket) failed\n"));
+ DEBUG(0,("talloc(mem_ctx, struct server_stream_socket) failed\n"));
socket_destroy(sock);
return NULL;
}
struct timed_event idle;
struct server_connection *srv_conn;
- srv_conn = talloc_p(stream_socket, struct server_connection);
+ srv_conn = talloc(stream_socket, struct server_connection);
if (!srv_conn) {
- DEBUG(0,("talloc_p(mem_ctx, struct server_connection) failed\n"));
+ DEBUG(0,("talloc(mem_ctx, struct server_connection) failed\n"));
return NULL;
}
status = smb_raw_trans2(cli->tree, mem_ctx, t2);
if (!NT_STATUS_IS_OK(status)) continue;
- t2b = talloc_p(mem_ctx, struct trans2_blobs);
+ t2b = talloc(mem_ctx, struct trans2_blobs);
t2b->level = level;
t2b->params = t2->out.params;
t2b->data = t2->out.data;
d_printf("Found %d aliased levels\n", alias_count);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
/* look for qfsinfo aliases */
gen_aliases(cli, &t2, 0);
smbcli_unlink(cli->tree, fname);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
gen_aliases(cli, &t2, 6);
smbcli_unlink(cli->tree, fname);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
if (!NT_STATUS_IS_OK(status) &&
!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) continue;
- t2b = talloc_p(mem_ctx, struct trans2_blobs);
+ t2b = talloc(mem_ctx, struct trans2_blobs);
t2b->level = level;
t2b->params = t2->out.params;
t2b->data = t2->out.data;
}
d_printf("Found %d valid levels\n", count);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
if (NT_STATUS_IS_ERR(smbcli_unlink(cli->tree, fname))) {
printf("unlink: %s\n", smbcli_errstr(cli->tree));
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
ret &= test_delayed_write_update2(cli, mem_ctx);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
*rparam_len = t2.out.params.length;
*rdata_len = t2.out.data.length;
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
if (NT_STATUS_IS_ERR(status)) {
DEBUG(1,("Failed to send NT_TRANS\n"));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
*rparam_len = parms.out.params.length;
*rdata_len = parms.out.data.length;
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
return False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
} while (nlocks == 0);
if (nlocks > 0) {
- parm[0].lockx.in.locks = talloc_array_p(current_op.mem_ctx,
+ parm[0].lockx.in.locks = talloc_array(current_op.mem_ctx,
struct smb_lock_entry,
nlocks);
for (n=0;n<nlocks;n++) {
ret = gen_ops[which_op].handler(instance);
- talloc_destroy(current_op.mem_ctx);
+ talloc_free(current_op.mem_ctx);
gen_ops[which_op].count++;
if (NT_STATUS_IS_OK(current_op.status)) {
/* no more test we are closing */
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_ldap_close(conn);
ret &= test_BindingString(mem_ctx, test_strings[i]);
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
ret = smb_raw_open(c->tree, mem_ctx, &io);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("NTCreateX", status, ret);
ret = smb_raw_pathinfo(c->tree, mem_ctx, &io);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("Pathinfo", status, ret);
}
ret = smb_raw_fileinfo(c->tree, mem_ctx, &io);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("Fileinfo", status, ret);
}
io.generic.level = level;
ret = smb_raw_fsinfo(c->tree, mem_ctx, &io);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("Fsinfo", status, ret);
}
ret = smb_raw_search_first(c->tree, mem_ctx, &io, NULL, findfirst_callback);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
check_status("Search", status, ret);
{
struct rap_call *call;
- call = talloc_p(mem_ctx, struct rap_call);
+ call = talloc(mem_ctx, struct rap_call);
if (call == NULL)
return NULL;
NDR_OK(ndr_pull_uint16(call->ndr_pull_param, &r->out.count));
NDR_OK(ndr_pull_uint16(call->ndr_pull_param, &r->out.available));
- r->out.info = talloc_array_p(call, union rap_shareenum_info,
+ r->out.info = talloc_array(call, union rap_shareenum_info,
r->out.count);
if (r->out.info == NULL) {
result = NT_STATUS_OK;
done:
- talloc_destroy(call);
+ talloc_free(call);
return result;
}
NDR_OK(ndr_pull_uint16(call->ndr_pull_param, &r->out.count));
NDR_OK(ndr_pull_uint16(call->ndr_pull_param, &r->out.available));
- r->out.info = talloc_array_p(call, union rap_server_info,
+ r->out.info = talloc_array(call, union rap_server_info,
r->out.count);
if (r->out.info == NULL) {
result = NT_STATUS_OK;
done:
- talloc_destroy(call);
+ talloc_free(call);
return result;
}
}
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smbcli_close(cli->tree, fnum);
smbcli_unlink(cli->tree, fname);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
setfile.generic.level = RAW_SFILEINFO_EA_SET;
setfile.generic.file.fnum = fnum;
setfile.ea_set.in.num_eas = 2;
- setfile.ea_set.in.eas = talloc_array_p(mem_ctx, struct ea_struct, 2);
+ setfile.ea_set.in.eas = talloc_array(mem_ctx, struct ea_struct, 2);
setfile.ea_set.in.eas[0].flags = 0;
setfile.ea_set.in.eas[0].name.s = "EAONE";
setfile.ea_set.in.eas[0].value = data_blob_string_const("VALUE1");
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
ret &= test_changetype(cli, mem_ctx);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
md.t2mkdir.level = RAW_MKDIR_T2MKDIR;
md.t2mkdir.in.path = path;
md.t2mkdir.in.num_eas = 3;
- md.t2mkdir.in.eas = talloc_array_p(mem_ctx, struct ea_struct, md.t2mkdir.in.num_eas);
+ md.t2mkdir.in.eas = talloc_array(mem_ctx, struct ea_struct, md.t2mkdir.in.num_eas);
md.t2mkdir.in.eas[0].flags = 0;
md.t2mkdir.in.eas[0].name.s = "EAONE";
md.t2mkdir.in.eas[0].value = data_blob_talloc(mem_ctx, "blah", 4);
}
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smb_raw_exit(cli->session);
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
io.t2open.in.timeout = 0;
io.t2open.in.num_eas = 3;
- io.t2open.in.eas = talloc_array_p(mem_ctx, struct ea_struct, io.t2open.in.num_eas);
+ io.t2open.in.eas = talloc_array(mem_ctx, struct ea_struct, io.t2open.in.num_eas);
io.t2open.in.eas[0].flags = 0;
io.t2open.in.eas[0].name.s = ".CLASSINFO";
io.t2open.in.eas[0].value = data_blob_talloc(mem_ctx, "first value", 11);
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
}
torture_close_connection(cli1);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smbcli_unlink(cli->tree, fname);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
done:
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
}
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
}
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
data->count++;
- data->list = talloc_realloc_p(data->mem_ctx,
+ data->list = talloc_realloc(data->mem_ctx,
data->list,
union smb_search_data,
data->count);
setfile.generic.level = RAW_SFILEINFO_EA_SET;
setfile.generic.file.fname = BASEDIR "\\file2.txt";
setfile.ea_set.in.num_eas = 2;
- setfile.ea_set.in.eas = talloc_array_p(mem_ctx, struct ea_struct, 2);
+ setfile.ea_set.in.eas = talloc_array(mem_ctx, struct ea_struct, 2);
setfile.ea_set.in.eas[0].flags = 0;
setfile.ea_set.in.eas[0].name.s = "EA ONE";
setfile.ea_set.in.eas[0].value = data_blob_string_const("VALUE 1");
io.t2ffirst.in.storage_type = 0;
io.t2ffirst.in.pattern = BASEDIR "\\*";
io.t2ffirst.in.num_names = 2;
- io.t2ffirst.in.ea_names = talloc_array_p(mem_ctx, struct ea_name, 2);
+ io.t2ffirst.in.ea_names = talloc_array(mem_ctx, struct ea_name, 2);
io.t2ffirst.in.ea_names[0].name.s = "SECOND EA";
io.t2ffirst.in.ea_names[1].name.s = "THIRD EA";
nxt.t2fnext.in.flags = FLAG_TRANS2_FIND_REQUIRE_RESUME | FLAG_TRANS2_FIND_CONTINUE;
nxt.t2fnext.in.last_name = "file2.txt";
nxt.t2fnext.in.num_names = 2;
- nxt.t2fnext.in.ea_names = talloc_array_p(mem_ctx, struct ea_name, 2);
+ nxt.t2fnext.in.ea_names = talloc_array(mem_ctx, struct ea_name, 2);
nxt.t2fnext.in.ea_names[0].name.s = "SECOND EA";
nxt.t2fnext.in.ea_names[1].name.s = "THIRD EA";
ret &= test_ea_list(cli, mem_ctx);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
}
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
}
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
smbcli_deltree(cli->tree, BASEDIR);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
}
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
ret &= test_writex(cli, mem_ctx);
torture_close_connection(cli);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
printf("testing DSSETUP pipe operations\n");
ret &= test_DsRoleGetPrimaryDomainInformation(p2, mem_ctx);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
return False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
status = dcerpc_parse_binding(mem_ctx, binding_string, &b);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to parse dcerpc binding '%s'\n", binding_string));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return False;
}
printf("\n");
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
return ret;
printf("\n");
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
return ret;
ret = False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
ret &= test_DsUnbind(p, mem_ctx, &priv);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
ret &= test_DsRoleGetPrimaryDomainInformation(p, mem_ctx);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
r.in.num_ents = 1;
- r.in.entries = talloc_array_p(mem_ctx, struct epm_entry_t, 1);
+ r.in.entries = talloc_array(mem_ctx, struct epm_entry_t, 1);
ZERO_STRUCT(r.in.entries[0].object);
r.in.entries[0].annotation = "smbtorture endpoint";
status = dcerpc_parse_binding(mem_ctx, "ncalrpc:[SMBTORTURE]", &bd);
return False;
}
- r.in.entries[0].tower = talloc_p(mem_ctx, struct epm_twr_t);
+ r.in.entries[0].tower = talloc(mem_ctx, struct epm_twr_t);
status = dcerpc_binding_build_tower(mem_ctx, &bd, &r.in.entries[0].tower->tower);
if (NT_STATUS_IS_ERR(status)) {
NTSTATUS status;
struct epm_InqObject r;
- r.in.epm_object = talloc_p(mem_ctx, struct GUID);
+ r.in.epm_object = talloc(mem_ctx, struct GUID);
GUID_from_string(DCERPC_EPMAPPER_UUID, r.in.epm_object);
status = dcerpc_epm_InqObject(p, mem_ctx, &r);
ret = False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
test_CloseEventLog(p, mem_ctx, &handle);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
sids.count = 0;
sids.sids = NULL;
- names = talloc_array_p(mem_ctx, struct lsa_String, tnames->count);
+ names = talloc_array(mem_ctx, struct lsa_String, tnames->count);
for (i=0;i<tnames->count;i++) {
init_lsa_String(&names[i], tnames->names[i].name.string);
}
sids.count = 0;
sids.sids = NULL;
- names = talloc_array_p(mem_ctx, struct lsa_String, tnames->count);
+ names = talloc_array(mem_ctx, struct lsa_String, tnames->count);
for (i=0;i<tnames->count;i++) {
init_lsa_String(&names[i], tnames->names[i].name.string);
}
sids.count = 0;
sids.sids = NULL;
- names = talloc_array_p(mem_ctx, struct lsa_String, tnames->count);
+ names = talloc_array(mem_ctx, struct lsa_String, tnames->count);
for (i=0;i<tnames->count;i++) {
init_lsa_String(&names[i], tnames->names[i].name.string);
}
sids.num_sids = 100;
- sids.sids = talloc_array_p(mem_ctx, struct lsa_SidPtr, sids.num_sids);
+ sids.sids = talloc_array(mem_ctx, struct lsa_SidPtr, sids.num_sids);
for (i=0; i<sids.num_sids; i++) {
const char *sidstr = "S-1-5-32-545";
privs.count = 1;
privs.unknown = 0;
- privs.set = talloc_array_p(mem_ctx, struct lsa_LUIDAttribute, 1);
+ privs.set = talloc_array(mem_ctx, struct lsa_LUIDAttribute, 1);
privs.set[0].luid = *luid;
privs.set[0].attribute = 0;
privs.count = 1;
privs.unknown = 0;
- privs.set = talloc_array_p(mem_ctx, struct lsa_LUIDAttribute, 1);
+ privs.set = talloc_array(mem_ctx, struct lsa_LUIDAttribute, 1);
privs.set[0].luid = *luid;
privs.set[0].attribute = 0;
ret = False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
struct creds_CredentialState creds_async[ASYNC_COUNT];
struct rpc_request *req[ASYNC_COUNT];
int i;
- int *async_counter = talloc_p(mem_ctx, int);
+ int *async_counter = talloc(mem_ctx, int);
if (!lp_parm_bool(-1, "torture", "dangerous", False)) {
printf("test_GetDomainInfo_async disabled - enable dangerous tests to use\n");
ret &= test_GetDomainInfo_async(p, mem_ctx);
ret &= test_netr_DrsGetDCNameEx2(p, mem_ctx);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
if(!test_ResolveOxid2(p, mem_ctx, oxid))
ret = False;
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
if(!test_RemoteActivation(p, mem_ctx))
ret = False;
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
}
failed:
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
r.in.alias_handle = handle;
r.in.level = levels[i];
- r.in.info = talloc_p(mem_ctx, union samr_AliasInfo);
+ r.in.info = talloc(mem_ctx, union samr_AliasInfo);
switch (r.in.level) {
case 2 : init_samr_String(&r.in.info->name,TEST_ALIASNAME); break;
case 3 : init_samr_String(&r.in.info->description,
a.in.sids = &sids;
sids.num_sids = 3;
- sids.sids = talloc_array_p(mem_ctx, struct lsa_SidPtr, 3);
+ sids.sids = talloc_array(mem_ctx, struct lsa_SidPtr, 3);
sids.sids[0].sid = dom_sid_parse_talloc(mem_ctx, "S-1-5-32-1-2-3-1");
sids.sids[1].sid = dom_sid_parse_talloc(mem_ctx, "S-1-5-32-1-2-3-2");
printf("Testing LookupNames\n");
n.in.domain_handle = handle;
n.in.num_names = r.out.sam->count;
- n.in.names = talloc_array_p(mem_ctx, struct samr_String, r.out.sam->count);
+ n.in.names = talloc_array(mem_ctx, struct samr_String, r.out.sam->count);
for (i=0;i<r.out.sam->count;i++) {
n.in.names[i] = r.out.sam->entries[i].name;
}
printf("Testing LookupRids\n");
lr.in.domain_handle = handle;
lr.in.num_rids = r.out.sam->count;
- lr.in.rids = talloc_array_p(mem_ctx, uint32_t, r.out.sam->count);
+ lr.in.rids = talloc_array(mem_ctx, uint32_t, r.out.sam->count);
for (i=0;i<r.out.sam->count;i++) {
lr.in.rids[i] = r.out.sam->entries[i].idx;
}
ret = False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
struct samr_String name;
struct samr_OpenDomain o;
struct samr_LookupDomain l;
- struct policy_handle *domain_handle = talloc_p(mem_ctx, struct policy_handle);
+ struct policy_handle *domain_handle = talloc(mem_ctx, struct policy_handle);
NTSTATUS nt_status;
name.string = domain;
{
struct netr_DELTA_SECRET *secret = delta->delta_union.secret;
const char *name = delta->delta_id_union.name;
- struct samsync_secret *new = talloc_p(samsync_state, struct samsync_secret);
- struct samsync_secret *old = talloc_p(mem_ctx, struct samsync_secret);
+ struct samsync_secret *new = talloc(samsync_state, struct samsync_secret);
+ struct samsync_secret *old = talloc(mem_ctx, struct samsync_secret);
struct lsa_QuerySecret q;
struct lsa_OpenSecret o;
struct policy_handle sec_handle;
struct netr_DELTA_TRUSTED_DOMAIN *trusted_domain = delta->delta_union.trusted_domain;
struct dom_sid *dom_sid = delta->delta_id_union.sid;
- struct samsync_trusted_domain *new = talloc_p(samsync_state, struct samsync_trusted_domain);
+ struct samsync_trusted_domain *new = talloc(samsync_state, struct samsync_trusted_domain);
struct lsa_OpenTrustedDomain t;
struct policy_handle trustdom_handle;
struct lsa_QueryTrustedDomainInfo q;
return False;
}
- samsync_state = talloc_zero_p(mem_ctx, struct samsync_state);
+ samsync_state = talloc_zero(mem_ctx, struct samsync_state);
samsync_state->p_samr = torture_join_samr_pipe(join_ctx);
- samsync_state->connect_handle = talloc_zero_p(samsync_state, struct policy_handle);
- samsync_state->lsa_handle = talloc_zero_p(samsync_state, struct policy_handle);
+ samsync_state->connect_handle = talloc_zero(samsync_state, struct policy_handle);
+ samsync_state->lsa_handle = talloc_zero(samsync_state, struct policy_handle);
c.in.system_name = NULL;
c.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
c.out.connect_handle = samsync_state->connect_handle;
s.in.domain_handle = domain_policy;
s.in.level = 4;
- s.in.info = talloc_p(mem_ctx, union samr_DomainInfo);
+ s.in.info = talloc(mem_ctx, union samr_DomainInfo);
s.in.info->info4.comment.string
= talloc_asprintf(mem_ctx,
torture_leave_domain(join_ctx);
torture_leave_domain(join_ctx2);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return ret;
}
ret = False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
r.in.level, devicequeue);
switch (r.in.level) {
case 0:
- r.in.info.info0 = talloc_p(mem_ctx, struct srvsvc_NetCharDevQInfo0);
+ r.in.info.info0 = talloc(mem_ctx, struct srvsvc_NetCharDevQInfo0);
r.in.info.info0->device = r.in.queue_name;
break;
case 1:
- r.in.info.info1 = talloc_p(mem_ctx, struct srvsvc_NetCharDevQInfo1);
+ r.in.info.info1 = talloc(mem_ctx, struct srvsvc_NetCharDevQInfo1);
r.in.info.info1->device = r.in.queue_name;
r.in.info.info1->priority = 0x000;
r.in.info.info1->devices = r.in.queue_name;
ret = False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
ret = False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
int policy_min_pw_len = 0;
struct test_join *join;
- join = talloc_p(NULL, struct test_join);
+ join = talloc(NULL, struct test_join);
if (join == NULL) {
return NULL;
}
{
struct test_join_ads_dc *join;
- join = talloc_p(NULL, struct test_join_ads_dc);
+ join = talloc(NULL, struct test_join_ads_dc);
if (join == NULL) {
return NULL;
}
ZERO_STRUCT(r);
r.in.handle = handle;
- r.in.data = r.out.data = talloc_zero_p(mem_ctx, struct KeySecurityData);
+ r.in.data = r.out.data = talloc_zero(mem_ctx, struct KeySecurityData);
r.in.data->size = 0xffff;
r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
printf("Testing QueryMultipleValues\n");
r.in.key_handle = handle;
- r.in.values = r.out.values = talloc_array_p(mem_ctx, struct QueryMultipleValue, 1);
- r.in.values[0].name = talloc_p(mem_ctx, struct winreg_String);
+ r.in.values = r.out.values = talloc_array(mem_ctx, struct QueryMultipleValue, 1);
+ r.in.values[0].name = talloc(mem_ctx, struct winreg_String);
r.in.values[0].name->name = valuename;
r.in.values[0].offset = 0;
r.in.values[0].length = 0;
r.in.values[0].type = 0;
r.in.num_values = 1;
- r.in.buffer_size = r.out.buffer_size = talloc_p(mem_ctx, uint32);
+ r.in.buffer_size = r.out.buffer_size = talloc(mem_ctx, uint32);
*r.in.buffer_size = 0x20;
r.in.buffer = r.out.buffer = talloc_zero_array(mem_ctx, uint8, *r.in.buffer_size);
NTSTATUS status;
r.in.hostname = NULL;
- r.in.message = talloc_p(mem_ctx, struct winreg_String);
+ r.in.message = talloc(mem_ctx, struct winreg_String);
init_winreg_String(r.in.message, msg);
r.in.force_apps = 1;
r.in.timeout = timeout;
NTSTATUS status;
r.in.hostname = NULL;
- r.in.message = talloc_p(mem_ctx, struct winreg_String);
+ r.in.message = talloc(mem_ctx, struct winreg_String);
init_winreg_String(r.in.message, msg);
r.in.force_apps = 1;
r.in.timeout = timeout;
ret = False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
ret = False;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
torture_rpc_close(p);
DCERPC_LSARPC_VERSION);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
talloc_free(p);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NT_STATUS_OK;
}
DCERPC_LSARPC_VERSION);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
!NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
printf("LookupNames failed - %s\n", nt_errstr(status));
talloc_free(p);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NT_STATUS_OK;
}
}
talloc_free(p);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NT_STATUS_OK;
}
DCERPC_NETLOGON_VERSION);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
&lmv2_response, &ntlmv2_response,
NULL, NULL)) {
data_blob_free(&names_blob);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NT_STATUS_UNSUCCESSFUL;
}
data_blob_free(&names_blob);
log.out.return_authenticator = NULL;
status = dcerpc_netr_LogonSamLogon(p, mem_ctx, &log);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
data_blob_free(&lmv2_response);
data_blob_free(&ntlmv2_response);
return status;
DCERPC_SAMR_VERSION);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
l.in.domain_handle = &domain_handle;
l.in.num_rids = g.out.rids->count;
- l.in.rids = talloc_array_p(mem_ctx, uint32_t, g.out.rids->count);
+ l.in.rids = talloc_array(mem_ctx, uint32_t, g.out.rids->count);
for (i=0; i<g.out.rids->count; i++)
l.in.rids[i] = g.out.rids->rid[i].rid;
status = dcerpc_samr_LookupRids(p, mem_ctx, &l);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
}
}
talloc_free(p);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NT_STATUS_OK;
}
DCERPC_SAMR_VERSION);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
ga.in.domain_handle = &builtin_handle;
sids.num_sids = g.out.rids->count+2;
- sids.sids = talloc_array_p(mem_ctx, struct lsa_SidPtr,
+ sids.sids = talloc_array(mem_ctx, struct lsa_SidPtr,
g.out.rids->count+2);
sids.sids[0].sid = user_sid;
sids.sids[1].sid = primary_group_sid;
}
talloc_free(p);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NT_STATUS_OK;
}
DCERPC_SRVSVC_VERSION);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
ZERO_STRUCT(r.out);
status = dcerpc_srvsvc_NetRemoteTOD(p, mem_ctx, &r);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
talloc_free(p);
return status;
}
if (mem_ctx == NULL)
return False;
- netlogon_creds = talloc_p(mem_ctx, struct creds_CredentialState);
+ netlogon_creds = talloc(mem_ctx, struct creds_CredentialState);
if (!netlogon_creds) {
return False;
}
talloc_free(transport);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return True;
}
status = dcerpc_parse_binding(mem_ctx, binding, &b);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("Failed to parse dcerpc binding '%s'\n", binding));
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
status = dcerpc_parse_binding(mem_ctx, binding_string, &binding_struct);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return NT_STATUS_IS_OK(status);
}
status = smb_raw_open(tree, mem_ctx, &io);
if (!NT_STATUS_IS_OK(status)) {
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return -1;
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return io.ntcreatex.out.fnum;
}
setfile.generic.level = RAW_SFILEINFO_EA_SET;
setfile.generic.file.fnum = fnum;
setfile.ea_set.in.num_eas = 2;
- setfile.ea_set.in.eas = talloc_array_p(mem_ctx, struct ea_struct, 2);
+ setfile.ea_set.in.eas = talloc_array(mem_ctx, struct ea_struct, 2);
setfile.ea_set.in.eas[0].flags = 0;
setfile.ea_set.in.eas[0].name.s = "EAONE";
setfile.ea_set.in.eas[0].value = data_blob_talloc(mem_ctx, "VALUE1", 6);
d_printf("%s:\n", fname);
dump_all_info(mem_ctx, &finfo);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
status = smb_raw_ioctl(tree, mem_ctx, &nt);
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return status;
}
net_init_subsystems;
mem_ctx = talloc_init("net_context");
- ctx = talloc_p(mem_ctx, struct net_context);
+ ctx = talloc(mem_ctx, struct net_context);
if (!ctx) {
d_printf("talloc_init(net_context) failed\n");
exit(1);
DEBUG(0,("return code = %d\n", rc));
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
return rc;
}
domain, username, workstation,
nt_errstr(nt_status)));
}
- talloc_destroy(mem_ctx);
+ talloc_free(mem_ctx);
}
if (error_string) {
*error_string = strdup(nt_errstr(nt_status));
return;
}
if (!mux_private) {
- mux_private = talloc_p(NULL, struct mux_private);
+ mux_private = talloc(NULL, struct mux_private);
mux_private->max_mux = 0;
mux_private->private_pointers = NULL;
}
unsigned int prev_max = mux_private->max_mux;
mux_private->max_mux = mux_id + 1;
mux_private->private_pointers
- = talloc_realloc_p(mux_private,
+ = talloc_realloc(mux_private,
mux_private->private_pointers,
void *, mux_private->max_mux);
memset(&mux_private->private_pointers[prev_max], '\0',
git.samba.org / samba.git / commitdiff