sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-03-27 22:50:26 +03:00
Code

we can now do a level1 NetDfsEnum()

Browse Source 
(This used to be commit f32641f73f7ff12b797378b3b533603ff1d526b5)
This commit is contained in:
Andrew Tridgell 2003-11-14 07:20:46 +00:00
parent 5b7f049829
commit e8a3825ebc
12 changed files with 1960 additions and 1482 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
source4/librpc/idl/dfs.idl
View File

@ -39,7 +39,7 @@
/******************/
/* Function: 0x04 */
NTSTATUS dfs_Info (
[in,ref] unistr *path,
[in,ref] unistr_noterm *path,
[in] unistr *server,
[in] unistr *share,
[in] uint16 level
@ -48,9 +48,29 @@
/******************/
/* Function: 0x05 */
typedef struct {
unistr *str;
} dfs_String;
typedef struct {
uint32 count;
[size_is(count)] dfs_String *s;
} dfs_Enum1;
typedef union {
case(1) dfs_Enum1 *enum1;
} dfs_EnumInfo;
typedef struct {
uint32 level;
[switch_is(level)] dfs_EnumInfo e;
} dfs_EnumStruct;
NTSTATUS dfs_Enum (
[in] unistr *name,
[in] uint32 level,
[in] uint32 buffer_size
[in] uint32 bufsize,
[in,out] dfs_EnumStruct *info,
[in] uint32 *unknown,
[in,out] uint32 *total
);
}

23
source4/librpc/idl/echo.idl
View File

@ -25,16 +25,27 @@ interface rpcecho
[out,ref,size_is(len)] uint8 *data
);
#define long uint32
#define int uint32
typedef struct {
long bar;
long count;
long foo;
[size_is(count)] long s[*];
int *count;
} echo_Enum1;
typedef struct {
int *count;
} echo_Enum3;
typedef union {
[case(1)] echo_Enum1 enum1;
[case(3)] echo_Enum3 enum3;
} echo_EnumInfo;
typedef struct {
int level;
[switch_is(level)] echo_EnumInfo e;
} Struct1;
void TestCall (
[out] Struct1 **s1
[out] Struct1 *s1
);
}

19
source4/librpc/ndr/ndr.c
View File

@ -337,3 +337,22 @@ NTSTATUS ndr_pull_error(struct ndr_pull *ndr, enum ndr_err_code err, const char
/* we should map to different status codes */
return NT_STATUS_INVALID_PARAMETER;
}
/*
return and possibly log an NDR error
*/
NTSTATUS ndr_push_error(struct ndr_push *ndr, enum ndr_err_code err, const char *format, ...)
{
char *s=NULL;
va_list ap;
va_start(ap, format);
vasprintf(&s, format, ap);
va_end(ap);
DEBUG(3,("ndr_push_error(%u): %s\n", err, s));
free(s);
/* we should map to different status codes */
return NT_STATUS_INVALID_PARAMETER;
}

12
source4/librpc/ndr/ndr_basic.c
View File

@ -238,6 +238,18 @@ NTSTATUS ndr_push_array_uint8(struct ndr_push *ndr, const char *data, uint32 n)
return ndr_push_bytes(ndr, data, n);
}
/*
push an array of uint32
*/
NTSTATUS ndr_push_array_uint32(struct ndr_push *ndr, const uint32 *data, uint32 n)
{
int i;
for (i=0;i<n;i++) {
NDR_CHECK(ndr_push_uint32(ndr, data[i]));
}
return NT_STATUS_OK;
}
/*
save the current position
*/

327
source4/librpc/ndr/ndr_dfs.c
View File

@ -8,13 +8,6 @@ NTSTATUS ndr_push_dfs_Exist(struct ndr_push *ndr, struct dfs_Exist *r)
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_Exist(struct ndr_pull *ndr, struct dfs_Exist *r)
{
NDR_CHECK(ndr_pull_uint32(ndr, r->out.exist_flag));
return NT_STATUS_OK;
}
NTSTATUS ndr_push_dfs_Add(struct ndr_push *ndr, struct dfs_Add *r)
{
NDR_CHECK(ndr_push_ptr(ndr, r->in.path));
@ -38,13 +31,6 @@ NTSTATUS ndr_push_dfs_Add(struct ndr_push *ndr, struct dfs_Add *r)
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_Add(struct ndr_pull *ndr, struct dfs_Add *r)
{
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
}
NTSTATUS ndr_push_dfs_Remove(struct ndr_push *ndr, struct dfs_Remove *r)
{
NDR_CHECK(ndr_push_unistr(ndr, r->in.path));
@ -60,29 +46,15 @@ NTSTATUS ndr_push_dfs_Remove(struct ndr_push *ndr, struct dfs_Remove *r)
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_Remove(struct ndr_pull *ndr, struct dfs_Remove *r)
{
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
}
NTSTATUS ndr_push_dfs_UNKNOWN3(struct ndr_push *ndr, struct dfs_UNKNOWN3 *r)
{
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_UNKNOWN3(struct ndr_pull *ndr, struct dfs_UNKNOWN3 *r)
{
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
}
NTSTATUS ndr_push_dfs_Info(struct ndr_push *ndr, struct dfs_Info *r)
{
NDR_CHECK(ndr_push_unistr(ndr, r->in.path));
NDR_CHECK(ndr_push_unistr_noterm(ndr, r->in.path));
NDR_CHECK(ndr_push_ptr(ndr, r->in.server));
if (r->in.server) {
NDR_CHECK(ndr_push_unistr(ndr, r->in.server));
@ -96,6 +68,125 @@ NTSTATUS ndr_push_dfs_Info(struct ndr_push *ndr, struct dfs_Info *r)
return NT_STATUS_OK;
}
static NTSTATUS ndr_push_dfs_String(struct ndr_push *ndr, int ndr_flags, struct dfs_String *r)
{
NDR_CHECK(ndr_push_align(ndr, 4));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_push_ptr(ndr, r->str));
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
if (r->str) {
NDR_CHECK(ndr_push_unistr(ndr, r->str));
}
done:
return NT_STATUS_OK;
}
static NTSTATUS ndr_push_dfs_Enum1(struct ndr_push *ndr, int ndr_flags, struct dfs_Enum1 *r)
{
NDR_CHECK(ndr_push_align(ndr, 4));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_push_uint32(ndr, r->count));
NDR_CHECK(ndr_push_ptr(ndr, r->s));
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
if (r->s) {
NDR_CHECK(ndr_push_uint32(ndr, r->count));
NDR_CHECK(ndr_push_array(ndr, ndr_flags, r->s, sizeof(r->s[0]), r->count, (ndr_push_flags_fn_t)ndr_push_dfs_String));
}
done:
return NT_STATUS_OK;
}
static NTSTATUS ndr_push_dfs_EnumInfo(struct ndr_push *ndr, int ndr_flags, uint16 level, union dfs_EnumInfo *r)
{
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_push_uint16(ndr, level));
switch (level) {
case 1:
NDR_CHECK(ndr_push_ptr(ndr, r->enum1));
break;
default:
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
}
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
switch (level) {
case 1:
if (r->enum1) {
NDR_CHECK(ndr_push_dfs_Enum1(ndr, ndr_flags, r->enum1));
}
break;
default:
return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
}
done:
return NT_STATUS_OK;
}
static NTSTATUS ndr_push_dfs_EnumStruct(struct ndr_push *ndr, int ndr_flags, struct dfs_EnumStruct *r)
{
NDR_CHECK(ndr_push_align(ndr, 4));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_push_uint32(ndr, r->level));
NDR_CHECK(ndr_push_dfs_EnumInfo(ndr, NDR_SCALARS, r->level, &r->e));
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
NDR_CHECK(ndr_push_dfs_EnumInfo(ndr, NDR_BUFFERS, r->level, &r->e));
done:
return NT_STATUS_OK;
}
NTSTATUS ndr_push_dfs_Enum(struct ndr_push *ndr, struct dfs_Enum *r)
{
NDR_CHECK(ndr_push_uint32(ndr, r->in.level));
NDR_CHECK(ndr_push_uint32(ndr, r->in.bufsize));
NDR_CHECK(ndr_push_ptr(ndr, r->in.info));
if (r->in.info) {
NDR_CHECK(ndr_push_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
}
NDR_CHECK(ndr_push_ptr(ndr, r->in.unknown));
if (r->in.unknown) {
NDR_CHECK(ndr_push_uint32(ndr, *r->in.unknown));
}
NDR_CHECK(ndr_push_ptr(ndr, r->in.total));
if (r->in.total) {
NDR_CHECK(ndr_push_uint32(ndr, *r->in.total));
}
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_Exist(struct ndr_pull *ndr, struct dfs_Exist *r)
{
NDR_CHECK(ndr_pull_uint32(ndr, r->out.exist_flag));
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_Add(struct ndr_pull *ndr, struct dfs_Add *r)
{
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_Remove(struct ndr_pull *ndr, struct dfs_Remove *r)
{
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_UNKNOWN3(struct ndr_pull *ndr, struct dfs_UNKNOWN3 *r)
{
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_Info(struct ndr_pull *ndr, struct dfs_Info *r)
{
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
@ -103,24 +194,186 @@ NTSTATUS ndr_pull_dfs_Info(struct ndr_pull *ndr, struct dfs_Info *r)
return NT_STATUS_OK;
}
NTSTATUS ndr_push_dfs_Enum(struct ndr_push *ndr, struct dfs_Enum *r)
static NTSTATUS ndr_pull_dfs_String(struct ndr_pull *ndr, int ndr_flags, struct dfs_String *r)
{
NDR_CHECK(ndr_push_ptr(ndr, r->in.name));
if (r->in.name) {
NDR_CHECK(ndr_push_unistr(ndr, r->in.name));
uint32 _ptr_str;
NDR_CHECK(ndr_pull_align(ndr, 4));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_str));
if (_ptr_str) {
NDR_ALLOC(ndr, r->str);
} else {
r->str = NULL;
}
NDR_CHECK(ndr_push_uint32(ndr, r->in.level));
NDR_CHECK(ndr_push_uint32(ndr, r->in.buffer_size));
NDR_CHECK(ndr_push_uint32(ndr, *r->in.resume_handle));
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
if (r->str) {
NDR_CHECK(ndr_pull_unistr(ndr, &r->str));
}
done:
return NT_STATUS_OK;
}
static NTSTATUS ndr_pull_dfs_Enum1(struct ndr_pull *ndr, int ndr_flags, struct dfs_Enum1 *r)
{
uint32 _ptr_s;
NDR_CHECK(ndr_pull_align(ndr, 4));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_s));
if (_ptr_s) {
NDR_ALLOC(ndr, r->s);
} else {
r->s = NULL;
}
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
if (r->s) {
{
uint32 _array_size;
NDR_CHECK(ndr_pull_uint32(ndr, &_array_size));
if (r->count > _array_size) {
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should be %u", _array_size, r->count);
}
}
NDR_ALLOC_N_SIZE(ndr, r->s, r->count, sizeof(r->s[0]));
NDR_CHECK(ndr_pull_array(ndr, ndr_flags, (void **)r->s, sizeof(r->s[0]), r->count, (ndr_pull_flags_fn_t)ndr_pull_dfs_String));
}
done:
return NT_STATUS_OK;
}
static NTSTATUS ndr_pull_dfs_EnumInfo(struct ndr_pull *ndr, int ndr_flags, uint16 *level, union dfs_EnumInfo *r)
{
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_pull_uint16(ndr, level));
switch (*level) {
case 1: {
uint32 _ptr_enum1;
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_enum1));
if (_ptr_enum1) {
NDR_ALLOC(ndr, r->enum1);
} else {
r->enum1 = NULL;
}
break; }
default:
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", *level);
}
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
switch (*level) {
case 1:
if (r->enum1) {
NDR_CHECK(ndr_pull_dfs_Enum1(ndr, NDR_SCALARS|NDR_BUFFERS, r->enum1));
}
break;
default:
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", *level);
}
done:
return NT_STATUS_OK;
}
static NTSTATUS ndr_pull_dfs_EnumStruct(struct ndr_pull *ndr, int ndr_flags, struct dfs_EnumStruct *r)
{
NDR_CHECK(ndr_pull_align(ndr, 4));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_pull_uint32(ndr, &r->level));
{ uint16 _level;
NDR_CHECK(ndr_pull_dfs_EnumInfo(ndr, NDR_SCALARS, &_level, &r->e));
if (_level != r->level) return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u in e");
}
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
{ uint16 _level;
NDR_CHECK(ndr_pull_dfs_EnumInfo(ndr, NDR_BUFFERS, &_level, &r->e));
if (_level != r->level) return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u in e");
}
done:
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_dfs_Enum(struct ndr_pull *ndr, struct dfs_Enum *r)
{
NDR_CHECK(ndr_pull_uint32(ndr, r->out.resume_handle));
uint32 _ptr_info;
uint32 _ptr_total;
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_info));
if (_ptr_info) {
NDR_ALLOC(ndr, r->out.info);
} else {
r->out.info = NULL;
}
if (r->out.info) {
NDR_CHECK(ndr_pull_dfs_EnumStruct(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
}
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_total));
if (_ptr_total) {
NDR_ALLOC(ndr, r->out.total);
} else {
r->out.total = NULL;
}
if (r->out.total) {
NDR_CHECK(ndr_pull_uint32(ndr, r->out.total));
}
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
}
void ndr_print_dfs_String(struct ndr_print *ndr, const char *name, struct dfs_String *r)
{
ndr_print_struct(ndr, name, "dfs_String");
ndr->depth++;
ndr_print_ptr(ndr, "str", r->str);
ndr->depth++;
if (r->str) {
ndr_print_unistr(ndr, "str", r->str);
}
ndr->depth--;
ndr->depth--;
}
void ndr_print_dfs_Enum1(struct ndr_print *ndr, const char *name, struct dfs_Enum1 *r)
{
ndr_print_struct(ndr, name, "dfs_Enum1");
ndr->depth++;
ndr_print_uint32(ndr, "count", r->count);
ndr_print_ptr(ndr, "s", r->s);
ndr->depth++;
if (r->s) {
ndr_print_array(ndr, "s", r->s, sizeof(r->s[0]), r->count, (ndr_print_fn_t)ndr_print_dfs_String);
}
ndr->depth--;
ndr->depth--;
}
void ndr_print_dfs_EnumInfo(struct ndr_print *ndr, const char *name, uint16 level, union dfs_EnumInfo *r)
{
ndr_print_union(ndr, name, level, "dfs_EnumInfo");
switch (level) {
case 1:
ndr_print_ptr(ndr, "enum1", r->enum1);
ndr->depth++;
if (r->enum1) {
ndr_print_dfs_Enum1(ndr, "enum1", r->enum1);
}
ndr->depth--;
break;
default:
ndr_print_bad_level(ndr, name, level);
}
}
void ndr_print_dfs_EnumStruct(struct ndr_print *ndr, const char *name, struct dfs_EnumStruct *r)
{
ndr_print_struct(ndr, name, "dfs_EnumStruct");
ndr->depth++;
ndr_print_uint32(ndr, "level", r->level);
ndr_print_dfs_EnumInfo(ndr, "e", r->level, &r->e);
ndr->depth--;
}

28
source4/librpc/ndr/ndr_dfs.h
View File

@ -62,16 +62,36 @@ struct dfs_Info {
};
struct dfs_String {
const char *str;
};
struct dfs_Enum1 {
uint32 count;
struct dfs_String *s;
};
union dfs_EnumInfo {
/* [case(1)] */ struct dfs_Enum1 *enum1;
};
struct dfs_EnumStruct {
uint32 level;
union dfs_EnumInfo e;
};
struct dfs_Enum {
struct {
const char *name;
uint32 level;
uint32 buffer_size;
uint32 *resume_handle;
uint32 bufsize;
struct dfs_EnumStruct *info;
uint32 *unknown;
uint32 *total;
} in;
struct {
uint32 *resume_handle;
struct dfs_EnumStruct *info;
uint32 *total;
NTSTATUS result;
} out;

205
source4/librpc/ndr/ndr_echo.c
View File

@ -9,13 +9,6 @@ NTSTATUS ndr_push_echo_AddOne(struct ndr_push *ndr, struct echo_AddOne *r)
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_echo_AddOne(struct ndr_pull *ndr, struct echo_AddOne *r)
{
NDR_CHECK(ndr_pull_uint32(ndr, r->out.v));
return NT_STATUS_OK;
}
NTSTATUS ndr_push_echo_EchoData(struct ndr_push *ndr, struct echo_EchoData *r)
{
NDR_CHECK(ndr_push_uint32(ndr, r->in.len));
@ -27,6 +20,37 @@ NTSTATUS ndr_push_echo_EchoData(struct ndr_push *ndr, struct echo_EchoData *r)
return NT_STATUS_OK;
}
NTSTATUS ndr_push_echo_SinkData(struct ndr_push *ndr, struct echo_SinkData *r)
{
NDR_CHECK(ndr_push_uint32(ndr, r->in.len));
if (r->in.data) {
NDR_CHECK(ndr_push_uint32(ndr, r->in.len));
NDR_CHECK(ndr_push_array_uint8(ndr, r->in.data, r->in.len));
}
return NT_STATUS_OK;
}
NTSTATUS ndr_push_echo_SourceData(struct ndr_push *ndr, struct echo_SourceData *r)
{
NDR_CHECK(ndr_push_uint32(ndr, r->in.len));
return NT_STATUS_OK;
}
NTSTATUS ndr_push_TestCall(struct ndr_push *ndr, struct TestCall *r)
{
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_echo_AddOne(struct ndr_pull *ndr, struct echo_AddOne *r)
{
NDR_CHECK(ndr_pull_uint32(ndr, r->out.v));
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_echo_EchoData(struct ndr_pull *ndr, struct echo_EchoData *r)
{
if (r->out.out_data) {
@ -44,30 +68,12 @@ NTSTATUS ndr_pull_echo_EchoData(struct ndr_pull *ndr, struct echo_EchoData *r)
return NT_STATUS_OK;
}
NTSTATUS ndr_push_echo_SinkData(struct ndr_push *ndr, struct echo_SinkData *r)
{
NDR_CHECK(ndr_push_uint32(ndr, r->in.len));
if (r->in.data) {
NDR_CHECK(ndr_push_uint32(ndr, r->in.len));
NDR_CHECK(ndr_push_array_uint8(ndr, r->in.data, r->in.len));
}
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_echo_SinkData(struct ndr_pull *ndr, struct echo_SinkData *r)
{
return NT_STATUS_OK;
}
NTSTATUS ndr_push_echo_SourceData(struct ndr_push *ndr, struct echo_SourceData *r)
{
NDR_CHECK(ndr_push_uint32(ndr, r->in.len));
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_echo_SourceData(struct ndr_pull *ndr, struct echo_SourceData *r)
{
if (r->out.data) {
@ -84,43 +90,96 @@ NTSTATUS ndr_pull_echo_SourceData(struct ndr_pull *ndr, struct echo_SourceData *
return NT_STATUS_OK;
}
static NTSTATUS ndr_pull_Struct1(struct ndr_pull *ndr, int ndr_flags, struct Struct1 *r)
static NTSTATUS ndr_pull_echo_Enum1(struct ndr_pull *ndr, int ndr_flags, struct echo_Enum1 *r)
{
uint32 _conformant_size;
NDR_CHECK(ndr_pull_uint32(ndr, &_conformant_size));
uint32 _ptr_count;
NDR_CHECK(ndr_pull_align(ndr, 4));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_pull_uint32(ndr, &r->bar));
NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
NDR_CHECK(ndr_pull_uint32(ndr, &r->foo));
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_count));
if (_ptr_count) {
NDR_ALLOC(ndr, r->count);
} else {
r->count = NULL;
}
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
if (r->count > _conformant_size) {
return ndr_pull_error(ndr, NDR_ERR_CONFORMANT_SIZE, "Bad conformant size %u should be %u", _conformant_size, r->count);
if (r->count) {
NDR_CHECK(ndr_pull_uint32(ndr, r->count));
}
NDR_ALLOC_N_SIZE(ndr, r->s, _conformant_size, sizeof(r->s[0]));
NDR_CHECK(ndr_pull_array_uint32(ndr, r->s, r->count));
done:
return NT_STATUS_OK;
}
void ndr_print_Struct1(struct ndr_print *ndr, const char *name, struct Struct1 *r)
static NTSTATUS ndr_pull_echo_Enum3(struct ndr_pull *ndr, int ndr_flags, struct echo_Enum3 *r)
{
ndr_print_struct(ndr, name, "Struct1");
ndr->depth++;
ndr_print_uint32(ndr, "bar", r->bar);
ndr_print_uint32(ndr, "count", r->count);
ndr_print_uint32(ndr, "foo", r->foo);
ndr_print_ptr(ndr, "s", r->s);
ndr->depth++;
ndr_print_array_uint32(ndr, "s", r->s, r->count);
ndr->depth--;
ndr->depth--;
uint32 _ptr_count;
NDR_CHECK(ndr_pull_align(ndr, 4));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_count));
if (_ptr_count) {
NDR_ALLOC(ndr, r->count);
} else {
r->count = NULL;
}
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
if (r->count) {
NDR_CHECK(ndr_pull_uint32(ndr, r->count));
}
done:
return NT_STATUS_OK;
}
NTSTATUS ndr_push_TestCall(struct ndr_push *ndr, struct TestCall *r)
static NTSTATUS ndr_pull_echo_EnumInfo(struct ndr_pull *ndr, int ndr_flags, uint16 *level, union echo_EnumInfo *r)
{
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_pull_uint16(ndr, level));
switch (*level) {
case 1: {
NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_SCALARS, &r->enum1));
break; }
case 3: {
NDR_CHECK(ndr_pull_echo_Enum3(ndr, NDR_SCALARS, &r->enum3));
break; }
default:
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", *level);
}
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
switch (*level) {
case 1:
NDR_CHECK(ndr_pull_echo_Enum1(ndr, NDR_BUFFERS, &r->enum1));
break;
case 3:
NDR_CHECK(ndr_pull_echo_Enum3(ndr, NDR_BUFFERS, &r->enum3));
break;
default:
return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", *level);
}
done:
return NT_STATUS_OK;
}
static NTSTATUS ndr_pull_Struct1(struct ndr_pull *ndr, int ndr_flags, struct Struct1 *r)
{
NDR_CHECK(ndr_pull_align(ndr, 4));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_pull_uint32(ndr, &r->level));
{ uint16 _level;
NDR_CHECK(ndr_pull_echo_EnumInfo(ndr, NDR_SCALARS, &_level, &r->e));
if (_level != r->level) return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u in e");
}
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
{ uint16 _level;
NDR_CHECK(ndr_pull_echo_EnumInfo(ndr, NDR_BUFFERS, &_level, &r->e));
if (_level != r->level) return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u in e");
}
done:
return NT_STATUS_OK;
}
@ -140,3 +199,55 @@ NTSTATUS ndr_pull_TestCall(struct ndr_pull *ndr, struct TestCall *r)
return NT_STATUS_OK;
}
void ndr_print_echo_Enum1(struct ndr_print *ndr, const char *name, struct echo_Enum1 *r)
{
ndr_print_struct(ndr, name, "echo_Enum1");
ndr->depth++;
ndr_print_ptr(ndr, "count", r->count);
ndr->depth++;
if (r->count) {
ndr_print_uint32(ndr, "count", *r->count);
}
ndr->depth--;
ndr->depth--;
}
void ndr_print_echo_Enum3(struct ndr_print *ndr, const char *name, struct echo_Enum3 *r)
{
ndr_print_struct(ndr, name, "echo_Enum3");
ndr->depth++;
ndr_print_ptr(ndr, "count", r->count);
ndr->depth++;
if (r->count) {
ndr_print_uint32(ndr, "count", *r->count);
}
ndr->depth--;
ndr->depth--;
}
void ndr_print_echo_EnumInfo(struct ndr_print *ndr, const char *name, uint16 level, union echo_EnumInfo *r)
{
ndr_print_union(ndr, name, level, "echo_EnumInfo");
switch (level) {
case 1:
ndr_print_echo_Enum1(ndr, "enum1", &r->enum1);
break;
case 3:
ndr_print_echo_Enum3(ndr, "enum3", &r->enum3);
break;
default:
ndr_print_bad_level(ndr, name, level);
}
}
void ndr_print_Struct1(struct ndr_print *ndr, const char *name, struct Struct1 *r)
{
ndr_print_struct(ndr, name, "Struct1");
ndr->depth++;
ndr_print_uint32(ndr, "level", r->level);
ndr_print_echo_EnumInfo(ndr, "e", r->level, &r->e);
ndr->depth--;
}

21
source4/librpc/ndr/ndr_echo.h
View File

@ -45,11 +45,22 @@ struct echo_SourceData {
};
struct echo_Enum1 {
uint32 *count;
};
struct echo_Enum3 {
uint32 *count;
};
union echo_EnumInfo {
/* [case(1)] */ struct echo_Enum1 enum1;
/* [case(3)] */ struct echo_Enum3 enum3;
};
struct Struct1 {
uint32 bar;
uint32 count;
uint32 foo;
uint32 *s;
uint32 level;
union echo_EnumInfo e;
};
struct TestCall {
@ -57,7 +68,7 @@ struct TestCall {
} in;
struct {
struct Struct1 **s1;
struct Struct1 *s1;
} out;
};

2748
source4/librpc/ndr/ndr_lsa.c
View File

File diff suppressed because it is too large Load Diff

2
source4/librpc/rpc/dcerpc.c
View File

@ -780,6 +780,8 @@ NTSTATUS dcerpc_ndr_request(struct dcerpc_pipe *p,
/* retrieve the blob */
request = ndr_push_blob(push);
dump_data(10, request.data, request.length);
/* make the actual dcerpc request */
status = dcerpc_request(p, opnum, mem_ctx, &request, &response);
if (!NT_STATUS_IS_OK(status)) {

26
source4/torture/rpc/dfs.c
View File

@ -45,20 +45,34 @@ static BOOL test_Enum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
{
NTSTATUS status;
struct dfs_Enum r;
uint32 resume_handle = 0;
uint32 total=0;
struct dfs_EnumStruct e;
uint32 i = 0;
struct dfs_String s;
struct dfs_Enum1 e1;
e.level = 1;
e.e.enum1 = &e1;
e.e.enum1->count = 0;
e.e.enum1->s = &s;
s.str = NULL;
r.in.name = "";
r.in.level = 1;
r.in.buffer_size = 20000;
r.in.resume_handle = &resume_handle;
r.out.resume_handle = &resume_handle;
r.in.bufsize = (uint32)-1;
r.in.total = &total;
r.in.unknown = NULL;
r.in.info = &e;
status = dcerpc_dfs_Enum(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
printf("Enum failed - %s\n", nt_errstr(status));
return False;
}
NDR_PRINT_DEBUG(dfs_EnumStruct, r.out.info);
printf("total=%d\n", r.out.total?*r.out.total:-1);
return True;
}

5
source4/torture/rpc/echo.c
View File

@ -197,6 +197,11 @@ BOOL torture_rpc_echo(int dummy)
return False;
}
if (!test_testcall(p, mem_ctx)) {
ret = False;
}
return ret;
if (!test_addone(p, mem_ctx)) {
ret = False;
}