librpc/gen_ndr/ndr_misc.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_misc.h"
   5
   6 _PUBLIC_ enum ndr_err_code ndr_push_GUID(struct ndr_push *ndr, int ndr_flags, const struct GUID *r)
   7 {
   8         if (ndr_flags & NDR_SCALARS) {
   9                 NDR_CHECK(ndr_push_align(ndr, 4));
  10                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time_low));
  11                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->time_mid));
  12                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->time_hi_and_version));
  13                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->clock_seq, 2));
  14                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->node, 6));
  15                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  16         }
  17         if (ndr_flags & NDR_BUFFERS) {
  18         }
  19         return NDR_ERR_SUCCESS;
  20 }
  21
  22 _PUBLIC_ enum ndr_err_code ndr_pull_GUID(struct ndr_pull *ndr, int ndr_flags, struct GUID *r)
  23 {
  24         uint32_t size_clock_seq_0 = 0;
  25         uint32_t size_node_0 = 0;
  26         if (ndr_flags & NDR_SCALARS) {
  27                 NDR_CHECK(ndr_pull_align(ndr, 4));
  28                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time_low));
  29                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->time_mid));
  30                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->time_hi_and_version));
  31                 size_clock_seq_0 = 2;
  32                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->clock_seq, size_clock_seq_0));
  33                 size_node_0 = 6;
  34                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->node, size_node_0));
  35                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
  36         }
  37         if (ndr_flags & NDR_BUFFERS) {
  38         }
  39         return NDR_ERR_SUCCESS;
  40 }
  41
  42 _PUBLIC_ size_t ndr_size_GUID(const struct GUID *r, struct smb_iconv_convenience *ic, int flags)
  43 {
  44         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_GUID, ic);
  45 }
  46
  47 _PUBLIC_ enum ndr_err_code ndr_push_ndr_syntax_id(struct ndr_push *ndr, int ndr_flags, const struct ndr_syntax_id *r)
  48 {
  49         if (ndr_flags & NDR_SCALARS) {
  50                 NDR_CHECK(ndr_push_align(ndr, 4));
  51                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
  52                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->if_version));
  53                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  54         }
  55         if (ndr_flags & NDR_BUFFERS) {
  56         }
  57         return NDR_ERR_SUCCESS;
  58 }
  59
  60 _PUBLIC_ enum ndr_err_code ndr_pull_ndr_syntax_id(struct ndr_pull *ndr, int ndr_flags, struct ndr_syntax_id *r)
  61 {
  62         if (ndr_flags & NDR_SCALARS) {
  63                 NDR_CHECK(ndr_pull_align(ndr, 4));
  64                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
  65                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->if_version));
  66                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
  67         }
  68         if (ndr_flags & NDR_BUFFERS) {
  69         }
  70         return NDR_ERR_SUCCESS;
  71 }
  72
  73 _PUBLIC_ void ndr_print_ndr_syntax_id(struct ndr_print *ndr, const char *name, const struct ndr_syntax_id *r)
  74 {
  75         ndr_print_struct(ndr, name, "ndr_syntax_id");
  76         ndr->depth++;
  77         ndr_print_GUID(ndr, "uuid", &r->uuid);
  78         ndr_print_uint32(ndr, "if_version", r->if_version);
  79         ndr->depth--;
  80 }
  81
  82 _PUBLIC_ enum ndr_err_code ndr_push_policy_handle(struct ndr_push *ndr, int ndr_flags, const struct policy_handle *r)
  83 {
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_push_align(ndr, 4));
  86                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->handle_type));
  87                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->uuid));
  88                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
  89         }
  90         if (ndr_flags & NDR_BUFFERS) {
  91         }
  92         return NDR_ERR_SUCCESS;
  93 }
  94
  95 _PUBLIC_ enum ndr_err_code ndr_pull_policy_handle(struct ndr_pull *ndr, int ndr_flags, struct policy_handle *r)
  96 {
  97         if (ndr_flags & NDR_SCALARS) {
  98                 NDR_CHECK(ndr_pull_align(ndr, 4));
  99                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->handle_type));
 100                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->uuid));
 101                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 102         }
 103         if (ndr_flags & NDR_BUFFERS) {
 104         }
 105         return NDR_ERR_SUCCESS;
 106 }
 107
 108 _PUBLIC_ void ndr_print_policy_handle(struct ndr_print *ndr, const char *name, const struct policy_handle *r)
 109 {
 110         ndr_print_struct(ndr, name, "policy_handle");
 111         ndr->depth++;
 112         ndr_print_uint32(ndr, "handle_type", r->handle_type);
 113         ndr_print_GUID(ndr, "uuid", &r->uuid);
 114         ndr->depth--;
 115 }
 116
 117 _PUBLIC_ enum ndr_err_code ndr_push_netr_SchannelType(struct ndr_push *ndr, int ndr_flags, enum netr_SchannelType r)
 118 {
 119         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 120         return NDR_ERR_SUCCESS;
 121 }
 122
 123 _PUBLIC_ enum ndr_err_code ndr_pull_netr_SchannelType(struct ndr_pull *ndr, int ndr_flags, enum netr_SchannelType *r)
 124 {
 125         uint16_t v;
 126         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 127         *r = v;
 128         return NDR_ERR_SUCCESS;
 129 }
 130
 131 _PUBLIC_ void ndr_print_netr_SchannelType(struct ndr_print *ndr, const char *name, enum netr_SchannelType r)
 132 {
 133         const char *val = NULL;
 134
 135         switch (r) {
 136                 case SEC_CHAN_NULL: val = "SEC_CHAN_NULL"; break;
 137                 case SEC_CHAN_WKSTA: val = "SEC_CHAN_WKSTA"; break;
 138                 case SEC_CHAN_DNS_DOMAIN: val = "SEC_CHAN_DNS_DOMAIN"; break;
 139                 case SEC_CHAN_DOMAIN: val = "SEC_CHAN_DOMAIN"; break;
 140                 case SEC_CHAN_BDC: val = "SEC_CHAN_BDC"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 _PUBLIC_ enum ndr_err_code ndr_push_KRB5_EDATA_NTSTATUS(struct ndr_push *ndr, int ndr_flags, const struct KRB5_EDATA_NTSTATUS *r)
 146 {
 147         if (ndr_flags & NDR_SCALARS) {
 148                 NDR_CHECK(ndr_push_align(ndr, 4));
 149                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->ntstatus));
 150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
 151                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
 152                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 153         }
 154         if (ndr_flags & NDR_BUFFERS) {
 155         }
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ enum ndr_err_code ndr_pull_KRB5_EDATA_NTSTATUS(struct ndr_pull *ndr, int ndr_flags, struct KRB5_EDATA_NTSTATUS *r)
 160 {
 161         if (ndr_flags & NDR_SCALARS) {
 162                 NDR_CHECK(ndr_pull_align(ndr, 4));
 163                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->ntstatus));
 164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
 165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
 166                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 167         }
 168         if (ndr_flags & NDR_BUFFERS) {
 169         }
 170         return NDR_ERR_SUCCESS;
 171 }
 172
 173 _PUBLIC_ void ndr_print_KRB5_EDATA_NTSTATUS(struct ndr_print *ndr, const char *name, const struct KRB5_EDATA_NTSTATUS *r)
 174 {
 175         ndr_print_struct(ndr, name, "KRB5_EDATA_NTSTATUS");
 176         ndr->depth++;
 177         ndr_print_NTSTATUS(ndr, "ntstatus", r->ntstatus);
 178         ndr_print_uint32(ndr, "unknown1", r->unknown1);
 179         ndr_print_uint32(ndr, "unknown2", r->unknown2);
 180         ndr->depth--;
 181 }
 182
 183 _PUBLIC_ enum ndr_err_code ndr_push_winreg_Type(struct ndr_push *ndr, int ndr_flags, enum winreg_Type r)
 184 {
 185         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 186         return NDR_ERR_SUCCESS;
 187 }
 188
 189 _PUBLIC_ enum ndr_err_code ndr_pull_winreg_Type(struct ndr_pull *ndr, int ndr_flags, enum winreg_Type *r)
 190 {
 191         uint32_t v;
 192         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 193         *r = v;
 194         return NDR_ERR_SUCCESS;
 195 }
 196
 197 _PUBLIC_ void ndr_print_winreg_Type(struct ndr_print *ndr, const char *name, enum winreg_Type r)
 198 {
 199         const char *val = NULL;
 200
 201         switch (r) {
 202                 case REG_NONE: val = "REG_NONE"; break;
 203                 case REG_SZ: val = "REG_SZ"; break;
 204                 case REG_EXPAND_SZ: val = "REG_EXPAND_SZ"; break;
 205                 case REG_BINARY: val = "REG_BINARY"; break;
 206                 case REG_DWORD: val = "REG_DWORD"; break;
 207                 case REG_DWORD_BIG_ENDIAN: val = "REG_DWORD_BIG_ENDIAN"; break;
 208                 case REG_LINK: val = "REG_LINK"; break;
 209                 case REG_MULTI_SZ: val = "REG_MULTI_SZ"; break;
 210                 case REG_RESOURCE_LIST: val = "REG_RESOURCE_LIST"; break;
 211                 case REG_FULL_RESOURCE_DESCRIPTOR: val = "REG_FULL_RESOURCE_DESCRIPTOR"; break;
 212                 case REG_RESOURCE_REQUIREMENTS_LIST: val = "REG_RESOURCE_REQUIREMENTS_LIST"; break;
 213                 case REG_QWORD: val = "REG_QWORD"; break;
 214         }
 215         ndr_print_enum(ndr, name, "ENUM", val, r);
 216 }
 217
 218 _PUBLIC_ enum ndr_err_code ndr_push_winreg_Data(struct ndr_push *ndr, int ndr_flags, const union winreg_Data *r)
 219 {
 220         {
 221                 uint32_t _flags_save_UNION = ndr->flags;
 222                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 223                 if (ndr_flags & NDR_SCALARS) {
 224                         int level = ndr_push_get_switch_value(ndr, r);
 225                         NDR_CHECK(ndr_push_union_align(ndr, 4));
 226                         switch (level) {
 227                                 case REG_NONE: {
 228                                 break; }
 229
 230                                 case REG_SZ: {
 231                                         {
 232                                                 uint32_t _flags_save_string = ndr->flags;
 233                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 234                                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
 235                                                 ndr->flags = _flags_save_string;
 236                                         }
 237                                 break; }
 238
 239                                 case REG_EXPAND_SZ: {
 240                                         {
 241                                                 uint32_t _flags_save_string = ndr->flags;
 242                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 243                                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
 244                                                 ndr->flags = _flags_save_string;
 245                                         }
 246                                 break; }
 247
 248                                 case REG_BINARY: {
 249                                         {
 250                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
 251                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 252                                                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
 253                                                 ndr->flags = _flags_save_DATA_BLOB;
 254                                         }
 255                                 break; }
 256
 257                                 case REG_DWORD: {
 258                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
 259                                 break; }
 260
 261                                 case REG_DWORD_BIG_ENDIAN: {
 262                                         {
 263                                                 uint32_t _flags_save_uint32 = ndr->flags;
 264                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 265                                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
 266                                                 ndr->flags = _flags_save_uint32;
 267                                         }
 268                                 break; }
 269
 270                                 case REG_MULTI_SZ: {
 271                                         {
 272                                                 uint32_t _flags_save_string_array = ndr->flags;
 273                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 274                                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
 275                                                 ndr->flags = _flags_save_string_array;
 276                                         }
 277                                 break; }
 278
 279                                 default: {
 280                                         {
 281                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
 282                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 283                                                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
 284                                                 ndr->flags = _flags_save_DATA_BLOB;
 285                                         }
 286                                 break; }
 287
 288                         }
 289                 }
 290                 if (ndr_flags & NDR_BUFFERS) {
 291                         int level = ndr_push_get_switch_value(ndr, r);
 292                         switch (level) {
 293                                 case REG_NONE:
 294                                 break;
 295
 296                                 case REG_SZ:
 297                                 break;
 298
 299                                 case REG_EXPAND_SZ:
 300                                 break;
 301
 302                                 case REG_BINARY:
 303                                 break;
 304
 305                                 case REG_DWORD:
 306                                 break;
 307
 308                                 case REG_DWORD_BIG_ENDIAN:
 309                                 break;
 310
 311                                 case REG_MULTI_SZ:
 312                                 break;
 313
 314                                 default:
 315                                 break;
 316
 317                         }
 318                 }
 319                 ndr->flags = _flags_save_UNION;
 320         }
 321         return NDR_ERR_SUCCESS;
 322 }
 323
 324 _PUBLIC_ enum ndr_err_code ndr_pull_winreg_Data(struct ndr_pull *ndr, int ndr_flags, union winreg_Data *r)
 325 {
 326         int level;
 327         {
 328                 uint32_t _flags_save_UNION = ndr->flags;
 329                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 330                 level = ndr_pull_get_switch_value(ndr, r);
 331                 if (ndr_flags & NDR_SCALARS) {
 332                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
 333                         switch (level) {
 334                                 case REG_NONE: {
 335                                 break; }
 336
 337                                 case REG_SZ: {
 338                                         {
 339                                                 uint32_t _flags_save_string = ndr->flags;
 340                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 341                                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
 342                                                 ndr->flags = _flags_save_string;
 343                                         }
 344                                 break; }
 345
 346                                 case REG_EXPAND_SZ: {
 347                                         {
 348                                                 uint32_t _flags_save_string = ndr->flags;
 349                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 350                                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
 351                                                 ndr->flags = _flags_save_string;
 352                                         }
 353                                 break; }
 354
 355                                 case REG_BINARY: {
 356                                         {
 357                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
 358                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 359                                                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
 360                                                 ndr->flags = _flags_save_DATA_BLOB;
 361                                         }
 362                                 break; }
 363
 364                                 case REG_DWORD: {
 365                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
 366                                 break; }
 367
 368                                 case REG_DWORD_BIG_ENDIAN: {
 369                                         {
 370                                                 uint32_t _flags_save_uint32 = ndr->flags;
 371                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 372                                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
 373                                                 ndr->flags = _flags_save_uint32;
 374                                         }
 375                                 break; }
 376
 377                                 case REG_MULTI_SZ: {
 378                                         {
 379                                                 uint32_t _flags_save_string_array = ndr->flags;
 380                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_ALIGN2);
 381                                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
 382                                                 ndr->flags = _flags_save_string_array;
 383                                         }
 384                                 break; }
 385
 386                                 default: {
 387                                         {
 388                                                 uint32_t _flags_save_DATA_BLOB = ndr->flags;
 389                                                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 390                                                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
 391                                                 ndr->flags = _flags_save_DATA_BLOB;
 392                                         }
 393                                 break; }
 394
 395                         }
 396                 }
 397                 if (ndr_flags & NDR_BUFFERS) {
 398                         switch (level) {
 399                                 case REG_NONE:
 400                                 break;
 401
 402                                 case REG_SZ:
 403                                 break;
 404
 405                                 case REG_EXPAND_SZ:
 406                                 break;
 407
 408                                 case REG_BINARY:
 409                                 break;
 410
 411                                 case REG_DWORD:
 412                                 break;
 413
 414                                 case REG_DWORD_BIG_ENDIAN:
 415                                 break;
 416
 417                                 case REG_MULTI_SZ:
 418                                 break;
 419
 420                                 default:
 421                                 break;
 422
 423                         }
 424                 }
 425                 ndr->flags = _flags_save_UNION;
 426         }
 427         return NDR_ERR_SUCCESS;
 428 }
 429
 430 _PUBLIC_ void ndr_print_winreg_Data(struct ndr_print *ndr, const char *name, const union winreg_Data *r)
 431 {
 432         int level;
 433         {
 434                 uint32_t _flags_save_UNION = ndr->flags;
 435                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 436                 level = ndr_print_get_switch_value(ndr, r);
 437                 ndr_print_union(ndr, name, level, "winreg_Data");
 438                 switch (level) {
 439                         case REG_NONE:
 440                         break;
 441
 442                         case REG_SZ:
 443                                 ndr_print_string(ndr, "string", r->string);
 444                         break;
 445
 446                         case REG_EXPAND_SZ:
 447                                 ndr_print_string(ndr, "string", r->string);
 448                         break;
 449
 450                         case REG_BINARY:
 451                                 ndr_print_DATA_BLOB(ndr, "binary", r->binary);
 452                         break;
 453
 454                         case REG_DWORD:
 455                                 ndr_print_uint32(ndr, "value", r->value);
 456                         break;
 457
 458                         case REG_DWORD_BIG_ENDIAN:
 459                                 ndr_print_uint32(ndr, "value", r->value);
 460                         break;
 461
 462                         case REG_MULTI_SZ:
 463                                 ndr_print_string_array(ndr, "string_array", r->string_array);
 464                         break;
 465
 466                         default:
 467                                 ndr_print_DATA_BLOB(ndr, "data", r->data);
 468                         break;
 469
 470                 }
 471                 ndr->flags = _flags_save_UNION;
 472         }
 473 }
 474