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