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