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