source3/librpc/gen_ndr/ndr_svcctl.c

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