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