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