00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "includes.h"
00024
00025 #define NDR_SVAL(ndr, ofs) (NDR_BE(ndr)?RSVAL(ndr->data,ofs):SVAL(ndr->data,ofs))
00026 #define NDR_IVAL(ndr, ofs) (NDR_BE(ndr)?RIVAL(ndr->data,ofs):IVAL(ndr->data,ofs))
00027 #define NDR_IVALS(ndr, ofs) (NDR_BE(ndr)?RIVALS(ndr->data,ofs):IVALS(ndr->data,ofs))
00028 #define NDR_SSVAL(ndr, ofs, v) do { if (NDR_BE(ndr)) { RSSVAL(ndr->data,ofs,v); } else SSVAL(ndr->data,ofs,v); } while (0)
00029 #define NDR_SIVAL(ndr, ofs, v) do { if (NDR_BE(ndr)) { RSIVAL(ndr->data,ofs,v); } else SIVAL(ndr->data,ofs,v); } while (0)
00030 #define NDR_SIVALS(ndr, ofs, v) do { if (NDR_BE(ndr)) { RSIVALS(ndr->data,ofs,v); } else SIVALS(ndr->data,ofs,v); } while (0)
00031
00032
00033
00034
00035
00036
00037
00038 void ndr_check_padding(struct ndr_pull *ndr, size_t n)
00039 {
00040 size_t ofs2 = (ndr->offset + (n-1)) & ~(n-1);
00041 int i;
00042 for (i=ndr->offset;i<ofs2;i++) {
00043 if (ndr->data[i] != 0) {
00044 break;
00045 }
00046 }
00047 if (i<ofs2) {
00048 DEBUG(0,("WARNING: Non-zero padding to %d: ", (int)n));
00049 for (i=ndr->offset;i<ofs2;i++) {
00050 DEBUG(0,("%02x ", ndr->data[i]));
00051 }
00052 DEBUG(0,("\n"));
00053 }
00054
00055 }
00056
00057
00058
00059
00060 NTSTATUS ndr_pull_int8(struct ndr_pull *ndr, int ndr_flags, int8_t *v)
00061 {
00062 NDR_PULL_NEED_BYTES(ndr, 1);
00063 *v = (int8_t)CVAL(ndr->data, ndr->offset);
00064 ndr->offset += 1;
00065 return NT_STATUS_OK;
00066 }
00067
00068
00069
00070
00071 NTSTATUS ndr_pull_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v)
00072 {
00073 NDR_PULL_NEED_BYTES(ndr, 1);
00074 *v = CVAL(ndr->data, ndr->offset);
00075 ndr->offset += 1;
00076 return NT_STATUS_OK;
00077 }
00078
00079
00080
00081
00082 NTSTATUS ndr_pull_int16(struct ndr_pull *ndr, int ndr_flags, int16_t *v)
00083 {
00084 NDR_PULL_ALIGN(ndr, 2);
00085 NDR_PULL_NEED_BYTES(ndr, 2);
00086 *v = (uint16_t)NDR_SVAL(ndr, ndr->offset);
00087 ndr->offset += 2;
00088 return NT_STATUS_OK;
00089 }
00090
00091
00092
00093
00094 NTSTATUS ndr_pull_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
00095 {
00096 NDR_PULL_ALIGN(ndr, 2);
00097 NDR_PULL_NEED_BYTES(ndr, 2);
00098 *v = NDR_SVAL(ndr, ndr->offset);
00099 ndr->offset += 2;
00100 return NT_STATUS_OK;
00101 }
00102
00103
00104
00105
00106 NTSTATUS ndr_pull_int32(struct ndr_pull *ndr, int ndr_flags, int32_t *v)
00107 {
00108 NDR_PULL_ALIGN(ndr, 4);
00109 NDR_PULL_NEED_BYTES(ndr, 4);
00110 *v = NDR_IVALS(ndr, ndr->offset);
00111 ndr->offset += 4;
00112 return NT_STATUS_OK;
00113 }
00114
00115
00116
00117
00118 NTSTATUS ndr_pull_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
00119 {
00120 NDR_PULL_ALIGN(ndr, 4);
00121 NDR_PULL_NEED_BYTES(ndr, 4);
00122 *v = NDR_IVAL(ndr, ndr->offset);
00123 ndr->offset += 4;
00124 return NT_STATUS_OK;
00125 }
00126
00127
00128
00129
00130 NTSTATUS ndr_pull_generic_ptr(struct ndr_pull *ndr, uint32_t *v)
00131 {
00132 NTSTATUS status;
00133 status = ndr_pull_uint32(ndr, NDR_SCALARS, v);
00134 if (NT_STATUS_IS_OK(status) && *v != 0) {
00135 ndr->ptr_count++;
00136 }
00137 return status;
00138 }
00139
00140
00141
00142
00143 NTSTATUS ndr_pull_ref_ptr(struct ndr_pull *ndr, uint32_t *v)
00144 {
00145 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, v));
00146
00147 *v = 1;
00148 return NT_STATUS_OK;
00149 }
00150
00151
00152
00153
00154 NTSTATUS ndr_pull_udlong(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
00155 {
00156 NDR_PULL_ALIGN(ndr, 4);
00157 NDR_PULL_NEED_BYTES(ndr, 8);
00158 *v = NDR_IVAL(ndr, ndr->offset);
00159 *v |= (uint64_t)(NDR_IVAL(ndr, ndr->offset+4)) << 32;
00160 ndr->offset += 8;
00161 return NT_STATUS_OK;
00162 }
00163
00164
00165
00166
00167 NTSTATUS ndr_pull_udlongr(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
00168 {
00169 NDR_PULL_ALIGN(ndr, 4);
00170 NDR_PULL_NEED_BYTES(ndr, 8);
00171 *v = ((uint64_t)NDR_IVAL(ndr, ndr->offset)) << 32;
00172 *v |= NDR_IVAL(ndr, ndr->offset+4);
00173 ndr->offset += 8;
00174 return NT_STATUS_OK;
00175 }
00176
00177
00178
00179
00180 NTSTATUS ndr_pull_dlong(struct ndr_pull *ndr, int ndr_flags, int64_t *v)
00181 {
00182 return ndr_pull_udlong(ndr, ndr_flags, (uint64_t *)v);
00183 }
00184
00185
00186
00187
00188 NTSTATUS ndr_pull_hyper(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
00189 {
00190 NDR_PULL_ALIGN(ndr, 8);
00191 return ndr_pull_udlong(ndr, ndr_flags, v);
00192 }
00193
00194
00195
00196
00197 NTSTATUS ndr_pull_pointer(struct ndr_pull *ndr, int ndr_flags, void* *v)
00198 {
00199 intptr_t h;
00200 NDR_PULL_ALIGN(ndr, sizeof(h));
00201 NDR_PULL_NEED_BYTES(ndr, sizeof(h));
00202 memcpy(&h, ndr->data+ndr->offset, sizeof(h));
00203 ndr->offset += sizeof(h);
00204 *v = (void *)h;
00205 return NT_STATUS_OK;
00206 }
00207
00208
00209
00210
00211 NTSTATUS ndr_pull_NTSTATUS(struct ndr_pull *ndr, int ndr_flags, NTSTATUS *status)
00212 {
00213 uint32_t v;
00214 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
00215 *status = NT_STATUS(v);
00216 return NT_STATUS_OK;
00217 }
00218
00219
00220
00221
00222 NTSTATUS ndr_push_NTSTATUS(struct ndr_push *ndr, int ndr_flags, NTSTATUS status)
00223 {
00224 return ndr_push_uint32(ndr, ndr_flags, NT_STATUS_V(status));
00225 }
00226
00227 void ndr_print_NTSTATUS(struct ndr_print *ndr, const char *name, NTSTATUS r)
00228 {
00229 ndr->print(ndr, "%-25s: %s", name, nt_errstr(r));
00230 }
00231
00232
00233
00234
00235 NTSTATUS ndr_pull_WERROR(struct ndr_pull *ndr, int ndr_flags, WERROR *status)
00236 {
00237 uint32_t v;
00238 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
00239 *status = W_ERROR(v);
00240 return NT_STATUS_OK;
00241 }
00242
00243
00244
00245
00246 NTSTATUS ndr_push_WERROR(struct ndr_push *ndr, int ndr_flags, WERROR status)
00247 {
00248 return ndr_push_uint32(ndr, NDR_SCALARS, W_ERROR_V(status));
00249 }
00250
00251 void ndr_print_WERROR(struct ndr_print *ndr, const char *name, WERROR r)
00252 {
00253 ndr->print(ndr, "%-25s: %s", name, dos_errstr(r));
00254 }
00255
00256
00257
00258
00259 NTSTATUS ndr_pull_bytes(struct ndr_pull *ndr, uint8_t *data, uint32_t n)
00260 {
00261 NDR_PULL_NEED_BYTES(ndr, n);
00262 memcpy(data, ndr->data + ndr->offset, n);
00263 ndr->offset += n;
00264 return NT_STATUS_OK;
00265 }
00266
00267
00268
00269
00270 NTSTATUS ndr_pull_array_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *data, uint32_t n)
00271 {
00272 if (!(ndr_flags & NDR_SCALARS)) {
00273 return NT_STATUS_OK;
00274 }
00275 return ndr_pull_bytes(ndr, data, n);
00276 }
00277
00278
00279
00280
00281 NTSTATUS ndr_push_int8(struct ndr_push *ndr, int ndr_flags, int8_t v)
00282 {
00283 NDR_PUSH_NEED_BYTES(ndr, 1);
00284 SCVAL(ndr->data, ndr->offset, (uint8_t)v);
00285 ndr->offset += 1;
00286 return NT_STATUS_OK;
00287 }
00288
00289
00290
00291
00292 NTSTATUS ndr_push_uint8(struct ndr_push *ndr, int ndr_flags, uint8_t v)
00293 {
00294 NDR_PUSH_NEED_BYTES(ndr, 1);
00295 SCVAL(ndr->data, ndr->offset, v);
00296 ndr->offset += 1;
00297 return NT_STATUS_OK;
00298 }
00299
00300
00301
00302
00303 NTSTATUS ndr_push_int16(struct ndr_push *ndr, int ndr_flags, int16_t v)
00304 {
00305 NDR_PUSH_ALIGN(ndr, 2);
00306 NDR_PUSH_NEED_BYTES(ndr, 2);
00307 NDR_SSVAL(ndr, ndr->offset, (uint16_t)v);
00308 ndr->offset += 2;
00309 return NT_STATUS_OK;
00310 }
00311
00312
00313
00314
00315 NTSTATUS ndr_push_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v)
00316 {
00317 NDR_PUSH_ALIGN(ndr, 2);
00318 NDR_PUSH_NEED_BYTES(ndr, 2);
00319 NDR_SSVAL(ndr, ndr->offset, v);
00320 ndr->offset += 2;
00321 return NT_STATUS_OK;
00322 }
00323
00324
00325
00326
00327 NTSTATUS ndr_push_int32(struct ndr_push *ndr, int ndr_flags, int32_t v)
00328 {
00329 NDR_PUSH_ALIGN(ndr, 4);
00330 NDR_PUSH_NEED_BYTES(ndr, 4);
00331 NDR_SIVALS(ndr, ndr->offset, v);
00332 ndr->offset += 4;
00333 return NT_STATUS_OK;
00334 }
00335
00336
00337
00338
00339 NTSTATUS ndr_push_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v)
00340 {
00341 NDR_PUSH_ALIGN(ndr, 4);
00342 NDR_PUSH_NEED_BYTES(ndr, 4);
00343 NDR_SIVAL(ndr, ndr->offset, v);
00344 ndr->offset += 4;
00345 return NT_STATUS_OK;
00346 }
00347
00348
00349
00350
00351 NTSTATUS ndr_push_udlong(struct ndr_push *ndr, int ndr_flags, uint64_t v)
00352 {
00353 NDR_PUSH_ALIGN(ndr, 4);
00354 NDR_PUSH_NEED_BYTES(ndr, 8);
00355 NDR_SIVAL(ndr, ndr->offset, (v & 0xFFFFFFFF));
00356 NDR_SIVAL(ndr, ndr->offset+4, (v>>32));
00357 ndr->offset += 8;
00358 return NT_STATUS_OK;
00359 }
00360
00361
00362
00363
00364 NTSTATUS ndr_push_udlongr(struct ndr_push *ndr, int ndr_flags, uint64_t v)
00365 {
00366 NDR_PUSH_ALIGN(ndr, 4);
00367 NDR_PUSH_NEED_BYTES(ndr, 8);
00368 NDR_SIVAL(ndr, ndr->offset, (v>>32));
00369 NDR_SIVAL(ndr, ndr->offset+4, (v & 0xFFFFFFFF));
00370 ndr->offset += 8;
00371 return NT_STATUS_OK;
00372 }
00373
00374
00375
00376
00377 NTSTATUS ndr_push_dlong(struct ndr_push *ndr, int ndr_flags, int64_t v)
00378 {
00379 return ndr_push_udlong(ndr, NDR_SCALARS, (uint64_t)v);
00380 }
00381
00382
00383
00384
00385 NTSTATUS ndr_push_hyper(struct ndr_push *ndr, int ndr_flags, uint64_t v)
00386 {
00387 NDR_PUSH_ALIGN(ndr, 8);
00388 return ndr_push_udlong(ndr, NDR_SCALARS, v);
00389 }
00390
00391
00392
00393
00394 NTSTATUS ndr_push_pointer(struct ndr_push *ndr, int ndr_flags, void* v)
00395 {
00396 intptr_t h = (intptr_t)v;
00397 NDR_PUSH_ALIGN(ndr, sizeof(h));
00398 NDR_PUSH_NEED_BYTES(ndr, sizeof(h));
00399 memcpy(ndr->data+ndr->offset, &h, sizeof(h));
00400 ndr->offset += sizeof(h);
00401 return NT_STATUS_OK;
00402 }
00403
00404 NTSTATUS ndr_push_align(struct ndr_push *ndr, size_t size)
00405 {
00406 NDR_PUSH_ALIGN(ndr, size);
00407 return NT_STATUS_OK;
00408 }
00409
00410 NTSTATUS ndr_pull_align(struct ndr_pull *ndr, size_t size)
00411 {
00412 NDR_PULL_ALIGN(ndr, size);
00413 return NT_STATUS_OK;
00414 }
00415
00416
00417
00418
00419 NTSTATUS ndr_push_bytes(struct ndr_push *ndr, const uint8_t *data, uint32_t n)
00420 {
00421 NDR_PUSH_NEED_BYTES(ndr, n);
00422 memcpy(ndr->data + ndr->offset, data, n);
00423 ndr->offset += n;
00424 return NT_STATUS_OK;
00425 }
00426
00427
00428
00429
00430 NTSTATUS ndr_push_zero(struct ndr_push *ndr, uint32_t n)
00431 {
00432 NDR_PUSH_NEED_BYTES(ndr, n);
00433 memset(ndr->data + ndr->offset, 0, n);
00434 ndr->offset += n;
00435 return NT_STATUS_OK;
00436 }
00437
00438
00439
00440
00441 NTSTATUS ndr_push_array_uint8(struct ndr_push *ndr, int ndr_flags, const uint8_t *data, uint32_t n)
00442 {
00443 if (!(ndr_flags & NDR_SCALARS)) {
00444 return NT_STATUS_OK;
00445 }
00446 return ndr_push_bytes(ndr, data, n);
00447 }
00448
00449
00450
00451
00452 void ndr_push_save(struct ndr_push *ndr, struct ndr_push_save *save)
00453 {
00454 save->offset = ndr->offset;
00455 }
00456
00457
00458
00459
00460 void ndr_push_restore(struct ndr_push *ndr, struct ndr_push_save *save)
00461 {
00462 ndr->offset = save->offset;
00463 }
00464
00465
00466
00467
00468 NTSTATUS ndr_push_unique_ptr(struct ndr_push *ndr, const void *p)
00469 {
00470 uint32_t ptr = 0;
00471 if (p) {
00472 ptr = ndr->ptr_count * 4;
00473 ptr |= 0x00020000;
00474 ndr->ptr_count++;
00475 }
00476 return ndr_push_uint32(ndr, NDR_SCALARS, ptr);
00477 }
00478
00479
00480
00481
00482 NTSTATUS ndr_push_sptr_ptr(struct ndr_push *ndr, const void *p)
00483 {
00484 uint32_t ptr = 0;
00485 if (p) {
00486 ndr->ptr_count++;
00487 ptr = ndr->ptr_count;
00488 }
00489 return ndr_push_uint32(ndr, NDR_SCALARS, ptr);
00490 }
00491
00492
00493
00494
00495 NTSTATUS ndr_push_ref_ptr(struct ndr_push *ndr)
00496 {
00497 return ndr_push_uint32(ndr, NDR_SCALARS, 0xAEF1AEF1);
00498 }
00499
00500
00501
00502
00503 NTSTATUS ndr_push_NTTIME(struct ndr_push *ndr, int ndr_flags, NTTIME t)
00504 {
00505 NDR_CHECK(ndr_push_udlong(ndr, ndr_flags, t));
00506 return NT_STATUS_OK;
00507 }
00508
00509
00510
00511
00512 NTSTATUS ndr_pull_NTTIME(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
00513 {
00514 NDR_CHECK(ndr_pull_udlong(ndr, ndr_flags, t));
00515 return NT_STATUS_OK;
00516 }
00517
00518
00519
00520
00521 NTSTATUS ndr_push_NTTIME_1sec(struct ndr_push *ndr, int ndr_flags, NTTIME t)
00522 {
00523 t /= 10000000;
00524 NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
00525 return NT_STATUS_OK;
00526 }
00527
00528
00529
00530
00531 NTSTATUS ndr_pull_NTTIME_1sec(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
00532 {
00533 NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
00534 (*t) *= 10000000;
00535 return NT_STATUS_OK;
00536 }
00537
00538
00539
00540
00541 NTSTATUS ndr_pull_NTTIME_hyper(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
00542 {
00543 NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
00544 return NT_STATUS_OK;
00545 }
00546
00547
00548
00549
00550 NTSTATUS ndr_push_NTTIME_hyper(struct ndr_push *ndr, int ndr_flags, NTTIME t)
00551 {
00552 NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
00553 return NT_STATUS_OK;
00554 }
00555
00556
00557
00558
00559 NTSTATUS ndr_push_time_t(struct ndr_push *ndr, int ndr_flags, time_t t)
00560 {
00561 return ndr_push_uint32(ndr, ndr_flags, t);
00562 }
00563
00564
00565
00566
00567 NTSTATUS ndr_pull_time_t(struct ndr_pull *ndr, int ndr_flags, time_t *t)
00568 {
00569 uint32_t tt;
00570 NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &tt));
00571 *t = tt;
00572 return NT_STATUS_OK;
00573 }
00574
00575
00576 void ndr_print_struct(struct ndr_print *ndr, const char *name, const char *type)
00577 {
00578 ndr->print(ndr, "%s: struct %s", name, type);
00579 }
00580
00581 void ndr_print_enum(struct ndr_print *ndr, const char *name, const char *type,
00582 const char *val, uint32_t value)
00583 {
00584 if (ndr->flags & LIBNDR_PRINT_ARRAY_HEX) {
00585 ndr->print(ndr, "%-25s: %s (0x%X)", name, val?val:"UNKNOWN_ENUM_VALUE", value);
00586 } else {
00587 ndr->print(ndr, "%-25s: %s (%d)", name, val?val:"UNKNOWN_ENUM_VALUE", value);
00588 }
00589 }
00590
00591 void ndr_print_bitmap_flag(struct ndr_print *ndr, size_t size, const char *flag_name, uint32_t flag, uint32_t value)
00592 {
00593
00594 value &= flag;
00595
00596 while (!(flag & 1)) {
00597 flag >>= 1;
00598 value >>= 1;
00599 }
00600 if (flag == 1) {
00601 ndr->print(ndr, " %d: %-25s", value, flag_name);
00602 } else {
00603 ndr->print(ndr, "0x%02x: %-25s (%d)", value, flag_name, value);
00604 }
00605 }
00606
00607 void ndr_print_int8(struct ndr_print *ndr, const char *name, int8_t v)
00608 {
00609 ndr->print(ndr, "%-25s: %d", name, v);
00610 }
00611
00612 void ndr_print_uint8(struct ndr_print *ndr, const char *name, uint8_t v)
00613 {
00614 ndr->print(ndr, "%-25s: 0x%02x (%u)", name, v, v);
00615 }
00616
00617 void ndr_print_int16(struct ndr_print *ndr, const char *name, int16_t v)
00618 {
00619 ndr->print(ndr, "%-25s: %d", name, v);
00620 }
00621
00622 void ndr_print_uint16(struct ndr_print *ndr, const char *name, uint16_t v)
00623 {
00624 ndr->print(ndr, "%-25s: 0x%04x (%u)", name, v, v);
00625 }
00626
00627 void ndr_print_int32(struct ndr_print *ndr, const char *name, int32_t v)
00628 {
00629 ndr->print(ndr, "%-25s: %d", name, v);
00630 }
00631
00632 void ndr_print_uint32(struct ndr_print *ndr, const char *name, uint32_t v)
00633 {
00634 ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
00635 }
00636
00637 void ndr_print_udlong(struct ndr_print *ndr, const char *name, uint64_t v)
00638 {
00639 ndr->print(ndr, "%-25s: 0x%016llx (%llu)", name, v, v);
00640 }
00641
00642 void ndr_print_udlongr(struct ndr_print *ndr, const char *name, uint64_t v)
00643 {
00644 ndr_print_udlong(ndr, name, v);
00645 }
00646
00647 void ndr_print_dlong(struct ndr_print *ndr, const char *name, int64_t v)
00648 {
00649 ndr->print(ndr, "%-25s: 0x%016llx (%lld)", name, v, v);
00650 }
00651
00652 void ndr_print_hyper(struct ndr_print *ndr, const char *name, uint64_t v)
00653 {
00654 ndr_print_dlong(ndr, name, v);
00655 }
00656
00657 void ndr_print_pointer(struct ndr_print *ndr, const char *name, void *v)
00658 {
00659 ndr->print(ndr, "%-25s: %p", name, v);
00660 }
00661
00662 void ndr_print_ptr(struct ndr_print *ndr, const char *name, const void *p)
00663 {
00664 if (p) {
00665 ndr->print(ndr, "%-25s: *", name);
00666 } else {
00667 ndr->print(ndr, "%-25s: NULL", name);
00668 }
00669 }
00670
00671 void ndr_print_NTTIME(struct ndr_print *ndr, const char *name, NTTIME t)
00672 {
00673 ndr->print(ndr, "%-25s: %s", name, nt_time_string(ndr, t));
00674 }
00675
00676 void ndr_print_NTTIME_1sec(struct ndr_print *ndr, const char *name, NTTIME t)
00677 {
00678
00679
00680
00681 ndr_print_NTTIME(ndr, name, t);
00682 }
00683
00684 void ndr_print_NTTIME_hyper(struct ndr_print *ndr, const char *name, NTTIME t)
00685 {
00686 ndr_print_NTTIME(ndr, name, t);
00687 }
00688
00689 void ndr_print_time_t(struct ndr_print *ndr, const char *name, time_t t)
00690 {
00691 if (t == (time_t)-1 || t == 0) {
00692 ndr->print(ndr, "%-25s: (time_t)%d", name, (int)t);
00693 } else {
00694 ndr->print(ndr, "%-25s: %s", name, timestring(ndr, t));
00695 }
00696 }
00697
00698 void ndr_print_union(struct ndr_print *ndr, const char *name, int level, const char *type)
00699 {
00700 if (ndr->flags & LIBNDR_PRINT_ARRAY_HEX) {
00701 ndr->print(ndr, "%-25s: union %s(case 0x%X)", name, type, level);
00702 } else {
00703 ndr->print(ndr, "%-25s: union %s(case %d)", name, type, level);
00704 }
00705 }
00706
00707 void ndr_print_bad_level(struct ndr_print *ndr, const char *name, uint16_t level)
00708 {
00709 ndr->print(ndr, "UNKNOWN LEVEL %u", level);
00710 }
00711
00712 void ndr_print_array_uint8(struct ndr_print *ndr, const char *name,
00713 const uint8_t *data, uint32_t count)
00714 {
00715 int i;
00716
00717 if (count <= 600 && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
00718 char s[1202];
00719 for (i=0;i<count;i++) {
00720 snprintf(&s[i*2], 3, "%02x", data[i]);
00721 }
00722 s[i*2] = 0;
00723 ndr->print(ndr, "%-25s: %s", name, s);
00724 return;
00725 }
00726
00727 ndr->print(ndr, "%s: ARRAY(%d)", name, count);
00728 ndr->depth++;
00729 for (i=0;i<count;i++) {
00730 char *idx=NULL;
00731 asprintf(&idx, "[%d]", i);
00732 if (idx) {
00733 ndr_print_uint8(ndr, idx, data[i]);
00734 free(idx);
00735 }
00736 }
00737 ndr->depth--;
00738 }
00739
00740 void ndr_print_DATA_BLOB(struct ndr_print *ndr, const char *name, DATA_BLOB r)
00741 {
00742 ndr->print(ndr, "%-25s: DATA_BLOB length=%u", name, r.length);
00743 if (r.length) {
00744 dump_data(10, (const char *)r.data, r.length);
00745 }
00746 }
00747
00748
00749
00750
00751
00752 NTSTATUS ndr_push_DATA_BLOB(struct ndr_push *ndr, int ndr_flags, DATA_BLOB blob)
00753 {
00754 if (ndr->flags & LIBNDR_ALIGN_FLAGS) {
00755 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
00756 blob.length = NDR_ALIGN(ndr, 2);
00757 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
00758 blob.length = NDR_ALIGN(ndr, 4);
00759 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
00760 blob.length = NDR_ALIGN(ndr, 8);
00761 }
00762 NDR_PUSH_ALLOC_SIZE(ndr, blob.data, blob.length);
00763 data_blob_clear(&blob);
00764 } else if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
00765 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, blob.length));
00766 }
00767 NDR_CHECK(ndr_push_bytes(ndr, blob.data, blob.length));
00768 return NT_STATUS_OK;
00769 }
00770
00771
00772
00773
00774 NTSTATUS ndr_pull_DATA_BLOB(struct ndr_pull *ndr, int ndr_flags, DATA_BLOB *blob)
00775 {
00776 uint32_t length = 0;
00777
00778 if (ndr->flags & LIBNDR_ALIGN_FLAGS) {
00779 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
00780 length = NDR_ALIGN(ndr, 2);
00781 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
00782 length = NDR_ALIGN(ndr, 4);
00783 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
00784 length = NDR_ALIGN(ndr, 8);
00785 }
00786 if (ndr->data_size - ndr->offset < length) {
00787 length = ndr->data_size - ndr->offset;
00788 }
00789 } else if (ndr->flags & LIBNDR_FLAG_REMAINING) {
00790 length = ndr->data_size - ndr->offset;
00791 } else {
00792 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &length));
00793 }
00794 NDR_PULL_NEED_BYTES(ndr, length);
00795 *blob = data_blob_talloc(ndr->current_mem_ctx, ndr->data+ndr->offset, length);
00796 ndr->offset += length;
00797 return NT_STATUS_OK;
00798 }
00799
00800 uint32_t ndr_size_DATA_BLOB(int ret, const DATA_BLOB *data, int flags)
00801 {
00802 return ret + data->length;
00803 }