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