s3: re-run make samba3-idl.

Guenther

diff --git a/librpc/gen_ndr/cli_eventlog.c b/librpc/gen_ndr/cli_eventlog.c
index 2f4b9f21af92e5a9dbd7cc11297db45d16fe41c0..6b084d22171c9cb2870fbd92a1587b9af653296f 100644 (file)
--- a/librpc/gen_ndr/cli_eventlog.c
+++ b/librpc/gen_ndr/cli_eventlog.c
@@ -47,12 +47,16 @@ NTSTATUS rpccli_eventlog_ClearEventLogW(struct rpc_pipe_client *cli,
 }
 
 NTSTATUS rpccli_eventlog_BackupEventLogW(struct rpc_pipe_client *cli,
-                                        TALLOC_CTX *mem_ctx)
+                                        TALLOC_CTX *mem_ctx,
+                                        struct policy_handle *handle /* [in] [ref] */,
+                                        struct lsa_String *backup_filename /* [in] [ref] */)
 {
        struct eventlog_BackupEventLogW r;
        NTSTATUS status;
 
        /* In parameters */
+       r.in.handle = handle;
+       r.in.backup_filename = backup_filename;
 
        if (DEBUGLEVEL >= 10) {
                NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogW, &r);
@@ -122,12 +126,14 @@ NTSTATUS rpccli_eventlog_CloseEventLog(struct rpc_pipe_client *cli,
 }
 
 NTSTATUS rpccli_eventlog_DeregisterEventSource(struct rpc_pipe_client *cli,
-                                              TALLOC_CTX *mem_ctx)
+                                              TALLOC_CTX *mem_ctx,
+                                              struct policy_handle *handle /* [in,out] [ref] */)
 {
        struct eventlog_DeregisterEventSource r;
        NTSTATUS status;
 
        /* In parameters */
+       r.in.handle = handle;
 
        if (DEBUGLEVEL >= 10) {
                NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, &r);
@@ -152,6 +158,7 @@ NTSTATUS rpccli_eventlog_DeregisterEventSource(struct rpc_pipe_client *cli,
        }
 
        /* Return variables */
+       *handle = *r.out.handle;
 
        /* Return result */
        return r.out.result;
@@ -322,12 +329,23 @@ NTSTATUS rpccli_eventlog_OpenEventLogW(struct rpc_pipe_client *cli,
 }
 
 NTSTATUS rpccli_eventlog_RegisterEventSourceW(struct rpc_pipe_client *cli,
-                                             TALLOC_CTX *mem_ctx)
+                                             TALLOC_CTX *mem_ctx,
+                                             struct eventlog_OpenUnknown0 *unknown0 /* [in] [unique] */,
+                                             struct lsa_String *module_name /* [in] [ref] */,
+                                             struct lsa_String *reg_module_name /* [in] [ref] */,
+                                             uint32_t major_version /* [in]  */,
+                                             uint32_t minor_version /* [in]  */,
+                                             struct policy_handle *log_handle /* [out] [ref] */)
 {
        struct eventlog_RegisterEventSourceW r;
        NTSTATUS status;
 
        /* In parameters */
+       r.in.unknown0 = unknown0;
+       r.in.module_name = module_name;
+       r.in.reg_module_name = reg_module_name;
+       r.in.major_version = major_version;
+       r.in.minor_version = minor_version;
 
        if (DEBUGLEVEL >= 10) {
                NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, &r);
@@ -352,18 +370,28 @@ NTSTATUS rpccli_eventlog_RegisterEventSourceW(struct rpc_pipe_client *cli,
        }
 
        /* Return variables */
+       *log_handle = *r.out.log_handle;
 
        /* Return result */
        return r.out.result;
 }
 
 NTSTATUS rpccli_eventlog_OpenBackupEventLogW(struct rpc_pipe_client *cli,
-                                            TALLOC_CTX *mem_ctx)
+                                            TALLOC_CTX *mem_ctx,
+                                            struct eventlog_OpenUnknown0 *unknown0 /* [in] [unique] */,
+                                            struct lsa_String *backup_logname /* [in] [ref] */,
+                                            uint32_t major_version /* [in]  */,
+                                            uint32_t minor_version /* [in]  */,
+                                            struct policy_handle *handle /* [out] [ref] */)
 {
        struct eventlog_OpenBackupEventLogW r;
        NTSTATUS status;
 
        /* In parameters */
+       r.in.unknown0 = unknown0;
+       r.in.backup_logname = backup_logname;
+       r.in.major_version = major_version;
+       r.in.minor_version = minor_version;
 
        if (DEBUGLEVEL >= 10) {
                NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, &r);
@@ -388,6 +416,7 @@ NTSTATUS rpccli_eventlog_OpenBackupEventLogW(struct rpc_pipe_client *cli,
        }
 
        /* Return variables */
+       *handle = *r.out.handle;
 
        /* Return result */
        return r.out.result;
@@ -444,12 +473,40 @@ NTSTATUS rpccli_eventlog_ReadEventLogW(struct rpc_pipe_client *cli,
 }
 
 NTSTATUS rpccli_eventlog_ReportEventW(struct rpc_pipe_client *cli,
-                                     TALLOC_CTX *mem_ctx)
+                                     TALLOC_CTX *mem_ctx,
+                                     struct policy_handle *handle /* [in] [ref] */,
+                                     time_t timestamp /* [in]  */,
+                                     enum eventlogEventTypes event_type /* [in]  */,
+                                     uint16_t event_category /* [in]  */,
+                                     uint32_t event_id /* [in]  */,
+                                     uint16_t num_of_strings /* [in] [range(0,256)] */,
+                                     uint32_t data_size /* [in] [range(0,0x3FFFF)] */,
+                                     struct lsa_String *servername /* [in] [ref] */,
+                                     struct dom_sid *user_sid /* [in] [unique] */,
+                                     struct lsa_String **strings /* [in] [unique,size_is(num_of_strings)] */,
+                                     uint8_t *data /* [in] [unique,size_is(data_size)] */,
+                                     uint16_t flags /* [in]  */,
+                                     uint32_t *record_number /* [in,out] [unique] */,
+                                     time_t *time_written /* [in,out] [unique] */)
 {
        struct eventlog_ReportEventW r;
        NTSTATUS status;
 
        /* In parameters */
+       r.in.handle = handle;
+       r.in.timestamp = timestamp;
+       r.in.event_type = event_type;
+       r.in.event_category = event_category;
+       r.in.event_id = event_id;
+       r.in.num_of_strings = num_of_strings;
+       r.in.data_size = data_size;
+       r.in.servername = servername;
+       r.in.user_sid = user_sid;
+       r.in.strings = strings;
+       r.in.data = data;
+       r.in.flags = flags;
+       r.in.record_number = record_number;
+       r.in.time_written = time_written;
 
        if (DEBUGLEVEL >= 10) {
                NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, &r);
@@ -474,6 +531,12 @@ NTSTATUS rpccli_eventlog_ReportEventW(struct rpc_pipe_client *cli,
        }
 
        /* Return variables */
+       if (record_number && r.out.record_number) {
+               *record_number = *r.out.record_number;
+       }
+       if (time_written && r.out.time_written) {
+               *time_written = *r.out.time_written;
+       }
 
        /* Return result */
        return r.out.result;
@@ -840,12 +903,20 @@ NTSTATUS rpccli_eventlog_WriteClusterEvents(struct rpc_pipe_client *cli,
 }
 
 NTSTATUS rpccli_eventlog_GetLogIntormation(struct rpc_pipe_client *cli,
-                                          TALLOC_CTX *mem_ctx)
+                                          TALLOC_CTX *mem_ctx,
+                                          struct policy_handle *handle /* [in] [ref] */,
+                                          uint32_t level /* [in]  */,
+                                          uint8_t *buffer /* [out] [ref,size_is(buf_size)] */,
+                                          uint32_t buf_size /* [in] [range(0,1024)] */,
+                                          uint32_t *bytes_needed /* [out] [ref] */)
 {
        struct eventlog_GetLogIntormation r;
        NTSTATUS status;
 
        /* In parameters */
+       r.in.handle = handle;
+       r.in.level = level;
+       r.in.buf_size = buf_size;
 
        if (DEBUGLEVEL >= 10) {
                NDR_PRINT_IN_DEBUG(eventlog_GetLogIntormation, &r);
@@ -870,6 +941,8 @@ NTSTATUS rpccli_eventlog_GetLogIntormation(struct rpc_pipe_client *cli,
        }
 
        /* Return variables */
+       memcpy(buffer, r.out.buffer, r.in.buf_size * sizeof(*buffer));
+       *bytes_needed = *r.out.bytes_needed;
 
        /* Return result */
        return r.out.result;
@@ -913,3 +986,75 @@ NTSTATUS rpccli_eventlog_FlushEventLog(struct rpc_pipe_client *cli,
        return r.out.result;
 }
 
+NTSTATUS rpccli_eventlog_ReportEventAndSourceW(struct rpc_pipe_client *cli,
+                                              TALLOC_CTX *mem_ctx,
+                                              struct policy_handle *handle /* [in] [ref] */,
+                                              time_t timestamp /* [in]  */,
+                                              enum eventlogEventTypes event_type /* [in]  */,
+                                              uint16_t event_category /* [in]  */,
+                                              uint32_t event_id /* [in]  */,
+                                              struct lsa_String *sourcename /* [in] [ref] */,
+                                              uint16_t num_of_strings /* [in] [range(0,256)] */,
+                                              uint32_t data_size /* [in] [range(0,0x3FFFF)] */,
+                                              struct lsa_String *servername /* [in] [ref] */,
+                                              struct dom_sid *user_sid /* [in] [unique] */,
+                                              struct lsa_String **strings /* [in] [unique,size_is(num_of_strings)] */,
+                                              uint8_t *data /* [in] [unique,size_is(data_size)] */,
+                                              uint16_t flags /* [in]  */,
+                                              uint32_t *record_number /* [in,out] [unique] */,
+                                              time_t *time_written /* [in,out] [unique] */)
+{
+       struct eventlog_ReportEventAndSourceW r;
+       NTSTATUS status;
+
+       /* In parameters */
+       r.in.handle = handle;
+       r.in.timestamp = timestamp;
+       r.in.event_type = event_type;
+       r.in.event_category = event_category;
+       r.in.event_id = event_id;
+       r.in.sourcename = sourcename;
+       r.in.num_of_strings = num_of_strings;
+       r.in.data_size = data_size;
+       r.in.servername = servername;
+       r.in.user_sid = user_sid;
+       r.in.strings = strings;
+       r.in.data = data;
+       r.in.flags = flags;
+       r.in.record_number = record_number;
+       r.in.time_written = time_written;
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(eventlog_ReportEventAndSourceW, &r);
+       }
+
+       status = cli->dispatch(cli,
+                               mem_ctx,
+                               &ndr_table_eventlog,
+                               NDR_EVENTLOG_REPORTEVENTANDSOURCEW,
+                               &r);
+
+       if (!NT_STATUS_IS_OK(status)) {
+               return status;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(eventlog_ReportEventAndSourceW, &r);
+       }
+
+       if (NT_STATUS_IS_ERR(status)) {
+               return status;
+       }
+
+       /* Return variables */
+       if (record_number && r.out.record_number) {
+               *record_number = *r.out.record_number;
+       }
+       if (time_written && r.out.time_written) {
+               *time_written = *r.out.time_written;
+       }
+
+       /* Return result */
+       return r.out.result;
+}
+

diff --git a/librpc/gen_ndr/cli_eventlog.h b/librpc/gen_ndr/cli_eventlog.h
index a1360cbc1651cc5aa02e41db73804dcea72fec2d..ae5544daf3aaeae7c622ed7e37de3efcee4775fc 100644 (file)
--- a/librpc/gen_ndr/cli_eventlog.h
+++ b/librpc/gen_ndr/cli_eventlog.h
@@ -6,12 +6,15 @@ NTSTATUS rpccli_eventlog_ClearEventLogW(struct rpc_pipe_client *cli,
                                        struct policy_handle *handle /* [in] [ref] */,
                                        struct lsa_String *backupfile /* [in] [unique] */);
 NTSTATUS rpccli_eventlog_BackupEventLogW(struct rpc_pipe_client *cli,
-                                        TALLOC_CTX *mem_ctx);
+                                        TALLOC_CTX *mem_ctx,
+                                        struct policy_handle *handle /* [in] [ref] */,
+                                        struct lsa_String *backup_filename /* [in] [ref] */);
 NTSTATUS rpccli_eventlog_CloseEventLog(struct rpc_pipe_client *cli,
                                       TALLOC_CTX *mem_ctx,
                                       struct policy_handle *handle /* [in,out] [ref] */);
 NTSTATUS rpccli_eventlog_DeregisterEventSource(struct rpc_pipe_client *cli,
-                                              TALLOC_CTX *mem_ctx);
+                                              TALLOC_CTX *mem_ctx,
+                                              struct policy_handle *handle /* [in,out] [ref] */);
 NTSTATUS rpccli_eventlog_GetNumRecords(struct rpc_pipe_client *cli,
                                       TALLOC_CTX *mem_ctx,
                                       struct policy_handle *handle /* [in] [ref] */,
@@ -31,9 +34,20 @@ NTSTATUS rpccli_eventlog_OpenEventLogW(struct rpc_pipe_client *cli,
                                       uint32_t minor_version /* [in]  */,
                                       struct policy_handle *handle /* [out] [ref] */);
 NTSTATUS rpccli_eventlog_RegisterEventSourceW(struct rpc_pipe_client *cli,
-                                             TALLOC_CTX *mem_ctx);
+                                             TALLOC_CTX *mem_ctx,
+                                             struct eventlog_OpenUnknown0 *unknown0 /* [in] [unique] */,
+                                             struct lsa_String *module_name /* [in] [ref] */,
+                                             struct lsa_String *reg_module_name /* [in] [ref] */,
+                                             uint32_t major_version /* [in]  */,
+                                             uint32_t minor_version /* [in]  */,
+                                             struct policy_handle *log_handle /* [out] [ref] */);
 NTSTATUS rpccli_eventlog_OpenBackupEventLogW(struct rpc_pipe_client *cli,
-                                            TALLOC_CTX *mem_ctx);
+                                            TALLOC_CTX *mem_ctx,
+                                            struct eventlog_OpenUnknown0 *unknown0 /* [in] [unique] */,
+                                            struct lsa_String *backup_logname /* [in] [ref] */,
+                                            uint32_t major_version /* [in]  */,
+                                            uint32_t minor_version /* [in]  */,
+                                            struct policy_handle *handle /* [out] [ref] */);
 NTSTATUS rpccli_eventlog_ReadEventLogW(struct rpc_pipe_client *cli,
                                       TALLOC_CTX *mem_ctx,
                                       struct policy_handle *handle /* [in] [ref] */,
@@ -44,7 +58,21 @@ NTSTATUS rpccli_eventlog_ReadEventLogW(struct rpc_pipe_client *cli,
                                       uint32_t *sent_size /* [out] [ref] */,
                                       uint32_t *real_size /* [out] [ref] */);
 NTSTATUS rpccli_eventlog_ReportEventW(struct rpc_pipe_client *cli,
-                                     TALLOC_CTX *mem_ctx);
+                                     TALLOC_CTX *mem_ctx,
+                                     struct policy_handle *handle /* [in] [ref] */,
+                                     time_t timestamp /* [in]  */,
+                                     enum eventlogEventTypes event_type /* [in]  */,
+                                     uint16_t event_category /* [in]  */,
+                                     uint32_t event_id /* [in]  */,
+                                     uint16_t num_of_strings /* [in] [range(0,256)] */,
+                                     uint32_t data_size /* [in] [range(0,0x3FFFF)] */,
+                                     struct lsa_String *servername /* [in] [ref] */,
+                                     struct dom_sid *user_sid /* [in] [unique] */,
+                                     struct lsa_String **strings /* [in] [unique,size_is(num_of_strings)] */,
+                                     uint8_t *data /* [in] [unique,size_is(data_size)] */,
+                                     uint16_t flags /* [in]  */,
+                                     uint32_t *record_number /* [in,out] [unique] */,
+                                     time_t *time_written /* [in,out] [unique] */);
 NTSTATUS rpccli_eventlog_ClearEventLogA(struct rpc_pipe_client *cli,
                                        TALLOC_CTX *mem_ctx);
 NTSTATUS rpccli_eventlog_BackupEventLogA(struct rpc_pipe_client *cli,
@@ -66,8 +94,30 @@ NTSTATUS rpccli_eventlog_DeregisterClusterSvc(struct rpc_pipe_client *cli,
 NTSTATUS rpccli_eventlog_WriteClusterEvents(struct rpc_pipe_client *cli,
                                            TALLOC_CTX *mem_ctx);
 NTSTATUS rpccli_eventlog_GetLogIntormation(struct rpc_pipe_client *cli,
-                                          TALLOC_CTX *mem_ctx);
+                                          TALLOC_CTX *mem_ctx,
+                                          struct policy_handle *handle /* [in] [ref] */,
+                                          uint32_t level /* [in]  */,
+                                          uint8_t *buffer /* [out] [ref,size_is(buf_size)] */,
+                                          uint32_t buf_size /* [in] [range(0,1024)] */,
+                                          uint32_t *bytes_needed /* [out] [ref] */);
 NTSTATUS rpccli_eventlog_FlushEventLog(struct rpc_pipe_client *cli,
                                       TALLOC_CTX *mem_ctx,
                                       struct policy_handle *handle /* [in] [ref] */);
+NTSTATUS rpccli_eventlog_ReportEventAndSourceW(struct rpc_pipe_client *cli,
+                                              TALLOC_CTX *mem_ctx,
+                                              struct policy_handle *handle /* [in] [ref] */,
+                                              time_t timestamp /* [in]  */,
+                                              enum eventlogEventTypes event_type /* [in]  */,
+                                              uint16_t event_category /* [in]  */,
+                                              uint32_t event_id /* [in]  */,
+                                              struct lsa_String *sourcename /* [in] [ref] */,
+                                              uint16_t num_of_strings /* [in] [range(0,256)] */,
+                                              uint32_t data_size /* [in] [range(0,0x3FFFF)] */,
+                                              struct lsa_String *servername /* [in] [ref] */,
+                                              struct dom_sid *user_sid /* [in] [unique] */,
+                                              struct lsa_String **strings /* [in] [unique,size_is(num_of_strings)] */,
+                                              uint8_t *data /* [in] [unique,size_is(data_size)] */,
+                                              uint16_t flags /* [in]  */,
+                                              uint32_t *record_number /* [in,out] [unique] */,
+                                              time_t *time_written /* [in,out] [unique] */);
 #endif /* __CLI_EVENTLOG__ */

diff --git a/librpc/gen_ndr/eventlog.h b/librpc/gen_ndr/eventlog.h
index 9c9a2ed2185812a0f22d58a361f4d566ed525699..8dc0d0d14621d6baa9a1203a18955441625f3fef 100644 (file)
--- a/librpc/gen_ndr/eventlog.h
+++ b/librpc/gen_ndr/eventlog.h
@@ -65,6 +65,10 @@ struct eventlog_Record {
        uint32_t size2;/* [value(size)] */
 }/* [public,flag(LIBNDR_FLAG_NOALIGN)] */;
 
+struct EVENTLOG_FULL_INFORMATION {
+       uint32_t full;
+};
+
 
 struct eventlog_ClearEventLogW {
        struct {
@@ -80,6 +84,11 @@ struct eventlog_ClearEventLogW {
 
 
 struct eventlog_BackupEventLogW {
+       struct {
+               struct policy_handle *handle;/* [ref] */
+               struct lsa_String *backup_filename;/* [ref] */
+       } in;
+
        struct {
                NTSTATUS result;
        } out;
@@ -102,6 +111,11 @@ struct eventlog_CloseEventLog {
 
 struct eventlog_DeregisterEventSource {
        struct {
+               struct policy_handle *handle;/* [ref] */
+       } in;
+
+       struct {
+               struct policy_handle *handle;/* [ref] */
                NTSTATUS result;
        } out;
 
@@ -161,6 +175,15 @@ struct eventlog_OpenEventLogW {
 
 struct eventlog_RegisterEventSourceW {
        struct {
+               struct eventlog_OpenUnknown0 *unknown0;/* [unique] */
+               struct lsa_String *module_name;/* [ref] */
+               struct lsa_String *reg_module_name;/* [ref] */
+               uint32_t major_version;
+               uint32_t minor_version;
+       } in;
+
+       struct {
+               struct policy_handle *log_handle;/* [ref] */
                NTSTATUS result;
        } out;
 
@@ -169,6 +192,14 @@ struct eventlog_RegisterEventSourceW {
 
 struct eventlog_OpenBackupEventLogW {
        struct {
+               struct eventlog_OpenUnknown0 *unknown0;/* [unique] */
+               struct lsa_String *backup_logname;/* [ref] */
+               uint32_t major_version;
+               uint32_t minor_version;
+       } in;
+
+       struct {
+               struct policy_handle *handle;/* [ref] */
                NTSTATUS result;
        } out;
 
@@ -195,6 +226,25 @@ struct eventlog_ReadEventLogW {
 
 struct eventlog_ReportEventW {
        struct {
+               struct policy_handle *handle;/* [ref] */
+               time_t timestamp;
+               enum eventlogEventTypes event_type;
+               uint16_t event_category;
+               uint32_t event_id;
+               uint16_t num_of_strings;/* [range(0,256)] */
+               uint32_t data_size;/* [range(0,0x3FFFF)] */
+               struct lsa_String *servername;/* [ref] */
+               struct dom_sid *user_sid;/* [unique] */
+               struct lsa_String **strings;/* [unique,size_is(num_of_strings)] */
+               uint8_t *data;/* [unique,size_is(data_size)] */
+               uint16_t flags;
+               uint32_t *record_number;/* [unique] */
+               time_t *time_written;/* [unique] */
+       } in;
+
+       struct {
+               uint32_t *record_number;/* [unique] */
+               time_t *time_written;/* [unique] */
                NTSTATUS result;
        } out;
 
@@ -283,6 +333,14 @@ struct eventlog_WriteClusterEvents {
 
 struct eventlog_GetLogIntormation {
        struct {
+               struct policy_handle *handle;/* [ref] */
+               uint32_t level;
+               uint32_t buf_size;/* [range(0,1024)] */
+       } in;
+
+       struct {
+               uint8_t *buffer;/* [ref,size_is(buf_size)] */
+               uint32_t *bytes_needed;/* [ref] */
                NTSTATUS result;
        } out;
 
@@ -300,4 +358,32 @@ struct eventlog_FlushEventLog {
 
 };
 
+
+struct eventlog_ReportEventAndSourceW {
+       struct {
+               struct policy_handle *handle;/* [ref] */
+               time_t timestamp;
+               enum eventlogEventTypes event_type;
+               uint16_t event_category;
+               uint32_t event_id;
+               struct lsa_String *sourcename;/* [ref] */
+               uint16_t num_of_strings;/* [range(0,256)] */
+               uint32_t data_size;/* [range(0,0x3FFFF)] */
+               struct lsa_String *servername;/* [ref] */
+               struct dom_sid *user_sid;/* [unique] */
+               struct lsa_String **strings;/* [unique,size_is(num_of_strings)] */
+               uint8_t *data;/* [unique,size_is(data_size)] */
+               uint16_t flags;
+               uint32_t *record_number;/* [unique] */
+               time_t *time_written;/* [unique] */
+       } in;
+
+       struct {
+               uint32_t *record_number;/* [unique] */
+               time_t *time_written;/* [unique] */
+               NTSTATUS result;
+       } out;
+
+};
+
 #endif /* _HEADER_eventlog */

diff --git a/librpc/gen_ndr/ndr_eventlog.c b/librpc/gen_ndr/ndr_eventlog.c
index ddc93f910b208f086922396fe5adef85c4dcc6c4..938f0db8eb06b00f9eb542d19c2fa31cbdd83725 100644 (file)
--- a/librpc/gen_ndr/ndr_eventlog.c
+++ b/librpc/gen_ndr/ndr_eventlog.c
@@ -371,6 +371,14 @@ _PUBLIC_ void ndr_print_eventlog_ClearEventLogW(struct ndr_print *ndr, const cha
 static enum ndr_err_code ndr_push_eventlog_BackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_BackupEventLogW *r)
 {
        if (flags & NDR_IN) {
+               if (r->in.handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
+               if (r->in.backup_filename == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_filename));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
@@ -380,7 +388,23 @@ static enum ndr_err_code ndr_push_eventlog_BackupEventLogW(struct ndr_push *ndr,
 
 static enum ndr_err_code ndr_pull_eventlog_BackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_BackupEventLogW *r)
 {
+       TALLOC_CTX *_mem_save_handle_0;
+       TALLOC_CTX *_mem_save_backup_filename_0;
        if (flags & NDR_IN) {
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.handle);
+               }
+               _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.backup_filename);
+               }
+               _mem_save_backup_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.backup_filename, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_filename));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backup_filename_0, LIBNDR_FLAG_REF_ALLOC);
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
@@ -398,6 +422,14 @@ _PUBLIC_ void ndr_print_eventlog_BackupEventLogW(struct ndr_print *ndr, const ch
        if (flags & NDR_IN) {
                ndr_print_struct(ndr, "in", "eventlog_BackupEventLogW");
                ndr->depth++;
+               ndr_print_ptr(ndr, "handle", r->in.handle);
+               ndr->depth++;
+               ndr_print_policy_handle(ndr, "handle", r->in.handle);
+               ndr->depth--;
+               ndr_print_ptr(ndr, "backup_filename", r->in.backup_filename);
+               ndr->depth++;
+               ndr_print_lsa_String(ndr, "backup_filename", r->in.backup_filename);
+               ndr->depth--;
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -488,8 +520,16 @@ _PUBLIC_ void ndr_print_eventlog_CloseEventLog(struct ndr_print *ndr, const char
 static enum ndr_err_code ndr_push_eventlog_DeregisterEventSource(struct ndr_push *ndr, int flags, const struct eventlog_DeregisterEventSource *r)
 {
        if (flags & NDR_IN) {
+               if (r->in.handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
        }
        if (flags & NDR_OUT) {
+               if (r->out.handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -497,9 +537,28 @@ static enum ndr_err_code ndr_push_eventlog_DeregisterEventSource(struct ndr_push
 
 static enum ndr_err_code ndr_pull_eventlog_DeregisterEventSource(struct ndr_pull *ndr, int flags, struct eventlog_DeregisterEventSource *r)
 {
+       TALLOC_CTX *_mem_save_handle_0;
        if (flags & NDR_IN) {
+               ZERO_STRUCT(r->out);
+
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.handle);
+               }
+               _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_PULL_ALLOC(ndr, r->out.handle);
+               *r->out.handle = *r->in.handle;
        }
        if (flags & NDR_OUT) {
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->out.handle);
+               }
+               _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -515,11 +574,19 @@ _PUBLIC_ void ndr_print_eventlog_DeregisterEventSource(struct ndr_print *ndr, co
        if (flags & NDR_IN) {
                ndr_print_struct(ndr, "in", "eventlog_DeregisterEventSource");
                ndr->depth++;
+               ndr_print_ptr(ndr, "handle", r->in.handle);
+               ndr->depth++;
+               ndr_print_policy_handle(ndr, "handle", r->in.handle);
+               ndr->depth--;
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
                ndr_print_struct(ndr, "out", "eventlog_DeregisterEventSource");
                ndr->depth++;
+               ndr_print_ptr(ndr, "handle", r->out.handle);
+               ndr->depth++;
+               ndr_print_policy_handle(ndr, "handle", r->out.handle);
+               ndr->depth--;
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
                ndr->depth--;
        }
@@ -847,8 +914,26 @@ _PUBLIC_ void ndr_print_eventlog_OpenEventLogW(struct ndr_print *ndr, const char
 static enum ndr_err_code ndr_push_eventlog_RegisterEventSourceW(struct ndr_push *ndr, int flags, const struct eventlog_RegisterEventSourceW *r)
 {
        if (flags & NDR_IN) {
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));
+               if (r->in.unknown0) {
+                       NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
+               }
+               if (r->in.module_name == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.module_name));
+               if (r->in.reg_module_name == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.reg_module_name));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));
        }
        if (flags & NDR_OUT) {
+               if (r->out.log_handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.log_handle));
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -856,9 +941,53 @@ static enum ndr_err_code ndr_push_eventlog_RegisterEventSourceW(struct ndr_push
 
 static enum ndr_err_code ndr_pull_eventlog_RegisterEventSourceW(struct ndr_pull *ndr, int flags, struct eventlog_RegisterEventSourceW *r)
 {
+       uint32_t _ptr_unknown0;
+       TALLOC_CTX *_mem_save_unknown0_0;
+       TALLOC_CTX *_mem_save_module_name_0;
+       TALLOC_CTX *_mem_save_reg_module_name_0;
+       TALLOC_CTX *_mem_save_log_handle_0;
        if (flags & NDR_IN) {
+               ZERO_STRUCT(r->out);
+
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));
+               if (_ptr_unknown0) {
+                       NDR_PULL_ALLOC(ndr, r->in.unknown0);
+               } else {
+                       r->in.unknown0 = NULL;
+               }
+               if (r->in.unknown0) {
+                       _mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);
+                       NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);
+               }
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.module_name);
+               }
+               _mem_save_module_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.module_name, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.module_name));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_module_name_0, LIBNDR_FLAG_REF_ALLOC);
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.reg_module_name);
+               }
+               _mem_save_reg_module_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.reg_module_name, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.reg_module_name));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reg_module_name_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));
+               NDR_PULL_ALLOC(ndr, r->out.log_handle);
+               ZERO_STRUCTP(r->out.log_handle);
        }
        if (flags & NDR_OUT) {
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->out.log_handle);
+               }
+               _mem_save_log_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.log_handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.log_handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_log_handle_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -874,11 +1003,31 @@ _PUBLIC_ void ndr_print_eventlog_RegisterEventSourceW(struct ndr_print *ndr, con
        if (flags & NDR_IN) {
                ndr_print_struct(ndr, "in", "eventlog_RegisterEventSourceW");
                ndr->depth++;
+               ndr_print_ptr(ndr, "unknown0", r->in.unknown0);
+               ndr->depth++;
+               if (r->in.unknown0) {
+                       ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "module_name", r->in.module_name);
+               ndr->depth++;
+               ndr_print_lsa_String(ndr, "module_name", r->in.module_name);
+               ndr->depth--;
+               ndr_print_ptr(ndr, "reg_module_name", r->in.reg_module_name);
+               ndr->depth++;
+               ndr_print_lsa_String(ndr, "reg_module_name", r->in.reg_module_name);
+               ndr->depth--;
+               ndr_print_uint32(ndr, "major_version", r->in.major_version);
+               ndr_print_uint32(ndr, "minor_version", r->in.minor_version);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
                ndr_print_struct(ndr, "out", "eventlog_RegisterEventSourceW");
                ndr->depth++;
+               ndr_print_ptr(ndr, "log_handle", r->out.log_handle);
+               ndr->depth++;
+               ndr_print_policy_handle(ndr, "log_handle", r->out.log_handle);
+               ndr->depth--;
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
                ndr->depth--;
        }
@@ -888,8 +1037,22 @@ _PUBLIC_ void ndr_print_eventlog_RegisterEventSourceW(struct ndr_print *ndr, con
 static enum ndr_err_code ndr_push_eventlog_OpenBackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_OpenBackupEventLogW *r)
 {
        if (flags & NDR_IN) {
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));
+               if (r->in.unknown0) {
+                       NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
+               }
+               if (r->in.backup_logname == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_logname));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));
        }
        if (flags & NDR_OUT) {
+               if (r->out.handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -897,9 +1060,45 @@ static enum ndr_err_code ndr_push_eventlog_OpenBackupEventLogW(struct ndr_push *
 
 static enum ndr_err_code ndr_pull_eventlog_OpenBackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_OpenBackupEventLogW *r)
 {
+       uint32_t _ptr_unknown0;
+       TALLOC_CTX *_mem_save_unknown0_0;
+       TALLOC_CTX *_mem_save_backup_logname_0;
+       TALLOC_CTX *_mem_save_handle_0;
        if (flags & NDR_IN) {
+               ZERO_STRUCT(r->out);
+
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));
+               if (_ptr_unknown0) {
+                       NDR_PULL_ALLOC(ndr, r->in.unknown0);
+               } else {
+                       r->in.unknown0 = NULL;
+               }
+               if (r->in.unknown0) {
+                       _mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);
+                       NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);
+               }
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.backup_logname);
+               }
+               _mem_save_backup_logname_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.backup_logname, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_logname));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backup_logname_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));
+               NDR_PULL_ALLOC(ndr, r->out.handle);
+               ZERO_STRUCTP(r->out.handle);
        }
        if (flags & NDR_OUT) {
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->out.handle);
+               }
+               _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -915,11 +1114,27 @@ _PUBLIC_ void ndr_print_eventlog_OpenBackupEventLogW(struct ndr_print *ndr, cons
        if (flags & NDR_IN) {
                ndr_print_struct(ndr, "in", "eventlog_OpenBackupEventLogW");
                ndr->depth++;
+               ndr_print_ptr(ndr, "unknown0", r->in.unknown0);
+               ndr->depth++;
+               if (r->in.unknown0) {
+                       ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "backup_logname", r->in.backup_logname);
+               ndr->depth++;
+               ndr_print_lsa_String(ndr, "backup_logname", r->in.backup_logname);
+               ndr->depth--;
+               ndr_print_uint32(ndr, "major_version", r->in.major_version);
+               ndr_print_uint32(ndr, "minor_version", r->in.minor_version);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
                ndr_print_struct(ndr, "out", "eventlog_OpenBackupEventLogW");
                ndr->depth++;
+               ndr_print_ptr(ndr, "handle", r->out.handle);
+               ndr->depth++;
+               ndr_print_policy_handle(ndr, "handle", r->out.handle);
+               ndr->depth--;
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
                ndr->depth--;
        }
@@ -1054,9 +1269,62 @@ _PUBLIC_ void ndr_print_eventlog_ReadEventLogW(struct ndr_print *ndr, const char
 
 static enum ndr_err_code ndr_push_eventlog_ReportEventW(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventW *r)
 {
+       uint32_t cntr_strings_1;
        if (flags & NDR_IN) {
+               if (r->in.handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
+               NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->in.timestamp));
+               NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->in.event_type));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.event_category));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.event_id));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.num_of_strings));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
+               if (r->in.servername == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user_sid));
+               if (r->in.user_sid) {
+                       NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
+               }
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings));
+               if (r->in.strings) {
+                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_of_strings));
+                       for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
+                       }
+                       for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
+                               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings[cntr_strings_1]));
+                               if (r->in.strings[cntr_strings_1]) {
+                                       NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
+                               }
+                       }
+               }
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
+               if (r->in.data) {
+                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
+                       NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_size));
+               }
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.flags));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.record_number));
+               if (r->in.record_number) {
+                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.record_number));
+               }
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.time_written));
+               if (r->in.time_written) {
+                       NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->in.time_written));
+               }
        }
        if (flags & NDR_OUT) {
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.record_number));
+               if (r->out.record_number) {
+                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.record_number));
+               }
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.time_written));
+               if (r->out.time_written) {
+                       NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->out.time_written));
+               }
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -1064,9 +1332,165 @@ static enum ndr_err_code ndr_push_eventlog_ReportEventW(struct ndr_push *ndr, in
 
 static enum ndr_err_code ndr_pull_eventlog_ReportEventW(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventW *r)
 {
+       uint32_t _ptr_user_sid;
+       uint32_t _ptr_strings;
+       uint32_t cntr_strings_1;
+       uint32_t _ptr_data;
+       uint32_t _ptr_record_number;
+       uint32_t _ptr_time_written;
+       TALLOC_CTX *_mem_save_handle_0;
+       TALLOC_CTX *_mem_save_servername_0;
+       TALLOC_CTX *_mem_save_user_sid_0;
+       TALLOC_CTX *_mem_save_strings_0;
+       TALLOC_CTX *_mem_save_strings_1;
+       TALLOC_CTX *_mem_save_strings_2;
+       TALLOC_CTX *_mem_save_data_0;
+       TALLOC_CTX *_mem_save_record_number_0;
+       TALLOC_CTX *_mem_save_time_written_0;
        if (flags & NDR_IN) {
+               ZERO_STRUCT(r->out);
+
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.handle);
+               }
+               _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->in.timestamp));
+               NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->in.event_type));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.event_category));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.event_id));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.num_of_strings));
+               if (r->in.num_of_strings > 256) {
+                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
+               }
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
+               if (r->in.data_size > 0x3FFFF) {
+                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
+               }
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.servername);
+               }
+               _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));
+               if (_ptr_user_sid) {
+                       NDR_PULL_ALLOC(ndr, r->in.user_sid);
+               } else {
+                       r->in.user_sid = NULL;
+               }
+               if (r->in.user_sid) {
+                       _mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.user_sid, 0);
+                       NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
+               if (_ptr_strings) {
+                       NDR_PULL_ALLOC(ndr, r->in.strings);
+               } else {
+                       r->in.strings = NULL;
+               }
+               if (r->in.strings) {
+                       _mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->in.strings));
+                       NDR_PULL_ALLOC_N(ndr, r->in.strings, ndr_get_array_size(ndr, &r->in.strings));
+                       _mem_save_strings_1 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
+                       for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
+                       }
+                       for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
+                               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
+                               if (_ptr_strings) {
+                                       NDR_PULL_ALLOC(ndr, r->in.strings[cntr_strings_1]);
+                               } else {
+                                       r->in.strings[cntr_strings_1] = NULL;
+                               }
+                               if (r->in.strings[cntr_strings_1]) {
+                                       _mem_save_strings_2 = NDR_PULL_GET_MEM_CTX(ndr);
+                                       NDR_PULL_SET_MEM_CTX(ndr, r->in.strings[cntr_strings_1], 0);
+                                       NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
+                                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_2, 0);
+                               }
+                       }
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_1, 0);
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
+               if (_ptr_data) {
+                       NDR_PULL_ALLOC(ndr, r->in.data);
+               } else {
+                       r->in.data = NULL;
+               }
+               if (r->in.data) {
+                       _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
+                       NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
+                       NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
+               }
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.flags));
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
+               if (_ptr_record_number) {
+                       NDR_PULL_ALLOC(ndr, r->in.record_number);
+               } else {
+                       r->in.record_number = NULL;
+               }
+               if (r->in.record_number) {
+                       _mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.record_number, 0);
+                       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.record_number));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
+               if (_ptr_time_written) {
+                       NDR_PULL_ALLOC(ndr, r->in.time_written);
+               } else {
+                       r->in.time_written = NULL;
+               }
+               if (r->in.time_written) {
+                       _mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.time_written, 0);
+                       NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->in.time_written));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
+               }
+               if (r->in.strings) {
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.strings, r->in.num_of_strings));
+               }
+               if (r->in.data) {
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.data_size));
+               }
        }
        if (flags & NDR_OUT) {
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
+               if (_ptr_record_number) {
+                       NDR_PULL_ALLOC(ndr, r->out.record_number);
+               } else {
+                       r->out.record_number = NULL;
+               }
+               if (r->out.record_number) {
+                       _mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->out.record_number, 0);
+                       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.record_number));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
+               if (_ptr_time_written) {
+                       NDR_PULL_ALLOC(ndr, r->out.time_written);
+               } else {
+                       r->out.time_written = NULL;
+               }
+               if (r->out.time_written) {
+                       _mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->out.time_written, 0);
+                       NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->out.time_written));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
+               }
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -1074,6 +1498,7 @@ static enum ndr_err_code ndr_pull_eventlog_ReportEventW(struct ndr_pull *ndr, in
 
 _PUBLIC_ void ndr_print_eventlog_ReportEventW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventW *r)
 {
+       uint32_t cntr_strings_1;
        ndr_print_struct(ndr, name, "eventlog_ReportEventW");
        ndr->depth++;
        if (flags & NDR_SET_VALUES) {
@@ -1082,11 +1507,82 @@ _PUBLIC_ void ndr_print_eventlog_ReportEventW(struct ndr_print *ndr, const char
        if (flags & NDR_IN) {
                ndr_print_struct(ndr, "in", "eventlog_ReportEventW");
                ndr->depth++;
+               ndr_print_ptr(ndr, "handle", r->in.handle);
+               ndr->depth++;
+               ndr_print_policy_handle(ndr, "handle", r->in.handle);
+               ndr->depth--;
+               ndr_print_time_t(ndr, "timestamp", r->in.timestamp);
+               ndr_print_eventlogEventTypes(ndr, "event_type", r->in.event_type);
+               ndr_print_uint16(ndr, "event_category", r->in.event_category);
+               ndr_print_uint32(ndr, "event_id", r->in.event_id);
+               ndr_print_uint16(ndr, "num_of_strings", r->in.num_of_strings);
+               ndr_print_uint32(ndr, "data_size", r->in.data_size);
+               ndr_print_ptr(ndr, "servername", r->in.servername);
+               ndr->depth++;
+               ndr_print_lsa_String(ndr, "servername", r->in.servername);
+               ndr->depth--;
+               ndr_print_ptr(ndr, "user_sid", r->in.user_sid);
+               ndr->depth++;
+               if (r->in.user_sid) {
+                       ndr_print_dom_sid(ndr, "user_sid", r->in.user_sid);
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "strings", r->in.strings);
+               ndr->depth++;
+               if (r->in.strings) {
+                       ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->in.num_of_strings);
+                       ndr->depth++;
+                       for (cntr_strings_1=0;cntr_strings_1<r->in.num_of_strings;cntr_strings_1++) {
+                               char *idx_1=NULL;
+                               if (asprintf(&idx_1, "[%d]", cntr_strings_1) != -1) {
+                                       ndr_print_ptr(ndr, "strings", r->in.strings[cntr_strings_1]);
+                                       ndr->depth++;
+                                       if (r->in.strings[cntr_strings_1]) {
+                                               ndr_print_lsa_String(ndr, "strings", r->in.strings[cntr_strings_1]);
+                                       }
+                                       ndr->depth--;
+                                       free(idx_1);
+                               }
+                       }
+                       ndr->depth--;
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "data", r->in.data);
+               ndr->depth++;
+               if (r->in.data) {
+                       ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_size);
+               }
+               ndr->depth--;
+               ndr_print_uint16(ndr, "flags", r->in.flags);
+               ndr_print_ptr(ndr, "record_number", r->in.record_number);
+               ndr->depth++;
+               if (r->in.record_number) {
+                       ndr_print_uint32(ndr, "record_number", *r->in.record_number);
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "time_written", r->in.time_written);
+               ndr->depth++;
+               if (r->in.time_written) {
+                       ndr_print_time_t(ndr, "time_written", *r->in.time_written);
+               }
+               ndr->depth--;
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
                ndr_print_struct(ndr, "out", "eventlog_ReportEventW");
                ndr->depth++;
+               ndr_print_ptr(ndr, "record_number", r->out.record_number);
+               ndr->depth++;
+               if (r->out.record_number) {
+                       ndr_print_uint32(ndr, "record_number", *r->out.record_number);
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "time_written", r->out.time_written);
+               ndr->depth++;
+               if (r->out.time_written) {
+                       ndr_print_time_t(ndr, "time_written", *r->out.time_written);
+               }
+               ndr->depth--;
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
                ndr->depth--;
        }
@@ -1506,8 +2002,23 @@ _PUBLIC_ void ndr_print_eventlog_WriteClusterEvents(struct ndr_print *ndr, const
 static enum ndr_err_code ndr_push_eventlog_GetLogIntormation(struct ndr_push *ndr, int flags, const struct eventlog_GetLogIntormation *r)
 {
        if (flags & NDR_IN) {
+               if (r->in.handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
        }
        if (flags & NDR_OUT) {
+               if (r->out.buffer == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
+               if (r->out.bytes_needed == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
                NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -1515,10 +2026,45 @@ static enum ndr_err_code ndr_push_eventlog_GetLogIntormation(struct ndr_push *nd
 
 static enum ndr_err_code ndr_pull_eventlog_GetLogIntormation(struct ndr_pull *ndr, int flags, struct eventlog_GetLogIntormation *r)
 {
+       TALLOC_CTX *_mem_save_handle_0;
+       TALLOC_CTX *_mem_save_bytes_needed_0;
        if (flags & NDR_IN) {
+               ZERO_STRUCT(r->out);
+
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.handle);
+               }
+               _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
+               if (r->in.buf_size > 1024) {
+                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
+               }
+               NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.buf_size);
+               memset(CONST_DISCARD(struct eventlog_GetLogIntormation *,r->out.buffer), 0, (r->in.buf_size) * sizeof(*r->out.buffer));
+               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+               ZERO_STRUCTP(r->out.bytes_needed);
        }
        if (flags & NDR_OUT) {
+               NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
+               }
+               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+               }
+               _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
+               if (r->out.buffer) {
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.buf_size));
+               }
        }
        return NDR_ERR_SUCCESS;
 }
@@ -1533,11 +2079,25 @@ _PUBLIC_ void ndr_print_eventlog_GetLogIntormation(struct ndr_print *ndr, const
        if (flags & NDR_IN) {
                ndr_print_struct(ndr, "in", "eventlog_GetLogIntormation");
                ndr->depth++;
+               ndr_print_ptr(ndr, "handle", r->in.handle);
+               ndr->depth++;
+               ndr_print_policy_handle(ndr, "handle", r->in.handle);
+               ndr->depth--;
+               ndr_print_uint32(ndr, "level", r->in.level);
+               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
                ndr_print_struct(ndr, "out", "eventlog_GetLogIntormation");
                ndr->depth++;
+               ndr_print_ptr(ndr, "buffer", r->out.buffer);
+               ndr->depth++;
+               ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.buf_size);
+               ndr->depth--;
+               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr->depth++;
+               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr->depth--;
                ndr_print_NTSTATUS(ndr, "result", r->out.result);
                ndr->depth--;
        }
@@ -1601,6 +2161,344 @@ _PUBLIC_ void ndr_print_eventlog_FlushEventLog(struct ndr_print *ndr, const char
        ndr->depth--;
 }
 
+static enum ndr_err_code ndr_push_eventlog_ReportEventAndSourceW(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventAndSourceW *r)
+{
+       uint32_t cntr_strings_1;
+       if (flags & NDR_IN) {
+               if (r->in.handle == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
+               NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->in.timestamp));
+               NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->in.event_type));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.event_category));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.event_id));
+               if (r->in.sourcename == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sourcename));
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.num_of_strings));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
+               if (r->in.servername == NULL) {
+                       return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
+               }
+               NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user_sid));
+               if (r->in.user_sid) {
+                       NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
+               }
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings));
+               if (r->in.strings) {
+                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_of_strings));
+                       for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
+                       }
+                       for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
+                               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings[cntr_strings_1]));
+                               if (r->in.strings[cntr_strings_1]) {
+                                       NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
+                               }
+                       }
+               }
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));
+               if (r->in.data) {
+                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
+                       NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_size));
+               }
+               NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.flags));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.record_number));
+               if (r->in.record_number) {
+                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.record_number));
+               }
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.time_written));
+               if (r->in.time_written) {
+                       NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->in.time_written));
+               }
+       }
+       if (flags & NDR_OUT) {
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.record_number));
+               if (r->out.record_number) {
+                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.record_number));
+               }
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.time_written));
+               if (r->out.time_written) {
+                       NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->out.time_written));
+               }
+               NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_eventlog_ReportEventAndSourceW(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventAndSourceW *r)
+{
+       uint32_t _ptr_user_sid;
+       uint32_t _ptr_strings;
+       uint32_t cntr_strings_1;
+       uint32_t _ptr_data;
+       uint32_t _ptr_record_number;
+       uint32_t _ptr_time_written;
+       TALLOC_CTX *_mem_save_handle_0;
+       TALLOC_CTX *_mem_save_sourcename_0;
+       TALLOC_CTX *_mem_save_servername_0;
+       TALLOC_CTX *_mem_save_user_sid_0;
+       TALLOC_CTX *_mem_save_strings_0;
+       TALLOC_CTX *_mem_save_strings_1;
+       TALLOC_CTX *_mem_save_strings_2;
+       TALLOC_CTX *_mem_save_data_0;
+       TALLOC_CTX *_mem_save_record_number_0;
+       TALLOC_CTX *_mem_save_time_written_0;
+       if (flags & NDR_IN) {
+               ZERO_STRUCT(r->out);
+
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.handle);
+               }
+               _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->in.timestamp));
+               NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->in.event_type));
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.event_category));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.event_id));
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.sourcename);
+               }
+               _mem_save_sourcename_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.sourcename, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sourcename));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sourcename_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.num_of_strings));
+               if (r->in.num_of_strings > 256) {
+                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
+               }
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
+               if (r->in.data_size > 0x3FFFF) {
+                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
+               }
+               if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
+                       NDR_PULL_ALLOC(ndr, r->in.servername);
+               }
+               _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));
+               if (_ptr_user_sid) {
+                       NDR_PULL_ALLOC(ndr, r->in.user_sid);
+               } else {
+                       r->in.user_sid = NULL;
+               }
+               if (r->in.user_sid) {
+                       _mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.user_sid, 0);
+                       NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
+               if (_ptr_strings) {
+                       NDR_PULL_ALLOC(ndr, r->in.strings);
+               } else {
+                       r->in.strings = NULL;
+               }
+               if (r->in.strings) {
+                       _mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->in.strings));
+                       NDR_PULL_ALLOC_N(ndr, r->in.strings, ndr_get_array_size(ndr, &r->in.strings));
+                       _mem_save_strings_1 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);
+                       for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
+                       }
+                       for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {
+                               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));
+                               if (_ptr_strings) {
+                                       NDR_PULL_ALLOC(ndr, r->in.strings[cntr_strings_1]);
+                               } else {
+                                       r->in.strings[cntr_strings_1] = NULL;
+                               }
+                               if (r->in.strings[cntr_strings_1]) {
+                                       _mem_save_strings_2 = NDR_PULL_GET_MEM_CTX(ndr);
+                                       NDR_PULL_SET_MEM_CTX(ndr, r->in.strings[cntr_strings_1], 0);
+                                       NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));
+                                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_2, 0);
+                               }
+                       }
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_1, 0);
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
+               if (_ptr_data) {
+                       NDR_PULL_ALLOC(ndr, r->in.data);
+               } else {
+                       r->in.data = NULL;
+               }
+               if (r->in.data) {
+                       _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
+                       NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
+                       NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
+               }
+               NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.flags));
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
+               if (_ptr_record_number) {
+                       NDR_PULL_ALLOC(ndr, r->in.record_number);
+               } else {
+                       r->in.record_number = NULL;
+               }
+               if (r->in.record_number) {
+                       _mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.record_number, 0);
+                       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.record_number));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
+               if (_ptr_time_written) {
+                       NDR_PULL_ALLOC(ndr, r->in.time_written);
+               } else {
+                       r->in.time_written = NULL;
+               }
+               if (r->in.time_written) {
+                       _mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.time_written, 0);
+                       NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->in.time_written));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
+               }
+               if (r->in.strings) {
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.strings, r->in.num_of_strings));
+               }
+               if (r->in.data) {
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.data_size));
+               }
+       }
+       if (flags & NDR_OUT) {
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));
+               if (_ptr_record_number) {
+                       NDR_PULL_ALLOC(ndr, r->out.record_number);
+               } else {
+                       r->out.record_number = NULL;
+               }
+               if (r->out.record_number) {
+                       _mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->out.record_number, 0);
+                       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.record_number));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));
+               if (_ptr_time_written) {
+                       NDR_PULL_ALLOC(ndr, r->out.time_written);
+               } else {
+                       r->out.time_written = NULL;
+               }
+               if (r->out.time_written) {
+                       _mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->out.time_written, 0);
+                       NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->out.time_written));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);
+               }
+               NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_eventlog_ReportEventAndSourceW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventAndSourceW *r)
+{
+       uint32_t cntr_strings_1;
+       ndr_print_struct(ndr, name, "eventlog_ReportEventAndSourceW");
+       ndr->depth++;
+       if (flags & NDR_SET_VALUES) {
+               ndr->flags |= LIBNDR_PRINT_SET_VALUES;
+       }
+       if (flags & NDR_IN) {
+               ndr_print_struct(ndr, "in", "eventlog_ReportEventAndSourceW");
+               ndr->depth++;
+               ndr_print_ptr(ndr, "handle", r->in.handle);
+               ndr->depth++;
+               ndr_print_policy_handle(ndr, "handle", r->in.handle);
+               ndr->depth--;
+               ndr_print_time_t(ndr, "timestamp", r->in.timestamp);
+               ndr_print_eventlogEventTypes(ndr, "event_type", r->in.event_type);
+               ndr_print_uint16(ndr, "event_category", r->in.event_category);
+               ndr_print_uint32(ndr, "event_id", r->in.event_id);
+               ndr_print_ptr(ndr, "sourcename", r->in.sourcename);
+               ndr->depth++;
+               ndr_print_lsa_String(ndr, "sourcename", r->in.sourcename);
+               ndr->depth--;
+               ndr_print_uint16(ndr, "num_of_strings", r->in.num_of_strings);
+               ndr_print_uint32(ndr, "data_size", r->in.data_size);
+               ndr_print_ptr(ndr, "servername", r->in.servername);
+               ndr->depth++;
+               ndr_print_lsa_String(ndr, "servername", r->in.servername);
+               ndr->depth--;
+               ndr_print_ptr(ndr, "user_sid", r->in.user_sid);
+               ndr->depth++;
+               if (r->in.user_sid) {
+                       ndr_print_dom_sid(ndr, "user_sid", r->in.user_sid);
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "strings", r->in.strings);
+               ndr->depth++;
+               if (r->in.strings) {
+                       ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->in.num_of_strings);
+                       ndr->depth++;
+                       for (cntr_strings_1=0;cntr_strings_1<r->in.num_of_strings;cntr_strings_1++) {
+                               char *idx_1=NULL;
+                               if (asprintf(&idx_1, "[%d]", cntr_strings_1) != -1) {
+                                       ndr_print_ptr(ndr, "strings", r->in.strings[cntr_strings_1]);
+                                       ndr->depth++;
+                                       if (r->in.strings[cntr_strings_1]) {
+                                               ndr_print_lsa_String(ndr, "strings", r->in.strings[cntr_strings_1]);
+                                       }
+                                       ndr->depth--;
+                                       free(idx_1);
+                               }
+                       }
+                       ndr->depth--;
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "data", r->in.data);
+               ndr->depth++;
+               if (r->in.data) {
+                       ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_size);
+               }
+               ndr->depth--;
+               ndr_print_uint16(ndr, "flags", r->in.flags);
+               ndr_print_ptr(ndr, "record_number", r->in.record_number);
+               ndr->depth++;
+               if (r->in.record_number) {
+                       ndr_print_uint32(ndr, "record_number", *r->in.record_number);
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "time_written", r->in.time_written);
+               ndr->depth++;
+               if (r->in.time_written) {
+                       ndr_print_time_t(ndr, "time_written", *r->in.time_written);
+               }
+               ndr->depth--;
+               ndr->depth--;
+       }
+       if (flags & NDR_OUT) {
+               ndr_print_struct(ndr, "out", "eventlog_ReportEventAndSourceW");
+               ndr->depth++;
+               ndr_print_ptr(ndr, "record_number", r->out.record_number);
+               ndr->depth++;
+               if (r->out.record_number) {
+                       ndr_print_uint32(ndr, "record_number", *r->out.record_number);
+               }
+               ndr->depth--;
+               ndr_print_ptr(ndr, "time_written", r->out.time_written);
+               ndr->depth++;
+               if (r->out.time_written) {
+                       ndr_print_time_t(ndr, "time_written", *r->out.time_written);
+               }
+               ndr->depth--;
+               ndr_print_NTSTATUS(ndr, "result", r->out.result);
+               ndr->depth--;
+       }
+       ndr->depth--;
+}
+
 static const struct ndr_interface_call eventlog_calls[] = {
        {
                "eventlog_ClearEventLogW",
@@ -1794,6 +2692,14 @@ static const struct ndr_interface_call eventlog_calls[] = {
                (ndr_print_function_t) ndr_print_eventlog_FlushEventLog,
                false,
        },
+       {
+               "eventlog_ReportEventAndSourceW",
+               sizeof(struct eventlog_ReportEventAndSourceW),
+               (ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventAndSourceW,
+               (ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventAndSourceW,
+               (ndr_print_function_t) ndr_print_eventlog_ReportEventAndSourceW,
+               false,
+       },
        { NULL, 0, NULL, NULL, NULL, false }
 };
 
@@ -1823,7 +2729,7 @@ const struct ndr_interface_table ndr_table_eventlog = {
                NDR_EVENTLOG_VERSION
        },
        .helpstring     = NDR_EVENTLOG_HELPSTRING,
-       .num_calls      = 24,
+       .num_calls      = 25,
        .calls          = eventlog_calls,
        .endpoints      = &eventlog_endpoints,
        .authservices   = &eventlog_authservices

diff --git a/librpc/gen_ndr/ndr_eventlog.h b/librpc/gen_ndr/ndr_eventlog.h
index f63fa9e569c498b8e990a6db47375d8f686d76c8..3fa20e3a29f0298c7344ba8f79b0f0016a189027 100644 (file)
--- a/librpc/gen_ndr/ndr_eventlog.h
+++ b/librpc/gen_ndr/ndr_eventlog.h
@@ -59,7 +59,9 @@ extern const struct ndr_interface_table ndr_table_eventlog;
 
 #define NDR_EVENTLOG_FLUSHEVENTLOG (0x17)
 
-#define NDR_EVENTLOG_CALL_COUNT (24)
+#define NDR_EVENTLOG_REPORTEVENTANDSOURCEW (0x18)
+
+#define NDR_EVENTLOG_CALL_COUNT (25)
 void ndr_print_eventlogReadFlags(struct ndr_print *ndr, const char *name, uint32_t r);
 enum ndr_err_code ndr_push_eventlogEventTypes(struct ndr_push *ndr, int ndr_flags, enum eventlogEventTypes r);
 enum ndr_err_code ndr_pull_eventlogEventTypes(struct ndr_pull *ndr, int ndr_flags, enum eventlogEventTypes *r);
@@ -92,4 +94,5 @@ void ndr_print_eventlog_DeregisterClusterSvc(struct ndr_print *ndr, const char *
 void ndr_print_eventlog_WriteClusterEvents(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_WriteClusterEvents *r);
 void ndr_print_eventlog_GetLogIntormation(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetLogIntormation *r);
 void ndr_print_eventlog_FlushEventLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_FlushEventLog *r);
+void ndr_print_eventlog_ReportEventAndSourceW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventAndSourceW *r);
 #endif /* _HEADER_NDR_eventlog */

diff --git a/librpc/gen_ndr/srv_eventlog.c b/librpc/gen_ndr/srv_eventlog.c
index 73c536d50f8f55d57fb024d1ce2cc77a7e42ae5a..795afc9a5ada6ac2620a83d5c73cb8c3bf76e1ed 100644 (file)
--- a/librpc/gen_ndr/srv_eventlog.c
+++ b/librpc/gen_ndr/srv_eventlog.c
@@ -265,6 +265,8 @@ static bool api_eventlog_DeregisterEventSource(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.handle = r->in.handle;
        r->out.result = _eventlog_DeregisterEventSource(p, r);
 
        if (p->rng_fault_state) {
@@ -651,6 +653,13 @@ static bool api_eventlog_RegisterEventSourceW(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.log_handle = talloc_zero(r, struct policy_handle);
+       if (r->out.log_handle == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _eventlog_RegisterEventSourceW(p, r);
 
        if (p->rng_fault_state) {
@@ -724,6 +733,13 @@ static bool api_eventlog_OpenBackupEventLogW(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.handle = talloc_zero(r, struct policy_handle);
+       if (r->out.handle == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _eventlog_OpenBackupEventLogW(p, r);
 
        if (p->rng_fault_state) {
@@ -889,6 +905,9 @@ static bool api_eventlog_ReportEventW(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.record_number = r->in.record_number;
+       r->out.time_written = r->in.time_written;
        r->out.result = _eventlog_ReportEventW(p, r);
 
        if (p->rng_fault_state) {
@@ -1692,6 +1711,19 @@ static bool api_eventlog_GetLogIntormation(pipes_struct *p)
                NDR_PRINT_IN_DEBUG(eventlog_GetLogIntormation, r);
        }
 
+       ZERO_STRUCT(r->out);
+       r->out.buffer = talloc_zero_array(r, uint8_t, r->in.buf_size);
+       if (r->out.buffer == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       r->out.bytes_needed = talloc_zero(r, uint32_t);
+       if (r->out.bytes_needed == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
        r->out.result = _eventlog_GetLogIntormation(p, r);
 
        if (p->rng_fault_state) {
@@ -1800,6 +1832,82 @@ static bool api_eventlog_FlushEventLog(pipes_struct *p)
        return true;
 }
 
+static bool api_eventlog_ReportEventAndSourceW(pipes_struct *p)
+{
+       const struct ndr_interface_call *call;
+       struct ndr_pull *pull;
+       struct ndr_push *push;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
+       struct eventlog_ReportEventAndSourceW *r;
+
+       call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTANDSOURCEW];
+
+       r = talloc(talloc_tos(), struct eventlog_ReportEventAndSourceW);
+       if (r == NULL) {
+               return false;
+       }
+
+       if (!prs_data_blob(&p->in_data.data, &blob, r)) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull = ndr_pull_init_blob(&blob, r, NULL);
+       if (pull == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       pull->flags |= LIBNDR_FLAG_REF_ALLOC;
+       ndr_err = call->ndr_pull(pull, NDR_IN, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_IN_DEBUG(eventlog_ReportEventAndSourceW, r);
+       }
+
+       ZERO_STRUCT(r->out);
+       r->out.record_number = r->in.record_number;
+       r->out.time_written = r->in.time_written;
+       r->out.result = _eventlog_ReportEventAndSourceW(p, r);
+
+       if (p->rng_fault_state) {
+               talloc_free(r);
+               /* Return true here, srv_pipe_hnd.c will take care */
+               return true;
+       }
+
+       if (DEBUGLEVEL >= 10) {
+               NDR_PRINT_OUT_DEBUG(eventlog_ReportEventAndSourceW, r);
+       }
+
+       push = ndr_push_init_ctx(r, NULL);
+       if (push == NULL) {
+               talloc_free(r);
+               return false;
+       }
+
+       ndr_err = call->ndr_push(push, NDR_OUT, r);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               talloc_free(r);
+               return false;
+       }
+
+       blob = ndr_push_blob(push);
+       if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
+               talloc_free(r);
+               return false;
+       }
+
+       talloc_free(r);
+
+       return true;
+}
+
 
 /* Tables */
 static struct api_struct api_eventlog_cmds[] = 
@@ -1828,6 +1936,7 @@ static struct api_struct api_eventlog_cmds[] =
        {"EVENTLOG_WRITECLUSTEREVENTS", NDR_EVENTLOG_WRITECLUSTEREVENTS, api_eventlog_WriteClusterEvents},
        {"EVENTLOG_GETLOGINTORMATION", NDR_EVENTLOG_GETLOGINTORMATION, api_eventlog_GetLogIntormation},
        {"EVENTLOG_FLUSHEVENTLOG", NDR_EVENTLOG_FLUSHEVENTLOG, api_eventlog_FlushEventLog},
+       {"EVENTLOG_REPORTEVENTANDSOURCEW", NDR_EVENTLOG_REPORTEVENTANDSOURCEW, api_eventlog_ReportEventAndSourceW},
 };
 
 void eventlog_get_pipe_fns(struct api_struct **fns, int *n_fns)
@@ -1866,6 +1975,8 @@ NTSTATUS rpc_eventlog_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_EVENTLOG_DEREGISTEREVENTSOURCE: {
                        struct eventlog_DeregisterEventSource *r = (struct eventlog_DeregisterEventSource *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.handle = r->in.handle;
                        r->out.result = _eventlog_DeregisterEventSource(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -1914,12 +2025,24 @@ NTSTATUS rpc_eventlog_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_EVENTLOG_REGISTEREVENTSOURCEW: {
                        struct eventlog_RegisterEventSourceW *r = (struct eventlog_RegisterEventSourceW *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.log_handle = talloc_zero(mem_ctx, struct policy_handle);
+                       if (r->out.log_handle == NULL) {
+                       return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _eventlog_RegisterEventSourceW(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
 
                case NDR_EVENTLOG_OPENBACKUPEVENTLOGW: {
                        struct eventlog_OpenBackupEventLogW *r = (struct eventlog_OpenBackupEventLogW *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
+                       if (r->out.handle == NULL) {
+                       return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _eventlog_OpenBackupEventLogW(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -1948,6 +2071,9 @@ NTSTATUS rpc_eventlog_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_EVENTLOG_REPORTEVENTW: {
                        struct eventlog_ReportEventW *r = (struct eventlog_ReportEventW *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.record_number = r->in.record_number;
+                       r->out.time_written = r->in.time_written;
                        r->out.result = _eventlog_ReportEventW(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -2014,6 +2140,17 @@ NTSTATUS rpc_eventlog_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 
                case NDR_EVENTLOG_GETLOGINTORMATION: {
                        struct eventlog_GetLogIntormation *r = (struct eventlog_GetLogIntormation *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.buf_size);
+                       if (r->out.buffer == NULL) {
+                       return NT_STATUS_NO_MEMORY;
+                       }
+
+                       r->out.bytes_needed = talloc_zero(mem_ctx, uint32_t);
+                       if (r->out.bytes_needed == NULL) {
+                       return NT_STATUS_NO_MEMORY;
+                       }
+
                        r->out.result = _eventlog_GetLogIntormation(cli->pipes_struct, r);
                        return NT_STATUS_OK;
                }
@@ -2024,6 +2161,15 @@ NTSTATUS rpc_eventlog_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
                        return NT_STATUS_OK;
                }
 
+               case NDR_EVENTLOG_REPORTEVENTANDSOURCEW: {
+                       struct eventlog_ReportEventAndSourceW *r = (struct eventlog_ReportEventAndSourceW *)_r;
+                       ZERO_STRUCT(r->out);
+                       r->out.record_number = r->in.record_number;
+                       r->out.time_written = r->in.time_written;
+                       r->out.result = _eventlog_ReportEventAndSourceW(cli->pipes_struct, r);
+                       return NT_STATUS_OK;
+               }
+
                default:
                        return NT_STATUS_NOT_IMPLEMENTED;
        }

diff --git a/librpc/gen_ndr/srv_eventlog.h b/librpc/gen_ndr/srv_eventlog.h
index c540f9224291668fba6e6207a5becae88e4f9d16..11d6886a24e0de36218f4463e3329c655a9288f5 100644 (file)
--- a/librpc/gen_ndr/srv_eventlog.h
+++ b/librpc/gen_ndr/srv_eventlog.h
@@ -25,6 +25,7 @@ NTSTATUS _eventlog_DeregisterClusterSvc(pipes_struct *p, struct eventlog_Deregis
 NTSTATUS _eventlog_WriteClusterEvents(pipes_struct *p, struct eventlog_WriteClusterEvents *r);
 NTSTATUS _eventlog_GetLogIntormation(pipes_struct *p, struct eventlog_GetLogIntormation *r);
 NTSTATUS _eventlog_FlushEventLog(pipes_struct *p, struct eventlog_FlushEventLog *r);
+NTSTATUS _eventlog_ReportEventAndSourceW(pipes_struct *p, struct eventlog_ReportEventAndSourceW *r);
 void eventlog_get_pipe_fns(struct api_struct **fns, int *n_fns);
 NTSTATUS rpc_eventlog_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *r);
 NTSTATUS _eventlog_ClearEventLogW(pipes_struct *p, struct eventlog_ClearEventLogW *r);
@@ -51,5 +52,6 @@ NTSTATUS _eventlog_DeregisterClusterSvc(pipes_struct *p, struct eventlog_Deregis
 NTSTATUS _eventlog_WriteClusterEvents(pipes_struct *p, struct eventlog_WriteClusterEvents *r);
 NTSTATUS _eventlog_GetLogIntormation(pipes_struct *p, struct eventlog_GetLogIntormation *r);
 NTSTATUS _eventlog_FlushEventLog(pipes_struct *p, struct eventlog_FlushEventLog *r);
+NTSTATUS _eventlog_ReportEventAndSourceW(pipes_struct *p, struct eventlog_ReportEventAndSourceW *r);
 NTSTATUS rpc_eventlog_init(void);
 #endif /* __SRV_EVENTLOG__ */