bin.gen_ndr/default/librpc/gen_ndr/ndr_svcctl.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "bin/default/librpc/gen_ndr/ndr_svcctl.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 static enum ndr_err_code ndr_push_SERVICE_LOCK_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_LOCK_STATUS *r)
   9 {
  10         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 5));
  13                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_locked));
  14                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lock_owner));
  15                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_duration));
  16                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  17         }
  18         if (ndr_flags & NDR_BUFFERS) {
  19                 if (r->lock_owner) {
  20                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
  21                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
  22                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
  23                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lock_owner, ndr_charset_length(r->lock_owner, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  24                 }
  25         }
  26         return NDR_ERR_SUCCESS;
  27 }
  28
  29 static enum ndr_err_code ndr_pull_SERVICE_LOCK_STATUS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_LOCK_STATUS *r)
  30 {
  31         uint32_t _ptr_lock_owner;
  32         uint32_t size_lock_owner_1 = 0;
  33         uint32_t length_lock_owner_1 = 0;
  34         TALLOC_CTX *_mem_save_lock_owner_0;
  35         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  36         if (ndr_flags & NDR_SCALARS) {
  37                 NDR_CHECK(ndr_pull_align(ndr, 5));
  38                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_locked));
  39                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lock_owner));
  40                 if (_ptr_lock_owner) {
  41                         NDR_PULL_ALLOC(ndr, r->lock_owner);
  42                 } else {
  43                         r->lock_owner = NULL;
  44                 }
  45                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_duration));
  46                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  47         }
  48         if (ndr_flags & NDR_BUFFERS) {
  49                 if (r->lock_owner) {
  50                         _mem_save_lock_owner_0 = NDR_PULL_GET_MEM_CTX(ndr);
  51                         NDR_PULL_SET_MEM_CTX(ndr, r->lock_owner, 0);
  52                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lock_owner));
  53                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lock_owner));
  54                         size_lock_owner_1 = ndr_get_array_size(ndr, &r->lock_owner);
  55                         length_lock_owner_1 = ndr_get_array_length(ndr, &r->lock_owner);
  56                         if (length_lock_owner_1 > size_lock_owner_1) {
  57                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_lock_owner_1, length_lock_owner_1);
  58                         }
  59                         NDR_CHECK(ndr_check_string_terminator(ndr, length_lock_owner_1, sizeof(uint16_t)));
  60                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lock_owner, length_lock_owner_1, sizeof(uint16_t), CH_UTF16));
  61                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_owner_0, 0);
  62                 }
  63         }
  64         return NDR_ERR_SUCCESS;
  65 }
  66
  67 _PUBLIC_ void ndr_print_SERVICE_LOCK_STATUS(struct ndr_print *ndr, const char *name, const struct SERVICE_LOCK_STATUS *r)
  68 {
  69         ndr_print_struct(ndr, name, "SERVICE_LOCK_STATUS");
  70         if (r == NULL) { ndr_print_null(ndr); return; }
  71         ndr->depth++;
  72         ndr_print_uint32(ndr, "is_locked", r->is_locked);
  73         ndr_print_ptr(ndr, "lock_owner", r->lock_owner);
  74         ndr->depth++;
  75         if (r->lock_owner) {
  76                 ndr_print_string(ndr, "lock_owner", r->lock_owner);
  77         }
  78         ndr->depth--;
  79         ndr_print_uint32(ndr, "lock_duration", r->lock_duration);
  80         ndr->depth--;
  81 }
  82
  83 static enum ndr_err_code ndr_push_svcctl_ServiceStatus(struct ndr_push *ndr, int ndr_flags, enum svcctl_ServiceStatus r)
  84 {
  85         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
  86         return NDR_ERR_SUCCESS;
  87 }
  88
  89 static enum ndr_err_code ndr_pull_svcctl_ServiceStatus(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ServiceStatus *r)
  90 {
  91         uint32_t v;
  92         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
  93         *r = v;
  94         return NDR_ERR_SUCCESS;
  95 }
  96
  97 _PUBLIC_ void ndr_print_svcctl_ServiceStatus(struct ndr_print *ndr, const char *name, enum svcctl_ServiceStatus r)
  98 {
  99         const char *val = NULL;
 100
 101         switch (r) {
 102                 case SVCCTL_STATE_UNKNOWN: val = "SVCCTL_STATE_UNKNOWN"; break;
 103                 case SVCCTL_STOPPED: val = "SVCCTL_STOPPED"; break;
 104                 case SVCCTL_START_PENDING: val = "SVCCTL_START_PENDING"; break;
 105                 case SVCCTL_STOP_PENDING: val = "SVCCTL_STOP_PENDING"; break;
 106                 case SVCCTL_RUNNING: val = "SVCCTL_RUNNING"; break;
 107                 case SVCCTL_CONTINUE_PENDING: val = "SVCCTL_CONTINUE_PENDING"; break;
 108                 case SVCCTL_PAUSE_PENDING: val = "SVCCTL_PAUSE_PENDING"; break;
 109                 case SVCCTL_PAUSED: val = "SVCCTL_PAUSED"; break;
 110         }
 111         ndr_print_enum(ndr, name, "ENUM", val, r);
 112 }
 113
 114 static enum ndr_err_code ndr_push_svcctl_ControlsAccepted(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 115 {
 116         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 117         return NDR_ERR_SUCCESS;
 118 }
 119
 120 static enum ndr_err_code ndr_pull_svcctl_ControlsAccepted(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 121 {
 122         uint32_t v;
 123         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 124         *r = v;
 125         return NDR_ERR_SUCCESS;
 126 }
 127
 128 _PUBLIC_ void ndr_print_svcctl_ControlsAccepted(struct ndr_print *ndr, const char *name, uint32_t r)
 129 {
 130         ndr_print_uint32(ndr, name, r);
 131         ndr->depth++;
 132         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_STOP", SVCCTL_ACCEPT_STOP, r);
 133         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_PAUSE_CONTINUE", SVCCTL_ACCEPT_PAUSE_CONTINUE, r);
 134         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_SHUTDOWN", SVCCTL_ACCEPT_SHUTDOWN, r);
 135         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_PARAMCHANGE", SVCCTL_ACCEPT_PARAMCHANGE, r);
 136         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_NETBINDCHANGE", SVCCTL_ACCEPT_NETBINDCHANGE, r);
 137         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_HARDWAREPROFILECHANGE", SVCCTL_ACCEPT_HARDWAREPROFILECHANGE, r);
 138         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SVCCTL_ACCEPT_POWEREVENT", SVCCTL_ACCEPT_POWEREVENT, r);
 139         ndr->depth--;
 140 }
 141
 142 static enum ndr_err_code ndr_push_SERVICE_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_STATUS *r)
 143 {
 144         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 145         if (ndr_flags & NDR_SCALARS) {
 146                 NDR_CHECK(ndr_push_align(ndr, 4));
 147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->type));
 148                 NDR_CHECK(ndr_push_svcctl_ServiceStatus(ndr, NDR_SCALARS, r->state));
 149                 NDR_CHECK(ndr_push_svcctl_ControlsAccepted(ndr, NDR_SCALARS, r->controls_accepted));
 150                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->win32_exit_code));
 151                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_exit_code));
 152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->check_point));
 153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wait_hint));
 154                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 155         }
 156         if (ndr_flags & NDR_BUFFERS) {
 157         }
 158         return NDR_ERR_SUCCESS;
 159 }
 160
 161 static enum ndr_err_code ndr_pull_SERVICE_STATUS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_STATUS *r)
 162 {
 163         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 164         if (ndr_flags & NDR_SCALARS) {
 165                 NDR_CHECK(ndr_pull_align(ndr, 4));
 166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->type));
 167                 NDR_CHECK(ndr_pull_svcctl_ServiceStatus(ndr, NDR_SCALARS, &r->state));
 168                 NDR_CHECK(ndr_pull_svcctl_ControlsAccepted(ndr, NDR_SCALARS, &r->controls_accepted));
 169                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->win32_exit_code));
 170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_exit_code));
 171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->check_point));
 172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wait_hint));
 173                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 174         }
 175         if (ndr_flags & NDR_BUFFERS) {
 176         }
 177         return NDR_ERR_SUCCESS;
 178 }
 179
 180 _PUBLIC_ void ndr_print_SERVICE_STATUS(struct ndr_print *ndr, const char *name, const struct SERVICE_STATUS *r)
 181 {
 182         ndr_print_struct(ndr, name, "SERVICE_STATUS");
 183         if (r == NULL) { ndr_print_null(ndr); return; }
 184         ndr->depth++;
 185         ndr_print_uint32(ndr, "type", r->type);
 186         ndr_print_svcctl_ServiceStatus(ndr, "state", r->state);
 187         ndr_print_svcctl_ControlsAccepted(ndr, "controls_accepted", r->controls_accepted);
 188         ndr_print_WERROR(ndr, "win32_exit_code", r->win32_exit_code);
 189         ndr_print_uint32(ndr, "service_exit_code", r->service_exit_code);
 190         ndr_print_uint32(ndr, "check_point", r->check_point);
 191         ndr_print_uint32(ndr, "wait_hint", r->wait_hint);
 192         ndr->depth--;
 193 }
 194
 195 _PUBLIC_ enum ndr_err_code ndr_push_SERVICE_STATUS_PROCESS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_STATUS_PROCESS *r)
 196 {
 197         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 198         if (ndr_flags & NDR_SCALARS) {
 199                 NDR_CHECK(ndr_push_align(ndr, 4));
 200                 NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
 201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->process_id));
 202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_flags));
 203                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 204         }
 205         if (ndr_flags & NDR_BUFFERS) {
 206         }
 207         return NDR_ERR_SUCCESS;
 208 }
 209
 210 _PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_STATUS_PROCESS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_STATUS_PROCESS *r)
 211 {
 212         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 213         if (ndr_flags & NDR_SCALARS) {
 214                 NDR_CHECK(ndr_pull_align(ndr, 4));
 215                 NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
 216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->process_id));
 217                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_flags));
 218                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 219         }
 220         if (ndr_flags & NDR_BUFFERS) {
 221         }
 222         return NDR_ERR_SUCCESS;
 223 }
 224
 225 _PUBLIC_ void ndr_print_SERVICE_STATUS_PROCESS(struct ndr_print *ndr, const char *name, const struct SERVICE_STATUS_PROCESS *r)
 226 {
 227         ndr_print_struct(ndr, name, "SERVICE_STATUS_PROCESS");
 228         if (r == NULL) { ndr_print_null(ndr); return; }
 229         ndr->depth++;
 230         ndr_print_SERVICE_STATUS(ndr, "status", &r->status);
 231         ndr_print_uint32(ndr, "process_id", r->process_id);
 232         ndr_print_uint32(ndr, "service_flags", r->service_flags);
 233         ndr->depth--;
 234 }
 235
 236 _PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSW(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUSW *r)
 237 {
 238         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 239         if (ndr_flags & NDR_SCALARS) {
 240                 NDR_CHECK(ndr_push_align(ndr, 5));
 241                 {
 242                         uint32_t _flags_save_string = ndr->flags;
 243                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 244                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->service_name));
 245                         ndr->flags = _flags_save_string;
 246                 }
 247                 {
 248                         uint32_t _flags_save_string = ndr->flags;
 249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 250                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
 251                         ndr->flags = _flags_save_string;
 252                 }
 253                 NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
 254                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 255         }
 256         if (ndr_flags & NDR_BUFFERS) {
 257                 {
 258                         uint32_t _flags_save_string = ndr->flags;
 259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 260                         if (r->service_name) {
 261                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->service_name));
 262                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->service_name));
 263                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->service_name));
 264                         }
 265                         ndr->flags = _flags_save_string;
 266                 }
 267                 {
 268                         uint32_t _flags_save_string = ndr->flags;
 269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 270                         if (r->display_name) {
 271                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
 272                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
 273                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
 274                         }
 275                         ndr->flags = _flags_save_string;
 276                 }
 277         }
 278         return NDR_ERR_SUCCESS;
 279 }
 280
 281 _PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSW(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUSW *r)
 282 {
 283         uint32_t _ptr_service_name;
 284         TALLOC_CTX *_mem_save_service_name_0;
 285         uint32_t _ptr_display_name;
 286         TALLOC_CTX *_mem_save_display_name_0;
 287         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 288         if (ndr_flags & NDR_SCALARS) {
 289                 NDR_CHECK(ndr_pull_align(ndr, 5));
 290                 {
 291                         uint32_t _flags_save_string = ndr->flags;
 292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 293                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
 294                         if (_ptr_service_name) {
 295                                 NDR_PULL_ALLOC(ndr, r->service_name);
 296                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->service_name, _ptr_service_name));
 297                         } else {
 298                                 r->service_name = NULL;
 299                         }
 300                         ndr->flags = _flags_save_string;
 301                 }
 302                 {
 303                         uint32_t _flags_save_string = ndr->flags;
 304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
 306                         if (_ptr_display_name) {
 307                                 NDR_PULL_ALLOC(ndr, r->display_name);
 308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
 309                         } else {
 310                                 r->display_name = NULL;
 311                         }
 312                         ndr->flags = _flags_save_string;
 313                 }
 314                 NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
 315                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 316         }
 317         if (ndr_flags & NDR_BUFFERS) {
 318                 {
 319                         uint32_t _flags_save_string = ndr->flags;
 320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 321                         if (r->service_name) {
 322                                 uint32_t _relative_save_offset;
 323                                 _relative_save_offset = ndr->offset;
 324                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->service_name));
 325                                 _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 326                                 NDR_PULL_SET_MEM_CTX(ndr, r->service_name, 0);
 327                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->service_name));
 328                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
 329                                 if (ndr->offset > ndr->relative_highest_offset) {
 330                                         ndr->relative_highest_offset = ndr->offset;
 331                                 }
 332                                 ndr->offset = _relative_save_offset;
 333                         }
 334                         ndr->flags = _flags_save_string;
 335                 }
 336                 {
 337                         uint32_t _flags_save_string = ndr->flags;
 338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 339                         if (r->display_name) {
 340                                 uint32_t _relative_save_offset;
 341                                 _relative_save_offset = ndr->offset;
 342                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
 343                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 344                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
 345                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
 346                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
 347                                 if (ndr->offset > ndr->relative_highest_offset) {
 348                                         ndr->relative_highest_offset = ndr->offset;
 349                                 }
 350                                 ndr->offset = _relative_save_offset;
 351                         }
 352                         ndr->flags = _flags_save_string;
 353                 }
 354         }
 355         return NDR_ERR_SUCCESS;
 356 }
 357
 358 _PUBLIC_ void ndr_print_ENUM_SERVICE_STATUSW(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUSW *r)
 359 {
 360         ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUSW");
 361         if (r == NULL) { ndr_print_null(ndr); return; }
 362         ndr->depth++;
 363         ndr_print_ptr(ndr, "service_name", r->service_name);
 364         ndr->depth++;
 365         if (r->service_name) {
 366                 ndr_print_string(ndr, "service_name", r->service_name);
 367         }
 368         ndr->depth--;
 369         ndr_print_ptr(ndr, "display_name", r->display_name);
 370         ndr->depth++;
 371         if (r->display_name) {
 372                 ndr_print_string(ndr, "display_name", r->display_name);
 373         }
 374         ndr->depth--;
 375         ndr_print_SERVICE_STATUS(ndr, "status", &r->status);
 376         ndr->depth--;
 377 }
 378
 379 _PUBLIC_ size_t ndr_size_ENUM_SERVICE_STATUSW(const struct ENUM_SERVICE_STATUSW *r, int flags)
 380 {
 381         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSW);
 382 }
 383
 384 _PUBLIC_ enum ndr_err_code ndr_push_ENUM_SERVICE_STATUSA(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUSA *r)
 385 {
 386         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 387         if (ndr_flags & NDR_SCALARS) {
 388                 NDR_CHECK(ndr_push_align(ndr, 5));
 389                 {
 390                         uint32_t _flags_save_string = ndr->flags;
 391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 392                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->service_name));
 393                         ndr->flags = _flags_save_string;
 394                 }
 395                 {
 396                         uint32_t _flags_save_string = ndr->flags;
 397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 398                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
 399                         ndr->flags = _flags_save_string;
 400                 }
 401                 NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
 402                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 403         }
 404         if (ndr_flags & NDR_BUFFERS) {
 405                 {
 406                         uint32_t _flags_save_string = ndr->flags;
 407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 408                         if (r->service_name) {
 409                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->service_name));
 410                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->service_name));
 411                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->service_name));
 412                         }
 413                         ndr->flags = _flags_save_string;
 414                 }
 415                 {
 416                         uint32_t _flags_save_string = ndr->flags;
 417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 418                         if (r->display_name) {
 419                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
 420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
 421                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
 422                         }
 423                         ndr->flags = _flags_save_string;
 424                 }
 425         }
 426         return NDR_ERR_SUCCESS;
 427 }
 428
 429 _PUBLIC_ enum ndr_err_code ndr_pull_ENUM_SERVICE_STATUSA(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUSA *r)
 430 {
 431         uint32_t _ptr_service_name;
 432         TALLOC_CTX *_mem_save_service_name_0;
 433         uint32_t _ptr_display_name;
 434         TALLOC_CTX *_mem_save_display_name_0;
 435         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 436         if (ndr_flags & NDR_SCALARS) {
 437                 NDR_CHECK(ndr_pull_align(ndr, 5));
 438                 {
 439                         uint32_t _flags_save_string = ndr->flags;
 440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 441                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
 442                         if (_ptr_service_name) {
 443                                 NDR_PULL_ALLOC(ndr, r->service_name);
 444                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->service_name, _ptr_service_name));
 445                         } else {
 446                                 r->service_name = NULL;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 453                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
 454                         if (_ptr_display_name) {
 455                                 NDR_PULL_ALLOC(ndr, r->display_name);
 456                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
 457                         } else {
 458                                 r->display_name = NULL;
 459                         }
 460                         ndr->flags = _flags_save_string;
 461                 }
 462                 NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
 463                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 464         }
 465         if (ndr_flags & NDR_BUFFERS) {
 466                 {
 467                         uint32_t _flags_save_string = ndr->flags;
 468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 469                         if (r->service_name) {
 470                                 uint32_t _relative_save_offset;
 471                                 _relative_save_offset = ndr->offset;
 472                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->service_name));
 473                                 _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 474                                 NDR_PULL_SET_MEM_CTX(ndr, r->service_name, 0);
 475                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->service_name));
 476                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
 477                                 if (ndr->offset > ndr->relative_highest_offset) {
 478                                         ndr->relative_highest_offset = ndr->offset;
 479                                 }
 480                                 ndr->offset = _relative_save_offset;
 481                         }
 482                         ndr->flags = _flags_save_string;
 483                 }
 484                 {
 485                         uint32_t _flags_save_string = ndr->flags;
 486                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 487                         if (r->display_name) {
 488                                 uint32_t _relative_save_offset;
 489                                 _relative_save_offset = ndr->offset;
 490                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
 491                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 492                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
 493                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
 494                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
 495                                 if (ndr->offset > ndr->relative_highest_offset) {
 496                                         ndr->relative_highest_offset = ndr->offset;
 497                                 }
 498                                 ndr->offset = _relative_save_offset;
 499                         }
 500                         ndr->flags = _flags_save_string;
 501                 }
 502         }
 503         return NDR_ERR_SUCCESS;
 504 }
 505
 506 _PUBLIC_ void ndr_print_ENUM_SERVICE_STATUSA(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUSA *r)
 507 {
 508         ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUSA");
 509         if (r == NULL) { ndr_print_null(ndr); return; }
 510         ndr->depth++;
 511         ndr_print_ptr(ndr, "service_name", r->service_name);
 512         ndr->depth++;
 513         if (r->service_name) {
 514                 ndr_print_string(ndr, "service_name", r->service_name);
 515         }
 516         ndr->depth--;
 517         ndr_print_ptr(ndr, "display_name", r->display_name);
 518         ndr->depth++;
 519         if (r->display_name) {
 520                 ndr_print_string(ndr, "display_name", r->display_name);
 521         }
 522         ndr->depth--;
 523         ndr_print_SERVICE_STATUS(ndr, "status", &r->status);
 524         ndr->depth--;
 525 }
 526
 527 _PUBLIC_ size_t ndr_size_ENUM_SERVICE_STATUSA(const struct ENUM_SERVICE_STATUSA *r, int flags)
 528 {
 529         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSA);
 530 }
 531
 532 static enum ndr_err_code ndr_push_SERVICE_CONTROL(struct ndr_push *ndr, int ndr_flags, enum SERVICE_CONTROL r)
 533 {
 534         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 535         return NDR_ERR_SUCCESS;
 536 }
 537
 538 static enum ndr_err_code ndr_pull_SERVICE_CONTROL(struct ndr_pull *ndr, int ndr_flags, enum SERVICE_CONTROL *r)
 539 {
 540         uint32_t v;
 541         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 542         *r = v;
 543         return NDR_ERR_SUCCESS;
 544 }
 545
 546 _PUBLIC_ void ndr_print_SERVICE_CONTROL(struct ndr_print *ndr, const char *name, enum SERVICE_CONTROL r)
 547 {
 548         const char *val = NULL;
 549
 550         switch (r) {
 551                 case SVCCTL_CONTROL_STOP: val = "SVCCTL_CONTROL_STOP"; break;
 552                 case SVCCTL_CONTROL_PAUSE: val = "SVCCTL_CONTROL_PAUSE"; break;
 553                 case SVCCTL_CONTROL_CONTINUE: val = "SVCCTL_CONTROL_CONTINUE"; break;
 554                 case SVCCTL_CONTROL_INTERROGATE: val = "SVCCTL_CONTROL_INTERROGATE"; break;
 555                 case SVCCTL_CONTROL_SHUTDOWN: val = "SVCCTL_CONTROL_SHUTDOWN"; break;
 556         }
 557         ndr_print_enum(ndr, name, "ENUM", val, r);
 558 }
 559
 560 static enum ndr_err_code ndr_push_svcctl_ErrorControl(struct ndr_push *ndr, int ndr_flags, enum svcctl_ErrorControl r)
 561 {
 562         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 563         return NDR_ERR_SUCCESS;
 564 }
 565
 566 static enum ndr_err_code ndr_pull_svcctl_ErrorControl(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ErrorControl *r)
 567 {
 568         uint32_t v;
 569         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 570         *r = v;
 571         return NDR_ERR_SUCCESS;
 572 }
 573
 574 _PUBLIC_ void ndr_print_svcctl_ErrorControl(struct ndr_print *ndr, const char *name, enum svcctl_ErrorControl r)
 575 {
 576         const char *val = NULL;
 577
 578         switch (r) {
 579                 case SVCCTL_SVC_ERROR_IGNORE: val = "SVCCTL_SVC_ERROR_IGNORE"; break;
 580                 case SVCCTL_SVC_ERROR_NORMAL: val = "SVCCTL_SVC_ERROR_NORMAL"; break;
 581                 case SVCCTL_SVC_ERROR_CRITICAL: val = "SVCCTL_SVC_ERROR_CRITICAL"; break;
 582                 case SVCCTL_SVC_ERROR_SEVERE: val = "SVCCTL_SVC_ERROR_SEVERE"; break;
 583         }
 584         ndr_print_enum(ndr, name, "ENUM", val, r);
 585 }
 586
 587 static enum ndr_err_code ndr_push_svcctl_StartType(struct ndr_push *ndr, int ndr_flags, enum svcctl_StartType r)
 588 {
 589         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 590         return NDR_ERR_SUCCESS;
 591 }
 592
 593 static enum ndr_err_code ndr_pull_svcctl_StartType(struct ndr_pull *ndr, int ndr_flags, enum svcctl_StartType *r)
 594 {
 595         uint32_t v;
 596         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 597         *r = v;
 598         return NDR_ERR_SUCCESS;
 599 }
 600
 601 _PUBLIC_ void ndr_print_svcctl_StartType(struct ndr_print *ndr, const char *name, enum svcctl_StartType r)
 602 {
 603         const char *val = NULL;
 604
 605         switch (r) {
 606                 case SVCCTL_BOOT_START: val = "SVCCTL_BOOT_START"; break;
 607                 case SVCCTL_SYSTEM_START: val = "SVCCTL_SYSTEM_START"; break;
 608                 case SVCCTL_AUTO_START: val = "SVCCTL_AUTO_START"; break;
 609                 case SVCCTL_DEMAND_START: val = "SVCCTL_DEMAND_START"; break;
 610                 case SVCCTL_DISABLED: val = "SVCCTL_DISABLED"; break;
 611         }
 612         ndr_print_enum(ndr, name, "ENUM", val, r);
 613 }
 614
 615 static enum ndr_err_code ndr_push_svcctl_ServiceState(struct ndr_push *ndr, int ndr_flags, enum svcctl_ServiceState r)
 616 {
 617         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 618         return NDR_ERR_SUCCESS;
 619 }
 620
 621 static enum ndr_err_code ndr_pull_svcctl_ServiceState(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ServiceState *r)
 622 {
 623         uint32_t v;
 624         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 625         *r = v;
 626         return NDR_ERR_SUCCESS;
 627 }
 628
 629 _PUBLIC_ void ndr_print_svcctl_ServiceState(struct ndr_print *ndr, const char *name, enum svcctl_ServiceState r)
 630 {
 631         const char *val = NULL;
 632
 633         switch (r) {
 634                 case SERVICE_STATE_ACTIVE: val = "SERVICE_STATE_ACTIVE"; break;
 635                 case SERVICE_STATE_INACTIVE: val = "SERVICE_STATE_INACTIVE"; break;
 636                 case SERVICE_STATE_ALL: val = "SERVICE_STATE_ALL"; break;
 637         }
 638         ndr_print_enum(ndr, name, "ENUM", val, r);
 639 }
 640
 641 static enum ndr_err_code ndr_push_svcctl_MgrAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 642 {
 643         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 644         return NDR_ERR_SUCCESS;
 645 }
 646
 647 static enum ndr_err_code ndr_pull_svcctl_MgrAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 648 {
 649         uint32_t v;
 650         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 651         *r = v;
 652         return NDR_ERR_SUCCESS;
 653 }
 654
 655 _PUBLIC_ void ndr_print_svcctl_MgrAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 656 {
 657         ndr_print_uint32(ndr, name, r);
 658         ndr->depth++;
 659         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_CONNECT", SC_RIGHT_MGR_CONNECT, r);
 660         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_CREATE_SERVICE", SC_RIGHT_MGR_CREATE_SERVICE, r);
 661         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_ENUMERATE_SERVICE", SC_RIGHT_MGR_ENUMERATE_SERVICE, r);
 662         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_LOCK", SC_RIGHT_MGR_LOCK, r);
 663         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_QUERY_LOCK_STATUS", SC_RIGHT_MGR_QUERY_LOCK_STATUS, r);
 664         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_MGR_MODIFY_BOOT_CONFIG", SC_RIGHT_MGR_MODIFY_BOOT_CONFIG, r);
 665         ndr->depth--;
 666 }
 667
 668 static enum ndr_err_code ndr_push_svcctl_ServiceAccessMask(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 669 {
 670         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 671         return NDR_ERR_SUCCESS;
 672 }
 673
 674 static enum ndr_err_code ndr_pull_svcctl_ServiceAccessMask(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 675 {
 676         uint32_t v;
 677         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 678         *r = v;
 679         return NDR_ERR_SUCCESS;
 680 }
 681
 682 _PUBLIC_ void ndr_print_svcctl_ServiceAccessMask(struct ndr_print *ndr, const char *name, uint32_t r)
 683 {
 684         ndr_print_uint32(ndr, name, r);
 685         ndr->depth++;
 686         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_QUERY_CONFIG", SC_RIGHT_SVC_QUERY_CONFIG, r);
 687         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_CHANGE_CONFIG", SC_RIGHT_SVC_CHANGE_CONFIG, r);
 688         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_QUERY_STATUS", SC_RIGHT_SVC_QUERY_STATUS, r);
 689         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_ENUMERATE_DEPENDENTS", SC_RIGHT_SVC_ENUMERATE_DEPENDENTS, r);
 690         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_START", SC_RIGHT_SVC_START, r);
 691         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_STOP", SC_RIGHT_SVC_STOP, r);
 692         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_PAUSE_CONTINUE", SC_RIGHT_SVC_PAUSE_CONTINUE, r);
 693         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_INTERROGATE", SC_RIGHT_SVC_INTERROGATE, r);
 694         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SC_RIGHT_SVC_USER_DEFINED_CONTROL", SC_RIGHT_SVC_USER_DEFINED_CONTROL, r);
 695         ndr->depth--;
 696 }
 697
 698 _PUBLIC_ enum ndr_err_code ndr_push_QUERY_SERVICE_CONFIG(struct ndr_push *ndr, int ndr_flags, const struct QUERY_SERVICE_CONFIG *r)
 699 {
 700         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 701         if (ndr_flags & NDR_SCALARS) {
 702                 NDR_CHECK(ndr_push_align(ndr, 5));
 703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_type));
 704                 NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->start_type));
 705                 NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->error_control));
 706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->executablepath));
 707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->loadordergroup));
 708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->tag_id));
 709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependencies));
 710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->startname));
 711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->displayname));
 712                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 713         }
 714         if (ndr_flags & NDR_BUFFERS) {
 715                 if (r->executablepath) {
 716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));
 717                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->executablepath, CH_UTF16)));
 719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->executablepath, ndr_charset_length(r->executablepath, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 720                 }
 721                 if (r->loadordergroup) {
 722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));
 723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 724                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->loadordergroup, CH_UTF16)));
 725                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->loadordergroup, ndr_charset_length(r->loadordergroup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 726                 }
 727                 if (r->dependencies) {
 728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));
 729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dependencies, CH_UTF16)));
 731                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dependencies, ndr_charset_length(r->dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 732                 }
 733                 if (r->startname) {
 734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));
 735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 736                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->startname, CH_UTF16)));
 737                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->startname, ndr_charset_length(r->startname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 738                 }
 739                 if (r->displayname) {
 740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));
 741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 742                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->displayname, CH_UTF16)));
 743                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->displayname, ndr_charset_length(r->displayname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 744                 }
 745         }
 746         return NDR_ERR_SUCCESS;
 747 }
 748
 749 _PUBLIC_ enum ndr_err_code ndr_pull_QUERY_SERVICE_CONFIG(struct ndr_pull *ndr, int ndr_flags, struct QUERY_SERVICE_CONFIG *r)
 750 {
 751         uint32_t _ptr_executablepath;
 752         uint32_t size_executablepath_1 = 0;
 753         uint32_t length_executablepath_1 = 0;
 754         TALLOC_CTX *_mem_save_executablepath_0;
 755         uint32_t _ptr_loadordergroup;
 756         uint32_t size_loadordergroup_1 = 0;
 757         uint32_t length_loadordergroup_1 = 0;
 758         TALLOC_CTX *_mem_save_loadordergroup_0;
 759         uint32_t _ptr_dependencies;
 760         uint32_t size_dependencies_1 = 0;
 761         uint32_t length_dependencies_1 = 0;
 762         TALLOC_CTX *_mem_save_dependencies_0;
 763         uint32_t _ptr_startname;
 764         uint32_t size_startname_1 = 0;
 765         uint32_t length_startname_1 = 0;
 766         TALLOC_CTX *_mem_save_startname_0;
 767         uint32_t _ptr_displayname;
 768         uint32_t size_displayname_1 = 0;
 769         uint32_t length_displayname_1 = 0;
 770         TALLOC_CTX *_mem_save_displayname_0;
 771         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 772         if (ndr_flags & NDR_SCALARS) {
 773                 NDR_CHECK(ndr_pull_align(ndr, 5));
 774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_type));
 775                 NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->start_type));
 776                 NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->error_control));
 777                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_executablepath));
 778                 if (_ptr_executablepath) {
 779                         NDR_PULL_ALLOC(ndr, r->executablepath);
 780                 } else {
 781                         r->executablepath = NULL;
 782                 }
 783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_loadordergroup));
 784                 if (_ptr_loadordergroup) {
 785                         NDR_PULL_ALLOC(ndr, r->loadordergroup);
 786                 } else {
 787                         r->loadordergroup = NULL;
 788                 }
 789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->tag_id));
 790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
 791                 if (_ptr_dependencies) {
 792                         NDR_PULL_ALLOC(ndr, r->dependencies);
 793                 } else {
 794                         r->dependencies = NULL;
 795                 }
 796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_startname));
 797                 if (_ptr_startname) {
 798                         NDR_PULL_ALLOC(ndr, r->startname);
 799                 } else {
 800                         r->startname = NULL;
 801                 }
 802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_displayname));
 803                 if (_ptr_displayname) {
 804                         NDR_PULL_ALLOC(ndr, r->displayname);
 805                 } else {
 806                         r->displayname = NULL;
 807                 }
 808                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 809         }
 810         if (ndr_flags & NDR_BUFFERS) {
 811                 if (r->executablepath) {
 812                         _mem_save_executablepath_0 = NDR_PULL_GET_MEM_CTX(ndr);
 813                         NDR_PULL_SET_MEM_CTX(ndr, r->executablepath, 0);
 814                         NDR_CHECK(ndr_pull_array_size(ndr, &r->executablepath));
 815                         NDR_CHECK(ndr_pull_array_length(ndr, &r->executablepath));
 816                         size_executablepath_1 = ndr_get_array_size(ndr, &r->executablepath);
 817                         if (size_executablepath_1 > 8192) {
 818                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 819                         }
 820                         length_executablepath_1 = ndr_get_array_length(ndr, &r->executablepath);
 821                         if (length_executablepath_1 > 8192) {
 822                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 823                         }
 824                         if (length_executablepath_1 > size_executablepath_1) {
 825                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_executablepath_1, length_executablepath_1);
 826                         }
 827                         NDR_CHECK(ndr_check_string_terminator(ndr, length_executablepath_1, sizeof(uint16_t)));
 828                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->executablepath, length_executablepath_1, sizeof(uint16_t), CH_UTF16));
 829                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_executablepath_0, 0);
 830                 }
 831                 if (r->loadordergroup) {
 832                         _mem_save_loadordergroup_0 = NDR_PULL_GET_MEM_CTX(ndr);
 833                         NDR_PULL_SET_MEM_CTX(ndr, r->loadordergroup, 0);
 834                         NDR_CHECK(ndr_pull_array_size(ndr, &r->loadordergroup));
 835                         NDR_CHECK(ndr_pull_array_length(ndr, &r->loadordergroup));
 836                         size_loadordergroup_1 = ndr_get_array_size(ndr, &r->loadordergroup);
 837                         if (size_loadordergroup_1 > 8192) {
 838                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 839                         }
 840                         length_loadordergroup_1 = ndr_get_array_length(ndr, &r->loadordergroup);
 841                         if (length_loadordergroup_1 > 8192) {
 842                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 843                         }
 844                         if (length_loadordergroup_1 > size_loadordergroup_1) {
 845                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_loadordergroup_1, length_loadordergroup_1);
 846                         }
 847                         NDR_CHECK(ndr_check_string_terminator(ndr, length_loadordergroup_1, sizeof(uint16_t)));
 848                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->loadordergroup, length_loadordergroup_1, sizeof(uint16_t), CH_UTF16));
 849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_loadordergroup_0, 0);
 850                 }
 851                 if (r->dependencies) {
 852                         _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
 853                         NDR_PULL_SET_MEM_CTX(ndr, r->dependencies, 0);
 854                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dependencies));
 855                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dependencies));
 856                         size_dependencies_1 = ndr_get_array_size(ndr, &r->dependencies);
 857                         if (size_dependencies_1 > 8192) {
 858                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 859                         }
 860                         length_dependencies_1 = ndr_get_array_length(ndr, &r->dependencies);
 861                         if (length_dependencies_1 > 8192) {
 862                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 863                         }
 864                         if (length_dependencies_1 > size_dependencies_1) {
 865                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dependencies_1, length_dependencies_1);
 866                         }
 867                         NDR_CHECK(ndr_check_string_terminator(ndr, length_dependencies_1, sizeof(uint16_t)));
 868                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dependencies, length_dependencies_1, sizeof(uint16_t), CH_UTF16));
 869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
 870                 }
 871                 if (r->startname) {
 872                         _mem_save_startname_0 = NDR_PULL_GET_MEM_CTX(ndr);
 873                         NDR_PULL_SET_MEM_CTX(ndr, r->startname, 0);
 874                         NDR_CHECK(ndr_pull_array_size(ndr, &r->startname));
 875                         NDR_CHECK(ndr_pull_array_length(ndr, &r->startname));
 876                         size_startname_1 = ndr_get_array_size(ndr, &r->startname);
 877                         if (size_startname_1 > 8192) {
 878                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 879                         }
 880                         length_startname_1 = ndr_get_array_length(ndr, &r->startname);
 881                         if (length_startname_1 > 8192) {
 882                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 883                         }
 884                         if (length_startname_1 > size_startname_1) {
 885                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_startname_1, length_startname_1);
 886                         }
 887                         NDR_CHECK(ndr_check_string_terminator(ndr, length_startname_1, sizeof(uint16_t)));
 888                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->startname, length_startname_1, sizeof(uint16_t), CH_UTF16));
 889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_startname_0, 0);
 890                 }
 891                 if (r->displayname) {
 892                         _mem_save_displayname_0 = NDR_PULL_GET_MEM_CTX(ndr);
 893                         NDR_PULL_SET_MEM_CTX(ndr, r->displayname, 0);
 894                         NDR_CHECK(ndr_pull_array_size(ndr, &r->displayname));
 895                         NDR_CHECK(ndr_pull_array_length(ndr, &r->displayname));
 896                         size_displayname_1 = ndr_get_array_size(ndr, &r->displayname);
 897                         if (size_displayname_1 > 8192) {
 898                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 899                         }
 900                         length_displayname_1 = ndr_get_array_length(ndr, &r->displayname);
 901                         if (length_displayname_1 > 8192) {
 902                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 903                         }
 904                         if (length_displayname_1 > size_displayname_1) {
 905                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_displayname_1, length_displayname_1);
 906                         }
 907                         NDR_CHECK(ndr_check_string_terminator(ndr, length_displayname_1, sizeof(uint16_t)));
 908                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->displayname, length_displayname_1, sizeof(uint16_t), CH_UTF16));
 909                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_displayname_0, 0);
 910                 }
 911         }
 912         return NDR_ERR_SUCCESS;
 913 }
 914
 915 _PUBLIC_ void ndr_print_QUERY_SERVICE_CONFIG(struct ndr_print *ndr, const char *name, const struct QUERY_SERVICE_CONFIG *r)
 916 {
 917         ndr_print_struct(ndr, name, "QUERY_SERVICE_CONFIG");
 918         if (r == NULL) { ndr_print_null(ndr); return; }
 919         ndr->depth++;
 920         ndr_print_uint32(ndr, "service_type", r->service_type);
 921         ndr_print_svcctl_StartType(ndr, "start_type", r->start_type);
 922         ndr_print_svcctl_ErrorControl(ndr, "error_control", r->error_control);
 923         ndr_print_ptr(ndr, "executablepath", r->executablepath);
 924         ndr->depth++;
 925         if (r->executablepath) {
 926                 ndr_print_string(ndr, "executablepath", r->executablepath);
 927         }
 928         ndr->depth--;
 929         ndr_print_ptr(ndr, "loadordergroup", r->loadordergroup);
 930         ndr->depth++;
 931         if (r->loadordergroup) {
 932                 ndr_print_string(ndr, "loadordergroup", r->loadordergroup);
 933         }
 934         ndr->depth--;
 935         ndr_print_uint32(ndr, "tag_id", r->tag_id);
 936         ndr_print_ptr(ndr, "dependencies", r->dependencies);
 937         ndr->depth++;
 938         if (r->dependencies) {
 939                 ndr_print_string(ndr, "dependencies", r->dependencies);
 940         }
 941         ndr->depth--;
 942         ndr_print_ptr(ndr, "startname", r->startname);
 943         ndr->depth++;
 944         if (r->startname) {
 945                 ndr_print_string(ndr, "startname", r->startname);
 946         }
 947         ndr->depth--;
 948         ndr_print_ptr(ndr, "displayname", r->displayname);
 949         ndr->depth++;
 950         if (r->displayname) {
 951                 ndr_print_string(ndr, "displayname", r->displayname);
 952         }
 953         ndr->depth--;
 954         ndr->depth--;
 955 }
 956
 957 _PUBLIC_ size_t ndr_size_QUERY_SERVICE_CONFIG(const struct QUERY_SERVICE_CONFIG *r, int flags)
 958 {
 959         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_QUERY_SERVICE_CONFIG);
 960 }
 961
 962 static enum ndr_err_code ndr_push_svcctl_ArgumentString(struct ndr_push *ndr, int ndr_flags, const struct svcctl_ArgumentString *r)
 963 {
 964         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 965         if (ndr_flags & NDR_SCALARS) {
 966                 NDR_CHECK(ndr_push_align(ndr, 5));
 967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
 968                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 969         }
 970         if (ndr_flags & NDR_BUFFERS) {
 971                 if (r->string) {
 972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string, CH_UTF16)));
 973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
 974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string, CH_UTF16)));
 975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, ndr_charset_length(r->string, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 976                 }
 977         }
 978         return NDR_ERR_SUCCESS;
 979 }
 980
 981 static enum ndr_err_code ndr_pull_svcctl_ArgumentString(struct ndr_pull *ndr, int ndr_flags, struct svcctl_ArgumentString *r)
 982 {
 983         uint32_t _ptr_string;
 984         uint32_t size_string_1 = 0;
 985         uint32_t length_string_1 = 0;
 986         TALLOC_CTX *_mem_save_string_0;
 987         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 988         if (ndr_flags & NDR_SCALARS) {
 989                 NDR_CHECK(ndr_pull_align(ndr, 5));
 990                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
 991                 if (_ptr_string) {
 992                         NDR_PULL_ALLOC(ndr, r->string);
 993                 } else {
 994                         r->string = NULL;
 995                 }
 996                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 997         }
 998         if (ndr_flags & NDR_BUFFERS) {
 999                 if (r->string) {
1000                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
1001                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
1002                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
1003                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string));
1004                         size_string_1 = ndr_get_array_size(ndr, &r->string);
1005                         if (size_string_1 > SC_MAX_ARGUMENT_LENGTH) {
1006                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1007                         }
1008                         length_string_1 = ndr_get_array_length(ndr, &r->string);
1009                         if (length_string_1 > SC_MAX_ARGUMENT_LENGTH) {
1010                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1011                         }
1012                         if (length_string_1 > size_string_1) {
1013                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_string_1, length_string_1);
1014                         }
1015                         NDR_CHECK(ndr_check_string_terminator(ndr, length_string_1, sizeof(uint16_t)));
1016                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, length_string_1, sizeof(uint16_t), CH_UTF16));
1017                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
1018                 }
1019         }
1020         return NDR_ERR_SUCCESS;
1021 }
1022
1023 _PUBLIC_ void ndr_print_svcctl_ArgumentString(struct ndr_print *ndr, const char *name, const struct svcctl_ArgumentString *r)
1024 {
1025         ndr_print_struct(ndr, name, "svcctl_ArgumentString");
1026         if (r == NULL) { ndr_print_null(ndr); return; }
1027         ndr->depth++;
1028         ndr_print_ptr(ndr, "string", r->string);
1029         ndr->depth++;
1030         if (r->string) {
1031                 ndr_print_string(ndr, "string", r->string);
1032         }
1033         ndr->depth--;
1034         ndr->depth--;
1035 }
1036
1037 static enum ndr_err_code ndr_push_svcctl_ConfigLevel(struct ndr_push *ndr, int ndr_flags, enum svcctl_ConfigLevel r)
1038 {
1039         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1040         return NDR_ERR_SUCCESS;
1041 }
1042
1043 static enum ndr_err_code ndr_pull_svcctl_ConfigLevel(struct ndr_pull *ndr, int ndr_flags, enum svcctl_ConfigLevel *r)
1044 {
1045         uint32_t v;
1046         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1047         *r = v;
1048         return NDR_ERR_SUCCESS;
1049 }
1050
1051 _PUBLIC_ void ndr_print_svcctl_ConfigLevel(struct ndr_print *ndr, const char *name, enum svcctl_ConfigLevel r)
1052 {
1053         const char *val = NULL;
1054
1055         switch (r) {
1056                 case SERVICE_CONFIG_DESCRIPTION: val = "SERVICE_CONFIG_DESCRIPTION"; break;
1057                 case SERVICE_CONFIG_FAILURE_ACTIONS: val = "SERVICE_CONFIG_FAILURE_ACTIONS"; break;
1058         }
1059         ndr_print_enum(ndr, name, "ENUM", val, r);
1060 }
1061
1062 _PUBLIC_ enum ndr_err_code ndr_push_SERVICE_DESCRIPTION(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_DESCRIPTION *r)
1063 {
1064         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1065         if (ndr_flags & NDR_SCALARS) {
1066                 NDR_CHECK(ndr_push_align(ndr, 5));
1067                 {
1068                         uint32_t _flags_save_string = ndr->flags;
1069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1070                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1071                         ndr->flags = _flags_save_string;
1072                 }
1073                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1074         }
1075         if (ndr_flags & NDR_BUFFERS) {
1076                 {
1077                         uint32_t _flags_save_string = ndr->flags;
1078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1079                         if (r->description) {
1080                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
1081                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1082                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
1083                         }
1084                         ndr->flags = _flags_save_string;
1085                 }
1086         }
1087         return NDR_ERR_SUCCESS;
1088 }
1089
1090 _PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_DESCRIPTION(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_DESCRIPTION *r)
1091 {
1092         uint32_t _ptr_description;
1093         TALLOC_CTX *_mem_save_description_0;
1094         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1095         if (ndr_flags & NDR_SCALARS) {
1096                 NDR_CHECK(ndr_pull_align(ndr, 5));
1097                 {
1098                         uint32_t _flags_save_string = ndr->flags;
1099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1100                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1101                         if (_ptr_description) {
1102                                 NDR_PULL_ALLOC(ndr, r->description);
1103                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1104                         } else {
1105                                 r->description = NULL;
1106                         }
1107                         ndr->flags = _flags_save_string;
1108                 }
1109                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1110         }
1111         if (ndr_flags & NDR_BUFFERS) {
1112                 {
1113                         uint32_t _flags_save_string = ndr->flags;
1114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1115                         if (r->description) {
1116                                 uint32_t _relative_save_offset;
1117                                 _relative_save_offset = ndr->offset;
1118                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1119                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1120                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1121                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1122                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1123                                 if (ndr->offset > ndr->relative_highest_offset) {
1124                                         ndr->relative_highest_offset = ndr->offset;
1125                                 }
1126                                 ndr->offset = _relative_save_offset;
1127                         }
1128                         ndr->flags = _flags_save_string;
1129                 }
1130         }
1131         return NDR_ERR_SUCCESS;
1132 }
1133
1134 _PUBLIC_ void ndr_print_SERVICE_DESCRIPTION(struct ndr_print *ndr, const char *name, const struct SERVICE_DESCRIPTION *r)
1135 {
1136         ndr_print_struct(ndr, name, "SERVICE_DESCRIPTION");
1137         if (r == NULL) { ndr_print_null(ndr); return; }
1138         ndr->depth++;
1139         ndr_print_ptr(ndr, "description", r->description);
1140         ndr->depth++;
1141         if (r->description) {
1142                 ndr_print_string(ndr, "description", r->description);
1143         }
1144         ndr->depth--;
1145         ndr->depth--;
1146 }
1147
1148 _PUBLIC_ size_t ndr_size_SERVICE_DESCRIPTION(const struct SERVICE_DESCRIPTION *r, int flags)
1149 {
1150         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_SERVICE_DESCRIPTION);
1151 }
1152
1153 static enum ndr_err_code ndr_push_SC_ACTION_TYPE(struct ndr_push *ndr, int ndr_flags, enum SC_ACTION_TYPE r)
1154 {
1155         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1156         return NDR_ERR_SUCCESS;
1157 }
1158
1159 static enum ndr_err_code ndr_pull_SC_ACTION_TYPE(struct ndr_pull *ndr, int ndr_flags, enum SC_ACTION_TYPE *r)
1160 {
1161         uint32_t v;
1162         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1163         *r = v;
1164         return NDR_ERR_SUCCESS;
1165 }
1166
1167 _PUBLIC_ void ndr_print_SC_ACTION_TYPE(struct ndr_print *ndr, const char *name, enum SC_ACTION_TYPE r)
1168 {
1169         const char *val = NULL;
1170
1171         switch (r) {
1172                 case SC_ACTION_NONE: val = "SC_ACTION_NONE"; break;
1173                 case SC_ACTION_RESTART: val = "SC_ACTION_RESTART"; break;
1174                 case SC_ACTION_REBOOT: val = "SC_ACTION_REBOOT"; break;
1175                 case SC_ACTION_RUN_COMMAND: val = "SC_ACTION_RUN_COMMAND"; break;
1176         }
1177         ndr_print_enum(ndr, name, "ENUM", val, r);
1178 }
1179
1180 static enum ndr_err_code ndr_push_SC_ACTION(struct ndr_push *ndr, int ndr_flags, const struct SC_ACTION *r)
1181 {
1182         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1183         if (ndr_flags & NDR_SCALARS) {
1184                 NDR_CHECK(ndr_push_align(ndr, 4));
1185                 NDR_CHECK(ndr_push_SC_ACTION_TYPE(ndr, NDR_SCALARS, r->type));
1186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->delay));
1187                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1188         }
1189         if (ndr_flags & NDR_BUFFERS) {
1190         }
1191         return NDR_ERR_SUCCESS;
1192 }
1193
1194 static enum ndr_err_code ndr_pull_SC_ACTION(struct ndr_pull *ndr, int ndr_flags, struct SC_ACTION *r)
1195 {
1196         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1197         if (ndr_flags & NDR_SCALARS) {
1198                 NDR_CHECK(ndr_pull_align(ndr, 4));
1199                 NDR_CHECK(ndr_pull_SC_ACTION_TYPE(ndr, NDR_SCALARS, &r->type));
1200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->delay));
1201                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1202         }
1203         if (ndr_flags & NDR_BUFFERS) {
1204         }
1205         return NDR_ERR_SUCCESS;
1206 }
1207
1208 _PUBLIC_ void ndr_print_SC_ACTION(struct ndr_print *ndr, const char *name, const struct SC_ACTION *r)
1209 {
1210         ndr_print_struct(ndr, name, "SC_ACTION");
1211         if (r == NULL) { ndr_print_null(ndr); return; }
1212         ndr->depth++;
1213         ndr_print_SC_ACTION_TYPE(ndr, "type", r->type);
1214         ndr_print_uint32(ndr, "delay", r->delay);
1215         ndr->depth--;
1216 }
1217
1218 _PUBLIC_ enum ndr_err_code ndr_push_SERVICE_FAILURE_ACTIONS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_FAILURE_ACTIONS *r)
1219 {
1220         uint32_t cntr_actions_1;
1221         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1222         if (ndr_flags & NDR_SCALARS) {
1223                 NDR_CHECK(ndr_push_align(ndr, 5));
1224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reset_period));
1225                 {
1226                         uint32_t _flags_save_string = ndr->flags;
1227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1228                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->rebootmsg));
1229                         ndr->flags = _flags_save_string;
1230                 }
1231                 {
1232                         uint32_t _flags_save_string = ndr->flags;
1233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1234                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->command));
1235                         ndr->flags = _flags_save_string;
1236                 }
1237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_actions));
1238                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->actions));
1239                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1240         }
1241         if (ndr_flags & NDR_BUFFERS) {
1242                 {
1243                         uint32_t _flags_save_string = ndr->flags;
1244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1245                         if (r->rebootmsg) {
1246                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->rebootmsg));
1247                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->rebootmsg));
1248                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->rebootmsg));
1249                         }
1250                         ndr->flags = _flags_save_string;
1251                 }
1252                 {
1253                         uint32_t _flags_save_string = ndr->flags;
1254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1255                         if (r->command) {
1256                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->command));
1257                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->command));
1258                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->command));
1259                         }
1260                         ndr->flags = _flags_save_string;
1261                 }
1262                 if (r->actions) {
1263                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->actions));
1264                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_actions));
1265                         for (cntr_actions_1 = 0; cntr_actions_1 < r->num_actions; cntr_actions_1++) {
1266                                 NDR_CHECK(ndr_push_SC_ACTION(ndr, NDR_SCALARS, &r->actions[cntr_actions_1]));
1267                         }
1268                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->actions));
1269                 }
1270         }
1271         return NDR_ERR_SUCCESS;
1272 }
1273
1274 _PUBLIC_ enum ndr_err_code ndr_pull_SERVICE_FAILURE_ACTIONS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_FAILURE_ACTIONS *r)
1275 {
1276         uint32_t _ptr_rebootmsg;
1277         TALLOC_CTX *_mem_save_rebootmsg_0;
1278         uint32_t _ptr_command;
1279         TALLOC_CTX *_mem_save_command_0;
1280         uint32_t _ptr_actions;
1281         uint32_t size_actions_1 = 0;
1282         uint32_t cntr_actions_1;
1283         TALLOC_CTX *_mem_save_actions_0;
1284         TALLOC_CTX *_mem_save_actions_1;
1285         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1286         if (ndr_flags & NDR_SCALARS) {
1287                 NDR_CHECK(ndr_pull_align(ndr, 5));
1288                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reset_period));
1289                 {
1290                         uint32_t _flags_save_string = ndr->flags;
1291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1292                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_rebootmsg));
1293                         if (_ptr_rebootmsg) {
1294                                 NDR_PULL_ALLOC(ndr, r->rebootmsg);
1295                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->rebootmsg, _ptr_rebootmsg));
1296                         } else {
1297                                 r->rebootmsg = NULL;
1298                         }
1299                         ndr->flags = _flags_save_string;
1300                 }
1301                 {
1302                         uint32_t _flags_save_string = ndr->flags;
1303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1304                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_command));
1305                         if (_ptr_command) {
1306                                 NDR_PULL_ALLOC(ndr, r->command);
1307                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->command, _ptr_command));
1308                         } else {
1309                                 r->command = NULL;
1310                         }
1311                         ndr->flags = _flags_save_string;
1312                 }
1313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_actions));
1314                 if (r->num_actions > 1024) {
1315                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1316                 }
1317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_actions));
1318                 if (_ptr_actions) {
1319                         NDR_PULL_ALLOC(ndr, r->actions);
1320                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->actions, _ptr_actions));
1321                 } else {
1322                         r->actions = NULL;
1323                 }
1324                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1325         }
1326         if (ndr_flags & NDR_BUFFERS) {
1327                 {
1328                         uint32_t _flags_save_string = ndr->flags;
1329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1330                         if (r->rebootmsg) {
1331                                 uint32_t _relative_save_offset;
1332                                 _relative_save_offset = ndr->offset;
1333                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->rebootmsg));
1334                                 _mem_save_rebootmsg_0 = NDR_PULL_GET_MEM_CTX(ndr);
1335                                 NDR_PULL_SET_MEM_CTX(ndr, r->rebootmsg, 0);
1336                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->rebootmsg));
1337                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_rebootmsg_0, 0);
1338                                 if (ndr->offset > ndr->relative_highest_offset) {
1339                                         ndr->relative_highest_offset = ndr->offset;
1340                                 }
1341                                 ndr->offset = _relative_save_offset;
1342                         }
1343                         ndr->flags = _flags_save_string;
1344                 }
1345                 {
1346                         uint32_t _flags_save_string = ndr->flags;
1347                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
1348                         if (r->command) {
1349                                 uint32_t _relative_save_offset;
1350                                 _relative_save_offset = ndr->offset;
1351                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->command));
1352                                 _mem_save_command_0 = NDR_PULL_GET_MEM_CTX(ndr);
1353                                 NDR_PULL_SET_MEM_CTX(ndr, r->command, 0);
1354                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->command));
1355                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_command_0, 0);
1356                                 if (ndr->offset > ndr->relative_highest_offset) {
1357                                         ndr->relative_highest_offset = ndr->offset;
1358                                 }
1359                                 ndr->offset = _relative_save_offset;
1360                         }
1361                         ndr->flags = _flags_save_string;
1362                 }
1363                 if (r->actions) {
1364                         uint32_t _relative_save_offset;
1365                         _relative_save_offset = ndr->offset;
1366                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->actions));
1367                         _mem_save_actions_0 = NDR_PULL_GET_MEM_CTX(ndr);
1368                         NDR_PULL_SET_MEM_CTX(ndr, r->actions, 0);
1369                         NDR_CHECK(ndr_pull_array_size(ndr, &r->actions));
1370                         size_actions_1 = ndr_get_array_size(ndr, &r->actions);
1371                         NDR_PULL_ALLOC_N(ndr, r->actions, size_actions_1);
1372                         _mem_save_actions_1 = NDR_PULL_GET_MEM_CTX(ndr);
1373                         NDR_PULL_SET_MEM_CTX(ndr, r->actions, 0);
1374                         for (cntr_actions_1 = 0; cntr_actions_1 < size_actions_1; cntr_actions_1++) {
1375                                 NDR_CHECK(ndr_pull_SC_ACTION(ndr, NDR_SCALARS, &r->actions[cntr_actions_1]));
1376                         }
1377                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actions_1, 0);
1378                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_actions_0, 0);
1379                         if (ndr->offset > ndr->relative_highest_offset) {
1380                                 ndr->relative_highest_offset = ndr->offset;
1381                         }
1382                         ndr->offset = _relative_save_offset;
1383                 }
1384                 if (r->actions) {
1385                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->actions, r->num_actions));
1386                 }
1387         }
1388         return NDR_ERR_SUCCESS;
1389 }
1390
1391 _PUBLIC_ void ndr_print_SERVICE_FAILURE_ACTIONS(struct ndr_print *ndr, const char *name, const struct SERVICE_FAILURE_ACTIONS *r)
1392 {
1393         uint32_t cntr_actions_1;
1394         ndr_print_struct(ndr, name, "SERVICE_FAILURE_ACTIONS");
1395         if (r == NULL) { ndr_print_null(ndr); return; }
1396         ndr->depth++;
1397         ndr_print_uint32(ndr, "reset_period", r->reset_period);
1398         ndr_print_ptr(ndr, "rebootmsg", r->rebootmsg);
1399         ndr->depth++;
1400         if (r->rebootmsg) {
1401                 ndr_print_string(ndr, "rebootmsg", r->rebootmsg);
1402         }
1403         ndr->depth--;
1404         ndr_print_ptr(ndr, "command", r->command);
1405         ndr->depth++;
1406         if (r->command) {
1407                 ndr_print_string(ndr, "command", r->command);
1408         }
1409         ndr->depth--;
1410         ndr_print_uint32(ndr, "num_actions", r->num_actions);
1411         ndr_print_ptr(ndr, "actions", r->actions);
1412         ndr->depth++;
1413         if (r->actions) {
1414                 ndr->print(ndr, "%s: ARRAY(%d)", "actions", (int)r->num_actions);
1415                 ndr->depth++;
1416                 for (cntr_actions_1=0;cntr_actions_1<r->num_actions;cntr_actions_1++) {
1417                         ndr_print_SC_ACTION(ndr, "actions", &r->actions[cntr_actions_1]);
1418                 }
1419                 ndr->depth--;
1420         }
1421         ndr->depth--;
1422         ndr->depth--;
1423 }
1424
1425 _PUBLIC_ size_t ndr_size_SERVICE_FAILURE_ACTIONS(const struct SERVICE_FAILURE_ACTIONS *r, int flags)
1426 {
1427         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_SERVICE_FAILURE_ACTIONS);
1428 }
1429
1430 static enum ndr_err_code ndr_push_svcctl_StatusLevel(struct ndr_push *ndr, int ndr_flags, enum svcctl_StatusLevel r)
1431 {
1432         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1433         return NDR_ERR_SUCCESS;
1434 }
1435
1436 static enum ndr_err_code ndr_pull_svcctl_StatusLevel(struct ndr_pull *ndr, int ndr_flags, enum svcctl_StatusLevel *r)
1437 {
1438         uint32_t v;
1439         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1440         *r = v;
1441         return NDR_ERR_SUCCESS;
1442 }
1443
1444 _PUBLIC_ void ndr_print_svcctl_StatusLevel(struct ndr_print *ndr, const char *name, enum svcctl_StatusLevel r)
1445 {
1446         const char *val = NULL;
1447
1448         switch (r) {
1449                 case SVC_STATUS_PROCESS_INFO: val = "SVC_STATUS_PROCESS_INFO"; break;
1450         }
1451         ndr_print_enum(ndr, name, "ENUM", val, r);
1452 }
1453
1454 static enum ndr_err_code ndr_push_svcctl_CloseServiceHandle(struct ndr_push *ndr, int flags, const struct svcctl_CloseServiceHandle *r)
1455 {
1456         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1457         if (flags & NDR_IN) {
1458                 if (r->in.handle == NULL) {
1459                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1460                 }
1461                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1462         }
1463         if (flags & NDR_OUT) {
1464                 if (r->out.handle == NULL) {
1465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1466                 }
1467                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1468                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1469         }
1470         return NDR_ERR_SUCCESS;
1471 }
1472
1473 static enum ndr_err_code ndr_pull_svcctl_CloseServiceHandle(struct ndr_pull *ndr, int flags, struct svcctl_CloseServiceHandle *r)
1474 {
1475         TALLOC_CTX *_mem_save_handle_0;
1476         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1477         if (flags & NDR_IN) {
1478                 ZERO_STRUCT(r->out);
1479
1480                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1481                         NDR_PULL_ALLOC(ndr, r->in.handle);
1482                 }
1483                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1484                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1485                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1486                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1487                 NDR_PULL_ALLOC(ndr, r->out.handle);
1488                 *r->out.handle = *r->in.handle;
1489         }
1490         if (flags & NDR_OUT) {
1491                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1492                         NDR_PULL_ALLOC(ndr, r->out.handle);
1493                 }
1494                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1495                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1496                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
1497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1498                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1499         }
1500         return NDR_ERR_SUCCESS;
1501 }
1502
1503 _PUBLIC_ void ndr_print_svcctl_CloseServiceHandle(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CloseServiceHandle *r)
1504 {
1505         ndr_print_struct(ndr, name, "svcctl_CloseServiceHandle");
1506         if (r == NULL) { ndr_print_null(ndr); return; }
1507         ndr->depth++;
1508         if (flags & NDR_SET_VALUES) {
1509                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1510         }
1511         if (flags & NDR_IN) {
1512                 ndr_print_struct(ndr, "in", "svcctl_CloseServiceHandle");
1513                 ndr->depth++;
1514                 ndr_print_ptr(ndr, "handle", r->in.handle);
1515                 ndr->depth++;
1516                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1517                 ndr->depth--;
1518                 ndr->depth--;
1519         }
1520         if (flags & NDR_OUT) {
1521                 ndr_print_struct(ndr, "out", "svcctl_CloseServiceHandle");
1522                 ndr->depth++;
1523                 ndr_print_ptr(ndr, "handle", r->out.handle);
1524                 ndr->depth++;
1525                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
1526                 ndr->depth--;
1527                 ndr_print_WERROR(ndr, "result", r->out.result);
1528                 ndr->depth--;
1529         }
1530         ndr->depth--;
1531 }
1532
1533 static enum ndr_err_code ndr_push_svcctl_ControlService(struct ndr_push *ndr, int flags, const struct svcctl_ControlService *r)
1534 {
1535         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1536         if (flags & NDR_IN) {
1537                 if (r->in.handle == NULL) {
1538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1539                 }
1540                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1541                 NDR_CHECK(ndr_push_SERVICE_CONTROL(ndr, NDR_SCALARS, r->in.control));
1542         }
1543         if (flags & NDR_OUT) {
1544                 if (r->out.service_status == NULL) {
1545                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1546                 }
1547                 NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
1548                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1549         }
1550         return NDR_ERR_SUCCESS;
1551 }
1552
1553 static enum ndr_err_code ndr_pull_svcctl_ControlService(struct ndr_pull *ndr, int flags, struct svcctl_ControlService *r)
1554 {
1555         TALLOC_CTX *_mem_save_handle_0;
1556         TALLOC_CTX *_mem_save_service_status_0;
1557         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1558         if (flags & NDR_IN) {
1559                 ZERO_STRUCT(r->out);
1560
1561                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1562                         NDR_PULL_ALLOC(ndr, r->in.handle);
1563                 }
1564                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1565                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1566                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1567                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1568                 NDR_CHECK(ndr_pull_SERVICE_CONTROL(ndr, NDR_SCALARS, &r->in.control));
1569                 NDR_PULL_ALLOC(ndr, r->out.service_status);
1570                 ZERO_STRUCTP(r->out.service_status);
1571         }
1572         if (flags & NDR_OUT) {
1573                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1574                         NDR_PULL_ALLOC(ndr, r->out.service_status);
1575                 }
1576                 _mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
1577                 NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, LIBNDR_FLAG_REF_ALLOC);
1578                 NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
1579                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, LIBNDR_FLAG_REF_ALLOC);
1580                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1581         }
1582         return NDR_ERR_SUCCESS;
1583 }
1584
1585 _PUBLIC_ void ndr_print_svcctl_ControlService(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ControlService *r)
1586 {
1587         ndr_print_struct(ndr, name, "svcctl_ControlService");
1588         if (r == NULL) { ndr_print_null(ndr); return; }
1589         ndr->depth++;
1590         if (flags & NDR_SET_VALUES) {
1591                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1592         }
1593         if (flags & NDR_IN) {
1594                 ndr_print_struct(ndr, "in", "svcctl_ControlService");
1595                 ndr->depth++;
1596                 ndr_print_ptr(ndr, "handle", r->in.handle);
1597                 ndr->depth++;
1598                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1599                 ndr->depth--;
1600                 ndr_print_SERVICE_CONTROL(ndr, "control", r->in.control);
1601                 ndr->depth--;
1602         }
1603         if (flags & NDR_OUT) {
1604                 ndr_print_struct(ndr, "out", "svcctl_ControlService");
1605                 ndr->depth++;
1606                 ndr_print_ptr(ndr, "service_status", r->out.service_status);
1607                 ndr->depth++;
1608                 ndr_print_SERVICE_STATUS(ndr, "service_status", r->out.service_status);
1609                 ndr->depth--;
1610                 ndr_print_WERROR(ndr, "result", r->out.result);
1611                 ndr->depth--;
1612         }
1613         ndr->depth--;
1614 }
1615
1616 static enum ndr_err_code ndr_push_svcctl_DeleteService(struct ndr_push *ndr, int flags, const struct svcctl_DeleteService *r)
1617 {
1618         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1619         if (flags & NDR_IN) {
1620                 if (r->in.handle == NULL) {
1621                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1622                 }
1623                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1624         }
1625         if (flags & NDR_OUT) {
1626                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1627         }
1628         return NDR_ERR_SUCCESS;
1629 }
1630
1631 static enum ndr_err_code ndr_pull_svcctl_DeleteService(struct ndr_pull *ndr, int flags, struct svcctl_DeleteService *r)
1632 {
1633         TALLOC_CTX *_mem_save_handle_0;
1634         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1635         if (flags & NDR_IN) {
1636                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1637                         NDR_PULL_ALLOC(ndr, r->in.handle);
1638                 }
1639                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1640                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1641                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1642                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1643         }
1644         if (flags & NDR_OUT) {
1645                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1646         }
1647         return NDR_ERR_SUCCESS;
1648 }
1649
1650 _PUBLIC_ void ndr_print_svcctl_DeleteService(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_DeleteService *r)
1651 {
1652         ndr_print_struct(ndr, name, "svcctl_DeleteService");
1653         if (r == NULL) { ndr_print_null(ndr); return; }
1654         ndr->depth++;
1655         if (flags & NDR_SET_VALUES) {
1656                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1657         }
1658         if (flags & NDR_IN) {
1659                 ndr_print_struct(ndr, "in", "svcctl_DeleteService");
1660                 ndr->depth++;
1661                 ndr_print_ptr(ndr, "handle", r->in.handle);
1662                 ndr->depth++;
1663                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1664                 ndr->depth--;
1665                 ndr->depth--;
1666         }
1667         if (flags & NDR_OUT) {
1668                 ndr_print_struct(ndr, "out", "svcctl_DeleteService");
1669                 ndr->depth++;
1670                 ndr_print_WERROR(ndr, "result", r->out.result);
1671                 ndr->depth--;
1672         }
1673         ndr->depth--;
1674 }
1675
1676 static enum ndr_err_code ndr_push_svcctl_LockServiceDatabase(struct ndr_push *ndr, int flags, const struct svcctl_LockServiceDatabase *r)
1677 {
1678         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1679         if (flags & NDR_IN) {
1680                 if (r->in.handle == NULL) {
1681                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1682                 }
1683                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1684         }
1685         if (flags & NDR_OUT) {
1686                 if (r->out.lock == NULL) {
1687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1688                 }
1689                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.lock));
1690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1691         }
1692         return NDR_ERR_SUCCESS;
1693 }
1694
1695 static enum ndr_err_code ndr_pull_svcctl_LockServiceDatabase(struct ndr_pull *ndr, int flags, struct svcctl_LockServiceDatabase *r)
1696 {
1697         TALLOC_CTX *_mem_save_handle_0;
1698         TALLOC_CTX *_mem_save_lock_0;
1699         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1700         if (flags & NDR_IN) {
1701                 ZERO_STRUCT(r->out);
1702
1703                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1704                         NDR_PULL_ALLOC(ndr, r->in.handle);
1705                 }
1706                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1707                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1708                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1709                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1710                 NDR_PULL_ALLOC(ndr, r->out.lock);
1711                 ZERO_STRUCTP(r->out.lock);
1712         }
1713         if (flags & NDR_OUT) {
1714                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1715                         NDR_PULL_ALLOC(ndr, r->out.lock);
1716                 }
1717                 _mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);
1718                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lock, LIBNDR_FLAG_REF_ALLOC);
1719                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.lock));
1720                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);
1721                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1722         }
1723         return NDR_ERR_SUCCESS;
1724 }
1725
1726 _PUBLIC_ void ndr_print_svcctl_LockServiceDatabase(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_LockServiceDatabase *r)
1727 {
1728         ndr_print_struct(ndr, name, "svcctl_LockServiceDatabase");
1729         if (r == NULL) { ndr_print_null(ndr); return; }
1730         ndr->depth++;
1731         if (flags & NDR_SET_VALUES) {
1732                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1733         }
1734         if (flags & NDR_IN) {
1735                 ndr_print_struct(ndr, "in", "svcctl_LockServiceDatabase");
1736                 ndr->depth++;
1737                 ndr_print_ptr(ndr, "handle", r->in.handle);
1738                 ndr->depth++;
1739                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1740                 ndr->depth--;
1741                 ndr->depth--;
1742         }
1743         if (flags & NDR_OUT) {
1744                 ndr_print_struct(ndr, "out", "svcctl_LockServiceDatabase");
1745                 ndr->depth++;
1746                 ndr_print_ptr(ndr, "lock", r->out.lock);
1747                 ndr->depth++;
1748                 ndr_print_policy_handle(ndr, "lock", r->out.lock);
1749                 ndr->depth--;
1750                 ndr_print_WERROR(ndr, "result", r->out.result);
1751                 ndr->depth--;
1752         }
1753         ndr->depth--;
1754 }
1755
1756 static enum ndr_err_code ndr_push_svcctl_QueryServiceObjectSecurity(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceObjectSecurity *r)
1757 {
1758         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1759         if (flags & NDR_IN) {
1760                 if (r->in.handle == NULL) {
1761                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1762                 }
1763                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1764                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.security_flags));
1765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
1766         }
1767         if (flags & NDR_OUT) {
1768                 if (r->out.buffer == NULL) {
1769                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1770                 }
1771                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
1772                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
1773                 if (r->out.needed == NULL) {
1774                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1775                 }
1776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
1777                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1778         }
1779         return NDR_ERR_SUCCESS;
1780 }
1781
1782 static enum ndr_err_code ndr_pull_svcctl_QueryServiceObjectSecurity(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceObjectSecurity *r)
1783 {
1784         uint32_t size_buffer_1 = 0;
1785         TALLOC_CTX *_mem_save_handle_0;
1786         TALLOC_CTX *_mem_save_needed_0;
1787         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1788         if (flags & NDR_IN) {
1789                 ZERO_STRUCT(r->out);
1790
1791                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1792                         NDR_PULL_ALLOC(ndr, r->in.handle);
1793                 }
1794                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1795                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1796                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1797                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1798                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.security_flags));
1799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
1800                 if (r->in.offered > 0x40000) {
1801                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1802                 }
1803                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
1804                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
1805                 NDR_PULL_ALLOC(ndr, r->out.needed);
1806                 ZERO_STRUCTP(r->out.needed);
1807         }
1808         if (flags & NDR_OUT) {
1809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
1810                 size_buffer_1 = ndr_get_array_size(ndr, &r->out.buffer);
1811                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1812                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, size_buffer_1);
1813                 }
1814                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, size_buffer_1));
1815                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1816                         NDR_PULL_ALLOC(ndr, r->out.needed);
1817                 }
1818                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
1819                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
1820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
1821                 if (*r->out.needed > 0x40000) {
1822                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1823                 }
1824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
1825                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1826                 if (r->out.buffer) {
1827                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
1828                 }
1829         }
1830         return NDR_ERR_SUCCESS;
1831 }
1832
1833 _PUBLIC_ void ndr_print_svcctl_QueryServiceObjectSecurity(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceObjectSecurity *r)
1834 {
1835         ndr_print_struct(ndr, name, "svcctl_QueryServiceObjectSecurity");
1836         if (r == NULL) { ndr_print_null(ndr); return; }
1837         ndr->depth++;
1838         if (flags & NDR_SET_VALUES) {
1839                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1840         }
1841         if (flags & NDR_IN) {
1842                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceObjectSecurity");
1843                 ndr->depth++;
1844                 ndr_print_ptr(ndr, "handle", r->in.handle);
1845                 ndr->depth++;
1846                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1847                 ndr->depth--;
1848                 ndr_print_security_secinfo(ndr, "security_flags", r->in.security_flags);
1849                 ndr_print_uint32(ndr, "offered", r->in.offered);
1850                 ndr->depth--;
1851         }
1852         if (flags & NDR_OUT) {
1853                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceObjectSecurity");
1854                 ndr->depth++;
1855                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
1856                 ndr->depth++;
1857                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
1858                 ndr->depth--;
1859                 ndr_print_ptr(ndr, "needed", r->out.needed);
1860                 ndr->depth++;
1861                 ndr_print_uint32(ndr, "needed", *r->out.needed);
1862                 ndr->depth--;
1863                 ndr_print_WERROR(ndr, "result", r->out.result);
1864                 ndr->depth--;
1865         }
1866         ndr->depth--;
1867 }
1868
1869 static enum ndr_err_code ndr_push_svcctl_SetServiceObjectSecurity(struct ndr_push *ndr, int flags, const struct svcctl_SetServiceObjectSecurity *r)
1870 {
1871         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1872         if (flags & NDR_IN) {
1873                 if (r->in.handle == NULL) {
1874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1875                 }
1876                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1877                 NDR_CHECK(ndr_push_security_secinfo(ndr, NDR_SCALARS, r->in.security_flags));
1878                 if (r->in.buffer == NULL) {
1879                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1880                 }
1881                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
1882                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
1883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
1884         }
1885         if (flags & NDR_OUT) {
1886                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1887         }
1888         return NDR_ERR_SUCCESS;
1889 }
1890
1891 static enum ndr_err_code ndr_pull_svcctl_SetServiceObjectSecurity(struct ndr_pull *ndr, int flags, struct svcctl_SetServiceObjectSecurity *r)
1892 {
1893         uint32_t size_buffer_1 = 0;
1894         TALLOC_CTX *_mem_save_handle_0;
1895         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1896         if (flags & NDR_IN) {
1897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1898                         NDR_PULL_ALLOC(ndr, r->in.handle);
1899                 }
1900                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1901                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1902                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1904                 NDR_CHECK(ndr_pull_security_secinfo(ndr, NDR_SCALARS, &r->in.security_flags));
1905                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
1906                 size_buffer_1 = ndr_get_array_size(ndr, &r->in.buffer);
1907                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1908                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, size_buffer_1);
1909                 }
1910                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, size_buffer_1));
1911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
1912                 if (r->in.buffer) {
1913                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
1914                 }
1915         }
1916         if (flags & NDR_OUT) {
1917                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1918         }
1919         return NDR_ERR_SUCCESS;
1920 }
1921
1922 _PUBLIC_ void ndr_print_svcctl_SetServiceObjectSecurity(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SetServiceObjectSecurity *r)
1923 {
1924         ndr_print_struct(ndr, name, "svcctl_SetServiceObjectSecurity");
1925         if (r == NULL) { ndr_print_null(ndr); return; }
1926         ndr->depth++;
1927         if (flags & NDR_SET_VALUES) {
1928                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1929         }
1930         if (flags & NDR_IN) {
1931                 ndr_print_struct(ndr, "in", "svcctl_SetServiceObjectSecurity");
1932                 ndr->depth++;
1933                 ndr_print_ptr(ndr, "handle", r->in.handle);
1934                 ndr->depth++;
1935                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1936                 ndr->depth--;
1937                 ndr_print_security_secinfo(ndr, "security_flags", r->in.security_flags);
1938                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
1939                 ndr->depth++;
1940                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
1941                 ndr->depth--;
1942                 ndr_print_uint32(ndr, "offered", r->in.offered);
1943                 ndr->depth--;
1944         }
1945         if (flags & NDR_OUT) {
1946                 ndr_print_struct(ndr, "out", "svcctl_SetServiceObjectSecurity");
1947                 ndr->depth++;
1948                 ndr_print_WERROR(ndr, "result", r->out.result);
1949                 ndr->depth--;
1950         }
1951         ndr->depth--;
1952 }
1953
1954 static enum ndr_err_code ndr_push_svcctl_QueryServiceStatus(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceStatus *r)
1955 {
1956         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
1957         if (flags & NDR_IN) {
1958                 if (r->in.handle == NULL) {
1959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1960                 }
1961                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1962         }
1963         if (flags & NDR_OUT) {
1964                 if (r->out.service_status == NULL) {
1965                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1966                 }
1967                 NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
1968                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1969         }
1970         return NDR_ERR_SUCCESS;
1971 }
1972
1973 static enum ndr_err_code ndr_pull_svcctl_QueryServiceStatus(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceStatus *r)
1974 {
1975         TALLOC_CTX *_mem_save_handle_0;
1976         TALLOC_CTX *_mem_save_service_status_0;
1977         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
1978         if (flags & NDR_IN) {
1979                 ZERO_STRUCT(r->out);
1980
1981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1982                         NDR_PULL_ALLOC(ndr, r->in.handle);
1983                 }
1984                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1985                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1986                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
1987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1988                 NDR_PULL_ALLOC(ndr, r->out.service_status);
1989                 ZERO_STRUCTP(r->out.service_status);
1990         }
1991         if (flags & NDR_OUT) {
1992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1993                         NDR_PULL_ALLOC(ndr, r->out.service_status);
1994                 }
1995                 _mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
1996                 NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, LIBNDR_FLAG_REF_ALLOC);
1997                 NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
1998                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, LIBNDR_FLAG_REF_ALLOC);
1999                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2000         }
2001         return NDR_ERR_SUCCESS;
2002 }
2003
2004 _PUBLIC_ void ndr_print_svcctl_QueryServiceStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceStatus *r)
2005 {
2006         ndr_print_struct(ndr, name, "svcctl_QueryServiceStatus");
2007         if (r == NULL) { ndr_print_null(ndr); return; }
2008         ndr->depth++;
2009         if (flags & NDR_SET_VALUES) {
2010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2011         }
2012         if (flags & NDR_IN) {
2013                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceStatus");
2014                 ndr->depth++;
2015                 ndr_print_ptr(ndr, "handle", r->in.handle);
2016                 ndr->depth++;
2017                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2018                 ndr->depth--;
2019                 ndr->depth--;
2020         }
2021         if (flags & NDR_OUT) {
2022                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceStatus");
2023                 ndr->depth++;
2024                 ndr_print_ptr(ndr, "service_status", r->out.service_status);
2025                 ndr->depth++;
2026                 ndr_print_SERVICE_STATUS(ndr, "service_status", r->out.service_status);
2027                 ndr->depth--;
2028                 ndr_print_WERROR(ndr, "result", r->out.result);
2029                 ndr->depth--;
2030         }
2031         ndr->depth--;
2032 }
2033
2034 static enum ndr_err_code ndr_push_svcctl_SetServiceStatus(struct ndr_push *ndr, int flags, const struct svcctl_SetServiceStatus *r)
2035 {
2036         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2037         if (flags & NDR_IN) {
2038         }
2039         if (flags & NDR_OUT) {
2040                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2041         }
2042         return NDR_ERR_SUCCESS;
2043 }
2044
2045 static enum ndr_err_code ndr_pull_svcctl_SetServiceStatus(struct ndr_pull *ndr, int flags, struct svcctl_SetServiceStatus *r)
2046 {
2047         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2048         if (flags & NDR_IN) {
2049         }
2050         if (flags & NDR_OUT) {
2051                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2052         }
2053         return NDR_ERR_SUCCESS;
2054 }
2055
2056 _PUBLIC_ void ndr_print_svcctl_SetServiceStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SetServiceStatus *r)
2057 {
2058         ndr_print_struct(ndr, name, "svcctl_SetServiceStatus");
2059         if (r == NULL) { ndr_print_null(ndr); return; }
2060         ndr->depth++;
2061         if (flags & NDR_SET_VALUES) {
2062                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2063         }
2064         if (flags & NDR_IN) {
2065                 ndr_print_struct(ndr, "in", "svcctl_SetServiceStatus");
2066                 ndr->depth++;
2067                 ndr->depth--;
2068         }
2069         if (flags & NDR_OUT) {
2070                 ndr_print_struct(ndr, "out", "svcctl_SetServiceStatus");
2071                 ndr->depth++;
2072                 ndr_print_WERROR(ndr, "result", r->out.result);
2073                 ndr->depth--;
2074         }
2075         ndr->depth--;
2076 }
2077
2078 static enum ndr_err_code ndr_push_svcctl_UnlockServiceDatabase(struct ndr_push *ndr, int flags, const struct svcctl_UnlockServiceDatabase *r)
2079 {
2080         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2081         if (flags & NDR_IN) {
2082                 if (r->in.lock == NULL) {
2083                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2084                 }
2085                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.lock));
2086         }
2087         if (flags & NDR_OUT) {
2088                 if (r->out.lock == NULL) {
2089                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2090                 }
2091                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.lock));
2092                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2093         }
2094         return NDR_ERR_SUCCESS;
2095 }
2096
2097 static enum ndr_err_code ndr_pull_svcctl_UnlockServiceDatabase(struct ndr_pull *ndr, int flags, struct svcctl_UnlockServiceDatabase *r)
2098 {
2099         TALLOC_CTX *_mem_save_lock_0;
2100         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2101         if (flags & NDR_IN) {
2102                 ZERO_STRUCT(r->out);
2103
2104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2105                         NDR_PULL_ALLOC(ndr, r->in.lock);
2106                 }
2107                 _mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);
2108                 NDR_PULL_SET_MEM_CTX(ndr, r->in.lock, LIBNDR_FLAG_REF_ALLOC);
2109                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.lock));
2110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);
2111                 NDR_PULL_ALLOC(ndr, r->out.lock);
2112                 *r->out.lock = *r->in.lock;
2113         }
2114         if (flags & NDR_OUT) {
2115                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2116                         NDR_PULL_ALLOC(ndr, r->out.lock);
2117                 }
2118                 _mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);
2119                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lock, LIBNDR_FLAG_REF_ALLOC);
2120                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.lock));
2121                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);
2122                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2123         }
2124         return NDR_ERR_SUCCESS;
2125 }
2126
2127 _PUBLIC_ void ndr_print_svcctl_UnlockServiceDatabase(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_UnlockServiceDatabase *r)
2128 {
2129         ndr_print_struct(ndr, name, "svcctl_UnlockServiceDatabase");
2130         if (r == NULL) { ndr_print_null(ndr); return; }
2131         ndr->depth++;
2132         if (flags & NDR_SET_VALUES) {
2133                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2134         }
2135         if (flags & NDR_IN) {
2136                 ndr_print_struct(ndr, "in", "svcctl_UnlockServiceDatabase");
2137                 ndr->depth++;
2138                 ndr_print_ptr(ndr, "lock", r->in.lock);
2139                 ndr->depth++;
2140                 ndr_print_policy_handle(ndr, "lock", r->in.lock);
2141                 ndr->depth--;
2142                 ndr->depth--;
2143         }
2144         if (flags & NDR_OUT) {
2145                 ndr_print_struct(ndr, "out", "svcctl_UnlockServiceDatabase");
2146                 ndr->depth++;
2147                 ndr_print_ptr(ndr, "lock", r->out.lock);
2148                 ndr->depth++;
2149                 ndr_print_policy_handle(ndr, "lock", r->out.lock);
2150                 ndr->depth--;
2151                 ndr_print_WERROR(ndr, "result", r->out.result);
2152                 ndr->depth--;
2153         }
2154         ndr->depth--;
2155 }
2156
2157 static enum ndr_err_code ndr_push_svcctl_NotifyBootConfigStatus(struct ndr_push *ndr, int flags, const struct svcctl_NotifyBootConfigStatus *r)
2158 {
2159         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2160         if (flags & NDR_IN) {
2161         }
2162         if (flags & NDR_OUT) {
2163                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2164         }
2165         return NDR_ERR_SUCCESS;
2166 }
2167
2168 static enum ndr_err_code ndr_pull_svcctl_NotifyBootConfigStatus(struct ndr_pull *ndr, int flags, struct svcctl_NotifyBootConfigStatus *r)
2169 {
2170         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2171         if (flags & NDR_IN) {
2172         }
2173         if (flags & NDR_OUT) {
2174                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2175         }
2176         return NDR_ERR_SUCCESS;
2177 }
2178
2179 _PUBLIC_ void ndr_print_svcctl_NotifyBootConfigStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_NotifyBootConfigStatus *r)
2180 {
2181         ndr_print_struct(ndr, name, "svcctl_NotifyBootConfigStatus");
2182         if (r == NULL) { ndr_print_null(ndr); return; }
2183         ndr->depth++;
2184         if (flags & NDR_SET_VALUES) {
2185                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2186         }
2187         if (flags & NDR_IN) {
2188                 ndr_print_struct(ndr, "in", "svcctl_NotifyBootConfigStatus");
2189                 ndr->depth++;
2190                 ndr->depth--;
2191         }
2192         if (flags & NDR_OUT) {
2193                 ndr_print_struct(ndr, "out", "svcctl_NotifyBootConfigStatus");
2194                 ndr->depth++;
2195                 ndr_print_WERROR(ndr, "result", r->out.result);
2196                 ndr->depth--;
2197         }
2198         ndr->depth--;
2199 }
2200
2201 static enum ndr_err_code ndr_push_svcctl_SCSetServiceBitsW(struct ndr_push *ndr, int flags, const struct svcctl_SCSetServiceBitsW *r)
2202 {
2203         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2204         if (flags & NDR_IN) {
2205                 if (r->in.handle == NULL) {
2206                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2207                 }
2208                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bits));
2210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bitson));
2211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.immediate));
2212         }
2213         if (flags & NDR_OUT) {
2214                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2215         }
2216         return NDR_ERR_SUCCESS;
2217 }
2218
2219 static enum ndr_err_code ndr_pull_svcctl_SCSetServiceBitsW(struct ndr_pull *ndr, int flags, struct svcctl_SCSetServiceBitsW *r)
2220 {
2221         TALLOC_CTX *_mem_save_handle_0;
2222         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2223         if (flags & NDR_IN) {
2224                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2225                         NDR_PULL_ALLOC(ndr, r->in.handle);
2226                 }
2227                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2228                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2229                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2230                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bits));
2232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bitson));
2233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.immediate));
2234         }
2235         if (flags & NDR_OUT) {
2236                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2237         }
2238         return NDR_ERR_SUCCESS;
2239 }
2240
2241 _PUBLIC_ void ndr_print_svcctl_SCSetServiceBitsW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSetServiceBitsW *r)
2242 {
2243         ndr_print_struct(ndr, name, "svcctl_SCSetServiceBitsW");
2244         if (r == NULL) { ndr_print_null(ndr); return; }
2245         ndr->depth++;
2246         if (flags & NDR_SET_VALUES) {
2247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2248         }
2249         if (flags & NDR_IN) {
2250                 ndr_print_struct(ndr, "in", "svcctl_SCSetServiceBitsW");
2251                 ndr->depth++;
2252                 ndr_print_ptr(ndr, "handle", r->in.handle);
2253                 ndr->depth++;
2254                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2255                 ndr->depth--;
2256                 ndr_print_uint32(ndr, "bits", r->in.bits);
2257                 ndr_print_uint32(ndr, "bitson", r->in.bitson);
2258                 ndr_print_uint32(ndr, "immediate", r->in.immediate);
2259                 ndr->depth--;
2260         }
2261         if (flags & NDR_OUT) {
2262                 ndr_print_struct(ndr, "out", "svcctl_SCSetServiceBitsW");
2263                 ndr->depth++;
2264                 ndr_print_WERROR(ndr, "result", r->out.result);
2265                 ndr->depth--;
2266         }
2267         ndr->depth--;
2268 }
2269
2270 static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfigW(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfigW *r)
2271 {
2272         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2273         if (flags & NDR_IN) {
2274                 if (r->in.handle == NULL) {
2275                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2276                 }
2277                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
2279                 NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
2280                 NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
2281                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
2282                 if (r->in.binary_path) {
2283                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2286                         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));
2287                 }
2288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.load_order_group));
2289                 if (r->in.load_order_group) {
2290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
2291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
2293                         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));
2294                 }
2295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
2296                 if (r->in.dependencies) {
2297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
2298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2299                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
2300                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2301                 }
2302                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
2303                 if (r->in.service_start_name) {
2304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2306                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2307                         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));
2308                 }
2309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
2310                 if (r->in.password) {
2311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
2312                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2313                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
2314                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2315                 }
2316                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name));
2317                 if (r->in.display_name) {
2318                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
2319                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2320                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
2321                         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));
2322                 }
2323         }
2324         if (flags & NDR_OUT) {
2325                 if (r->out.tag_id == NULL) {
2326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2327                 }
2328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.tag_id));
2329                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2330         }
2331         return NDR_ERR_SUCCESS;
2332 }
2333
2334 static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfigW(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfigW *r)
2335 {
2336         uint32_t _ptr_binary_path;
2337         uint32_t size_binary_path_1 = 0;
2338         uint32_t length_binary_path_1 = 0;
2339         uint32_t _ptr_load_order_group;
2340         uint32_t size_load_order_group_1 = 0;
2341         uint32_t length_load_order_group_1 = 0;
2342         uint32_t _ptr_dependencies;
2343         uint32_t size_dependencies_1 = 0;
2344         uint32_t length_dependencies_1 = 0;
2345         uint32_t _ptr_service_start_name;
2346         uint32_t size_service_start_name_1 = 0;
2347         uint32_t length_service_start_name_1 = 0;
2348         uint32_t _ptr_password;
2349         uint32_t size_password_1 = 0;
2350         uint32_t length_password_1 = 0;
2351         uint32_t _ptr_display_name;
2352         uint32_t size_display_name_1 = 0;
2353         uint32_t length_display_name_1 = 0;
2354         TALLOC_CTX *_mem_save_handle_0;
2355         TALLOC_CTX *_mem_save_binary_path_0;
2356         TALLOC_CTX *_mem_save_load_order_group_0;
2357         TALLOC_CTX *_mem_save_tag_id_0;
2358         TALLOC_CTX *_mem_save_dependencies_0;
2359         TALLOC_CTX *_mem_save_service_start_name_0;
2360         TALLOC_CTX *_mem_save_password_0;
2361         TALLOC_CTX *_mem_save_display_name_0;
2362         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2363         if (flags & NDR_IN) {
2364                 ZERO_STRUCT(r->out);
2365
2366                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2367                         NDR_PULL_ALLOC(ndr, r->in.handle);
2368                 }
2369                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2370                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2371                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
2372                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
2374                 NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
2375                 NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
2376                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
2377                 if (_ptr_binary_path) {
2378                         NDR_PULL_ALLOC(ndr, r->in.binary_path);
2379                 } else {
2380                         r->in.binary_path = NULL;
2381                 }
2382                 if (r->in.binary_path) {
2383                         _mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
2384                         NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);
2385                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
2386                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
2387                         size_binary_path_1 = ndr_get_array_size(ndr, &r->in.binary_path);
2388                         length_binary_path_1 = ndr_get_array_length(ndr, &r->in.binary_path);
2389                         if (length_binary_path_1 > size_binary_path_1) {
2390                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_binary_path_1, length_binary_path_1);
2391                         }
2392                         NDR_CHECK(ndr_check_string_terminator(ndr, length_binary_path_1, sizeof(uint16_t)));
2393                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, length_binary_path_1, sizeof(uint16_t), CH_UTF16));
2394                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);
2395                 }
2396                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_load_order_group));
2397                 if (_ptr_load_order_group) {
2398                         NDR_PULL_ALLOC(ndr, r->in.load_order_group);
2399                 } else {
2400                         r->in.load_order_group = NULL;
2401                 }
2402                 if (r->in.load_order_group) {
2403                         _mem_save_load_order_group_0 = NDR_PULL_GET_MEM_CTX(ndr);
2404                         NDR_PULL_SET_MEM_CTX(ndr, r->in.load_order_group, 0);
2405                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.load_order_group));
2406                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.load_order_group));
2407                         size_load_order_group_1 = ndr_get_array_size(ndr, &r->in.load_order_group);
2408                         length_load_order_group_1 = ndr_get_array_length(ndr, &r->in.load_order_group);
2409                         if (length_load_order_group_1 > size_load_order_group_1) {
2410                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_load_order_group_1, length_load_order_group_1);
2411                         }
2412                         NDR_CHECK(ndr_check_string_terminator(ndr, length_load_order_group_1, sizeof(uint16_t)));
2413                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.load_order_group, length_load_order_group_1, sizeof(uint16_t), CH_UTF16));
2414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_load_order_group_0, 0);
2415                 }
2416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
2417                 if (_ptr_dependencies) {
2418                         NDR_PULL_ALLOC(ndr, r->in.dependencies);
2419                 } else {
2420                         r->in.dependencies = NULL;
2421                 }
2422                 if (r->in.dependencies) {
2423                         _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
2424                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
2425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
2426                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));
2427                         size_dependencies_1 = ndr_get_array_size(ndr, &r->in.dependencies);
2428                         length_dependencies_1 = ndr_get_array_length(ndr, &r->in.dependencies);
2429                         if (length_dependencies_1 > size_dependencies_1) {
2430                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dependencies_1, length_dependencies_1);
2431                         }
2432                         NDR_CHECK(ndr_check_string_terminator(ndr, length_dependencies_1, sizeof(uint16_t)));
2433                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, length_dependencies_1, sizeof(uint16_t), CH_UTF16));
2434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
2435                 }
2436                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
2437                 if (_ptr_service_start_name) {
2438                         NDR_PULL_ALLOC(ndr, r->in.service_start_name);
2439                 } else {
2440                         r->in.service_start_name = NULL;
2441                 }
2442                 if (r->in.service_start_name) {
2443                         _mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2444                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
2445                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
2446                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
2447                         size_service_start_name_1 = ndr_get_array_size(ndr, &r->in.service_start_name);
2448                         length_service_start_name_1 = ndr_get_array_length(ndr, &r->in.service_start_name);
2449                         if (length_service_start_name_1 > size_service_start_name_1) {
2450                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_service_start_name_1, length_service_start_name_1);
2451                         }
2452                         NDR_CHECK(ndr_check_string_terminator(ndr, length_service_start_name_1, sizeof(uint16_t)));
2453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, length_service_start_name_1, sizeof(uint16_t), CH_UTF16));
2454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
2455                 }
2456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
2457                 if (_ptr_password) {
2458                         NDR_PULL_ALLOC(ndr, r->in.password);
2459                 } else {
2460                         r->in.password = NULL;
2461                 }
2462                 if (r->in.password) {
2463                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2464                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
2465                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
2466                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
2467                         size_password_1 = ndr_get_array_size(ndr, &r->in.password);
2468                         length_password_1 = ndr_get_array_length(ndr, &r->in.password);
2469                         if (length_password_1 > size_password_1) {
2470                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_password_1, length_password_1);
2471                         }
2472                         NDR_CHECK(ndr_check_string_terminator(ndr, length_password_1, sizeof(uint16_t)));
2473                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, length_password_1, sizeof(uint16_t), CH_UTF16));
2474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
2475                 }
2476                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
2477                 if (_ptr_display_name) {
2478                         NDR_PULL_ALLOC(ndr, r->in.display_name);
2479                 } else {
2480                         r->in.display_name = NULL;
2481                 }
2482                 if (r->in.display_name) {
2483                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2484                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name, 0);
2485                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.display_name));
2486                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.display_name));
2487                         size_display_name_1 = ndr_get_array_size(ndr, &r->in.display_name);
2488                         length_display_name_1 = ndr_get_array_length(ndr, &r->in.display_name);
2489                         if (length_display_name_1 > size_display_name_1) {
2490                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_display_name_1, length_display_name_1);
2491                         }
2492                         NDR_CHECK(ndr_check_string_terminator(ndr, length_display_name_1, sizeof(uint16_t)));
2493                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.display_name, length_display_name_1, sizeof(uint16_t), CH_UTF16));
2494                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
2495                 }
2496                 NDR_PULL_ALLOC(ndr, r->out.tag_id);
2497                 ZERO_STRUCTP(r->out.tag_id);
2498         }
2499         if (flags & NDR_OUT) {
2500                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2501                         NDR_PULL_ALLOC(ndr, r->out.tag_id);
2502                 }
2503                 _mem_save_tag_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
2504                 NDR_PULL_SET_MEM_CTX(ndr, r->out.tag_id, LIBNDR_FLAG_REF_ALLOC);
2505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.tag_id));
2506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tag_id_0, LIBNDR_FLAG_REF_ALLOC);
2507                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2508         }
2509         return NDR_ERR_SUCCESS;
2510 }
2511
2512 _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfigW *r)
2513 {
2514         ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfigW");
2515         if (r == NULL) { ndr_print_null(ndr); return; }
2516         ndr->depth++;
2517         if (flags & NDR_SET_VALUES) {
2518                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2519         }
2520         if (flags & NDR_IN) {
2521                 ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfigW");
2522                 ndr->depth++;
2523                 ndr_print_ptr(ndr, "handle", r->in.handle);
2524                 ndr->depth++;
2525                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2526                 ndr->depth--;
2527                 ndr_print_uint32(ndr, "type", r->in.type);
2528                 ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
2529                 ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
2530                 ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
2531                 ndr->depth++;
2532                 if (r->in.binary_path) {
2533                         ndr_print_string(ndr, "binary_path", r->in.binary_path);
2534                 }
2535                 ndr->depth--;
2536                 ndr_print_ptr(ndr, "load_order_group", r->in.load_order_group);
2537                 ndr->depth++;
2538                 if (r->in.load_order_group) {
2539                         ndr_print_string(ndr, "load_order_group", r->in.load_order_group);
2540                 }
2541                 ndr->depth--;
2542                 ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
2543                 ndr->depth++;
2544                 if (r->in.dependencies) {
2545                         ndr_print_string(ndr, "dependencies", r->in.dependencies);
2546                 }
2547                 ndr->depth--;
2548                 ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
2549                 ndr->depth++;
2550                 if (r->in.service_start_name) {
2551                         ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
2552                 }
2553                 ndr->depth--;
2554                 ndr_print_ptr(ndr, "password", r->in.password);
2555                 ndr->depth++;
2556                 if (r->in.password) {
2557                         ndr_print_string(ndr, "password", r->in.password);
2558                 }
2559                 ndr->depth--;
2560                 ndr_print_ptr(ndr, "display_name", r->in.display_name);
2561                 ndr->depth++;
2562                 if (r->in.display_name) {
2563                         ndr_print_string(ndr, "display_name", r->in.display_name);
2564                 }
2565                 ndr->depth--;
2566                 ndr->depth--;
2567         }
2568         if (flags & NDR_OUT) {
2569                 ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfigW");
2570                 ndr->depth++;
2571                 ndr_print_ptr(ndr, "tag_id", r->out.tag_id);
2572                 ndr->depth++;
2573                 ndr_print_uint32(ndr, "tag_id", *r->out.tag_id);
2574                 ndr->depth--;
2575                 ndr_print_WERROR(ndr, "result", r->out.result);
2576                 ndr->depth--;
2577         }
2578         ndr->depth--;
2579 }
2580
2581 static enum ndr_err_code ndr_push_svcctl_CreateServiceW(struct ndr_push *ndr, int flags, const struct svcctl_CreateServiceW *r)
2582 {
2583         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2584         if (flags & NDR_IN) {
2585                 if (r->in.scmanager_handle == NULL) {
2586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2587                 }
2588                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
2589                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
2590                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2591                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
2592                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DisplayName));
2594                 if (r->in.DisplayName) {
2595                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
2596                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2597                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
2598                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2599                 }
2600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.desired_access));
2601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
2602                 NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
2603                 NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
2604                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2605                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2606                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2607                 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));
2608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.LoadOrderGroupKey));
2609                 if (r->in.LoadOrderGroupKey) {
2610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
2611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2612                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
2613                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2614                 }
2615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.TagId));
2616                 if (r->in.TagId) {
2617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.TagId));
2618                 }
2619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
2620                 if (r->in.dependencies) {
2621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.dependencies_size));
2622                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.dependencies, r->in.dependencies_size));
2623                 }
2624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dependencies_size));
2625                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
2626                 if (r->in.service_start_name) {
2627                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
2629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2630                         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));
2631                 }
2632                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
2633                 if (r->in.password) {
2634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.password_size));
2635                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.password, r->in.password_size));
2636                 }
2637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.password_size));
2638         }
2639         if (flags & NDR_OUT) {
2640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.TagId));
2641                 if (r->out.TagId) {
2642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.TagId));
2643                 }
2644                 if (r->out.handle == NULL) {
2645                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2646                 }
2647                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
2648                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2649         }
2650         return NDR_ERR_SUCCESS;
2651 }
2652
2653 static enum ndr_err_code ndr_pull_svcctl_CreateServiceW(struct ndr_pull *ndr, int flags, struct svcctl_CreateServiceW *r)
2654 {
2655         uint32_t size_ServiceName_0 = 0;
2656         uint32_t length_ServiceName_0 = 0;
2657         uint32_t _ptr_DisplayName;
2658         uint32_t size_DisplayName_1 = 0;
2659         uint32_t length_DisplayName_1 = 0;
2660         uint32_t size_binary_path_0 = 0;
2661         uint32_t length_binary_path_0 = 0;
2662         uint32_t _ptr_LoadOrderGroupKey;
2663         uint32_t size_LoadOrderGroupKey_1 = 0;
2664         uint32_t length_LoadOrderGroupKey_1 = 0;
2665         uint32_t _ptr_TagId;
2666         uint32_t _ptr_dependencies;
2667         uint32_t size_dependencies_1 = 0;
2668         uint32_t _ptr_service_start_name;
2669         uint32_t size_service_start_name_1 = 0;
2670         uint32_t length_service_start_name_1 = 0;
2671         uint32_t _ptr_password;
2672         uint32_t size_password_1 = 0;
2673         TALLOC_CTX *_mem_save_scmanager_handle_0;
2674         TALLOC_CTX *_mem_save_DisplayName_0;
2675         TALLOC_CTX *_mem_save_LoadOrderGroupKey_0;
2676         TALLOC_CTX *_mem_save_TagId_0;
2677         TALLOC_CTX *_mem_save_dependencies_0;
2678         TALLOC_CTX *_mem_save_service_start_name_0;
2679         TALLOC_CTX *_mem_save_password_0;
2680         TALLOC_CTX *_mem_save_handle_0;
2681         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2682         if (flags & NDR_IN) {
2683                 ZERO_STRUCT(r->out);
2684
2685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2686                         NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);
2687                 }
2688                 _mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2689                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);
2690                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
2691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);
2692                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
2693                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
2694                 size_ServiceName_0 = ndr_get_array_size(ndr, &r->in.ServiceName);
2695                 length_ServiceName_0 = ndr_get_array_length(ndr, &r->in.ServiceName);
2696                 if (length_ServiceName_0 > size_ServiceName_0) {
2697                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ServiceName_0, length_ServiceName_0);
2698                 }
2699                 NDR_CHECK(ndr_check_string_terminator(ndr, length_ServiceName_0, sizeof(uint16_t)));
2700                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, length_ServiceName_0, sizeof(uint16_t), CH_UTF16));
2701                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DisplayName));
2702                 if (_ptr_DisplayName) {
2703                         NDR_PULL_ALLOC(ndr, r->in.DisplayName);
2704                 } else {
2705                         r->in.DisplayName = NULL;
2706                 }
2707                 if (r->in.DisplayName) {
2708                         _mem_save_DisplayName_0 = NDR_PULL_GET_MEM_CTX(ndr);
2709                         NDR_PULL_SET_MEM_CTX(ndr, r->in.DisplayName, 0);
2710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DisplayName));
2711                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DisplayName));
2712                         size_DisplayName_1 = ndr_get_array_size(ndr, &r->in.DisplayName);
2713                         length_DisplayName_1 = ndr_get_array_length(ndr, &r->in.DisplayName);
2714                         if (length_DisplayName_1 > size_DisplayName_1) {
2715                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_DisplayName_1, length_DisplayName_1);
2716                         }
2717                         NDR_CHECK(ndr_check_string_terminator(ndr, length_DisplayName_1, sizeof(uint16_t)));
2718                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DisplayName, length_DisplayName_1, sizeof(uint16_t), CH_UTF16));
2719                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DisplayName_0, 0);
2720                 }
2721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.desired_access));
2722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
2723                 NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
2724                 NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
2725                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
2726                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
2727                 size_binary_path_0 = ndr_get_array_size(ndr, &r->in.binary_path);
2728                 length_binary_path_0 = ndr_get_array_length(ndr, &r->in.binary_path);
2729                 if (length_binary_path_0 > size_binary_path_0) {
2730                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_binary_path_0, length_binary_path_0);
2731                 }
2732                 NDR_CHECK(ndr_check_string_terminator(ndr, length_binary_path_0, sizeof(uint16_t)));
2733                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, length_binary_path_0, sizeof(uint16_t), CH_UTF16));
2734                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_LoadOrderGroupKey));
2735                 if (_ptr_LoadOrderGroupKey) {
2736                         NDR_PULL_ALLOC(ndr, r->in.LoadOrderGroupKey);
2737                 } else {
2738                         r->in.LoadOrderGroupKey = NULL;
2739                 }
2740                 if (r->in.LoadOrderGroupKey) {
2741                         _mem_save_LoadOrderGroupKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
2742                         NDR_PULL_SET_MEM_CTX(ndr, r->in.LoadOrderGroupKey, 0);
2743                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.LoadOrderGroupKey));
2744                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.LoadOrderGroupKey));
2745                         size_LoadOrderGroupKey_1 = ndr_get_array_size(ndr, &r->in.LoadOrderGroupKey);
2746                         length_LoadOrderGroupKey_1 = ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey);
2747                         if (length_LoadOrderGroupKey_1 > size_LoadOrderGroupKey_1) {
2748                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_LoadOrderGroupKey_1, length_LoadOrderGroupKey_1);
2749                         }
2750                         NDR_CHECK(ndr_check_string_terminator(ndr, length_LoadOrderGroupKey_1, sizeof(uint16_t)));
2751                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.LoadOrderGroupKey, length_LoadOrderGroupKey_1, sizeof(uint16_t), CH_UTF16));
2752                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_LoadOrderGroupKey_0, 0);
2753                 }
2754                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));
2755                 if (_ptr_TagId) {
2756                         NDR_PULL_ALLOC(ndr, r->in.TagId);
2757                 } else {
2758                         r->in.TagId = NULL;
2759                 }
2760                 if (r->in.TagId) {
2761                         _mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);
2762                         NDR_PULL_SET_MEM_CTX(ndr, r->in.TagId, 0);
2763                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.TagId));
2764                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);
2765                 }
2766                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
2767                 if (_ptr_dependencies) {
2768                         NDR_PULL_ALLOC(ndr, r->in.dependencies);
2769                 } else {
2770                         r->in.dependencies = NULL;
2771                 }
2772                 if (r->in.dependencies) {
2773                         _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
2774                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
2775                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
2776                         size_dependencies_1 = ndr_get_array_size(ndr, &r->in.dependencies);
2777                         NDR_PULL_ALLOC_N(ndr, r->in.dependencies, size_dependencies_1);
2778                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.dependencies, size_dependencies_1));
2779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
2780                 }
2781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dependencies_size));
2782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
2783                 if (_ptr_service_start_name) {
2784                         NDR_PULL_ALLOC(ndr, r->in.service_start_name);
2785                 } else {
2786                         r->in.service_start_name = NULL;
2787                 }
2788                 if (r->in.service_start_name) {
2789                         _mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2790                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
2791                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
2792                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
2793                         size_service_start_name_1 = ndr_get_array_size(ndr, &r->in.service_start_name);
2794                         length_service_start_name_1 = ndr_get_array_length(ndr, &r->in.service_start_name);
2795                         if (length_service_start_name_1 > size_service_start_name_1) {
2796                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_service_start_name_1, length_service_start_name_1);
2797                         }
2798                         NDR_CHECK(ndr_check_string_terminator(ndr, length_service_start_name_1, sizeof(uint16_t)));
2799                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, length_service_start_name_1, sizeof(uint16_t), CH_UTF16));
2800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
2801                 }
2802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
2803                 if (_ptr_password) {
2804                         NDR_PULL_ALLOC(ndr, r->in.password);
2805                 } else {
2806                         r->in.password = NULL;
2807                 }
2808                 if (r->in.password) {
2809                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2810                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
2811                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
2812                         size_password_1 = ndr_get_array_size(ndr, &r->in.password);
2813                         NDR_PULL_ALLOC_N(ndr, r->in.password, size_password_1);
2814                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.password, size_password_1));
2815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
2816                 }
2817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.password_size));
2818                 NDR_PULL_ALLOC(ndr, r->out.handle);
2819                 ZERO_STRUCTP(r->out.handle);
2820                 if (r->in.dependencies) {
2821                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.dependencies, r->in.dependencies_size));
2822                 }
2823                 if (r->in.password) {
2824                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.password, r->in.password_size));
2825                 }
2826         }
2827         if (flags & NDR_OUT) {
2828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));
2829                 if (_ptr_TagId) {
2830                         NDR_PULL_ALLOC(ndr, r->out.TagId);
2831                 } else {
2832                         r->out.TagId = NULL;
2833                 }
2834                 if (r->out.TagId) {
2835                         _mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);
2836                         NDR_PULL_SET_MEM_CTX(ndr, r->out.TagId, 0);
2837                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.TagId));
2838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);
2839                 }
2840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2841                         NDR_PULL_ALLOC(ndr, r->out.handle);
2842                 }
2843                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2844                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
2845                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
2846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2847                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2848         }
2849         return NDR_ERR_SUCCESS;
2850 }
2851
2852 _PUBLIC_ void ndr_print_svcctl_CreateServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CreateServiceW *r)
2853 {
2854         ndr_print_struct(ndr, name, "svcctl_CreateServiceW");
2855         if (r == NULL) { ndr_print_null(ndr); return; }
2856         ndr->depth++;
2857         if (flags & NDR_SET_VALUES) {
2858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2859         }
2860         if (flags & NDR_IN) {
2861                 ndr_print_struct(ndr, "in", "svcctl_CreateServiceW");
2862                 ndr->depth++;
2863                 ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);
2864                 ndr->depth++;
2865                 ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);
2866                 ndr->depth--;
2867                 ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
2868                 ndr_print_ptr(ndr, "DisplayName", r->in.DisplayName);
2869                 ndr->depth++;
2870                 if (r->in.DisplayName) {
2871                         ndr_print_string(ndr, "DisplayName", r->in.DisplayName);
2872                 }
2873                 ndr->depth--;
2874                 ndr_print_uint32(ndr, "desired_access", r->in.desired_access);
2875                 ndr_print_uint32(ndr, "type", r->in.type);
2876                 ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
2877                 ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
2878                 ndr_print_string(ndr, "binary_path", r->in.binary_path);
2879                 ndr_print_ptr(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
2880                 ndr->depth++;
2881                 if (r->in.LoadOrderGroupKey) {
2882                         ndr_print_string(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
2883                 }
2884                 ndr->depth--;
2885                 ndr_print_ptr(ndr, "TagId", r->in.TagId);
2886                 ndr->depth++;
2887                 if (r->in.TagId) {
2888                         ndr_print_uint32(ndr, "TagId", *r->in.TagId);
2889                 }
2890                 ndr->depth--;
2891                 ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
2892                 ndr->depth++;
2893                 if (r->in.dependencies) {
2894                         ndr_print_array_uint8(ndr, "dependencies", r->in.dependencies, r->in.dependencies_size);
2895                 }
2896                 ndr->depth--;
2897                 ndr_print_uint32(ndr, "dependencies_size", r->in.dependencies_size);
2898                 ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
2899                 ndr->depth++;
2900                 if (r->in.service_start_name) {
2901                         ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
2902                 }
2903                 ndr->depth--;
2904                 ndr_print_ptr(ndr, "password", r->in.password);
2905                 ndr->depth++;
2906                 if (r->in.password) {
2907                         ndr_print_array_uint8(ndr, "password", r->in.password, r->in.password_size);
2908                 }
2909                 ndr->depth--;
2910                 ndr_print_uint32(ndr, "password_size", r->in.password_size);
2911                 ndr->depth--;
2912         }
2913         if (flags & NDR_OUT) {
2914                 ndr_print_struct(ndr, "out", "svcctl_CreateServiceW");
2915                 ndr->depth++;
2916                 ndr_print_ptr(ndr, "TagId", r->out.TagId);
2917                 ndr->depth++;
2918                 if (r->out.TagId) {
2919                         ndr_print_uint32(ndr, "TagId", *r->out.TagId);
2920                 }
2921                 ndr->depth--;
2922                 ndr_print_ptr(ndr, "handle", r->out.handle);
2923                 ndr->depth++;
2924                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
2925                 ndr->depth--;
2926                 ndr_print_WERROR(ndr, "result", r->out.result);
2927                 ndr->depth--;
2928         }
2929         ndr->depth--;
2930 }
2931
2932 static enum ndr_err_code ndr_push_svcctl_EnumDependentServicesW(struct ndr_push *ndr, int flags, const struct svcctl_EnumDependentServicesW *r)
2933 {
2934         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
2935         if (flags & NDR_IN) {
2936                 if (r->in.service == NULL) {
2937                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2938                 }
2939                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.service));
2940                 NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
2941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
2942         }
2943         if (flags & NDR_OUT) {
2944                 if (r->out.service_status == NULL) {
2945                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2946                 }
2947                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
2948                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service_status, r->in.offered));
2949                 if (r->out.needed == NULL) {
2950                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2951                 }
2952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
2953                 if (r->out.services_returned == NULL) {
2954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
2955                 }
2956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
2957                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2958         }
2959         return NDR_ERR_SUCCESS;
2960 }
2961
2962 static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesW(struct ndr_pull *ndr, int flags, struct svcctl_EnumDependentServicesW *r)
2963 {
2964         uint32_t size_service_status_1 = 0;
2965         TALLOC_CTX *_mem_save_service_0;
2966         TALLOC_CTX *_mem_save_needed_0;
2967         TALLOC_CTX *_mem_save_services_returned_0;
2968         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
2969         if (flags & NDR_IN) {
2970                 ZERO_STRUCT(r->out);
2971
2972                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2973                         NDR_PULL_ALLOC(ndr, r->in.service);
2974                 }
2975                 _mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);
2976                 NDR_PULL_SET_MEM_CTX(ndr, r->in.service, LIBNDR_FLAG_REF_ALLOC);
2977                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.service));
2978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);
2979                 NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
2980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
2981                 if (r->in.offered > 0x40000) {
2982                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2983                 }
2984                 NDR_PULL_ALLOC_N(ndr, r->out.service_status, r->in.offered);
2985                 memset(r->out.service_status, 0, (r->in.offered) * sizeof(*r->out.service_status));
2986                 NDR_PULL_ALLOC(ndr, r->out.needed);
2987                 ZERO_STRUCTP(r->out.needed);
2988                 NDR_PULL_ALLOC(ndr, r->out.services_returned);
2989                 ZERO_STRUCTP(r->out.services_returned);
2990         }
2991         if (flags & NDR_OUT) {
2992                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.service_status));
2993                 size_service_status_1 = ndr_get_array_size(ndr, &r->out.service_status);
2994                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2995                         NDR_PULL_ALLOC_N(ndr, r->out.service_status, size_service_status_1);
2996                 }
2997                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service_status, size_service_status_1));
2998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2999                         NDR_PULL_ALLOC(ndr, r->out.needed);
3000                 }
3001                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3002                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
3003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
3004                 if (*r->out.needed > 0x40000) {
3005                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3006                 }
3007                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
3008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3009                         NDR_PULL_ALLOC(ndr, r->out.services_returned);
3010                 }
3011                 _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
3012                 NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
3013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
3014                 if (*r->out.services_returned > 0x40000) {
3015                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3016                 }
3017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
3018                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3019                 if (r->out.service_status) {
3020                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service_status, r->in.offered));
3021                 }
3022         }
3023         return NDR_ERR_SUCCESS;
3024 }
3025
3026 _PUBLIC_ void ndr_print_svcctl_EnumDependentServicesW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumDependentServicesW *r)
3027 {
3028         ndr_print_struct(ndr, name, "svcctl_EnumDependentServicesW");
3029         if (r == NULL) { ndr_print_null(ndr); return; }
3030         ndr->depth++;
3031         if (flags & NDR_SET_VALUES) {
3032                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3033         }
3034         if (flags & NDR_IN) {
3035                 ndr_print_struct(ndr, "in", "svcctl_EnumDependentServicesW");
3036                 ndr->depth++;
3037                 ndr_print_ptr(ndr, "service", r->in.service);
3038                 ndr->depth++;
3039                 ndr_print_policy_handle(ndr, "service", r->in.service);
3040                 ndr->depth--;
3041                 ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
3042                 ndr_print_uint32(ndr, "offered", r->in.offered);
3043                 ndr->depth--;
3044         }
3045         if (flags & NDR_OUT) {
3046                 ndr_print_struct(ndr, "out", "svcctl_EnumDependentServicesW");
3047                 ndr->depth++;
3048                 ndr_print_ptr(ndr, "service_status", r->out.service_status);
3049                 ndr->depth++;
3050                 ndr_print_array_uint8(ndr, "service_status", r->out.service_status, r->in.offered);
3051                 ndr->depth--;
3052                 ndr_print_ptr(ndr, "needed", r->out.needed);
3053                 ndr->depth++;
3054                 ndr_print_uint32(ndr, "needed", *r->out.needed);
3055                 ndr->depth--;
3056                 ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
3057                 ndr->depth++;
3058                 ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
3059                 ndr->depth--;
3060                 ndr_print_WERROR(ndr, "result", r->out.result);
3061                 ndr->depth--;
3062         }
3063         ndr->depth--;
3064 }
3065
3066 static enum ndr_err_code ndr_push_svcctl_EnumServicesStatusW(struct ndr_push *ndr, int flags, const struct svcctl_EnumServicesStatusW *r)
3067 {
3068         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3069         if (flags & NDR_IN) {
3070                 if (r->in.handle == NULL) {
3071                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3072                 }
3073                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
3075                 NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
3076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
3077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
3078                 if (r->in.resume_handle) {
3079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
3080                 }
3081         }
3082         if (flags & NDR_OUT) {
3083                 if (r->out.service == NULL) {
3084                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3085                 }
3086                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
3087                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.offered));
3088                 if (r->out.needed == NULL) {
3089                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3090                 }
3091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
3092                 if (r->out.services_returned == NULL) {
3093                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3094                 }
3095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
3096                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
3097                 if (r->out.resume_handle) {
3098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
3099                 }
3100                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3101         }
3102         return NDR_ERR_SUCCESS;
3103 }
3104
3105 static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusW(struct ndr_pull *ndr, int flags, struct svcctl_EnumServicesStatusW *r)
3106 {
3107         uint32_t size_service_1 = 0;
3108         uint32_t _ptr_resume_handle;
3109         TALLOC_CTX *_mem_save_handle_0;
3110         TALLOC_CTX *_mem_save_needed_0;
3111         TALLOC_CTX *_mem_save_services_returned_0;
3112         TALLOC_CTX *_mem_save_resume_handle_0;
3113         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3114         if (flags & NDR_IN) {
3115                 ZERO_STRUCT(r->out);
3116
3117                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3118                         NDR_PULL_ALLOC(ndr, r->in.handle);
3119                 }
3120                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3121                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3122                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3123                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
3125                 NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
3126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
3127                 if (r->in.offered > 0x40000) {
3128                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3129                 }
3130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
3131                 if (_ptr_resume_handle) {
3132                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
3133                 } else {
3134                         r->in.resume_handle = NULL;
3135                 }
3136                 if (r->in.resume_handle) {
3137                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3138                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
3139                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
3140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
3141                 }
3142                 NDR_PULL_ALLOC_N(ndr, r->out.service, r->in.offered);
3143                 memset(r->out.service, 0, (r->in.offered) * sizeof(*r->out.service));
3144                 NDR_PULL_ALLOC(ndr, r->out.needed);
3145                 ZERO_STRUCTP(r->out.needed);
3146                 NDR_PULL_ALLOC(ndr, r->out.services_returned);
3147                 ZERO_STRUCTP(r->out.services_returned);
3148         }
3149         if (flags & NDR_OUT) {
3150                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.service));
3151                 size_service_1 = ndr_get_array_size(ndr, &r->out.service);
3152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3153                         NDR_PULL_ALLOC_N(ndr, r->out.service, size_service_1);
3154                 }
3155                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, size_service_1));
3156                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3157                         NDR_PULL_ALLOC(ndr, r->out.needed);
3158                 }
3159                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3160                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
3161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
3162                 if (*r->out.needed > 0x40000) {
3163                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3164                 }
3165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
3166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3167                         NDR_PULL_ALLOC(ndr, r->out.services_returned);
3168                 }
3169                 _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
3170                 NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
3171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
3172                 if (*r->out.services_returned > 0x40000) {
3173                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3174                 }
3175                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
3176                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
3177                 if (_ptr_resume_handle) {
3178                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
3179                 } else {
3180                         r->out.resume_handle = NULL;
3181                 }
3182                 if (r->out.resume_handle) {
3183                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3184                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
3185                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
3186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
3187                 }
3188                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3189                 if (r->out.service) {
3190                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.offered));
3191                 }
3192         }
3193         return NDR_ERR_SUCCESS;
3194 }
3195
3196 _PUBLIC_ void ndr_print_svcctl_EnumServicesStatusW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServicesStatusW *r)
3197 {
3198         ndr_print_struct(ndr, name, "svcctl_EnumServicesStatusW");
3199         if (r == NULL) { ndr_print_null(ndr); return; }
3200         ndr->depth++;
3201         if (flags & NDR_SET_VALUES) {
3202                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3203         }
3204         if (flags & NDR_IN) {
3205                 ndr_print_struct(ndr, "in", "svcctl_EnumServicesStatusW");
3206                 ndr->depth++;
3207                 ndr_print_ptr(ndr, "handle", r->in.handle);
3208                 ndr->depth++;
3209                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3210                 ndr->depth--;
3211                 ndr_print_uint32(ndr, "type", r->in.type);
3212                 ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
3213                 ndr_print_uint32(ndr, "offered", r->in.offered);
3214                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
3215                 ndr->depth++;
3216                 if (r->in.resume_handle) {
3217                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
3218                 }
3219                 ndr->depth--;
3220                 ndr->depth--;
3221         }
3222         if (flags & NDR_OUT) {
3223                 ndr_print_struct(ndr, "out", "svcctl_EnumServicesStatusW");
3224                 ndr->depth++;
3225                 ndr_print_ptr(ndr, "service", r->out.service);
3226                 ndr->depth++;
3227                 ndr_print_array_uint8(ndr, "service", r->out.service, r->in.offered);
3228                 ndr->depth--;
3229                 ndr_print_ptr(ndr, "needed", r->out.needed);
3230                 ndr->depth++;
3231                 ndr_print_uint32(ndr, "needed", *r->out.needed);
3232                 ndr->depth--;
3233                 ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
3234                 ndr->depth++;
3235                 ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
3236                 ndr->depth--;
3237                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
3238                 ndr->depth++;
3239                 if (r->out.resume_handle) {
3240                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
3241                 }
3242                 ndr->depth--;
3243                 ndr_print_WERROR(ndr, "result", r->out.result);
3244                 ndr->depth--;
3245         }
3246         ndr->depth--;
3247 }
3248
3249 static enum ndr_err_code ndr_push_svcctl_OpenSCManagerW(struct ndr_push *ndr, int flags, const struct svcctl_OpenSCManagerW *r)
3250 {
3251         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3252         if (flags & NDR_IN) {
3253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.MachineName));
3254                 if (r->in.MachineName) {
3255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
3256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
3258                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3259                 }
3260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DatabaseName));
3261                 if (r->in.DatabaseName) {
3262                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
3263                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3264                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
3265                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3266                 }
3267                 NDR_CHECK(ndr_push_svcctl_MgrAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3268         }
3269         if (flags & NDR_OUT) {
3270                 if (r->out.handle == NULL) {
3271                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3272                 }
3273                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3274                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3275         }
3276         return NDR_ERR_SUCCESS;
3277 }
3278
3279 static enum ndr_err_code ndr_pull_svcctl_OpenSCManagerW(struct ndr_pull *ndr, int flags, struct svcctl_OpenSCManagerW *r)
3280 {
3281         uint32_t _ptr_MachineName;
3282         uint32_t size_MachineName_1 = 0;
3283         uint32_t length_MachineName_1 = 0;
3284         uint32_t _ptr_DatabaseName;
3285         uint32_t size_DatabaseName_1 = 0;
3286         uint32_t length_DatabaseName_1 = 0;
3287         TALLOC_CTX *_mem_save_MachineName_0;
3288         TALLOC_CTX *_mem_save_DatabaseName_0;
3289         TALLOC_CTX *_mem_save_handle_0;
3290         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3291         if (flags & NDR_IN) {
3292                 ZERO_STRUCT(r->out);
3293
3294                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_MachineName));
3295                 if (_ptr_MachineName) {
3296                         NDR_PULL_ALLOC(ndr, r->in.MachineName);
3297                 } else {
3298                         r->in.MachineName = NULL;
3299                 }
3300                 if (r->in.MachineName) {
3301                         _mem_save_MachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3302                         NDR_PULL_SET_MEM_CTX(ndr, r->in.MachineName, 0);
3303                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.MachineName));
3304                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.MachineName));
3305                         size_MachineName_1 = ndr_get_array_size(ndr, &r->in.MachineName);
3306                         length_MachineName_1 = ndr_get_array_length(ndr, &r->in.MachineName);
3307                         if (length_MachineName_1 > size_MachineName_1) {
3308                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_MachineName_1, length_MachineName_1);
3309                         }
3310                         NDR_CHECK(ndr_check_string_terminator(ndr, length_MachineName_1, sizeof(uint16_t)));
3311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.MachineName, length_MachineName_1, sizeof(uint16_t), CH_UTF16));
3312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MachineName_0, 0);
3313                 }
3314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DatabaseName));
3315                 if (_ptr_DatabaseName) {
3316                         NDR_PULL_ALLOC(ndr, r->in.DatabaseName);
3317                 } else {
3318                         r->in.DatabaseName = NULL;
3319                 }
3320                 if (r->in.DatabaseName) {
3321                         _mem_save_DatabaseName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3322                         NDR_PULL_SET_MEM_CTX(ndr, r->in.DatabaseName, 0);
3323                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DatabaseName));
3324                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DatabaseName));
3325                         size_DatabaseName_1 = ndr_get_array_size(ndr, &r->in.DatabaseName);
3326                         length_DatabaseName_1 = ndr_get_array_length(ndr, &r->in.DatabaseName);
3327                         if (length_DatabaseName_1 > size_DatabaseName_1) {
3328                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_DatabaseName_1, length_DatabaseName_1);
3329                         }
3330                         NDR_CHECK(ndr_check_string_terminator(ndr, length_DatabaseName_1, sizeof(uint16_t)));
3331                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DatabaseName, length_DatabaseName_1, sizeof(uint16_t), CH_UTF16));
3332                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DatabaseName_0, 0);
3333                 }
3334                 NDR_CHECK(ndr_pull_svcctl_MgrAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3335                 NDR_PULL_ALLOC(ndr, r->out.handle);
3336                 ZERO_STRUCTP(r->out.handle);
3337         }
3338         if (flags & NDR_OUT) {
3339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3340                         NDR_PULL_ALLOC(ndr, r->out.handle);
3341                 }
3342                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3343                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3344                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3346                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3347         }
3348         return NDR_ERR_SUCCESS;
3349 }
3350
3351 _PUBLIC_ void ndr_print_svcctl_OpenSCManagerW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenSCManagerW *r)
3352 {
3353         ndr_print_struct(ndr, name, "svcctl_OpenSCManagerW");
3354         if (r == NULL) { ndr_print_null(ndr); return; }
3355         ndr->depth++;
3356         if (flags & NDR_SET_VALUES) {
3357                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3358         }
3359         if (flags & NDR_IN) {
3360                 ndr_print_struct(ndr, "in", "svcctl_OpenSCManagerW");
3361                 ndr->depth++;
3362                 ndr_print_ptr(ndr, "MachineName", r->in.MachineName);
3363                 ndr->depth++;
3364                 if (r->in.MachineName) {
3365                         ndr_print_string(ndr, "MachineName", r->in.MachineName);
3366                 }
3367                 ndr->depth--;
3368                 ndr_print_ptr(ndr, "DatabaseName", r->in.DatabaseName);
3369                 ndr->depth++;
3370                 if (r->in.DatabaseName) {
3371                         ndr_print_string(ndr, "DatabaseName", r->in.DatabaseName);
3372                 }
3373                 ndr->depth--;
3374                 ndr_print_svcctl_MgrAccessMask(ndr, "access_mask", r->in.access_mask);
3375                 ndr->depth--;
3376         }
3377         if (flags & NDR_OUT) {
3378                 ndr_print_struct(ndr, "out", "svcctl_OpenSCManagerW");
3379                 ndr->depth++;
3380                 ndr_print_ptr(ndr, "handle", r->out.handle);
3381                 ndr->depth++;
3382                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
3383                 ndr->depth--;
3384                 ndr_print_WERROR(ndr, "result", r->out.result);
3385                 ndr->depth--;
3386         }
3387         ndr->depth--;
3388 }
3389
3390 static enum ndr_err_code ndr_push_svcctl_OpenServiceW(struct ndr_push *ndr, int flags, const struct svcctl_OpenServiceW *r)
3391 {
3392         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3393         if (flags & NDR_IN) {
3394                 if (r->in.scmanager_handle == NULL) {
3395                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3396                 }
3397                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
3398                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
3399                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3400                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
3401                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3402                 NDR_CHECK(ndr_push_svcctl_ServiceAccessMask(ndr, NDR_SCALARS, r->in.access_mask));
3403         }
3404         if (flags & NDR_OUT) {
3405                 if (r->out.handle == NULL) {
3406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3407                 }
3408                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3409                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3410         }
3411         return NDR_ERR_SUCCESS;
3412 }
3413
3414 static enum ndr_err_code ndr_pull_svcctl_OpenServiceW(struct ndr_pull *ndr, int flags, struct svcctl_OpenServiceW *r)
3415 {
3416         uint32_t size_ServiceName_0 = 0;
3417         uint32_t length_ServiceName_0 = 0;
3418         TALLOC_CTX *_mem_save_scmanager_handle_0;
3419         TALLOC_CTX *_mem_save_handle_0;
3420         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3421         if (flags & NDR_IN) {
3422                 ZERO_STRUCT(r->out);
3423
3424                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3425                         NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);
3426                 }
3427                 _mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3428                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);
3429                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
3430                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);
3431                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
3432                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
3433                 size_ServiceName_0 = ndr_get_array_size(ndr, &r->in.ServiceName);
3434                 length_ServiceName_0 = ndr_get_array_length(ndr, &r->in.ServiceName);
3435                 if (length_ServiceName_0 > size_ServiceName_0) {
3436                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ServiceName_0, length_ServiceName_0);
3437                 }
3438                 NDR_CHECK(ndr_check_string_terminator(ndr, length_ServiceName_0, sizeof(uint16_t)));
3439                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, length_ServiceName_0, sizeof(uint16_t), CH_UTF16));
3440                 NDR_CHECK(ndr_pull_svcctl_ServiceAccessMask(ndr, NDR_SCALARS, &r->in.access_mask));
3441                 NDR_PULL_ALLOC(ndr, r->out.handle);
3442                 ZERO_STRUCTP(r->out.handle);
3443         }
3444         if (flags & NDR_OUT) {
3445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3446                         NDR_PULL_ALLOC(ndr, r->out.handle);
3447                 }
3448                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3449                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3450                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
3451                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3452                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3453         }
3454         return NDR_ERR_SUCCESS;
3455 }
3456
3457 _PUBLIC_ void ndr_print_svcctl_OpenServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenServiceW *r)
3458 {
3459         ndr_print_struct(ndr, name, "svcctl_OpenServiceW");
3460         if (r == NULL) { ndr_print_null(ndr); return; }
3461         ndr->depth++;
3462         if (flags & NDR_SET_VALUES) {
3463                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3464         }
3465         if (flags & NDR_IN) {
3466                 ndr_print_struct(ndr, "in", "svcctl_OpenServiceW");
3467                 ndr->depth++;
3468                 ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);
3469                 ndr->depth++;
3470                 ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);
3471                 ndr->depth--;
3472                 ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
3473                 ndr_print_svcctl_ServiceAccessMask(ndr, "access_mask", r->in.access_mask);
3474                 ndr->depth--;
3475         }
3476         if (flags & NDR_OUT) {
3477                 ndr_print_struct(ndr, "out", "svcctl_OpenServiceW");
3478                 ndr->depth++;
3479                 ndr_print_ptr(ndr, "handle", r->out.handle);
3480                 ndr->depth++;
3481                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
3482                 ndr->depth--;
3483                 ndr_print_WERROR(ndr, "result", r->out.result);
3484                 ndr->depth--;
3485         }
3486         ndr->depth--;
3487 }
3488
3489 static enum ndr_err_code ndr_push_svcctl_QueryServiceConfigW(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfigW *r)
3490 {
3491         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3492         if (flags & NDR_IN) {
3493                 if (r->in.handle == NULL) {
3494                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3495                 }
3496                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
3498         }
3499         if (flags & NDR_OUT) {
3500                 if (r->out.query == NULL) {
3501                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3502                 }
3503                 NDR_CHECK(ndr_push_QUERY_SERVICE_CONFIG(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.query));
3504                 if (r->out.needed == NULL) {
3505                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3506                 }
3507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
3508                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3509         }
3510         return NDR_ERR_SUCCESS;
3511 }
3512
3513 static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigW(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfigW *r)
3514 {
3515         TALLOC_CTX *_mem_save_handle_0;
3516         TALLOC_CTX *_mem_save_query_0;
3517         TALLOC_CTX *_mem_save_needed_0;
3518         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3519         if (flags & NDR_IN) {
3520                 ZERO_STRUCT(r->out);
3521
3522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3523                         NDR_PULL_ALLOC(ndr, r->in.handle);
3524                 }
3525                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3527                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
3530                 if (r->in.offered > 8192) {
3531                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3532                 }
3533                 NDR_PULL_ALLOC(ndr, r->out.query);
3534                 ZERO_STRUCTP(r->out.query);
3535                 NDR_PULL_ALLOC(ndr, r->out.needed);
3536                 ZERO_STRUCTP(r->out.needed);
3537         }
3538         if (flags & NDR_OUT) {
3539                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3540                         NDR_PULL_ALLOC(ndr, r->out.query);
3541                 }
3542                 _mem_save_query_0 = NDR_PULL_GET_MEM_CTX(ndr);
3543                 NDR_PULL_SET_MEM_CTX(ndr, r->out.query, LIBNDR_FLAG_REF_ALLOC);
3544                 NDR_CHECK(ndr_pull_QUERY_SERVICE_CONFIG(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.query));
3545                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_query_0, LIBNDR_FLAG_REF_ALLOC);
3546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3547                         NDR_PULL_ALLOC(ndr, r->out.needed);
3548                 }
3549                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3550                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
3551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
3552                 if (*r->out.needed > 8192) {
3553                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3554                 }
3555                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
3556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3557         }
3558         return NDR_ERR_SUCCESS;
3559 }
3560
3561 _PUBLIC_ void ndr_print_svcctl_QueryServiceConfigW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfigW *r)
3562 {
3563         ndr_print_struct(ndr, name, "svcctl_QueryServiceConfigW");
3564         if (r == NULL) { ndr_print_null(ndr); return; }
3565         ndr->depth++;
3566         if (flags & NDR_SET_VALUES) {
3567                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3568         }
3569         if (flags & NDR_IN) {
3570                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfigW");
3571                 ndr->depth++;
3572                 ndr_print_ptr(ndr, "handle", r->in.handle);
3573                 ndr->depth++;
3574                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3575                 ndr->depth--;
3576                 ndr_print_uint32(ndr, "offered", r->in.offered);
3577                 ndr->depth--;
3578         }
3579         if (flags & NDR_OUT) {
3580                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfigW");
3581                 ndr->depth++;
3582                 ndr_print_ptr(ndr, "query", r->out.query);
3583                 ndr->depth++;
3584                 ndr_print_QUERY_SERVICE_CONFIG(ndr, "query", r->out.query);
3585                 ndr->depth--;
3586                 ndr_print_ptr(ndr, "needed", r->out.needed);
3587                 ndr->depth++;
3588                 ndr_print_uint32(ndr, "needed", *r->out.needed);
3589                 ndr->depth--;
3590                 ndr_print_WERROR(ndr, "result", r->out.result);
3591                 ndr->depth--;
3592         }
3593         ndr->depth--;
3594 }
3595
3596 static enum ndr_err_code ndr_push_svcctl_QueryServiceLockStatusW(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceLockStatusW *r)
3597 {
3598         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3599         if (flags & NDR_IN) {
3600                 if (r->in.handle == NULL) {
3601                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3602                 }
3603                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
3605         }
3606         if (flags & NDR_OUT) {
3607                 if (r->out.lock_status == NULL) {
3608                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3609                 }
3610                 NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
3611                 if (r->out.needed == NULL) {
3612                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3613                 }
3614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
3615                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3616         }
3617         return NDR_ERR_SUCCESS;
3618 }
3619
3620 static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusW(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceLockStatusW *r)
3621 {
3622         TALLOC_CTX *_mem_save_handle_0;
3623         TALLOC_CTX *_mem_save_lock_status_0;
3624         TALLOC_CTX *_mem_save_needed_0;
3625         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3626         if (flags & NDR_IN) {
3627                 ZERO_STRUCT(r->out);
3628
3629                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3630                         NDR_PULL_ALLOC(ndr, r->in.handle);
3631                 }
3632                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3633                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3634                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
3637                 NDR_PULL_ALLOC(ndr, r->out.lock_status);
3638                 ZERO_STRUCTP(r->out.lock_status);
3639                 NDR_PULL_ALLOC(ndr, r->out.needed);
3640                 ZERO_STRUCTP(r->out.needed);
3641         }
3642         if (flags & NDR_OUT) {
3643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3644                         NDR_PULL_ALLOC(ndr, r->out.lock_status);
3645                 }
3646                 _mem_save_lock_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3647                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lock_status, LIBNDR_FLAG_REF_ALLOC);
3648                 NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
3649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);
3650                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3651                         NDR_PULL_ALLOC(ndr, r->out.needed);
3652                 }
3653                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3654                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
3655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
3656                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
3657                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3658         }
3659         return NDR_ERR_SUCCESS;
3660 }
3661
3662 _PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceLockStatusW *r)
3663 {
3664         ndr_print_struct(ndr, name, "svcctl_QueryServiceLockStatusW");
3665         if (r == NULL) { ndr_print_null(ndr); return; }
3666         ndr->depth++;
3667         if (flags & NDR_SET_VALUES) {
3668                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3669         }
3670         if (flags & NDR_IN) {
3671                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceLockStatusW");
3672                 ndr->depth++;
3673                 ndr_print_ptr(ndr, "handle", r->in.handle);
3674                 ndr->depth++;
3675                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3676                 ndr->depth--;
3677                 ndr_print_uint32(ndr, "offered", r->in.offered);
3678                 ndr->depth--;
3679         }
3680         if (flags & NDR_OUT) {
3681                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceLockStatusW");
3682                 ndr->depth++;
3683                 ndr_print_ptr(ndr, "lock_status", r->out.lock_status);
3684                 ndr->depth++;
3685                 ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);
3686                 ndr->depth--;
3687                 ndr_print_ptr(ndr, "needed", r->out.needed);
3688                 ndr->depth++;
3689                 ndr_print_uint32(ndr, "needed", *r->out.needed);
3690                 ndr->depth--;
3691                 ndr_print_WERROR(ndr, "result", r->out.result);
3692                 ndr->depth--;
3693         }
3694         ndr->depth--;
3695 }
3696
3697 static enum ndr_err_code ndr_push_svcctl_StartServiceW(struct ndr_push *ndr, int flags, const struct svcctl_StartServiceW *r)
3698 {
3699         uint32_t cntr_Arguments_1;
3700         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3701         if (flags & NDR_IN) {
3702                 if (r->in.handle == NULL) {
3703                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3704                 }
3705                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));
3707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));
3708                 if (r->in.Arguments) {
3709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.NumArgs));
3710                         for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
3711                                 NDR_CHECK(ndr_push_svcctl_ArgumentString(ndr, NDR_SCALARS, &r->in.Arguments[cntr_Arguments_1]));
3712                         }
3713                         for (cntr_Arguments_1 = 0; cntr_Arguments_1 < r->in.NumArgs; cntr_Arguments_1++) {
3714                                 NDR_CHECK(ndr_push_svcctl_ArgumentString(ndr, NDR_BUFFERS, &r->in.Arguments[cntr_Arguments_1]));
3715                         }
3716                 }
3717         }
3718         if (flags & NDR_OUT) {
3719                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3720         }
3721         return NDR_ERR_SUCCESS;
3722 }
3723
3724 static enum ndr_err_code ndr_pull_svcctl_StartServiceW(struct ndr_pull *ndr, int flags, struct svcctl_StartServiceW *r)
3725 {
3726         uint32_t _ptr_Arguments;
3727         uint32_t size_Arguments_1 = 0;
3728         uint32_t cntr_Arguments_1;
3729         TALLOC_CTX *_mem_save_handle_0;
3730         TALLOC_CTX *_mem_save_Arguments_0;
3731         TALLOC_CTX *_mem_save_Arguments_1;
3732         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3733         if (flags & NDR_IN) {
3734                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3735                         NDR_PULL_ALLOC(ndr, r->in.handle);
3736                 }
3737                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3738                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3739                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3740                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.NumArgs));
3742                 if (r->in.NumArgs > SC_MAX_ARGUMENTS) {
3743                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3744                 }
3745                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Arguments));
3746                 if (_ptr_Arguments) {
3747                         NDR_PULL_ALLOC(ndr, r->in.Arguments);
3748                 } else {
3749                         r->in.Arguments = NULL;
3750                 }
3751                 if (r->in.Arguments) {
3752                         _mem_save_Arguments_0 = NDR_PULL_GET_MEM_CTX(ndr);
3753                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
3754                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Arguments));
3755                         size_Arguments_1 = ndr_get_array_size(ndr, &r->in.Arguments);
3756                         NDR_PULL_ALLOC_N(ndr, r->in.Arguments, size_Arguments_1);
3757                         _mem_save_Arguments_1 = NDR_PULL_GET_MEM_CTX(ndr);
3758                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
3759                         for (cntr_Arguments_1 = 0; cntr_Arguments_1 < size_Arguments_1; cntr_Arguments_1++) {
3760                                 NDR_CHECK(ndr_pull_svcctl_ArgumentString(ndr, NDR_SCALARS, &r->in.Arguments[cntr_Arguments_1]));
3761                         }
3762                         for (cntr_Arguments_1 = 0; cntr_Arguments_1 < size_Arguments_1; cntr_Arguments_1++) {
3763                                 NDR_CHECK(ndr_pull_svcctl_ArgumentString(ndr, NDR_BUFFERS, &r->in.Arguments[cntr_Arguments_1]));
3764                         }
3765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_1, 0);
3766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_0, 0);
3767                 }
3768                 if (r->in.Arguments) {
3769                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.Arguments, r->in.NumArgs));
3770                 }
3771         }
3772         if (flags & NDR_OUT) {
3773                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3774         }
3775         return NDR_ERR_SUCCESS;
3776 }
3777
3778 _PUBLIC_ void ndr_print_svcctl_StartServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_StartServiceW *r)
3779 {
3780         uint32_t cntr_Arguments_1;
3781         ndr_print_struct(ndr, name, "svcctl_StartServiceW");
3782         if (r == NULL) { ndr_print_null(ndr); return; }
3783         ndr->depth++;
3784         if (flags & NDR_SET_VALUES) {
3785                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3786         }
3787         if (flags & NDR_IN) {
3788                 ndr_print_struct(ndr, "in", "svcctl_StartServiceW");
3789                 ndr->depth++;
3790                 ndr_print_ptr(ndr, "handle", r->in.handle);
3791                 ndr->depth++;
3792                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3793                 ndr->depth--;
3794                 ndr_print_uint32(ndr, "NumArgs", r->in.NumArgs);
3795                 ndr_print_ptr(ndr, "Arguments", r->in.Arguments);
3796                 ndr->depth++;
3797                 if (r->in.Arguments) {
3798                         ndr->print(ndr, "%s: ARRAY(%d)", "Arguments", (int)r->in.NumArgs);
3799                         ndr->depth++;
3800                         for (cntr_Arguments_1=0;cntr_Arguments_1<r->in.NumArgs;cntr_Arguments_1++) {
3801                                 ndr_print_svcctl_ArgumentString(ndr, "Arguments", &r->in.Arguments[cntr_Arguments_1]);
3802                         }
3803                         ndr->depth--;
3804                 }
3805                 ndr->depth--;
3806                 ndr->depth--;
3807         }
3808         if (flags & NDR_OUT) {
3809                 ndr_print_struct(ndr, "out", "svcctl_StartServiceW");
3810                 ndr->depth++;
3811                 ndr_print_WERROR(ndr, "result", r->out.result);
3812                 ndr->depth--;
3813         }
3814         ndr->depth--;
3815 }
3816
3817 static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameW(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceDisplayNameW *r)
3818 {
3819         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
3820         if (flags & NDR_IN) {
3821                 if (r->in.handle == NULL) {
3822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3823                 }
3824                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3825                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
3826                 if (r->in.service_name) {
3827                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
3828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3829                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
3830                         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));
3831                 }
3832                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
3833                 if (r->in.display_name_length) {
3834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
3835                 }
3836         }
3837         if (flags & NDR_OUT) {
3838                 if (r->out.display_name == NULL) {
3839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3840                 }
3841                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.display_name));
3842                 if (*r->out.display_name) {
3843                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
3844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
3846                         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));
3847                 }
3848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
3849                 if (r->out.display_name_length) {
3850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
3851                 }
3852                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3853         }
3854         return NDR_ERR_SUCCESS;
3855 }
3856
3857 static enum ndr_err_code ndr_pull_svcctl_GetServiceDisplayNameW(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceDisplayNameW *r)
3858 {
3859         uint32_t _ptr_service_name;
3860         uint32_t size_service_name_1 = 0;
3861         uint32_t length_service_name_1 = 0;
3862         uint32_t _ptr_display_name;
3863         uint32_t size_display_name_2 = 0;
3864         uint32_t length_display_name_2 = 0;
3865         uint32_t _ptr_display_name_length;
3866         TALLOC_CTX *_mem_save_handle_0;
3867         TALLOC_CTX *_mem_save_service_name_0;
3868         TALLOC_CTX *_mem_save_display_name_0;
3869         TALLOC_CTX *_mem_save_display_name_1;
3870         TALLOC_CTX *_mem_save_display_name_length_0;
3871         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
3872         if (flags & NDR_IN) {
3873                 ZERO_STRUCT(r->out);
3874
3875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3876                         NDR_PULL_ALLOC(ndr, r->in.handle);
3877                 }
3878                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3879                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3880                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
3881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
3883                 if (_ptr_service_name) {
3884                         NDR_PULL_ALLOC(ndr, r->in.service_name);
3885                 } else {
3886                         r->in.service_name = NULL;
3887                 }
3888                 if (r->in.service_name) {
3889                         _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3890                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
3891                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
3892                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
3893                         size_service_name_1 = ndr_get_array_size(ndr, &r->in.service_name);
3894                         length_service_name_1 = ndr_get_array_length(ndr, &r->in.service_name);
3895                         if (length_service_name_1 > size_service_name_1) {
3896                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_service_name_1, length_service_name_1);
3897                         }
3898                         NDR_CHECK(ndr_check_string_terminator(ndr, length_service_name_1, sizeof(uint16_t)));
3899                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, length_service_name_1, sizeof(uint16_t), CH_UTF16));
3900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
3901                 }
3902                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
3903                 if (_ptr_display_name_length) {
3904                         NDR_PULL_ALLOC(ndr, r->in.display_name_length);
3905                 } else {
3906                         r->in.display_name_length = NULL;
3907                 }
3908                 if (r->in.display_name_length) {
3909                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
3910                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
3911                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
3912                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
3913                 }
3914                 NDR_PULL_ALLOC(ndr, r->out.display_name);
3915                 ZERO_STRUCTP(r->out.display_name);
3916         }
3917         if (flags & NDR_OUT) {
3918                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3919                         NDR_PULL_ALLOC(ndr, r->out.display_name);
3920                 }
3921                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3922                 NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name, LIBNDR_FLAG_REF_ALLOC);
3923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
3924                 if (_ptr_display_name) {
3925                         NDR_PULL_ALLOC(ndr, *r->out.display_name);
3926                 } else {
3927                         *r->out.display_name = NULL;
3928                 }
3929                 if (*r->out.display_name) {
3930                         _mem_save_display_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
3931                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.display_name, 0);
3932                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.display_name));
3933                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.display_name));
3934                         size_display_name_2 = ndr_get_array_size(ndr, r->out.display_name);
3935                         length_display_name_2 = ndr_get_array_length(ndr, r->out.display_name);
3936                         if (length_display_name_2 > size_display_name_2) {
3937                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_display_name_2, length_display_name_2);
3938                         }
3939                         NDR_CHECK(ndr_check_string_terminator(ndr, length_display_name_2, sizeof(uint16_t)));
3940                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.display_name, length_display_name_2, sizeof(uint16_t), CH_UTF16));
3941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_1, 0);
3942                 }
3943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, LIBNDR_FLAG_REF_ALLOC);
3944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
3945                 if (_ptr_display_name_length) {
3946                         NDR_PULL_ALLOC(ndr, r->out.display_name_length);
3947                 } else {
3948                         r->out.display_name_length = NULL;
3949                 }
3950                 if (r->out.display_name_length) {
3951                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
3952                         NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
3953                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
3954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
3955                 }
3956                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3957         }
3958         return NDR_ERR_SUCCESS;
3959 }
3960
3961 _PUBLIC_ void ndr_print_svcctl_GetServiceDisplayNameW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceDisplayNameW *r)
3962 {
3963         ndr_print_struct(ndr, name, "svcctl_GetServiceDisplayNameW");
3964         if (r == NULL) { ndr_print_null(ndr); return; }
3965         ndr->depth++;
3966         if (flags & NDR_SET_VALUES) {
3967                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3968         }
3969         if (flags & NDR_IN) {
3970                 ndr_print_struct(ndr, "in", "svcctl_GetServiceDisplayNameW");
3971                 ndr->depth++;
3972                 ndr_print_ptr(ndr, "handle", r->in.handle);
3973                 ndr->depth++;
3974                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3975                 ndr->depth--;
3976                 ndr_print_ptr(ndr, "service_name", r->in.service_name);
3977                 ndr->depth++;
3978                 if (r->in.service_name) {
3979                         ndr_print_string(ndr, "service_name", r->in.service_name);
3980                 }
3981                 ndr->depth--;
3982                 ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
3983                 ndr->depth++;
3984                 if (r->in.display_name_length) {
3985                         ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
3986                 }
3987                 ndr->depth--;
3988                 ndr->depth--;
3989         }
3990         if (flags & NDR_OUT) {
3991                 ndr_print_struct(ndr, "out", "svcctl_GetServiceDisplayNameW");
3992                 ndr->depth++;
3993                 ndr_print_ptr(ndr, "display_name", r->out.display_name);
3994                 ndr->depth++;
3995                 ndr_print_ptr(ndr, "display_name", *r->out.display_name);
3996                 ndr->depth++;
3997                 if (*r->out.display_name) {
3998                         ndr_print_string(ndr, "display_name", *r->out.display_name);
3999                 }
4000                 ndr->depth--;
4001                 ndr->depth--;
4002                 ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
4003                 ndr->depth++;
4004                 if (r->out.display_name_length) {
4005                         ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
4006                 }
4007                 ndr->depth--;
4008                 ndr_print_WERROR(ndr, "result", r->out.result);
4009                 ndr->depth--;
4010         }
4011         ndr->depth--;
4012 }
4013
4014 static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameW(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceKeyNameW *r)
4015 {
4016         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4017         if (flags & NDR_IN) {
4018                 if (r->in.handle == NULL) {
4019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4020                 }
4021                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
4023                 if (r->in.service_name) {
4024                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
4025                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
4027                         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));
4028                 }
4029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
4030                 if (r->in.display_name_length) {
4031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
4032                 }
4033         }
4034         if (flags & NDR_OUT) {
4035                 if (r->out.key_name == NULL) {
4036                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4037                 }
4038                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_name));
4039                 if (*r->out.key_name) {
4040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
4041                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4042                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
4043                         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));
4044                 }
4045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
4046                 if (r->out.display_name_length) {
4047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
4048                 }
4049                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4050         }
4051         return NDR_ERR_SUCCESS;
4052 }
4053
4054 static enum ndr_err_code ndr_pull_svcctl_GetServiceKeyNameW(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceKeyNameW *r)
4055 {
4056         uint32_t _ptr_service_name;
4057         uint32_t size_service_name_1 = 0;
4058         uint32_t length_service_name_1 = 0;
4059         uint32_t _ptr_key_name;
4060         uint32_t size_key_name_2 = 0;
4061         uint32_t length_key_name_2 = 0;
4062         uint32_t _ptr_display_name_length;
4063         TALLOC_CTX *_mem_save_handle_0;
4064         TALLOC_CTX *_mem_save_service_name_0;
4065         TALLOC_CTX *_mem_save_key_name_0;
4066         TALLOC_CTX *_mem_save_key_name_1;
4067         TALLOC_CTX *_mem_save_display_name_length_0;
4068         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4069         if (flags & NDR_IN) {
4070                 ZERO_STRUCT(r->out);
4071
4072                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4073                         NDR_PULL_ALLOC(ndr, r->in.handle);
4074                 }
4075                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4076                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4077                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4078                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
4080                 if (_ptr_service_name) {
4081                         NDR_PULL_ALLOC(ndr, r->in.service_name);
4082                 } else {
4083                         r->in.service_name = NULL;
4084                 }
4085                 if (r->in.service_name) {
4086                         _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4087                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
4088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
4089                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
4090                         size_service_name_1 = ndr_get_array_size(ndr, &r->in.service_name);
4091                         length_service_name_1 = ndr_get_array_length(ndr, &r->in.service_name);
4092                         if (length_service_name_1 > size_service_name_1) {
4093                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_service_name_1, length_service_name_1);
4094                         }
4095                         NDR_CHECK(ndr_check_string_terminator(ndr, length_service_name_1, sizeof(uint16_t)));
4096                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, length_service_name_1, sizeof(uint16_t), CH_UTF16));
4097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
4098                 }
4099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
4100                 if (_ptr_display_name_length) {
4101                         NDR_PULL_ALLOC(ndr, r->in.display_name_length);
4102                 } else {
4103                         r->in.display_name_length = NULL;
4104                 }
4105                 if (r->in.display_name_length) {
4106                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
4107                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
4108                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
4109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
4110                 }
4111                 NDR_PULL_ALLOC(ndr, r->out.key_name);
4112                 ZERO_STRUCTP(r->out.key_name);
4113         }
4114         if (flags & NDR_OUT) {
4115                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4116                         NDR_PULL_ALLOC(ndr, r->out.key_name);
4117                 }
4118                 _mem_save_key_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4119                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_name, LIBNDR_FLAG_REF_ALLOC);
4120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_name));
4121                 if (_ptr_key_name) {
4122                         NDR_PULL_ALLOC(ndr, *r->out.key_name);
4123                 } else {
4124                         *r->out.key_name = NULL;
4125                 }
4126                 if (*r->out.key_name) {
4127                         _mem_save_key_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
4128                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_name, 0);
4129                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.key_name));
4130                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.key_name));
4131                         size_key_name_2 = ndr_get_array_size(ndr, r->out.key_name);
4132                         length_key_name_2 = ndr_get_array_length(ndr, r->out.key_name);
4133                         if (length_key_name_2 > size_key_name_2) {
4134                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_key_name_2, length_key_name_2);
4135                         }
4136                         NDR_CHECK(ndr_check_string_terminator(ndr, length_key_name_2, sizeof(uint16_t)));
4137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.key_name, length_key_name_2, sizeof(uint16_t), CH_UTF16));
4138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_1, 0);
4139                 }
4140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_0, LIBNDR_FLAG_REF_ALLOC);
4141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
4142                 if (_ptr_display_name_length) {
4143                         NDR_PULL_ALLOC(ndr, r->out.display_name_length);
4144                 } else {
4145                         r->out.display_name_length = NULL;
4146                 }
4147                 if (r->out.display_name_length) {
4148                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
4149                         NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
4150                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
4151                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
4152                 }
4153                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4154         }
4155         return NDR_ERR_SUCCESS;
4156 }
4157
4158 _PUBLIC_ void ndr_print_svcctl_GetServiceKeyNameW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceKeyNameW *r)
4159 {
4160         ndr_print_struct(ndr, name, "svcctl_GetServiceKeyNameW");
4161         if (r == NULL) { ndr_print_null(ndr); return; }
4162         ndr->depth++;
4163         if (flags & NDR_SET_VALUES) {
4164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4165         }
4166         if (flags & NDR_IN) {
4167                 ndr_print_struct(ndr, "in", "svcctl_GetServiceKeyNameW");
4168                 ndr->depth++;
4169                 ndr_print_ptr(ndr, "handle", r->in.handle);
4170                 ndr->depth++;
4171                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4172                 ndr->depth--;
4173                 ndr_print_ptr(ndr, "service_name", r->in.service_name);
4174                 ndr->depth++;
4175                 if (r->in.service_name) {
4176                         ndr_print_string(ndr, "service_name", r->in.service_name);
4177                 }
4178                 ndr->depth--;
4179                 ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
4180                 ndr->depth++;
4181                 if (r->in.display_name_length) {
4182                         ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
4183                 }
4184                 ndr->depth--;
4185                 ndr->depth--;
4186         }
4187         if (flags & NDR_OUT) {
4188                 ndr_print_struct(ndr, "out", "svcctl_GetServiceKeyNameW");
4189                 ndr->depth++;
4190                 ndr_print_ptr(ndr, "key_name", r->out.key_name);
4191                 ndr->depth++;
4192                 ndr_print_ptr(ndr, "key_name", *r->out.key_name);
4193                 ndr->depth++;
4194                 if (*r->out.key_name) {
4195                         ndr_print_string(ndr, "key_name", *r->out.key_name);
4196                 }
4197                 ndr->depth--;
4198                 ndr->depth--;
4199                 ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
4200                 ndr->depth++;
4201                 if (r->out.display_name_length) {
4202                         ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
4203                 }
4204                 ndr->depth--;
4205                 ndr_print_WERROR(ndr, "result", r->out.result);
4206                 ndr->depth--;
4207         }
4208         ndr->depth--;
4209 }
4210
4211 static enum ndr_err_code ndr_push_svcctl_SCSetServiceBitsA(struct ndr_push *ndr, int flags, const struct svcctl_SCSetServiceBitsA *r)
4212 {
4213         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4214         if (flags & NDR_IN) {
4215                 if (r->in.handle == NULL) {
4216                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4217                 }
4218                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bits));
4220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bitson));
4221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.immediate));
4222         }
4223         if (flags & NDR_OUT) {
4224                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4225         }
4226         return NDR_ERR_SUCCESS;
4227 }
4228
4229 static enum ndr_err_code ndr_pull_svcctl_SCSetServiceBitsA(struct ndr_pull *ndr, int flags, struct svcctl_SCSetServiceBitsA *r)
4230 {
4231         TALLOC_CTX *_mem_save_handle_0;
4232         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4233         if (flags & NDR_IN) {
4234                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4235                         NDR_PULL_ALLOC(ndr, r->in.handle);
4236                 }
4237                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4238                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4239                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4240                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bits));
4242                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bitson));
4243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.immediate));
4244         }
4245         if (flags & NDR_OUT) {
4246                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4247         }
4248         return NDR_ERR_SUCCESS;
4249 }
4250
4251 _PUBLIC_ void ndr_print_svcctl_SCSetServiceBitsA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSetServiceBitsA *r)
4252 {
4253         ndr_print_struct(ndr, name, "svcctl_SCSetServiceBitsA");
4254         if (r == NULL) { ndr_print_null(ndr); return; }
4255         ndr->depth++;
4256         if (flags & NDR_SET_VALUES) {
4257                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4258         }
4259         if (flags & NDR_IN) {
4260                 ndr_print_struct(ndr, "in", "svcctl_SCSetServiceBitsA");
4261                 ndr->depth++;
4262                 ndr_print_ptr(ndr, "handle", r->in.handle);
4263                 ndr->depth++;
4264                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4265                 ndr->depth--;
4266                 ndr_print_uint32(ndr, "bits", r->in.bits);
4267                 ndr_print_uint32(ndr, "bitson", r->in.bitson);
4268                 ndr_print_uint32(ndr, "immediate", r->in.immediate);
4269                 ndr->depth--;
4270         }
4271         if (flags & NDR_OUT) {
4272                 ndr_print_struct(ndr, "out", "svcctl_SCSetServiceBitsA");
4273                 ndr->depth++;
4274                 ndr_print_WERROR(ndr, "result", r->out.result);
4275                 ndr->depth--;
4276         }
4277         ndr->depth--;
4278 }
4279
4280 static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfigA(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfigA *r)
4281 {
4282         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4283         if (flags & NDR_IN) {
4284                 if (r->in.handle == NULL) {
4285                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4286                 }
4287                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
4289                 NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
4290                 NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
4291                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
4292                 if (r->in.binary_path) {
4293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
4294                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4295                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
4296                         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));
4297                 }
4298                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.load_order_group));
4299                 if (r->in.load_order_group) {
4300                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
4301                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4302                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
4303                         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));
4304                 }
4305                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
4306                 if (r->in.dependencies) {
4307                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
4308                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
4310                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4311                 }
4312                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
4313                 if (r->in.service_start_name) {
4314                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
4315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
4317                         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));
4318                 }
4319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
4320                 if (r->in.password) {
4321                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
4322                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4323                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
4324                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4325                 }
4326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name));
4327                 if (r->in.display_name) {
4328                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
4329                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4330                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
4331                         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));
4332                 }
4333         }
4334         if (flags & NDR_OUT) {
4335                 if (r->out.tag_id == NULL) {
4336                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4337                 }
4338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.tag_id));
4339                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4340         }
4341         return NDR_ERR_SUCCESS;
4342 }
4343
4344 static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfigA(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfigA *r)
4345 {
4346         uint32_t _ptr_binary_path;
4347         uint32_t size_binary_path_1 = 0;
4348         uint32_t length_binary_path_1 = 0;
4349         uint32_t _ptr_load_order_group;
4350         uint32_t size_load_order_group_1 = 0;
4351         uint32_t length_load_order_group_1 = 0;
4352         uint32_t _ptr_dependencies;
4353         uint32_t size_dependencies_1 = 0;
4354         uint32_t length_dependencies_1 = 0;
4355         uint32_t _ptr_service_start_name;
4356         uint32_t size_service_start_name_1 = 0;
4357         uint32_t length_service_start_name_1 = 0;
4358         uint32_t _ptr_password;
4359         uint32_t size_password_1 = 0;
4360         uint32_t length_password_1 = 0;
4361         uint32_t _ptr_display_name;
4362         uint32_t size_display_name_1 = 0;
4363         uint32_t length_display_name_1 = 0;
4364         TALLOC_CTX *_mem_save_handle_0;
4365         TALLOC_CTX *_mem_save_binary_path_0;
4366         TALLOC_CTX *_mem_save_load_order_group_0;
4367         TALLOC_CTX *_mem_save_tag_id_0;
4368         TALLOC_CTX *_mem_save_dependencies_0;
4369         TALLOC_CTX *_mem_save_service_start_name_0;
4370         TALLOC_CTX *_mem_save_password_0;
4371         TALLOC_CTX *_mem_save_display_name_0;
4372         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4373         if (flags & NDR_IN) {
4374                 ZERO_STRUCT(r->out);
4375
4376                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4377                         NDR_PULL_ALLOC(ndr, r->in.handle);
4378                 }
4379                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4380                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4381                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
4384                 NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
4385                 NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
4386                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
4387                 if (_ptr_binary_path) {
4388                         NDR_PULL_ALLOC(ndr, r->in.binary_path);
4389                 } else {
4390                         r->in.binary_path = NULL;
4391                 }
4392                 if (r->in.binary_path) {
4393                         _mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4394                         NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);
4395                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
4396                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
4397                         size_binary_path_1 = ndr_get_array_size(ndr, &r->in.binary_path);
4398                         length_binary_path_1 = ndr_get_array_length(ndr, &r->in.binary_path);
4399                         if (length_binary_path_1 > size_binary_path_1) {
4400                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_binary_path_1, length_binary_path_1);
4401                         }
4402                         NDR_CHECK(ndr_check_string_terminator(ndr, length_binary_path_1, sizeof(uint16_t)));
4403                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, length_binary_path_1, sizeof(uint16_t), CH_UTF16));
4404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);
4405                 }
4406                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_load_order_group));
4407                 if (_ptr_load_order_group) {
4408                         NDR_PULL_ALLOC(ndr, r->in.load_order_group);
4409                 } else {
4410                         r->in.load_order_group = NULL;
4411                 }
4412                 if (r->in.load_order_group) {
4413                         _mem_save_load_order_group_0 = NDR_PULL_GET_MEM_CTX(ndr);
4414                         NDR_PULL_SET_MEM_CTX(ndr, r->in.load_order_group, 0);
4415                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.load_order_group));
4416                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.load_order_group));
4417                         size_load_order_group_1 = ndr_get_array_size(ndr, &r->in.load_order_group);
4418                         length_load_order_group_1 = ndr_get_array_length(ndr, &r->in.load_order_group);
4419                         if (length_load_order_group_1 > size_load_order_group_1) {
4420                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_load_order_group_1, length_load_order_group_1);
4421                         }
4422                         NDR_CHECK(ndr_check_string_terminator(ndr, length_load_order_group_1, sizeof(uint16_t)));
4423                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.load_order_group, length_load_order_group_1, sizeof(uint16_t), CH_UTF16));
4424                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_load_order_group_0, 0);
4425                 }
4426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
4427                 if (_ptr_dependencies) {
4428                         NDR_PULL_ALLOC(ndr, r->in.dependencies);
4429                 } else {
4430                         r->in.dependencies = NULL;
4431                 }
4432                 if (r->in.dependencies) {
4433                         _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
4434                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
4435                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
4436                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));
4437                         size_dependencies_1 = ndr_get_array_size(ndr, &r->in.dependencies);
4438                         length_dependencies_1 = ndr_get_array_length(ndr, &r->in.dependencies);
4439                         if (length_dependencies_1 > size_dependencies_1) {
4440                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dependencies_1, length_dependencies_1);
4441                         }
4442                         NDR_CHECK(ndr_check_string_terminator(ndr, length_dependencies_1, sizeof(uint16_t)));
4443                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, length_dependencies_1, sizeof(uint16_t), CH_UTF16));
4444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
4445                 }
4446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
4447                 if (_ptr_service_start_name) {
4448                         NDR_PULL_ALLOC(ndr, r->in.service_start_name);
4449                 } else {
4450                         r->in.service_start_name = NULL;
4451                 }
4452                 if (r->in.service_start_name) {
4453                         _mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4454                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
4455                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
4456                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
4457                         size_service_start_name_1 = ndr_get_array_size(ndr, &r->in.service_start_name);
4458                         length_service_start_name_1 = ndr_get_array_length(ndr, &r->in.service_start_name);
4459                         if (length_service_start_name_1 > size_service_start_name_1) {
4460                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_service_start_name_1, length_service_start_name_1);
4461                         }
4462                         NDR_CHECK(ndr_check_string_terminator(ndr, length_service_start_name_1, sizeof(uint16_t)));
4463                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, length_service_start_name_1, sizeof(uint16_t), CH_UTF16));
4464                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
4465                 }
4466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4467                 if (_ptr_password) {
4468                         NDR_PULL_ALLOC(ndr, r->in.password);
4469                 } else {
4470                         r->in.password = NULL;
4471                 }
4472                 if (r->in.password) {
4473                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4474                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
4475                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
4476                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
4477                         size_password_1 = ndr_get_array_size(ndr, &r->in.password);
4478                         length_password_1 = ndr_get_array_length(ndr, &r->in.password);
4479                         if (length_password_1 > size_password_1) {
4480                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_password_1, length_password_1);
4481                         }
4482                         NDR_CHECK(ndr_check_string_terminator(ndr, length_password_1, sizeof(uint16_t)));
4483                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, length_password_1, sizeof(uint16_t), CH_UTF16));
4484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4485                 }
4486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
4487                 if (_ptr_display_name) {
4488                         NDR_PULL_ALLOC(ndr, r->in.display_name);
4489                 } else {
4490                         r->in.display_name = NULL;
4491                 }
4492                 if (r->in.display_name) {
4493                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4494                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name, 0);
4495                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.display_name));
4496                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.display_name));
4497                         size_display_name_1 = ndr_get_array_size(ndr, &r->in.display_name);
4498                         length_display_name_1 = ndr_get_array_length(ndr, &r->in.display_name);
4499                         if (length_display_name_1 > size_display_name_1) {
4500                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_display_name_1, length_display_name_1);
4501                         }
4502                         NDR_CHECK(ndr_check_string_terminator(ndr, length_display_name_1, sizeof(uint16_t)));
4503                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.display_name, length_display_name_1, sizeof(uint16_t), CH_UTF16));
4504                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
4505                 }
4506                 NDR_PULL_ALLOC(ndr, r->out.tag_id);
4507                 ZERO_STRUCTP(r->out.tag_id);
4508         }
4509         if (flags & NDR_OUT) {
4510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4511                         NDR_PULL_ALLOC(ndr, r->out.tag_id);
4512                 }
4513                 _mem_save_tag_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
4514                 NDR_PULL_SET_MEM_CTX(ndr, r->out.tag_id, LIBNDR_FLAG_REF_ALLOC);
4515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.tag_id));
4516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tag_id_0, LIBNDR_FLAG_REF_ALLOC);
4517                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4518         }
4519         return NDR_ERR_SUCCESS;
4520 }
4521
4522 _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfigA *r)
4523 {
4524         ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfigA");
4525         if (r == NULL) { ndr_print_null(ndr); return; }
4526         ndr->depth++;
4527         if (flags & NDR_SET_VALUES) {
4528                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4529         }
4530         if (flags & NDR_IN) {
4531                 ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfigA");
4532                 ndr->depth++;
4533                 ndr_print_ptr(ndr, "handle", r->in.handle);
4534                 ndr->depth++;
4535                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4536                 ndr->depth--;
4537                 ndr_print_uint32(ndr, "type", r->in.type);
4538                 ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
4539                 ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
4540                 ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
4541                 ndr->depth++;
4542                 if (r->in.binary_path) {
4543                         ndr_print_string(ndr, "binary_path", r->in.binary_path);
4544                 }
4545                 ndr->depth--;
4546                 ndr_print_ptr(ndr, "load_order_group", r->in.load_order_group);
4547                 ndr->depth++;
4548                 if (r->in.load_order_group) {
4549                         ndr_print_string(ndr, "load_order_group", r->in.load_order_group);
4550                 }
4551                 ndr->depth--;
4552                 ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
4553                 ndr->depth++;
4554                 if (r->in.dependencies) {
4555                         ndr_print_string(ndr, "dependencies", r->in.dependencies);
4556                 }
4557                 ndr->depth--;
4558                 ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
4559                 ndr->depth++;
4560                 if (r->in.service_start_name) {
4561                         ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
4562                 }
4563                 ndr->depth--;
4564                 ndr_print_ptr(ndr, "password", r->in.password);
4565                 ndr->depth++;
4566                 if (r->in.password) {
4567                         ndr_print_string(ndr, "password", r->in.password);
4568                 }
4569                 ndr->depth--;
4570                 ndr_print_ptr(ndr, "display_name", r->in.display_name);
4571                 ndr->depth++;
4572                 if (r->in.display_name) {
4573                         ndr_print_string(ndr, "display_name", r->in.display_name);
4574                 }
4575                 ndr->depth--;
4576                 ndr->depth--;
4577         }
4578         if (flags & NDR_OUT) {
4579                 ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfigA");
4580                 ndr->depth++;
4581                 ndr_print_ptr(ndr, "tag_id", r->out.tag_id);
4582                 ndr->depth++;
4583                 ndr_print_uint32(ndr, "tag_id", *r->out.tag_id);
4584                 ndr->depth--;
4585                 ndr_print_WERROR(ndr, "result", r->out.result);
4586                 ndr->depth--;
4587         }
4588         ndr->depth--;
4589 }
4590
4591 static enum ndr_err_code ndr_push_svcctl_CreateServiceA(struct ndr_push *ndr, int flags, const struct svcctl_CreateServiceA *r)
4592 {
4593         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4594         if (flags & NDR_IN) {
4595                 if (r->in.handle == NULL) {
4596                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4597                 }
4598                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));
4600                 if (r->in.ServiceName) {
4601                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
4602                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4603                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
4604                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4605                 }
4606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DisplayName));
4607                 if (r->in.DisplayName) {
4608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
4609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
4611                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4612                 }
4613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.desired_access));
4614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
4615                 NDR_CHECK(ndr_push_svcctl_StartType(ndr, NDR_SCALARS, r->in.start_type));
4616                 NDR_CHECK(ndr_push_svcctl_ErrorControl(ndr, NDR_SCALARS, r->in.error_control));
4617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
4618                 if (r->in.binary_path) {
4619                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
4620                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
4622                         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));
4623                 }
4624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.LoadOrderGroupKey));
4625                 if (r->in.LoadOrderGroupKey) {
4626                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
4627                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
4629                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4630                 }
4631                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
4632                 if (r->in.dependencies) {
4633                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
4634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
4636                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4637                 }
4638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
4639                 if (r->in.service_start_name) {
4640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
4641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
4643                         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));
4644                 }
4645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
4646                 if (r->in.password) {
4647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
4648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
4650                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4651                 }
4652         }
4653         if (flags & NDR_OUT) {
4654                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.TagId));
4655                 if (r->out.TagId) {
4656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.TagId));
4657                 }
4658                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4659         }
4660         return NDR_ERR_SUCCESS;
4661 }
4662
4663 static enum ndr_err_code ndr_pull_svcctl_CreateServiceA(struct ndr_pull *ndr, int flags, struct svcctl_CreateServiceA *r)
4664 {
4665         uint32_t _ptr_ServiceName;
4666         uint32_t size_ServiceName_1 = 0;
4667         uint32_t length_ServiceName_1 = 0;
4668         uint32_t _ptr_DisplayName;
4669         uint32_t size_DisplayName_1 = 0;
4670         uint32_t length_DisplayName_1 = 0;
4671         uint32_t _ptr_binary_path;
4672         uint32_t size_binary_path_1 = 0;
4673         uint32_t length_binary_path_1 = 0;
4674         uint32_t _ptr_LoadOrderGroupKey;
4675         uint32_t size_LoadOrderGroupKey_1 = 0;
4676         uint32_t length_LoadOrderGroupKey_1 = 0;
4677         uint32_t _ptr_TagId;
4678         uint32_t _ptr_dependencies;
4679         uint32_t size_dependencies_1 = 0;
4680         uint32_t length_dependencies_1 = 0;
4681         uint32_t _ptr_service_start_name;
4682         uint32_t size_service_start_name_1 = 0;
4683         uint32_t length_service_start_name_1 = 0;
4684         uint32_t _ptr_password;
4685         uint32_t size_password_1 = 0;
4686         uint32_t length_password_1 = 0;
4687         TALLOC_CTX *_mem_save_handle_0;
4688         TALLOC_CTX *_mem_save_ServiceName_0;
4689         TALLOC_CTX *_mem_save_DisplayName_0;
4690         TALLOC_CTX *_mem_save_binary_path_0;
4691         TALLOC_CTX *_mem_save_LoadOrderGroupKey_0;
4692         TALLOC_CTX *_mem_save_TagId_0;
4693         TALLOC_CTX *_mem_save_dependencies_0;
4694         TALLOC_CTX *_mem_save_service_start_name_0;
4695         TALLOC_CTX *_mem_save_password_0;
4696         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4697         if (flags & NDR_IN) {
4698                 ZERO_STRUCT(r->out);
4699
4700                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4701                         NDR_PULL_ALLOC(ndr, r->in.handle);
4702                 }
4703                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4704                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4705                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
4706                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ServiceName));
4708                 if (_ptr_ServiceName) {
4709                         NDR_PULL_ALLOC(ndr, r->in.ServiceName);
4710                 } else {
4711                         r->in.ServiceName = NULL;
4712                 }
4713                 if (r->in.ServiceName) {
4714                         _mem_save_ServiceName_0 = NDR_PULL_GET_MEM_CTX(ndr);
4715                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ServiceName, 0);
4716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
4717                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
4718                         size_ServiceName_1 = ndr_get_array_size(ndr, &r->in.ServiceName);
4719                         length_ServiceName_1 = ndr_get_array_length(ndr, &r->in.ServiceName);
4720                         if (length_ServiceName_1 > size_ServiceName_1) {
4721                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ServiceName_1, length_ServiceName_1);
4722                         }
4723                         NDR_CHECK(ndr_check_string_terminator(ndr, length_ServiceName_1, sizeof(uint16_t)));
4724                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, length_ServiceName_1, sizeof(uint16_t), CH_UTF16));
4725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ServiceName_0, 0);
4726                 }
4727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DisplayName));
4728                 if (_ptr_DisplayName) {
4729                         NDR_PULL_ALLOC(ndr, r->in.DisplayName);
4730                 } else {
4731                         r->in.DisplayName = NULL;
4732                 }
4733                 if (r->in.DisplayName) {
4734                         _mem_save_DisplayName_0 = NDR_PULL_GET_MEM_CTX(ndr);
4735                         NDR_PULL_SET_MEM_CTX(ndr, r->in.DisplayName, 0);
4736                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DisplayName));
4737                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DisplayName));
4738                         size_DisplayName_1 = ndr_get_array_size(ndr, &r->in.DisplayName);
4739                         length_DisplayName_1 = ndr_get_array_length(ndr, &r->in.DisplayName);
4740                         if (length_DisplayName_1 > size_DisplayName_1) {
4741                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_DisplayName_1, length_DisplayName_1);
4742                         }
4743                         NDR_CHECK(ndr_check_string_terminator(ndr, length_DisplayName_1, sizeof(uint16_t)));
4744                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DisplayName, length_DisplayName_1, sizeof(uint16_t), CH_UTF16));
4745                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DisplayName_0, 0);
4746                 }
4747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.desired_access));
4748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
4749                 NDR_CHECK(ndr_pull_svcctl_StartType(ndr, NDR_SCALARS, &r->in.start_type));
4750                 NDR_CHECK(ndr_pull_svcctl_ErrorControl(ndr, NDR_SCALARS, &r->in.error_control));
4751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
4752                 if (_ptr_binary_path) {
4753                         NDR_PULL_ALLOC(ndr, r->in.binary_path);
4754                 } else {
4755                         r->in.binary_path = NULL;
4756                 }
4757                 if (r->in.binary_path) {
4758                         _mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4759                         NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);
4760                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
4761                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
4762                         size_binary_path_1 = ndr_get_array_size(ndr, &r->in.binary_path);
4763                         length_binary_path_1 = ndr_get_array_length(ndr, &r->in.binary_path);
4764                         if (length_binary_path_1 > size_binary_path_1) {
4765                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_binary_path_1, length_binary_path_1);
4766                         }
4767                         NDR_CHECK(ndr_check_string_terminator(ndr, length_binary_path_1, sizeof(uint16_t)));
4768                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, length_binary_path_1, sizeof(uint16_t), CH_UTF16));
4769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);
4770                 }
4771                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_LoadOrderGroupKey));
4772                 if (_ptr_LoadOrderGroupKey) {
4773                         NDR_PULL_ALLOC(ndr, r->in.LoadOrderGroupKey);
4774                 } else {
4775                         r->in.LoadOrderGroupKey = NULL;
4776                 }
4777                 if (r->in.LoadOrderGroupKey) {
4778                         _mem_save_LoadOrderGroupKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
4779                         NDR_PULL_SET_MEM_CTX(ndr, r->in.LoadOrderGroupKey, 0);
4780                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.LoadOrderGroupKey));
4781                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.LoadOrderGroupKey));
4782                         size_LoadOrderGroupKey_1 = ndr_get_array_size(ndr, &r->in.LoadOrderGroupKey);
4783                         length_LoadOrderGroupKey_1 = ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey);
4784                         if (length_LoadOrderGroupKey_1 > size_LoadOrderGroupKey_1) {
4785                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_LoadOrderGroupKey_1, length_LoadOrderGroupKey_1);
4786                         }
4787                         NDR_CHECK(ndr_check_string_terminator(ndr, length_LoadOrderGroupKey_1, sizeof(uint16_t)));
4788                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.LoadOrderGroupKey, length_LoadOrderGroupKey_1, sizeof(uint16_t), CH_UTF16));
4789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_LoadOrderGroupKey_0, 0);
4790                 }
4791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
4792                 if (_ptr_dependencies) {
4793                         NDR_PULL_ALLOC(ndr, r->in.dependencies);
4794                 } else {
4795                         r->in.dependencies = NULL;
4796                 }
4797                 if (r->in.dependencies) {
4798                         _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
4799                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
4800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
4801                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));
4802                         size_dependencies_1 = ndr_get_array_size(ndr, &r->in.dependencies);
4803                         length_dependencies_1 = ndr_get_array_length(ndr, &r->in.dependencies);
4804                         if (length_dependencies_1 > size_dependencies_1) {
4805                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_dependencies_1, length_dependencies_1);
4806                         }
4807                         NDR_CHECK(ndr_check_string_terminator(ndr, length_dependencies_1, sizeof(uint16_t)));
4808                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, length_dependencies_1, sizeof(uint16_t), CH_UTF16));
4809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
4810                 }
4811                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
4812                 if (_ptr_service_start_name) {
4813                         NDR_PULL_ALLOC(ndr, r->in.service_start_name);
4814                 } else {
4815                         r->in.service_start_name = NULL;
4816                 }
4817                 if (r->in.service_start_name) {
4818                         _mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4819                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
4820                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
4821                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
4822                         size_service_start_name_1 = ndr_get_array_size(ndr, &r->in.service_start_name);
4823                         length_service_start_name_1 = ndr_get_array_length(ndr, &r->in.service_start_name);
4824                         if (length_service_start_name_1 > size_service_start_name_1) {
4825                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_service_start_name_1, length_service_start_name_1);
4826                         }
4827                         NDR_CHECK(ndr_check_string_terminator(ndr, length_service_start_name_1, sizeof(uint16_t)));
4828                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, length_service_start_name_1, sizeof(uint16_t), CH_UTF16));
4829                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
4830                 }
4831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
4832                 if (_ptr_password) {
4833                         NDR_PULL_ALLOC(ndr, r->in.password);
4834                 } else {
4835                         r->in.password = NULL;
4836                 }
4837                 if (r->in.password) {
4838                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
4839                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
4840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
4841                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
4842                         size_password_1 = ndr_get_array_size(ndr, &r->in.password);
4843                         length_password_1 = ndr_get_array_length(ndr, &r->in.password);
4844                         if (length_password_1 > size_password_1) {
4845                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_password_1, length_password_1);
4846                         }
4847                         NDR_CHECK(ndr_check_string_terminator(ndr, length_password_1, sizeof(uint16_t)));
4848                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, length_password_1, sizeof(uint16_t), CH_UTF16));
4849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
4850                 }
4851         }
4852         if (flags & NDR_OUT) {
4853                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));
4854                 if (_ptr_TagId) {
4855                         NDR_PULL_ALLOC(ndr, r->out.TagId);
4856                 } else {
4857                         r->out.TagId = NULL;
4858                 }
4859                 if (r->out.TagId) {
4860                         _mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);
4861                         NDR_PULL_SET_MEM_CTX(ndr, r->out.TagId, 0);
4862                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.TagId));
4863                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);
4864                 }
4865                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4866         }
4867         return NDR_ERR_SUCCESS;
4868 }
4869
4870 _PUBLIC_ void ndr_print_svcctl_CreateServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CreateServiceA *r)
4871 {
4872         ndr_print_struct(ndr, name, "svcctl_CreateServiceA");
4873         if (r == NULL) { ndr_print_null(ndr); return; }
4874         ndr->depth++;
4875         if (flags & NDR_SET_VALUES) {
4876                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4877         }
4878         if (flags & NDR_IN) {
4879                 ndr_print_struct(ndr, "in", "svcctl_CreateServiceA");
4880                 ndr->depth++;
4881                 ndr_print_ptr(ndr, "handle", r->in.handle);
4882                 ndr->depth++;
4883                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4884                 ndr->depth--;
4885                 ndr_print_ptr(ndr, "ServiceName", r->in.ServiceName);
4886                 ndr->depth++;
4887                 if (r->in.ServiceName) {
4888                         ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
4889                 }
4890                 ndr->depth--;
4891                 ndr_print_ptr(ndr, "DisplayName", r->in.DisplayName);
4892                 ndr->depth++;
4893                 if (r->in.DisplayName) {
4894                         ndr_print_string(ndr, "DisplayName", r->in.DisplayName);
4895                 }
4896                 ndr->depth--;
4897                 ndr_print_uint32(ndr, "desired_access", r->in.desired_access);
4898                 ndr_print_uint32(ndr, "type", r->in.type);
4899                 ndr_print_svcctl_StartType(ndr, "start_type", r->in.start_type);
4900                 ndr_print_svcctl_ErrorControl(ndr, "error_control", r->in.error_control);
4901                 ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
4902                 ndr->depth++;
4903                 if (r->in.binary_path) {
4904                         ndr_print_string(ndr, "binary_path", r->in.binary_path);
4905                 }
4906                 ndr->depth--;
4907                 ndr_print_ptr(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
4908                 ndr->depth++;
4909                 if (r->in.LoadOrderGroupKey) {
4910                         ndr_print_string(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
4911                 }
4912                 ndr->depth--;
4913                 ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
4914                 ndr->depth++;
4915                 if (r->in.dependencies) {
4916                         ndr_print_string(ndr, "dependencies", r->in.dependencies);
4917                 }
4918                 ndr->depth--;
4919                 ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
4920                 ndr->depth++;
4921                 if (r->in.service_start_name) {
4922                         ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
4923                 }
4924                 ndr->depth--;
4925                 ndr_print_ptr(ndr, "password", r->in.password);
4926                 ndr->depth++;
4927                 if (r->in.password) {
4928                         ndr_print_string(ndr, "password", r->in.password);
4929                 }
4930                 ndr->depth--;
4931                 ndr->depth--;
4932         }
4933         if (flags & NDR_OUT) {
4934                 ndr_print_struct(ndr, "out", "svcctl_CreateServiceA");
4935                 ndr->depth++;
4936                 ndr_print_ptr(ndr, "TagId", r->out.TagId);
4937                 ndr->depth++;
4938                 if (r->out.TagId) {
4939                         ndr_print_uint32(ndr, "TagId", *r->out.TagId);
4940                 }
4941                 ndr->depth--;
4942                 ndr_print_WERROR(ndr, "result", r->out.result);
4943                 ndr->depth--;
4944         }
4945         ndr->depth--;
4946 }
4947
4948 static enum ndr_err_code ndr_push_svcctl_EnumDependentServicesA(struct ndr_push *ndr, int flags, const struct svcctl_EnumDependentServicesA *r)
4949 {
4950         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
4951         if (flags & NDR_IN) {
4952                 if (r->in.service == NULL) {
4953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4954                 }
4955                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.service));
4956                 NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
4957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
4958         }
4959         if (flags & NDR_OUT) {
4960                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.service_status));
4961                 if (r->out.service_status) {
4962                         NDR_CHECK(ndr_push_ENUM_SERVICE_STATUSA(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
4963                 }
4964                 if (r->out.needed == NULL) {
4965                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4966                 }
4967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
4968                 if (r->out.services_returned == NULL) {
4969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4970                 }
4971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
4972                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4973         }
4974         return NDR_ERR_SUCCESS;
4975 }
4976
4977 static enum ndr_err_code ndr_pull_svcctl_EnumDependentServicesA(struct ndr_pull *ndr, int flags, struct svcctl_EnumDependentServicesA *r)
4978 {
4979         uint32_t _ptr_service_status;
4980         TALLOC_CTX *_mem_save_service_0;
4981         TALLOC_CTX *_mem_save_service_status_0;
4982         TALLOC_CTX *_mem_save_needed_0;
4983         TALLOC_CTX *_mem_save_services_returned_0;
4984         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
4985         if (flags & NDR_IN) {
4986                 ZERO_STRUCT(r->out);
4987
4988                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4989                         NDR_PULL_ALLOC(ndr, r->in.service);
4990                 }
4991                 _mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);
4992                 NDR_PULL_SET_MEM_CTX(ndr, r->in.service, LIBNDR_FLAG_REF_ALLOC);
4993                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.service));
4994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);
4995                 NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
4996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
4997                 NDR_PULL_ALLOC(ndr, r->out.needed);
4998                 ZERO_STRUCTP(r->out.needed);
4999                 NDR_PULL_ALLOC(ndr, r->out.services_returned);
5000                 ZERO_STRUCTP(r->out.services_returned);
5001         }
5002         if (flags & NDR_OUT) {
5003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_status));
5004                 if (_ptr_service_status) {
5005                         NDR_PULL_ALLOC(ndr, r->out.service_status);
5006                 } else {
5007                         r->out.service_status = NULL;
5008                 }
5009                 if (r->out.service_status) {
5010                         _mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5011                         NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, 0);
5012                         NDR_CHECK(ndr_pull_ENUM_SERVICE_STATUSA(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
5013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, 0);
5014                 }
5015                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5016                         NDR_PULL_ALLOC(ndr, r->out.needed);
5017                 }
5018                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
5019                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
5020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
5021                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
5022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5023                         NDR_PULL_ALLOC(ndr, r->out.services_returned);
5024                 }
5025                 _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
5026                 NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
5027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
5028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
5029                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5030         }
5031         return NDR_ERR_SUCCESS;
5032 }
5033
5034 _PUBLIC_ void ndr_print_svcctl_EnumDependentServicesA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumDependentServicesA *r)
5035 {
5036         ndr_print_struct(ndr, name, "svcctl_EnumDependentServicesA");
5037         if (r == NULL) { ndr_print_null(ndr); return; }
5038         ndr->depth++;
5039         if (flags & NDR_SET_VALUES) {
5040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5041         }
5042         if (flags & NDR_IN) {
5043                 ndr_print_struct(ndr, "in", "svcctl_EnumDependentServicesA");
5044                 ndr->depth++;
5045                 ndr_print_ptr(ndr, "service", r->in.service);
5046                 ndr->depth++;
5047                 ndr_print_policy_handle(ndr, "service", r->in.service);
5048                 ndr->depth--;
5049                 ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
5050                 ndr_print_uint32(ndr, "offered", r->in.offered);
5051                 ndr->depth--;
5052         }
5053         if (flags & NDR_OUT) {
5054                 ndr_print_struct(ndr, "out", "svcctl_EnumDependentServicesA");
5055                 ndr->depth++;
5056                 ndr_print_ptr(ndr, "service_status", r->out.service_status);
5057                 ndr->depth++;
5058                 if (r->out.service_status) {
5059                         ndr_print_ENUM_SERVICE_STATUSA(ndr, "service_status", r->out.service_status);
5060                 }
5061                 ndr->depth--;
5062                 ndr_print_ptr(ndr, "needed", r->out.needed);
5063                 ndr->depth++;
5064                 ndr_print_uint32(ndr, "needed", *r->out.needed);
5065                 ndr->depth--;
5066                 ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
5067                 ndr->depth++;
5068                 ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
5069                 ndr->depth--;
5070                 ndr_print_WERROR(ndr, "result", r->out.result);
5071                 ndr->depth--;
5072         }
5073         ndr->depth--;
5074 }
5075
5076 static enum ndr_err_code ndr_push_svcctl_EnumServicesStatusA(struct ndr_push *ndr, int flags, const struct svcctl_EnumServicesStatusA *r)
5077 {
5078         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5079         if (flags & NDR_IN) {
5080                 if (r->in.handle == NULL) {
5081                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5082                 }
5083                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
5085                 NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
5086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
5087                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
5088                 if (r->in.resume_handle) {
5089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5090                 }
5091         }
5092         if (flags & NDR_OUT) {
5093                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
5094                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.offered));
5095                 if (r->out.needed == NULL) {
5096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5097                 }
5098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
5099                 if (r->out.services_returned == NULL) {
5100                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5101                 }
5102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
5103                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
5104                 if (r->out.resume_handle) {
5105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5106                 }
5107                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5108         }
5109         return NDR_ERR_SUCCESS;
5110 }
5111
5112 static enum ndr_err_code ndr_pull_svcctl_EnumServicesStatusA(struct ndr_pull *ndr, int flags, struct svcctl_EnumServicesStatusA *r)
5113 {
5114         uint32_t size_service_0 = 0;
5115         uint32_t _ptr_resume_handle;
5116         TALLOC_CTX *_mem_save_handle_0;
5117         TALLOC_CTX *_mem_save_needed_0;
5118         TALLOC_CTX *_mem_save_services_returned_0;
5119         TALLOC_CTX *_mem_save_resume_handle_0;
5120         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5121         if (flags & NDR_IN) {
5122                 ZERO_STRUCT(r->out);
5123
5124                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5125                         NDR_PULL_ALLOC(ndr, r->in.handle);
5126                 }
5127                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5128                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5129                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5130                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
5132                 NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
5133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
5134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
5135                 if (_ptr_resume_handle) {
5136                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5137                 } else {
5138                         r->in.resume_handle = NULL;
5139                 }
5140                 if (r->in.resume_handle) {
5141                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5142                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
5143                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5144                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
5145                 }
5146                 NDR_PULL_ALLOC(ndr, r->out.needed);
5147                 ZERO_STRUCTP(r->out.needed);
5148                 NDR_PULL_ALLOC(ndr, r->out.services_returned);
5149                 ZERO_STRUCTP(r->out.services_returned);
5150         }
5151         if (flags & NDR_OUT) {
5152                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.service));
5153                 size_service_0 = ndr_get_array_size(ndr, &r->out.service);
5154                 NDR_PULL_ALLOC_N(ndr, r->out.service, size_service_0);
5155                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, size_service_0));
5156                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5157                         NDR_PULL_ALLOC(ndr, r->out.needed);
5158                 }
5159                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
5160                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
5161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
5162                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
5163                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5164                         NDR_PULL_ALLOC(ndr, r->out.services_returned);
5165                 }
5166                 _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
5167                 NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
5168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
5169                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
5170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
5171                 if (_ptr_resume_handle) {
5172                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5173                 } else {
5174                         r->out.resume_handle = NULL;
5175                 }
5176                 if (r->out.resume_handle) {
5177                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5178                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
5179                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
5181                 }
5182                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5183                 if (r->out.service) {
5184                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.offered));
5185                 }
5186         }
5187         return NDR_ERR_SUCCESS;
5188 }
5189
5190 _PUBLIC_ void ndr_print_svcctl_EnumServicesStatusA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServicesStatusA *r)
5191 {
5192         ndr_print_struct(ndr, name, "svcctl_EnumServicesStatusA");
5193         if (r == NULL) { ndr_print_null(ndr); return; }
5194         ndr->depth++;
5195         if (flags & NDR_SET_VALUES) {
5196                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5197         }
5198         if (flags & NDR_IN) {
5199                 ndr_print_struct(ndr, "in", "svcctl_EnumServicesStatusA");
5200                 ndr->depth++;
5201                 ndr_print_ptr(ndr, "handle", r->in.handle);
5202                 ndr->depth++;
5203                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5204                 ndr->depth--;
5205                 ndr_print_uint32(ndr, "type", r->in.type);
5206                 ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
5207                 ndr_print_uint32(ndr, "offered", r->in.offered);
5208                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5209                 ndr->depth++;
5210                 if (r->in.resume_handle) {
5211                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5212                 }
5213                 ndr->depth--;
5214                 ndr->depth--;
5215         }
5216         if (flags & NDR_OUT) {
5217                 ndr_print_struct(ndr, "out", "svcctl_EnumServicesStatusA");
5218                 ndr->depth++;
5219                 ndr_print_array_uint8(ndr, "service", r->out.service, r->in.offered);
5220                 ndr_print_ptr(ndr, "needed", r->out.needed);
5221                 ndr->depth++;
5222                 ndr_print_uint32(ndr, "needed", *r->out.needed);
5223                 ndr->depth--;
5224                 ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
5225                 ndr->depth++;
5226                 ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
5227                 ndr->depth--;
5228                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5229                 ndr->depth++;
5230                 if (r->out.resume_handle) {
5231                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5232                 }
5233                 ndr->depth--;
5234                 ndr_print_WERROR(ndr, "result", r->out.result);
5235                 ndr->depth--;
5236         }
5237         ndr->depth--;
5238 }
5239
5240 static enum ndr_err_code ndr_push_svcctl_OpenSCManagerA(struct ndr_push *ndr, int flags, const struct svcctl_OpenSCManagerA *r)
5241 {
5242         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5243         if (flags & NDR_IN) {
5244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.MachineName));
5245                 if (r->in.MachineName) {
5246                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
5247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
5249                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5250                 }
5251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DatabaseName));
5252                 if (r->in.DatabaseName) {
5253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
5254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
5256                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5257                 }
5258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5259         }
5260         if (flags & NDR_OUT) {
5261                 if (r->out.handle == NULL) {
5262                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5263                 }
5264                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5265                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5266         }
5267         return NDR_ERR_SUCCESS;
5268 }
5269
5270 static enum ndr_err_code ndr_pull_svcctl_OpenSCManagerA(struct ndr_pull *ndr, int flags, struct svcctl_OpenSCManagerA *r)
5271 {
5272         uint32_t _ptr_MachineName;
5273         uint32_t size_MachineName_1 = 0;
5274         uint32_t length_MachineName_1 = 0;
5275         uint32_t _ptr_DatabaseName;
5276         uint32_t size_DatabaseName_1 = 0;
5277         uint32_t length_DatabaseName_1 = 0;
5278         TALLOC_CTX *_mem_save_MachineName_0;
5279         TALLOC_CTX *_mem_save_DatabaseName_0;
5280         TALLOC_CTX *_mem_save_handle_0;
5281         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5282         if (flags & NDR_IN) {
5283                 ZERO_STRUCT(r->out);
5284
5285                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_MachineName));
5286                 if (_ptr_MachineName) {
5287                         NDR_PULL_ALLOC(ndr, r->in.MachineName);
5288                 } else {
5289                         r->in.MachineName = NULL;
5290                 }
5291                 if (r->in.MachineName) {
5292                         _mem_save_MachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
5293                         NDR_PULL_SET_MEM_CTX(ndr, r->in.MachineName, 0);
5294                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.MachineName));
5295                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.MachineName));
5296                         size_MachineName_1 = ndr_get_array_size(ndr, &r->in.MachineName);
5297                         length_MachineName_1 = ndr_get_array_length(ndr, &r->in.MachineName);
5298                         if (length_MachineName_1 > size_MachineName_1) {
5299                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_MachineName_1, length_MachineName_1);
5300                         }
5301                         NDR_CHECK(ndr_check_string_terminator(ndr, length_MachineName_1, sizeof(uint16_t)));
5302                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.MachineName, length_MachineName_1, sizeof(uint16_t), CH_UTF16));
5303                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MachineName_0, 0);
5304                 }
5305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DatabaseName));
5306                 if (_ptr_DatabaseName) {
5307                         NDR_PULL_ALLOC(ndr, r->in.DatabaseName);
5308                 } else {
5309                         r->in.DatabaseName = NULL;
5310                 }
5311                 if (r->in.DatabaseName) {
5312                         _mem_save_DatabaseName_0 = NDR_PULL_GET_MEM_CTX(ndr);
5313                         NDR_PULL_SET_MEM_CTX(ndr, r->in.DatabaseName, 0);
5314                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DatabaseName));
5315                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DatabaseName));
5316                         size_DatabaseName_1 = ndr_get_array_size(ndr, &r->in.DatabaseName);
5317                         length_DatabaseName_1 = ndr_get_array_length(ndr, &r->in.DatabaseName);
5318                         if (length_DatabaseName_1 > size_DatabaseName_1) {
5319                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_DatabaseName_1, length_DatabaseName_1);
5320                         }
5321                         NDR_CHECK(ndr_check_string_terminator(ndr, length_DatabaseName_1, sizeof(uint16_t)));
5322                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DatabaseName, length_DatabaseName_1, sizeof(uint16_t), CH_UTF16));
5323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DatabaseName_0, 0);
5324                 }
5325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5326                 NDR_PULL_ALLOC(ndr, r->out.handle);
5327                 ZERO_STRUCTP(r->out.handle);
5328         }
5329         if (flags & NDR_OUT) {
5330                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5331                         NDR_PULL_ALLOC(ndr, r->out.handle);
5332                 }
5333                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5334                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
5335                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
5336                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5337                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5338         }
5339         return NDR_ERR_SUCCESS;
5340 }
5341
5342 _PUBLIC_ void ndr_print_svcctl_OpenSCManagerA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenSCManagerA *r)
5343 {
5344         ndr_print_struct(ndr, name, "svcctl_OpenSCManagerA");
5345         if (r == NULL) { ndr_print_null(ndr); return; }
5346         ndr->depth++;
5347         if (flags & NDR_SET_VALUES) {
5348                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5349         }
5350         if (flags & NDR_IN) {
5351                 ndr_print_struct(ndr, "in", "svcctl_OpenSCManagerA");
5352                 ndr->depth++;
5353                 ndr_print_ptr(ndr, "MachineName", r->in.MachineName);
5354                 ndr->depth++;
5355                 if (r->in.MachineName) {
5356                         ndr_print_string(ndr, "MachineName", r->in.MachineName);
5357                 }
5358                 ndr->depth--;
5359                 ndr_print_ptr(ndr, "DatabaseName", r->in.DatabaseName);
5360                 ndr->depth++;
5361                 if (r->in.DatabaseName) {
5362                         ndr_print_string(ndr, "DatabaseName", r->in.DatabaseName);
5363                 }
5364                 ndr->depth--;
5365                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5366                 ndr->depth--;
5367         }
5368         if (flags & NDR_OUT) {
5369                 ndr_print_struct(ndr, "out", "svcctl_OpenSCManagerA");
5370                 ndr->depth++;
5371                 ndr_print_ptr(ndr, "handle", r->out.handle);
5372                 ndr->depth++;
5373                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
5374                 ndr->depth--;
5375                 ndr_print_WERROR(ndr, "result", r->out.result);
5376                 ndr->depth--;
5377         }
5378         ndr->depth--;
5379 }
5380
5381 static enum ndr_err_code ndr_push_svcctl_OpenServiceA(struct ndr_push *ndr, int flags, const struct svcctl_OpenServiceA *r)
5382 {
5383         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5384         if (flags & NDR_IN) {
5385                 if (r->in.scmanager_handle == NULL) {
5386                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5387                 }
5388                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
5389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));
5390                 if (r->in.ServiceName) {
5391                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
5392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
5394                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5395                 }
5396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
5397         }
5398         if (flags & NDR_OUT) {
5399                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5400         }
5401         return NDR_ERR_SUCCESS;
5402 }
5403
5404 static enum ndr_err_code ndr_pull_svcctl_OpenServiceA(struct ndr_pull *ndr, int flags, struct svcctl_OpenServiceA *r)
5405 {
5406         uint32_t _ptr_ServiceName;
5407         uint32_t size_ServiceName_1 = 0;
5408         uint32_t length_ServiceName_1 = 0;
5409         TALLOC_CTX *_mem_save_scmanager_handle_0;
5410         TALLOC_CTX *_mem_save_ServiceName_0;
5411         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5412         if (flags & NDR_IN) {
5413                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5414                         NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);
5415                 }
5416                 _mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5417                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);
5418                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager_handle));
5419                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);
5420                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ServiceName));
5421                 if (_ptr_ServiceName) {
5422                         NDR_PULL_ALLOC(ndr, r->in.ServiceName);
5423                 } else {
5424                         r->in.ServiceName = NULL;
5425                 }
5426                 if (r->in.ServiceName) {
5427                         _mem_save_ServiceName_0 = NDR_PULL_GET_MEM_CTX(ndr);
5428                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ServiceName, 0);
5429                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
5430                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
5431                         size_ServiceName_1 = ndr_get_array_size(ndr, &r->in.ServiceName);
5432                         length_ServiceName_1 = ndr_get_array_length(ndr, &r->in.ServiceName);
5433                         if (length_ServiceName_1 > size_ServiceName_1) {
5434                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_ServiceName_1, length_ServiceName_1);
5435                         }
5436                         NDR_CHECK(ndr_check_string_terminator(ndr, length_ServiceName_1, sizeof(uint16_t)));
5437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, length_ServiceName_1, sizeof(uint16_t), CH_UTF16));
5438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ServiceName_0, 0);
5439                 }
5440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
5441         }
5442         if (flags & NDR_OUT) {
5443                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5444         }
5445         return NDR_ERR_SUCCESS;
5446 }
5447
5448 _PUBLIC_ void ndr_print_svcctl_OpenServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenServiceA *r)
5449 {
5450         ndr_print_struct(ndr, name, "svcctl_OpenServiceA");
5451         if (r == NULL) { ndr_print_null(ndr); return; }
5452         ndr->depth++;
5453         if (flags & NDR_SET_VALUES) {
5454                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5455         }
5456         if (flags & NDR_IN) {
5457                 ndr_print_struct(ndr, "in", "svcctl_OpenServiceA");
5458                 ndr->depth++;
5459                 ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);
5460                 ndr->depth++;
5461                 ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);
5462                 ndr->depth--;
5463                 ndr_print_ptr(ndr, "ServiceName", r->in.ServiceName);
5464                 ndr->depth++;
5465                 if (r->in.ServiceName) {
5466                         ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
5467                 }
5468                 ndr->depth--;
5469                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
5470                 ndr->depth--;
5471         }
5472         if (flags & NDR_OUT) {
5473                 ndr_print_struct(ndr, "out", "svcctl_OpenServiceA");
5474                 ndr->depth++;
5475                 ndr_print_WERROR(ndr, "result", r->out.result);
5476                 ndr->depth--;
5477         }
5478         ndr->depth--;
5479 }
5480
5481 static enum ndr_err_code ndr_push_svcctl_QueryServiceConfigA(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfigA *r)
5482 {
5483         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5484         if (flags & NDR_IN) {
5485                 if (r->in.handle == NULL) {
5486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5487                 }
5488                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
5490         }
5491         if (flags & NDR_OUT) {
5492                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.offered));
5493                 if (r->out.needed == NULL) {
5494                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5495                 }
5496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
5497                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5498         }
5499         return NDR_ERR_SUCCESS;
5500 }
5501
5502 static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfigA(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfigA *r)
5503 {
5504         uint32_t size_query_0 = 0;
5505         TALLOC_CTX *_mem_save_handle_0;
5506         TALLOC_CTX *_mem_save_needed_0;
5507         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5508         if (flags & NDR_IN) {
5509                 ZERO_STRUCT(r->out);
5510
5511                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5512                         NDR_PULL_ALLOC(ndr, r->in.handle);
5513                 }
5514                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5515                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5516                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5517                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
5519                 NDR_PULL_ALLOC(ndr, r->out.needed);
5520                 ZERO_STRUCTP(r->out.needed);
5521         }
5522         if (flags & NDR_OUT) {
5523                 size_query_0 = r->in.offered;
5524                 NDR_PULL_ALLOC_N(ndr, r->out.query, size_query_0);
5525                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.query, size_query_0));
5526                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5527                         NDR_PULL_ALLOC(ndr, r->out.needed);
5528                 }
5529                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
5530                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
5531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
5532                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
5533                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5534         }
5535         return NDR_ERR_SUCCESS;
5536 }
5537
5538 _PUBLIC_ void ndr_print_svcctl_QueryServiceConfigA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfigA *r)
5539 {
5540         ndr_print_struct(ndr, name, "svcctl_QueryServiceConfigA");
5541         if (r == NULL) { ndr_print_null(ndr); return; }
5542         ndr->depth++;
5543         if (flags & NDR_SET_VALUES) {
5544                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5545         }
5546         if (flags & NDR_IN) {
5547                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfigA");
5548                 ndr->depth++;
5549                 ndr_print_ptr(ndr, "handle", r->in.handle);
5550                 ndr->depth++;
5551                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5552                 ndr->depth--;
5553                 ndr_print_uint32(ndr, "offered", r->in.offered);
5554                 ndr->depth--;
5555         }
5556         if (flags & NDR_OUT) {
5557                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfigA");
5558                 ndr->depth++;
5559                 ndr_print_array_uint8(ndr, "query", r->out.query, r->in.offered);
5560                 ndr_print_ptr(ndr, "needed", r->out.needed);
5561                 ndr->depth++;
5562                 ndr_print_uint32(ndr, "needed", *r->out.needed);
5563                 ndr->depth--;
5564                 ndr_print_WERROR(ndr, "result", r->out.result);
5565                 ndr->depth--;
5566         }
5567         ndr->depth--;
5568 }
5569
5570 static enum ndr_err_code ndr_push_svcctl_QueryServiceLockStatusA(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceLockStatusA *r)
5571 {
5572         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5573         if (flags & NDR_IN) {
5574                 if (r->in.handle == NULL) {
5575                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5576                 }
5577                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5578                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
5579         }
5580         if (flags & NDR_OUT) {
5581                 if (r->out.lock_status == NULL) {
5582                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5583                 }
5584                 NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
5585                 if (r->out.needed == NULL) {
5586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5587                 }
5588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
5589                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5590         }
5591         return NDR_ERR_SUCCESS;
5592 }
5593
5594 static enum ndr_err_code ndr_pull_svcctl_QueryServiceLockStatusA(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceLockStatusA *r)
5595 {
5596         TALLOC_CTX *_mem_save_handle_0;
5597         TALLOC_CTX *_mem_save_lock_status_0;
5598         TALLOC_CTX *_mem_save_needed_0;
5599         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5600         if (flags & NDR_IN) {
5601                 ZERO_STRUCT(r->out);
5602
5603                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5604                         NDR_PULL_ALLOC(ndr, r->in.handle);
5605                 }
5606                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5607                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5608                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
5611                 NDR_PULL_ALLOC(ndr, r->out.lock_status);
5612                 ZERO_STRUCTP(r->out.lock_status);
5613                 NDR_PULL_ALLOC(ndr, r->out.needed);
5614                 ZERO_STRUCTP(r->out.needed);
5615         }
5616         if (flags & NDR_OUT) {
5617                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5618                         NDR_PULL_ALLOC(ndr, r->out.lock_status);
5619                 }
5620                 _mem_save_lock_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5621                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lock_status, LIBNDR_FLAG_REF_ALLOC);
5622                 NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
5623                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);
5624                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5625                         NDR_PULL_ALLOC(ndr, r->out.needed);
5626                 }
5627                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
5628                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
5629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
5630                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
5631                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5632         }
5633         return NDR_ERR_SUCCESS;
5634 }
5635
5636 _PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceLockStatusA *r)
5637 {
5638         ndr_print_struct(ndr, name, "svcctl_QueryServiceLockStatusA");
5639         if (r == NULL) { ndr_print_null(ndr); return; }
5640         ndr->depth++;
5641         if (flags & NDR_SET_VALUES) {
5642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5643         }
5644         if (flags & NDR_IN) {
5645                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceLockStatusA");
5646                 ndr->depth++;
5647                 ndr_print_ptr(ndr, "handle", r->in.handle);
5648                 ndr->depth++;
5649                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5650                 ndr->depth--;
5651                 ndr_print_uint32(ndr, "offered", r->in.offered);
5652                 ndr->depth--;
5653         }
5654         if (flags & NDR_OUT) {
5655                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceLockStatusA");
5656                 ndr->depth++;
5657                 ndr_print_ptr(ndr, "lock_status", r->out.lock_status);
5658                 ndr->depth++;
5659                 ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);
5660                 ndr->depth--;
5661                 ndr_print_ptr(ndr, "needed", r->out.needed);
5662                 ndr->depth++;
5663                 ndr_print_uint32(ndr, "needed", *r->out.needed);
5664                 ndr->depth--;
5665                 ndr_print_WERROR(ndr, "result", r->out.result);
5666                 ndr->depth--;
5667         }
5668         ndr->depth--;
5669 }
5670
5671 static enum ndr_err_code ndr_push_svcctl_StartServiceA(struct ndr_push *ndr, int flags, const struct svcctl_StartServiceA *r)
5672 {
5673         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5674         if (flags & NDR_IN) {
5675                 if (r->in.handle == NULL) {
5676                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5677                 }
5678                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));
5680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));
5681                 if (r->in.Arguments) {
5682                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
5683                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5684                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
5685                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Arguments, ndr_charset_length(r->in.Arguments, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5686                 }
5687         }
5688         if (flags & NDR_OUT) {
5689                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5690         }
5691         return NDR_ERR_SUCCESS;
5692 }
5693
5694 static enum ndr_err_code ndr_pull_svcctl_StartServiceA(struct ndr_pull *ndr, int flags, struct svcctl_StartServiceA *r)
5695 {
5696         uint32_t _ptr_Arguments;
5697         uint32_t size_Arguments_1 = 0;
5698         uint32_t length_Arguments_1 = 0;
5699         TALLOC_CTX *_mem_save_handle_0;
5700         TALLOC_CTX *_mem_save_Arguments_0;
5701         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5702         if (flags & NDR_IN) {
5703                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5704                         NDR_PULL_ALLOC(ndr, r->in.handle);
5705                 }
5706                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5707                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5708                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5709                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.NumArgs));
5711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Arguments));
5712                 if (_ptr_Arguments) {
5713                         NDR_PULL_ALLOC(ndr, r->in.Arguments);
5714                 } else {
5715                         r->in.Arguments = NULL;
5716                 }
5717                 if (r->in.Arguments) {
5718                         _mem_save_Arguments_0 = NDR_PULL_GET_MEM_CTX(ndr);
5719                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
5720                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Arguments));
5721                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Arguments));
5722                         size_Arguments_1 = ndr_get_array_size(ndr, &r->in.Arguments);
5723                         length_Arguments_1 = ndr_get_array_length(ndr, &r->in.Arguments);
5724                         if (length_Arguments_1 > size_Arguments_1) {
5725                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_Arguments_1, length_Arguments_1);
5726                         }
5727                         NDR_CHECK(ndr_check_string_terminator(ndr, length_Arguments_1, sizeof(uint16_t)));
5728                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Arguments, length_Arguments_1, sizeof(uint16_t), CH_UTF16));
5729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_0, 0);
5730                 }
5731         }
5732         if (flags & NDR_OUT) {
5733                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5734         }
5735         return NDR_ERR_SUCCESS;
5736 }
5737
5738 _PUBLIC_ void ndr_print_svcctl_StartServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_StartServiceA *r)
5739 {
5740         ndr_print_struct(ndr, name, "svcctl_StartServiceA");
5741         if (r == NULL) { ndr_print_null(ndr); return; }
5742         ndr->depth++;
5743         if (flags & NDR_SET_VALUES) {
5744                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5745         }
5746         if (flags & NDR_IN) {
5747                 ndr_print_struct(ndr, "in", "svcctl_StartServiceA");
5748                 ndr->depth++;
5749                 ndr_print_ptr(ndr, "handle", r->in.handle);
5750                 ndr->depth++;
5751                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5752                 ndr->depth--;
5753                 ndr_print_uint32(ndr, "NumArgs", r->in.NumArgs);
5754                 ndr_print_ptr(ndr, "Arguments", r->in.Arguments);
5755                 ndr->depth++;
5756                 if (r->in.Arguments) {
5757                         ndr_print_string(ndr, "Arguments", r->in.Arguments);
5758                 }
5759                 ndr->depth--;
5760                 ndr->depth--;
5761         }
5762         if (flags & NDR_OUT) {
5763                 ndr_print_struct(ndr, "out", "svcctl_StartServiceA");
5764                 ndr->depth++;
5765                 ndr_print_WERROR(ndr, "result", r->out.result);
5766                 ndr->depth--;
5767         }
5768         ndr->depth--;
5769 }
5770
5771 static enum ndr_err_code ndr_push_svcctl_GetServiceDisplayNameA(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceDisplayNameA *r)
5772 {
5773         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5774         if (flags & NDR_IN) {
5775                 if (r->in.handle == NULL) {
5776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5777                 }
5778                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
5780                 if (r->in.service_name) {
5781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
5782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
5784                         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));
5785                 }
5786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
5787                 if (r->in.display_name_length) {
5788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
5789                 }
5790         }
5791         if (flags & NDR_OUT) {
5792                 if (r->out.display_name == NULL) {
5793                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5794                 }
5795                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.display_name));
5796                 if (*r->out.display_name) {
5797                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
5798                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5799                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
5800                         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));
5801                 }
5802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
5803                 if (r->out.display_name_length) {
5804                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
5805                 }
5806                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5807         }
5808         return NDR_ERR_SUCCESS;
5809 }
5810
5811 static enum ndr_err_code ndr_pull_svcctl_GetServiceDisplayNameA(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceDisplayNameA *r)
5812 {
5813         uint32_t _ptr_service_name;
5814         uint32_t size_service_name_1 = 0;
5815         uint32_t length_service_name_1 = 0;
5816         uint32_t _ptr_display_name;
5817         uint32_t size_display_name_2 = 0;
5818         uint32_t length_display_name_2 = 0;
5819         uint32_t _ptr_display_name_length;
5820         TALLOC_CTX *_mem_save_handle_0;
5821         TALLOC_CTX *_mem_save_service_name_0;
5822         TALLOC_CTX *_mem_save_display_name_0;
5823         TALLOC_CTX *_mem_save_display_name_1;
5824         TALLOC_CTX *_mem_save_display_name_length_0;
5825         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
5826         if (flags & NDR_IN) {
5827                 ZERO_STRUCT(r->out);
5828
5829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5830                         NDR_PULL_ALLOC(ndr, r->in.handle);
5831                 }
5832                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5833                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
5834                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
5836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
5837                 if (_ptr_service_name) {
5838                         NDR_PULL_ALLOC(ndr, r->in.service_name);
5839                 } else {
5840                         r->in.service_name = NULL;
5841                 }
5842                 if (r->in.service_name) {
5843                         _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5844                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
5845                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
5846                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
5847                         size_service_name_1 = ndr_get_array_size(ndr, &r->in.service_name);
5848                         length_service_name_1 = ndr_get_array_length(ndr, &r->in.service_name);
5849                         if (length_service_name_1 > size_service_name_1) {
5850                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_service_name_1, length_service_name_1);
5851                         }
5852                         NDR_CHECK(ndr_check_string_terminator(ndr, length_service_name_1, sizeof(uint16_t)));
5853                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, length_service_name_1, sizeof(uint16_t), CH_UTF16));
5854                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
5855                 }
5856                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
5857                 if (_ptr_display_name_length) {
5858                         NDR_PULL_ALLOC(ndr, r->in.display_name_length);
5859                 } else {
5860                         r->in.display_name_length = NULL;
5861                 }
5862                 if (r->in.display_name_length) {
5863                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
5864                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
5865                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
5866                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
5867                 }
5868                 NDR_PULL_ALLOC(ndr, r->out.display_name);
5869                 ZERO_STRUCTP(r->out.display_name);
5870         }
5871         if (flags & NDR_OUT) {
5872                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5873                         NDR_PULL_ALLOC(ndr, r->out.display_name);
5874                 }
5875                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5876                 NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name, LIBNDR_FLAG_REF_ALLOC);
5877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
5878                 if (_ptr_display_name) {
5879                         NDR_PULL_ALLOC(ndr, *r->out.display_name);
5880                 } else {
5881                         *r->out.display_name = NULL;
5882                 }
5883                 if (*r->out.display_name) {
5884                         _mem_save_display_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
5885                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.display_name, 0);
5886                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.display_name));
5887                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.display_name));
5888                         size_display_name_2 = ndr_get_array_size(ndr, r->out.display_name);
5889                         length_display_name_2 = ndr_get_array_length(ndr, r->out.display_name);
5890                         if (length_display_name_2 > size_display_name_2) {
5891                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_display_name_2, length_display_name_2);
5892                         }
5893                         NDR_CHECK(ndr_check_string_terminator(ndr, length_display_name_2, sizeof(uint16_t)));
5894                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.display_name, length_display_name_2, sizeof(uint16_t), CH_UTF16));
5895                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_1, 0);
5896                 }
5897                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, LIBNDR_FLAG_REF_ALLOC);
5898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
5899                 if (_ptr_display_name_length) {
5900                         NDR_PULL_ALLOC(ndr, r->out.display_name_length);
5901                 } else {
5902                         r->out.display_name_length = NULL;
5903                 }
5904                 if (r->out.display_name_length) {
5905                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
5906                         NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
5907                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
5908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
5909                 }
5910                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5911         }
5912         return NDR_ERR_SUCCESS;
5913 }
5914
5915 _PUBLIC_ void ndr_print_svcctl_GetServiceDisplayNameA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceDisplayNameA *r)
5916 {
5917         ndr_print_struct(ndr, name, "svcctl_GetServiceDisplayNameA");
5918         if (r == NULL) { ndr_print_null(ndr); return; }
5919         ndr->depth++;
5920         if (flags & NDR_SET_VALUES) {
5921                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5922         }
5923         if (flags & NDR_IN) {
5924                 ndr_print_struct(ndr, "in", "svcctl_GetServiceDisplayNameA");
5925                 ndr->depth++;
5926                 ndr_print_ptr(ndr, "handle", r->in.handle);
5927                 ndr->depth++;
5928                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
5929                 ndr->depth--;
5930                 ndr_print_ptr(ndr, "service_name", r->in.service_name);
5931                 ndr->depth++;
5932                 if (r->in.service_name) {
5933                         ndr_print_string(ndr, "service_name", r->in.service_name);
5934                 }
5935                 ndr->depth--;
5936                 ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
5937                 ndr->depth++;
5938                 if (r->in.display_name_length) {
5939                         ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
5940                 }
5941                 ndr->depth--;
5942                 ndr->depth--;
5943         }
5944         if (flags & NDR_OUT) {
5945                 ndr_print_struct(ndr, "out", "svcctl_GetServiceDisplayNameA");
5946                 ndr->depth++;
5947                 ndr_print_ptr(ndr, "display_name", r->out.display_name);
5948                 ndr->depth++;
5949                 ndr_print_ptr(ndr, "display_name", *r->out.display_name);
5950                 ndr->depth++;
5951                 if (*r->out.display_name) {
5952                         ndr_print_string(ndr, "display_name", *r->out.display_name);
5953                 }
5954                 ndr->depth--;
5955                 ndr->depth--;
5956                 ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
5957                 ndr->depth++;
5958                 if (r->out.display_name_length) {
5959                         ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
5960                 }
5961                 ndr->depth--;
5962                 ndr_print_WERROR(ndr, "result", r->out.result);
5963                 ndr->depth--;
5964         }
5965         ndr->depth--;
5966 }
5967
5968 static enum ndr_err_code ndr_push_svcctl_GetServiceKeyNameA(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceKeyNameA *r)
5969 {
5970         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
5971         if (flags & NDR_IN) {
5972                 if (r->in.handle == NULL) {
5973                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5974                 }
5975                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
5976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
5977                 if (r->in.service_name) {
5978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
5979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5980                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
5981                         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));
5982                 }
5983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
5984                 if (r->in.display_name_length) {
5985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
5986                 }
5987         }
5988         if (flags & NDR_OUT) {
5989                 if (r->out.key_name == NULL) {
5990                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
5991                 }
5992                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_name));
5993                 if (*r->out.key_name) {
5994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
5995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
5997                         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));
5998                 }
5999                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
6000                 if (r->out.display_name_length) {
6001                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
6002                 }
6003                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6004         }
6005         return NDR_ERR_SUCCESS;
6006 }
6007
6008 static enum ndr_err_code ndr_pull_svcctl_GetServiceKeyNameA(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceKeyNameA *r)
6009 {
6010         uint32_t _ptr_service_name;
6011         uint32_t size_service_name_1 = 0;
6012         uint32_t length_service_name_1 = 0;
6013         uint32_t _ptr_key_name;
6014         uint32_t size_key_name_2 = 0;
6015         uint32_t length_key_name_2 = 0;
6016         uint32_t _ptr_display_name_length;
6017         TALLOC_CTX *_mem_save_handle_0;
6018         TALLOC_CTX *_mem_save_service_name_0;
6019         TALLOC_CTX *_mem_save_key_name_0;
6020         TALLOC_CTX *_mem_save_key_name_1;
6021         TALLOC_CTX *_mem_save_display_name_length_0;
6022         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6023         if (flags & NDR_IN) {
6024                 ZERO_STRUCT(r->out);
6025
6026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6027                         NDR_PULL_ALLOC(ndr, r->in.handle);
6028                 }
6029                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6030                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6031                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
6034                 if (_ptr_service_name) {
6035                         NDR_PULL_ALLOC(ndr, r->in.service_name);
6036                 } else {
6037                         r->in.service_name = NULL;
6038                 }
6039                 if (r->in.service_name) {
6040                         _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6041                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
6042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
6043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
6044                         size_service_name_1 = ndr_get_array_size(ndr, &r->in.service_name);
6045                         length_service_name_1 = ndr_get_array_length(ndr, &r->in.service_name);
6046                         if (length_service_name_1 > size_service_name_1) {
6047                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_service_name_1, length_service_name_1);
6048                         }
6049                         NDR_CHECK(ndr_check_string_terminator(ndr, length_service_name_1, sizeof(uint16_t)));
6050                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, length_service_name_1, sizeof(uint16_t), CH_UTF16));
6051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
6052                 }
6053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
6054                 if (_ptr_display_name_length) {
6055                         NDR_PULL_ALLOC(ndr, r->in.display_name_length);
6056                 } else {
6057                         r->in.display_name_length = NULL;
6058                 }
6059                 if (r->in.display_name_length) {
6060                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
6061                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
6062                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
6063                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
6064                 }
6065                 NDR_PULL_ALLOC(ndr, r->out.key_name);
6066                 ZERO_STRUCTP(r->out.key_name);
6067         }
6068         if (flags & NDR_OUT) {
6069                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6070                         NDR_PULL_ALLOC(ndr, r->out.key_name);
6071                 }
6072                 _mem_save_key_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6073                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_name, LIBNDR_FLAG_REF_ALLOC);
6074                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_name));
6075                 if (_ptr_key_name) {
6076                         NDR_PULL_ALLOC(ndr, *r->out.key_name);
6077                 } else {
6078                         *r->out.key_name = NULL;
6079                 }
6080                 if (*r->out.key_name) {
6081                         _mem_save_key_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
6082                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_name, 0);
6083                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.key_name));
6084                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.key_name));
6085                         size_key_name_2 = ndr_get_array_size(ndr, r->out.key_name);
6086                         length_key_name_2 = ndr_get_array_length(ndr, r->out.key_name);
6087                         if (length_key_name_2 > size_key_name_2) {
6088                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_key_name_2, length_key_name_2);
6089                         }
6090                         NDR_CHECK(ndr_check_string_terminator(ndr, length_key_name_2, sizeof(uint16_t)));
6091                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.key_name, length_key_name_2, sizeof(uint16_t), CH_UTF16));
6092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_1, 0);
6093                 }
6094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_0, LIBNDR_FLAG_REF_ALLOC);
6095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
6096                 if (_ptr_display_name_length) {
6097                         NDR_PULL_ALLOC(ndr, r->out.display_name_length);
6098                 } else {
6099                         r->out.display_name_length = NULL;
6100                 }
6101                 if (r->out.display_name_length) {
6102                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
6103                         NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
6104                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
6105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
6106                 }
6107                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6108         }
6109         return NDR_ERR_SUCCESS;
6110 }
6111
6112 _PUBLIC_ void ndr_print_svcctl_GetServiceKeyNameA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceKeyNameA *r)
6113 {
6114         ndr_print_struct(ndr, name, "svcctl_GetServiceKeyNameA");
6115         if (r == NULL) { ndr_print_null(ndr); return; }
6116         ndr->depth++;
6117         if (flags & NDR_SET_VALUES) {
6118                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6119         }
6120         if (flags & NDR_IN) {
6121                 ndr_print_struct(ndr, "in", "svcctl_GetServiceKeyNameA");
6122                 ndr->depth++;
6123                 ndr_print_ptr(ndr, "handle", r->in.handle);
6124                 ndr->depth++;
6125                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6126                 ndr->depth--;
6127                 ndr_print_ptr(ndr, "service_name", r->in.service_name);
6128                 ndr->depth++;
6129                 if (r->in.service_name) {
6130                         ndr_print_string(ndr, "service_name", r->in.service_name);
6131                 }
6132                 ndr->depth--;
6133                 ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
6134                 ndr->depth++;
6135                 if (r->in.display_name_length) {
6136                         ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
6137                 }
6138                 ndr->depth--;
6139                 ndr->depth--;
6140         }
6141         if (flags & NDR_OUT) {
6142                 ndr_print_struct(ndr, "out", "svcctl_GetServiceKeyNameA");
6143                 ndr->depth++;
6144                 ndr_print_ptr(ndr, "key_name", r->out.key_name);
6145                 ndr->depth++;
6146                 ndr_print_ptr(ndr, "key_name", *r->out.key_name);
6147                 ndr->depth++;
6148                 if (*r->out.key_name) {
6149                         ndr_print_string(ndr, "key_name", *r->out.key_name);
6150                 }
6151                 ndr->depth--;
6152                 ndr->depth--;
6153                 ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
6154                 ndr->depth++;
6155                 if (r->out.display_name_length) {
6156                         ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
6157                 }
6158                 ndr->depth--;
6159                 ndr_print_WERROR(ndr, "result", r->out.result);
6160                 ndr->depth--;
6161         }
6162         ndr->depth--;
6163 }
6164
6165 static enum ndr_err_code ndr_push_svcctl_GetCurrentGroupeStateW(struct ndr_push *ndr, int flags, const struct svcctl_GetCurrentGroupeStateW *r)
6166 {
6167         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6168         if (flags & NDR_IN) {
6169         }
6170         if (flags & NDR_OUT) {
6171                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6172         }
6173         return NDR_ERR_SUCCESS;
6174 }
6175
6176 static enum ndr_err_code ndr_pull_svcctl_GetCurrentGroupeStateW(struct ndr_pull *ndr, int flags, struct svcctl_GetCurrentGroupeStateW *r)
6177 {
6178         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6179         if (flags & NDR_IN) {
6180         }
6181         if (flags & NDR_OUT) {
6182                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6183         }
6184         return NDR_ERR_SUCCESS;
6185 }
6186
6187 _PUBLIC_ void ndr_print_svcctl_GetCurrentGroupeStateW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetCurrentGroupeStateW *r)
6188 {
6189         ndr_print_struct(ndr, name, "svcctl_GetCurrentGroupeStateW");
6190         if (r == NULL) { ndr_print_null(ndr); return; }
6191         ndr->depth++;
6192         if (flags & NDR_SET_VALUES) {
6193                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6194         }
6195         if (flags & NDR_IN) {
6196                 ndr_print_struct(ndr, "in", "svcctl_GetCurrentGroupeStateW");
6197                 ndr->depth++;
6198                 ndr->depth--;
6199         }
6200         if (flags & NDR_OUT) {
6201                 ndr_print_struct(ndr, "out", "svcctl_GetCurrentGroupeStateW");
6202                 ndr->depth++;
6203                 ndr_print_WERROR(ndr, "result", r->out.result);
6204                 ndr->depth--;
6205         }
6206         ndr->depth--;
6207 }
6208
6209 static enum ndr_err_code ndr_push_svcctl_EnumServiceGroupW(struct ndr_push *ndr, int flags, const struct svcctl_EnumServiceGroupW *r)
6210 {
6211         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6212         if (flags & NDR_IN) {
6213         }
6214         if (flags & NDR_OUT) {
6215                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6216         }
6217         return NDR_ERR_SUCCESS;
6218 }
6219
6220 static enum ndr_err_code ndr_pull_svcctl_EnumServiceGroupW(struct ndr_pull *ndr, int flags, struct svcctl_EnumServiceGroupW *r)
6221 {
6222         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6223         if (flags & NDR_IN) {
6224         }
6225         if (flags & NDR_OUT) {
6226                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6227         }
6228         return NDR_ERR_SUCCESS;
6229 }
6230
6231 _PUBLIC_ void ndr_print_svcctl_EnumServiceGroupW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServiceGroupW *r)
6232 {
6233         ndr_print_struct(ndr, name, "svcctl_EnumServiceGroupW");
6234         if (r == NULL) { ndr_print_null(ndr); return; }
6235         ndr->depth++;
6236         if (flags & NDR_SET_VALUES) {
6237                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6238         }
6239         if (flags & NDR_IN) {
6240                 ndr_print_struct(ndr, "in", "svcctl_EnumServiceGroupW");
6241                 ndr->depth++;
6242                 ndr->depth--;
6243         }
6244         if (flags & NDR_OUT) {
6245                 ndr_print_struct(ndr, "out", "svcctl_EnumServiceGroupW");
6246                 ndr->depth++;
6247                 ndr_print_WERROR(ndr, "result", r->out.result);
6248                 ndr->depth--;
6249         }
6250         ndr->depth--;
6251 }
6252
6253 static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfig2A(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfig2A *r)
6254 {
6255         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6256         if (flags & NDR_IN) {
6257                 if (r->in.handle == NULL) {
6258                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6259                 }
6260                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
6262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
6263                 if (r->in.info) {
6264                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->in.info));
6265                 }
6266         }
6267         if (flags & NDR_OUT) {
6268                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6269         }
6270         return NDR_ERR_SUCCESS;
6271 }
6272
6273 static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfig2A(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfig2A *r)
6274 {
6275         uint32_t _ptr_info;
6276         TALLOC_CTX *_mem_save_handle_0;
6277         TALLOC_CTX *_mem_save_info_0;
6278         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6279         if (flags & NDR_IN) {
6280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6281                         NDR_PULL_ALLOC(ndr, r->in.handle);
6282                 }
6283                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6284                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6285                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6287                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
6288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6289                 if (_ptr_info) {
6290                         NDR_PULL_ALLOC(ndr, r->in.info);
6291                 } else {
6292                         r->in.info = NULL;
6293                 }
6294                 if (r->in.info) {
6295                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6296                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
6297                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->in.info));
6298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
6299                 }
6300         }
6301         if (flags & NDR_OUT) {
6302                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6303         }
6304         return NDR_ERR_SUCCESS;
6305 }
6306
6307 _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfig2A(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfig2A *r)
6308 {
6309         ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfig2A");
6310         if (r == NULL) { ndr_print_null(ndr); return; }
6311         ndr->depth++;
6312         if (flags & NDR_SET_VALUES) {
6313                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6314         }
6315         if (flags & NDR_IN) {
6316                 ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfig2A");
6317                 ndr->depth++;
6318                 ndr_print_ptr(ndr, "handle", r->in.handle);
6319                 ndr->depth++;
6320                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6321                 ndr->depth--;
6322                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
6323                 ndr_print_ptr(ndr, "info", r->in.info);
6324                 ndr->depth++;
6325                 if (r->in.info) {
6326                         ndr_print_uint8(ndr, "info", *r->in.info);
6327                 }
6328                 ndr->depth--;
6329                 ndr->depth--;
6330         }
6331         if (flags & NDR_OUT) {
6332                 ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfig2A");
6333                 ndr->depth++;
6334                 ndr_print_WERROR(ndr, "result", r->out.result);
6335                 ndr->depth--;
6336         }
6337         ndr->depth--;
6338 }
6339
6340 static enum ndr_err_code ndr_push_svcctl_ChangeServiceConfig2W(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfig2W *r)
6341 {
6342         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6343         if (flags & NDR_IN) {
6344                 if (r->in.handle == NULL) {
6345                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6346                 }
6347                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
6349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
6350                 if (r->in.info) {
6351                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->in.info));
6352                 }
6353         }
6354         if (flags & NDR_OUT) {
6355                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6356         }
6357         return NDR_ERR_SUCCESS;
6358 }
6359
6360 static enum ndr_err_code ndr_pull_svcctl_ChangeServiceConfig2W(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfig2W *r)
6361 {
6362         uint32_t _ptr_info;
6363         TALLOC_CTX *_mem_save_handle_0;
6364         TALLOC_CTX *_mem_save_info_0;
6365         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6366         if (flags & NDR_IN) {
6367                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6368                         NDR_PULL_ALLOC(ndr, r->in.handle);
6369                 }
6370                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6371                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6372                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
6375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
6376                 if (_ptr_info) {
6377                         NDR_PULL_ALLOC(ndr, r->in.info);
6378                 } else {
6379                         r->in.info = NULL;
6380                 }
6381                 if (r->in.info) {
6382                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
6383                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
6384                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->in.info));
6385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
6386                 }
6387         }
6388         if (flags & NDR_OUT) {
6389                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6390         }
6391         return NDR_ERR_SUCCESS;
6392 }
6393
6394 _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfig2W(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfig2W *r)
6395 {
6396         ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfig2W");
6397         if (r == NULL) { ndr_print_null(ndr); return; }
6398         ndr->depth++;
6399         if (flags & NDR_SET_VALUES) {
6400                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6401         }
6402         if (flags & NDR_IN) {
6403                 ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfig2W");
6404                 ndr->depth++;
6405                 ndr_print_ptr(ndr, "handle", r->in.handle);
6406                 ndr->depth++;
6407                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6408                 ndr->depth--;
6409                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
6410                 ndr_print_ptr(ndr, "info", r->in.info);
6411                 ndr->depth++;
6412                 if (r->in.info) {
6413                         ndr_print_uint8(ndr, "info", *r->in.info);
6414                 }
6415                 ndr->depth--;
6416                 ndr->depth--;
6417         }
6418         if (flags & NDR_OUT) {
6419                 ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfig2W");
6420                 ndr->depth++;
6421                 ndr_print_WERROR(ndr, "result", r->out.result);
6422                 ndr->depth--;
6423         }
6424         ndr->depth--;
6425 }
6426
6427 static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2A(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfig2A *r)
6428 {
6429         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6430         if (flags & NDR_IN) {
6431                 if (r->in.handle == NULL) {
6432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6433                 }
6434                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6435                 NDR_CHECK(ndr_push_svcctl_ConfigLevel(ndr, NDR_SCALARS, r->in.info_level));
6436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6437         }
6438         if (flags & NDR_OUT) {
6439                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
6440                 if (r->out.needed == NULL) {
6441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6442                 }
6443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6444                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6445         }
6446         return NDR_ERR_SUCCESS;
6447 }
6448
6449 static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2A(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2A *r)
6450 {
6451         uint32_t size_buffer_0 = 0;
6452         TALLOC_CTX *_mem_save_handle_0;
6453         TALLOC_CTX *_mem_save_needed_0;
6454         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6455         if (flags & NDR_IN) {
6456                 ZERO_STRUCT(r->out);
6457
6458                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6459                         NDR_PULL_ALLOC(ndr, r->in.handle);
6460                 }
6461                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6462                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6463                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6465                 NDR_CHECK(ndr_pull_svcctl_ConfigLevel(ndr, NDR_SCALARS, &r->in.info_level));
6466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
6467                 NDR_PULL_ALLOC(ndr, r->out.needed);
6468                 ZERO_STRUCTP(r->out.needed);
6469         }
6470         if (flags & NDR_OUT) {
6471                 size_buffer_0 = r->in.offered;
6472                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, size_buffer_0);
6473                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, size_buffer_0));
6474                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6475                         NDR_PULL_ALLOC(ndr, r->out.needed);
6476                 }
6477                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
6478                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
6479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
6480                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
6481                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6482         }
6483         return NDR_ERR_SUCCESS;
6484 }
6485
6486 _PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2A(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfig2A *r)
6487 {
6488         ndr_print_struct(ndr, name, "svcctl_QueryServiceConfig2A");
6489         if (r == NULL) { ndr_print_null(ndr); return; }
6490         ndr->depth++;
6491         if (flags & NDR_SET_VALUES) {
6492                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6493         }
6494         if (flags & NDR_IN) {
6495                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfig2A");
6496                 ndr->depth++;
6497                 ndr_print_ptr(ndr, "handle", r->in.handle);
6498                 ndr->depth++;
6499                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6500                 ndr->depth--;
6501                 ndr_print_svcctl_ConfigLevel(ndr, "info_level", r->in.info_level);
6502                 ndr_print_uint32(ndr, "offered", r->in.offered);
6503                 ndr->depth--;
6504         }
6505         if (flags & NDR_OUT) {
6506                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfig2A");
6507                 ndr->depth++;
6508                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
6509                 ndr_print_ptr(ndr, "needed", r->out.needed);
6510                 ndr->depth++;
6511                 ndr_print_uint32(ndr, "needed", *r->out.needed);
6512                 ndr->depth--;
6513                 ndr_print_WERROR(ndr, "result", r->out.result);
6514                 ndr->depth--;
6515         }
6516         ndr->depth--;
6517 }
6518
6519 static enum ndr_err_code ndr_push_svcctl_QueryServiceConfig2W(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfig2W *r)
6520 {
6521         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6522         if (flags & NDR_IN) {
6523                 if (r->in.handle == NULL) {
6524                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6525                 }
6526                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6527                 NDR_CHECK(ndr_push_svcctl_ConfigLevel(ndr, NDR_SCALARS, r->in.info_level));
6528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6529         }
6530         if (flags & NDR_OUT) {
6531                 if (r->out.buffer == NULL) {
6532                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6533                 }
6534                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
6535                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
6536                 if (r->out.needed == NULL) {
6537                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6538                 }
6539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6540                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6541         }
6542         return NDR_ERR_SUCCESS;
6543 }
6544
6545 static enum ndr_err_code ndr_pull_svcctl_QueryServiceConfig2W(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2W *r)
6546 {
6547         uint32_t size_buffer_1 = 0;
6548         TALLOC_CTX *_mem_save_handle_0;
6549         TALLOC_CTX *_mem_save_needed_0;
6550         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6551         if (flags & NDR_IN) {
6552                 ZERO_STRUCT(r->out);
6553
6554                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6555                         NDR_PULL_ALLOC(ndr, r->in.handle);
6556                 }
6557                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6558                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6559                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6561                 NDR_CHECK(ndr_pull_svcctl_ConfigLevel(ndr, NDR_SCALARS, &r->in.info_level));
6562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
6563                 if (r->in.offered > 8192) {
6564                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6565                 }
6566                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
6567                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
6568                 NDR_PULL_ALLOC(ndr, r->out.needed);
6569                 ZERO_STRUCTP(r->out.needed);
6570         }
6571         if (flags & NDR_OUT) {
6572                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
6573                 size_buffer_1 = ndr_get_array_size(ndr, &r->out.buffer);
6574                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6575                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, size_buffer_1);
6576                 }
6577                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, size_buffer_1));
6578                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6579                         NDR_PULL_ALLOC(ndr, r->out.needed);
6580                 }
6581                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
6582                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
6583                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
6584                 if (*r->out.needed > 8192) {
6585                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6586                 }
6587                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
6588                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6589                 if (r->out.buffer) {
6590                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
6591                 }
6592         }
6593         return NDR_ERR_SUCCESS;
6594 }
6595
6596 _PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2W(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfig2W *r)
6597 {
6598         ndr_print_struct(ndr, name, "svcctl_QueryServiceConfig2W");
6599         if (r == NULL) { ndr_print_null(ndr); return; }
6600         ndr->depth++;
6601         if (flags & NDR_SET_VALUES) {
6602                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6603         }
6604         if (flags & NDR_IN) {
6605                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfig2W");
6606                 ndr->depth++;
6607                 ndr_print_ptr(ndr, "handle", r->in.handle);
6608                 ndr->depth++;
6609                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6610                 ndr->depth--;
6611                 ndr_print_svcctl_ConfigLevel(ndr, "info_level", r->in.info_level);
6612                 ndr_print_uint32(ndr, "offered", r->in.offered);
6613                 ndr->depth--;
6614         }
6615         if (flags & NDR_OUT) {
6616                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfig2W");
6617                 ndr->depth++;
6618                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
6619                 ndr->depth++;
6620                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
6621                 ndr->depth--;
6622                 ndr_print_ptr(ndr, "needed", r->out.needed);
6623                 ndr->depth++;
6624                 ndr_print_uint32(ndr, "needed", *r->out.needed);
6625                 ndr->depth--;
6626                 ndr_print_WERROR(ndr, "result", r->out.result);
6627                 ndr->depth--;
6628         }
6629         ndr->depth--;
6630 }
6631
6632 static enum ndr_err_code ndr_push_svcctl_QueryServiceStatusEx(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceStatusEx *r)
6633 {
6634         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6635         if (flags & NDR_IN) {
6636                 if (r->in.handle == NULL) {
6637                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6638                 }
6639                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6640                 NDR_CHECK(ndr_push_svcctl_StatusLevel(ndr, NDR_SCALARS, r->in.info_level));
6641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6642         }
6643         if (flags & NDR_OUT) {
6644                 if (r->out.buffer == NULL) {
6645                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6646                 }
6647                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
6648                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
6649                 if (r->out.needed == NULL) {
6650                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6651                 }
6652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6653                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6654         }
6655         return NDR_ERR_SUCCESS;
6656 }
6657
6658 static enum ndr_err_code ndr_pull_svcctl_QueryServiceStatusEx(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceStatusEx *r)
6659 {
6660         uint32_t size_buffer_1 = 0;
6661         TALLOC_CTX *_mem_save_handle_0;
6662         TALLOC_CTX *_mem_save_needed_0;
6663         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6664         if (flags & NDR_IN) {
6665                 ZERO_STRUCT(r->out);
6666
6667                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6668                         NDR_PULL_ALLOC(ndr, r->in.handle);
6669                 }
6670                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6671                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
6672                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
6673                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
6674                 NDR_CHECK(ndr_pull_svcctl_StatusLevel(ndr, NDR_SCALARS, &r->in.info_level));
6675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
6676                 if (r->in.offered > 8192) {
6677                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6678                 }
6679                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
6680                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
6681                 NDR_PULL_ALLOC(ndr, r->out.needed);
6682                 ZERO_STRUCTP(r->out.needed);
6683         }
6684         if (flags & NDR_OUT) {
6685                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
6686                 size_buffer_1 = ndr_get_array_size(ndr, &r->out.buffer);
6687                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6688                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, size_buffer_1);
6689                 }
6690                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, size_buffer_1));
6691                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6692                         NDR_PULL_ALLOC(ndr, r->out.needed);
6693                 }
6694                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
6695                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
6696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
6697                 if (*r->out.needed > 8192) {
6698                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6699                 }
6700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
6701                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6702                 if (r->out.buffer) {
6703                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
6704                 }
6705         }
6706         return NDR_ERR_SUCCESS;
6707 }
6708
6709 _PUBLIC_ void ndr_print_svcctl_QueryServiceStatusEx(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceStatusEx *r)
6710 {
6711         ndr_print_struct(ndr, name, "svcctl_QueryServiceStatusEx");
6712         if (r == NULL) { ndr_print_null(ndr); return; }
6713         ndr->depth++;
6714         if (flags & NDR_SET_VALUES) {
6715                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6716         }
6717         if (flags & NDR_IN) {
6718                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceStatusEx");
6719                 ndr->depth++;
6720                 ndr_print_ptr(ndr, "handle", r->in.handle);
6721                 ndr->depth++;
6722                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
6723                 ndr->depth--;
6724                 ndr_print_svcctl_StatusLevel(ndr, "info_level", r->in.info_level);
6725                 ndr_print_uint32(ndr, "offered", r->in.offered);
6726                 ndr->depth--;
6727         }
6728         if (flags & NDR_OUT) {
6729                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceStatusEx");
6730                 ndr->depth++;
6731                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
6732                 ndr->depth++;
6733                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
6734                 ndr->depth--;
6735                 ndr_print_ptr(ndr, "needed", r->out.needed);
6736                 ndr->depth++;
6737                 ndr_print_uint32(ndr, "needed", *r->out.needed);
6738                 ndr->depth--;
6739                 ndr_print_WERROR(ndr, "result", r->out.result);
6740                 ndr->depth--;
6741         }
6742         ndr->depth--;
6743 }
6744
6745 static enum ndr_err_code ndr_push_EnumServicesStatusExA(struct ndr_push *ndr, int flags, const struct EnumServicesStatusExA *r)
6746 {
6747         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6748         if (flags & NDR_IN) {
6749                 if (r->in.scmanager == NULL) {
6750                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6751                 }
6752                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
6753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
6754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
6755                 NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
6756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6758                 if (r->in.resume_handle) {
6759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6760                 }
6761         }
6762         if (flags & NDR_OUT) {
6763                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));
6764                 if (r->out.needed == NULL) {
6765                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6766                 }
6767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6768                 if (r->out.service_returned == NULL) {
6769                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6770                 }
6771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.service_returned));
6772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6773                 if (r->out.resume_handle) {
6774                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
6775                 }
6776                 if (r->out.group_name == NULL) {
6777                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6778                 }
6779                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.group_name));
6780                 if (*r->out.group_name) {
6781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
6782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
6784                         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));
6785                 }
6786                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
6787         }
6788         return NDR_ERR_SUCCESS;
6789 }
6790
6791 static enum ndr_err_code ndr_pull_EnumServicesStatusExA(struct ndr_pull *ndr, int flags, struct EnumServicesStatusExA *r)
6792 {
6793         uint32_t size_services_0 = 0;
6794         uint32_t _ptr_resume_handle;
6795         uint32_t _ptr_group_name;
6796         uint32_t size_group_name_2 = 0;
6797         uint32_t length_group_name_2 = 0;
6798         TALLOC_CTX *_mem_save_scmanager_0;
6799         TALLOC_CTX *_mem_save_needed_0;
6800         TALLOC_CTX *_mem_save_service_returned_0;
6801         TALLOC_CTX *_mem_save_resume_handle_0;
6802         TALLOC_CTX *_mem_save_group_name_0;
6803         TALLOC_CTX *_mem_save_group_name_1;
6804         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
6805         if (flags & NDR_IN) {
6806                 ZERO_STRUCT(r->out);
6807
6808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6809                         NDR_PULL_ALLOC(ndr, r->in.scmanager);
6810                 }
6811                 _mem_save_scmanager_0 = NDR_PULL_GET_MEM_CTX(ndr);
6812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager, LIBNDR_FLAG_REF_ALLOC);
6813                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
6814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);
6815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
6816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
6817                 NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
6818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
6819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6820                 if (_ptr_resume_handle) {
6821                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
6822                 } else {
6823                         r->in.resume_handle = NULL;
6824                 }
6825                 if (r->in.resume_handle) {
6826                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6827                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
6828                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
6829                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6830                 }
6831                 NDR_PULL_ALLOC(ndr, r->out.needed);
6832                 ZERO_STRUCTP(r->out.needed);
6833                 NDR_PULL_ALLOC(ndr, r->out.service_returned);
6834                 ZERO_STRUCTP(r->out.service_returned);
6835                 NDR_PULL_ALLOC(ndr, r->out.group_name);
6836                 ZERO_STRUCTP(r->out.group_name);
6837         }
6838         if (flags & NDR_OUT) {
6839                 size_services_0 = r->in.offered;
6840                 NDR_PULL_ALLOC_N(ndr, r->out.services, size_services_0);
6841                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, size_services_0));
6842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6843                         NDR_PULL_ALLOC(ndr, r->out.needed);
6844                 }
6845                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
6846                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
6847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
6848                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
6849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6850                         NDR_PULL_ALLOC(ndr, r->out.service_returned);
6851                 }
6852                 _mem_save_service_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
6853                 NDR_PULL_SET_MEM_CTX(ndr, r->out.service_returned, LIBNDR_FLAG_REF_ALLOC);
6854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.service_returned));
6855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_returned_0, LIBNDR_FLAG_REF_ALLOC);
6856                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
6857                 if (_ptr_resume_handle) {
6858                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
6859                 } else {
6860                         r->out.resume_handle = NULL;
6861                 }
6862                 if (r->out.resume_handle) {
6863                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
6864                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
6865                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
6866                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
6867                 }
6868                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
6869                         NDR_PULL_ALLOC(ndr, r->out.group_name);
6870                 }
6871                 _mem_save_group_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6872                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_name, LIBNDR_FLAG_REF_ALLOC);
6873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_name));
6874                 if (_ptr_group_name) {
6875                         NDR_PULL_ALLOC(ndr, *r->out.group_name);
6876                 } else {
6877                         *r->out.group_name = NULL;
6878                 }
6879                 if (*r->out.group_name) {
6880                         _mem_save_group_name_1 = NDR_PULL_GET_MEM_CTX(ndr);
6881                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.group_name, 0);
6882                         NDR_CHECK(ndr_pull_array_size(ndr, r->out.group_name));
6883                         NDR_CHECK(ndr_pull_array_length(ndr, r->out.group_name));
6884                         size_group_name_2 = ndr_get_array_size(ndr, r->out.group_name);
6885                         length_group_name_2 = ndr_get_array_length(ndr, r->out.group_name);
6886                         if (length_group_name_2 > size_group_name_2) {
6887                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_group_name_2, length_group_name_2);
6888                         }
6889                         NDR_CHECK(ndr_check_string_terminator(ndr, length_group_name_2, sizeof(uint16_t)));
6890                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.group_name, length_group_name_2, sizeof(uint16_t), CH_UTF16));
6891                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_1, 0);
6892                 }
6893                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_0, LIBNDR_FLAG_REF_ALLOC);
6894                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
6895         }
6896         return NDR_ERR_SUCCESS;
6897 }
6898
6899 _PUBLIC_ void ndr_print_EnumServicesStatusExA(struct ndr_print *ndr, const char *name, int flags, const struct EnumServicesStatusExA *r)
6900 {
6901         ndr_print_struct(ndr, name, "EnumServicesStatusExA");
6902         if (r == NULL) { ndr_print_null(ndr); return; }
6903         ndr->depth++;
6904         if (flags & NDR_SET_VALUES) {
6905                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
6906         }
6907         if (flags & NDR_IN) {
6908                 ndr_print_struct(ndr, "in", "EnumServicesStatusExA");
6909                 ndr->depth++;
6910                 ndr_print_ptr(ndr, "scmanager", r->in.scmanager);
6911                 ndr->depth++;
6912                 ndr_print_policy_handle(ndr, "scmanager", r->in.scmanager);
6913                 ndr->depth--;
6914                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
6915                 ndr_print_uint32(ndr, "type", r->in.type);
6916                 ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
6917                 ndr_print_uint32(ndr, "offered", r->in.offered);
6918                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
6919                 ndr->depth++;
6920                 if (r->in.resume_handle) {
6921                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
6922                 }
6923                 ndr->depth--;
6924                 ndr->depth--;
6925         }
6926         if (flags & NDR_OUT) {
6927                 ndr_print_struct(ndr, "out", "EnumServicesStatusExA");
6928                 ndr->depth++;
6929                 ndr_print_array_uint8(ndr, "services", r->out.services, r->in.offered);
6930                 ndr_print_ptr(ndr, "needed", r->out.needed);
6931                 ndr->depth++;
6932                 ndr_print_uint32(ndr, "needed", *r->out.needed);
6933                 ndr->depth--;
6934                 ndr_print_ptr(ndr, "service_returned", r->out.service_returned);
6935                 ndr->depth++;
6936                 ndr_print_uint32(ndr, "service_returned", *r->out.service_returned);
6937                 ndr->depth--;
6938                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
6939                 ndr->depth++;
6940                 if (r->out.resume_handle) {
6941                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
6942                 }
6943                 ndr->depth--;
6944                 ndr_print_ptr(ndr, "group_name", r->out.group_name);
6945                 ndr->depth++;
6946                 ndr_print_ptr(ndr, "group_name", *r->out.group_name);
6947                 ndr->depth++;
6948                 if (*r->out.group_name) {
6949                         ndr_print_string(ndr, "group_name", *r->out.group_name);
6950                 }
6951                 ndr->depth--;
6952                 ndr->depth--;
6953                 ndr_print_WERROR(ndr, "result", r->out.result);
6954                 ndr->depth--;
6955         }
6956         ndr->depth--;
6957 }
6958
6959 static enum ndr_err_code ndr_push_EnumServicesStatusExW(struct ndr_push *ndr, int flags, const struct EnumServicesStatusExW *r)
6960 {
6961         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
6962         if (flags & NDR_IN) {
6963                 if (r->in.scmanager == NULL) {
6964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6965                 }
6966                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
6967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
6968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
6969                 NDR_CHECK(ndr_push_svcctl_ServiceState(ndr, NDR_SCALARS, r->in.state));
6970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
6971                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
6972                 if (r->in.resume_handle) {
6973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
6974                 }
6975                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.group_name));
6976                 if (r->in.group_name) {
6977                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));
6978                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.group_name, CH_UTF16)));
6980                         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));
6981                 }
6982         }
6983         if (flags & NDR_OUT) {
6984                 if (r->out.services == NULL) {
6985                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6986                 }
6987                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
6988                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.offered));
6989                 if (r->out.needed == NULL) {
6990                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6991                 }
6992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
6993                 if (r->out.service_returned == NULL) {
6994                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
6995                 }
6996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.service_returned));
6997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
6998                 if (r->out.resume_handle) {
6999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
7000                 }
7001                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7002         }
7003         return NDR_ERR_SUCCESS;
7004 }
7005
7006 static enum ndr_err_code ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, int flags, struct EnumServicesStatusExW *r)
7007 {
7008         uint32_t size_services_1 = 0;
7009         uint32_t _ptr_resume_handle;
7010         uint32_t _ptr_group_name;
7011         uint32_t size_group_name_1 = 0;
7012         uint32_t length_group_name_1 = 0;
7013         TALLOC_CTX *_mem_save_scmanager_0;
7014         TALLOC_CTX *_mem_save_needed_0;
7015         TALLOC_CTX *_mem_save_service_returned_0;
7016         TALLOC_CTX *_mem_save_resume_handle_0;
7017         TALLOC_CTX *_mem_save_group_name_0;
7018         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7019         if (flags & NDR_IN) {
7020                 ZERO_STRUCT(r->out);
7021
7022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7023                         NDR_PULL_ALLOC(ndr, r->in.scmanager);
7024                 }
7025                 _mem_save_scmanager_0 = NDR_PULL_GET_MEM_CTX(ndr);
7026                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager, LIBNDR_FLAG_REF_ALLOC);
7027                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.scmanager));
7028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);
7029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
7030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
7031                 NDR_CHECK(ndr_pull_svcctl_ServiceState(ndr, NDR_SCALARS, &r->in.state));
7032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
7033                 if (r->in.offered > 0x40000) {
7034                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7035                 }
7036                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7037                 if (_ptr_resume_handle) {
7038                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
7039                 } else {
7040                         r->in.resume_handle = NULL;
7041                 }
7042                 if (r->in.resume_handle) {
7043                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7044                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
7045                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
7046                         if (*r->in.resume_handle > 0x40000) {
7047                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7048                         }
7049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7050                 }
7051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_name));
7052                 if (_ptr_group_name) {
7053                         NDR_PULL_ALLOC(ndr, r->in.group_name);
7054                 } else {
7055                         r->in.group_name = NULL;
7056                 }
7057                 if (r->in.group_name) {
7058                         _mem_save_group_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7059                         NDR_PULL_SET_MEM_CTX(ndr, r->in.group_name, 0);
7060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.group_name));
7061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.group_name));
7062                         size_group_name_1 = ndr_get_array_size(ndr, &r->in.group_name);
7063                         length_group_name_1 = ndr_get_array_length(ndr, &r->in.group_name);
7064                         if (length_group_name_1 > size_group_name_1) {
7065                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", size_group_name_1, length_group_name_1);
7066                         }
7067                         NDR_CHECK(ndr_check_string_terminator(ndr, length_group_name_1, sizeof(uint16_t)));
7068                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.group_name, length_group_name_1, sizeof(uint16_t), CH_UTF16));
7069                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_0, 0);
7070                 }
7071                 NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.offered);
7072                 memset(r->out.services, 0, (r->in.offered) * sizeof(*r->out.services));
7073                 NDR_PULL_ALLOC(ndr, r->out.needed);
7074                 ZERO_STRUCTP(r->out.needed);
7075                 NDR_PULL_ALLOC(ndr, r->out.service_returned);
7076                 ZERO_STRUCTP(r->out.service_returned);
7077         }
7078         if (flags & NDR_OUT) {
7079                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.services));
7080                 size_services_1 = ndr_get_array_size(ndr, &r->out.services);
7081                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7082                         NDR_PULL_ALLOC_N(ndr, r->out.services, size_services_1);
7083                 }
7084                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, size_services_1));
7085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7086                         NDR_PULL_ALLOC(ndr, r->out.needed);
7087                 }
7088                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
7089                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
7090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
7091                 if (*r->out.needed > 0x40000) {
7092                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7093                 }
7094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
7095                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
7096                         NDR_PULL_ALLOC(ndr, r->out.service_returned);
7097                 }
7098                 _mem_save_service_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
7099                 NDR_PULL_SET_MEM_CTX(ndr, r->out.service_returned, LIBNDR_FLAG_REF_ALLOC);
7100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.service_returned));
7101                 if (*r->out.service_returned > 0x40000) {
7102                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7103                 }
7104                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_returned_0, LIBNDR_FLAG_REF_ALLOC);
7105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
7106                 if (_ptr_resume_handle) {
7107                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
7108                 } else {
7109                         r->out.resume_handle = NULL;
7110                 }
7111                 if (r->out.resume_handle) {
7112                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
7113                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
7114                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
7115                         if (*r->out.resume_handle > 0x40000) {
7116                                 return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7117                         }
7118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
7119                 }
7120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7121                 if (r->out.services) {
7122                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.services, r->in.offered));
7123                 }
7124         }
7125         return NDR_ERR_SUCCESS;
7126 }
7127
7128 _PUBLIC_ void ndr_print_EnumServicesStatusExW(struct ndr_print *ndr, const char *name, int flags, const struct EnumServicesStatusExW *r)
7129 {
7130         ndr_print_struct(ndr, name, "EnumServicesStatusExW");
7131         if (r == NULL) { ndr_print_null(ndr); return; }
7132         ndr->depth++;
7133         if (flags & NDR_SET_VALUES) {
7134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7135         }
7136         if (flags & NDR_IN) {
7137                 ndr_print_struct(ndr, "in", "EnumServicesStatusExW");
7138                 ndr->depth++;
7139                 ndr_print_ptr(ndr, "scmanager", r->in.scmanager);
7140                 ndr->depth++;
7141                 ndr_print_policy_handle(ndr, "scmanager", r->in.scmanager);
7142                 ndr->depth--;
7143                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
7144                 ndr_print_uint32(ndr, "type", r->in.type);
7145                 ndr_print_svcctl_ServiceState(ndr, "state", r->in.state);
7146                 ndr_print_uint32(ndr, "offered", r->in.offered);
7147                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
7148                 ndr->depth++;
7149                 if (r->in.resume_handle) {
7150                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
7151                 }
7152                 ndr->depth--;
7153                 ndr_print_ptr(ndr, "group_name", r->in.group_name);
7154                 ndr->depth++;
7155                 if (r->in.group_name) {
7156                         ndr_print_string(ndr, "group_name", r->in.group_name);
7157                 }
7158                 ndr->depth--;
7159                 ndr->depth--;
7160         }
7161         if (flags & NDR_OUT) {
7162                 ndr_print_struct(ndr, "out", "EnumServicesStatusExW");
7163                 ndr->depth++;
7164                 ndr_print_ptr(ndr, "services", r->out.services);
7165                 ndr->depth++;
7166                 ndr_print_array_uint8(ndr, "services", r->out.services, r->in.offered);
7167                 ndr->depth--;
7168                 ndr_print_ptr(ndr, "needed", r->out.needed);
7169                 ndr->depth++;
7170                 ndr_print_uint32(ndr, "needed", *r->out.needed);
7171                 ndr->depth--;
7172                 ndr_print_ptr(ndr, "service_returned", r->out.service_returned);
7173                 ndr->depth++;
7174                 ndr_print_uint32(ndr, "service_returned", *r->out.service_returned);
7175                 ndr->depth--;
7176                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
7177                 ndr->depth++;
7178                 if (r->out.resume_handle) {
7179                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
7180                 }
7181                 ndr->depth--;
7182                 ndr_print_WERROR(ndr, "result", r->out.result);
7183                 ndr->depth--;
7184         }
7185         ndr->depth--;
7186 }
7187
7188 static enum ndr_err_code ndr_push_svcctl_SCSendTSMessage(struct ndr_push *ndr, int flags, const struct svcctl_SCSendTSMessage *r)
7189 {
7190         NDR_PUSH_CHECK_FN_FLAGS(ndr, flags);
7191         if (flags & NDR_IN) {
7192         }
7193         if (flags & NDR_OUT) {
7194                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
7195         }
7196         return NDR_ERR_SUCCESS;
7197 }
7198
7199 static enum ndr_err_code ndr_pull_svcctl_SCSendTSMessage(struct ndr_pull *ndr, int flags, struct svcctl_SCSendTSMessage *r)
7200 {
7201         NDR_PULL_CHECK_FN_FLAGS(ndr, flags);
7202         if (flags & NDR_IN) {
7203         }
7204         if (flags & NDR_OUT) {
7205                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
7206         }
7207         return NDR_ERR_SUCCESS;
7208 }
7209
7210 _PUBLIC_ void ndr_print_svcctl_SCSendTSMessage(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSendTSMessage *r)
7211 {
7212         ndr_print_struct(ndr, name, "svcctl_SCSendTSMessage");
7213         if (r == NULL) { ndr_print_null(ndr); return; }
7214         ndr->depth++;
7215         if (flags & NDR_SET_VALUES) {
7216                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
7217         }
7218         if (flags & NDR_IN) {
7219                 ndr_print_struct(ndr, "in", "svcctl_SCSendTSMessage");
7220                 ndr->depth++;
7221                 ndr->depth--;
7222         }
7223         if (flags & NDR_OUT) {
7224                 ndr_print_struct(ndr, "out", "svcctl_SCSendTSMessage");
7225                 ndr->depth++;
7226                 ndr_print_WERROR(ndr, "result", r->out.result);
7227                 ndr->depth--;
7228         }
7229         ndr->depth--;
7230 }
7231
7232 static const struct ndr_interface_call svcctl_calls[] = {
7233         {
7234                 "svcctl_CloseServiceHandle",
7235                 sizeof(struct svcctl_CloseServiceHandle),
7236                 (ndr_push_flags_fn_t) ndr_push_svcctl_CloseServiceHandle,
7237                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_CloseServiceHandle,
7238                 (ndr_print_function_t) ndr_print_svcctl_CloseServiceHandle,
7239                 { 0, NULL },
7240                 { 0, NULL },
7241         },
7242         {
7243                 "svcctl_ControlService",
7244                 sizeof(struct svcctl_ControlService),
7245                 (ndr_push_flags_fn_t) ndr_push_svcctl_ControlService,
7246                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ControlService,
7247                 (ndr_print_function_t) ndr_print_svcctl_ControlService,
7248                 { 0, NULL },
7249                 { 0, NULL },
7250         },
7251         {
7252                 "svcctl_DeleteService",
7253                 sizeof(struct svcctl_DeleteService),
7254                 (ndr_push_flags_fn_t) ndr_push_svcctl_DeleteService,
7255                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_DeleteService,
7256                 (ndr_print_function_t) ndr_print_svcctl_DeleteService,
7257                 { 0, NULL },
7258                 { 0, NULL },
7259         },
7260         {
7261                 "svcctl_LockServiceDatabase",
7262                 sizeof(struct svcctl_LockServiceDatabase),
7263                 (ndr_push_flags_fn_t) ndr_push_svcctl_LockServiceDatabase,
7264                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_LockServiceDatabase,
7265                 (ndr_print_function_t) ndr_print_svcctl_LockServiceDatabase,
7266                 { 0, NULL },
7267                 { 0, NULL },
7268         },
7269         {
7270                 "svcctl_QueryServiceObjectSecurity",
7271                 sizeof(struct svcctl_QueryServiceObjectSecurity),
7272                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceObjectSecurity,
7273                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceObjectSecurity,
7274                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceObjectSecurity,
7275                 { 0, NULL },
7276                 { 0, NULL },
7277         },
7278         {
7279                 "svcctl_SetServiceObjectSecurity",
7280                 sizeof(struct svcctl_SetServiceObjectSecurity),
7281                 (ndr_push_flags_fn_t) ndr_push_svcctl_SetServiceObjectSecurity,
7282                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SetServiceObjectSecurity,
7283                 (ndr_print_function_t) ndr_print_svcctl_SetServiceObjectSecurity,
7284                 { 0, NULL },
7285                 { 0, NULL },
7286         },
7287         {
7288                 "svcctl_QueryServiceStatus",
7289                 sizeof(struct svcctl_QueryServiceStatus),
7290                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceStatus,
7291                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceStatus,
7292                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceStatus,
7293                 { 0, NULL },
7294                 { 0, NULL },
7295         },
7296         {
7297                 "svcctl_SetServiceStatus",
7298                 sizeof(struct svcctl_SetServiceStatus),
7299                 (ndr_push_flags_fn_t) ndr_push_svcctl_SetServiceStatus,
7300                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SetServiceStatus,
7301                 (ndr_print_function_t) ndr_print_svcctl_SetServiceStatus,
7302                 { 0, NULL },
7303                 { 0, NULL },
7304         },
7305         {
7306                 "svcctl_UnlockServiceDatabase",
7307                 sizeof(struct svcctl_UnlockServiceDatabase),
7308                 (ndr_push_flags_fn_t) ndr_push_svcctl_UnlockServiceDatabase,
7309                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_UnlockServiceDatabase,
7310                 (ndr_print_function_t) ndr_print_svcctl_UnlockServiceDatabase,
7311                 { 0, NULL },
7312                 { 0, NULL },
7313         },
7314         {
7315                 "svcctl_NotifyBootConfigStatus",
7316                 sizeof(struct svcctl_NotifyBootConfigStatus),
7317                 (ndr_push_flags_fn_t) ndr_push_svcctl_NotifyBootConfigStatus,
7318                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_NotifyBootConfigStatus,
7319                 (ndr_print_function_t) ndr_print_svcctl_NotifyBootConfigStatus,
7320                 { 0, NULL },
7321                 { 0, NULL },
7322         },
7323         {
7324                 "svcctl_SCSetServiceBitsW",
7325                 sizeof(struct svcctl_SCSetServiceBitsW),
7326                 (ndr_push_flags_fn_t) ndr_push_svcctl_SCSetServiceBitsW,
7327                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSetServiceBitsW,
7328                 (ndr_print_function_t) ndr_print_svcctl_SCSetServiceBitsW,
7329                 { 0, NULL },
7330                 { 0, NULL },
7331         },
7332         {
7333                 "svcctl_ChangeServiceConfigW",
7334                 sizeof(struct svcctl_ChangeServiceConfigW),
7335                 (ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfigW,
7336                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfigW,
7337                 (ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfigW,
7338                 { 0, NULL },
7339                 { 0, NULL },
7340         },
7341         {
7342                 "svcctl_CreateServiceW",
7343                 sizeof(struct svcctl_CreateServiceW),
7344                 (ndr_push_flags_fn_t) ndr_push_svcctl_CreateServiceW,
7345                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_CreateServiceW,
7346                 (ndr_print_function_t) ndr_print_svcctl_CreateServiceW,
7347                 { 0, NULL },
7348                 { 0, NULL },
7349         },
7350         {
7351                 "svcctl_EnumDependentServicesW",
7352                 sizeof(struct svcctl_EnumDependentServicesW),
7353                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumDependentServicesW,
7354                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumDependentServicesW,
7355                 (ndr_print_function_t) ndr_print_svcctl_EnumDependentServicesW,
7356                 { 0, NULL },
7357                 { 0, NULL },
7358         },
7359         {
7360                 "svcctl_EnumServicesStatusW",
7361                 sizeof(struct svcctl_EnumServicesStatusW),
7362                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumServicesStatusW,
7363                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServicesStatusW,
7364                 (ndr_print_function_t) ndr_print_svcctl_EnumServicesStatusW,
7365                 { 0, NULL },
7366                 { 0, NULL },
7367         },
7368         {
7369                 "svcctl_OpenSCManagerW",
7370                 sizeof(struct svcctl_OpenSCManagerW),
7371                 (ndr_push_flags_fn_t) ndr_push_svcctl_OpenSCManagerW,
7372                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenSCManagerW,
7373                 (ndr_print_function_t) ndr_print_svcctl_OpenSCManagerW,
7374                 { 0, NULL },
7375                 { 0, NULL },
7376         },
7377         {
7378                 "svcctl_OpenServiceW",
7379                 sizeof(struct svcctl_OpenServiceW),
7380                 (ndr_push_flags_fn_t) ndr_push_svcctl_OpenServiceW,
7381                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenServiceW,
7382                 (ndr_print_function_t) ndr_print_svcctl_OpenServiceW,
7383                 { 0, NULL },
7384                 { 0, NULL },
7385         },
7386         {
7387                 "svcctl_QueryServiceConfigW",
7388                 sizeof(struct svcctl_QueryServiceConfigW),
7389                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfigW,
7390                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfigW,
7391                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceConfigW,
7392                 { 0, NULL },
7393                 { 0, NULL },
7394         },
7395         {
7396                 "svcctl_QueryServiceLockStatusW",
7397                 sizeof(struct svcctl_QueryServiceLockStatusW),
7398                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceLockStatusW,
7399                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceLockStatusW,
7400                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceLockStatusW,
7401                 { 0, NULL },
7402                 { 0, NULL },
7403         },
7404         {
7405                 "svcctl_StartServiceW",
7406                 sizeof(struct svcctl_StartServiceW),
7407                 (ndr_push_flags_fn_t) ndr_push_svcctl_StartServiceW,
7408                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_StartServiceW,
7409                 (ndr_print_function_t) ndr_print_svcctl_StartServiceW,
7410                 { 0, NULL },
7411                 { 0, NULL },
7412         },
7413         {
7414                 "svcctl_GetServiceDisplayNameW",
7415                 sizeof(struct svcctl_GetServiceDisplayNameW),
7416                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceDisplayNameW,
7417                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceDisplayNameW,
7418                 (ndr_print_function_t) ndr_print_svcctl_GetServiceDisplayNameW,
7419                 { 0, NULL },
7420                 { 0, NULL },
7421         },
7422         {
7423                 "svcctl_GetServiceKeyNameW",
7424                 sizeof(struct svcctl_GetServiceKeyNameW),
7425                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceKeyNameW,
7426                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceKeyNameW,
7427                 (ndr_print_function_t) ndr_print_svcctl_GetServiceKeyNameW,
7428                 { 0, NULL },
7429                 { 0, NULL },
7430         },
7431         {
7432                 "svcctl_SCSetServiceBitsA",
7433                 sizeof(struct svcctl_SCSetServiceBitsA),
7434                 (ndr_push_flags_fn_t) ndr_push_svcctl_SCSetServiceBitsA,
7435                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSetServiceBitsA,
7436                 (ndr_print_function_t) ndr_print_svcctl_SCSetServiceBitsA,
7437                 { 0, NULL },
7438                 { 0, NULL },
7439         },
7440         {
7441                 "svcctl_ChangeServiceConfigA",
7442                 sizeof(struct svcctl_ChangeServiceConfigA),
7443                 (ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfigA,
7444                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfigA,
7445                 (ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfigA,
7446                 { 0, NULL },
7447                 { 0, NULL },
7448         },
7449         {
7450                 "svcctl_CreateServiceA",
7451                 sizeof(struct svcctl_CreateServiceA),
7452                 (ndr_push_flags_fn_t) ndr_push_svcctl_CreateServiceA,
7453                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_CreateServiceA,
7454                 (ndr_print_function_t) ndr_print_svcctl_CreateServiceA,
7455                 { 0, NULL },
7456                 { 0, NULL },
7457         },
7458         {
7459                 "svcctl_EnumDependentServicesA",
7460                 sizeof(struct svcctl_EnumDependentServicesA),
7461                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumDependentServicesA,
7462                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumDependentServicesA,
7463                 (ndr_print_function_t) ndr_print_svcctl_EnumDependentServicesA,
7464                 { 0, NULL },
7465                 { 0, NULL },
7466         },
7467         {
7468                 "svcctl_EnumServicesStatusA",
7469                 sizeof(struct svcctl_EnumServicesStatusA),
7470                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumServicesStatusA,
7471                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServicesStatusA,
7472                 (ndr_print_function_t) ndr_print_svcctl_EnumServicesStatusA,
7473                 { 0, NULL },
7474                 { 0, NULL },
7475         },
7476         {
7477                 "svcctl_OpenSCManagerA",
7478                 sizeof(struct svcctl_OpenSCManagerA),
7479                 (ndr_push_flags_fn_t) ndr_push_svcctl_OpenSCManagerA,
7480                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenSCManagerA,
7481                 (ndr_print_function_t) ndr_print_svcctl_OpenSCManagerA,
7482                 { 0, NULL },
7483                 { 0, NULL },
7484         },
7485         {
7486                 "svcctl_OpenServiceA",
7487                 sizeof(struct svcctl_OpenServiceA),
7488                 (ndr_push_flags_fn_t) ndr_push_svcctl_OpenServiceA,
7489                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenServiceA,
7490                 (ndr_print_function_t) ndr_print_svcctl_OpenServiceA,
7491                 { 0, NULL },
7492                 { 0, NULL },
7493         },
7494         {
7495                 "svcctl_QueryServiceConfigA",
7496                 sizeof(struct svcctl_QueryServiceConfigA),
7497                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfigA,
7498                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfigA,
7499                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceConfigA,
7500                 { 0, NULL },
7501                 { 0, NULL },
7502         },
7503         {
7504                 "svcctl_QueryServiceLockStatusA",
7505                 sizeof(struct svcctl_QueryServiceLockStatusA),
7506                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceLockStatusA,
7507                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceLockStatusA,
7508                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceLockStatusA,
7509                 { 0, NULL },
7510                 { 0, NULL },
7511         },
7512         {
7513                 "svcctl_StartServiceA",
7514                 sizeof(struct svcctl_StartServiceA),
7515                 (ndr_push_flags_fn_t) ndr_push_svcctl_StartServiceA,
7516                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_StartServiceA,
7517                 (ndr_print_function_t) ndr_print_svcctl_StartServiceA,
7518                 { 0, NULL },
7519                 { 0, NULL },
7520         },
7521         {
7522                 "svcctl_GetServiceDisplayNameA",
7523                 sizeof(struct svcctl_GetServiceDisplayNameA),
7524                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceDisplayNameA,
7525                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceDisplayNameA,
7526                 (ndr_print_function_t) ndr_print_svcctl_GetServiceDisplayNameA,
7527                 { 0, NULL },
7528                 { 0, NULL },
7529         },
7530         {
7531                 "svcctl_GetServiceKeyNameA",
7532                 sizeof(struct svcctl_GetServiceKeyNameA),
7533                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceKeyNameA,
7534                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceKeyNameA,
7535                 (ndr_print_function_t) ndr_print_svcctl_GetServiceKeyNameA,
7536                 { 0, NULL },
7537                 { 0, NULL },
7538         },
7539         {
7540                 "svcctl_GetCurrentGroupeStateW",
7541                 sizeof(struct svcctl_GetCurrentGroupeStateW),
7542                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetCurrentGroupeStateW,
7543                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetCurrentGroupeStateW,
7544                 (ndr_print_function_t) ndr_print_svcctl_GetCurrentGroupeStateW,
7545                 { 0, NULL },
7546                 { 0, NULL },
7547         },
7548         {
7549                 "svcctl_EnumServiceGroupW",
7550                 sizeof(struct svcctl_EnumServiceGroupW),
7551                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumServiceGroupW,
7552                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServiceGroupW,
7553                 (ndr_print_function_t) ndr_print_svcctl_EnumServiceGroupW,
7554                 { 0, NULL },
7555                 { 0, NULL },
7556         },
7557         {
7558                 "svcctl_ChangeServiceConfig2A",
7559                 sizeof(struct svcctl_ChangeServiceConfig2A),
7560                 (ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfig2A,
7561                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfig2A,
7562                 (ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfig2A,
7563                 { 0, NULL },
7564                 { 0, NULL },
7565         },
7566         {
7567                 "svcctl_ChangeServiceConfig2W",
7568                 sizeof(struct svcctl_ChangeServiceConfig2W),
7569                 (ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfig2W,
7570                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfig2W,
7571                 (ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfig2W,
7572                 { 0, NULL },
7573                 { 0, NULL },
7574         },
7575         {
7576                 "svcctl_QueryServiceConfig2A",
7577                 sizeof(struct svcctl_QueryServiceConfig2A),
7578                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfig2A,
7579                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfig2A,
7580                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceConfig2A,
7581                 { 0, NULL },
7582                 { 0, NULL },
7583         },
7584         {
7585                 "svcctl_QueryServiceConfig2W",
7586                 sizeof(struct svcctl_QueryServiceConfig2W),
7587                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfig2W,
7588                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfig2W,
7589                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceConfig2W,
7590                 { 0, NULL },
7591                 { 0, NULL },
7592         },
7593         {
7594                 "svcctl_QueryServiceStatusEx",
7595                 sizeof(struct svcctl_QueryServiceStatusEx),
7596                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceStatusEx,
7597                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceStatusEx,
7598                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceStatusEx,
7599                 { 0, NULL },
7600                 { 0, NULL },
7601         },
7602         {
7603                 "EnumServicesStatusExA",
7604                 sizeof(struct EnumServicesStatusExA),
7605                 (ndr_push_flags_fn_t) ndr_push_EnumServicesStatusExA,
7606                 (ndr_pull_flags_fn_t) ndr_pull_EnumServicesStatusExA,
7607                 (ndr_print_function_t) ndr_print_EnumServicesStatusExA,
7608                 { 0, NULL },
7609                 { 0, NULL },
7610         },
7611         {
7612                 "EnumServicesStatusExW",
7613                 sizeof(struct EnumServicesStatusExW),
7614                 (ndr_push_flags_fn_t) ndr_push_EnumServicesStatusExW,
7615                 (ndr_pull_flags_fn_t) ndr_pull_EnumServicesStatusExW,
7616                 (ndr_print_function_t) ndr_print_EnumServicesStatusExW,
7617                 { 0, NULL },
7618                 { 0, NULL },
7619         },
7620         {
7621                 "svcctl_SCSendTSMessage",
7622                 sizeof(struct svcctl_SCSendTSMessage),
7623                 (ndr_push_flags_fn_t) ndr_push_svcctl_SCSendTSMessage,
7624                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSendTSMessage,
7625                 (ndr_print_function_t) ndr_print_svcctl_SCSendTSMessage,
7626                 { 0, NULL },
7627                 { 0, NULL },
7628         },
7629         { NULL, 0, NULL, NULL, NULL }
7630 };
7631
7632 static const char * const svcctl_endpoint_strings[] = {
7633         "ncacn_np:[\\pipe\\svcctl]",
7634         "ncalrpc:",
7635 };
7636
7637 static const struct ndr_interface_string_array svcctl_endpoints = {
7638         .count  = 2,
7639         .names  = svcctl_endpoint_strings
7640 };
7641
7642 static const char * const svcctl_authservice_strings[] = {
7643         "host",
7644 };
7645
7646 static const struct ndr_interface_string_array svcctl_authservices = {
7647         .count  = 1,
7648         .names  = svcctl_authservice_strings
7649 };
7650
7651
7652 const struct ndr_interface_table ndr_table_svcctl = {
7653         .name           = "svcctl",
7654         .syntax_id      = {
7655                 {0x367abb81,0x9844,0x35f1,{0xad,0x32},{0x98,0xf0,0x38,0x00,0x10,0x03}},
7656                 NDR_SVCCTL_VERSION
7657         },
7658         .helpstring     = NDR_SVCCTL_HELPSTRING,
7659         .num_calls      = 44,
7660         .calls          = svcctl_calls,
7661         .endpoints      = &svcctl_endpoints,
7662         .authservices   = &svcctl_authservices
7663 };
7664