s3: re-run make samba3-idl and add generated header file.

[amitay/samba.git] / librpc / gen_ndr / ndr_svcctl.c

diff --git a/librpc/gen_ndr/ndr_svcctl.c b/librpc/gen_ndr/ndr_svcctl.c
index cdea71f4d4a324f12527eb47b136913ab70ec77e..a51b0eb3f22737747ef4566f0b7ee8826dd22bcc 100644 (file)
--- a/librpc/gen_ndr/ndr_svcctl.c
+++ b/librpc/gen_ndr/ndr_svcctl.c
@@ -8,16 +8,17 @@
 static enum ndr_err_code ndr_push_SERVICE_LOCK_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_LOCK_STATUS *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_locked));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->lock_owner));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_duration));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->lock_owner) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lock_owner, ndr_charset_length(r->lock_owner, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -29,7 +30,7 @@ static enum ndr_err_code ndr_pull_SERVICE_LOCK_STATUS(struct ndr_pull *ndr, int
        uint32_t _ptr_lock_owner;
        TALLOC_CTX *_mem_save_lock_owner_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_locked));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lock_owner));
                if (_ptr_lock_owner) {
@@ -38,6 +39,7 @@ static enum ndr_err_code ndr_pull_SERVICE_LOCK_STATUS(struct ndr_pull *ndr, int
                        r->lock_owner = NULL;
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_duration));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->lock_owner) {
@@ -71,17 +73,77 @@ _PUBLIC_ void ndr_print_SERVICE_LOCK_STATUS(struct ndr_print *ndr, const char *n
        ndr->depth--;
 }
 
+static enum ndr_err_code ndr_push_svcctl_ServiceStatus(struct ndr_push *ndr, int ndr_flags, enum svcctl_ServiceStatus r)
+{
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_svcctl_ServiceStatus(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ServiceStatus *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_svcctl_ServiceStatus(struct ndr_print *ndr, const char *name, enum svcctl_ServiceStatus r)
+{
+       const char *val = NULL;
+
+       switch (r) {
+               case SVCCTL_STATE_UNKNOWN: val = "SVCCTL_STATE_UNKNOWN"; break;
+               case SVCCTL_STOPPED: val = "SVCCTL_STOPPED"; break;
+               case SVCCTL_START_PENDING: val = "SVCCTL_START_PENDING"; break;
+               case SVCCTL_STOP_PENDING: val = "SVCCTL_STOP_PENDING"; break;
+               case SVCCTL_RUNNING: val = "SVCCTL_RUNNING"; break;
+               case SVCCTL_CONTINUE_PENDING: val = "SVCCTL_CONTINUE_PENDING"; break;
+               case SVCCTL_PAUSE_PENDING: val = "SVCCTL_PAUSE_PENDING"; break;
+               case SVCCTL_PAUSED: val = "SVCCTL_PAUSED"; break;
+       }
+       ndr_print_enum(ndr, name, "ENUM", val, r);
+}
+
+static enum ndr_err_code ndr_push_svcctl_ControlsAccepted(struct ndr_push *ndr, int ndr_flags, uint32_t r)
+{
+       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_svcctl_ControlsAccepted(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_svcctl_ControlsAccepted(struct ndr_print *ndr, const char *name, uint32_t r)
+{
+       ndr_print_uint32(ndr, name, r);
+       ndr->depth++;
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_STOP", SVCCTL_ACCEPT_STOP, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_PAUSE_CONTINUE", SVCCTL_ACCEPT_PAUSE_CONTINUE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_SHUTDOWN", SVCCTL_ACCEPT_SHUTDOWN, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_PARAMCHANGE", SVCCTL_ACCEPT_PARAMCHANGE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_NETBINDCHANGE", SVCCTL_ACCEPT_NETBINDCHANGE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_HARDWAREPROFILECHANGE", SVCCTL_ACCEPT_HARDWAREPROFILECHANGE, r);
+       ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_POWEREVENT", SVCCTL_ACCEPT_POWEREVENT, r);
+       ndr->depth--;
+}
+
 static enum ndr_err_code ndr_push_SERVICE_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_STATUS *r)
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->state));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->controls_accepted));
+               NDR_CHECK(ndr_push_svcctl_ServiceStatus(ndr, NDR_SCALARS, r->state));
+               NDR_CHECK(ndr_push_svcctl_ControlsAccepted(ndr, NDR_SCALARS, r->controls_accepted));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->win32_exit_code));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_exit_code));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->check_point));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wait_hint));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -93,12 +155,13 @@ static enum ndr_err_code ndr_pull_SERVICE_STATUS(struct ndr_pull *ndr, int ndr_f
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_pull_align(ndr, 4));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->state));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->controls_accepted));
+               NDR_CHECK(ndr_pull_svcctl_ServiceStatus(ndr, NDR_SCALARS, &r->state));
+               NDR_CHECK(ndr_pull_svcctl_ControlsAccepted(ndr, NDR_SCALARS, &r->controls_accepted));
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->win32_exit_code));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_exit_code));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->check_point));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wait_hint));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
        }
        if (ndr_flags & NDR_BUFFERS) {
        }
@@ -110,8 +173,8 @@ _PUBLIC_ void ndr_print_SERVICE_STATUS(struct ndr_print *ndr, const char *name,
        ndr_print_struct(ndr, name, "SERVICE_STATUS");
        ndr->depth++;
        ndr_print_uint32(ndr, "type", r->type);
-       ndr_print_uint32(ndr, "state", r->state);
-       ndr_print_uint32(ndr, "controls_accepted", r->controls_accepted);
+       ndr_print_svcctl_ServiceStatus(ndr, "state", r->state);
+       ndr_print_svcctl_ControlsAccepted(ndr, "controls_accepted", r->controls_accepted);
        ndr_print_WERROR(ndr, "win32_exit_code", r->win32_exit_code);
        ndr_print_uint32(ndr, "service_exit_code", r->service_exit_code);
        ndr_print_uint32(ndr, "check_point", r->check_point);
@@ -119,10 +182,193 @@ _PUBLIC_ void ndr_print_SERVICE_STATUS(struct ndr_print *ndr, const char *name,
        ndr->depth--;
 }
 
-static enum ndr_err_code ndr_push_ENUM_SERVICE_STATUS(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUS *r)
+_PUBLIC_ enum ndr_err_code ndr_push_SERVICE_STATUS_PROCESS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_STATUS_PROCESS *r)
 {
        if (ndr_flags & NDR_SCALARS) {
                NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->process_id));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_flags));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_STATUS_PROCESS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_STATUS_PROCESS *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->process_id));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_flags));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_SERVICE_STATUS_PROCESS(struct ndr_print *ndr, const char *name, const struct SERVICE_STATUS_PROCESS *r)
+{
+       ndr_print_struct(ndr, name, "SERVICE_STATUS_PROCESS");
+       ndr->depth++;
+       ndr_print_SERVICE_STATUS(ndr, "status", &r->status);
+       ndr_print_uint32(ndr, "process_id", r->process_id);
+       ndr_print_uint32(ndr, "service_flags", r->service_flags);
+       ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSW(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUSW *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_push_relative_ptr1(ndr, r->service_name));
+                       ndr->flags = _flags_save_string;
+               }
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
+                       ndr->flags = _flags_save_string;
+               }
+               NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->service_name) {
+                               NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->service_name));
+                               NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->service_name));
+                               NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->service_name));
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->display_name) {
+                               NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
+                               NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
+                               NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSW(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUSW *r)
+{
+       uint32_t _ptr_service_name;
+       TALLOC_CTX *_mem_save_service_name_0;
+       uint32_t _ptr_display_name;
+       TALLOC_CTX *_mem_save_display_name_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
+                       if (_ptr_service_name) {
+                               NDR_PULL_ALLOC(ndr, r->service_name);
+                               NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->service_name, _ptr_service_name));
+                       } else {
+                               r->service_name = NULL;
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
+                       if (_ptr_display_name) {
+                               NDR_PULL_ALLOC(ndr, r->display_name);
+                               NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
+                       } else {
+                               r->display_name = NULL;
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+               NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->service_name) {
+                               uint32_t _relative_save_offset;
+                               _relative_save_offset = ndr->offset;
+                               NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->service_name));
+                               _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                               NDR_PULL_SET_MEM_CTX(ndr, r->service_name, 0);
+                               NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->service_name));
+                               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
+                               if (ndr->offset > ndr->relative_highest_offset) {
+                                       ndr->relative_highest_offset = ndr->offset;
+                               }
+                               ndr->offset = _relative_save_offset;
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->display_name) {
+                               uint32_t _relative_save_offset;
+                               _relative_save_offset = ndr->offset;
+                               NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
+                               _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                               NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
+                               NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
+                               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
+                               if (ndr->offset > ndr->relative_highest_offset) {
+                                       ndr->relative_highest_offset = ndr->offset;
+                               }
+                               ndr->offset = _relative_save_offset;
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_ENUM_SERVICE_STATUSW(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUSW *r)
+{
+       ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUSW");
+       ndr->depth++;
+       ndr_print_ptr(ndr, "service_name", r->service_name);
+       ndr->depth++;
+       if (r->service_name) {
+               ndr_print_string(ndr, "service_name", r->service_name);
+       }
+       ndr->depth--;
+       ndr_print_ptr(ndr, "display_name", r->display_name);
+       ndr->depth++;
+       if (r->display_name) {
+               ndr_print_string(ndr, "display_name", r->display_name);
+       }
+       ndr->depth--;
+       ndr_print_SERVICE_STATUS(ndr, "status", &r->status);
+       ndr->depth--;
+}
+
+_PUBLIC_ size_t ndr_size_ENUM_SERVICE_STATUSW(const struct ENUM_SERVICE_STATUSW *r, struct smb_iconv_convenience *ic, int flags)
+{
+       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSW, ic);
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSA(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUSA *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
                {
                        uint32_t _flags_save_string = ndr->flags;
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
@@ -136,14 +382,16 @@ static enum ndr_err_code ndr_push_ENUM_SERVICE_STATUS(struct ndr_push *ndr, int
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
                        uint32_t _flags_save_string = ndr->flags;
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
                        if (r->service_name) {
-                               NDR_CHECK(ndr_push_relative_ptr2(ndr, r->service_name));
+                               NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->service_name));
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->service_name));
+                               NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->service_name));
                        }
                        ndr->flags = _flags_save_string;
                }
@@ -151,8 +399,9 @@ static enum ndr_err_code ndr_push_ENUM_SERVICE_STATUS(struct ndr_push *ndr, int
                        uint32_t _flags_save_string = ndr->flags;
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
                        if (r->display_name) {
-                               NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
+                               NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
+                               NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
                        }
                        ndr->flags = _flags_save_string;
                }
@@ -160,14 +409,14 @@ static enum ndr_err_code ndr_push_ENUM_SERVICE_STATUS(struct ndr_push *ndr, int
        return NDR_ERR_SUCCESS;
 }
 
-static enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUS(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUS *r)
+_PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSA(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUSA *r)
 {
        uint32_t _ptr_service_name;
        TALLOC_CTX *_mem_save_service_name_0;
        uint32_t _ptr_display_name;
        TALLOC_CTX *_mem_save_display_name_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                {
                        uint32_t _flags_save_string = ndr->flags;
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
@@ -193,6 +442,7 @@ static enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUS(struct ndr_pull *ndr, int
                        ndr->flags = _flags_save_string;
                }
                NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                {
@@ -206,6 +456,9 @@ static enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUS(struct ndr_pull *ndr, int
                                NDR_PULL_SET_MEM_CTX(ndr, r->service_name, 0);
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->service_name));
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
+                               if (ndr->offset > ndr->relative_highest_offset) {
+                                       ndr->relative_highest_offset = ndr->offset;
+                               }
                                ndr->offset = _relative_save_offset;
                        }
                        ndr->flags = _flags_save_string;
@@ -221,6 +474,9 @@ static enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUS(struct ndr_pull *ndr, int
                                NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
+                               if (ndr->offset > ndr->relative_highest_offset) {
+                                       ndr->relative_highest_offset = ndr->offset;
+                               }
                                ndr->offset = _relative_save_offset;
                        }
                        ndr->flags = _flags_save_string;
@@ -229,9 +485,9 @@ static enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUS(struct ndr_pull *ndr, int
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_ENUM_SERVICE_STATUS(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUS *r)
+_PUBLIC_ void ndr_print_ENUM_SERVICE_STATUSA(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUSA *r)
 {
-       ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUS");
+       ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUSA");
        ndr->depth++;
        ndr_print_ptr(ndr, "service_name", r->service_name);
        ndr->depth++;
@@ -249,6 +505,11 @@ _PUBLIC_ void ndr_print_ENUM_SERVICE_STATUS(struct ndr_print *ndr, const char *n
        ndr->depth--;
 }
 
+_PUBLIC_ size_t ndr_size_ENUM_SERVICE_STATUSA(const struct ENUM_SERVICE_STATUSA *r, struct smb_iconv_convenience *ic, int flags)
+{
+       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSA, ic);
+}
+
 _PUBLIC_ enum ndr_err_code ndr_push_svcctl_ServerType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 {
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
@@ -299,14 +560,14 @@ _PUBLIC_ void ndr_print_svcctl_ServerType(struct ndr_print *ndr, const char *nam
 
 static enum ndr_err_code ndr_push_SERVICE_CONTROL(struct ndr_push *ndr, int ndr_flags, enum SERVICE_CONTROL r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_SERVICE_CONTROL(struct ndr_pull *ndr, int ndr_flags, enum SERVICE_CONTROL *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -325,6 +586,87 @@ _PUBLIC_ void ndr_print_SERVICE_CONTROL(struct ndr_print *ndr, const char *name,
        ndr_print_enum(ndr, name, "ENUM", val, r);
 }
 
+static enum ndr_err_code ndr_push_svcctl_ErrorControl(struct ndr_push *ndr, int ndr_flags, enum svcctl_ErrorControl r)
+{
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_svcctl_ErrorControl(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ErrorControl *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_svcctl_ErrorControl(struct ndr_print *ndr, const char *name, enum svcctl_ErrorControl r)
+{
+       const char *val = NULL;
+
+       switch (r) {
+               case SVCCTL_SVC_ERROR_IGNORE: val = "SVCCTL_SVC_ERROR_IGNORE"; break;
+               case SVCCTL_SVC_ERROR_NORMAL: val = "SVCCTL_SVC_ERROR_NORMAL"; break;
+               case SVCCTL_SVC_ERROR_CRITICAL: val = "SVCCTL_SVC_ERROR_CRITICAL"; break;
+               case SVCCTL_SVC_ERROR_SEVERE: val = "SVCCTL_SVC_ERROR_SEVERE"; break;
+       }
+       ndr_print_enum(ndr, name, "ENUM", val, r);
+}
+
+static enum ndr_err_code ndr_push_svcctl_StartType(struct ndr_push *ndr, int ndr_flags, enum svcctl_StartType r)
+{
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_svcctl_StartType(struct ndr_pull *ndr, int ndr_flags, enum svcctl_StartType *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_svcctl_StartType(struct ndr_print *ndr, const char *name, enum svcctl_StartType r)
+{
+       const char *val = NULL;
+
+       switch (r) {
+               case SVCCTL_BOOT_START: val = "SVCCTL_BOOT_START"; break;
+               case SVCCTL_SYSTEM_START: val = "SVCCTL_SYSTEM_START"; break;
+               case SVCCTL_AUTO_START: val = "SVCCTL_AUTO_START"; break;
+               case SVCCTL_DEMAND_START: val = "SVCCTL_DEMAND_START"; break;
+               case SVCCTL_DISABLED: val = "SVCCTL_DISABLED"; break;
+       }
+       ndr_print_enum(ndr, name, "ENUM", val, r);
+}
+
+static enum ndr_err_code ndr_push_svcctl_ServiceState(struct ndr_push *ndr, int ndr_flags, enum svcctl_ServiceState r)
+{
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_svcctl_ServiceState(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ServiceState *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_svcctl_ServiceState(struct ndr_print *ndr, const char *name, enum svcctl_ServiceState r)
+{
+       const char *val = NULL;
+
+       switch (r) {
+               case SERVICE_STATE_ACTIVE: val = "SERVICE_STATE_ACTIVE"; break;
+               case SERVICE_STATE_INACTIVE: val = "SERVICE_STATE_INACTIVE"; break;
+               case SERVICE_STATE_ALL: val = "SERVICE_STATE_ALL"; break;
+       }
+       ndr_print_enum(ndr, name, "ENUM", val, r);
+}
+
 static enum ndr_err_code ndr_push_svcctl_MgrAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 {
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
@@ -385,46 +727,47 @@ _PUBLIC_ void ndr_print_svcctl_ServiceAccessMask(struct ndr_print *ndr, const ch
 _PUBLIC_ enum ndr_err_code ndr_push_QUERY_SERVICE_CONFIG(struct ndr_push *ndr, int ndr_flags, const struct QUERY_SERVICE_CONFIG *r)
 {
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_align(ndr, 5));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->error_control));
+               NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->start_type));
+               NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->error_control));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->executablepath));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->loadordergroup));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->tag_id));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependencies));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->startname));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->displayname));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->executablepath) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->executablepath, ndr_charset_length(r->executablepath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->loadordergroup) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->loadordergroup, ndr_charset_length(r->loadordergroup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->dependencies) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dependencies, ndr_charset_length(r->dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->startname) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->startname, ndr_charset_length(r->startname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                if (r->displayname) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->displayname, ndr_charset_length(r->displayname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -444,10 +787,10 @@ _PUBLIC_ enum ndr_err_code ndr_pull_QUERY_SERVICE_CONFIG(struct ndr_pull *ndr, i
        uint32_t _ptr_displayname;
        TALLOC_CTX *_mem_save_displayname_0;
        if (ndr_flags & NDR_SCALARS) {
-               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_align(ndr, 5));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->error_control));
+               NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->start_type));
+               NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->error_control));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_executablepath));
                if (_ptr_executablepath) {
                        NDR_PULL_ALLOC(ndr, r->executablepath);
@@ -479,6 +822,7 @@ _PUBLIC_ enum ndr_err_code ndr_pull_QUERY_SERVICE_CONFIG(struct ndr_pull *ndr, i
                } else {
                        r->displayname = NULL;
                }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
        }
        if (ndr_flags & NDR_BUFFERS) {
                if (r->executablepath) {
@@ -505,102 +849,550 @@ _PUBLIC_ enum ndr_err_code ndr_pull_QUERY_SERVICE_CONFIG(struct ndr_pull *ndr, i
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->loadordergroup, ndr_get_array_length(ndr, &r->loadordergroup), sizeof(uint16_t), CH_UTF16));
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_loadordergroup_0, 0);
                }
-               if (r->dependencies) {
-                       _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
-                       NDR_PULL_SET_MEM_CTX(ndr, r->dependencies, 0);
-                       NDR_CHECK(ndr_pull_array_size(ndr, &r->dependencies));
-                       NDR_CHECK(ndr_pull_array_length(ndr, &r->dependencies));
-                       if (ndr_get_array_length(ndr, &r->dependencies) > ndr_get_array_size(ndr, &r->dependencies)) {
-                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dependencies), ndr_get_array_length(ndr, &r->dependencies));
+               if (r->dependencies) {
+                       _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->dependencies, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->dependencies));
+                       NDR_CHECK(ndr_pull_array_length(ndr, &r->dependencies));
+                       if (ndr_get_array_length(ndr, &r->dependencies) > ndr_get_array_size(ndr, &r->dependencies)) {
+                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->dependencies), ndr_get_array_length(ndr, &r->dependencies));
+                       }
+                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dependencies), sizeof(uint16_t)));
+                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dependencies, ndr_get_array_length(ndr, &r->dependencies), sizeof(uint16_t), CH_UTF16));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
+               }
+               if (r->startname) {
+                       _mem_save_startname_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->startname, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->startname));
+                       NDR_CHECK(ndr_pull_array_length(ndr, &r->startname));
+                       if (ndr_get_array_length(ndr, &r->startname) > ndr_get_array_size(ndr, &r->startname)) {
+                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->startname), ndr_get_array_length(ndr, &r->startname));
+                       }
+                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->startname), sizeof(uint16_t)));
+                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->startname, ndr_get_array_length(ndr, &r->startname), sizeof(uint16_t), CH_UTF16));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_startname_0, 0);
+               }
+               if (r->displayname) {
+                       _mem_save_displayname_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->displayname, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->displayname));
+                       NDR_CHECK(ndr_pull_array_length(ndr, &r->displayname));
+                       if (ndr_get_array_length(ndr, &r->displayname) > ndr_get_array_size(ndr, &r->displayname)) {
+                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->displayname), ndr_get_array_length(ndr, &r->displayname));
+                       }
+                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->displayname), sizeof(uint16_t)));
+                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->displayname, ndr_get_array_length(ndr, &r->displayname), sizeof(uint16_t), CH_UTF16));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_displayname_0, 0);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_QUERY_SERVICE_CONFIG(struct ndr_print *ndr, const char *name, const struct QUERY_SERVICE_CONFIG *r)
+{
+       ndr_print_struct(ndr, name, "QUERY_SERVICE_CONFIG");
+       ndr->depth++;
+       ndr_print_uint32(ndr, "service_type", r->service_type);
+       ndr_print_svcctl_StartType(ndr, "start_type", r->start_type);
+       ndr_print_svcctl_ErrorControl(ndr, "error_control", r->error_control);
+       ndr_print_ptr(ndr, "executablepath", r->executablepath);
+       ndr->depth++;
+       if (r->executablepath) {
+               ndr_print_string(ndr, "executablepath", r->executablepath);
+       }
+       ndr->depth--;
+       ndr_print_ptr(ndr, "loadordergroup", r->loadordergroup);
+       ndr->depth++;
+       if (r->loadordergroup) {
+               ndr_print_string(ndr, "loadordergroup", r->loadordergroup);
+       }
+       ndr->depth--;
+       ndr_print_uint32(ndr, "tag_id", r->tag_id);
+       ndr_print_ptr(ndr, "dependencies", r->dependencies);
+       ndr->depth++;
+       if (r->dependencies) {
+               ndr_print_string(ndr, "dependencies", r->dependencies);
+       }
+       ndr->depth--;
+       ndr_print_ptr(ndr, "startname", r->startname);
+       ndr->depth++;
+       if (r->startname) {
+               ndr_print_string(ndr, "startname", r->startname);
+       }
+       ndr->depth--;
+       ndr_print_ptr(ndr, "displayname", r->displayname);
+       ndr->depth++;
+       if (r->displayname) {
+               ndr_print_string(ndr, "displayname", r->displayname);
+       }
+       ndr->depth--;
+       ndr->depth--;
+}
+
+_PUBLIC_ size_t ndr_size_QUERY_SERVICE_CONFIG(const struct QUERY_SERVICE_CONFIG *r, struct smb_iconv_convenience *ic, int flags)
+{
+       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_QUERY_SERVICE_CONFIG, ic);
+}
+
+static enum ndr_err_code ndr_push_svcctl_ArgumentString(struct ndr_push *ndr, int ndr_flags, const struct svcctl_ArgumentString *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->string) {
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string, CH_UTF16)));
+                       NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, ndr_charset_length(r->string, CH_UTF16), sizeof(uint16_t), CH_UTF16));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_svcctl_ArgumentString(struct ndr_pull *ndr, int ndr_flags, struct svcctl_ArgumentString *r)
+{
+       uint32_t _ptr_string;
+       TALLOC_CTX *_mem_save_string_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
+               if (_ptr_string) {
+                       NDR_PULL_ALLOC(ndr, r->string);
+               } else {
+                       r->string = NULL;
+               }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               if (r->string) {
+                       _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
+                       NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
+                       if (ndr_get_array_length(ndr, &r->string) > ndr_get_array_size(ndr, &r->string)) {
+                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string), ndr_get_array_length(ndr, &r->string));
+                       }
+                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t)));
+                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_length(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_svcctl_ArgumentString(struct ndr_print *ndr, const char *name, const struct svcctl_ArgumentString *r)
+{
+       ndr_print_struct(ndr, name, "svcctl_ArgumentString");
+       ndr->depth++;
+       ndr_print_ptr(ndr, "string", r->string);
+       ndr->depth++;
+       if (r->string) {
+               ndr_print_string(ndr, "string", r->string);
+       }
+       ndr->depth--;
+       ndr->depth--;
+}
+
+static enum ndr_err_code ndr_push_svcctl_ConfigLevel(struct ndr_push *ndr, int ndr_flags, enum svcctl_ConfigLevel r)
+{
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_svcctl_ConfigLevel(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ConfigLevel *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_svcctl_ConfigLevel(struct ndr_print *ndr, const char *name, enum svcctl_ConfigLevel r)
+{
+       const char *val = NULL;
+
+       switch (r) {
+               case SERVICE_CONFIG_DESCRIPTION: val = "SERVICE_CONFIG_DESCRIPTION"; break;
+               case SERVICE_CONFIG_FAILURE_ACTIONS: val = "SERVICE_CONFIG_FAILURE_ACTIONS"; break;
+       }
+       ndr_print_enum(ndr, name, "ENUM", val, r);
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_SERVICE_DESCRIPTION(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_DESCRIPTION *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
+                       ndr->flags = _flags_save_string;
+               }
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->description) {
+                               NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
+                               NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
+                               NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_DESCRIPTION(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_DESCRIPTION *r)
+{
+       uint32_t _ptr_description;
+       TALLOC_CTX *_mem_save_description_0;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
+                       if (_ptr_description) {
+                               NDR_PULL_ALLOC(ndr, r->description);
+                               NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
+                       } else {
+                               r->description = NULL;
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->description) {
+                               uint32_t _relative_save_offset;
+                               _relative_save_offset = ndr->offset;
+                               NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
+                               _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                               NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
+                               NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
+                               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
+                               if (ndr->offset > ndr->relative_highest_offset) {
+                                       ndr->relative_highest_offset = ndr->offset;
+                               }
+                               ndr->offset = _relative_save_offset;
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_SERVICE_DESCRIPTION(struct ndr_print *ndr, const char *name, const struct SERVICE_DESCRIPTION *r)
+{
+       ndr_print_struct(ndr, name, "SERVICE_DESCRIPTION");
+       ndr->depth++;
+       ndr_print_ptr(ndr, "description", r->description);
+       ndr->depth++;
+       if (r->description) {
+               ndr_print_string(ndr, "description", r->description);
+       }
+       ndr->depth--;
+       ndr->depth--;
+}
+
+_PUBLIC_ size_t ndr_size_SERVICE_DESCRIPTION(const struct SERVICE_DESCRIPTION *r, struct smb_iconv_convenience *ic, int flags)
+{
+       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_SERVICE_DESCRIPTION, ic);
+}
+
+static enum ndr_err_code ndr_push_SC_ACTION_TYPE(struct ndr_push *ndr, int ndr_flags, enum SC_ACTION_TYPE r)
+{
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_SC_ACTION_TYPE(struct ndr_pull *ndr, int ndr_flags, enum SC_ACTION_TYPE *r)
+{
+       uint32_t v;
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
+       *r = v;
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_SC_ACTION_TYPE(struct ndr_print *ndr, const char *name, enum SC_ACTION_TYPE r)
+{
+       const char *val = NULL;
+
+       switch (r) {
+               case SC_ACTION_NONE: val = "SC_ACTION_NONE"; break;
+               case SC_ACTION_RESTART: val = "SC_ACTION_RESTART"; break;
+               case SC_ACTION_REBOOT: val = "SC_ACTION_REBOOT"; break;
+               case SC_ACTION_RUN_COMMAND: val = "SC_ACTION_RUN_COMMAND"; break;
+       }
+       ndr_print_enum(ndr, name, "ENUM", val, r);
+}
+
+static enum ndr_err_code ndr_push_SC_ACTION(struct ndr_push *ndr, int ndr_flags, const struct SC_ACTION *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 4));
+               NDR_CHECK(ndr_push_SC_ACTION_TYPE(ndr, NDR_SCALARS, r->type));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->delay));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+static enum ndr_err_code ndr_pull_SC_ACTION(struct ndr_pull *ndr, int ndr_flags, struct SC_ACTION *r)
+{
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 4));
+               NDR_CHECK(ndr_pull_SC_ACTION_TYPE(ndr, NDR_SCALARS, &r->type));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->delay));
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_SC_ACTION(struct ndr_print *ndr, const char *name, const struct SC_ACTION *r)
+{
+       ndr_print_struct(ndr, name, "SC_ACTION");
+       ndr->depth++;
+       ndr_print_SC_ACTION_TYPE(ndr, "type", r->type);
+       ndr_print_uint32(ndr, "delay", r->delay);
+       ndr->depth--;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_SERVICE_FAILURE_ACTIONS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_FAILURE_ACTIONS *r)
+{
+       uint32_t cntr_actions_1;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_push_align(ndr, 5));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reset_period));
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_push_relative_ptr1(ndr, r->rebootmsg));
+                       ndr->flags = _flags_save_string;
+               }
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_push_relative_ptr1(ndr, r->command));
+                       ndr->flags = _flags_save_string;
+               }
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_actions));
+               NDR_CHECK(ndr_push_relative_ptr1(ndr, r->actions));
+               NDR_CHECK(ndr_push_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->rebootmsg) {
+                               NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->rebootmsg));
+                               NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->rebootmsg));
+                               NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->rebootmsg));
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->command) {
+                               NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->command));
+                               NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->command));
+                               NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->command));
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+               if (r->actions) {
+                       NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->actions));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_actions));
+                       for (cntr_actions_1 = 0; cntr_actions_1 < r->num_actions; cntr_actions_1++) {
+                               NDR_CHECK(ndr_push_SC_ACTION(ndr, NDR_SCALARS, &r->actions[cntr_actions_1]));
+                       }
+                       NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->actions));
+               }
+       }
+       return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_FAILURE_ACTIONS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_FAILURE_ACTIONS *r)
+{
+       uint32_t _ptr_rebootmsg;
+       TALLOC_CTX *_mem_save_rebootmsg_0;
+       uint32_t _ptr_command;
+       TALLOC_CTX *_mem_save_command_0;
+       uint32_t _ptr_actions;
+       uint32_t cntr_actions_1;
+       TALLOC_CTX *_mem_save_actions_0;
+       TALLOC_CTX *_mem_save_actions_1;
+       if (ndr_flags & NDR_SCALARS) {
+               NDR_CHECK(ndr_pull_align(ndr, 5));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reset_period));
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rebootmsg));
+                       if (_ptr_rebootmsg) {
+                               NDR_PULL_ALLOC(ndr, r->rebootmsg);
+                               NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->rebootmsg, _ptr_rebootmsg));
+                       } else {
+                               r->rebootmsg = NULL;
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_command));
+                       if (_ptr_command) {
+                               NDR_PULL_ALLOC(ndr, r->command);
+                               NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->command, _ptr_command));
+                       } else {
+                               r->command = NULL;
+                       }
+                       ndr->flags = _flags_save_string;
+               }
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_actions));
+               if (r->num_actions > 1024) {
+                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
+               }
+               NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_actions));
+               if (_ptr_actions) {
+                       NDR_PULL_ALLOC(ndr, r->actions);
+                       NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->actions, _ptr_actions));
+               } else {
+                       r->actions = NULL;
+               }
+               NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
+       }
+       if (ndr_flags & NDR_BUFFERS) {
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->rebootmsg) {
+                               uint32_t _relative_save_offset;
+                               _relative_save_offset = ndr->offset;
+                               NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->rebootmsg));
+                               _mem_save_rebootmsg_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                               NDR_PULL_SET_MEM_CTX(ndr, r->rebootmsg, 0);
+                               NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->rebootmsg));
+                               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rebootmsg_0, 0);
+                               if (ndr->offset > ndr->relative_highest_offset) {
+                                       ndr->relative_highest_offset = ndr->offset;
+                               }
+                               ndr->offset = _relative_save_offset;
                        }
-                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dependencies), sizeof(uint16_t)));
-                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dependencies, ndr_get_array_length(ndr, &r->dependencies), sizeof(uint16_t), CH_UTF16));
-                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
+                       ndr->flags = _flags_save_string;
                }
-               if (r->startname) {
-                       _mem_save_startname_0 = NDR_PULL_GET_MEM_CTX(ndr);
-                       NDR_PULL_SET_MEM_CTX(ndr, r->startname, 0);
-                       NDR_CHECK(ndr_pull_array_size(ndr, &r->startname));
-                       NDR_CHECK(ndr_pull_array_length(ndr, &r->startname));
-                       if (ndr_get_array_length(ndr, &r->startname) > ndr_get_array_size(ndr, &r->startname)) {
-                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->startname), ndr_get_array_length(ndr, &r->startname));
+               {
+                       uint32_t _flags_save_string = ndr->flags;
+                       ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
+                       if (r->command) {
+                               uint32_t _relative_save_offset;
+                               _relative_save_offset = ndr->offset;
+                               NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->command));
+                               _mem_save_command_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                               NDR_PULL_SET_MEM_CTX(ndr, r->command, 0);
+                               NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->command));
+                               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_command_0, 0);
+                               if (ndr->offset > ndr->relative_highest_offset) {
+                                       ndr->relative_highest_offset = ndr->offset;
+                               }
+                               ndr->offset = _relative_save_offset;
                        }
-                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->startname), sizeof(uint16_t)));
-                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->startname, ndr_get_array_length(ndr, &r->startname), sizeof(uint16_t), CH_UTF16));
-                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_startname_0, 0);
+                       ndr->flags = _flags_save_string;
                }
-               if (r->displayname) {
-                       _mem_save_displayname_0 = NDR_PULL_GET_MEM_CTX(ndr);
-                       NDR_PULL_SET_MEM_CTX(ndr, r->displayname, 0);
-                       NDR_CHECK(ndr_pull_array_size(ndr, &r->displayname));
-                       NDR_CHECK(ndr_pull_array_length(ndr, &r->displayname));
-                       if (ndr_get_array_length(ndr, &r->displayname) > ndr_get_array_size(ndr, &r->displayname)) {
-                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->displayname), ndr_get_array_length(ndr, &r->displayname));
+               if (r->actions) {
+                       uint32_t _relative_save_offset;
+                       _relative_save_offset = ndr->offset;
+                       NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->actions));
+                       _mem_save_actions_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->actions, 0);
+                       NDR_CHECK(ndr_pull_array_size(ndr, &r->actions));
+                       NDR_PULL_ALLOC_N(ndr, r->actions, ndr_get_array_size(ndr, &r->actions));
+                       _mem_save_actions_1 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->actions, 0);
+                       for (cntr_actions_1 = 0; cntr_actions_1 < r->num_actions; cntr_actions_1++) {
+                               NDR_CHECK(ndr_pull_SC_ACTION(ndr, NDR_SCALARS, &r->actions[cntr_actions_1]));
                        }
-                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->displayname), sizeof(uint16_t)));
-                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->displayname, ndr_get_array_length(ndr, &r->displayname), sizeof(uint16_t), CH_UTF16));
-                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_displayname_0, 0);
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actions_1, 0);
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actions_0, 0);
+                       if (ndr->offset > ndr->relative_highest_offset) {
+                               ndr->relative_highest_offset = ndr->offset;
+                       }
+                       ndr->offset = _relative_save_offset;
+               }
+               if (r->actions) {
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->actions, r->num_actions));
                }
        }
        return NDR_ERR_SUCCESS;
 }
 
-_PUBLIC_ void ndr_print_QUERY_SERVICE_CONFIG(struct ndr_print *ndr, const char *name, const struct QUERY_SERVICE_CONFIG *r)
+_PUBLIC_ void ndr_print_SERVICE_FAILURE_ACTIONS(struct ndr_print *ndr, const char *name, const struct SERVICE_FAILURE_ACTIONS *r)
 {
-       ndr_print_struct(ndr, name, "QUERY_SERVICE_CONFIG");
+       uint32_t cntr_actions_1;
+       ndr_print_struct(ndr, name, "SERVICE_FAILURE_ACTIONS");
        ndr->depth++;
-       ndr_print_uint32(ndr, "service_type", r->service_type);
-       ndr_print_uint32(ndr, "start_type", r->start_type);
-       ndr_print_uint32(ndr, "error_control", r->error_control);
-       ndr_print_ptr(ndr, "executablepath", r->executablepath);
-       ndr->depth++;
-       if (r->executablepath) {
-               ndr_print_string(ndr, "executablepath", r->executablepath);
-       }
-       ndr->depth--;
-       ndr_print_ptr(ndr, "loadordergroup", r->loadordergroup);
+       ndr_print_uint32(ndr, "reset_period", r->reset_period);
+       ndr_print_ptr(ndr, "rebootmsg", r->rebootmsg);
        ndr->depth++;
-       if (r->loadordergroup) {
-               ndr_print_string(ndr, "loadordergroup", r->loadordergroup);
-       }
-       ndr->depth--;
-       ndr_print_uint32(ndr, "tag_id", r->tag_id);
-       ndr_print_ptr(ndr, "dependencies", r->dependencies);
-       ndr->depth++;
-       if (r->dependencies) {
-               ndr_print_string(ndr, "dependencies", r->dependencies);
+       if (r->rebootmsg) {
+               ndr_print_string(ndr, "rebootmsg", r->rebootmsg);
        }
        ndr->depth--;
-       ndr_print_ptr(ndr, "startname", r->startname);
+       ndr_print_ptr(ndr, "command", r->command);
        ndr->depth++;
-       if (r->startname) {
-               ndr_print_string(ndr, "startname", r->startname);
+       if (r->command) {
+               ndr_print_string(ndr, "command", r->command);
        }
        ndr->depth--;
-       ndr_print_ptr(ndr, "displayname", r->displayname);
+       ndr_print_uint32(ndr, "num_actions", r->num_actions);
+       ndr_print_ptr(ndr, "actions", r->actions);
        ndr->depth++;
-       if (r->displayname) {
-               ndr_print_string(ndr, "displayname", r->displayname);
+       if (r->actions) {
+               ndr->print(ndr, "%s: ARRAY(%d)", "actions", (int)r->num_actions);
+               ndr->depth++;
+               for (cntr_actions_1=0;cntr_actions_1<r->num_actions;cntr_actions_1++) {
+                       char *idx_1=NULL;
+                       if (asprintf(&idx_1, "[%d]", cntr_actions_1) != -1) {
+                               ndr_print_SC_ACTION(ndr, "actions", &r->actions[cntr_actions_1]);
+                               free(idx_1);
+                       }
+               }
+               ndr->depth--;
        }
        ndr->depth--;
        ndr->depth--;
 }
 
-_PUBLIC_ size_t ndr_size_QUERY_SERVICE_CONFIG(const struct QUERY_SERVICE_CONFIG *r, struct smb_iconv_convenience *ic, int flags)
+_PUBLIC_ size_t ndr_size_SERVICE_FAILURE_ACTIONS(const struct SERVICE_FAILURE_ACTIONS *r, struct smb_iconv_convenience *ic, int flags)
 {
-       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_QUERY_SERVICE_CONFIG, ic);
+       return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_SERVICE_FAILURE_ACTIONS, ic);
 }
 
 static enum ndr_err_code ndr_push_svcctl_StatusLevel(struct ndr_push *ndr, int ndr_flags, enum svcctl_StatusLevel r)
 {
-       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
+       NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
        return NDR_ERR_SUCCESS;
 }
 
 static enum ndr_err_code ndr_pull_svcctl_StatusLevel(struct ndr_pull *ndr, int ndr_flags, enum svcctl_StatusLevel *r)
 {
        uint32_t v;
-       NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+       NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
        *r = v;
        return NDR_ERR_SUCCESS;
 }
@@ -912,15 +1704,15 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceObjectSecurity(struct ndr_p
                        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.security_flags));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buffer_size));
+               NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.security_flags));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        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.buffer_size));
-               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buffer_size));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
                if (r->out.needed == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
@@ -944,13 +1736,13 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceObjectSecurity(struct ndr_p
                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.security_flags));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buffer_size));
-               if (r->in.buffer_size < 0 || r->in.buffer_size > 0x40000) {
+               NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.security_flags));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               if (r->in.offered > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
-               NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.buffer_size);
-               memset(CONST_DISCARD(struct svcctl_QueryServiceObjectSecurity *,r->out.buffer), 0, (r->in.buffer_size) * sizeof(*r->out.buffer));
+               NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
+               memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
                NDR_PULL_ALLOC(ndr, r->out.needed);
                ZERO_STRUCTP(r->out.needed);
        }
@@ -966,13 +1758,13 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceObjectSecurity(struct ndr_p
                _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
                NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
-               if (*r->out.needed < 0 || *r->out.needed > 0x40000) {
+               if (*r->out.needed > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
                if (r->out.buffer) {
-                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.buffer_size));
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
                }
        }
        return NDR_ERR_SUCCESS;
@@ -992,8 +1784,8 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceObjectSecurity(struct ndr_print *ndr,
                ndr->depth++;
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
-               ndr_print_uint32(ndr, "security_flags", r->in.security_flags);
-               ndr_print_uint32(ndr, "buffer_size", r->in.buffer_size);
+               ndr_print_security_secinfo(ndr, "security_flags", r->in.security_flags);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -1001,7 +1793,7 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceObjectSecurity(struct ndr_print *ndr,
                ndr->depth++;
                ndr_print_ptr(ndr, "buffer", r->out.buffer);
                ndr->depth++;
-               ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.buffer_size);
+               ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
                ndr->depth--;
                ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
@@ -1020,13 +1812,13 @@ static enum ndr_err_code ndr_push_svcctl_SetServiceObjectSecurity(struct ndr_pus
                        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.security_flags));
+               NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.security_flags));
                if (r->in.buffer == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buffer_size));
-               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.buffer_size));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buffer_size));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
@@ -1045,15 +1837,15 @@ static enum ndr_err_code ndr_pull_svcctl_SetServiceObjectSecurity(struct ndr_pul
                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.security_flags));
+               NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.security_flags));
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
                        NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
                }
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buffer_size));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
                if (r->in.buffer) {
-                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.buffer_size));
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
                }
        }
        if (flags & NDR_OUT) {
@@ -1076,12 +1868,12 @@ _PUBLIC_ void ndr_print_svcctl_SetServiceObjectSecurity(struct ndr_print *ndr, c
                ndr->depth++;
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
-               ndr_print_uint32(ndr, "security_flags", r->in.security_flags);
+               ndr_print_security_secinfo(ndr, "security_flags", r->in.security_flags);
                ndr_print_ptr(ndr, "buffer", r->in.buffer);
                ndr->depth++;
-               ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.buffer_size);
+               ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
                ndr->depth--;
-               ndr_print_uint32(ndr, "buffer_size", r->in.buffer_size);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -1402,48 +2194,48 @@ static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfigW(struct ndr_push *n
                }
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.error));
+               NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
+               NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
                if (r->in.binary_path) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.load_order_group));
                if (r->in.load_order_group) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.load_order_group, ndr_charset_length(r->in.load_order_group, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
                if (r->in.dependencies) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
                if (r->in.service_start_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
                if (r->in.password) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name));
                if (r->in.display_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.display_name, ndr_charset_length(r->in.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -1484,8 +2276,8 @@ static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfigW(struct ndr_pull *n
                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.type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.error));
+               NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
+               NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
                if (_ptr_binary_path) {
                        NDR_PULL_ALLOC(ndr, r->in.binary_path);
@@ -1625,8 +2417,8 @@ _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigW(struct ndr_print *ndr, const
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
                ndr_print_uint32(ndr, "type", r->in.type);
-               ndr_print_uint32(ndr, "start", r->in.start);
-               ndr_print_uint32(ndr, "error", r->in.error);
+               ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
+               ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
                ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
                ndr->depth++;
                if (r->in.binary_path) {
@@ -1685,30 +2477,30 @@ static enum ndr_err_code ndr_push_svcctl_CreateServiceW(struct ndr_push *ndr, in
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DisplayName));
                if (r->in.DisplayName) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.desired_access));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.error_control));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
+               NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
+               NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.LoadOrderGroupKey));
                if (r->in.LoadOrderGroupKey) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.TagId));
@@ -1717,20 +2509,20 @@ static enum ndr_err_code ndr_push_svcctl_CreateServiceW(struct ndr_push *ndr, in
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
                if (r->in.dependencies) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dependencies_size));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.dependencies_size));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.dependencies, r->in.dependencies_size));
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dependencies_size));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
                if (r->in.service_start_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
                if (r->in.password) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.password_size));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.password_size));
                        NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.password, r->in.password_size));
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.password_size));
@@ -1802,8 +2594,8 @@ static enum ndr_err_code ndr_pull_svcctl_CreateServiceW(struct ndr_pull *ndr, in
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.desired_access));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.error_control));
+               NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
+               NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
                NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
                NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
                if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {
@@ -1946,8 +2738,8 @@ _PUBLIC_ void ndr_print_svcctl_CreateServiceW(struct ndr_print *ndr, const char
                ndr->depth--;
                ndr_print_uint32(ndr, "desired_access", r->in.desired_access);
                ndr_print_uint32(ndr, "type", r->in.type);
-               ndr_print_uint32(ndr, "start_type", r->in.start_type);
-               ndr_print_uint32(ndr, "error_control", r->in.error_control);
+               ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
+               ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
                ndr_print_string(ndr, "binary_path", r->in.binary_path);
                ndr_print_ptr(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
                ndr->depth++;
@@ -2009,19 +2801,19 @@ static enum ndr_err_code ndr_push_svcctl_EnumDependentServicesW(struct ndr_push
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.service));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        if (flags & NDR_OUT) {
                if (r->out.service_status == 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.service_status, r->in.buf_size));
-               if (r->out.bytes_needed == NULL) {
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service_status, r->in.offered));
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                if (r->out.services_returned == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
@@ -2034,7 +2826,7 @@ static enum ndr_err_code ndr_push_svcctl_EnumDependentServicesW(struct ndr_push
 static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesW(struct ndr_pull *ndr, int flags, struct svcctl_EnumDependentServicesW *r)
 {
        TALLOC_CTX *_mem_save_service_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        TALLOC_CTX *_mem_save_services_returned_0;
        if (flags & NDR_IN) {
                ZERO_STRUCT(r->out);
@@ -2046,15 +2838,15 @@ static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesW(struct ndr_pull
                NDR_PULL_SET_MEM_CTX(ndr, r->in.service, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.service));
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
-               if (r->in.buf_size < 0 || r->in.buf_size > 0x40000) {
+               NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               if (r->in.offered > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
-               NDR_PULL_ALLOC_N(ndr, r->out.service_status, r->in.buf_size);
-               memset(CONST_DISCARD(struct svcctl_EnumDependentServicesW *,r->out.service_status), 0, (r->in.buf_size) * sizeof(*r->out.service_status));
-               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
-               ZERO_STRUCTP(r->out.bytes_needed);
+               NDR_PULL_ALLOC_N(ndr, r->out.service_status, r->in.offered);
+               memset(r->out.service_status, 0, (r->in.offered) * sizeof(*r->out.service_status));
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
                NDR_PULL_ALLOC(ndr, r->out.services_returned);
                ZERO_STRUCTP(r->out.services_returned);
        }
@@ -2065,28 +2857,28 @@ static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesW(struct ndr_pull
                }
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service_status, ndr_get_array_size(ndr, &r->out.service_status)));
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+                       NDR_PULL_ALLOC(ndr, r->out.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));
-               if (*r->out.bytes_needed < 0 || *r->out.bytes_needed > 0x40000) {
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               if (*r->out.needed > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
-               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
                        NDR_PULL_ALLOC(ndr, r->out.services_returned);
                }
                _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
                NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
-               if (*r->out.services_returned < 0 || *r->out.services_returned > 0x40000) {
+               if (*r->out.services_returned > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
                if (r->out.service_status) {
-                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service_status, r->in.buf_size));
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service_status, r->in.offered));
                }
        }
        return NDR_ERR_SUCCESS;
@@ -2106,8 +2898,8 @@ _PUBLIC_ void ndr_print_svcctl_EnumDependentServicesW(struct ndr_print *ndr, con
                ndr->depth++;
                ndr_print_policy_handle(ndr, "service", r->in.service);
                ndr->depth--;
-               ndr_print_uint32(ndr, "state", r->in.state);
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -2115,11 +2907,11 @@ _PUBLIC_ void ndr_print_svcctl_EnumDependentServicesW(struct ndr_print *ndr, con
                ndr->depth++;
                ndr_print_ptr(ndr, "service_status", r->out.service_status);
                ndr->depth++;
-               ndr_print_array_uint8(ndr, "service_status", r->out.service_status, r->in.buf_size);
+               ndr_print_array_uint8(ndr, "service_status", r->out.service_status, r->in.offered);
                ndr->depth--;
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
                ndr->depth++;
@@ -2139,8 +2931,8 @@ static enum ndr_err_code ndr_push_svcctl_EnumServicesStatusW(struct ndr_push *nd
                }
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
                if (r->in.resume_handle) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
@@ -2150,12 +2942,12 @@ static enum ndr_err_code ndr_push_svcctl_EnumServicesStatusW(struct ndr_push *nd
                if (r->out.service == 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.service, r->in.buf_size));
-               if (r->out.bytes_needed == NULL) {
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.offered));
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                if (r->out.services_returned == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
@@ -2173,7 +2965,7 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusW(struct ndr_pull *nd
 {
        uint32_t _ptr_resume_handle;
        TALLOC_CTX *_mem_save_handle_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        TALLOC_CTX *_mem_save_services_returned_0;
        TALLOC_CTX *_mem_save_resume_handle_0;
        if (flags & NDR_IN) {
@@ -2187,9 +2979,9 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusW(struct ndr_pull *nd
                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.type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
-               if (r->in.buf_size < 0 || r->in.buf_size > 262144) {
+               NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               if (r->in.offered > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
@@ -2204,10 +2996,10 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusW(struct ndr_pull *nd
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
                }
-               NDR_PULL_ALLOC_N(ndr, r->out.service, r->in.buf_size);
-               memset(CONST_DISCARD(struct svcctl_EnumServicesStatusW *,r->out.service), 0, (r->in.buf_size) * sizeof(*r->out.service));
-               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
-               ZERO_STRUCTP(r->out.bytes_needed);
+               NDR_PULL_ALLOC_N(ndr, r->out.service, r->in.offered);
+               memset(r->out.service, 0, (r->in.offered) * sizeof(*r->out.service));
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
                NDR_PULL_ALLOC(ndr, r->out.services_returned);
                ZERO_STRUCTP(r->out.services_returned);
        }
@@ -2218,22 +3010,22 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusW(struct ndr_pull *nd
                }
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, ndr_get_array_size(ndr, &r->out.service)));
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+                       NDR_PULL_ALLOC(ndr, r->out.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));
-               if (*r->out.bytes_needed < 0 || *r->out.bytes_needed > 262144) {
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               if (*r->out.needed > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
-               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
                        NDR_PULL_ALLOC(ndr, r->out.services_returned);
                }
                _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
                NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
-               if (*r->out.services_returned < 0 || *r->out.services_returned > 262144) {
+               if (*r->out.services_returned > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
@@ -2251,7 +3043,7 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusW(struct ndr_pull *nd
                }
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
                if (r->out.service) {
-                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.buf_size));
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.offered));
                }
        }
        return NDR_ERR_SUCCESS;
@@ -2272,8 +3064,8 @@ _PUBLIC_ void ndr_print_svcctl_EnumServicesStatusW(struct ndr_print *ndr, const
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
                ndr_print_uint32(ndr, "type", r->in.type);
-               ndr_print_uint32(ndr, "state", r->in.state);
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
                ndr->depth++;
                if (r->in.resume_handle) {
@@ -2287,11 +3079,11 @@ _PUBLIC_ void ndr_print_svcctl_EnumServicesStatusW(struct ndr_print *ndr, const
                ndr->depth++;
                ndr_print_ptr(ndr, "service", r->out.service);
                ndr->depth++;
-               ndr_print_array_uint8(ndr, "service", r->out.service, r->in.buf_size);
+               ndr_print_array_uint8(ndr, "service", r->out.service, r->in.offered);
                ndr->depth--;
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
                ndr->depth++;
@@ -2314,16 +3106,16 @@ static enum ndr_err_code ndr_push_svcctl_OpenSCManagerW(struct ndr_push *ndr, in
        if (flags & NDR_IN) {
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.MachineName));
                if (r->in.MachineName) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DatabaseName));
                if (r->in.DatabaseName) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_svcctl_MgrAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
@@ -2446,9 +3238,9 @@ static enum ndr_err_code ndr_push_svcctl_OpenServiceW(struct ndr_push *ndr, int
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
                NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                NDR_CHECK(ndr_push_svcctl_ServiceAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
        }
@@ -2538,17 +3330,17 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceConfigW(struct ndr_push *nd
                        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.buf_size));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        if (flags & NDR_OUT) {
                if (r->out.query == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
                NDR_CHECK(ndr_push_QUERY_SERVICE_CONFIG(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.query));
-               if (r->out.bytes_needed == NULL) {
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -2558,7 +3350,7 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigW(struct ndr_pull *nd
 {
        TALLOC_CTX *_mem_save_handle_0;
        TALLOC_CTX *_mem_save_query_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        if (flags & NDR_IN) {
                ZERO_STRUCT(r->out);
 
@@ -2569,14 +3361,14 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigW(struct ndr_pull *nd
                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.buf_size));
-               if (r->in.buf_size < 0 || r->in.buf_size > 8192) {
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               if (r->in.offered > 8192) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_PULL_ALLOC(ndr, r->out.query);
                ZERO_STRUCTP(r->out.query);
-               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
-               ZERO_STRUCTP(r->out.bytes_needed);
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
        }
        if (flags & NDR_OUT) {
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
@@ -2587,15 +3379,15 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigW(struct ndr_pull *nd
                NDR_CHECK(ndr_pull_QUERY_SERVICE_CONFIG(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.query));
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_query_0, LIBNDR_FLAG_REF_ALLOC);
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+                       NDR_PULL_ALLOC(ndr, r->out.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));
-               if (*r->out.bytes_needed < 0 || *r->out.bytes_needed > 8192) {
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               if (*r->out.needed > 8192) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
-               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -2615,7 +3407,7 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceConfigW(struct ndr_print *ndr, const
                ndr->depth++;
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -2625,9 +3417,9 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceConfigW(struct ndr_print *ndr, const
                ndr->depth++;
                ndr_print_QUERY_SERVICE_CONFIG(ndr, "query", r->out.query);
                ndr->depth--;
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -2642,17 +3434,17 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceLockStatusW(struct ndr_push
                        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.buf_size));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        if (flags & NDR_OUT) {
                if (r->out.lock_status == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
                NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
-               if (r->out.required_buf_size == NULL) {
+               if (r->out.needed == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required_buf_size));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -2662,7 +3454,7 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusW(struct ndr_pull
 {
        TALLOC_CTX *_mem_save_handle_0;
        TALLOC_CTX *_mem_save_lock_status_0;
-       TALLOC_CTX *_mem_save_required_buf_size_0;
+       TALLOC_CTX *_mem_save_needed_0;
        if (flags & NDR_IN) {
                ZERO_STRUCT(r->out);
 
@@ -2673,11 +3465,11 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusW(struct ndr_pull
                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.buf_size));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
                NDR_PULL_ALLOC(ndr, r->out.lock_status);
                ZERO_STRUCTP(r->out.lock_status);
-               NDR_PULL_ALLOC(ndr, r->out.required_buf_size);
-               ZERO_STRUCTP(r->out.required_buf_size);
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
        }
        if (flags & NDR_OUT) {
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
@@ -2688,12 +3480,12 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusW(struct ndr_pull
                NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.required_buf_size);
+                       NDR_PULL_ALLOC(ndr, r->out.needed);
                }
-               _mem_save_required_buf_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
-               NDR_PULL_SET_MEM_CTX(ndr, r->out.required_buf_size, LIBNDR_FLAG_REF_ALLOC);
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required_buf_size));
-               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_buf_size_0, LIBNDR_FLAG_REF_ALLOC);
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -2713,7 +3505,7 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusW(struct ndr_print *ndr, co
                ndr->depth++;
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -2723,9 +3515,9 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusW(struct ndr_print *ndr, co
                ndr->depth++;
                ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);
                ndr->depth--;
-               ndr_print_ptr(ndr, "required_buf_size", r->out.required_buf_size);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "required_buf_size", *r->out.required_buf_size);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -2735,6 +3527,7 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusW(struct ndr_print *ndr, co
 
 static enum ndr_err_code ndr_push_svcctl_StartServiceW(struct ndr_push *ndr, int flags, const struct svcctl_StartServiceW *r)
 {
+       uint32_t cntr_Arguments_1;
        if (flags & NDR_IN) {
                if (r->in.handle == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
@@ -2743,10 +3536,13 @@ static enum ndr_err_code ndr_push_svcctl_StartServiceW(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));
                if (r->in.Arguments) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
-                       NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Arguments, ndr_charset_length(r->in.Arguments, CH_UTF16), sizeof(uint16_t), CH_UTF16));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.NumArgs));
+                       for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
+                               NDR_CHECK(ndr_push_svcctl_ArgumentString(ndr, NDR_SCALARS, &r->in.Arguments[cntr_Arguments_1]));
+                       }
+                       for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
+                               NDR_CHECK(ndr_push_svcctl_ArgumentString(ndr, NDR_BUFFERS, &r->in.Arguments[cntr_Arguments_1]));
+                       }
                }
        }
        if (flags & NDR_OUT) {
@@ -2758,8 +3554,10 @@ static enum ndr_err_code ndr_push_svcctl_StartServiceW(struct ndr_push *ndr, int
 static enum ndr_err_code ndr_pull_svcctl_StartServiceW(struct ndr_pull *ndr, int flags, struct svcctl_StartServiceW *r)
 {
        uint32_t _ptr_Arguments;
+       uint32_t cntr_Arguments_1;
        TALLOC_CTX *_mem_save_handle_0;
        TALLOC_CTX *_mem_save_Arguments_0;
+       TALLOC_CTX *_mem_save_Arguments_1;
        if (flags & NDR_IN) {
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
                        NDR_PULL_ALLOC(ndr, r->in.handle);
@@ -2769,6 +3567,9 @@ static enum ndr_err_code ndr_pull_svcctl_StartServiceW(struct ndr_pull *ndr, int
                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.NumArgs));
+               if (r->in.NumArgs > SC_MAX_ARGUMENTS) {
+                       return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
+               }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Arguments));
                if (_ptr_Arguments) {
                        NDR_PULL_ALLOC(ndr, r->in.Arguments);
@@ -2779,14 +3580,21 @@ static enum ndr_err_code ndr_pull_svcctl_StartServiceW(struct ndr_pull *ndr, int
                        _mem_save_Arguments_0 = NDR_PULL_GET_MEM_CTX(ndr);
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
                        NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Arguments));
-                       NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Arguments));
-                       if (ndr_get_array_length(ndr, &r->in.Arguments) > ndr_get_array_size(ndr, &r->in.Arguments)) {
-                               return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.Arguments), ndr_get_array_length(ndr, &r->in.Arguments));
+                       NDR_PULL_ALLOC_N(ndr, r->in.Arguments, ndr_get_array_size(ndr, &r->in.Arguments));
+                       _mem_save_Arguments_1 = NDR_PULL_GET_MEM_CTX(ndr);
+                       NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
+                       for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
+                               NDR_CHECK(ndr_pull_svcctl_ArgumentString(ndr, NDR_SCALARS, &r->in.Arguments[cntr_Arguments_1]));
                        }
-                       NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t)));
-                       NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Arguments, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t), CH_UTF16));
+                       for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
+                               NDR_CHECK(ndr_pull_svcctl_ArgumentString(ndr, NDR_BUFFERS, &r->in.Arguments[cntr_Arguments_1]));
+                       }
+                       NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_1, 0);
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_0, 0);
                }
+               if (r->in.Arguments) {
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.Arguments, r->in.NumArgs));
+               }
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
@@ -2796,6 +3604,7 @@ static enum ndr_err_code ndr_pull_svcctl_StartServiceW(struct ndr_pull *ndr, int
 
 _PUBLIC_ void ndr_print_svcctl_StartServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_StartServiceW *r)
 {
+       uint32_t cntr_Arguments_1;
        ndr_print_struct(ndr, name, "svcctl_StartServiceW");
        ndr->depth++;
        if (flags & NDR_SET_VALUES) {
@@ -2812,7 +3621,16 @@ _PUBLIC_ void ndr_print_svcctl_StartServiceW(struct ndr_print *ndr, const char *
                ndr_print_ptr(ndr, "Arguments", r->in.Arguments);
                ndr->depth++;
                if (r->in.Arguments) {
-                       ndr_print_string(ndr, "Arguments", r->in.Arguments);
+                       ndr->print(ndr, "%s: ARRAY(%d)", "Arguments", (int)r->in.NumArgs);
+                       ndr->depth++;
+                       for (cntr_Arguments_1=0;cntr_Arguments_1<r->in.NumArgs;cntr_Arguments_1++) {
+                               char *idx_1=NULL;
+                               if (asprintf(&idx_1, "[%d]", cntr_Arguments_1) != -1) {
+                                       ndr_print_svcctl_ArgumentString(ndr, "Arguments", &r->in.Arguments[cntr_Arguments_1]);
+                                       free(idx_1);
+                               }
+                       }
+                       ndr->depth--;
                }
                ndr->depth--;
                ndr->depth--;
@@ -2835,9 +3653,9 @@ static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameW(struct ndr_push
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
                if (r->in.service_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
@@ -2851,9 +3669,9 @@ static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameW(struct ndr_push
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.display_name));
                if (*r->out.display_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.display_name, ndr_charset_length(*r->out.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
@@ -3021,9 +3839,9 @@ static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameW(struct ndr_push *ndr
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
                if (r->in.service_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
@@ -3037,9 +3855,9 @@ static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameW(struct ndr_push *ndr
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_name));
                if (*r->out.key_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.key_name, ndr_charset_length(*r->out.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
@@ -3272,48 +4090,48 @@ static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfigA(struct ndr_push *n
                }
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.error));
+               NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
+               NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
                if (r->in.binary_path) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.load_order_group));
                if (r->in.load_order_group) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.load_order_group, ndr_charset_length(r->in.load_order_group, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
                if (r->in.dependencies) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
                if (r->in.service_start_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
                if (r->in.password) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name));
                if (r->in.display_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.display_name, ndr_charset_length(r->in.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -3354,8 +4172,8 @@ static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfigA(struct ndr_pull *n
                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.type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.error));
+               NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
+               NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
                if (_ptr_binary_path) {
                        NDR_PULL_ALLOC(ndr, r->in.binary_path);
@@ -3495,8 +4313,8 @@ _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigA(struct ndr_print *ndr, const
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
                ndr_print_uint32(ndr, "type", r->in.type);
-               ndr_print_uint32(ndr, "start", r->in.start);
-               ndr_print_uint32(ndr, "error", r->in.error);
+               ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
+               ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
                ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
                ndr->depth++;
                if (r->in.binary_path) {
@@ -3557,55 +4375,55 @@ static enum ndr_err_code ndr_push_svcctl_CreateServiceA(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));
                if (r->in.ServiceName) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DisplayName));
                if (r->in.DisplayName) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.desired_access));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.error_control));
+               NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
+               NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
                if (r->in.binary_path) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.binary_path, ndr_charset_length(r->in.binary_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.LoadOrderGroupKey));
                if (r->in.LoadOrderGroupKey) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
                if (r->in.dependencies) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
                if (r->in.service_start_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_start_name, ndr_charset_length(r->in.service_start_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
                if (r->in.password) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -3686,8 +4504,8 @@ static enum ndr_err_code ndr_pull_svcctl_CreateServiceA(struct ndr_pull *ndr, in
                }
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.desired_access));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.error_control));
+               NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
+               NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
                if (_ptr_binary_path) {
                        NDR_PULL_ALLOC(ndr, r->in.binary_path);
@@ -3825,8 +4643,8 @@ _PUBLIC_ void ndr_print_svcctl_CreateServiceA(struct ndr_print *ndr, const char
                ndr->depth--;
                ndr_print_uint32(ndr, "desired_access", r->in.desired_access);
                ndr_print_uint32(ndr, "type", r->in.type);
-               ndr_print_uint32(ndr, "start_type", r->in.start_type);
-               ndr_print_uint32(ndr, "error_control", r->in.error_control);
+               ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
+               ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
                ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
                ndr->depth++;
                if (r->in.binary_path) {
@@ -3881,18 +4699,18 @@ static enum ndr_err_code ndr_push_svcctl_EnumDependentServicesA(struct ndr_push
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.service));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.service_status));
                if (r->out.service_status) {
-                       NDR_CHECK(ndr_push_ENUM_SERVICE_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
+                       NDR_CHECK(ndr_push_ENUM_SERVICE_STATUSA(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
                }
-               if (r->out.bytes_needed == NULL) {
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                if (r->out.services_returned == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
@@ -3907,7 +4725,7 @@ static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesA(struct ndr_pull
        uint32_t _ptr_service_status;
        TALLOC_CTX *_mem_save_service_0;
        TALLOC_CTX *_mem_save_service_status_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        TALLOC_CTX *_mem_save_services_returned_0;
        if (flags & NDR_IN) {
                ZERO_STRUCT(r->out);
@@ -3919,10 +4737,10 @@ static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesA(struct ndr_pull
                NDR_PULL_SET_MEM_CTX(ndr, r->in.service, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.service));
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
-               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
-               ZERO_STRUCTP(r->out.bytes_needed);
+               NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
                NDR_PULL_ALLOC(ndr, r->out.services_returned);
                ZERO_STRUCTP(r->out.services_returned);
        }
@@ -3936,16 +4754,16 @@ static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesA(struct ndr_pull
                if (r->out.service_status) {
                        _mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, 0);
-                       NDR_CHECK(ndr_pull_ENUM_SERVICE_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
+                       NDR_CHECK(ndr_pull_ENUM_SERVICE_STATUSA(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, 0);
                }
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+                       NDR_PULL_ALLOC(ndr, r->out.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);
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
                        NDR_PULL_ALLOC(ndr, r->out.services_returned);
                }
@@ -3972,8 +4790,8 @@ _PUBLIC_ void ndr_print_svcctl_EnumDependentServicesA(struct ndr_print *ndr, con
                ndr->depth++;
                ndr_print_policy_handle(ndr, "service", r->in.service);
                ndr->depth--;
-               ndr_print_uint32(ndr, "state", r->in.state);
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -3982,12 +4800,12 @@ _PUBLIC_ void ndr_print_svcctl_EnumDependentServicesA(struct ndr_print *ndr, con
                ndr_print_ptr(ndr, "service_status", r->out.service_status);
                ndr->depth++;
                if (r->out.service_status) {
-                       ndr_print_ENUM_SERVICE_STATUS(ndr, "service_status", r->out.service_status);
+                       ndr_print_ENUM_SERVICE_STATUSA(ndr, "service_status", r->out.service_status);
                }
                ndr->depth--;
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
                ndr->depth++;
@@ -4007,20 +4825,20 @@ static enum ndr_err_code ndr_push_svcctl_EnumServicesStatusA(struct ndr_push *nd
                }
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
                if (r->in.resume_handle) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
                }
        }
        if (flags & NDR_OUT) {
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
-               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.buf_size));
-               if (r->out.bytes_needed == NULL) {
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.offered));
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                if (r->out.services_returned == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
@@ -4038,7 +4856,7 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusA(struct ndr_pull *nd
 {
        uint32_t _ptr_resume_handle;
        TALLOC_CTX *_mem_save_handle_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        TALLOC_CTX *_mem_save_services_returned_0;
        TALLOC_CTX *_mem_save_resume_handle_0;
        if (flags & NDR_IN) {
@@ -4052,8 +4870,8 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusA(struct ndr_pull *nd
                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.type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
+               NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
                if (_ptr_resume_handle) {
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
@@ -4066,8 +4884,8 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusA(struct ndr_pull *nd
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
                }
-               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
-               ZERO_STRUCTP(r->out.bytes_needed);
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
                NDR_PULL_ALLOC(ndr, r->out.services_returned);
                ZERO_STRUCTP(r->out.services_returned);
        }
@@ -4076,12 +4894,12 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusA(struct ndr_pull *nd
                NDR_PULL_ALLOC_N(ndr, r->out.service, ndr_get_array_size(ndr, &r->out.service));
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, ndr_get_array_size(ndr, &r->out.service)));
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+                       NDR_PULL_ALLOC(ndr, r->out.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);
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
                        NDR_PULL_ALLOC(ndr, r->out.services_returned);
                }
@@ -4103,7 +4921,7 @@ static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusA(struct ndr_pull *nd
                }
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
                if (r->out.service) {
-                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.buf_size));
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.offered));
                }
        }
        return NDR_ERR_SUCCESS;
@@ -4124,8 +4942,8 @@ _PUBLIC_ void ndr_print_svcctl_EnumServicesStatusA(struct ndr_print *ndr, const
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
                ndr_print_uint32(ndr, "type", r->in.type);
-               ndr_print_uint32(ndr, "state", r->in.state);
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
                ndr->depth++;
                if (r->in.resume_handle) {
@@ -4137,10 +4955,10 @@ _PUBLIC_ void ndr_print_svcctl_EnumServicesStatusA(struct ndr_print *ndr, const
        if (flags & NDR_OUT) {
                ndr_print_struct(ndr, "out", "svcctl_EnumServicesStatusA");
                ndr->depth++;
-               ndr_print_array_uint8(ndr, "service", r->out.service, r->in.buf_size);
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_array_uint8(ndr, "service", r->out.service, r->in.offered);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
                ndr->depth++;
@@ -4163,16 +4981,16 @@ static enum ndr_err_code ndr_push_svcctl_OpenSCManagerA(struct ndr_push *ndr, in
        if (flags & NDR_IN) {
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.MachineName));
                if (r->in.MachineName) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DatabaseName));
                if (r->in.DatabaseName) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
@@ -4297,9 +5115,9 @@ static enum ndr_err_code ndr_push_svcctl_OpenServiceA(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));
                if (r->in.ServiceName) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
@@ -4388,14 +5206,14 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceConfigA(struct ndr_push *nd
                        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.buf_size));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        if (flags & NDR_OUT) {
-               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.buf_size));
-               if (r->out.bytes_needed == NULL) {
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.offered));
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -4404,7 +5222,7 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceConfigA(struct ndr_push *nd
 static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigA(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfigA *r)
 {
        TALLOC_CTX *_mem_save_handle_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        if (flags & NDR_IN) {
                ZERO_STRUCT(r->out);
 
@@ -4415,20 +5233,20 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigA(struct ndr_pull *nd
                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.buf_size));
-               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
-               ZERO_STRUCTP(r->out.bytes_needed);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
        }
        if (flags & NDR_OUT) {
-               NDR_PULL_ALLOC_N(ndr, r->out.query, r->in.buf_size);
-               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.buf_size));
+               NDR_PULL_ALLOC_N(ndr, r->out.query, r->in.offered);
+               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.offered));
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+                       NDR_PULL_ALLOC(ndr, r->out.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);
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -4448,16 +5266,16 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceConfigA(struct ndr_print *ndr, const
                ndr->depth++;
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
                ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfigA");
                ndr->depth++;
-               ndr_print_array_uint8(ndr, "query", r->out.query, r->in.buf_size);
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_array_uint8(ndr, "query", r->out.query, r->in.offered);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -4472,17 +5290,17 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceLockStatusA(struct ndr_push
                        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.buf_size));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        if (flags & NDR_OUT) {
                if (r->out.lock_status == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
                NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
-               if (r->out.required_buf_size == NULL) {
+               if (r->out.needed == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required_buf_size));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -4492,7 +5310,7 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusA(struct ndr_pull
 {
        TALLOC_CTX *_mem_save_handle_0;
        TALLOC_CTX *_mem_save_lock_status_0;
-       TALLOC_CTX *_mem_save_required_buf_size_0;
+       TALLOC_CTX *_mem_save_needed_0;
        if (flags & NDR_IN) {
                ZERO_STRUCT(r->out);
 
@@ -4503,11 +5321,11 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusA(struct ndr_pull
                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.buf_size));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
                NDR_PULL_ALLOC(ndr, r->out.lock_status);
                ZERO_STRUCTP(r->out.lock_status);
-               NDR_PULL_ALLOC(ndr, r->out.required_buf_size);
-               ZERO_STRUCTP(r->out.required_buf_size);
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
        }
        if (flags & NDR_OUT) {
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
@@ -4518,12 +5336,12 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusA(struct ndr_pull
                NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.required_buf_size);
+                       NDR_PULL_ALLOC(ndr, r->out.needed);
                }
-               _mem_save_required_buf_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
-               NDR_PULL_SET_MEM_CTX(ndr, r->out.required_buf_size, LIBNDR_FLAG_REF_ALLOC);
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required_buf_size));
-               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_buf_size_0, LIBNDR_FLAG_REF_ALLOC);
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -4543,7 +5361,7 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusA(struct ndr_print *ndr, co
                ndr->depth++;
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -4553,9 +5371,9 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusA(struct ndr_print *ndr, co
                ndr->depth++;
                ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);
                ndr->depth--;
-               ndr_print_ptr(ndr, "required_buf_size", r->out.required_buf_size);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "required_buf_size", *r->out.required_buf_size);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -4573,9 +5391,9 @@ static enum ndr_err_code ndr_push_svcctl_StartServiceA(struct ndr_push *ndr, int
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));
                if (r->in.Arguments) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Arguments, ndr_charset_length(r->in.Arguments, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -4665,9 +5483,9 @@ static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameA(struct ndr_push
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
                if (r->in.service_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
@@ -4681,9 +5499,9 @@ static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameA(struct ndr_push
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.display_name));
                if (*r->out.display_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.display_name, ndr_charset_length(*r->out.display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
@@ -4851,9 +5669,9 @@ static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameA(struct ndr_push *ndr
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
                if (r->in.service_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.service_name, ndr_charset_length(r->in.service_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
@@ -4867,9 +5685,9 @@ static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameA(struct ndr_push *ndr
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_name));
                if (*r->out.key_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.key_name, ndr_charset_length(*r->out.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
@@ -5285,15 +6103,15 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2A(struct ndr_push *n
                        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.info_level));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_svcctl_ConfigLevel(ndr, NDR_SCALARS, r->in.info_level));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        if (flags & NDR_OUT) {
-               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
-               if (r->out.bytes_needed == NULL) {
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -5302,7 +6120,7 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2A(struct ndr_push *n
 static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2A(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2A *r)
 {
        TALLOC_CTX *_mem_save_handle_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        if (flags & NDR_IN) {
                ZERO_STRUCT(r->out);
 
@@ -5313,21 +6131,21 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2A(struct ndr_pull *n
                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.info_level));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
-               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
-               ZERO_STRUCTP(r->out.bytes_needed);
+               NDR_CHECK(ndr_pull_svcctl_ConfigLevel(ndr, NDR_SCALARS, &r->in.info_level));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
        }
        if (flags & NDR_OUT) {
-               NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.buf_size);
-               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
+               NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
+               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+                       NDR_PULL_ALLOC(ndr, r->out.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);
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -5347,17 +6165,17 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2A(struct ndr_print *ndr, const
                ndr->depth++;
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
-               ndr_print_uint32(ndr, "info_level", r->in.info_level);
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_svcctl_ConfigLevel(ndr, "info_level", r->in.info_level);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
                ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfig2A");
                ndr->depth++;
-               ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.buf_size);
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -5372,19 +6190,19 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2W(struct ndr_push *n
                        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.info_level));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_svcctl_ConfigLevel(ndr, NDR_SCALARS, r->in.info_level));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        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) {
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -5393,7 +6211,7 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2W(struct ndr_push *n
 static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2W(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2W *r)
 {
        TALLOC_CTX *_mem_save_handle_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        if (flags & NDR_IN) {
                ZERO_STRUCT(r->out);
 
@@ -5404,15 +6222,15 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2W(struct ndr_pull *n
                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.info_level));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
-               if (r->in.buf_size < 0 || r->in.buf_size > 8192) {
+               NDR_CHECK(ndr_pull_svcctl_ConfigLevel(ndr, NDR_SCALARS, &r->in.info_level));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               if (r->in.offered > 8192) {
                        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 svcctl_QueryServiceConfig2W *,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);
+               NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
+               memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
@@ -5421,18 +6239,18 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2W(struct ndr_pull *n
                }
                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);
+                       NDR_PULL_ALLOC(ndr, r->out.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));
-               if (*r->out.bytes_needed < 0 || *r->out.bytes_needed > 8192) {
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               if (*r->out.needed > 8192) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
-               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_WERROR(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));
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5452,8 +6270,8 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2W(struct ndr_print *ndr, const
                ndr->depth++;
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
-               ndr_print_uint32(ndr, "info_level", r->in.info_level);
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_svcctl_ConfigLevel(ndr, "info_level", r->in.info_level);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -5461,11 +6279,11 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2W(struct ndr_print *ndr, const
                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_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
                ndr->depth--;
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -5481,18 +6299,18 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceStatusEx(struct ndr_push *n
                }
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
                NDR_CHECK(ndr_push_svcctl_StatusLevel(ndr, NDR_SCALARS, r->in.info_level));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
        }
        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) {
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
        }
        return NDR_ERR_SUCCESS;
@@ -5501,7 +6319,7 @@ static enum ndr_err_code ndr_push_svcctl_QueryServiceStatusEx(struct ndr_push *n
 static enum ndr_err_code ndr_pull_svcctl_QueryServiceStatusEx(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceStatusEx *r)
 {
        TALLOC_CTX *_mem_save_handle_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        if (flags & NDR_IN) {
                ZERO_STRUCT(r->out);
 
@@ -5513,14 +6331,14 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceStatusEx(struct ndr_pull *n
                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_svcctl_StatusLevel(ndr, NDR_SCALARS, &r->in.info_level));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
-               if (r->in.buf_size < 0 || r->in.buf_size > 8192) {
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               if (r->in.offered > 8192) {
                        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 svcctl_QueryServiceStatusEx *,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);
+               NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
+               memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
        }
        if (flags & NDR_OUT) {
                NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
@@ -5529,18 +6347,18 @@ static enum ndr_err_code ndr_pull_svcctl_QueryServiceStatusEx(struct ndr_pull *n
                }
                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);
+                       NDR_PULL_ALLOC(ndr, r->out.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));
-               if (*r->out.bytes_needed < 0 || *r->out.bytes_needed > 8192) {
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               if (*r->out.needed > 8192) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
-               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_WERROR(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));
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5561,7 +6379,7 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceStatusEx(struct ndr_print *ndr, const
                ndr_print_policy_handle(ndr, "handle", r->in.handle);
                ndr->depth--;
                ndr_print_svcctl_StatusLevel(ndr, "info_level", r->in.info_level);
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr->depth--;
        }
        if (flags & NDR_OUT) {
@@ -5569,11 +6387,11 @@ _PUBLIC_ void ndr_print_svcctl_QueryServiceStatusEx(struct ndr_print *ndr, const
                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_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
                ndr->depth--;
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_WERROR(ndr, "result", r->out.result);
                ndr->depth--;
@@ -5590,19 +6408,19 @@ static enum ndr_err_code ndr_push_EnumServicesStatusExA(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
                if (r->in.resume_handle) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
                }
        }
        if (flags & NDR_OUT) {
-               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.buf_size));
-               if (r->out.bytes_needed == NULL) {
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                if (r->out.service_returned == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
@@ -5616,9 +6434,9 @@ static enum ndr_err_code ndr_push_EnumServicesStatusExA(struct ndr_push *ndr, in
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.group_name));
                if (*r->out.group_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, *r->out.group_name, ndr_charset_length(*r->out.group_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
                NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
@@ -5631,7 +6449,7 @@ static enum ndr_err_code ndr_pull_EnumServicesStatusExA(struct ndr_pull *ndr, in
        uint32_t _ptr_resume_handle;
        uint32_t _ptr_group_name;
        TALLOC_CTX *_mem_save_scmanager_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        TALLOC_CTX *_mem_save_service_returned_0;
        TALLOC_CTX *_mem_save_resume_handle_0;
        TALLOC_CTX *_mem_save_group_name_0;
@@ -5648,8 +6466,8 @@ static enum ndr_err_code ndr_pull_EnumServicesStatusExA(struct ndr_pull *ndr, in
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
+               NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
                if (_ptr_resume_handle) {
                        NDR_PULL_ALLOC(ndr, r->in.resume_handle);
@@ -5662,23 +6480,23 @@ static enum ndr_err_code ndr_pull_EnumServicesStatusExA(struct ndr_pull *ndr, in
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
                }
-               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
-               ZERO_STRUCTP(r->out.bytes_needed);
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
                NDR_PULL_ALLOC(ndr, r->out.service_returned);
                ZERO_STRUCTP(r->out.service_returned);
                NDR_PULL_ALLOC(ndr, r->out.group_name);
                ZERO_STRUCTP(r->out.group_name);
        }
        if (flags & NDR_OUT) {
-               NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.buf_size);
-               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.buf_size));
+               NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.offered);
+               NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+                       NDR_PULL_ALLOC(ndr, r->out.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);
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
                        NDR_PULL_ALLOC(ndr, r->out.service_returned);
                }
@@ -5743,8 +6561,8 @@ _PUBLIC_ void ndr_print_EnumServicesStatusExA(struct ndr_print *ndr, const char
                ndr->depth--;
                ndr_print_uint32(ndr, "info_level", r->in.info_level);
                ndr_print_uint32(ndr, "type", r->in.type);
-               ndr_print_uint32(ndr, "state", r->in.state);
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
                ndr->depth++;
                if (r->in.resume_handle) {
@@ -5756,10 +6574,10 @@ _PUBLIC_ void ndr_print_EnumServicesStatusExA(struct ndr_print *ndr, const char
        if (flags & NDR_OUT) {
                ndr_print_struct(ndr, "out", "EnumServicesStatusExA");
                ndr->depth++;
-               ndr_print_array_uint8(ndr, "services", r->out.services, r->in.buf_size);
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_array_uint8(ndr, "services", r->out.services, r->in.offered);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_ptr(ndr, "service_returned", r->out.service_returned);
                ndr->depth++;
@@ -5795,17 +6613,17 @@ static enum ndr_err_code ndr_push_EnumServicesStatusExW(struct ndr_push *ndr, in
                NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
-               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
+               NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
+               NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
                if (r->in.resume_handle) {
                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
                }
                NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.group_name));
                if (r->in.group_name) {
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
-                       NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
+                       NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));
                        NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.group_name, ndr_charset_length(r->in.group_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
                }
        }
@@ -5813,12 +6631,12 @@ static enum ndr_err_code ndr_push_EnumServicesStatusExW(struct ndr_push *ndr, in
                if (r->out.services == 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.services, r->in.buf_size));
-               if (r->out.bytes_needed == NULL) {
+               NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
+               NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));
+               if (r->out.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_uint32(ndr, NDR_SCALARS, *r->out.needed));
                if (r->out.service_returned == NULL) {
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
                }
@@ -5837,7 +6655,7 @@ static enum ndr_err_code ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, in
        uint32_t _ptr_resume_handle;
        uint32_t _ptr_group_name;
        TALLOC_CTX *_mem_save_scmanager_0;
-       TALLOC_CTX *_mem_save_bytes_needed_0;
+       TALLOC_CTX *_mem_save_needed_0;
        TALLOC_CTX *_mem_save_service_returned_0;
        TALLOC_CTX *_mem_save_resume_handle_0;
        TALLOC_CTX *_mem_save_group_name_0;
@@ -5853,9 +6671,9 @@ static enum ndr_err_code ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, in
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
-               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
-               if (r->in.buf_size < 0 || r->in.buf_size > 262144) {
+               NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
+               if (r->in.offered > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
@@ -5868,7 +6686,7 @@ static enum ndr_err_code ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, in
                        _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
                        NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
-                       if (*r->in.resume_handle < 0 || *r->in.resume_handle > 262144) {
+                       if (*r->in.resume_handle > 0x40000) {
                                return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                        }
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
@@ -5891,10 +6709,10 @@ static enum ndr_err_code ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, in
                        NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.group_name, ndr_get_array_length(ndr, &r->in.group_name), sizeof(uint16_t), CH_UTF16));
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_0, 0);
                }
-               NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.buf_size);
-               memset(CONST_DISCARD(struct EnumServicesStatusExW *,r->out.services), 0, (r->in.buf_size) * sizeof(*r->out.services));
-               NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
-               ZERO_STRUCTP(r->out.bytes_needed);
+               NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.offered);
+               memset(r->out.services, 0, (r->in.offered) * sizeof(*r->out.services));
+               NDR_PULL_ALLOC(ndr, r->out.needed);
+               ZERO_STRUCTP(r->out.needed);
                NDR_PULL_ALLOC(ndr, r->out.service_returned);
                ZERO_STRUCTP(r->out.service_returned);
        }
@@ -5905,22 +6723,22 @@ static enum ndr_err_code ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, in
                }
                NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, ndr_get_array_size(ndr, &r->out.services)));
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
-                       NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
+                       NDR_PULL_ALLOC(ndr, r->out.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));
-               if (*r->out.bytes_needed < 0 || *r->out.bytes_needed > 262144) {
+               _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
+               NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
+               NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
+               if (*r->out.needed > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
-               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
+               NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
                        NDR_PULL_ALLOC(ndr, r->out.service_returned);
                }
                _mem_save_service_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
                NDR_PULL_SET_MEM_CTX(ndr, r->out.service_returned, LIBNDR_FLAG_REF_ALLOC);
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.service_returned));
-               if (*r->out.service_returned < 0 || *r->out.service_returned > 262144) {
+               if (*r->out.service_returned > 0x40000) {
                        return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                }
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_returned_0, LIBNDR_FLAG_REF_ALLOC);
@@ -5934,14 +6752,14 @@ static enum ndr_err_code ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, in
                        _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
-                       if (*r->out.resume_handle < 0 || *r->out.resume_handle > 262144) {
+                       if (*r->out.resume_handle > 0x40000) {
                                return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                        }
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
                }
                NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
                if (r->out.services) {
-                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.services, r->in.buf_size));
+                       NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.services, r->in.offered));
                }
        }
        return NDR_ERR_SUCCESS;
@@ -5963,8 +6781,8 @@ _PUBLIC_ void ndr_print_EnumServicesStatusExW(struct ndr_print *ndr, const char
                ndr->depth--;
                ndr_print_uint32(ndr, "info_level", r->in.info_level);
                ndr_print_uint32(ndr, "type", r->in.type);
-               ndr_print_uint32(ndr, "state", r->in.state);
-               ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
+               ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
+               ndr_print_uint32(ndr, "offered", r->in.offered);
                ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
                ndr->depth++;
                if (r->in.resume_handle) {
@@ -5984,11 +6802,11 @@ _PUBLIC_ void ndr_print_EnumServicesStatusExW(struct ndr_print *ndr, const char
                ndr->depth++;
                ndr_print_ptr(ndr, "services", r->out.services);
                ndr->depth++;
-               ndr_print_array_uint8(ndr, "services", r->out.services, r->in.buf_size);
+               ndr_print_array_uint8(ndr, "services", r->out.services, r->in.offered);
                ndr->depth--;
-               ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
+               ndr_print_ptr(ndr, "needed", r->out.needed);
                ndr->depth++;
-               ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
+               ndr_print_uint32(ndr, "needed", *r->out.needed);
                ndr->depth--;
                ndr_print_ptr(ndr, "service_returned", r->out.service_returned);
                ndr->depth++;