source3/librpc/gen_ndr/ndr_svcctl.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "librpc/gen_ndr/ndr_svcctl.h"
   5
   6 NTSTATUS ndr_push_SERVICE_LOCK_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_LOCK_STATUS *r)
   7 {
   8         if (ndr_flags & NDR_SCALARS) {
   9                 NDR_CHECK(ndr_push_align(ndr, 4));
  10                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_locked));
  11                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->lock_owner));
  12                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lock_duration));
  13         }
  14         if (ndr_flags & NDR_BUFFERS) {
  15                 if (r->lock_owner) {
  16                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
  17                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
  18                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->lock_owner, CH_UTF16)));
  19                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->lock_owner, ndr_charset_length(r->lock_owner, CH_UTF16), sizeof(uint16_t), CH_UTF16));
  20                 }
  21         }
  22         return NT_STATUS_OK;
  23 }
  24
  25 NTSTATUS ndr_pull_SERVICE_LOCK_STATUS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_LOCK_STATUS *r)
  26 {
  27         uint32_t _ptr_lock_owner;
  28         TALLOC_CTX *_mem_save_lock_owner_0;
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 4));
  31                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_locked));
  32                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_lock_owner));
  33                 if (_ptr_lock_owner) {
  34                         NDR_PULL_ALLOC(ndr, r->lock_owner);
  35                 } else {
  36                         r->lock_owner = NULL;
  37                 }
  38                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lock_duration));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41                 if (r->lock_owner) {
  42                         _mem_save_lock_owner_0 = NDR_PULL_GET_MEM_CTX(ndr);
  43                         NDR_PULL_SET_MEM_CTX(ndr, r->lock_owner, 0);
  44                         NDR_CHECK(ndr_pull_array_size(ndr, &r->lock_owner));
  45                         NDR_CHECK(ndr_pull_array_length(ndr, &r->lock_owner));
  46                         if (ndr_get_array_length(ndr, &r->lock_owner) > ndr_get_array_size(ndr, &r->lock_owner)) {
  47                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->lock_owner), ndr_get_array_length(ndr, &r->lock_owner));
  48                         }
  49                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->lock_owner), sizeof(uint16_t)));
  50                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->lock_owner, ndr_get_array_length(ndr, &r->lock_owner), sizeof(uint16_t), CH_UTF16));
  51                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_owner_0, 0);
  52                 }
  53         }
  54         return NT_STATUS_OK;
  55 }
  56
  57 _PUBLIC_ void ndr_print_SERVICE_LOCK_STATUS(struct ndr_print *ndr, const char *name, const struct SERVICE_LOCK_STATUS *r)
  58 {
  59         ndr_print_struct(ndr, name, "SERVICE_LOCK_STATUS");
  60         ndr->depth++;
  61         ndr_print_uint32(ndr, "is_locked", r->is_locked);
  62         ndr_print_ptr(ndr, "lock_owner", r->lock_owner);
  63         ndr->depth++;
  64         if (r->lock_owner) {
  65                 ndr_print_string(ndr, "lock_owner", r->lock_owner);
  66         }
  67         ndr->depth--;
  68         ndr_print_uint32(ndr, "lock_duration", r->lock_duration);
  69         ndr->depth--;
  70 }
  71
  72 NTSTATUS ndr_push_SERVICE_STATUS(struct ndr_push *ndr, int ndr_flags, const struct SERVICE_STATUS *r)
  73 {
  74         if (ndr_flags & NDR_SCALARS) {
  75                 NDR_CHECK(ndr_push_align(ndr, 4));
  76                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->type));
  77                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->state));
  78                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->controls_accepted));
  79                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->win32_exit_code));
  80                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->service_exit_code));
  81                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->check_point));
  82                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->wait_hint));
  83         }
  84         if (ndr_flags & NDR_BUFFERS) {
  85         }
  86         return NT_STATUS_OK;
  87 }
  88
  89 NTSTATUS ndr_pull_SERVICE_STATUS(struct ndr_pull *ndr, int ndr_flags, struct SERVICE_STATUS *r)
  90 {
  91         if (ndr_flags & NDR_SCALARS) {
  92                 NDR_CHECK(ndr_pull_align(ndr, 4));
  93                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->type));
  94                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->state));
  95                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->controls_accepted));
  96                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->win32_exit_code));
  97                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->service_exit_code));
  98                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->check_point));
  99                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->wait_hint));
 100         }
 101         if (ndr_flags & NDR_BUFFERS) {
 102         }
 103         return NT_STATUS_OK;
 104 }
 105
 106 _PUBLIC_ void ndr_print_SERVICE_STATUS(struct ndr_print *ndr, const char *name, const struct SERVICE_STATUS *r)
 107 {
 108         ndr_print_struct(ndr, name, "SERVICE_STATUS");
 109         ndr->depth++;
 110         ndr_print_uint32(ndr, "type", r->type);
 111         ndr_print_uint32(ndr, "state", r->state);
 112         ndr_print_uint32(ndr, "controls_accepted", r->controls_accepted);
 113         ndr_print_WERROR(ndr, "win32_exit_code", r->win32_exit_code);
 114         ndr_print_uint32(ndr, "service_exit_code", r->service_exit_code);
 115         ndr_print_uint32(ndr, "check_point", r->check_point);
 116         ndr_print_uint32(ndr, "wait_hint", r->wait_hint);
 117         ndr->depth--;
 118 }
 119
 120 NTSTATUS ndr_push_ENUM_SERVICE_STATUS(struct ndr_push *ndr, int ndr_flags, const struct ENUM_SERVICE_STATUS *r)
 121 {
 122         if (ndr_flags & NDR_SCALARS) {
 123                 NDR_CHECK(ndr_push_align(ndr, 4));
 124                 {
 125                         uint32_t _flags_save_string = ndr->flags;
 126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 127                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->service_name));
 128                         ndr->flags = _flags_save_string;
 129                 }
 130                 {
 131                         uint32_t _flags_save_string = ndr->flags;
 132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 133                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
 134                         ndr->flags = _flags_save_string;
 135                 }
 136                 NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
 137         }
 138         if (ndr_flags & NDR_BUFFERS) {
 139                 {
 140                         uint32_t _flags_save_string = ndr->flags;
 141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 142                         if (r->service_name) {
 143                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->service_name));
 144                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->service_name));
 145                         }
 146                         ndr->flags = _flags_save_string;
 147                 }
 148                 {
 149                         uint32_t _flags_save_string = ndr->flags;
 150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 151                         if (r->display_name) {
 152                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
 153                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
 154                         }
 155                         ndr->flags = _flags_save_string;
 156                 }
 157         }
 158         return NT_STATUS_OK;
 159 }
 160
 161 NTSTATUS ndr_pull_ENUM_SERVICE_STATUS(struct ndr_pull *ndr, int ndr_flags, struct ENUM_SERVICE_STATUS *r)
 162 {
 163         uint32_t _ptr_service_name;
 164         TALLOC_CTX *_mem_save_service_name_0;
 165         uint32_t _ptr_display_name;
 166         TALLOC_CTX *_mem_save_display_name_0;
 167         if (ndr_flags & NDR_SCALARS) {
 168                 NDR_CHECK(ndr_pull_align(ndr, 4));
 169                 {
 170                         uint32_t _flags_save_string = ndr->flags;
 171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 172                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
 173                         if (_ptr_service_name) {
 174                                 NDR_PULL_ALLOC(ndr, r->service_name);
 175                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->service_name, _ptr_service_name));
 176                         } else {
 177                                 r->service_name = NULL;
 178                         }
 179                         ndr->flags = _flags_save_string;
 180                 }
 181                 {
 182                         uint32_t _flags_save_string = ndr->flags;
 183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 184                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
 185                         if (_ptr_display_name) {
 186                                 NDR_PULL_ALLOC(ndr, r->display_name);
 187                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
 188                         } else {
 189                                 r->display_name = NULL;
 190                         }
 191                         ndr->flags = _flags_save_string;
 192                 }
 193                 NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, &r->status));
 194         }
 195         if (ndr_flags & NDR_BUFFERS) {
 196                 {
 197                         uint32_t _flags_save_string = ndr->flags;
 198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 199                         if (r->service_name) {
 200                                 struct ndr_pull_save _relative_save;
 201                                 ndr_pull_save(ndr, &_relative_save);
 202                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->service_name));
 203                                 _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 204                                 NDR_PULL_SET_MEM_CTX(ndr, r->service_name, 0);
 205                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->service_name));
 206                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
 207                                 ndr_pull_restore(ndr, &_relative_save);
 208                         }
 209                         ndr->flags = _flags_save_string;
 210                 }
 211                 {
 212                         uint32_t _flags_save_string = ndr->flags;
 213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 214                         if (r->display_name) {
 215                                 struct ndr_pull_save _relative_save;
 216                                 ndr_pull_save(ndr, &_relative_save);
 217                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
 218                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 219                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
 220                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
 221                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
 222                                 ndr_pull_restore(ndr, &_relative_save);
 223                         }
 224                         ndr->flags = _flags_save_string;
 225                 }
 226         }
 227         return NT_STATUS_OK;
 228 }
 229
 230 _PUBLIC_ void ndr_print_ENUM_SERVICE_STATUS(struct ndr_print *ndr, const char *name, const struct ENUM_SERVICE_STATUS *r)
 231 {
 232         ndr_print_struct(ndr, name, "ENUM_SERVICE_STATUS");
 233         ndr->depth++;
 234         ndr_print_ptr(ndr, "service_name", r->service_name);
 235         ndr->depth++;
 236         if (r->service_name) {
 237                 ndr_print_string(ndr, "service_name", r->service_name);
 238         }
 239         ndr->depth--;
 240         ndr_print_ptr(ndr, "display_name", r->display_name);
 241         ndr->depth++;
 242         if (r->display_name) {
 243                 ndr_print_string(ndr, "display_name", r->display_name);
 244         }
 245         ndr->depth--;
 246         ndr_print_SERVICE_STATUS(ndr, "status", &r->status);
 247         ndr->depth--;
 248 }
 249
 250 _PUBLIC_ NTSTATUS ndr_push_svcctl_ServerType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 251 {
 252         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 253         return NT_STATUS_OK;
 254 }
 255
 256 _PUBLIC_ NTSTATUS ndr_pull_svcctl_ServerType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 257 {
 258         uint32_t v;
 259         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 260         *r = v;
 261         return NT_STATUS_OK;
 262 }
 263
 264 _PUBLIC_ void ndr_print_svcctl_ServerType(struct ndr_print *ndr, const char *name, uint32_t r)
 265 {
 266         ndr_print_uint32(ndr, name, r);
 267         ndr->depth++;
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_WORKSTATION", SV_TYPE_WORKSTATION, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER", SV_TYPE_SERVER, r);
 270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SQLSERVER", SV_TYPE_SQLSERVER, r);
 271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_CTRL", SV_TYPE_DOMAIN_CTRL, r);
 272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_BAKCTRL", SV_TYPE_DOMAIN_BAKCTRL, r);
 273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_TIME_SOURCE", SV_TYPE_TIME_SOURCE, r);
 274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_AFP", SV_TYPE_AFP, r);
 275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_NOVELL", SV_TYPE_NOVELL, r);
 276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_MEMBER", SV_TYPE_DOMAIN_MEMBER, r);
 277         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_PRINTQ_SERVER", SV_TYPE_PRINTQ_SERVER, r);
 278         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DIALIN_SERVER", SV_TYPE_DIALIN_SERVER, r);
 279         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_UNIX", SV_TYPE_SERVER_UNIX, r);
 280         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_NT", SV_TYPE_NT, r);
 281         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_WFW", SV_TYPE_WFW, r);
 282         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_MFPN", SV_TYPE_SERVER_MFPN, r);
 283         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_NT", SV_TYPE_SERVER_NT, r);
 284         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_POTENTIAL_BROWSER", SV_TYPE_POTENTIAL_BROWSER, r);
 285         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_BACKUP_BROWSER", SV_TYPE_BACKUP_BROWSER, r);
 286         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_MASTER_BROWSER", SV_TYPE_MASTER_BROWSER, r);
 287         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_MASTER", SV_TYPE_DOMAIN_MASTER, r);
 288         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_OSF", SV_TYPE_SERVER_OSF, r);
 289         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_SERVER_VMS", SV_TYPE_SERVER_VMS, r);
 290         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_WIN95_PLUS", SV_TYPE_WIN95_PLUS, r);
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DFS_SERVER", SV_TYPE_DFS_SERVER, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_ALTERNATE_XPORT", SV_TYPE_ALTERNATE_XPORT, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_LOCAL_LIST_ONLY", SV_TYPE_LOCAL_LIST_ONLY, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SV_TYPE_DOMAIN_ENUM", SV_TYPE_DOMAIN_ENUM, r);
 295         ndr->depth--;
 296 }
 297
 298 NTSTATUS ndr_push_svcctl_CloseServiceHandle(struct ndr_push *ndr, int flags, const struct svcctl_CloseServiceHandle *r)
 299 {
 300         if (flags & NDR_IN) {
 301                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 302                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 303         }
 304         if (flags & NDR_OUT) {
 305                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 306                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 307                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 308         }
 309         return NT_STATUS_OK;
 310 }
 311
 312 NTSTATUS ndr_pull_svcctl_CloseServiceHandle(struct ndr_pull *ndr, int flags, struct svcctl_CloseServiceHandle *r)
 313 {
 314         TALLOC_CTX *_mem_save_handle_0;
 315         if (flags & NDR_IN) {
 316                 ZERO_STRUCT(r->out);
 317
 318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 319                         NDR_PULL_ALLOC(ndr, r->in.handle);
 320                 }
 321                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 322                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 323                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 325                 NDR_PULL_ALLOC(ndr, r->out.handle);
 326                 *r->out.handle = *r->in.handle;
 327         }
 328         if (flags & NDR_OUT) {
 329                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 330                         NDR_PULL_ALLOC(ndr, r->out.handle);
 331                 }
 332                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 333                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
 334                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
 335                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 336                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 337         }
 338         return NT_STATUS_OK;
 339 }
 340
 341 _PUBLIC_ void ndr_print_svcctl_CloseServiceHandle(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CloseServiceHandle *r)
 342 {
 343         ndr_print_struct(ndr, name, "svcctl_CloseServiceHandle");
 344         ndr->depth++;
 345         if (flags & NDR_SET_VALUES) {
 346                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 347         }
 348         if (flags & NDR_IN) {
 349                 ndr_print_struct(ndr, "in", "svcctl_CloseServiceHandle");
 350                 ndr->depth++;
 351                 ndr_print_ptr(ndr, "handle", r->in.handle);
 352                 ndr->depth++;
 353                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 354                 ndr->depth--;
 355                 ndr->depth--;
 356         }
 357         if (flags & NDR_OUT) {
 358                 ndr_print_struct(ndr, "out", "svcctl_CloseServiceHandle");
 359                 ndr->depth++;
 360                 ndr_print_ptr(ndr, "handle", r->out.handle);
 361                 ndr->depth++;
 362                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
 363                 ndr->depth--;
 364                 ndr_print_WERROR(ndr, "result", r->out.result);
 365                 ndr->depth--;
 366         }
 367         ndr->depth--;
 368 }
 369
 370 NTSTATUS ndr_push_svcctl_ControlService(struct ndr_push *ndr, int flags, const struct svcctl_ControlService *r)
 371 {
 372         if (flags & NDR_IN) {
 373                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 374                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.control));
 376         }
 377         if (flags & NDR_OUT) {
 378                 if (r->out.service_status == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 379                 NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
 380                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 381         }
 382         return NT_STATUS_OK;
 383 }
 384
 385 NTSTATUS ndr_pull_svcctl_ControlService(struct ndr_pull *ndr, int flags, struct svcctl_ControlService *r)
 386 {
 387         TALLOC_CTX *_mem_save_handle_0;
 388         TALLOC_CTX *_mem_save_service_status_0;
 389         if (flags & NDR_IN) {
 390                 ZERO_STRUCT(r->out);
 391
 392                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 393                         NDR_PULL_ALLOC(ndr, r->in.handle);
 394                 }
 395                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 396                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 397                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 398                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.control));
 400                 NDR_PULL_ALLOC(ndr, r->out.service_status);
 401                 ZERO_STRUCTP(r->out.service_status);
 402         }
 403         if (flags & NDR_OUT) {
 404                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 405                         NDR_PULL_ALLOC(ndr, r->out.service_status);
 406                 }
 407                 _mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
 408                 NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, LIBNDR_FLAG_REF_ALLOC);
 409                 NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
 410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, LIBNDR_FLAG_REF_ALLOC);
 411                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 412         }
 413         return NT_STATUS_OK;
 414 }
 415
 416 _PUBLIC_ void ndr_print_svcctl_ControlService(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ControlService *r)
 417 {
 418         ndr_print_struct(ndr, name, "svcctl_ControlService");
 419         ndr->depth++;
 420         if (flags & NDR_SET_VALUES) {
 421                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 422         }
 423         if (flags & NDR_IN) {
 424                 ndr_print_struct(ndr, "in", "svcctl_ControlService");
 425                 ndr->depth++;
 426                 ndr_print_ptr(ndr, "handle", r->in.handle);
 427                 ndr->depth++;
 428                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 429                 ndr->depth--;
 430                 ndr_print_uint32(ndr, "control", r->in.control);
 431                 ndr->depth--;
 432         }
 433         if (flags & NDR_OUT) {
 434                 ndr_print_struct(ndr, "out", "svcctl_ControlService");
 435                 ndr->depth++;
 436                 ndr_print_ptr(ndr, "service_status", r->out.service_status);
 437                 ndr->depth++;
 438                 ndr_print_SERVICE_STATUS(ndr, "service_status", r->out.service_status);
 439                 ndr->depth--;
 440                 ndr_print_WERROR(ndr, "result", r->out.result);
 441                 ndr->depth--;
 442         }
 443         ndr->depth--;
 444 }
 445
 446 NTSTATUS ndr_push_svcctl_DeleteService(struct ndr_push *ndr, int flags, const struct svcctl_DeleteService *r)
 447 {
 448         if (flags & NDR_IN) {
 449                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 450                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 451         }
 452         if (flags & NDR_OUT) {
 453                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 454         }
 455         return NT_STATUS_OK;
 456 }
 457
 458 NTSTATUS ndr_pull_svcctl_DeleteService(struct ndr_pull *ndr, int flags, struct svcctl_DeleteService *r)
 459 {
 460         TALLOC_CTX *_mem_save_handle_0;
 461         if (flags & NDR_IN) {
 462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 463                         NDR_PULL_ALLOC(ndr, r->in.handle);
 464                 }
 465                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 466                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 467                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 469         }
 470         if (flags & NDR_OUT) {
 471                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 472         }
 473         return NT_STATUS_OK;
 474 }
 475
 476 _PUBLIC_ void ndr_print_svcctl_DeleteService(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_DeleteService *r)
 477 {
 478         ndr_print_struct(ndr, name, "svcctl_DeleteService");
 479         ndr->depth++;
 480         if (flags & NDR_SET_VALUES) {
 481                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 482         }
 483         if (flags & NDR_IN) {
 484                 ndr_print_struct(ndr, "in", "svcctl_DeleteService");
 485                 ndr->depth++;
 486                 ndr_print_ptr(ndr, "handle", r->in.handle);
 487                 ndr->depth++;
 488                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 489                 ndr->depth--;
 490                 ndr->depth--;
 491         }
 492         if (flags & NDR_OUT) {
 493                 ndr_print_struct(ndr, "out", "svcctl_DeleteService");
 494                 ndr->depth++;
 495                 ndr_print_WERROR(ndr, "result", r->out.result);
 496                 ndr->depth--;
 497         }
 498         ndr->depth--;
 499 }
 500
 501 NTSTATUS ndr_push_svcctl_LockServiceDatabase(struct ndr_push *ndr, int flags, const struct svcctl_LockServiceDatabase *r)
 502 {
 503         if (flags & NDR_IN) {
 504                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 505                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 506         }
 507         if (flags & NDR_OUT) {
 508                 if (r->out.lock == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 509                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock));
 510                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 511         }
 512         return NT_STATUS_OK;
 513 }
 514
 515 NTSTATUS ndr_pull_svcctl_LockServiceDatabase(struct ndr_pull *ndr, int flags, struct svcctl_LockServiceDatabase *r)
 516 {
 517         TALLOC_CTX *_mem_save_handle_0;
 518         TALLOC_CTX *_mem_save_lock_0;
 519         if (flags & NDR_IN) {
 520                 ZERO_STRUCT(r->out);
 521
 522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 523                         NDR_PULL_ALLOC(ndr, r->in.handle);
 524                 }
 525                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 527                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 529                 NDR_PULL_ALLOC(ndr, r->out.lock);
 530                 ZERO_STRUCTP(r->out.lock);
 531         }
 532         if (flags & NDR_OUT) {
 533                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 534                         NDR_PULL_ALLOC(ndr, r->out.lock);
 535                 }
 536                 _mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);
 537                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lock, LIBNDR_FLAG_REF_ALLOC);
 538                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock));
 539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);
 540                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 541         }
 542         return NT_STATUS_OK;
 543 }
 544
 545 _PUBLIC_ void ndr_print_svcctl_LockServiceDatabase(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_LockServiceDatabase *r)
 546 {
 547         ndr_print_struct(ndr, name, "svcctl_LockServiceDatabase");
 548         ndr->depth++;
 549         if (flags & NDR_SET_VALUES) {
 550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 551         }
 552         if (flags & NDR_IN) {
 553                 ndr_print_struct(ndr, "in", "svcctl_LockServiceDatabase");
 554                 ndr->depth++;
 555                 ndr_print_ptr(ndr, "handle", r->in.handle);
 556                 ndr->depth++;
 557                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 558                 ndr->depth--;
 559                 ndr->depth--;
 560         }
 561         if (flags & NDR_OUT) {
 562                 ndr_print_struct(ndr, "out", "svcctl_LockServiceDatabase");
 563                 ndr->depth++;
 564                 ndr_print_ptr(ndr, "lock", r->out.lock);
 565                 ndr->depth++;
 566                 ndr_print_policy_handle(ndr, "lock", r->out.lock);
 567                 ndr->depth--;
 568                 ndr_print_WERROR(ndr, "result", r->out.result);
 569                 ndr->depth--;
 570         }
 571         ndr->depth--;
 572 }
 573
 574 NTSTATUS ndr_push_svcctl_QueryServiceObjectSecurity(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceObjectSecurity *r)
 575 {
 576         if (flags & NDR_IN) {
 577         }
 578         if (flags & NDR_OUT) {
 579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 580         }
 581         return NT_STATUS_OK;
 582 }
 583
 584 NTSTATUS ndr_pull_svcctl_QueryServiceObjectSecurity(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceObjectSecurity *r)
 585 {
 586         if (flags & NDR_IN) {
 587         }
 588         if (flags & NDR_OUT) {
 589                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 590         }
 591         return NT_STATUS_OK;
 592 }
 593
 594 _PUBLIC_ void ndr_print_svcctl_QueryServiceObjectSecurity(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceObjectSecurity *r)
 595 {
 596         ndr_print_struct(ndr, name, "svcctl_QueryServiceObjectSecurity");
 597         ndr->depth++;
 598         if (flags & NDR_SET_VALUES) {
 599                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 600         }
 601         if (flags & NDR_IN) {
 602                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceObjectSecurity");
 603                 ndr->depth++;
 604                 ndr->depth--;
 605         }
 606         if (flags & NDR_OUT) {
 607                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceObjectSecurity");
 608                 ndr->depth++;
 609                 ndr_print_WERROR(ndr, "result", r->out.result);
 610                 ndr->depth--;
 611         }
 612         ndr->depth--;
 613 }
 614
 615 NTSTATUS ndr_push_svcctl_SetServiceObjectSecurity(struct ndr_push *ndr, int flags, const struct svcctl_SetServiceObjectSecurity *r)
 616 {
 617         if (flags & NDR_IN) {
 618         }
 619         if (flags & NDR_OUT) {
 620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 621         }
 622         return NT_STATUS_OK;
 623 }
 624
 625 NTSTATUS ndr_pull_svcctl_SetServiceObjectSecurity(struct ndr_pull *ndr, int flags, struct svcctl_SetServiceObjectSecurity *r)
 626 {
 627         if (flags & NDR_IN) {
 628         }
 629         if (flags & NDR_OUT) {
 630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 631         }
 632         return NT_STATUS_OK;
 633 }
 634
 635 _PUBLIC_ void ndr_print_svcctl_SetServiceObjectSecurity(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SetServiceObjectSecurity *r)
 636 {
 637         ndr_print_struct(ndr, name, "svcctl_SetServiceObjectSecurity");
 638         ndr->depth++;
 639         if (flags & NDR_SET_VALUES) {
 640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 641         }
 642         if (flags & NDR_IN) {
 643                 ndr_print_struct(ndr, "in", "svcctl_SetServiceObjectSecurity");
 644                 ndr->depth++;
 645                 ndr->depth--;
 646         }
 647         if (flags & NDR_OUT) {
 648                 ndr_print_struct(ndr, "out", "svcctl_SetServiceObjectSecurity");
 649                 ndr->depth++;
 650                 ndr_print_WERROR(ndr, "result", r->out.result);
 651                 ndr->depth--;
 652         }
 653         ndr->depth--;
 654 }
 655
 656 NTSTATUS ndr_push_svcctl_QueryServiceStatus(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceStatus *r)
 657 {
 658         if (flags & NDR_IN) {
 659                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 660                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 661         }
 662         if (flags & NDR_OUT) {
 663                 if (r->out.service_status == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 664                 NDR_CHECK(ndr_push_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
 665                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 666         }
 667         return NT_STATUS_OK;
 668 }
 669
 670 NTSTATUS ndr_pull_svcctl_QueryServiceStatus(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceStatus *r)
 671 {
 672         TALLOC_CTX *_mem_save_handle_0;
 673         TALLOC_CTX *_mem_save_service_status_0;
 674         if (flags & NDR_IN) {
 675                 ZERO_STRUCT(r->out);
 676
 677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 678                         NDR_PULL_ALLOC(ndr, r->in.handle);
 679                 }
 680                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 682                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 684                 NDR_PULL_ALLOC(ndr, r->out.service_status);
 685                 ZERO_STRUCTP(r->out.service_status);
 686         }
 687         if (flags & NDR_OUT) {
 688                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 689                         NDR_PULL_ALLOC(ndr, r->out.service_status);
 690                 }
 691                 _mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
 692                 NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, LIBNDR_FLAG_REF_ALLOC);
 693                 NDR_CHECK(ndr_pull_SERVICE_STATUS(ndr, NDR_SCALARS, r->out.service_status));
 694                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, LIBNDR_FLAG_REF_ALLOC);
 695                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 696         }
 697         return NT_STATUS_OK;
 698 }
 699
 700 _PUBLIC_ void ndr_print_svcctl_QueryServiceStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceStatus *r)
 701 {
 702         ndr_print_struct(ndr, name, "svcctl_QueryServiceStatus");
 703         ndr->depth++;
 704         if (flags & NDR_SET_VALUES) {
 705                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 706         }
 707         if (flags & NDR_IN) {
 708                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceStatus");
 709                 ndr->depth++;
 710                 ndr_print_ptr(ndr, "handle", r->in.handle);
 711                 ndr->depth++;
 712                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 713                 ndr->depth--;
 714                 ndr->depth--;
 715         }
 716         if (flags & NDR_OUT) {
 717                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceStatus");
 718                 ndr->depth++;
 719                 ndr_print_ptr(ndr, "service_status", r->out.service_status);
 720                 ndr->depth++;
 721                 ndr_print_SERVICE_STATUS(ndr, "service_status", r->out.service_status);
 722                 ndr->depth--;
 723                 ndr_print_WERROR(ndr, "result", r->out.result);
 724                 ndr->depth--;
 725         }
 726         ndr->depth--;
 727 }
 728
 729 NTSTATUS ndr_push_svcctl_SetServiceStatus(struct ndr_push *ndr, int flags, const struct svcctl_SetServiceStatus *r)
 730 {
 731         if (flags & NDR_IN) {
 732         }
 733         if (flags & NDR_OUT) {
 734                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 735         }
 736         return NT_STATUS_OK;
 737 }
 738
 739 NTSTATUS ndr_pull_svcctl_SetServiceStatus(struct ndr_pull *ndr, int flags, struct svcctl_SetServiceStatus *r)
 740 {
 741         if (flags & NDR_IN) {
 742         }
 743         if (flags & NDR_OUT) {
 744                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 745         }
 746         return NT_STATUS_OK;
 747 }
 748
 749 _PUBLIC_ void ndr_print_svcctl_SetServiceStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SetServiceStatus *r)
 750 {
 751         ndr_print_struct(ndr, name, "svcctl_SetServiceStatus");
 752         ndr->depth++;
 753         if (flags & NDR_SET_VALUES) {
 754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 755         }
 756         if (flags & NDR_IN) {
 757                 ndr_print_struct(ndr, "in", "svcctl_SetServiceStatus");
 758                 ndr->depth++;
 759                 ndr->depth--;
 760         }
 761         if (flags & NDR_OUT) {
 762                 ndr_print_struct(ndr, "out", "svcctl_SetServiceStatus");
 763                 ndr->depth++;
 764                 ndr_print_WERROR(ndr, "result", r->out.result);
 765                 ndr->depth--;
 766         }
 767         ndr->depth--;
 768 }
 769
 770 NTSTATUS ndr_push_svcctl_UnlockServiceDatabase(struct ndr_push *ndr, int flags, const struct svcctl_UnlockServiceDatabase *r)
 771 {
 772         if (flags & NDR_IN) {
 773                 if (r->in.lock == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 774                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.lock));
 775         }
 776         if (flags & NDR_OUT) {
 777                 if (r->out.lock == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 778                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock));
 779                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 780         }
 781         return NT_STATUS_OK;
 782 }
 783
 784 NTSTATUS ndr_pull_svcctl_UnlockServiceDatabase(struct ndr_pull *ndr, int flags, struct svcctl_UnlockServiceDatabase *r)
 785 {
 786         TALLOC_CTX *_mem_save_lock_0;
 787         if (flags & NDR_IN) {
 788                 ZERO_STRUCT(r->out);
 789
 790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 791                         NDR_PULL_ALLOC(ndr, r->in.lock);
 792                 }
 793                 _mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);
 794                 NDR_PULL_SET_MEM_CTX(ndr, r->in.lock, LIBNDR_FLAG_REF_ALLOC);
 795                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.lock));
 796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);
 797                 NDR_PULL_ALLOC(ndr, r->out.lock);
 798                 *r->out.lock = *r->in.lock;
 799         }
 800         if (flags & NDR_OUT) {
 801                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 802                         NDR_PULL_ALLOC(ndr, r->out.lock);
 803                 }
 804                 _mem_save_lock_0 = NDR_PULL_GET_MEM_CTX(ndr);
 805                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lock, LIBNDR_FLAG_REF_ALLOC);
 806                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock));
 807                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_0, LIBNDR_FLAG_REF_ALLOC);
 808                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 809         }
 810         return NT_STATUS_OK;
 811 }
 812
 813 _PUBLIC_ void ndr_print_svcctl_UnlockServiceDatabase(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_UnlockServiceDatabase *r)
 814 {
 815         ndr_print_struct(ndr, name, "svcctl_UnlockServiceDatabase");
 816         ndr->depth++;
 817         if (flags & NDR_SET_VALUES) {
 818                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 819         }
 820         if (flags & NDR_IN) {
 821                 ndr_print_struct(ndr, "in", "svcctl_UnlockServiceDatabase");
 822                 ndr->depth++;
 823                 ndr_print_ptr(ndr, "lock", r->in.lock);
 824                 ndr->depth++;
 825                 ndr_print_policy_handle(ndr, "lock", r->in.lock);
 826                 ndr->depth--;
 827                 ndr->depth--;
 828         }
 829         if (flags & NDR_OUT) {
 830                 ndr_print_struct(ndr, "out", "svcctl_UnlockServiceDatabase");
 831                 ndr->depth++;
 832                 ndr_print_ptr(ndr, "lock", r->out.lock);
 833                 ndr->depth++;
 834                 ndr_print_policy_handle(ndr, "lock", r->out.lock);
 835                 ndr->depth--;
 836                 ndr_print_WERROR(ndr, "result", r->out.result);
 837                 ndr->depth--;
 838         }
 839         ndr->depth--;
 840 }
 841
 842 NTSTATUS ndr_push_svcctl_NotifyBootConfigStatus(struct ndr_push *ndr, int flags, const struct svcctl_NotifyBootConfigStatus *r)
 843 {
 844         if (flags & NDR_IN) {
 845         }
 846         if (flags & NDR_OUT) {
 847                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 848         }
 849         return NT_STATUS_OK;
 850 }
 851
 852 NTSTATUS ndr_pull_svcctl_NotifyBootConfigStatus(struct ndr_pull *ndr, int flags, struct svcctl_NotifyBootConfigStatus *r)
 853 {
 854         if (flags & NDR_IN) {
 855         }
 856         if (flags & NDR_OUT) {
 857                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 858         }
 859         return NT_STATUS_OK;
 860 }
 861
 862 _PUBLIC_ void ndr_print_svcctl_NotifyBootConfigStatus(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_NotifyBootConfigStatus *r)
 863 {
 864         ndr_print_struct(ndr, name, "svcctl_NotifyBootConfigStatus");
 865         ndr->depth++;
 866         if (flags & NDR_SET_VALUES) {
 867                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 868         }
 869         if (flags & NDR_IN) {
 870                 ndr_print_struct(ndr, "in", "svcctl_NotifyBootConfigStatus");
 871                 ndr->depth++;
 872                 ndr->depth--;
 873         }
 874         if (flags & NDR_OUT) {
 875                 ndr_print_struct(ndr, "out", "svcctl_NotifyBootConfigStatus");
 876                 ndr->depth++;
 877                 ndr_print_WERROR(ndr, "result", r->out.result);
 878                 ndr->depth--;
 879         }
 880         ndr->depth--;
 881 }
 882
 883 NTSTATUS ndr_push_svcctl_SCSetServiceBitsW(struct ndr_push *ndr, int flags, const struct svcctl_SCSetServiceBitsW *r)
 884 {
 885         if (flags & NDR_IN) {
 886                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 887                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bits));
 889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bitson));
 890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.immediate));
 891         }
 892         if (flags & NDR_OUT) {
 893                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
 894         }
 895         return NT_STATUS_OK;
 896 }
 897
 898 NTSTATUS ndr_pull_svcctl_SCSetServiceBitsW(struct ndr_pull *ndr, int flags, struct svcctl_SCSetServiceBitsW *r)
 899 {
 900         TALLOC_CTX *_mem_save_handle_0;
 901         if (flags & NDR_IN) {
 902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 903                         NDR_PULL_ALLOC(ndr, r->in.handle);
 904                 }
 905                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
 906                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
 907                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 908                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
 909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bits));
 910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bitson));
 911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.immediate));
 912         }
 913         if (flags & NDR_OUT) {
 914                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
 915         }
 916         return NT_STATUS_OK;
 917 }
 918
 919 _PUBLIC_ void ndr_print_svcctl_SCSetServiceBitsW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSetServiceBitsW *r)
 920 {
 921         ndr_print_struct(ndr, name, "svcctl_SCSetServiceBitsW");
 922         ndr->depth++;
 923         if (flags & NDR_SET_VALUES) {
 924                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
 925         }
 926         if (flags & NDR_IN) {
 927                 ndr_print_struct(ndr, "in", "svcctl_SCSetServiceBitsW");
 928                 ndr->depth++;
 929                 ndr_print_ptr(ndr, "handle", r->in.handle);
 930                 ndr->depth++;
 931                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
 932                 ndr->depth--;
 933                 ndr_print_uint32(ndr, "bits", r->in.bits);
 934                 ndr_print_uint32(ndr, "bitson", r->in.bitson);
 935                 ndr_print_uint32(ndr, "immediate", r->in.immediate);
 936                 ndr->depth--;
 937         }
 938         if (flags & NDR_OUT) {
 939                 ndr_print_struct(ndr, "out", "svcctl_SCSetServiceBitsW");
 940                 ndr->depth++;
 941                 ndr_print_WERROR(ndr, "result", r->out.result);
 942                 ndr->depth--;
 943         }
 944         ndr->depth--;
 945 }
 946
 947 NTSTATUS ndr_push_svcctl_ChangeServiceConfigW(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfigW *r)
 948 {
 949         if (flags & NDR_IN) {
 950                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
 951                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
 952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
 953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start));
 954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.error));
 955                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
 956                 if (r->in.binary_path) {
 957                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
 958                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
 960                         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));
 961                 }
 962                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.load_order_group));
 963                 if (r->in.load_order_group) {
 964                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
 965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
 967                         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));
 968                 }
 969                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
 970                 if (r->in.dependencies) {
 971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
 972                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
 974                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 975                 }
 976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
 977                 if (r->in.service_start_name) {
 978                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
 979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
 981                         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));
 982                 }
 983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
 984                 if (r->in.password) {
 985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
 986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 987                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
 988                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
 989                 }
 990                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name));
 991                 if (r->in.display_name) {
 992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
 993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 994                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
 995                         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));
 996                 }
 997         }
 998         if (flags & NDR_OUT) {
 999                 if (r->out.tag_id == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.tag_id));
1001                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1002         }
1003         return NT_STATUS_OK;
1004 }
1005
1006 NTSTATUS ndr_pull_svcctl_ChangeServiceConfigW(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfigW *r)
1007 {
1008         uint32_t _ptr_binary_path;
1009         uint32_t _ptr_load_order_group;
1010         uint32_t _ptr_dependencies;
1011         uint32_t _ptr_service_start_name;
1012         uint32_t _ptr_password;
1013         uint32_t _ptr_display_name;
1014         TALLOC_CTX *_mem_save_handle_0;
1015         TALLOC_CTX *_mem_save_binary_path_0;
1016         TALLOC_CTX *_mem_save_load_order_group_0;
1017         TALLOC_CTX *_mem_save_tag_id_0;
1018         TALLOC_CTX *_mem_save_dependencies_0;
1019         TALLOC_CTX *_mem_save_service_start_name_0;
1020         TALLOC_CTX *_mem_save_password_0;
1021         TALLOC_CTX *_mem_save_display_name_0;
1022         if (flags & NDR_IN) {
1023                 ZERO_STRUCT(r->out);
1024
1025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1026                         NDR_PULL_ALLOC(ndr, r->in.handle);
1027                 }
1028                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1029                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1030                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
1033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start));
1034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.error));
1035                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
1036                 if (_ptr_binary_path) {
1037                         NDR_PULL_ALLOC(ndr, r->in.binary_path);
1038                 } else {
1039                         r->in.binary_path = NULL;
1040                 }
1041                 if (r->in.binary_path) {
1042                         _mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
1043                         NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);
1044                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
1045                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
1046                         if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {
1047                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));
1048                         }
1049                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));
1050                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));
1051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);
1052                 }
1053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_load_order_group));
1054                 if (_ptr_load_order_group) {
1055                         NDR_PULL_ALLOC(ndr, r->in.load_order_group);
1056                 } else {
1057                         r->in.load_order_group = NULL;
1058                 }
1059                 if (r->in.load_order_group) {
1060                         _mem_save_load_order_group_0 = NDR_PULL_GET_MEM_CTX(ndr);
1061                         NDR_PULL_SET_MEM_CTX(ndr, r->in.load_order_group, 0);
1062                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.load_order_group));
1063                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.load_order_group));
1064                         if (ndr_get_array_length(ndr, &r->in.load_order_group) > ndr_get_array_size(ndr, &r->in.load_order_group)) {
1065                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.load_order_group), ndr_get_array_length(ndr, &r->in.load_order_group));
1066                         }
1067                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t)));
1068                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.load_order_group, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t), CH_UTF16));
1069                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_load_order_group_0, 0);
1070                 }
1071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
1072                 if (_ptr_dependencies) {
1073                         NDR_PULL_ALLOC(ndr, r->in.dependencies);
1074                 } else {
1075                         r->in.dependencies = NULL;
1076                 }
1077                 if (r->in.dependencies) {
1078                         _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
1079                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
1080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
1081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));
1082                         if (ndr_get_array_length(ndr, &r->in.dependencies) > ndr_get_array_size(ndr, &r->in.dependencies)) {
1083                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dependencies), ndr_get_array_length(ndr, &r->in.dependencies));
1084                         }
1085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t)));
1086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t), CH_UTF16));
1087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
1088                 }
1089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
1090                 if (_ptr_service_start_name) {
1091                         NDR_PULL_ALLOC(ndr, r->in.service_start_name);
1092                 } else {
1093                         r->in.service_start_name = NULL;
1094                 }
1095                 if (r->in.service_start_name) {
1096                         _mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1097                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
1098                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
1099                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
1100                         if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {
1101                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));
1102                         }
1103                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));
1104                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));
1105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
1106                 }
1107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
1108                 if (_ptr_password) {
1109                         NDR_PULL_ALLOC(ndr, r->in.password);
1110                 } else {
1111                         r->in.password = NULL;
1112                 }
1113                 if (r->in.password) {
1114                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
1115                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
1116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
1117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
1118                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
1119                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.password), ndr_get_array_length(ndr, &r->in.password));
1120                         }
1121                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
1122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
1123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
1124                 }
1125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
1126                 if (_ptr_display_name) {
1127                         NDR_PULL_ALLOC(ndr, r->in.display_name);
1128                 } else {
1129                         r->in.display_name = NULL;
1130                 }
1131                 if (r->in.display_name) {
1132                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1133                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name, 0);
1134                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.display_name));
1135                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.display_name));
1136                         if (ndr_get_array_length(ndr, &r->in.display_name) > ndr_get_array_size(ndr, &r->in.display_name)) {
1137                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.display_name), ndr_get_array_length(ndr, &r->in.display_name));
1138                         }
1139                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t)));
1140                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.display_name, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t), CH_UTF16));
1141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
1142                 }
1143                 NDR_PULL_ALLOC(ndr, r->out.tag_id);
1144                 ZERO_STRUCTP(r->out.tag_id);
1145         }
1146         if (flags & NDR_OUT) {
1147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1148                         NDR_PULL_ALLOC(ndr, r->out.tag_id);
1149                 }
1150                 _mem_save_tag_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
1151                 NDR_PULL_SET_MEM_CTX(ndr, r->out.tag_id, LIBNDR_FLAG_REF_ALLOC);
1152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.tag_id));
1153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tag_id_0, LIBNDR_FLAG_REF_ALLOC);
1154                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1155         }
1156         return NT_STATUS_OK;
1157 }
1158
1159 _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfigW *r)
1160 {
1161         ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfigW");
1162         ndr->depth++;
1163         if (flags & NDR_SET_VALUES) {
1164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1165         }
1166         if (flags & NDR_IN) {
1167                 ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfigW");
1168                 ndr->depth++;
1169                 ndr_print_ptr(ndr, "handle", r->in.handle);
1170                 ndr->depth++;
1171                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1172                 ndr->depth--;
1173                 ndr_print_uint32(ndr, "type", r->in.type);
1174                 ndr_print_uint32(ndr, "start", r->in.start);
1175                 ndr_print_uint32(ndr, "error", r->in.error);
1176                 ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
1177                 ndr->depth++;
1178                 if (r->in.binary_path) {
1179                         ndr_print_string(ndr, "binary_path", r->in.binary_path);
1180                 }
1181                 ndr->depth--;
1182                 ndr_print_ptr(ndr, "load_order_group", r->in.load_order_group);
1183                 ndr->depth++;
1184                 if (r->in.load_order_group) {
1185                         ndr_print_string(ndr, "load_order_group", r->in.load_order_group);
1186                 }
1187                 ndr->depth--;
1188                 ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
1189                 ndr->depth++;
1190                 if (r->in.dependencies) {
1191                         ndr_print_string(ndr, "dependencies", r->in.dependencies);
1192                 }
1193                 ndr->depth--;
1194                 ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
1195                 ndr->depth++;
1196                 if (r->in.service_start_name) {
1197                         ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
1198                 }
1199                 ndr->depth--;
1200                 ndr_print_ptr(ndr, "password", r->in.password);
1201                 ndr->depth++;
1202                 if (r->in.password) {
1203                         ndr_print_string(ndr, "password", r->in.password);
1204                 }
1205                 ndr->depth--;
1206                 ndr_print_ptr(ndr, "display_name", r->in.display_name);
1207                 ndr->depth++;
1208                 if (r->in.display_name) {
1209                         ndr_print_string(ndr, "display_name", r->in.display_name);
1210                 }
1211                 ndr->depth--;
1212                 ndr->depth--;
1213         }
1214         if (flags & NDR_OUT) {
1215                 ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfigW");
1216                 ndr->depth++;
1217                 ndr_print_ptr(ndr, "tag_id", r->out.tag_id);
1218                 ndr->depth++;
1219                 ndr_print_uint32(ndr, "tag_id", *r->out.tag_id);
1220                 ndr->depth--;
1221                 ndr_print_WERROR(ndr, "result", r->out.result);
1222                 ndr->depth--;
1223         }
1224         ndr->depth--;
1225 }
1226
1227 NTSTATUS ndr_push_svcctl_CreateServiceW(struct ndr_push *ndr, int flags, const struct svcctl_CreateServiceW *r)
1228 {
1229         if (flags & NDR_IN) {
1230                 if (r->in.scmanager_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1231                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager_handle));
1232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
1233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
1235                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DisplayName));
1237                 if (r->in.DisplayName) {
1238                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
1239                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1240                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
1241                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1242                 }
1243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.desired_access));
1244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
1245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_type));
1246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.error_control));
1247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
1248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
1250                 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));
1251                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.LoadOrderGroupKey));
1252                 if (r->in.LoadOrderGroupKey) {
1253                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
1254                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1255                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
1256                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1257                 }
1258                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.TagId));
1259                 if (r->in.TagId) {
1260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.TagId));
1261                 }
1262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
1263                 if (r->in.dependencies) {
1264                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dependencies_size));
1265                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.dependencies, r->in.dependencies_size));
1266                 }
1267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.dependencies_size));
1268                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
1269                 if (r->in.service_start_name) {
1270                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
1271                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1272                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
1273                         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));
1274                 }
1275                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
1276                 if (r->in.password) {
1277                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.password_size));
1278                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.password, r->in.password_size));
1279                 }
1280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.password_size));
1281         }
1282         if (flags & NDR_OUT) {
1283                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.TagId));
1284                 if (r->out.TagId) {
1285                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.TagId));
1286                 }
1287                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1288                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
1289                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1290         }
1291         return NT_STATUS_OK;
1292 }
1293
1294 NTSTATUS ndr_pull_svcctl_CreateServiceW(struct ndr_pull *ndr, int flags, struct svcctl_CreateServiceW *r)
1295 {
1296         uint32_t _ptr_DisplayName;
1297         uint32_t _ptr_LoadOrderGroupKey;
1298         uint32_t _ptr_TagId;
1299         uint32_t _ptr_dependencies;
1300         uint32_t _ptr_service_start_name;
1301         uint32_t _ptr_password;
1302         TALLOC_CTX *_mem_save_scmanager_handle_0;
1303         TALLOC_CTX *_mem_save_DisplayName_0;
1304         TALLOC_CTX *_mem_save_LoadOrderGroupKey_0;
1305         TALLOC_CTX *_mem_save_TagId_0;
1306         TALLOC_CTX *_mem_save_dependencies_0;
1307         TALLOC_CTX *_mem_save_service_start_name_0;
1308         TALLOC_CTX *_mem_save_password_0;
1309         TALLOC_CTX *_mem_save_handle_0;
1310         if (flags & NDR_IN) {
1311                 ZERO_STRUCT(r->out);
1312
1313                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1314                         NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);
1315                 }
1316                 _mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1317                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);
1318                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager_handle));
1319                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);
1320                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
1321                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
1322                 if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {
1323                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));
1324                 }
1325                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));
1326                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));
1327                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DisplayName));
1328                 if (_ptr_DisplayName) {
1329                         NDR_PULL_ALLOC(ndr, r->in.DisplayName);
1330                 } else {
1331                         r->in.DisplayName = NULL;
1332                 }
1333                 if (r->in.DisplayName) {
1334                         _mem_save_DisplayName_0 = NDR_PULL_GET_MEM_CTX(ndr);
1335                         NDR_PULL_SET_MEM_CTX(ndr, r->in.DisplayName, 0);
1336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DisplayName));
1337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DisplayName));
1338                         if (ndr_get_array_length(ndr, &r->in.DisplayName) > ndr_get_array_size(ndr, &r->in.DisplayName)) {
1339                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.DisplayName), ndr_get_array_length(ndr, &r->in.DisplayName));
1340                         }
1341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t)));
1342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DisplayName, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t), CH_UTF16));
1343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DisplayName_0, 0);
1344                 }
1345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.desired_access));
1346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
1347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_type));
1348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.error_control));
1349                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
1350                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
1351                 if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {
1352                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));
1353                 }
1354                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));
1355                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));
1356                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_LoadOrderGroupKey));
1357                 if (_ptr_LoadOrderGroupKey) {
1358                         NDR_PULL_ALLOC(ndr, r->in.LoadOrderGroupKey);
1359                 } else {
1360                         r->in.LoadOrderGroupKey = NULL;
1361                 }
1362                 if (r->in.LoadOrderGroupKey) {
1363                         _mem_save_LoadOrderGroupKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
1364                         NDR_PULL_SET_MEM_CTX(ndr, r->in.LoadOrderGroupKey, 0);
1365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.LoadOrderGroupKey));
1366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.LoadOrderGroupKey));
1367                         if (ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey) > ndr_get_array_size(ndr, &r->in.LoadOrderGroupKey)) {
1368                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.LoadOrderGroupKey), ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey));
1369                         }
1370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t)));
1371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.LoadOrderGroupKey, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t), CH_UTF16));
1372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_LoadOrderGroupKey_0, 0);
1373                 }
1374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));
1375                 if (_ptr_TagId) {
1376                         NDR_PULL_ALLOC(ndr, r->in.TagId);
1377                 } else {
1378                         r->in.TagId = NULL;
1379                 }
1380                 if (r->in.TagId) {
1381                         _mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);
1382                         NDR_PULL_SET_MEM_CTX(ndr, r->in.TagId, 0);
1383                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.TagId));
1384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);
1385                 }
1386                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
1387                 if (_ptr_dependencies) {
1388                         NDR_PULL_ALLOC(ndr, r->in.dependencies);
1389                 } else {
1390                         r->in.dependencies = NULL;
1391                 }
1392                 if (r->in.dependencies) {
1393                         _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
1394                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
1395                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
1396                         NDR_PULL_ALLOC_N(ndr, r->in.dependencies, ndr_get_array_size(ndr, &r->in.dependencies));
1397                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.dependencies, ndr_get_array_size(ndr, &r->in.dependencies)));
1398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
1399                 }
1400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.dependencies_size));
1401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
1402                 if (_ptr_service_start_name) {
1403                         NDR_PULL_ALLOC(ndr, r->in.service_start_name);
1404                 } else {
1405                         r->in.service_start_name = NULL;
1406                 }
1407                 if (r->in.service_start_name) {
1408                         _mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1409                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
1410                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
1411                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
1412                         if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {
1413                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));
1414                         }
1415                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));
1416                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));
1417                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
1418                 }
1419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
1420                 if (_ptr_password) {
1421                         NDR_PULL_ALLOC(ndr, r->in.password);
1422                 } else {
1423                         r->in.password = NULL;
1424                 }
1425                 if (r->in.password) {
1426                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
1427                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
1428                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
1429                         NDR_PULL_ALLOC_N(ndr, r->in.password, ndr_get_array_size(ndr, &r->in.password));
1430                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.password, ndr_get_array_size(ndr, &r->in.password)));
1431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
1432                 }
1433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.password_size));
1434                 NDR_PULL_ALLOC(ndr, r->out.handle);
1435                 ZERO_STRUCTP(r->out.handle);
1436                 if (r->in.dependencies) {
1437                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.dependencies, r->in.dependencies_size));
1438                 }
1439                 if (r->in.password) {
1440                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.password, r->in.password_size));
1441                 }
1442         }
1443         if (flags & NDR_OUT) {
1444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));
1445                 if (_ptr_TagId) {
1446                         NDR_PULL_ALLOC(ndr, r->out.TagId);
1447                 } else {
1448                         r->out.TagId = NULL;
1449                 }
1450                 if (r->out.TagId) {
1451                         _mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);
1452                         NDR_PULL_SET_MEM_CTX(ndr, r->out.TagId, 0);
1453                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.TagId));
1454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);
1455                 }
1456                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1457                         NDR_PULL_ALLOC(ndr, r->out.handle);
1458                 }
1459                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1460                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1461                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
1462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1463                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1464         }
1465         return NT_STATUS_OK;
1466 }
1467
1468 _PUBLIC_ void ndr_print_svcctl_CreateServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CreateServiceW *r)
1469 {
1470         ndr_print_struct(ndr, name, "svcctl_CreateServiceW");
1471         ndr->depth++;
1472         if (flags & NDR_SET_VALUES) {
1473                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1474         }
1475         if (flags & NDR_IN) {
1476                 ndr_print_struct(ndr, "in", "svcctl_CreateServiceW");
1477                 ndr->depth++;
1478                 ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);
1479                 ndr->depth++;
1480                 ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);
1481                 ndr->depth--;
1482                 ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
1483                 ndr_print_ptr(ndr, "DisplayName", r->in.DisplayName);
1484                 ndr->depth++;
1485                 if (r->in.DisplayName) {
1486                         ndr_print_string(ndr, "DisplayName", r->in.DisplayName);
1487                 }
1488                 ndr->depth--;
1489                 ndr_print_uint32(ndr, "desired_access", r->in.desired_access);
1490                 ndr_print_uint32(ndr, "type", r->in.type);
1491                 ndr_print_uint32(ndr, "start_type", r->in.start_type);
1492                 ndr_print_uint32(ndr, "error_control", r->in.error_control);
1493                 ndr_print_string(ndr, "binary_path", r->in.binary_path);
1494                 ndr_print_ptr(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
1495                 ndr->depth++;
1496                 if (r->in.LoadOrderGroupKey) {
1497                         ndr_print_string(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
1498                 }
1499                 ndr->depth--;
1500                 ndr_print_ptr(ndr, "TagId", r->in.TagId);
1501                 ndr->depth++;
1502                 if (r->in.TagId) {
1503                         ndr_print_uint32(ndr, "TagId", *r->in.TagId);
1504                 }
1505                 ndr->depth--;
1506                 ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
1507                 ndr->depth++;
1508                 if (r->in.dependencies) {
1509                         ndr_print_array_uint8(ndr, "dependencies", r->in.dependencies, r->in.dependencies_size);
1510                 }
1511                 ndr->depth--;
1512                 ndr_print_uint32(ndr, "dependencies_size", r->in.dependencies_size);
1513                 ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
1514                 ndr->depth++;
1515                 if (r->in.service_start_name) {
1516                         ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
1517                 }
1518                 ndr->depth--;
1519                 ndr_print_ptr(ndr, "password", r->in.password);
1520                 ndr->depth++;
1521                 if (r->in.password) {
1522                         ndr_print_array_uint8(ndr, "password", r->in.password, r->in.password_size);
1523                 }
1524                 ndr->depth--;
1525                 ndr_print_uint32(ndr, "password_size", r->in.password_size);
1526                 ndr->depth--;
1527         }
1528         if (flags & NDR_OUT) {
1529                 ndr_print_struct(ndr, "out", "svcctl_CreateServiceW");
1530                 ndr->depth++;
1531                 ndr_print_ptr(ndr, "TagId", r->out.TagId);
1532                 ndr->depth++;
1533                 if (r->out.TagId) {
1534                         ndr_print_uint32(ndr, "TagId", *r->out.TagId);
1535                 }
1536                 ndr->depth--;
1537                 ndr_print_ptr(ndr, "handle", r->out.handle);
1538                 ndr->depth++;
1539                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
1540                 ndr->depth--;
1541                 ndr_print_WERROR(ndr, "result", r->out.result);
1542                 ndr->depth--;
1543         }
1544         ndr->depth--;
1545 }
1546
1547 NTSTATUS ndr_push_svcctl_EnumDependentServicesW(struct ndr_push *ndr, int flags, const struct svcctl_EnumDependentServicesW *r)
1548 {
1549         if (flags & NDR_IN) {
1550                 if (r->in.service == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1551                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.service));
1552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
1553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
1554         }
1555         if (flags & NDR_OUT) {
1556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.service_status));
1557                 if (r->out.service_status) {
1558                         NDR_CHECK(ndr_push_ENUM_SERVICE_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
1559                 }
1560                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
1562                 if (r->out.services_returned == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
1564                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1565         }
1566         return NT_STATUS_OK;
1567 }
1568
1569 NTSTATUS ndr_pull_svcctl_EnumDependentServicesW(struct ndr_pull *ndr, int flags, struct svcctl_EnumDependentServicesW *r)
1570 {
1571         uint32_t _ptr_service_status;
1572         TALLOC_CTX *_mem_save_service_0;
1573         TALLOC_CTX *_mem_save_service_status_0;
1574         TALLOC_CTX *_mem_save_bytes_needed_0;
1575         TALLOC_CTX *_mem_save_services_returned_0;
1576         if (flags & NDR_IN) {
1577                 ZERO_STRUCT(r->out);
1578
1579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1580                         NDR_PULL_ALLOC(ndr, r->in.service);
1581                 }
1582                 _mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);
1583                 NDR_PULL_SET_MEM_CTX(ndr, r->in.service, LIBNDR_FLAG_REF_ALLOC);
1584                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.service));
1585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);
1586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
1587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
1588                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
1589                 ZERO_STRUCTP(r->out.bytes_needed);
1590                 NDR_PULL_ALLOC(ndr, r->out.services_returned);
1591                 ZERO_STRUCTP(r->out.services_returned);
1592         }
1593         if (flags & NDR_OUT) {
1594                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_status));
1595                 if (_ptr_service_status) {
1596                         NDR_PULL_ALLOC(ndr, r->out.service_status);
1597                 } else {
1598                         r->out.service_status = NULL;
1599                 }
1600                 if (r->out.service_status) {
1601                         _mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
1602                         NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, 0);
1603                         NDR_CHECK(ndr_pull_ENUM_SERVICE_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
1604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, 0);
1605                 }
1606                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1607                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
1608                 }
1609                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
1610                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
1611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
1612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
1613                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1614                         NDR_PULL_ALLOC(ndr, r->out.services_returned);
1615                 }
1616                 _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
1617                 NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
1618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
1619                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
1620                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1621         }
1622         return NT_STATUS_OK;
1623 }
1624
1625 _PUBLIC_ void ndr_print_svcctl_EnumDependentServicesW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumDependentServicesW *r)
1626 {
1627         ndr_print_struct(ndr, name, "svcctl_EnumDependentServicesW");
1628         ndr->depth++;
1629         if (flags & NDR_SET_VALUES) {
1630                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1631         }
1632         if (flags & NDR_IN) {
1633                 ndr_print_struct(ndr, "in", "svcctl_EnumDependentServicesW");
1634                 ndr->depth++;
1635                 ndr_print_ptr(ndr, "service", r->in.service);
1636                 ndr->depth++;
1637                 ndr_print_policy_handle(ndr, "service", r->in.service);
1638                 ndr->depth--;
1639                 ndr_print_uint32(ndr, "state", r->in.state);
1640                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
1641                 ndr->depth--;
1642         }
1643         if (flags & NDR_OUT) {
1644                 ndr_print_struct(ndr, "out", "svcctl_EnumDependentServicesW");
1645                 ndr->depth++;
1646                 ndr_print_ptr(ndr, "service_status", r->out.service_status);
1647                 ndr->depth++;
1648                 if (r->out.service_status) {
1649                         ndr_print_ENUM_SERVICE_STATUS(ndr, "service_status", r->out.service_status);
1650                 }
1651                 ndr->depth--;
1652                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
1653                 ndr->depth++;
1654                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
1655                 ndr->depth--;
1656                 ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
1657                 ndr->depth++;
1658                 ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
1659                 ndr->depth--;
1660                 ndr_print_WERROR(ndr, "result", r->out.result);
1661                 ndr->depth--;
1662         }
1663         ndr->depth--;
1664 }
1665
1666 NTSTATUS ndr_push_svcctl_EnumServicesStatusW(struct ndr_push *ndr, int flags, const struct svcctl_EnumServicesStatusW *r)
1667 {
1668         if (flags & NDR_IN) {
1669                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1670                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
1672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
1673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
1674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
1675                 if (r->in.resume_handle) {
1676                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
1677                 }
1678         }
1679         if (flags & NDR_OUT) {
1680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
1681                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.buf_size));
1682                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
1684                 if (r->out.services_returned == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
1686                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
1687                 if (r->out.resume_handle) {
1688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
1689                 }
1690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1691         }
1692         return NT_STATUS_OK;
1693 }
1694
1695 NTSTATUS ndr_pull_svcctl_EnumServicesStatusW(struct ndr_pull *ndr, int flags, struct svcctl_EnumServicesStatusW *r)
1696 {
1697         uint32_t _ptr_resume_handle;
1698         TALLOC_CTX *_mem_save_handle_0;
1699         TALLOC_CTX *_mem_save_bytes_needed_0;
1700         TALLOC_CTX *_mem_save_services_returned_0;
1701         TALLOC_CTX *_mem_save_resume_handle_0;
1702         if (flags & NDR_IN) {
1703                 ZERO_STRUCT(r->out);
1704
1705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1706                         NDR_PULL_ALLOC(ndr, r->in.handle);
1707                 }
1708                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1709                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
1710                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
1711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
1713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
1714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
1715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
1716                 if (_ptr_resume_handle) {
1717                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
1718                 } else {
1719                         r->in.resume_handle = NULL;
1720                 }
1721                 if (r->in.resume_handle) {
1722                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1723                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
1724                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
1725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
1726                 }
1727                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
1728                 ZERO_STRUCTP(r->out.bytes_needed);
1729                 NDR_PULL_ALLOC(ndr, r->out.services_returned);
1730                 ZERO_STRUCTP(r->out.services_returned);
1731         }
1732         if (flags & NDR_OUT) {
1733                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.service));
1734                 NDR_PULL_ALLOC_N(ndr, r->out.service, ndr_get_array_size(ndr, &r->out.service));
1735                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, ndr_get_array_size(ndr, &r->out.service)));
1736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1737                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
1738                 }
1739                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
1740                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
1741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
1742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
1743                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1744                         NDR_PULL_ALLOC(ndr, r->out.services_returned);
1745                 }
1746                 _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
1747                 NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
1748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
1749                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
1750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
1751                 if (_ptr_resume_handle) {
1752                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
1753                 } else {
1754                         r->out.resume_handle = NULL;
1755                 }
1756                 if (r->out.resume_handle) {
1757                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1758                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
1759                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
1760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
1761                 }
1762                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1763                 if (r->out.service) {
1764                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.buf_size));
1765                 }
1766         }
1767         return NT_STATUS_OK;
1768 }
1769
1770 _PUBLIC_ void ndr_print_svcctl_EnumServicesStatusW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServicesStatusW *r)
1771 {
1772         ndr_print_struct(ndr, name, "svcctl_EnumServicesStatusW");
1773         ndr->depth++;
1774         if (flags & NDR_SET_VALUES) {
1775                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1776         }
1777         if (flags & NDR_IN) {
1778                 ndr_print_struct(ndr, "in", "svcctl_EnumServicesStatusW");
1779                 ndr->depth++;
1780                 ndr_print_ptr(ndr, "handle", r->in.handle);
1781                 ndr->depth++;
1782                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
1783                 ndr->depth--;
1784                 ndr_print_uint32(ndr, "type", r->in.type);
1785                 ndr_print_uint32(ndr, "state", r->in.state);
1786                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
1787                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
1788                 ndr->depth++;
1789                 if (r->in.resume_handle) {
1790                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
1791                 }
1792                 ndr->depth--;
1793                 ndr->depth--;
1794         }
1795         if (flags & NDR_OUT) {
1796                 ndr_print_struct(ndr, "out", "svcctl_EnumServicesStatusW");
1797                 ndr->depth++;
1798                 ndr_print_array_uint8(ndr, "service", r->out.service, r->in.buf_size);
1799                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
1800                 ndr->depth++;
1801                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
1802                 ndr->depth--;
1803                 ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
1804                 ndr->depth++;
1805                 ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
1806                 ndr->depth--;
1807                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
1808                 ndr->depth++;
1809                 if (r->out.resume_handle) {
1810                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
1811                 }
1812                 ndr->depth--;
1813                 ndr_print_WERROR(ndr, "result", r->out.result);
1814                 ndr->depth--;
1815         }
1816         ndr->depth--;
1817 }
1818
1819 NTSTATUS ndr_push_svcctl_OpenSCManagerW(struct ndr_push *ndr, int flags, const struct svcctl_OpenSCManagerW *r)
1820 {
1821         if (flags & NDR_IN) {
1822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.MachineName));
1823                 if (r->in.MachineName) {
1824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
1825                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
1827                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1828                 }
1829                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DatabaseName));
1830                 if (r->in.DatabaseName) {
1831                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
1832                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1833                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
1834                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1835                 }
1836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
1837         }
1838         if (flags & NDR_OUT) {
1839                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1840                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
1841                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1842         }
1843         return NT_STATUS_OK;
1844 }
1845
1846 NTSTATUS ndr_pull_svcctl_OpenSCManagerW(struct ndr_pull *ndr, int flags, struct svcctl_OpenSCManagerW *r)
1847 {
1848         uint32_t _ptr_MachineName;
1849         uint32_t _ptr_DatabaseName;
1850         TALLOC_CTX *_mem_save_MachineName_0;
1851         TALLOC_CTX *_mem_save_DatabaseName_0;
1852         TALLOC_CTX *_mem_save_handle_0;
1853         if (flags & NDR_IN) {
1854                 ZERO_STRUCT(r->out);
1855
1856                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_MachineName));
1857                 if (_ptr_MachineName) {
1858                         NDR_PULL_ALLOC(ndr, r->in.MachineName);
1859                 } else {
1860                         r->in.MachineName = NULL;
1861                 }
1862                 if (r->in.MachineName) {
1863                         _mem_save_MachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
1864                         NDR_PULL_SET_MEM_CTX(ndr, r->in.MachineName, 0);
1865                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.MachineName));
1866                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.MachineName));
1867                         if (ndr_get_array_length(ndr, &r->in.MachineName) > ndr_get_array_size(ndr, &r->in.MachineName)) {
1868                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.MachineName), ndr_get_array_length(ndr, &r->in.MachineName));
1869                         }
1870                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t)));
1871                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.MachineName, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t), CH_UTF16));
1872                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MachineName_0, 0);
1873                 }
1874                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DatabaseName));
1875                 if (_ptr_DatabaseName) {
1876                         NDR_PULL_ALLOC(ndr, r->in.DatabaseName);
1877                 } else {
1878                         r->in.DatabaseName = NULL;
1879                 }
1880                 if (r->in.DatabaseName) {
1881                         _mem_save_DatabaseName_0 = NDR_PULL_GET_MEM_CTX(ndr);
1882                         NDR_PULL_SET_MEM_CTX(ndr, r->in.DatabaseName, 0);
1883                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DatabaseName));
1884                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DatabaseName));
1885                         if (ndr_get_array_length(ndr, &r->in.DatabaseName) > ndr_get_array_size(ndr, &r->in.DatabaseName)) {
1886                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.DatabaseName), ndr_get_array_length(ndr, &r->in.DatabaseName));
1887                         }
1888                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t)));
1889                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DatabaseName, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t), CH_UTF16));
1890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DatabaseName_0, 0);
1891                 }
1892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
1893                 NDR_PULL_ALLOC(ndr, r->out.handle);
1894                 ZERO_STRUCTP(r->out.handle);
1895         }
1896         if (flags & NDR_OUT) {
1897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1898                         NDR_PULL_ALLOC(ndr, r->out.handle);
1899                 }
1900                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1901                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1902                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
1903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1904                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
1905         }
1906         return NT_STATUS_OK;
1907 }
1908
1909 _PUBLIC_ void ndr_print_svcctl_OpenSCManagerW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenSCManagerW *r)
1910 {
1911         ndr_print_struct(ndr, name, "svcctl_OpenSCManagerW");
1912         ndr->depth++;
1913         if (flags & NDR_SET_VALUES) {
1914                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
1915         }
1916         if (flags & NDR_IN) {
1917                 ndr_print_struct(ndr, "in", "svcctl_OpenSCManagerW");
1918                 ndr->depth++;
1919                 ndr_print_ptr(ndr, "MachineName", r->in.MachineName);
1920                 ndr->depth++;
1921                 if (r->in.MachineName) {
1922                         ndr_print_string(ndr, "MachineName", r->in.MachineName);
1923                 }
1924                 ndr->depth--;
1925                 ndr_print_ptr(ndr, "DatabaseName", r->in.DatabaseName);
1926                 ndr->depth++;
1927                 if (r->in.DatabaseName) {
1928                         ndr_print_string(ndr, "DatabaseName", r->in.DatabaseName);
1929                 }
1930                 ndr->depth--;
1931                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
1932                 ndr->depth--;
1933         }
1934         if (flags & NDR_OUT) {
1935                 ndr_print_struct(ndr, "out", "svcctl_OpenSCManagerW");
1936                 ndr->depth++;
1937                 ndr_print_ptr(ndr, "handle", r->out.handle);
1938                 ndr->depth++;
1939                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
1940                 ndr->depth--;
1941                 ndr_print_WERROR(ndr, "result", r->out.result);
1942                 ndr->depth--;
1943         }
1944         ndr->depth--;
1945 }
1946
1947 NTSTATUS ndr_push_svcctl_OpenServiceW(struct ndr_push *ndr, int flags, const struct svcctl_OpenServiceW *r)
1948 {
1949         if (flags & NDR_IN) {
1950                 if (r->in.scmanager_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1951                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager_handle));
1952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
1953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
1955                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
1956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
1957         }
1958         if (flags & NDR_OUT) {
1959                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
1960                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
1961                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
1962         }
1963         return NT_STATUS_OK;
1964 }
1965
1966 NTSTATUS ndr_pull_svcctl_OpenServiceW(struct ndr_pull *ndr, int flags, struct svcctl_OpenServiceW *r)
1967 {
1968         TALLOC_CTX *_mem_save_scmanager_handle_0;
1969         TALLOC_CTX *_mem_save_handle_0;
1970         if (flags & NDR_IN) {
1971                 ZERO_STRUCT(r->out);
1972
1973                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1974                         NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);
1975                 }
1976                 _mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1977                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);
1978                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager_handle));
1979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);
1980                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
1981                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
1982                 if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {
1983                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));
1984                 }
1985                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));
1986                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));
1987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
1988                 NDR_PULL_ALLOC(ndr, r->out.handle);
1989                 ZERO_STRUCTP(r->out.handle);
1990         }
1991         if (flags & NDR_OUT) {
1992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
1993                         NDR_PULL_ALLOC(ndr, r->out.handle);
1994                 }
1995                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
1996                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
1997                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
1998                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
1999                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2000         }
2001         return NT_STATUS_OK;
2002 }
2003
2004 _PUBLIC_ void ndr_print_svcctl_OpenServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenServiceW *r)
2005 {
2006         ndr_print_struct(ndr, name, "svcctl_OpenServiceW");
2007         ndr->depth++;
2008         if (flags & NDR_SET_VALUES) {
2009                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2010         }
2011         if (flags & NDR_IN) {
2012                 ndr_print_struct(ndr, "in", "svcctl_OpenServiceW");
2013                 ndr->depth++;
2014                 ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);
2015                 ndr->depth++;
2016                 ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);
2017                 ndr->depth--;
2018                 ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
2019                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
2020                 ndr->depth--;
2021         }
2022         if (flags & NDR_OUT) {
2023                 ndr_print_struct(ndr, "out", "svcctl_OpenServiceW");
2024                 ndr->depth++;
2025                 ndr_print_ptr(ndr, "handle", r->out.handle);
2026                 ndr->depth++;
2027                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
2028                 ndr->depth--;
2029                 ndr_print_WERROR(ndr, "result", r->out.result);
2030                 ndr->depth--;
2031         }
2032         ndr->depth--;
2033 }
2034
2035 NTSTATUS ndr_push_svcctl_QueryServiceConfigW(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfigW *r)
2036 {
2037         if (flags & NDR_IN) {
2038                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2039                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
2041         }
2042         if (flags & NDR_OUT) {
2043                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.buf_size));
2044                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
2046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2047         }
2048         return NT_STATUS_OK;
2049 }
2050
2051 NTSTATUS ndr_pull_svcctl_QueryServiceConfigW(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfigW *r)
2052 {
2053         TALLOC_CTX *_mem_save_handle_0;
2054         TALLOC_CTX *_mem_save_bytes_needed_0;
2055         if (flags & NDR_IN) {
2056                 ZERO_STRUCT(r->out);
2057
2058                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2059                         NDR_PULL_ALLOC(ndr, r->in.handle);
2060                 }
2061                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2062                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2063                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2064                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
2066                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
2067                 ZERO_STRUCTP(r->out.bytes_needed);
2068         }
2069         if (flags & NDR_OUT) {
2070                 NDR_PULL_ALLOC_N(ndr, r->out.query, r->in.buf_size);
2071                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.buf_size));
2072                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2073                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
2074                 }
2075                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
2076                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
2077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
2078                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
2079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2080         }
2081         return NT_STATUS_OK;
2082 }
2083
2084 _PUBLIC_ void ndr_print_svcctl_QueryServiceConfigW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfigW *r)
2085 {
2086         ndr_print_struct(ndr, name, "svcctl_QueryServiceConfigW");
2087         ndr->depth++;
2088         if (flags & NDR_SET_VALUES) {
2089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2090         }
2091         if (flags & NDR_IN) {
2092                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfigW");
2093                 ndr->depth++;
2094                 ndr_print_ptr(ndr, "handle", r->in.handle);
2095                 ndr->depth++;
2096                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2097                 ndr->depth--;
2098                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
2099                 ndr->depth--;
2100         }
2101         if (flags & NDR_OUT) {
2102                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfigW");
2103                 ndr->depth++;
2104                 ndr_print_array_uint8(ndr, "query", r->out.query, r->in.buf_size);
2105                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
2106                 ndr->depth++;
2107                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
2108                 ndr->depth--;
2109                 ndr_print_WERROR(ndr, "result", r->out.result);
2110                 ndr->depth--;
2111         }
2112         ndr->depth--;
2113 }
2114
2115 NTSTATUS ndr_push_svcctl_QueryServiceLockStatusW(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceLockStatusW *r)
2116 {
2117         if (flags & NDR_IN) {
2118                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2119                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
2121         }
2122         if (flags & NDR_OUT) {
2123                 if (r->out.lock_status == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2124                 NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
2125                 if (r->out.required_buf_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required_buf_size));
2127                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2128         }
2129         return NT_STATUS_OK;
2130 }
2131
2132 NTSTATUS ndr_pull_svcctl_QueryServiceLockStatusW(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceLockStatusW *r)
2133 {
2134         TALLOC_CTX *_mem_save_handle_0;
2135         TALLOC_CTX *_mem_save_lock_status_0;
2136         TALLOC_CTX *_mem_save_required_buf_size_0;
2137         if (flags & NDR_IN) {
2138                 ZERO_STRUCT(r->out);
2139
2140                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2141                         NDR_PULL_ALLOC(ndr, r->in.handle);
2142                 }
2143                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2144                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2145                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2146                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
2148                 NDR_PULL_ALLOC(ndr, r->out.lock_status);
2149                 ZERO_STRUCTP(r->out.lock_status);
2150                 NDR_PULL_ALLOC(ndr, r->out.required_buf_size);
2151                 ZERO_STRUCTP(r->out.required_buf_size);
2152         }
2153         if (flags & NDR_OUT) {
2154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2155                         NDR_PULL_ALLOC(ndr, r->out.lock_status);
2156                 }
2157                 _mem_save_lock_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2158                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lock_status, LIBNDR_FLAG_REF_ALLOC);
2159                 NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
2160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);
2161                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2162                         NDR_PULL_ALLOC(ndr, r->out.required_buf_size);
2163                 }
2164                 _mem_save_required_buf_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
2165                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required_buf_size, LIBNDR_FLAG_REF_ALLOC);
2166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required_buf_size));
2167                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_buf_size_0, LIBNDR_FLAG_REF_ALLOC);
2168                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2169         }
2170         return NT_STATUS_OK;
2171 }
2172
2173 _PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceLockStatusW *r)
2174 {
2175         ndr_print_struct(ndr, name, "svcctl_QueryServiceLockStatusW");
2176         ndr->depth++;
2177         if (flags & NDR_SET_VALUES) {
2178                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2179         }
2180         if (flags & NDR_IN) {
2181                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceLockStatusW");
2182                 ndr->depth++;
2183                 ndr_print_ptr(ndr, "handle", r->in.handle);
2184                 ndr->depth++;
2185                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2186                 ndr->depth--;
2187                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
2188                 ndr->depth--;
2189         }
2190         if (flags & NDR_OUT) {
2191                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceLockStatusW");
2192                 ndr->depth++;
2193                 ndr_print_ptr(ndr, "lock_status", r->out.lock_status);
2194                 ndr->depth++;
2195                 ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);
2196                 ndr->depth--;
2197                 ndr_print_ptr(ndr, "required_buf_size", r->out.required_buf_size);
2198                 ndr->depth++;
2199                 ndr_print_uint32(ndr, "required_buf_size", *r->out.required_buf_size);
2200                 ndr->depth--;
2201                 ndr_print_WERROR(ndr, "result", r->out.result);
2202                 ndr->depth--;
2203         }
2204         ndr->depth--;
2205 }
2206
2207 NTSTATUS ndr_push_svcctl_StartServiceW(struct ndr_push *ndr, int flags, const struct svcctl_StartServiceW *r)
2208 {
2209         if (flags & NDR_IN) {
2210                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2211                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));
2213                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));
2214                 if (r->in.Arguments) {
2215                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
2216                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
2218                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Arguments, ndr_charset_length(r->in.Arguments, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2219                 }
2220         }
2221         if (flags & NDR_OUT) {
2222                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2223         }
2224         return NT_STATUS_OK;
2225 }
2226
2227 NTSTATUS ndr_pull_svcctl_StartServiceW(struct ndr_pull *ndr, int flags, struct svcctl_StartServiceW *r)
2228 {
2229         uint32_t _ptr_Arguments;
2230         TALLOC_CTX *_mem_save_handle_0;
2231         TALLOC_CTX *_mem_save_Arguments_0;
2232         if (flags & NDR_IN) {
2233                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2234                         NDR_PULL_ALLOC(ndr, r->in.handle);
2235                 }
2236                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2237                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2238                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2239                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.NumArgs));
2241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Arguments));
2242                 if (_ptr_Arguments) {
2243                         NDR_PULL_ALLOC(ndr, r->in.Arguments);
2244                 } else {
2245                         r->in.Arguments = NULL;
2246                 }
2247                 if (r->in.Arguments) {
2248                         _mem_save_Arguments_0 = NDR_PULL_GET_MEM_CTX(ndr);
2249                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
2250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Arguments));
2251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Arguments));
2252                         if (ndr_get_array_length(ndr, &r->in.Arguments) > ndr_get_array_size(ndr, &r->in.Arguments)) {
2253                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.Arguments), ndr_get_array_length(ndr, &r->in.Arguments));
2254                         }
2255                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t)));
2256                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Arguments, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t), CH_UTF16));
2257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_0, 0);
2258                 }
2259         }
2260         if (flags & NDR_OUT) {
2261                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2262         }
2263         return NT_STATUS_OK;
2264 }
2265
2266 _PUBLIC_ void ndr_print_svcctl_StartServiceW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_StartServiceW *r)
2267 {
2268         ndr_print_struct(ndr, name, "svcctl_StartServiceW");
2269         ndr->depth++;
2270         if (flags & NDR_SET_VALUES) {
2271                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2272         }
2273         if (flags & NDR_IN) {
2274                 ndr_print_struct(ndr, "in", "svcctl_StartServiceW");
2275                 ndr->depth++;
2276                 ndr_print_ptr(ndr, "handle", r->in.handle);
2277                 ndr->depth++;
2278                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2279                 ndr->depth--;
2280                 ndr_print_uint32(ndr, "NumArgs", r->in.NumArgs);
2281                 ndr_print_ptr(ndr, "Arguments", r->in.Arguments);
2282                 ndr->depth++;
2283                 if (r->in.Arguments) {
2284                         ndr_print_string(ndr, "Arguments", r->in.Arguments);
2285                 }
2286                 ndr->depth--;
2287                 ndr->depth--;
2288         }
2289         if (flags & NDR_OUT) {
2290                 ndr_print_struct(ndr, "out", "svcctl_StartServiceW");
2291                 ndr->depth++;
2292                 ndr_print_WERROR(ndr, "result", r->out.result);
2293                 ndr->depth--;
2294         }
2295         ndr->depth--;
2296 }
2297
2298 NTSTATUS ndr_push_svcctl_GetServiceDisplayNameW(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceDisplayNameW *r)
2299 {
2300         if (flags & NDR_IN) {
2301                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2302                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2303                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
2304                 if (r->in.service_name) {
2305                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
2306                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2307                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
2308                         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));
2309                 }
2310                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
2311                 if (r->in.display_name_length) {
2312                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
2313                 }
2314         }
2315         if (flags & NDR_OUT) {
2316                 if (r->out.display_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2317                 if (*r->out.display_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2318                 NDR_CHECK(ndr_push_ref_ptr(ndr));
2319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
2320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
2322                 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));
2323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
2324                 if (r->out.display_name_length) {
2325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
2326                 }
2327                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2328         }
2329         return NT_STATUS_OK;
2330 }
2331
2332 NTSTATUS ndr_pull_svcctl_GetServiceDisplayNameW(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceDisplayNameW *r)
2333 {
2334         uint32_t _ptr_service_name;
2335         uint32_t _ptr_display_name;
2336         uint32_t _ptr_display_name_length;
2337         TALLOC_CTX *_mem_save_handle_0;
2338         TALLOC_CTX *_mem_save_service_name_0;
2339         TALLOC_CTX *_mem_save_display_name_0;
2340         TALLOC_CTX *_mem_save_display_name_length_0;
2341         if (flags & NDR_IN) {
2342                 ZERO_STRUCT(r->out);
2343
2344                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2345                         NDR_PULL_ALLOC(ndr, r->in.handle);
2346                 }
2347                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2348                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2349                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2351                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
2352                 if (_ptr_service_name) {
2353                         NDR_PULL_ALLOC(ndr, r->in.service_name);
2354                 } else {
2355                         r->in.service_name = NULL;
2356                 }
2357                 if (r->in.service_name) {
2358                         _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2359                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
2360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
2361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
2362                         if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {
2363                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.service_name), ndr_get_array_length(ndr, &r->in.service_name));
2364                         }
2365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));
2366                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));
2367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
2368                 }
2369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
2370                 if (_ptr_display_name_length) {
2371                         NDR_PULL_ALLOC(ndr, r->in.display_name_length);
2372                 } else {
2373                         r->in.display_name_length = NULL;
2374                 }
2375                 if (r->in.display_name_length) {
2376                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2377                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
2378                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
2379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
2380                 }
2381                 NDR_PULL_ALLOC(ndr, r->out.display_name);
2382                 ZERO_STRUCTP(r->out.display_name);
2383         }
2384         if (flags & NDR_OUT) {
2385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2386                         NDR_PULL_ALLOC(ndr, r->out.display_name);
2387                 }
2388                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2389                 NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name, LIBNDR_FLAG_REF_ALLOC);
2390                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_display_name));
2391                 NDR_CHECK(ndr_pull_array_size(ndr, r->out.display_name));
2392                 NDR_CHECK(ndr_pull_array_length(ndr, r->out.display_name));
2393                 if (ndr_get_array_length(ndr, r->out.display_name) > ndr_get_array_size(ndr, r->out.display_name)) {
2394                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.display_name), ndr_get_array_length(ndr, r->out.display_name));
2395                 }
2396                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t)));
2397                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.display_name, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t), CH_UTF16));
2398                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, LIBNDR_FLAG_REF_ALLOC);
2399                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
2400                 if (_ptr_display_name_length) {
2401                         NDR_PULL_ALLOC(ndr, r->out.display_name_length);
2402                 } else {
2403                         r->out.display_name_length = NULL;
2404                 }
2405                 if (r->out.display_name_length) {
2406                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2407                         NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
2408                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
2409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
2410                 }
2411                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2412         }
2413         return NT_STATUS_OK;
2414 }
2415
2416 _PUBLIC_ void ndr_print_svcctl_GetServiceDisplayNameW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceDisplayNameW *r)
2417 {
2418         ndr_print_struct(ndr, name, "svcctl_GetServiceDisplayNameW");
2419         ndr->depth++;
2420         if (flags & NDR_SET_VALUES) {
2421                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2422         }
2423         if (flags & NDR_IN) {
2424                 ndr_print_struct(ndr, "in", "svcctl_GetServiceDisplayNameW");
2425                 ndr->depth++;
2426                 ndr_print_ptr(ndr, "handle", r->in.handle);
2427                 ndr->depth++;
2428                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2429                 ndr->depth--;
2430                 ndr_print_ptr(ndr, "service_name", r->in.service_name);
2431                 ndr->depth++;
2432                 if (r->in.service_name) {
2433                         ndr_print_string(ndr, "service_name", r->in.service_name);
2434                 }
2435                 ndr->depth--;
2436                 ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
2437                 ndr->depth++;
2438                 if (r->in.display_name_length) {
2439                         ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
2440                 }
2441                 ndr->depth--;
2442                 ndr->depth--;
2443         }
2444         if (flags & NDR_OUT) {
2445                 ndr_print_struct(ndr, "out", "svcctl_GetServiceDisplayNameW");
2446                 ndr->depth++;
2447                 ndr_print_ptr(ndr, "display_name", r->out.display_name);
2448                 ndr->depth++;
2449                 ndr_print_ptr(ndr, "display_name", *r->out.display_name);
2450                 ndr->depth++;
2451                 ndr_print_string(ndr, "display_name", *r->out.display_name);
2452                 ndr->depth--;
2453                 ndr->depth--;
2454                 ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
2455                 ndr->depth++;
2456                 if (r->out.display_name_length) {
2457                         ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
2458                 }
2459                 ndr->depth--;
2460                 ndr_print_WERROR(ndr, "result", r->out.result);
2461                 ndr->depth--;
2462         }
2463         ndr->depth--;
2464 }
2465
2466 NTSTATUS ndr_push_svcctl_GetServiceKeyNameW(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceKeyNameW *r)
2467 {
2468         if (flags & NDR_IN) {
2469                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2470                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
2472                 if (r->in.service_name) {
2473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
2474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
2476                         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));
2477                 }
2478                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
2479                 if (r->in.display_name_length) {
2480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
2481                 }
2482         }
2483         if (flags & NDR_OUT) {
2484                 if (r->out.key_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2485                 if (*r->out.key_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2486                 NDR_CHECK(ndr_push_ref_ptr(ndr));
2487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
2488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
2490                 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));
2491                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
2492                 if (r->out.display_name_length) {
2493                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
2494                 }
2495                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2496         }
2497         return NT_STATUS_OK;
2498 }
2499
2500 NTSTATUS ndr_pull_svcctl_GetServiceKeyNameW(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceKeyNameW *r)
2501 {
2502         uint32_t _ptr_service_name;
2503         uint32_t _ptr_key_name;
2504         uint32_t _ptr_display_name_length;
2505         TALLOC_CTX *_mem_save_handle_0;
2506         TALLOC_CTX *_mem_save_service_name_0;
2507         TALLOC_CTX *_mem_save_key_name_0;
2508         TALLOC_CTX *_mem_save_display_name_length_0;
2509         if (flags & NDR_IN) {
2510                 ZERO_STRUCT(r->out);
2511
2512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2513                         NDR_PULL_ALLOC(ndr, r->in.handle);
2514                 }
2515                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2516                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2517                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2519                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
2520                 if (_ptr_service_name) {
2521                         NDR_PULL_ALLOC(ndr, r->in.service_name);
2522                 } else {
2523                         r->in.service_name = NULL;
2524                 }
2525                 if (r->in.service_name) {
2526                         _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2527                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
2528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
2529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
2530                         if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {
2531                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.service_name), ndr_get_array_length(ndr, &r->in.service_name));
2532                         }
2533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));
2534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));
2535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
2536                 }
2537                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
2538                 if (_ptr_display_name_length) {
2539                         NDR_PULL_ALLOC(ndr, r->in.display_name_length);
2540                 } else {
2541                         r->in.display_name_length = NULL;
2542                 }
2543                 if (r->in.display_name_length) {
2544                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2545                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
2546                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
2547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
2548                 }
2549                 NDR_PULL_ALLOC(ndr, r->out.key_name);
2550                 ZERO_STRUCTP(r->out.key_name);
2551         }
2552         if (flags & NDR_OUT) {
2553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2554                         NDR_PULL_ALLOC(ndr, r->out.key_name);
2555                 }
2556                 _mem_save_key_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2557                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_name, LIBNDR_FLAG_REF_ALLOC);
2558                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_key_name));
2559                 NDR_CHECK(ndr_pull_array_size(ndr, r->out.key_name));
2560                 NDR_CHECK(ndr_pull_array_length(ndr, r->out.key_name));
2561                 if (ndr_get_array_length(ndr, r->out.key_name) > ndr_get_array_size(ndr, r->out.key_name)) {
2562                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.key_name), ndr_get_array_length(ndr, r->out.key_name));
2563                 }
2564                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t)));
2565                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.key_name, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t), CH_UTF16));
2566                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_0, LIBNDR_FLAG_REF_ALLOC);
2567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
2568                 if (_ptr_display_name_length) {
2569                         NDR_PULL_ALLOC(ndr, r->out.display_name_length);
2570                 } else {
2571                         r->out.display_name_length = NULL;
2572                 }
2573                 if (r->out.display_name_length) {
2574                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
2575                         NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
2576                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
2577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
2578                 }
2579                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2580         }
2581         return NT_STATUS_OK;
2582 }
2583
2584 _PUBLIC_ void ndr_print_svcctl_GetServiceKeyNameW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceKeyNameW *r)
2585 {
2586         ndr_print_struct(ndr, name, "svcctl_GetServiceKeyNameW");
2587         ndr->depth++;
2588         if (flags & NDR_SET_VALUES) {
2589                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2590         }
2591         if (flags & NDR_IN) {
2592                 ndr_print_struct(ndr, "in", "svcctl_GetServiceKeyNameW");
2593                 ndr->depth++;
2594                 ndr_print_ptr(ndr, "handle", r->in.handle);
2595                 ndr->depth++;
2596                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2597                 ndr->depth--;
2598                 ndr_print_ptr(ndr, "service_name", r->in.service_name);
2599                 ndr->depth++;
2600                 if (r->in.service_name) {
2601                         ndr_print_string(ndr, "service_name", r->in.service_name);
2602                 }
2603                 ndr->depth--;
2604                 ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
2605                 ndr->depth++;
2606                 if (r->in.display_name_length) {
2607                         ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
2608                 }
2609                 ndr->depth--;
2610                 ndr->depth--;
2611         }
2612         if (flags & NDR_OUT) {
2613                 ndr_print_struct(ndr, "out", "svcctl_GetServiceKeyNameW");
2614                 ndr->depth++;
2615                 ndr_print_ptr(ndr, "key_name", r->out.key_name);
2616                 ndr->depth++;
2617                 ndr_print_ptr(ndr, "key_name", *r->out.key_name);
2618                 ndr->depth++;
2619                 ndr_print_string(ndr, "key_name", *r->out.key_name);
2620                 ndr->depth--;
2621                 ndr->depth--;
2622                 ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
2623                 ndr->depth++;
2624                 if (r->out.display_name_length) {
2625                         ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
2626                 }
2627                 ndr->depth--;
2628                 ndr_print_WERROR(ndr, "result", r->out.result);
2629                 ndr->depth--;
2630         }
2631         ndr->depth--;
2632 }
2633
2634 NTSTATUS ndr_push_svcctl_SCSetServiceBitsA(struct ndr_push *ndr, int flags, const struct svcctl_SCSetServiceBitsA *r)
2635 {
2636         if (flags & NDR_IN) {
2637                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2638                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bits));
2640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bitson));
2641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.immediate));
2642         }
2643         if (flags & NDR_OUT) {
2644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2645         }
2646         return NT_STATUS_OK;
2647 }
2648
2649 NTSTATUS ndr_pull_svcctl_SCSetServiceBitsA(struct ndr_pull *ndr, int flags, struct svcctl_SCSetServiceBitsA *r)
2650 {
2651         TALLOC_CTX *_mem_save_handle_0;
2652         if (flags & NDR_IN) {
2653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2654                         NDR_PULL_ALLOC(ndr, r->in.handle);
2655                 }
2656                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2657                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2658                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2659                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bits));
2661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bitson));
2662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.immediate));
2663         }
2664         if (flags & NDR_OUT) {
2665                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2666         }
2667         return NT_STATUS_OK;
2668 }
2669
2670 _PUBLIC_ void ndr_print_svcctl_SCSetServiceBitsA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSetServiceBitsA *r)
2671 {
2672         ndr_print_struct(ndr, name, "svcctl_SCSetServiceBitsA");
2673         ndr->depth++;
2674         if (flags & NDR_SET_VALUES) {
2675                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2676         }
2677         if (flags & NDR_IN) {
2678                 ndr_print_struct(ndr, "in", "svcctl_SCSetServiceBitsA");
2679                 ndr->depth++;
2680                 ndr_print_ptr(ndr, "handle", r->in.handle);
2681                 ndr->depth++;
2682                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2683                 ndr->depth--;
2684                 ndr_print_uint32(ndr, "bits", r->in.bits);
2685                 ndr_print_uint32(ndr, "bitson", r->in.bitson);
2686                 ndr_print_uint32(ndr, "immediate", r->in.immediate);
2687                 ndr->depth--;
2688         }
2689         if (flags & NDR_OUT) {
2690                 ndr_print_struct(ndr, "out", "svcctl_SCSetServiceBitsA");
2691                 ndr->depth++;
2692                 ndr_print_WERROR(ndr, "result", r->out.result);
2693                 ndr->depth--;
2694         }
2695         ndr->depth--;
2696 }
2697
2698 NTSTATUS ndr_push_svcctl_ChangeServiceConfigA(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfigA *r)
2699 {
2700         if (flags & NDR_IN) {
2701                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2702                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
2704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start));
2705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.error));
2706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
2707                 if (r->in.binary_path) {
2708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
2711                         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));
2712                 }
2713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.load_order_group));
2714                 if (r->in.load_order_group) {
2715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
2716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.load_order_group, CH_UTF16)));
2718                         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));
2719                 }
2720                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
2721                 if (r->in.dependencies) {
2722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
2723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
2725                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2726                 }
2727                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
2728                 if (r->in.service_start_name) {
2729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
2732                         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));
2733                 }
2734                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
2735                 if (r->in.password) {
2736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
2737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
2739                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2740                 }
2741                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name));
2742                 if (r->in.display_name) {
2743                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
2744                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.display_name, CH_UTF16)));
2746                         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));
2747                 }
2748         }
2749         if (flags & NDR_OUT) {
2750                 if (r->out.tag_id == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.tag_id));
2752                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
2753         }
2754         return NT_STATUS_OK;
2755 }
2756
2757 NTSTATUS ndr_pull_svcctl_ChangeServiceConfigA(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfigA *r)
2758 {
2759         uint32_t _ptr_binary_path;
2760         uint32_t _ptr_load_order_group;
2761         uint32_t _ptr_dependencies;
2762         uint32_t _ptr_service_start_name;
2763         uint32_t _ptr_password;
2764         uint32_t _ptr_display_name;
2765         TALLOC_CTX *_mem_save_handle_0;
2766         TALLOC_CTX *_mem_save_binary_path_0;
2767         TALLOC_CTX *_mem_save_load_order_group_0;
2768         TALLOC_CTX *_mem_save_tag_id_0;
2769         TALLOC_CTX *_mem_save_dependencies_0;
2770         TALLOC_CTX *_mem_save_service_start_name_0;
2771         TALLOC_CTX *_mem_save_password_0;
2772         TALLOC_CTX *_mem_save_display_name_0;
2773         if (flags & NDR_IN) {
2774                 ZERO_STRUCT(r->out);
2775
2776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2777                         NDR_PULL_ALLOC(ndr, r->in.handle);
2778                 }
2779                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
2780                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
2781                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
2783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
2784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start));
2785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.error));
2786                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
2787                 if (_ptr_binary_path) {
2788                         NDR_PULL_ALLOC(ndr, r->in.binary_path);
2789                 } else {
2790                         r->in.binary_path = NULL;
2791                 }
2792                 if (r->in.binary_path) {
2793                         _mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
2794                         NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);
2795                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
2796                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
2797                         if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {
2798                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));
2799                         }
2800                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));
2801                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));
2802                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);
2803                 }
2804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_load_order_group));
2805                 if (_ptr_load_order_group) {
2806                         NDR_PULL_ALLOC(ndr, r->in.load_order_group);
2807                 } else {
2808                         r->in.load_order_group = NULL;
2809                 }
2810                 if (r->in.load_order_group) {
2811                         _mem_save_load_order_group_0 = NDR_PULL_GET_MEM_CTX(ndr);
2812                         NDR_PULL_SET_MEM_CTX(ndr, r->in.load_order_group, 0);
2813                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.load_order_group));
2814                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.load_order_group));
2815                         if (ndr_get_array_length(ndr, &r->in.load_order_group) > ndr_get_array_size(ndr, &r->in.load_order_group)) {
2816                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.load_order_group), ndr_get_array_length(ndr, &r->in.load_order_group));
2817                         }
2818                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t)));
2819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.load_order_group, ndr_get_array_length(ndr, &r->in.load_order_group), sizeof(uint16_t), CH_UTF16));
2820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_load_order_group_0, 0);
2821                 }
2822                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
2823                 if (_ptr_dependencies) {
2824                         NDR_PULL_ALLOC(ndr, r->in.dependencies);
2825                 } else {
2826                         r->in.dependencies = NULL;
2827                 }
2828                 if (r->in.dependencies) {
2829                         _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
2830                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
2831                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
2832                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));
2833                         if (ndr_get_array_length(ndr, &r->in.dependencies) > ndr_get_array_size(ndr, &r->in.dependencies)) {
2834                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dependencies), ndr_get_array_length(ndr, &r->in.dependencies));
2835                         }
2836                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t)));
2837                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t), CH_UTF16));
2838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
2839                 }
2840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
2841                 if (_ptr_service_start_name) {
2842                         NDR_PULL_ALLOC(ndr, r->in.service_start_name);
2843                 } else {
2844                         r->in.service_start_name = NULL;
2845                 }
2846                 if (r->in.service_start_name) {
2847                         _mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2848                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
2849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
2850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
2851                         if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {
2852                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));
2853                         }
2854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));
2855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));
2856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
2857                 }
2858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
2859                 if (_ptr_password) {
2860                         NDR_PULL_ALLOC(ndr, r->in.password);
2861                 } else {
2862                         r->in.password = NULL;
2863                 }
2864                 if (r->in.password) {
2865                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
2866                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
2867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
2868                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
2869                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
2870                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.password), ndr_get_array_length(ndr, &r->in.password));
2871                         }
2872                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
2873                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
2874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
2875                 }
2876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
2877                 if (_ptr_display_name) {
2878                         NDR_PULL_ALLOC(ndr, r->in.display_name);
2879                 } else {
2880                         r->in.display_name = NULL;
2881                 }
2882                 if (r->in.display_name) {
2883                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2884                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name, 0);
2885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.display_name));
2886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.display_name));
2887                         if (ndr_get_array_length(ndr, &r->in.display_name) > ndr_get_array_size(ndr, &r->in.display_name)) {
2888                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.display_name), ndr_get_array_length(ndr, &r->in.display_name));
2889                         }
2890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t)));
2891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.display_name, ndr_get_array_length(ndr, &r->in.display_name), sizeof(uint16_t), CH_UTF16));
2892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
2893                 }
2894                 NDR_PULL_ALLOC(ndr, r->out.tag_id);
2895                 ZERO_STRUCTP(r->out.tag_id);
2896         }
2897         if (flags & NDR_OUT) {
2898                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
2899                         NDR_PULL_ALLOC(ndr, r->out.tag_id);
2900                 }
2901                 _mem_save_tag_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
2902                 NDR_PULL_SET_MEM_CTX(ndr, r->out.tag_id, LIBNDR_FLAG_REF_ALLOC);
2903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.tag_id));
2904                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_tag_id_0, LIBNDR_FLAG_REF_ALLOC);
2905                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
2906         }
2907         return NT_STATUS_OK;
2908 }
2909
2910 _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfigA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfigA *r)
2911 {
2912         ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfigA");
2913         ndr->depth++;
2914         if (flags & NDR_SET_VALUES) {
2915                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
2916         }
2917         if (flags & NDR_IN) {
2918                 ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfigA");
2919                 ndr->depth++;
2920                 ndr_print_ptr(ndr, "handle", r->in.handle);
2921                 ndr->depth++;
2922                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
2923                 ndr->depth--;
2924                 ndr_print_uint32(ndr, "type", r->in.type);
2925                 ndr_print_uint32(ndr, "start", r->in.start);
2926                 ndr_print_uint32(ndr, "error", r->in.error);
2927                 ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
2928                 ndr->depth++;
2929                 if (r->in.binary_path) {
2930                         ndr_print_string(ndr, "binary_path", r->in.binary_path);
2931                 }
2932                 ndr->depth--;
2933                 ndr_print_ptr(ndr, "load_order_group", r->in.load_order_group);
2934                 ndr->depth++;
2935                 if (r->in.load_order_group) {
2936                         ndr_print_string(ndr, "load_order_group", r->in.load_order_group);
2937                 }
2938                 ndr->depth--;
2939                 ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
2940                 ndr->depth++;
2941                 if (r->in.dependencies) {
2942                         ndr_print_string(ndr, "dependencies", r->in.dependencies);
2943                 }
2944                 ndr->depth--;
2945                 ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
2946                 ndr->depth++;
2947                 if (r->in.service_start_name) {
2948                         ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
2949                 }
2950                 ndr->depth--;
2951                 ndr_print_ptr(ndr, "password", r->in.password);
2952                 ndr->depth++;
2953                 if (r->in.password) {
2954                         ndr_print_string(ndr, "password", r->in.password);
2955                 }
2956                 ndr->depth--;
2957                 ndr_print_ptr(ndr, "display_name", r->in.display_name);
2958                 ndr->depth++;
2959                 if (r->in.display_name) {
2960                         ndr_print_string(ndr, "display_name", r->in.display_name);
2961                 }
2962                 ndr->depth--;
2963                 ndr->depth--;
2964         }
2965         if (flags & NDR_OUT) {
2966                 ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfigA");
2967                 ndr->depth++;
2968                 ndr_print_ptr(ndr, "tag_id", r->out.tag_id);
2969                 ndr->depth++;
2970                 ndr_print_uint32(ndr, "tag_id", *r->out.tag_id);
2971                 ndr->depth--;
2972                 ndr_print_WERROR(ndr, "result", r->out.result);
2973                 ndr->depth--;
2974         }
2975         ndr->depth--;
2976 }
2977
2978 NTSTATUS ndr_push_svcctl_CreateServiceA(struct ndr_push *ndr, int flags, const struct svcctl_CreateServiceA *r)
2979 {
2980         if (flags & NDR_IN) {
2981                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
2982                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
2983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));
2984                 if (r->in.ServiceName) {
2985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
2986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2987                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
2988                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2989                 }
2990                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DisplayName));
2991                 if (r->in.DisplayName) {
2992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
2993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
2994                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DisplayName, CH_UTF16)));
2995                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DisplayName, ndr_charset_length(r->in.DisplayName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
2996                 }
2997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.desired_access));
2998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
2999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.start_type));
3000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.error_control));
3001                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.binary_path));
3002                 if (r->in.binary_path) {
3003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
3004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.binary_path, CH_UTF16)));
3006                         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));
3007                 }
3008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.LoadOrderGroupKey));
3009                 if (r->in.LoadOrderGroupKey) {
3010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
3011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16)));
3013                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.LoadOrderGroupKey, ndr_charset_length(r->in.LoadOrderGroupKey, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3014                 }
3015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.dependencies));
3016                 if (r->in.dependencies) {
3017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
3018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.dependencies, CH_UTF16)));
3020                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.dependencies, ndr_charset_length(r->in.dependencies, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3021                 }
3022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_start_name));
3023                 if (r->in.service_start_name) {
3024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
3025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_start_name, CH_UTF16)));
3027                         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));
3028                 }
3029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.password));
3030                 if (r->in.password) {
3031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
3032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3033                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.password, CH_UTF16)));
3034                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.password, ndr_charset_length(r->in.password, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3035                 }
3036         }
3037         if (flags & NDR_OUT) {
3038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.TagId));
3039                 if (r->out.TagId) {
3040                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.TagId));
3041                 }
3042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3043         }
3044         return NT_STATUS_OK;
3045 }
3046
3047 NTSTATUS ndr_pull_svcctl_CreateServiceA(struct ndr_pull *ndr, int flags, struct svcctl_CreateServiceA *r)
3048 {
3049         uint32_t _ptr_ServiceName;
3050         uint32_t _ptr_DisplayName;
3051         uint32_t _ptr_binary_path;
3052         uint32_t _ptr_LoadOrderGroupKey;
3053         uint32_t _ptr_TagId;
3054         uint32_t _ptr_dependencies;
3055         uint32_t _ptr_service_start_name;
3056         uint32_t _ptr_password;
3057         TALLOC_CTX *_mem_save_handle_0;
3058         TALLOC_CTX *_mem_save_ServiceName_0;
3059         TALLOC_CTX *_mem_save_DisplayName_0;
3060         TALLOC_CTX *_mem_save_binary_path_0;
3061         TALLOC_CTX *_mem_save_LoadOrderGroupKey_0;
3062         TALLOC_CTX *_mem_save_TagId_0;
3063         TALLOC_CTX *_mem_save_dependencies_0;
3064         TALLOC_CTX *_mem_save_service_start_name_0;
3065         TALLOC_CTX *_mem_save_password_0;
3066         if (flags & NDR_IN) {
3067                 ZERO_STRUCT(r->out);
3068
3069                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3070                         NDR_PULL_ALLOC(ndr, r->in.handle);
3071                 }
3072                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3073                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3074                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3075                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ServiceName));
3077                 if (_ptr_ServiceName) {
3078                         NDR_PULL_ALLOC(ndr, r->in.ServiceName);
3079                 } else {
3080                         r->in.ServiceName = NULL;
3081                 }
3082                 if (r->in.ServiceName) {
3083                         _mem_save_ServiceName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3084                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ServiceName, 0);
3085                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
3086                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
3087                         if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {
3088                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));
3089                         }
3090                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));
3091                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));
3092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ServiceName_0, 0);
3093                 }
3094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DisplayName));
3095                 if (_ptr_DisplayName) {
3096                         NDR_PULL_ALLOC(ndr, r->in.DisplayName);
3097                 } else {
3098                         r->in.DisplayName = NULL;
3099                 }
3100                 if (r->in.DisplayName) {
3101                         _mem_save_DisplayName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3102                         NDR_PULL_SET_MEM_CTX(ndr, r->in.DisplayName, 0);
3103                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DisplayName));
3104                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DisplayName));
3105                         if (ndr_get_array_length(ndr, &r->in.DisplayName) > ndr_get_array_size(ndr, &r->in.DisplayName)) {
3106                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.DisplayName), ndr_get_array_length(ndr, &r->in.DisplayName));
3107                         }
3108                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t)));
3109                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DisplayName, ndr_get_array_length(ndr, &r->in.DisplayName), sizeof(uint16_t), CH_UTF16));
3110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DisplayName_0, 0);
3111                 }
3112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.desired_access));
3113                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
3114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.start_type));
3115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.error_control));
3116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_path));
3117                 if (_ptr_binary_path) {
3118                         NDR_PULL_ALLOC(ndr, r->in.binary_path);
3119                 } else {
3120                         r->in.binary_path = NULL;
3121                 }
3122                 if (r->in.binary_path) {
3123                         _mem_save_binary_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
3124                         NDR_PULL_SET_MEM_CTX(ndr, r->in.binary_path, 0);
3125                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.binary_path));
3126                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.binary_path));
3127                         if (ndr_get_array_length(ndr, &r->in.binary_path) > ndr_get_array_size(ndr, &r->in.binary_path)) {
3128                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.binary_path), ndr_get_array_length(ndr, &r->in.binary_path));
3129                         }
3130                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t)));
3131                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.binary_path, ndr_get_array_length(ndr, &r->in.binary_path), sizeof(uint16_t), CH_UTF16));
3132                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_path_0, 0);
3133                 }
3134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_LoadOrderGroupKey));
3135                 if (_ptr_LoadOrderGroupKey) {
3136                         NDR_PULL_ALLOC(ndr, r->in.LoadOrderGroupKey);
3137                 } else {
3138                         r->in.LoadOrderGroupKey = NULL;
3139                 }
3140                 if (r->in.LoadOrderGroupKey) {
3141                         _mem_save_LoadOrderGroupKey_0 = NDR_PULL_GET_MEM_CTX(ndr);
3142                         NDR_PULL_SET_MEM_CTX(ndr, r->in.LoadOrderGroupKey, 0);
3143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.LoadOrderGroupKey));
3144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.LoadOrderGroupKey));
3145                         if (ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey) > ndr_get_array_size(ndr, &r->in.LoadOrderGroupKey)) {
3146                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.LoadOrderGroupKey), ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey));
3147                         }
3148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t)));
3149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.LoadOrderGroupKey, ndr_get_array_length(ndr, &r->in.LoadOrderGroupKey), sizeof(uint16_t), CH_UTF16));
3150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_LoadOrderGroupKey_0, 0);
3151                 }
3152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependencies));
3153                 if (_ptr_dependencies) {
3154                         NDR_PULL_ALLOC(ndr, r->in.dependencies);
3155                 } else {
3156                         r->in.dependencies = NULL;
3157                 }
3158                 if (r->in.dependencies) {
3159                         _mem_save_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
3160                         NDR_PULL_SET_MEM_CTX(ndr, r->in.dependencies, 0);
3161                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.dependencies));
3162                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.dependencies));
3163                         if (ndr_get_array_length(ndr, &r->in.dependencies) > ndr_get_array_size(ndr, &r->in.dependencies)) {
3164                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.dependencies), ndr_get_array_length(ndr, &r->in.dependencies));
3165                         }
3166                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t)));
3167                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.dependencies, ndr_get_array_length(ndr, &r->in.dependencies), sizeof(uint16_t), CH_UTF16));
3168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependencies_0, 0);
3169                 }
3170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_start_name));
3171                 if (_ptr_service_start_name) {
3172                         NDR_PULL_ALLOC(ndr, r->in.service_start_name);
3173                 } else {
3174                         r->in.service_start_name = NULL;
3175                 }
3176                 if (r->in.service_start_name) {
3177                         _mem_save_service_start_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3178                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_start_name, 0);
3179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_start_name));
3180                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_start_name));
3181                         if (ndr_get_array_length(ndr, &r->in.service_start_name) > ndr_get_array_size(ndr, &r->in.service_start_name)) {
3182                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.service_start_name), ndr_get_array_length(ndr, &r->in.service_start_name));
3183                         }
3184                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t)));
3185                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_start_name, ndr_get_array_length(ndr, &r->in.service_start_name), sizeof(uint16_t), CH_UTF16));
3186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_start_name_0, 0);
3187                 }
3188                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_password));
3189                 if (_ptr_password) {
3190                         NDR_PULL_ALLOC(ndr, r->in.password);
3191                 } else {
3192                         r->in.password = NULL;
3193                 }
3194                 if (r->in.password) {
3195                         _mem_save_password_0 = NDR_PULL_GET_MEM_CTX(ndr);
3196                         NDR_PULL_SET_MEM_CTX(ndr, r->in.password, 0);
3197                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.password));
3198                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.password));
3199                         if (ndr_get_array_length(ndr, &r->in.password) > ndr_get_array_size(ndr, &r->in.password)) {
3200                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.password), ndr_get_array_length(ndr, &r->in.password));
3201                         }
3202                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t)));
3203                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.password, ndr_get_array_length(ndr, &r->in.password), sizeof(uint16_t), CH_UTF16));
3204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_password_0, 0);
3205                 }
3206         }
3207         if (flags & NDR_OUT) {
3208                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_TagId));
3209                 if (_ptr_TagId) {
3210                         NDR_PULL_ALLOC(ndr, r->out.TagId);
3211                 } else {
3212                         r->out.TagId = NULL;
3213                 }
3214                 if (r->out.TagId) {
3215                         _mem_save_TagId_0 = NDR_PULL_GET_MEM_CTX(ndr);
3216                         NDR_PULL_SET_MEM_CTX(ndr, r->out.TagId, 0);
3217                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.TagId));
3218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_TagId_0, 0);
3219                 }
3220                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3221         }
3222         return NT_STATUS_OK;
3223 }
3224
3225 _PUBLIC_ void ndr_print_svcctl_CreateServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_CreateServiceA *r)
3226 {
3227         ndr_print_struct(ndr, name, "svcctl_CreateServiceA");
3228         ndr->depth++;
3229         if (flags & NDR_SET_VALUES) {
3230                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3231         }
3232         if (flags & NDR_IN) {
3233                 ndr_print_struct(ndr, "in", "svcctl_CreateServiceA");
3234                 ndr->depth++;
3235                 ndr_print_ptr(ndr, "handle", r->in.handle);
3236                 ndr->depth++;
3237                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3238                 ndr->depth--;
3239                 ndr_print_ptr(ndr, "ServiceName", r->in.ServiceName);
3240                 ndr->depth++;
3241                 if (r->in.ServiceName) {
3242                         ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
3243                 }
3244                 ndr->depth--;
3245                 ndr_print_ptr(ndr, "DisplayName", r->in.DisplayName);
3246                 ndr->depth++;
3247                 if (r->in.DisplayName) {
3248                         ndr_print_string(ndr, "DisplayName", r->in.DisplayName);
3249                 }
3250                 ndr->depth--;
3251                 ndr_print_uint32(ndr, "desired_access", r->in.desired_access);
3252                 ndr_print_uint32(ndr, "type", r->in.type);
3253                 ndr_print_uint32(ndr, "start_type", r->in.start_type);
3254                 ndr_print_uint32(ndr, "error_control", r->in.error_control);
3255                 ndr_print_ptr(ndr, "binary_path", r->in.binary_path);
3256                 ndr->depth++;
3257                 if (r->in.binary_path) {
3258                         ndr_print_string(ndr, "binary_path", r->in.binary_path);
3259                 }
3260                 ndr->depth--;
3261                 ndr_print_ptr(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
3262                 ndr->depth++;
3263                 if (r->in.LoadOrderGroupKey) {
3264                         ndr_print_string(ndr, "LoadOrderGroupKey", r->in.LoadOrderGroupKey);
3265                 }
3266                 ndr->depth--;
3267                 ndr_print_ptr(ndr, "dependencies", r->in.dependencies);
3268                 ndr->depth++;
3269                 if (r->in.dependencies) {
3270                         ndr_print_string(ndr, "dependencies", r->in.dependencies);
3271                 }
3272                 ndr->depth--;
3273                 ndr_print_ptr(ndr, "service_start_name", r->in.service_start_name);
3274                 ndr->depth++;
3275                 if (r->in.service_start_name) {
3276                         ndr_print_string(ndr, "service_start_name", r->in.service_start_name);
3277                 }
3278                 ndr->depth--;
3279                 ndr_print_ptr(ndr, "password", r->in.password);
3280                 ndr->depth++;
3281                 if (r->in.password) {
3282                         ndr_print_string(ndr, "password", r->in.password);
3283                 }
3284                 ndr->depth--;
3285                 ndr->depth--;
3286         }
3287         if (flags & NDR_OUT) {
3288                 ndr_print_struct(ndr, "out", "svcctl_CreateServiceA");
3289                 ndr->depth++;
3290                 ndr_print_ptr(ndr, "TagId", r->out.TagId);
3291                 ndr->depth++;
3292                 if (r->out.TagId) {
3293                         ndr_print_uint32(ndr, "TagId", *r->out.TagId);
3294                 }
3295                 ndr->depth--;
3296                 ndr_print_WERROR(ndr, "result", r->out.result);
3297                 ndr->depth--;
3298         }
3299         ndr->depth--;
3300 }
3301
3302 NTSTATUS ndr_push_svcctl_EnumDependentServicesA(struct ndr_push *ndr, int flags, const struct svcctl_EnumDependentServicesA *r)
3303 {
3304         if (flags & NDR_IN) {
3305                 if (r->in.service == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3306                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.service));
3307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
3308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
3309         }
3310         if (flags & NDR_OUT) {
3311                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.service_status));
3312                 if (r->out.service_status) {
3313                         NDR_CHECK(ndr_push_ENUM_SERVICE_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
3314                 }
3315                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
3317                 if (r->out.services_returned == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
3319                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3320         }
3321         return NT_STATUS_OK;
3322 }
3323
3324 NTSTATUS ndr_pull_svcctl_EnumDependentServicesA(struct ndr_pull *ndr, int flags, struct svcctl_EnumDependentServicesA *r)
3325 {
3326         uint32_t _ptr_service_status;
3327         TALLOC_CTX *_mem_save_service_0;
3328         TALLOC_CTX *_mem_save_service_status_0;
3329         TALLOC_CTX *_mem_save_bytes_needed_0;
3330         TALLOC_CTX *_mem_save_services_returned_0;
3331         if (flags & NDR_IN) {
3332                 ZERO_STRUCT(r->out);
3333
3334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3335                         NDR_PULL_ALLOC(ndr, r->in.service);
3336                 }
3337                 _mem_save_service_0 = NDR_PULL_GET_MEM_CTX(ndr);
3338                 NDR_PULL_SET_MEM_CTX(ndr, r->in.service, LIBNDR_FLAG_REF_ALLOC);
3339                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.service));
3340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_0, LIBNDR_FLAG_REF_ALLOC);
3341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
3342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
3343                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
3344                 ZERO_STRUCTP(r->out.bytes_needed);
3345                 NDR_PULL_ALLOC(ndr, r->out.services_returned);
3346                 ZERO_STRUCTP(r->out.services_returned);
3347         }
3348         if (flags & NDR_OUT) {
3349                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_status));
3350                 if (_ptr_service_status) {
3351                         NDR_PULL_ALLOC(ndr, r->out.service_status);
3352                 } else {
3353                         r->out.service_status = NULL;
3354                 }
3355                 if (r->out.service_status) {
3356                         _mem_save_service_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3357                         NDR_PULL_SET_MEM_CTX(ndr, r->out.service_status, 0);
3358                         NDR_CHECK(ndr_pull_ENUM_SERVICE_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.service_status));
3359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_status_0, 0);
3360                 }
3361                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3362                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
3363                 }
3364                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3365                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
3366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
3367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
3368                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3369                         NDR_PULL_ALLOC(ndr, r->out.services_returned);
3370                 }
3371                 _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
3372                 NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
3373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
3374                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
3375                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3376         }
3377         return NT_STATUS_OK;
3378 }
3379
3380 _PUBLIC_ void ndr_print_svcctl_EnumDependentServicesA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumDependentServicesA *r)
3381 {
3382         ndr_print_struct(ndr, name, "svcctl_EnumDependentServicesA");
3383         ndr->depth++;
3384         if (flags & NDR_SET_VALUES) {
3385                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3386         }
3387         if (flags & NDR_IN) {
3388                 ndr_print_struct(ndr, "in", "svcctl_EnumDependentServicesA");
3389                 ndr->depth++;
3390                 ndr_print_ptr(ndr, "service", r->in.service);
3391                 ndr->depth++;
3392                 ndr_print_policy_handle(ndr, "service", r->in.service);
3393                 ndr->depth--;
3394                 ndr_print_uint32(ndr, "state", r->in.state);
3395                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
3396                 ndr->depth--;
3397         }
3398         if (flags & NDR_OUT) {
3399                 ndr_print_struct(ndr, "out", "svcctl_EnumDependentServicesA");
3400                 ndr->depth++;
3401                 ndr_print_ptr(ndr, "service_status", r->out.service_status);
3402                 ndr->depth++;
3403                 if (r->out.service_status) {
3404                         ndr_print_ENUM_SERVICE_STATUS(ndr, "service_status", r->out.service_status);
3405                 }
3406                 ndr->depth--;
3407                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
3408                 ndr->depth++;
3409                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
3410                 ndr->depth--;
3411                 ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
3412                 ndr->depth++;
3413                 ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
3414                 ndr->depth--;
3415                 ndr_print_WERROR(ndr, "result", r->out.result);
3416                 ndr->depth--;
3417         }
3418         ndr->depth--;
3419 }
3420
3421 NTSTATUS ndr_push_svcctl_EnumServicesStatusA(struct ndr_push *ndr, int flags, const struct svcctl_EnumServicesStatusA *r)
3422 {
3423         if (flags & NDR_IN) {
3424                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3425                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
3427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
3428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
3429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
3430                 if (r->in.resume_handle) {
3431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
3432                 }
3433         }
3434         if (flags & NDR_OUT) {
3435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
3436                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.service, r->in.buf_size));
3437                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
3439                 if (r->out.services_returned == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.services_returned));
3441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
3442                 if (r->out.resume_handle) {
3443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
3444                 }
3445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3446         }
3447         return NT_STATUS_OK;
3448 }
3449
3450 NTSTATUS ndr_pull_svcctl_EnumServicesStatusA(struct ndr_pull *ndr, int flags, struct svcctl_EnumServicesStatusA *r)
3451 {
3452         uint32_t _ptr_resume_handle;
3453         TALLOC_CTX *_mem_save_handle_0;
3454         TALLOC_CTX *_mem_save_bytes_needed_0;
3455         TALLOC_CTX *_mem_save_services_returned_0;
3456         TALLOC_CTX *_mem_save_resume_handle_0;
3457         if (flags & NDR_IN) {
3458                 ZERO_STRUCT(r->out);
3459
3460                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3461                         NDR_PULL_ALLOC(ndr, r->in.handle);
3462                 }
3463                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3464                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3465                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3466                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
3468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
3469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
3470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
3471                 if (_ptr_resume_handle) {
3472                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
3473                 } else {
3474                         r->in.resume_handle = NULL;
3475                 }
3476                 if (r->in.resume_handle) {
3477                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3478                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
3479                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
3480                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
3481                 }
3482                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
3483                 ZERO_STRUCTP(r->out.bytes_needed);
3484                 NDR_PULL_ALLOC(ndr, r->out.services_returned);
3485                 ZERO_STRUCTP(r->out.services_returned);
3486         }
3487         if (flags & NDR_OUT) {
3488                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.service));
3489                 NDR_PULL_ALLOC_N(ndr, r->out.service, ndr_get_array_size(ndr, &r->out.service));
3490                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.service, ndr_get_array_size(ndr, &r->out.service)));
3491                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3492                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
3493                 }
3494                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3495                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
3496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
3497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
3498                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3499                         NDR_PULL_ALLOC(ndr, r->out.services_returned);
3500                 }
3501                 _mem_save_services_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
3502                 NDR_PULL_SET_MEM_CTX(ndr, r->out.services_returned, LIBNDR_FLAG_REF_ALLOC);
3503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.services_returned));
3504                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_services_returned_0, LIBNDR_FLAG_REF_ALLOC);
3505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
3506                 if (_ptr_resume_handle) {
3507                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
3508                 } else {
3509                         r->out.resume_handle = NULL;
3510                 }
3511                 if (r->out.resume_handle) {
3512                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3513                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
3514                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
3515                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
3516                 }
3517                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3518                 if (r->out.service) {
3519                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.service, r->in.buf_size));
3520                 }
3521         }
3522         return NT_STATUS_OK;
3523 }
3524
3525 _PUBLIC_ void ndr_print_svcctl_EnumServicesStatusA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServicesStatusA *r)
3526 {
3527         ndr_print_struct(ndr, name, "svcctl_EnumServicesStatusA");
3528         ndr->depth++;
3529         if (flags & NDR_SET_VALUES) {
3530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3531         }
3532         if (flags & NDR_IN) {
3533                 ndr_print_struct(ndr, "in", "svcctl_EnumServicesStatusA");
3534                 ndr->depth++;
3535                 ndr_print_ptr(ndr, "handle", r->in.handle);
3536                 ndr->depth++;
3537                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3538                 ndr->depth--;
3539                 ndr_print_uint32(ndr, "type", r->in.type);
3540                 ndr_print_uint32(ndr, "state", r->in.state);
3541                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
3542                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
3543                 ndr->depth++;
3544                 if (r->in.resume_handle) {
3545                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
3546                 }
3547                 ndr->depth--;
3548                 ndr->depth--;
3549         }
3550         if (flags & NDR_OUT) {
3551                 ndr_print_struct(ndr, "out", "svcctl_EnumServicesStatusA");
3552                 ndr->depth++;
3553                 ndr_print_array_uint8(ndr, "service", r->out.service, r->in.buf_size);
3554                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
3555                 ndr->depth++;
3556                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
3557                 ndr->depth--;
3558                 ndr_print_ptr(ndr, "services_returned", r->out.services_returned);
3559                 ndr->depth++;
3560                 ndr_print_uint32(ndr, "services_returned", *r->out.services_returned);
3561                 ndr->depth--;
3562                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
3563                 ndr->depth++;
3564                 if (r->out.resume_handle) {
3565                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
3566                 }
3567                 ndr->depth--;
3568                 ndr_print_WERROR(ndr, "result", r->out.result);
3569                 ndr->depth--;
3570         }
3571         ndr->depth--;
3572 }
3573
3574 NTSTATUS ndr_push_svcctl_OpenSCManagerA(struct ndr_push *ndr, int flags, const struct svcctl_OpenSCManagerA *r)
3575 {
3576         if (flags & NDR_IN) {
3577                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.MachineName));
3578                 if (r->in.MachineName) {
3579                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
3580                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3581                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.MachineName, CH_UTF16)));
3582                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.MachineName, ndr_charset_length(r->in.MachineName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3583                 }
3584                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.DatabaseName));
3585                 if (r->in.DatabaseName) {
3586                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
3587                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.DatabaseName, CH_UTF16)));
3589                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.DatabaseName, ndr_charset_length(r->in.DatabaseName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3590                 }
3591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
3592         }
3593         if (flags & NDR_OUT) {
3594                 if (r->out.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3595                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3596                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3597         }
3598         return NT_STATUS_OK;
3599 }
3600
3601 NTSTATUS ndr_pull_svcctl_OpenSCManagerA(struct ndr_pull *ndr, int flags, struct svcctl_OpenSCManagerA *r)
3602 {
3603         uint32_t _ptr_MachineName;
3604         uint32_t _ptr_DatabaseName;
3605         TALLOC_CTX *_mem_save_MachineName_0;
3606         TALLOC_CTX *_mem_save_DatabaseName_0;
3607         TALLOC_CTX *_mem_save_handle_0;
3608         if (flags & NDR_IN) {
3609                 ZERO_STRUCT(r->out);
3610
3611                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_MachineName));
3612                 if (_ptr_MachineName) {
3613                         NDR_PULL_ALLOC(ndr, r->in.MachineName);
3614                 } else {
3615                         r->in.MachineName = NULL;
3616                 }
3617                 if (r->in.MachineName) {
3618                         _mem_save_MachineName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3619                         NDR_PULL_SET_MEM_CTX(ndr, r->in.MachineName, 0);
3620                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.MachineName));
3621                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.MachineName));
3622                         if (ndr_get_array_length(ndr, &r->in.MachineName) > ndr_get_array_size(ndr, &r->in.MachineName)) {
3623                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.MachineName), ndr_get_array_length(ndr, &r->in.MachineName));
3624                         }
3625                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t)));
3626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.MachineName, ndr_get_array_length(ndr, &r->in.MachineName), sizeof(uint16_t), CH_UTF16));
3627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_MachineName_0, 0);
3628                 }
3629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_DatabaseName));
3630                 if (_ptr_DatabaseName) {
3631                         NDR_PULL_ALLOC(ndr, r->in.DatabaseName);
3632                 } else {
3633                         r->in.DatabaseName = NULL;
3634                 }
3635                 if (r->in.DatabaseName) {
3636                         _mem_save_DatabaseName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3637                         NDR_PULL_SET_MEM_CTX(ndr, r->in.DatabaseName, 0);
3638                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.DatabaseName));
3639                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.DatabaseName));
3640                         if (ndr_get_array_length(ndr, &r->in.DatabaseName) > ndr_get_array_size(ndr, &r->in.DatabaseName)) {
3641                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.DatabaseName), ndr_get_array_length(ndr, &r->in.DatabaseName));
3642                         }
3643                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t)));
3644                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.DatabaseName, ndr_get_array_length(ndr, &r->in.DatabaseName), sizeof(uint16_t), CH_UTF16));
3645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_DatabaseName_0, 0);
3646                 }
3647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
3648                 NDR_PULL_ALLOC(ndr, r->out.handle);
3649                 ZERO_STRUCTP(r->out.handle);
3650         }
3651         if (flags & NDR_OUT) {
3652                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3653                         NDR_PULL_ALLOC(ndr, r->out.handle);
3654                 }
3655                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3656                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
3657                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.handle));
3658                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3659                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3660         }
3661         return NT_STATUS_OK;
3662 }
3663
3664 _PUBLIC_ void ndr_print_svcctl_OpenSCManagerA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenSCManagerA *r)
3665 {
3666         ndr_print_struct(ndr, name, "svcctl_OpenSCManagerA");
3667         ndr->depth++;
3668         if (flags & NDR_SET_VALUES) {
3669                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3670         }
3671         if (flags & NDR_IN) {
3672                 ndr_print_struct(ndr, "in", "svcctl_OpenSCManagerA");
3673                 ndr->depth++;
3674                 ndr_print_ptr(ndr, "MachineName", r->in.MachineName);
3675                 ndr->depth++;
3676                 if (r->in.MachineName) {
3677                         ndr_print_string(ndr, "MachineName", r->in.MachineName);
3678                 }
3679                 ndr->depth--;
3680                 ndr_print_ptr(ndr, "DatabaseName", r->in.DatabaseName);
3681                 ndr->depth++;
3682                 if (r->in.DatabaseName) {
3683                         ndr_print_string(ndr, "DatabaseName", r->in.DatabaseName);
3684                 }
3685                 ndr->depth--;
3686                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
3687                 ndr->depth--;
3688         }
3689         if (flags & NDR_OUT) {
3690                 ndr_print_struct(ndr, "out", "svcctl_OpenSCManagerA");
3691                 ndr->depth++;
3692                 ndr_print_ptr(ndr, "handle", r->out.handle);
3693                 ndr->depth++;
3694                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
3695                 ndr->depth--;
3696                 ndr_print_WERROR(ndr, "result", r->out.result);
3697                 ndr->depth--;
3698         }
3699         ndr->depth--;
3700 }
3701
3702 NTSTATUS ndr_push_svcctl_OpenServiceA(struct ndr_push *ndr, int flags, const struct svcctl_OpenServiceA *r)
3703 {
3704         if (flags & NDR_IN) {
3705                 if (r->in.scmanager_handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3706                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager_handle));
3707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ServiceName));
3708                 if (r->in.ServiceName) {
3709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
3710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.ServiceName, CH_UTF16)));
3712                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.ServiceName, ndr_charset_length(r->in.ServiceName, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3713                 }
3714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
3715         }
3716         if (flags & NDR_OUT) {
3717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3718         }
3719         return NT_STATUS_OK;
3720 }
3721
3722 NTSTATUS ndr_pull_svcctl_OpenServiceA(struct ndr_pull *ndr, int flags, struct svcctl_OpenServiceA *r)
3723 {
3724         uint32_t _ptr_ServiceName;
3725         TALLOC_CTX *_mem_save_scmanager_handle_0;
3726         TALLOC_CTX *_mem_save_ServiceName_0;
3727         if (flags & NDR_IN) {
3728                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3729                         NDR_PULL_ALLOC(ndr, r->in.scmanager_handle);
3730                 }
3731                 _mem_save_scmanager_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3732                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager_handle, LIBNDR_FLAG_REF_ALLOC);
3733                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager_handle));
3734                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_handle_0, LIBNDR_FLAG_REF_ALLOC);
3735                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ServiceName));
3736                 if (_ptr_ServiceName) {
3737                         NDR_PULL_ALLOC(ndr, r->in.ServiceName);
3738                 } else {
3739                         r->in.ServiceName = NULL;
3740                 }
3741                 if (r->in.ServiceName) {
3742                         _mem_save_ServiceName_0 = NDR_PULL_GET_MEM_CTX(ndr);
3743                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ServiceName, 0);
3744                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.ServiceName));
3745                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.ServiceName));
3746                         if (ndr_get_array_length(ndr, &r->in.ServiceName) > ndr_get_array_size(ndr, &r->in.ServiceName)) {
3747                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.ServiceName), ndr_get_array_length(ndr, &r->in.ServiceName));
3748                         }
3749                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t)));
3750                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.ServiceName, ndr_get_array_length(ndr, &r->in.ServiceName), sizeof(uint16_t), CH_UTF16));
3751                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ServiceName_0, 0);
3752                 }
3753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
3754         }
3755         if (flags & NDR_OUT) {
3756                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3757         }
3758         return NT_STATUS_OK;
3759 }
3760
3761 _PUBLIC_ void ndr_print_svcctl_OpenServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_OpenServiceA *r)
3762 {
3763         ndr_print_struct(ndr, name, "svcctl_OpenServiceA");
3764         ndr->depth++;
3765         if (flags & NDR_SET_VALUES) {
3766                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3767         }
3768         if (flags & NDR_IN) {
3769                 ndr_print_struct(ndr, "in", "svcctl_OpenServiceA");
3770                 ndr->depth++;
3771                 ndr_print_ptr(ndr, "scmanager_handle", r->in.scmanager_handle);
3772                 ndr->depth++;
3773                 ndr_print_policy_handle(ndr, "scmanager_handle", r->in.scmanager_handle);
3774                 ndr->depth--;
3775                 ndr_print_ptr(ndr, "ServiceName", r->in.ServiceName);
3776                 ndr->depth++;
3777                 if (r->in.ServiceName) {
3778                         ndr_print_string(ndr, "ServiceName", r->in.ServiceName);
3779                 }
3780                 ndr->depth--;
3781                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
3782                 ndr->depth--;
3783         }
3784         if (flags & NDR_OUT) {
3785                 ndr_print_struct(ndr, "out", "svcctl_OpenServiceA");
3786                 ndr->depth++;
3787                 ndr_print_WERROR(ndr, "result", r->out.result);
3788                 ndr->depth--;
3789         }
3790         ndr->depth--;
3791 }
3792
3793 NTSTATUS ndr_push_svcctl_QueryServiceConfigA(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfigA *r)
3794 {
3795         if (flags & NDR_IN) {
3796                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3797                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
3799         }
3800         if (flags & NDR_OUT) {
3801                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.buf_size));
3802                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
3804                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3805         }
3806         return NT_STATUS_OK;
3807 }
3808
3809 NTSTATUS ndr_pull_svcctl_QueryServiceConfigA(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfigA *r)
3810 {
3811         TALLOC_CTX *_mem_save_handle_0;
3812         TALLOC_CTX *_mem_save_bytes_needed_0;
3813         if (flags & NDR_IN) {
3814                 ZERO_STRUCT(r->out);
3815
3816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3817                         NDR_PULL_ALLOC(ndr, r->in.handle);
3818                 }
3819                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3820                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3821                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
3824                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
3825                 ZERO_STRUCTP(r->out.bytes_needed);
3826         }
3827         if (flags & NDR_OUT) {
3828                 NDR_PULL_ALLOC_N(ndr, r->out.query, r->in.buf_size);
3829                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.query, r->in.buf_size));
3830                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3831                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
3832                 }
3833                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
3834                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
3835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
3836                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
3837                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3838         }
3839         return NT_STATUS_OK;
3840 }
3841
3842 _PUBLIC_ void ndr_print_svcctl_QueryServiceConfigA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfigA *r)
3843 {
3844         ndr_print_struct(ndr, name, "svcctl_QueryServiceConfigA");
3845         ndr->depth++;
3846         if (flags & NDR_SET_VALUES) {
3847                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3848         }
3849         if (flags & NDR_IN) {
3850                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfigA");
3851                 ndr->depth++;
3852                 ndr_print_ptr(ndr, "handle", r->in.handle);
3853                 ndr->depth++;
3854                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3855                 ndr->depth--;
3856                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
3857                 ndr->depth--;
3858         }
3859         if (flags & NDR_OUT) {
3860                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfigA");
3861                 ndr->depth++;
3862                 ndr_print_array_uint8(ndr, "query", r->out.query, r->in.buf_size);
3863                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
3864                 ndr->depth++;
3865                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
3866                 ndr->depth--;
3867                 ndr_print_WERROR(ndr, "result", r->out.result);
3868                 ndr->depth--;
3869         }
3870         ndr->depth--;
3871 }
3872
3873 NTSTATUS ndr_push_svcctl_QueryServiceLockStatusA(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceLockStatusA *r)
3874 {
3875         if (flags & NDR_IN) {
3876                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3877                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
3879         }
3880         if (flags & NDR_OUT) {
3881                 if (r->out.lock_status == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3882                 NDR_CHECK(ndr_push_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
3883                 if (r->out.required_buf_size == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required_buf_size));
3885                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3886         }
3887         return NT_STATUS_OK;
3888 }
3889
3890 NTSTATUS ndr_pull_svcctl_QueryServiceLockStatusA(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceLockStatusA *r)
3891 {
3892         TALLOC_CTX *_mem_save_handle_0;
3893         TALLOC_CTX *_mem_save_lock_status_0;
3894         TALLOC_CTX *_mem_save_required_buf_size_0;
3895         if (flags & NDR_IN) {
3896                 ZERO_STRUCT(r->out);
3897
3898                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3899                         NDR_PULL_ALLOC(ndr, r->in.handle);
3900                 }
3901                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3902                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3903                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3904                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
3906                 NDR_PULL_ALLOC(ndr, r->out.lock_status);
3907                 ZERO_STRUCTP(r->out.lock_status);
3908                 NDR_PULL_ALLOC(ndr, r->out.required_buf_size);
3909                 ZERO_STRUCTP(r->out.required_buf_size);
3910         }
3911         if (flags & NDR_OUT) {
3912                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3913                         NDR_PULL_ALLOC(ndr, r->out.lock_status);
3914                 }
3915                 _mem_save_lock_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3916                 NDR_PULL_SET_MEM_CTX(ndr, r->out.lock_status, LIBNDR_FLAG_REF_ALLOC);
3917                 NDR_CHECK(ndr_pull_SERVICE_LOCK_STATUS(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.lock_status));
3918                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_lock_status_0, LIBNDR_FLAG_REF_ALLOC);
3919                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3920                         NDR_PULL_ALLOC(ndr, r->out.required_buf_size);
3921                 }
3922                 _mem_save_required_buf_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
3923                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required_buf_size, LIBNDR_FLAG_REF_ALLOC);
3924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required_buf_size));
3925                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_buf_size_0, LIBNDR_FLAG_REF_ALLOC);
3926                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
3927         }
3928         return NT_STATUS_OK;
3929 }
3930
3931 _PUBLIC_ void ndr_print_svcctl_QueryServiceLockStatusA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceLockStatusA *r)
3932 {
3933         ndr_print_struct(ndr, name, "svcctl_QueryServiceLockStatusA");
3934         ndr->depth++;
3935         if (flags & NDR_SET_VALUES) {
3936                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
3937         }
3938         if (flags & NDR_IN) {
3939                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceLockStatusA");
3940                 ndr->depth++;
3941                 ndr_print_ptr(ndr, "handle", r->in.handle);
3942                 ndr->depth++;
3943                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
3944                 ndr->depth--;
3945                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
3946                 ndr->depth--;
3947         }
3948         if (flags & NDR_OUT) {
3949                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceLockStatusA");
3950                 ndr->depth++;
3951                 ndr_print_ptr(ndr, "lock_status", r->out.lock_status);
3952                 ndr->depth++;
3953                 ndr_print_SERVICE_LOCK_STATUS(ndr, "lock_status", r->out.lock_status);
3954                 ndr->depth--;
3955                 ndr_print_ptr(ndr, "required_buf_size", r->out.required_buf_size);
3956                 ndr->depth++;
3957                 ndr_print_uint32(ndr, "required_buf_size", *r->out.required_buf_size);
3958                 ndr->depth--;
3959                 ndr_print_WERROR(ndr, "result", r->out.result);
3960                 ndr->depth--;
3961         }
3962         ndr->depth--;
3963 }
3964
3965 NTSTATUS ndr_push_svcctl_StartServiceA(struct ndr_push *ndr, int flags, const struct svcctl_StartServiceA *r)
3966 {
3967         if (flags & NDR_IN) {
3968                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
3969                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.NumArgs));
3971                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.Arguments));
3972                 if (r->in.Arguments) {
3973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
3974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
3975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.Arguments, CH_UTF16)));
3976                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.Arguments, ndr_charset_length(r->in.Arguments, CH_UTF16), sizeof(uint16_t), CH_UTF16));
3977                 }
3978         }
3979         if (flags & NDR_OUT) {
3980                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
3981         }
3982         return NT_STATUS_OK;
3983 }
3984
3985 NTSTATUS ndr_pull_svcctl_StartServiceA(struct ndr_pull *ndr, int flags, struct svcctl_StartServiceA *r)
3986 {
3987         uint32_t _ptr_Arguments;
3988         TALLOC_CTX *_mem_save_handle_0;
3989         TALLOC_CTX *_mem_save_Arguments_0;
3990         if (flags & NDR_IN) {
3991                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
3992                         NDR_PULL_ALLOC(ndr, r->in.handle);
3993                 }
3994                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
3995                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
3996                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
3997                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
3998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.NumArgs));
3999                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_Arguments));
4000                 if (_ptr_Arguments) {
4001                         NDR_PULL_ALLOC(ndr, r->in.Arguments);
4002                 } else {
4003                         r->in.Arguments = NULL;
4004                 }
4005                 if (r->in.Arguments) {
4006                         _mem_save_Arguments_0 = NDR_PULL_GET_MEM_CTX(ndr);
4007                         NDR_PULL_SET_MEM_CTX(ndr, r->in.Arguments, 0);
4008                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.Arguments));
4009                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.Arguments));
4010                         if (ndr_get_array_length(ndr, &r->in.Arguments) > ndr_get_array_size(ndr, &r->in.Arguments)) {
4011                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.Arguments), ndr_get_array_length(ndr, &r->in.Arguments));
4012                         }
4013                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t)));
4014                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.Arguments, ndr_get_array_length(ndr, &r->in.Arguments), sizeof(uint16_t), CH_UTF16));
4015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Arguments_0, 0);
4016                 }
4017         }
4018         if (flags & NDR_OUT) {
4019                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4020         }
4021         return NT_STATUS_OK;
4022 }
4023
4024 _PUBLIC_ void ndr_print_svcctl_StartServiceA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_StartServiceA *r)
4025 {
4026         ndr_print_struct(ndr, name, "svcctl_StartServiceA");
4027         ndr->depth++;
4028         if (flags & NDR_SET_VALUES) {
4029                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4030         }
4031         if (flags & NDR_IN) {
4032                 ndr_print_struct(ndr, "in", "svcctl_StartServiceA");
4033                 ndr->depth++;
4034                 ndr_print_ptr(ndr, "handle", r->in.handle);
4035                 ndr->depth++;
4036                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4037                 ndr->depth--;
4038                 ndr_print_uint32(ndr, "NumArgs", r->in.NumArgs);
4039                 ndr_print_ptr(ndr, "Arguments", r->in.Arguments);
4040                 ndr->depth++;
4041                 if (r->in.Arguments) {
4042                         ndr_print_string(ndr, "Arguments", r->in.Arguments);
4043                 }
4044                 ndr->depth--;
4045                 ndr->depth--;
4046         }
4047         if (flags & NDR_OUT) {
4048                 ndr_print_struct(ndr, "out", "svcctl_StartServiceA");
4049                 ndr->depth++;
4050                 ndr_print_WERROR(ndr, "result", r->out.result);
4051                 ndr->depth--;
4052         }
4053         ndr->depth--;
4054 }
4055
4056 NTSTATUS ndr_push_svcctl_GetServiceDisplayNameA(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceDisplayNameA *r)
4057 {
4058         if (flags & NDR_IN) {
4059                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4060                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
4062                 if (r->in.service_name) {
4063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
4064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
4066                         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));
4067                 }
4068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
4069                 if (r->in.display_name_length) {
4070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
4071                 }
4072         }
4073         if (flags & NDR_OUT) {
4074                 if (r->out.display_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4075                 if (*r->out.display_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4076                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
4078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.display_name, CH_UTF16)));
4080                 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));
4081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
4082                 if (r->out.display_name_length) {
4083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
4084                 }
4085                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4086         }
4087         return NT_STATUS_OK;
4088 }
4089
4090 NTSTATUS ndr_pull_svcctl_GetServiceDisplayNameA(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceDisplayNameA *r)
4091 {
4092         uint32_t _ptr_service_name;
4093         uint32_t _ptr_display_name;
4094         uint32_t _ptr_display_name_length;
4095         TALLOC_CTX *_mem_save_handle_0;
4096         TALLOC_CTX *_mem_save_service_name_0;
4097         TALLOC_CTX *_mem_save_display_name_0;
4098         TALLOC_CTX *_mem_save_display_name_length_0;
4099         if (flags & NDR_IN) {
4100                 ZERO_STRUCT(r->out);
4101
4102                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4103                         NDR_PULL_ALLOC(ndr, r->in.handle);
4104                 }
4105                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4106                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4107                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4108                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
4110                 if (_ptr_service_name) {
4111                         NDR_PULL_ALLOC(ndr, r->in.service_name);
4112                 } else {
4113                         r->in.service_name = NULL;
4114                 }
4115                 if (r->in.service_name) {
4116                         _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4117                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
4118                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
4119                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
4120                         if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {
4121                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.service_name), ndr_get_array_length(ndr, &r->in.service_name));
4122                         }
4123                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));
4124                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));
4125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
4126                 }
4127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
4128                 if (_ptr_display_name_length) {
4129                         NDR_PULL_ALLOC(ndr, r->in.display_name_length);
4130                 } else {
4131                         r->in.display_name_length = NULL;
4132                 }
4133                 if (r->in.display_name_length) {
4134                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
4135                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
4136                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
4137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
4138                 }
4139                 NDR_PULL_ALLOC(ndr, r->out.display_name);
4140                 ZERO_STRUCTP(r->out.display_name);
4141         }
4142         if (flags & NDR_OUT) {
4143                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4144                         NDR_PULL_ALLOC(ndr, r->out.display_name);
4145                 }
4146                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4147                 NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name, LIBNDR_FLAG_REF_ALLOC);
4148                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_display_name));
4149                 NDR_CHECK(ndr_pull_array_size(ndr, r->out.display_name));
4150                 NDR_CHECK(ndr_pull_array_length(ndr, r->out.display_name));
4151                 if (ndr_get_array_length(ndr, r->out.display_name) > ndr_get_array_size(ndr, r->out.display_name)) {
4152                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.display_name), ndr_get_array_length(ndr, r->out.display_name));
4153                 }
4154                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t)));
4155                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.display_name, ndr_get_array_length(ndr, r->out.display_name), sizeof(uint16_t), CH_UTF16));
4156                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, LIBNDR_FLAG_REF_ALLOC);
4157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
4158                 if (_ptr_display_name_length) {
4159                         NDR_PULL_ALLOC(ndr, r->out.display_name_length);
4160                 } else {
4161                         r->out.display_name_length = NULL;
4162                 }
4163                 if (r->out.display_name_length) {
4164                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
4165                         NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
4166                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
4167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
4168                 }
4169                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4170         }
4171         return NT_STATUS_OK;
4172 }
4173
4174 _PUBLIC_ void ndr_print_svcctl_GetServiceDisplayNameA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceDisplayNameA *r)
4175 {
4176         ndr_print_struct(ndr, name, "svcctl_GetServiceDisplayNameA");
4177         ndr->depth++;
4178         if (flags & NDR_SET_VALUES) {
4179                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4180         }
4181         if (flags & NDR_IN) {
4182                 ndr_print_struct(ndr, "in", "svcctl_GetServiceDisplayNameA");
4183                 ndr->depth++;
4184                 ndr_print_ptr(ndr, "handle", r->in.handle);
4185                 ndr->depth++;
4186                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4187                 ndr->depth--;
4188                 ndr_print_ptr(ndr, "service_name", r->in.service_name);
4189                 ndr->depth++;
4190                 if (r->in.service_name) {
4191                         ndr_print_string(ndr, "service_name", r->in.service_name);
4192                 }
4193                 ndr->depth--;
4194                 ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
4195                 ndr->depth++;
4196                 if (r->in.display_name_length) {
4197                         ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
4198                 }
4199                 ndr->depth--;
4200                 ndr->depth--;
4201         }
4202         if (flags & NDR_OUT) {
4203                 ndr_print_struct(ndr, "out", "svcctl_GetServiceDisplayNameA");
4204                 ndr->depth++;
4205                 ndr_print_ptr(ndr, "display_name", r->out.display_name);
4206                 ndr->depth++;
4207                 ndr_print_ptr(ndr, "display_name", *r->out.display_name);
4208                 ndr->depth++;
4209                 ndr_print_string(ndr, "display_name", *r->out.display_name);
4210                 ndr->depth--;
4211                 ndr->depth--;
4212                 ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
4213                 ndr->depth++;
4214                 if (r->out.display_name_length) {
4215                         ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
4216                 }
4217                 ndr->depth--;
4218                 ndr_print_WERROR(ndr, "result", r->out.result);
4219                 ndr->depth--;
4220         }
4221         ndr->depth--;
4222 }
4223
4224 NTSTATUS ndr_push_svcctl_GetServiceKeyNameA(struct ndr_push *ndr, int flags, const struct svcctl_GetServiceKeyNameA *r)
4225 {
4226         if (flags & NDR_IN) {
4227                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4228                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4229                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.service_name));
4230                 if (r->in.service_name) {
4231                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
4232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4233                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.service_name, CH_UTF16)));
4234                         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));
4235                 }
4236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.display_name_length));
4237                 if (r->in.display_name_length) {
4238                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.display_name_length));
4239                 }
4240         }
4241         if (flags & NDR_OUT) {
4242                 if (r->out.key_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4243                 if (*r->out.key_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4244                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
4246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.key_name, CH_UTF16)));
4248                 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));
4249                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.display_name_length));
4250                 if (r->out.display_name_length) {
4251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.display_name_length));
4252                 }
4253                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4254         }
4255         return NT_STATUS_OK;
4256 }
4257
4258 NTSTATUS ndr_pull_svcctl_GetServiceKeyNameA(struct ndr_pull *ndr, int flags, struct svcctl_GetServiceKeyNameA *r)
4259 {
4260         uint32_t _ptr_service_name;
4261         uint32_t _ptr_key_name;
4262         uint32_t _ptr_display_name_length;
4263         TALLOC_CTX *_mem_save_handle_0;
4264         TALLOC_CTX *_mem_save_service_name_0;
4265         TALLOC_CTX *_mem_save_key_name_0;
4266         TALLOC_CTX *_mem_save_display_name_length_0;
4267         if (flags & NDR_IN) {
4268                 ZERO_STRUCT(r->out);
4269
4270                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4271                         NDR_PULL_ALLOC(ndr, r->in.handle);
4272                 }
4273                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4274                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4275                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4276                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4277                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_service_name));
4278                 if (_ptr_service_name) {
4279                         NDR_PULL_ALLOC(ndr, r->in.service_name);
4280                 } else {
4281                         r->in.service_name = NULL;
4282                 }
4283                 if (r->in.service_name) {
4284                         _mem_save_service_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4285                         NDR_PULL_SET_MEM_CTX(ndr, r->in.service_name, 0);
4286                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.service_name));
4287                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.service_name));
4288                         if (ndr_get_array_length(ndr, &r->in.service_name) > ndr_get_array_size(ndr, &r->in.service_name)) {
4289                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.service_name), ndr_get_array_length(ndr, &r->in.service_name));
4290                         }
4291                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t)));
4292                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.service_name, ndr_get_array_length(ndr, &r->in.service_name), sizeof(uint16_t), CH_UTF16));
4293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_name_0, 0);
4294                 }
4295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
4296                 if (_ptr_display_name_length) {
4297                         NDR_PULL_ALLOC(ndr, r->in.display_name_length);
4298                 } else {
4299                         r->in.display_name_length = NULL;
4300                 }
4301                 if (r->in.display_name_length) {
4302                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
4303                         NDR_PULL_SET_MEM_CTX(ndr, r->in.display_name_length, 0);
4304                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.display_name_length));
4305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
4306                 }
4307                 NDR_PULL_ALLOC(ndr, r->out.key_name);
4308                 ZERO_STRUCTP(r->out.key_name);
4309         }
4310         if (flags & NDR_OUT) {
4311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4312                         NDR_PULL_ALLOC(ndr, r->out.key_name);
4313                 }
4314                 _mem_save_key_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4315                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_name, LIBNDR_FLAG_REF_ALLOC);
4316                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_key_name));
4317                 NDR_CHECK(ndr_pull_array_size(ndr, r->out.key_name));
4318                 NDR_CHECK(ndr_pull_array_length(ndr, r->out.key_name));
4319                 if (ndr_get_array_length(ndr, r->out.key_name) > ndr_get_array_size(ndr, r->out.key_name)) {
4320                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.key_name), ndr_get_array_length(ndr, r->out.key_name));
4321                 }
4322                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t)));
4323                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.key_name, ndr_get_array_length(ndr, r->out.key_name), sizeof(uint16_t), CH_UTF16));
4324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_name_0, LIBNDR_FLAG_REF_ALLOC);
4325                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name_length));
4326                 if (_ptr_display_name_length) {
4327                         NDR_PULL_ALLOC(ndr, r->out.display_name_length);
4328                 } else {
4329                         r->out.display_name_length = NULL;
4330                 }
4331                 if (r->out.display_name_length) {
4332                         _mem_save_display_name_length_0 = NDR_PULL_GET_MEM_CTX(ndr);
4333                         NDR_PULL_SET_MEM_CTX(ndr, r->out.display_name_length, 0);
4334                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.display_name_length));
4335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_length_0, 0);
4336                 }
4337                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4338         }
4339         return NT_STATUS_OK;
4340 }
4341
4342 _PUBLIC_ void ndr_print_svcctl_GetServiceKeyNameA(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetServiceKeyNameA *r)
4343 {
4344         ndr_print_struct(ndr, name, "svcctl_GetServiceKeyNameA");
4345         ndr->depth++;
4346         if (flags & NDR_SET_VALUES) {
4347                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4348         }
4349         if (flags & NDR_IN) {
4350                 ndr_print_struct(ndr, "in", "svcctl_GetServiceKeyNameA");
4351                 ndr->depth++;
4352                 ndr_print_ptr(ndr, "handle", r->in.handle);
4353                 ndr->depth++;
4354                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4355                 ndr->depth--;
4356                 ndr_print_ptr(ndr, "service_name", r->in.service_name);
4357                 ndr->depth++;
4358                 if (r->in.service_name) {
4359                         ndr_print_string(ndr, "service_name", r->in.service_name);
4360                 }
4361                 ndr->depth--;
4362                 ndr_print_ptr(ndr, "display_name_length", r->in.display_name_length);
4363                 ndr->depth++;
4364                 if (r->in.display_name_length) {
4365                         ndr_print_uint32(ndr, "display_name_length", *r->in.display_name_length);
4366                 }
4367                 ndr->depth--;
4368                 ndr->depth--;
4369         }
4370         if (flags & NDR_OUT) {
4371                 ndr_print_struct(ndr, "out", "svcctl_GetServiceKeyNameA");
4372                 ndr->depth++;
4373                 ndr_print_ptr(ndr, "key_name", r->out.key_name);
4374                 ndr->depth++;
4375                 ndr_print_ptr(ndr, "key_name", *r->out.key_name);
4376                 ndr->depth++;
4377                 ndr_print_string(ndr, "key_name", *r->out.key_name);
4378                 ndr->depth--;
4379                 ndr->depth--;
4380                 ndr_print_ptr(ndr, "display_name_length", r->out.display_name_length);
4381                 ndr->depth++;
4382                 if (r->out.display_name_length) {
4383                         ndr_print_uint32(ndr, "display_name_length", *r->out.display_name_length);
4384                 }
4385                 ndr->depth--;
4386                 ndr_print_WERROR(ndr, "result", r->out.result);
4387                 ndr->depth--;
4388         }
4389         ndr->depth--;
4390 }
4391
4392 NTSTATUS ndr_push_svcctl_GetCurrentGroupeStateW(struct ndr_push *ndr, int flags, const struct svcctl_GetCurrentGroupeStateW *r)
4393 {
4394         if (flags & NDR_IN) {
4395         }
4396         if (flags & NDR_OUT) {
4397                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4398         }
4399         return NT_STATUS_OK;
4400 }
4401
4402 NTSTATUS ndr_pull_svcctl_GetCurrentGroupeStateW(struct ndr_pull *ndr, int flags, struct svcctl_GetCurrentGroupeStateW *r)
4403 {
4404         if (flags & NDR_IN) {
4405         }
4406         if (flags & NDR_OUT) {
4407                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4408         }
4409         return NT_STATUS_OK;
4410 }
4411
4412 _PUBLIC_ void ndr_print_svcctl_GetCurrentGroupeStateW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_GetCurrentGroupeStateW *r)
4413 {
4414         ndr_print_struct(ndr, name, "svcctl_GetCurrentGroupeStateW");
4415         ndr->depth++;
4416         if (flags & NDR_SET_VALUES) {
4417                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4418         }
4419         if (flags & NDR_IN) {
4420                 ndr_print_struct(ndr, "in", "svcctl_GetCurrentGroupeStateW");
4421                 ndr->depth++;
4422                 ndr->depth--;
4423         }
4424         if (flags & NDR_OUT) {
4425                 ndr_print_struct(ndr, "out", "svcctl_GetCurrentGroupeStateW");
4426                 ndr->depth++;
4427                 ndr_print_WERROR(ndr, "result", r->out.result);
4428                 ndr->depth--;
4429         }
4430         ndr->depth--;
4431 }
4432
4433 NTSTATUS ndr_push_svcctl_EnumServiceGroupW(struct ndr_push *ndr, int flags, const struct svcctl_EnumServiceGroupW *r)
4434 {
4435         if (flags & NDR_IN) {
4436         }
4437         if (flags & NDR_OUT) {
4438                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4439         }
4440         return NT_STATUS_OK;
4441 }
4442
4443 NTSTATUS ndr_pull_svcctl_EnumServiceGroupW(struct ndr_pull *ndr, int flags, struct svcctl_EnumServiceGroupW *r)
4444 {
4445         if (flags & NDR_IN) {
4446         }
4447         if (flags & NDR_OUT) {
4448                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4449         }
4450         return NT_STATUS_OK;
4451 }
4452
4453 _PUBLIC_ void ndr_print_svcctl_EnumServiceGroupW(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_EnumServiceGroupW *r)
4454 {
4455         ndr_print_struct(ndr, name, "svcctl_EnumServiceGroupW");
4456         ndr->depth++;
4457         if (flags & NDR_SET_VALUES) {
4458                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4459         }
4460         if (flags & NDR_IN) {
4461                 ndr_print_struct(ndr, "in", "svcctl_EnumServiceGroupW");
4462                 ndr->depth++;
4463                 ndr->depth--;
4464         }
4465         if (flags & NDR_OUT) {
4466                 ndr_print_struct(ndr, "out", "svcctl_EnumServiceGroupW");
4467                 ndr->depth++;
4468                 ndr_print_WERROR(ndr, "result", r->out.result);
4469                 ndr->depth--;
4470         }
4471         ndr->depth--;
4472 }
4473
4474 NTSTATUS ndr_push_svcctl_ChangeServiceConfig2A(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfig2A *r)
4475 {
4476         if (flags & NDR_IN) {
4477                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4478                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
4480                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
4481                 if (r->in.info) {
4482                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->in.info));
4483                 }
4484         }
4485         if (flags & NDR_OUT) {
4486                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4487         }
4488         return NT_STATUS_OK;
4489 }
4490
4491 NTSTATUS ndr_pull_svcctl_ChangeServiceConfig2A(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfig2A *r)
4492 {
4493         uint32_t _ptr_info;
4494         TALLOC_CTX *_mem_save_handle_0;
4495         TALLOC_CTX *_mem_save_info_0;
4496         if (flags & NDR_IN) {
4497                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4498                         NDR_PULL_ALLOC(ndr, r->in.handle);
4499                 }
4500                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4501                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4502                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
4505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
4506                 if (_ptr_info) {
4507                         NDR_PULL_ALLOC(ndr, r->in.info);
4508                 } else {
4509                         r->in.info = NULL;
4510                 }
4511                 if (r->in.info) {
4512                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4513                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
4514                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->in.info));
4515                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
4516                 }
4517         }
4518         if (flags & NDR_OUT) {
4519                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4520         }
4521         return NT_STATUS_OK;
4522 }
4523
4524 _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfig2A(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfig2A *r)
4525 {
4526         ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfig2A");
4527         ndr->depth++;
4528         if (flags & NDR_SET_VALUES) {
4529                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4530         }
4531         if (flags & NDR_IN) {
4532                 ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfig2A");
4533                 ndr->depth++;
4534                 ndr_print_ptr(ndr, "handle", r->in.handle);
4535                 ndr->depth++;
4536                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4537                 ndr->depth--;
4538                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
4539                 ndr_print_ptr(ndr, "info", r->in.info);
4540                 ndr->depth++;
4541                 if (r->in.info) {
4542                         ndr_print_uint8(ndr, "info", *r->in.info);
4543                 }
4544                 ndr->depth--;
4545                 ndr->depth--;
4546         }
4547         if (flags & NDR_OUT) {
4548                 ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfig2A");
4549                 ndr->depth++;
4550                 ndr_print_WERROR(ndr, "result", r->out.result);
4551                 ndr->depth--;
4552         }
4553         ndr->depth--;
4554 }
4555
4556 NTSTATUS ndr_push_svcctl_ChangeServiceConfig2W(struct ndr_push *ndr, int flags, const struct svcctl_ChangeServiceConfig2W *r)
4557 {
4558         if (flags & NDR_IN) {
4559                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4560                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
4562                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
4563                 if (r->in.info) {
4564                         NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, *r->in.info));
4565                 }
4566         }
4567         if (flags & NDR_OUT) {
4568                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4569         }
4570         return NT_STATUS_OK;
4571 }
4572
4573 NTSTATUS ndr_pull_svcctl_ChangeServiceConfig2W(struct ndr_pull *ndr, int flags, struct svcctl_ChangeServiceConfig2W *r)
4574 {
4575         uint32_t _ptr_info;
4576         TALLOC_CTX *_mem_save_handle_0;
4577         TALLOC_CTX *_mem_save_info_0;
4578         if (flags & NDR_IN) {
4579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4580                         NDR_PULL_ALLOC(ndr, r->in.handle);
4581                 }
4582                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4583                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4584                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
4587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
4588                 if (_ptr_info) {
4589                         NDR_PULL_ALLOC(ndr, r->in.info);
4590                 } else {
4591                         r->in.info = NULL;
4592                 }
4593                 if (r->in.info) {
4594                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
4595                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
4596                         NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, r->in.info));
4597                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
4598                 }
4599         }
4600         if (flags & NDR_OUT) {
4601                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4602         }
4603         return NT_STATUS_OK;
4604 }
4605
4606 _PUBLIC_ void ndr_print_svcctl_ChangeServiceConfig2W(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_ChangeServiceConfig2W *r)
4607 {
4608         ndr_print_struct(ndr, name, "svcctl_ChangeServiceConfig2W");
4609         ndr->depth++;
4610         if (flags & NDR_SET_VALUES) {
4611                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4612         }
4613         if (flags & NDR_IN) {
4614                 ndr_print_struct(ndr, "in", "svcctl_ChangeServiceConfig2W");
4615                 ndr->depth++;
4616                 ndr_print_ptr(ndr, "handle", r->in.handle);
4617                 ndr->depth++;
4618                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4619                 ndr->depth--;
4620                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
4621                 ndr_print_ptr(ndr, "info", r->in.info);
4622                 ndr->depth++;
4623                 if (r->in.info) {
4624                         ndr_print_uint8(ndr, "info", *r->in.info);
4625                 }
4626                 ndr->depth--;
4627                 ndr->depth--;
4628         }
4629         if (flags & NDR_OUT) {
4630                 ndr_print_struct(ndr, "out", "svcctl_ChangeServiceConfig2W");
4631                 ndr->depth++;
4632                 ndr_print_WERROR(ndr, "result", r->out.result);
4633                 ndr->depth--;
4634         }
4635         ndr->depth--;
4636 }
4637
4638 NTSTATUS ndr_push_svcctl_QueryServiceConfig2A(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfig2A *r)
4639 {
4640         if (flags & NDR_IN) {
4641                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4642                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
4644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
4645         }
4646         if (flags & NDR_OUT) {
4647                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
4648                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
4650                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4651         }
4652         return NT_STATUS_OK;
4653 }
4654
4655 NTSTATUS ndr_pull_svcctl_QueryServiceConfig2A(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2A *r)
4656 {
4657         TALLOC_CTX *_mem_save_handle_0;
4658         TALLOC_CTX *_mem_save_bytes_needed_0;
4659         if (flags & NDR_IN) {
4660                 ZERO_STRUCT(r->out);
4661
4662                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4663                         NDR_PULL_ALLOC(ndr, r->in.handle);
4664                 }
4665                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4666                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4667                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4668                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
4670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
4671                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
4672                 ZERO_STRUCTP(r->out.bytes_needed);
4673         }
4674         if (flags & NDR_OUT) {
4675                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.buf_size);
4676                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
4677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4678                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
4679                 }
4680                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
4681                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
4682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
4683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
4684                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4685         }
4686         return NT_STATUS_OK;
4687 }
4688
4689 _PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2A(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfig2A *r)
4690 {
4691         ndr_print_struct(ndr, name, "svcctl_QueryServiceConfig2A");
4692         ndr->depth++;
4693         if (flags & NDR_SET_VALUES) {
4694                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4695         }
4696         if (flags & NDR_IN) {
4697                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfig2A");
4698                 ndr->depth++;
4699                 ndr_print_ptr(ndr, "handle", r->in.handle);
4700                 ndr->depth++;
4701                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4702                 ndr->depth--;
4703                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
4704                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
4705                 ndr->depth--;
4706         }
4707         if (flags & NDR_OUT) {
4708                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfig2A");
4709                 ndr->depth++;
4710                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.buf_size);
4711                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
4712                 ndr->depth++;
4713                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
4714                 ndr->depth--;
4715                 ndr_print_WERROR(ndr, "result", r->out.result);
4716                 ndr->depth--;
4717         }
4718         ndr->depth--;
4719 }
4720
4721 NTSTATUS ndr_push_svcctl_QueryServiceConfig2W(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceConfig2W *r)
4722 {
4723         if (flags & NDR_IN) {
4724                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4725                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
4727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
4728         }
4729         if (flags & NDR_OUT) {
4730                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
4731                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
4733                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4734         }
4735         return NT_STATUS_OK;
4736 }
4737
4738 NTSTATUS ndr_pull_svcctl_QueryServiceConfig2W(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceConfig2W *r)
4739 {
4740         TALLOC_CTX *_mem_save_handle_0;
4741         TALLOC_CTX *_mem_save_bytes_needed_0;
4742         if (flags & NDR_IN) {
4743                 ZERO_STRUCT(r->out);
4744
4745                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4746                         NDR_PULL_ALLOC(ndr, r->in.handle);
4747                 }
4748                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4749                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4750                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4751                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4752                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
4753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
4754                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
4755                 ZERO_STRUCTP(r->out.bytes_needed);
4756         }
4757         if (flags & NDR_OUT) {
4758                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.buf_size);
4759                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
4760                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4761                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
4762                 }
4763                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
4764                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
4765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
4766                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
4767                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4768         }
4769         return NT_STATUS_OK;
4770 }
4771
4772 _PUBLIC_ void ndr_print_svcctl_QueryServiceConfig2W(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceConfig2W *r)
4773 {
4774         ndr_print_struct(ndr, name, "svcctl_QueryServiceConfig2W");
4775         ndr->depth++;
4776         if (flags & NDR_SET_VALUES) {
4777                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4778         }
4779         if (flags & NDR_IN) {
4780                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceConfig2W");
4781                 ndr->depth++;
4782                 ndr_print_ptr(ndr, "handle", r->in.handle);
4783                 ndr->depth++;
4784                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4785                 ndr->depth--;
4786                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
4787                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
4788                 ndr->depth--;
4789         }
4790         if (flags & NDR_OUT) {
4791                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceConfig2W");
4792                 ndr->depth++;
4793                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.buf_size);
4794                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
4795                 ndr->depth++;
4796                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
4797                 ndr->depth--;
4798                 ndr_print_WERROR(ndr, "result", r->out.result);
4799                 ndr->depth--;
4800         }
4801         ndr->depth--;
4802 }
4803
4804 NTSTATUS ndr_push_svcctl_QueryServiceStatusEx(struct ndr_push *ndr, int flags, const struct svcctl_QueryServiceStatusEx *r)
4805 {
4806         if (flags & NDR_IN) {
4807                 if (r->in.handle == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4808                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
4810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
4811         }
4812         if (flags & NDR_OUT) {
4813                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
4814                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
4816                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4817         }
4818         return NT_STATUS_OK;
4819 }
4820
4821 NTSTATUS ndr_pull_svcctl_QueryServiceStatusEx(struct ndr_pull *ndr, int flags, struct svcctl_QueryServiceStatusEx *r)
4822 {
4823         TALLOC_CTX *_mem_save_handle_0;
4824         TALLOC_CTX *_mem_save_bytes_needed_0;
4825         if (flags & NDR_IN) {
4826                 ZERO_STRUCT(r->out);
4827
4828                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4829                         NDR_PULL_ALLOC(ndr, r->in.handle);
4830                 }
4831                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4832                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
4833                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.handle));
4834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
4835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
4836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
4837                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
4838                 ZERO_STRUCTP(r->out.bytes_needed);
4839         }
4840         if (flags & NDR_OUT) {
4841                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.buf_size);
4842                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));
4843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4844                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
4845                 }
4846                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
4847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
4848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
4849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
4850                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
4851         }
4852         return NT_STATUS_OK;
4853 }
4854
4855 _PUBLIC_ void ndr_print_svcctl_QueryServiceStatusEx(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_QueryServiceStatusEx *r)
4856 {
4857         ndr_print_struct(ndr, name, "svcctl_QueryServiceStatusEx");
4858         ndr->depth++;
4859         if (flags & NDR_SET_VALUES) {
4860                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
4861         }
4862         if (flags & NDR_IN) {
4863                 ndr_print_struct(ndr, "in", "svcctl_QueryServiceStatusEx");
4864                 ndr->depth++;
4865                 ndr_print_ptr(ndr, "handle", r->in.handle);
4866                 ndr->depth++;
4867                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
4868                 ndr->depth--;
4869                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
4870                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
4871                 ndr->depth--;
4872         }
4873         if (flags & NDR_OUT) {
4874                 ndr_print_struct(ndr, "out", "svcctl_QueryServiceStatusEx");
4875                 ndr->depth++;
4876                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.buf_size);
4877                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
4878                 ndr->depth++;
4879                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
4880                 ndr->depth--;
4881                 ndr_print_WERROR(ndr, "result", r->out.result);
4882                 ndr->depth--;
4883         }
4884         ndr->depth--;
4885 }
4886
4887 NTSTATUS ndr_push_EnumServicesStatusExA(struct ndr_push *ndr, int flags, const struct EnumServicesStatusExA *r)
4888 {
4889         if (flags & NDR_IN) {
4890                 if (r->in.scmanager == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4891                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager));
4892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
4893                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
4894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
4895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
4896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
4897                 if (r->in.resume_handle) {
4898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
4899                 }
4900         }
4901         if (flags & NDR_OUT) {
4902                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.buf_size));
4903                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
4905                 if (r->out.service_returned == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.service_returned));
4907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
4908                 if (r->out.resume_handle) {
4909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
4910                 }
4911                 if (r->out.group_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4912                 if (*r->out.group_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
4913                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
4915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
4917                 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));
4918                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
4919         }
4920         return NT_STATUS_OK;
4921 }
4922
4923 NTSTATUS ndr_pull_EnumServicesStatusExA(struct ndr_pull *ndr, int flags, struct EnumServicesStatusExA *r)
4924 {
4925         uint32_t _ptr_resume_handle;
4926         uint32_t _ptr_group_name;
4927         TALLOC_CTX *_mem_save_scmanager_0;
4928         TALLOC_CTX *_mem_save_bytes_needed_0;
4929         TALLOC_CTX *_mem_save_service_returned_0;
4930         TALLOC_CTX *_mem_save_resume_handle_0;
4931         TALLOC_CTX *_mem_save_group_name_0;
4932         if (flags & NDR_IN) {
4933                 ZERO_STRUCT(r->out);
4934
4935                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4936                         NDR_PULL_ALLOC(ndr, r->in.scmanager);
4937                 }
4938                 _mem_save_scmanager_0 = NDR_PULL_GET_MEM_CTX(ndr);
4939                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager, LIBNDR_FLAG_REF_ALLOC);
4940                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager));
4941                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);
4942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
4943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
4944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
4945                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
4946                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
4947                 if (_ptr_resume_handle) {
4948                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
4949                 } else {
4950                         r->in.resume_handle = NULL;
4951                 }
4952                 if (r->in.resume_handle) {
4953                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4954                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
4955                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
4956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
4957                 }
4958                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
4959                 ZERO_STRUCTP(r->out.bytes_needed);
4960                 NDR_PULL_ALLOC(ndr, r->out.service_returned);
4961                 ZERO_STRUCTP(r->out.service_returned);
4962                 NDR_PULL_ALLOC(ndr, r->out.group_name);
4963                 ZERO_STRUCTP(r->out.group_name);
4964         }
4965         if (flags & NDR_OUT) {
4966                 NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.buf_size);
4967                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.buf_size));
4968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4969                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
4970                 }
4971                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
4972                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
4973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
4974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
4975                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4976                         NDR_PULL_ALLOC(ndr, r->out.service_returned);
4977                 }
4978                 _mem_save_service_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
4979                 NDR_PULL_SET_MEM_CTX(ndr, r->out.service_returned, LIBNDR_FLAG_REF_ALLOC);
4980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.service_returned));
4981                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_returned_0, LIBNDR_FLAG_REF_ALLOC);
4982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
4983                 if (_ptr_resume_handle) {
4984                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
4985                 } else {
4986                         r->out.resume_handle = NULL;
4987                 }
4988                 if (r->out.resume_handle) {
4989                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
4990                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
4991                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
4992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
4993                 }
4994                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
4995                         NDR_PULL_ALLOC(ndr, r->out.group_name);
4996                 }
4997                 _mem_save_group_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4998                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_name, LIBNDR_FLAG_REF_ALLOC);
4999                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_group_name));
5000                 NDR_CHECK(ndr_pull_array_size(ndr, r->out.group_name));
5001                 NDR_CHECK(ndr_pull_array_length(ndr, r->out.group_name));
5002                 if (ndr_get_array_length(ndr, r->out.group_name) > ndr_get_array_size(ndr, r->out.group_name)) {
5003                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.group_name), ndr_get_array_length(ndr, r->out.group_name));
5004                 }
5005                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.group_name), sizeof(uint16_t)));
5006                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.group_name, ndr_get_array_length(ndr, r->out.group_name), sizeof(uint16_t), CH_UTF16));
5007                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_0, LIBNDR_FLAG_REF_ALLOC);
5008                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5009         }
5010         return NT_STATUS_OK;
5011 }
5012
5013 _PUBLIC_ void ndr_print_EnumServicesStatusExA(struct ndr_print *ndr, const char *name, int flags, const struct EnumServicesStatusExA *r)
5014 {
5015         ndr_print_struct(ndr, name, "EnumServicesStatusExA");
5016         ndr->depth++;
5017         if (flags & NDR_SET_VALUES) {
5018                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5019         }
5020         if (flags & NDR_IN) {
5021                 ndr_print_struct(ndr, "in", "EnumServicesStatusExA");
5022                 ndr->depth++;
5023                 ndr_print_ptr(ndr, "scmanager", r->in.scmanager);
5024                 ndr->depth++;
5025                 ndr_print_policy_handle(ndr, "scmanager", r->in.scmanager);
5026                 ndr->depth--;
5027                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
5028                 ndr_print_uint32(ndr, "type", r->in.type);
5029                 ndr_print_uint32(ndr, "state", r->in.state);
5030                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
5031                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5032                 ndr->depth++;
5033                 if (r->in.resume_handle) {
5034                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5035                 }
5036                 ndr->depth--;
5037                 ndr->depth--;
5038         }
5039         if (flags & NDR_OUT) {
5040                 ndr_print_struct(ndr, "out", "EnumServicesStatusExA");
5041                 ndr->depth++;
5042                 ndr_print_array_uint8(ndr, "services", r->out.services, r->in.buf_size);
5043                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
5044                 ndr->depth++;
5045                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
5046                 ndr->depth--;
5047                 ndr_print_ptr(ndr, "service_returned", r->out.service_returned);
5048                 ndr->depth++;
5049                 ndr_print_uint32(ndr, "service_returned", *r->out.service_returned);
5050                 ndr->depth--;
5051                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5052                 ndr->depth++;
5053                 if (r->out.resume_handle) {
5054                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5055                 }
5056                 ndr->depth--;
5057                 ndr_print_ptr(ndr, "group_name", r->out.group_name);
5058                 ndr->depth++;
5059                 ndr_print_ptr(ndr, "group_name", *r->out.group_name);
5060                 ndr->depth++;
5061                 ndr_print_string(ndr, "group_name", *r->out.group_name);
5062                 ndr->depth--;
5063                 ndr->depth--;
5064                 ndr_print_WERROR(ndr, "result", r->out.result);
5065                 ndr->depth--;
5066         }
5067         ndr->depth--;
5068 }
5069
5070 NTSTATUS ndr_push_EnumServicesStatusExW(struct ndr_push *ndr, int flags, const struct EnumServicesStatusExW *r)
5071 {
5072         if (flags & NDR_IN) {
5073                 if (r->in.scmanager == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5074                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager));
5075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.info_level));
5076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
5077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.state));
5078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));
5079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.resume_handle));
5080                 if (r->in.resume_handle) {
5081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.resume_handle));
5082                 }
5083         }
5084         if (flags & NDR_OUT) {
5085                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.buf_size));
5086                 if (r->out.bytes_needed == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));
5088                 if (r->out.service_returned == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.service_returned));
5090                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.resume_handle));
5091                 if (r->out.resume_handle) {
5092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.resume_handle));
5093                 }
5094                 if (r->out.group_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5095                 if (*r->out.group_name == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
5096                 NDR_CHECK(ndr_push_ref_ptr(ndr));
5097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
5098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(*r->out.group_name, CH_UTF16)));
5100                 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));
5101                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5102         }
5103         return NT_STATUS_OK;
5104 }
5105
5106 NTSTATUS ndr_pull_EnumServicesStatusExW(struct ndr_pull *ndr, int flags, struct EnumServicesStatusExW *r)
5107 {
5108         uint32_t _ptr_resume_handle;
5109         uint32_t _ptr_group_name;
5110         TALLOC_CTX *_mem_save_scmanager_0;
5111         TALLOC_CTX *_mem_save_bytes_needed_0;
5112         TALLOC_CTX *_mem_save_service_returned_0;
5113         TALLOC_CTX *_mem_save_resume_handle_0;
5114         TALLOC_CTX *_mem_save_group_name_0;
5115         if (flags & NDR_IN) {
5116                 ZERO_STRUCT(r->out);
5117
5118                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5119                         NDR_PULL_ALLOC(ndr, r->in.scmanager);
5120                 }
5121                 _mem_save_scmanager_0 = NDR_PULL_GET_MEM_CTX(ndr);
5122                 NDR_PULL_SET_MEM_CTX(ndr, r->in.scmanager, LIBNDR_FLAG_REF_ALLOC);
5123                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.scmanager));
5124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_scmanager_0, LIBNDR_FLAG_REF_ALLOC);
5125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.info_level));
5126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
5127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.state));
5128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));
5129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
5130                 if (_ptr_resume_handle) {
5131                         NDR_PULL_ALLOC(ndr, r->in.resume_handle);
5132                 } else {
5133                         r->in.resume_handle = NULL;
5134                 }
5135                 if (r->in.resume_handle) {
5136                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5137                         NDR_PULL_SET_MEM_CTX(ndr, r->in.resume_handle, 0);
5138                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.resume_handle));
5139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
5140                 }
5141                 NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
5142                 ZERO_STRUCTP(r->out.bytes_needed);
5143                 NDR_PULL_ALLOC(ndr, r->out.service_returned);
5144                 ZERO_STRUCTP(r->out.service_returned);
5145                 NDR_PULL_ALLOC(ndr, r->out.group_name);
5146                 ZERO_STRUCTP(r->out.group_name);
5147         }
5148         if (flags & NDR_OUT) {
5149                 NDR_PULL_ALLOC_N(ndr, r->out.services, r->in.buf_size);
5150                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.services, r->in.buf_size));
5151                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5152                         NDR_PULL_ALLOC(ndr, r->out.bytes_needed);
5153                 }
5154                 _mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
5155                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);
5156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));
5157                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);
5158                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5159                         NDR_PULL_ALLOC(ndr, r->out.service_returned);
5160                 }
5161                 _mem_save_service_returned_0 = NDR_PULL_GET_MEM_CTX(ndr);
5162                 NDR_PULL_SET_MEM_CTX(ndr, r->out.service_returned, LIBNDR_FLAG_REF_ALLOC);
5163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.service_returned));
5164                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_service_returned_0, LIBNDR_FLAG_REF_ALLOC);
5165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_resume_handle));
5166                 if (_ptr_resume_handle) {
5167                         NDR_PULL_ALLOC(ndr, r->out.resume_handle);
5168                 } else {
5169                         r->out.resume_handle = NULL;
5170                 }
5171                 if (r->out.resume_handle) {
5172                         _mem_save_resume_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
5173                         NDR_PULL_SET_MEM_CTX(ndr, r->out.resume_handle, 0);
5174                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.resume_handle));
5175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_resume_handle_0, 0);
5176                 }
5177                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
5178                         NDR_PULL_ALLOC(ndr, r->out.group_name);
5179                 }
5180                 _mem_save_group_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5181                 NDR_PULL_SET_MEM_CTX(ndr, r->out.group_name, LIBNDR_FLAG_REF_ALLOC);
5182                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_group_name));
5183                 NDR_CHECK(ndr_pull_array_size(ndr, r->out.group_name));
5184                 NDR_CHECK(ndr_pull_array_length(ndr, r->out.group_name));
5185                 if (ndr_get_array_length(ndr, r->out.group_name) > ndr_get_array_size(ndr, r->out.group_name)) {
5186                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, r->out.group_name), ndr_get_array_length(ndr, r->out.group_name));
5187                 }
5188                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, r->out.group_name), sizeof(uint16_t)));
5189                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, r->out.group_name, ndr_get_array_length(ndr, r->out.group_name), sizeof(uint16_t), CH_UTF16));
5190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_name_0, LIBNDR_FLAG_REF_ALLOC);
5191                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5192         }
5193         return NT_STATUS_OK;
5194 }
5195
5196 _PUBLIC_ void ndr_print_EnumServicesStatusExW(struct ndr_print *ndr, const char *name, int flags, const struct EnumServicesStatusExW *r)
5197 {
5198         ndr_print_struct(ndr, name, "EnumServicesStatusExW");
5199         ndr->depth++;
5200         if (flags & NDR_SET_VALUES) {
5201                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5202         }
5203         if (flags & NDR_IN) {
5204                 ndr_print_struct(ndr, "in", "EnumServicesStatusExW");
5205                 ndr->depth++;
5206                 ndr_print_ptr(ndr, "scmanager", r->in.scmanager);
5207                 ndr->depth++;
5208                 ndr_print_policy_handle(ndr, "scmanager", r->in.scmanager);
5209                 ndr->depth--;
5210                 ndr_print_uint32(ndr, "info_level", r->in.info_level);
5211                 ndr_print_uint32(ndr, "type", r->in.type);
5212                 ndr_print_uint32(ndr, "state", r->in.state);
5213                 ndr_print_uint32(ndr, "buf_size", r->in.buf_size);
5214                 ndr_print_ptr(ndr, "resume_handle", r->in.resume_handle);
5215                 ndr->depth++;
5216                 if (r->in.resume_handle) {
5217                         ndr_print_uint32(ndr, "resume_handle", *r->in.resume_handle);
5218                 }
5219                 ndr->depth--;
5220                 ndr->depth--;
5221         }
5222         if (flags & NDR_OUT) {
5223                 ndr_print_struct(ndr, "out", "EnumServicesStatusExW");
5224                 ndr->depth++;
5225                 ndr_print_array_uint8(ndr, "services", r->out.services, r->in.buf_size);
5226                 ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);
5227                 ndr->depth++;
5228                 ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);
5229                 ndr->depth--;
5230                 ndr_print_ptr(ndr, "service_returned", r->out.service_returned);
5231                 ndr->depth++;
5232                 ndr_print_uint32(ndr, "service_returned", *r->out.service_returned);
5233                 ndr->depth--;
5234                 ndr_print_ptr(ndr, "resume_handle", r->out.resume_handle);
5235                 ndr->depth++;
5236                 if (r->out.resume_handle) {
5237                         ndr_print_uint32(ndr, "resume_handle", *r->out.resume_handle);
5238                 }
5239                 ndr->depth--;
5240                 ndr_print_ptr(ndr, "group_name", r->out.group_name);
5241                 ndr->depth++;
5242                 ndr_print_ptr(ndr, "group_name", *r->out.group_name);
5243                 ndr->depth++;
5244                 ndr_print_string(ndr, "group_name", *r->out.group_name);
5245                 ndr->depth--;
5246                 ndr->depth--;
5247                 ndr_print_WERROR(ndr, "result", r->out.result);
5248                 ndr->depth--;
5249         }
5250         ndr->depth--;
5251 }
5252
5253 NTSTATUS ndr_push_svcctl_SCSendTSMessage(struct ndr_push *ndr, int flags, const struct svcctl_SCSendTSMessage *r)
5254 {
5255         if (flags & NDR_IN) {
5256         }
5257         if (flags & NDR_OUT) {
5258                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
5259         }
5260         return NT_STATUS_OK;
5261 }
5262
5263 NTSTATUS ndr_pull_svcctl_SCSendTSMessage(struct ndr_pull *ndr, int flags, struct svcctl_SCSendTSMessage *r)
5264 {
5265         if (flags & NDR_IN) {
5266         }
5267         if (flags & NDR_OUT) {
5268                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
5269         }
5270         return NT_STATUS_OK;
5271 }
5272
5273 _PUBLIC_ void ndr_print_svcctl_SCSendTSMessage(struct ndr_print *ndr, const char *name, int flags, const struct svcctl_SCSendTSMessage *r)
5274 {
5275         ndr_print_struct(ndr, name, "svcctl_SCSendTSMessage");
5276         ndr->depth++;
5277         if (flags & NDR_SET_VALUES) {
5278                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
5279         }
5280         if (flags & NDR_IN) {
5281                 ndr_print_struct(ndr, "in", "svcctl_SCSendTSMessage");
5282                 ndr->depth++;
5283                 ndr->depth--;
5284         }
5285         if (flags & NDR_OUT) {
5286                 ndr_print_struct(ndr, "out", "svcctl_SCSendTSMessage");
5287                 ndr->depth++;
5288                 ndr_print_WERROR(ndr, "result", r->out.result);
5289                 ndr->depth--;
5290         }
5291         ndr->depth--;
5292 }
5293
5294 const struct ndr_interface_call svcctl_calls[] = {
5295         {
5296                 "svcctl_CloseServiceHandle",
5297                 sizeof(struct svcctl_CloseServiceHandle),
5298                 (ndr_push_flags_fn_t) ndr_push_svcctl_CloseServiceHandle,
5299                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_CloseServiceHandle,
5300                 (ndr_print_function_t) ndr_print_svcctl_CloseServiceHandle,
5301                 False,
5302         },
5303         {
5304                 "svcctl_ControlService",
5305                 sizeof(struct svcctl_ControlService),
5306                 (ndr_push_flags_fn_t) ndr_push_svcctl_ControlService,
5307                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ControlService,
5308                 (ndr_print_function_t) ndr_print_svcctl_ControlService,
5309                 False,
5310         },
5311         {
5312                 "svcctl_DeleteService",
5313                 sizeof(struct svcctl_DeleteService),
5314                 (ndr_push_flags_fn_t) ndr_push_svcctl_DeleteService,
5315                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_DeleteService,
5316                 (ndr_print_function_t) ndr_print_svcctl_DeleteService,
5317                 False,
5318         },
5319         {
5320                 "svcctl_LockServiceDatabase",
5321                 sizeof(struct svcctl_LockServiceDatabase),
5322                 (ndr_push_flags_fn_t) ndr_push_svcctl_LockServiceDatabase,
5323                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_LockServiceDatabase,
5324                 (ndr_print_function_t) ndr_print_svcctl_LockServiceDatabase,
5325                 False,
5326         },
5327         {
5328                 "svcctl_QueryServiceObjectSecurity",
5329                 sizeof(struct svcctl_QueryServiceObjectSecurity),
5330                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceObjectSecurity,
5331                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceObjectSecurity,
5332                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceObjectSecurity,
5333                 False,
5334         },
5335         {
5336                 "svcctl_SetServiceObjectSecurity",
5337                 sizeof(struct svcctl_SetServiceObjectSecurity),
5338                 (ndr_push_flags_fn_t) ndr_push_svcctl_SetServiceObjectSecurity,
5339                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SetServiceObjectSecurity,
5340                 (ndr_print_function_t) ndr_print_svcctl_SetServiceObjectSecurity,
5341                 False,
5342         },
5343         {
5344                 "svcctl_QueryServiceStatus",
5345                 sizeof(struct svcctl_QueryServiceStatus),
5346                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceStatus,
5347                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceStatus,
5348                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceStatus,
5349                 False,
5350         },
5351         {
5352                 "svcctl_SetServiceStatus",
5353                 sizeof(struct svcctl_SetServiceStatus),
5354                 (ndr_push_flags_fn_t) ndr_push_svcctl_SetServiceStatus,
5355                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SetServiceStatus,
5356                 (ndr_print_function_t) ndr_print_svcctl_SetServiceStatus,
5357                 False,
5358         },
5359         {
5360                 "svcctl_UnlockServiceDatabase",
5361                 sizeof(struct svcctl_UnlockServiceDatabase),
5362                 (ndr_push_flags_fn_t) ndr_push_svcctl_UnlockServiceDatabase,
5363                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_UnlockServiceDatabase,
5364                 (ndr_print_function_t) ndr_print_svcctl_UnlockServiceDatabase,
5365                 False,
5366         },
5367         {
5368                 "svcctl_NotifyBootConfigStatus",
5369                 sizeof(struct svcctl_NotifyBootConfigStatus),
5370                 (ndr_push_flags_fn_t) ndr_push_svcctl_NotifyBootConfigStatus,
5371                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_NotifyBootConfigStatus,
5372                 (ndr_print_function_t) ndr_print_svcctl_NotifyBootConfigStatus,
5373                 False,
5374         },
5375         {
5376                 "svcctl_SCSetServiceBitsW",
5377                 sizeof(struct svcctl_SCSetServiceBitsW),
5378                 (ndr_push_flags_fn_t) ndr_push_svcctl_SCSetServiceBitsW,
5379                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSetServiceBitsW,
5380                 (ndr_print_function_t) ndr_print_svcctl_SCSetServiceBitsW,
5381                 False,
5382         },
5383         {
5384                 "svcctl_ChangeServiceConfigW",
5385                 sizeof(struct svcctl_ChangeServiceConfigW),
5386                 (ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfigW,
5387                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfigW,
5388                 (ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfigW,
5389                 False,
5390         },
5391         {
5392                 "svcctl_CreateServiceW",
5393                 sizeof(struct svcctl_CreateServiceW),
5394                 (ndr_push_flags_fn_t) ndr_push_svcctl_CreateServiceW,
5395                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_CreateServiceW,
5396                 (ndr_print_function_t) ndr_print_svcctl_CreateServiceW,
5397                 False,
5398         },
5399         {
5400                 "svcctl_EnumDependentServicesW",
5401                 sizeof(struct svcctl_EnumDependentServicesW),
5402                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumDependentServicesW,
5403                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumDependentServicesW,
5404                 (ndr_print_function_t) ndr_print_svcctl_EnumDependentServicesW,
5405                 False,
5406         },
5407         {
5408                 "svcctl_EnumServicesStatusW",
5409                 sizeof(struct svcctl_EnumServicesStatusW),
5410                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumServicesStatusW,
5411                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServicesStatusW,
5412                 (ndr_print_function_t) ndr_print_svcctl_EnumServicesStatusW,
5413                 False,
5414         },
5415         {
5416                 "svcctl_OpenSCManagerW",
5417                 sizeof(struct svcctl_OpenSCManagerW),
5418                 (ndr_push_flags_fn_t) ndr_push_svcctl_OpenSCManagerW,
5419                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenSCManagerW,
5420                 (ndr_print_function_t) ndr_print_svcctl_OpenSCManagerW,
5421                 False,
5422         },
5423         {
5424                 "svcctl_OpenServiceW",
5425                 sizeof(struct svcctl_OpenServiceW),
5426                 (ndr_push_flags_fn_t) ndr_push_svcctl_OpenServiceW,
5427                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenServiceW,
5428                 (ndr_print_function_t) ndr_print_svcctl_OpenServiceW,
5429                 False,
5430         },
5431         {
5432                 "svcctl_QueryServiceConfigW",
5433                 sizeof(struct svcctl_QueryServiceConfigW),
5434                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfigW,
5435                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfigW,
5436                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceConfigW,
5437                 False,
5438         },
5439         {
5440                 "svcctl_QueryServiceLockStatusW",
5441                 sizeof(struct svcctl_QueryServiceLockStatusW),
5442                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceLockStatusW,
5443                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceLockStatusW,
5444                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceLockStatusW,
5445                 False,
5446         },
5447         {
5448                 "svcctl_StartServiceW",
5449                 sizeof(struct svcctl_StartServiceW),
5450                 (ndr_push_flags_fn_t) ndr_push_svcctl_StartServiceW,
5451                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_StartServiceW,
5452                 (ndr_print_function_t) ndr_print_svcctl_StartServiceW,
5453                 False,
5454         },
5455         {
5456                 "svcctl_GetServiceDisplayNameW",
5457                 sizeof(struct svcctl_GetServiceDisplayNameW),
5458                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceDisplayNameW,
5459                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceDisplayNameW,
5460                 (ndr_print_function_t) ndr_print_svcctl_GetServiceDisplayNameW,
5461                 False,
5462         },
5463         {
5464                 "svcctl_GetServiceKeyNameW",
5465                 sizeof(struct svcctl_GetServiceKeyNameW),
5466                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceKeyNameW,
5467                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceKeyNameW,
5468                 (ndr_print_function_t) ndr_print_svcctl_GetServiceKeyNameW,
5469                 False,
5470         },
5471         {
5472                 "svcctl_SCSetServiceBitsA",
5473                 sizeof(struct svcctl_SCSetServiceBitsA),
5474                 (ndr_push_flags_fn_t) ndr_push_svcctl_SCSetServiceBitsA,
5475                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSetServiceBitsA,
5476                 (ndr_print_function_t) ndr_print_svcctl_SCSetServiceBitsA,
5477                 False,
5478         },
5479         {
5480                 "svcctl_ChangeServiceConfigA",
5481                 sizeof(struct svcctl_ChangeServiceConfigA),
5482                 (ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfigA,
5483                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfigA,
5484                 (ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfigA,
5485                 False,
5486         },
5487         {
5488                 "svcctl_CreateServiceA",
5489                 sizeof(struct svcctl_CreateServiceA),
5490                 (ndr_push_flags_fn_t) ndr_push_svcctl_CreateServiceA,
5491                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_CreateServiceA,
5492                 (ndr_print_function_t) ndr_print_svcctl_CreateServiceA,
5493                 False,
5494         },
5495         {
5496                 "svcctl_EnumDependentServicesA",
5497                 sizeof(struct svcctl_EnumDependentServicesA),
5498                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumDependentServicesA,
5499                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumDependentServicesA,
5500                 (ndr_print_function_t) ndr_print_svcctl_EnumDependentServicesA,
5501                 False,
5502         },
5503         {
5504                 "svcctl_EnumServicesStatusA",
5505                 sizeof(struct svcctl_EnumServicesStatusA),
5506                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumServicesStatusA,
5507                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServicesStatusA,
5508                 (ndr_print_function_t) ndr_print_svcctl_EnumServicesStatusA,
5509                 False,
5510         },
5511         {
5512                 "svcctl_OpenSCManagerA",
5513                 sizeof(struct svcctl_OpenSCManagerA),
5514                 (ndr_push_flags_fn_t) ndr_push_svcctl_OpenSCManagerA,
5515                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenSCManagerA,
5516                 (ndr_print_function_t) ndr_print_svcctl_OpenSCManagerA,
5517                 False,
5518         },
5519         {
5520                 "svcctl_OpenServiceA",
5521                 sizeof(struct svcctl_OpenServiceA),
5522                 (ndr_push_flags_fn_t) ndr_push_svcctl_OpenServiceA,
5523                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_OpenServiceA,
5524                 (ndr_print_function_t) ndr_print_svcctl_OpenServiceA,
5525                 False,
5526         },
5527         {
5528                 "svcctl_QueryServiceConfigA",
5529                 sizeof(struct svcctl_QueryServiceConfigA),
5530                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfigA,
5531                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfigA,
5532                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceConfigA,
5533                 False,
5534         },
5535         {
5536                 "svcctl_QueryServiceLockStatusA",
5537                 sizeof(struct svcctl_QueryServiceLockStatusA),
5538                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceLockStatusA,
5539                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceLockStatusA,
5540                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceLockStatusA,
5541                 False,
5542         },
5543         {
5544                 "svcctl_StartServiceA",
5545                 sizeof(struct svcctl_StartServiceA),
5546                 (ndr_push_flags_fn_t) ndr_push_svcctl_StartServiceA,
5547                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_StartServiceA,
5548                 (ndr_print_function_t) ndr_print_svcctl_StartServiceA,
5549                 False,
5550         },
5551         {
5552                 "svcctl_GetServiceDisplayNameA",
5553                 sizeof(struct svcctl_GetServiceDisplayNameA),
5554                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceDisplayNameA,
5555                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceDisplayNameA,
5556                 (ndr_print_function_t) ndr_print_svcctl_GetServiceDisplayNameA,
5557                 False,
5558         },
5559         {
5560                 "svcctl_GetServiceKeyNameA",
5561                 sizeof(struct svcctl_GetServiceKeyNameA),
5562                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetServiceKeyNameA,
5563                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetServiceKeyNameA,
5564                 (ndr_print_function_t) ndr_print_svcctl_GetServiceKeyNameA,
5565                 False,
5566         },
5567         {
5568                 "svcctl_GetCurrentGroupeStateW",
5569                 sizeof(struct svcctl_GetCurrentGroupeStateW),
5570                 (ndr_push_flags_fn_t) ndr_push_svcctl_GetCurrentGroupeStateW,
5571                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_GetCurrentGroupeStateW,
5572                 (ndr_print_function_t) ndr_print_svcctl_GetCurrentGroupeStateW,
5573                 False,
5574         },
5575         {
5576                 "svcctl_EnumServiceGroupW",
5577                 sizeof(struct svcctl_EnumServiceGroupW),
5578                 (ndr_push_flags_fn_t) ndr_push_svcctl_EnumServiceGroupW,
5579                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_EnumServiceGroupW,
5580                 (ndr_print_function_t) ndr_print_svcctl_EnumServiceGroupW,
5581                 False,
5582         },
5583         {
5584                 "svcctl_ChangeServiceConfig2A",
5585                 sizeof(struct svcctl_ChangeServiceConfig2A),
5586                 (ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfig2A,
5587                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfig2A,
5588                 (ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfig2A,
5589                 False,
5590         },
5591         {
5592                 "svcctl_ChangeServiceConfig2W",
5593                 sizeof(struct svcctl_ChangeServiceConfig2W),
5594                 (ndr_push_flags_fn_t) ndr_push_svcctl_ChangeServiceConfig2W,
5595                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_ChangeServiceConfig2W,
5596                 (ndr_print_function_t) ndr_print_svcctl_ChangeServiceConfig2W,
5597                 False,
5598         },
5599         {
5600                 "svcctl_QueryServiceConfig2A",
5601                 sizeof(struct svcctl_QueryServiceConfig2A),
5602                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfig2A,
5603                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfig2A,
5604                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceConfig2A,
5605                 False,
5606         },
5607         {
5608                 "svcctl_QueryServiceConfig2W",
5609                 sizeof(struct svcctl_QueryServiceConfig2W),
5610                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceConfig2W,
5611                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceConfig2W,
5612                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceConfig2W,
5613                 False,
5614         },
5615         {
5616                 "svcctl_QueryServiceStatusEx",
5617                 sizeof(struct svcctl_QueryServiceStatusEx),
5618                 (ndr_push_flags_fn_t) ndr_push_svcctl_QueryServiceStatusEx,
5619                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_QueryServiceStatusEx,
5620                 (ndr_print_function_t) ndr_print_svcctl_QueryServiceStatusEx,
5621                 False,
5622         },
5623         {
5624                 "EnumServicesStatusExA",
5625                 sizeof(struct EnumServicesStatusExA),
5626                 (ndr_push_flags_fn_t) ndr_push_EnumServicesStatusExA,
5627                 (ndr_pull_flags_fn_t) ndr_pull_EnumServicesStatusExA,
5628                 (ndr_print_function_t) ndr_print_EnumServicesStatusExA,
5629                 False,
5630         },
5631         {
5632                 "EnumServicesStatusExW",
5633                 sizeof(struct EnumServicesStatusExW),
5634                 (ndr_push_flags_fn_t) ndr_push_EnumServicesStatusExW,
5635                 (ndr_pull_flags_fn_t) ndr_pull_EnumServicesStatusExW,
5636                 (ndr_print_function_t) ndr_print_EnumServicesStatusExW,
5637                 False,
5638         },
5639         {
5640                 "svcctl_SCSendTSMessage",
5641                 sizeof(struct svcctl_SCSendTSMessage),
5642                 (ndr_push_flags_fn_t) ndr_push_svcctl_SCSendTSMessage,
5643                 (ndr_pull_flags_fn_t) ndr_pull_svcctl_SCSendTSMessage,
5644                 (ndr_print_function_t) ndr_print_svcctl_SCSendTSMessage,
5645                 False,
5646         },
5647         { NULL, 0, NULL, NULL, NULL, False }
5648 };
5649
5650 const char * const svcctl_endpoint_strings[] = {
5651         "ncacn_np:[\\pipe\\svcctl]",
5652         "ncalrpc:",
5653 };
5654
5655 const struct ndr_interface_string_array svcctl_endpoints = {
5656         .count  = 2,
5657         .names  = svcctl_endpoint_strings
5658 };
5659
5660 const char * const svcctl_authservice_strings[] = {
5661         "host",
5662 };
5663
5664 const struct ndr_interface_string_array svcctl_authservices = {
5665         .count  = 2,
5666         .names  = svcctl_authservice_strings
5667 };
5668
5669
5670 const struct ndr_interface_table dcerpc_table_svcctl = {
5671         .name           = "svcctl",
5672         .syntax_id      = {
5673                 {0x367abb81,0x9844,0x35f1,{0xad,0x32},{0x98,0xf0,0x38,0x00,0x10,0x03}},
5674                 DCERPC_SVCCTL_VERSION
5675         },
5676         .helpstring     = DCERPC_SVCCTL_HELPSTRING,
5677         .num_calls      = 44,
5678         .calls          = svcctl_calls,
5679         .endpoints      = &svcctl_endpoints,
5680         .authservices   = &svcctl_authservices
5681 };
5682