librpc/gen_ndr/ndr_svcctl.c

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