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