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