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_enum_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_enum_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_enum_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_enum_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         if (ndr_flags & NDR_SCALARS) {
 209                 int level = ndr_push_get_switch_value(ndr, r);
 210                 switch (level) {
 211                         case REG_NONE: {
 212                         break; }
 213
 214                         case REG_SZ: {
 215                                 {
 216                                         uint32_t _flags_save_string = ndr->flags;
 217                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 218                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
 219                                         ndr->flags = _flags_save_string;
 220                                 }
 221                         break; }
 222
 223                         case REG_BINARY: {
 224                                 {
 225                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 226                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 227                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
 228                                         ndr->flags = _flags_save_DATA_BLOB;
 229                                 }
 230                         break; }
 231
 232                         case REG_DWORD: {
 233                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
 234                         break; }
 235
 236                         case REG_MULTI_SZ: {
 237                                 {
 238                                         uint32_t _flags_save_string_array = ndr->flags;
 239                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 240                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
 241                                         ndr->flags = _flags_save_string_array;
 242                                 }
 243                         break; }
 244
 245                         default: {
 246                                 {
 247                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 248                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 249                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
 250                                         ndr->flags = _flags_save_DATA_BLOB;
 251                                 }
 252                         break; }
 253
 254                 }
 255         }
 256         if (ndr_flags & NDR_BUFFERS) {
 257                 int level = ndr_push_get_switch_value(ndr, r);
 258                 switch (level) {
 259                         case REG_NONE:
 260                         break;
 261
 262                         case REG_SZ:
 263                         break;
 264
 265                         case REG_BINARY:
 266                         break;
 267
 268                         case REG_DWORD:
 269                         break;
 270
 271                         case REG_MULTI_SZ:
 272                         break;
 273
 274                         default:
 275                         break;
 276
 277                 }
 278         }
 279         return NDR_ERR_SUCCESS;
 280 }
 281
 282 _PUBLIC_ enum ndr_err_code ndr_pull_winreg_Data(struct ndr_pull *ndr, int ndr_flags, union winreg_Data *r)
 283 {
 284         int level;
 285         level = ndr_pull_get_switch_value(ndr, r);
 286         if (ndr_flags & NDR_SCALARS) {
 287                 switch (level) {
 288                         case REG_NONE: {
 289                         break; }
 290
 291                         case REG_SZ: {
 292                                 {
 293                                         uint32_t _flags_save_string = ndr->flags;
 294                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 295                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
 296                                         ndr->flags = _flags_save_string;
 297                                 }
 298                         break; }
 299
 300                         case REG_BINARY: {
 301                                 {
 302                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 303                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 304                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
 305                                         ndr->flags = _flags_save_DATA_BLOB;
 306                                 }
 307                         break; }
 308
 309                         case REG_DWORD: {
 310                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
 311                         break; }
 312
 313                         case REG_MULTI_SZ: {
 314                                 {
 315                                         uint32_t _flags_save_string_array = ndr->flags;
 316                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 317                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
 318                                         ndr->flags = _flags_save_string_array;
 319                                 }
 320                         break; }
 321
 322                         default: {
 323                                 {
 324                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 325                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 326                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
 327                                         ndr->flags = _flags_save_DATA_BLOB;
 328                                 }
 329                         break; }
 330
 331                 }
 332         }
 333         if (ndr_flags & NDR_BUFFERS) {
 334                 switch (level) {
 335                         case REG_NONE:
 336                         break;
 337
 338                         case REG_SZ:
 339                         break;
 340
 341                         case REG_BINARY:
 342                         break;
 343
 344                         case REG_DWORD:
 345                         break;
 346
 347                         case REG_MULTI_SZ:
 348                         break;
 349
 350                         default:
 351                         break;
 352
 353                 }
 354         }
 355         return NDR_ERR_SUCCESS;
 356 }
 357
 358 _PUBLIC_ void ndr_print_winreg_Data(struct ndr_print *ndr, const char *name, const union winreg_Data *r)
 359 {
 360         int level;
 361         level = ndr_print_get_switch_value(ndr, r);
 362         ndr_print_union(ndr, name, level, "winreg_Data");
 363         switch (level) {
 364                 case REG_NONE:
 365                 break;
 366
 367                 case REG_SZ:
 368                         ndr_print_string(ndr, "string", r->string);
 369                 break;
 370
 371                 case REG_BINARY:
 372                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
 373                 break;
 374
 375                 case REG_DWORD:
 376                         ndr_print_uint32(ndr, "value", r->value);
 377                 break;
 378
 379                 case REG_MULTI_SZ:
 380                         ndr_print_string_array(ndr, "string_array", r->string_array);
 381                 break;
 382
 383                 default:
 384                         ndr_print_DATA_BLOB(ndr, "data", r->data);
 385                 break;
 386
 387         }
 388 }
 389