~zulcss/samba/server-dailies-3.4

ndr_print_uint32(ndr, "strings_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * ndr_size_string_array(r->strings, r->num_of_strings, LIBNDR_FLAG_STR_NULLTERM):r->strings_len);

252

ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->num_of_strings);

253

ndr->depth++;

254

for (cntr_strings_0=0;cntr_strings_0<r->num_of_strings;cntr_strings_0++) {

255

char *idx_0=NULL;

256

if (asprintf(&idx_0, "[%d]", cntr_strings_0) != -1) {

257

ndr_print_string(ndr, "strings", r->strings[cntr_strings_0]);

258

free(idx_0);

259

}

260

}

261

ndr->depth--;

262

ndr_print_DATA_BLOB(ndr, "data", r->data);

263

ndr_print_uint32(ndr, "padding", r->padding);

264

ndr->depth--;

265

ndr->flags = _flags_save_STRUCT;

266

}

267

}

268

269

static enum ndr_err_code ndr_push_EVENTLOG_HEADER_FLAGS(struct ndr_push *ndr, int ndr_flags, enum EVENTLOG_HEADER_FLAGS r)

270

{

271

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));

272

return NDR_ERR_SUCCESS;

273

}

274

275

static enum ndr_err_code ndr_pull_EVENTLOG_HEADER_FLAGS(struct ndr_pull *ndr, int ndr_flags, enum EVENTLOG_HEADER_FLAGS *r)

276

{

277

uint32_t v;

278

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));

279

*r = v;

280

return NDR_ERR_SUCCESS;

281

}

282

283

_PUBLIC_ void ndr_print_EVENTLOG_HEADER_FLAGS(struct ndr_print *ndr, const char *name, enum EVENTLOG_HEADER_FLAGS r)

284

{

285

const char *val = NULL;

286

287

switch (r) {

288

case ELF_LOGFILE_HEADER_DIRTY: val = "ELF_LOGFILE_HEADER_DIRTY"; break;

289

case ELF_LOGFILE_HEADER_WRAP: val = "ELF_LOGFILE_HEADER_WRAP"; break;

290

case ELF_LOGFILE_LOGFULL_WRITTEN: val = "ELF_LOGFILE_LOGFULL_WRITTEN"; break;

291

case ELF_LOGFILE_ARCHIVE_SET: val = "ELF_LOGFILE_ARCHIVE_SET"; break;

292

}

293

ndr_print_enum(ndr, name, "ENUM", val, r);

294

}

295

296

_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGHEADER(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOGHEADER *r)

297

{

298

if (ndr_flags & NDR_SCALARS) {

299

NDR_CHECK(ndr_push_align(ndr, 4));

300

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x30));

301

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "LfLe", 4, sizeof(uint8_t), CH_DOS));

302

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));

303

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));

304

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->StartOffset));

305

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EndOffset));

306

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CurrentRecordNumber));

307

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->OldestRecordNumber));

308

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->MaxSize));

309

NDR_CHECK(ndr_push_EVENTLOG_HEADER_FLAGS(ndr, NDR_SCALARS, r->Flags));

310

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Retention));

311

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x30));

312

}

313

if (ndr_flags & NDR_BUFFERS) {

314

}

315

return NDR_ERR_SUCCESS;

316

}

317

318

_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGHEADER(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOGHEADER *r)

319

{

320

if (ndr_flags & NDR_SCALARS) {

321

NDR_CHECK(ndr_pull_align(ndr, 4));

322

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->HeaderSize));

323

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Signature, 4, sizeof(uint8_t), CH_DOS));

324

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MajorVersion));

325

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MinorVersion));

326

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->StartOffset));

327

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndOffset));

328

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CurrentRecordNumber));

329

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->OldestRecordNumber));

330

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->MaxSize));

331

NDR_CHECK(ndr_pull_EVENTLOG_HEADER_FLAGS(ndr, NDR_SCALARS, &r->Flags));

332

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Retention));

333

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndHeaderSize));

334

}

335

if (ndr_flags & NDR_BUFFERS) {

336

}

337

return NDR_ERR_SUCCESS;

338

}

339

340

_PUBLIC_ void ndr_print_EVENTLOGHEADER(struct ndr_print *ndr, const char *name, const struct EVENTLOGHEADER *r)

341

{

342

ndr_print_struct(ndr, name, "EVENTLOGHEADER");

343

ndr->depth++;

344

ndr_print_uint32(ndr, "HeaderSize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x30:r->HeaderSize);

345

ndr_print_string(ndr, "Signature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"LfLe":r->Signature);

346

ndr_print_uint32(ndr, "MajorVersion", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->MajorVersion);

347

ndr_print_uint32(ndr, "MinorVersion", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->MinorVersion);

348

ndr_print_uint32(ndr, "StartOffset", r->StartOffset);

349

ndr_print_uint32(ndr, "EndOffset", r->EndOffset);

350

ndr_print_uint32(ndr, "CurrentRecordNumber", r->CurrentRecordNumber);

351

ndr_print_uint32(ndr, "OldestRecordNumber", r->OldestRecordNumber);

352

ndr_print_uint32(ndr, "MaxSize", r->MaxSize);

353

ndr_print_EVENTLOG_HEADER_FLAGS(ndr, "Flags", r->Flags);

354

ndr_print_uint32(ndr, "Retention", r->Retention);

355

ndr_print_uint32(ndr, "EndHeaderSize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x30:r->EndHeaderSize);

356

ndr->depth--;

357

}

358

359

_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGRECORD(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOGRECORD *r)

360

{

361

uint32_t cntr_Strings_0;

362

if (ndr_flags & NDR_SCALARS) {

363

NDR_CHECK(ndr_push_align(ndr, 4));

364

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Length));

365

NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, "LfLe", 4, sizeof(uint8_t), CH_DOS));

366

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->RecordNumber));

367

NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->TimeGenerated));

368

NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->TimeWritten));

369

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EventID));

370

NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->EventType));

371

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->NumStrings));

372

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->EventCategory));

373

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ReservedFlags));

374

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ClosingRecordNumber));

375

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + ndr_size_dom_sid0(&r->UserSid, ndr->flags)));

376

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid0(&r->UserSid, ndr->flags)));

377

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername))));

378

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->DataLength));

379

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + ndr_size_dom_sid0(&r->UserSid, ndr->flags) + (2 * ndr_size_string_array(r->Strings, r->NumStrings, LIBNDR_FLAG_STR_NULLTERM))));

380

{

381

uint32_t _flags_save_string = ndr->flags;

382

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

383

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->SourceName));

384

ndr->flags = _flags_save_string;

385

}

386

{

387

uint32_t _flags_save_string = ndr->flags;

388

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

389

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Computername));

390

ndr->flags = _flags_save_string;

391

}

392

{

393

uint32_t _flags_save_dom_sid0 = ndr->flags;

394

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);

395

{

396

struct ndr_push *_ndr_UserSid;

397

NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_UserSid, 0, ndr_size_dom_sid0(&r->UserSid, ndr->flags)));

398

NDR_CHECK(ndr_push_dom_sid0(_ndr_UserSid, NDR_SCALARS|NDR_BUFFERS, &r->UserSid));

399

NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_UserSid, 0, ndr_size_dom_sid0(&r->UserSid, ndr->flags)));

400

}

401

ndr->flags = _flags_save_dom_sid0;

402

}

403

{

404

uint32_t _flags_save_string = ndr->flags;

405

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

406

for (cntr_Strings_0 = 0; cntr_Strings_0 < r->NumStrings; cntr_Strings_0++) {

407

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Strings[cntr_Strings_0]));

408

}

409

ndr->flags = _flags_save_string;

410

}

411

{

412

uint32_t _flags_save_uint8 = ndr->flags;

413

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

414

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->Data, r->DataLength));

415

ndr->flags = _flags_save_uint8;

416

}

417

{

418

uint32_t _flags_save_string = ndr->flags;

419

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

420

NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->Pad));

421

ndr->flags = _flags_save_string;

422

}

423

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->Length));

424

}

425

if (ndr_flags & NDR_BUFFERS) {

426

{

427

uint32_t _flags_save_dom_sid0 = ndr->flags;

428

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);

429

ndr->flags = _flags_save_dom_sid0;

430

}

431

}

432

return NDR_ERR_SUCCESS;

433

}

434

435

_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGRECORD(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOGRECORD *r)

436

{

437

uint32_t cntr_Strings_0;

438

TALLOC_CTX *_mem_save_Strings_0;

439

if (ndr_flags & NDR_SCALARS) {

440

NDR_CHECK(ndr_pull_align(ndr, 4));

441

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Length));

442

NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->Reserved, 4, sizeof(uint8_t), CH_DOS));

443

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordNumber));

444

NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->TimeGenerated));

445

NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->TimeWritten));

446

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EventID));

447

NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->EventType));

448

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->NumStrings));

449

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->EventCategory));

450

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ReservedFlags));

451

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ClosingRecordNumber));

452

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->StringOffset));

453

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->UserSidLength));

454

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->UserSidOffset));

455

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DataLength));

456

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->DataOffset));

457

{

458

uint32_t _flags_save_string = ndr->flags;

459

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

460

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->SourceName));

461

ndr->flags = _flags_save_string;

462

}

463

{

464

uint32_t _flags_save_string = ndr->flags;

465

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

466

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Computername));

467

ndr->flags = _flags_save_string;

468

}

469

{

470

uint32_t _flags_save_dom_sid0 = ndr->flags;

471

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);

472

{

473

struct ndr_pull *_ndr_UserSid;

474

NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_UserSid, 0, r->UserSidLength));

475

NDR_CHECK(ndr_pull_dom_sid0(_ndr_UserSid, NDR_SCALARS|NDR_BUFFERS, &r->UserSid));

476

NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_UserSid, 0, r->UserSidLength));

477

}

478

ndr->flags = _flags_save_dom_sid0;

479

}

480

{

481

uint32_t _flags_save_string = ndr->flags;

482

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);

483

NDR_PULL_ALLOC_N(ndr, r->Strings, r->NumStrings);

484

_mem_save_Strings_0 = NDR_PULL_GET_MEM_CTX(ndr);

485

NDR_PULL_SET_MEM_CTX(ndr, r->Strings, 0);

486

for (cntr_Strings_0 = 0; cntr_Strings_0 < r->NumStrings; cntr_Strings_0++) {

487

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Strings[cntr_Strings_0]));

488

}

489

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_Strings_0, 0);

490

ndr->flags = _flags_save_string;

491

}

492

{

493

uint32_t _flags_save_uint8 = ndr->flags;

494

ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);

495

NDR_PULL_ALLOC_N(ndr, r->Data, r->DataLength);

496

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->Data, r->DataLength));

497

ndr->flags = _flags_save_uint8;

498

}

499

{

500

uint32_t _flags_save_string = ndr->flags;

501

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);

502

NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->Pad));

503

ndr->flags = _flags_save_string;

504

}

505

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Length2));

506

}

507

if (ndr_flags & NDR_BUFFERS) {

508

{

509

uint32_t _flags_save_dom_sid0 = ndr->flags;

510

ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);

511

ndr->flags = _flags_save_dom_sid0;

512

}

513

}

514

return NDR_ERR_SUCCESS;

515

}

516

517

_PUBLIC_ void ndr_print_EVENTLOGRECORD(struct ndr_print *ndr, const char *name, const struct EVENTLOGRECORD *r)

518

{

519

uint32_t cntr_Strings_0;

520

ndr_print_struct(ndr, name, "EVENTLOGRECORD");

521

ndr->depth++;

522

ndr_print_uint32(ndr, "Length", r->Length);

523

ndr_print_string(ndr, "Reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?"LfLe":r->Reserved);

524

ndr_print_uint32(ndr, "RecordNumber", r->RecordNumber);

525

ndr_print_time_t(ndr, "TimeGenerated", r->TimeGenerated);

526

ndr_print_time_t(ndr, "TimeWritten", r->TimeWritten);

527

ndr_print_uint32(ndr, "EventID", r->EventID);

528

ndr_print_eventlogEventTypes(ndr, "EventType", r->EventType);

529

ndr_print_uint16(ndr, "NumStrings", r->NumStrings);

530

ndr_print_uint16(ndr, "EventCategory", r->EventCategory);

531

ndr_print_uint16(ndr, "ReservedFlags", r->ReservedFlags);

532

ndr_print_uint32(ndr, "ClosingRecordNumber", r->ClosingRecordNumber);

533

ndr_print_uint32(ndr, "StringOffset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + r->UserSidLength:r->StringOffset);

534

ndr_print_uint32(ndr, "UserSidLength", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid0(&r->UserSid, ndr->flags):r->UserSidLength);

535

ndr_print_uint32(ndr, "UserSidOffset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)):r->UserSidOffset);

536

ndr_print_uint32(ndr, "DataLength", r->DataLength);

537

ndr_print_uint32(ndr, "DataOffset", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?56 + 2 * (strlen_m_term(r->SourceName) + strlen_m_term(r->Computername)) + r->UserSidLength + (2 * ndr_size_string_array(r->Strings, r->NumStrings, LIBNDR_FLAG_STR_NULLTERM)):r->DataOffset);

538

ndr_print_string(ndr, "SourceName", r->SourceName);

539

ndr_print_string(ndr, "Computername", r->Computername);

540

ndr_print_dom_sid0(ndr, "UserSid", &r->UserSid);

541

ndr->print(ndr, "%s: ARRAY(%d)", "Strings", (int)r->NumStrings);

542

ndr->depth++;

543

for (cntr_Strings_0=0;cntr_Strings_0<r->NumStrings;cntr_Strings_0++) {

544

char *idx_0=NULL;

545

if (asprintf(&idx_0, "[%d]", cntr_Strings_0) != -1) {

546

ndr_print_string(ndr, "Strings", r->Strings[cntr_Strings_0]);

547

free(idx_0);

548

}

549

}

550

ndr->depth--;

551

ndr_print_array_uint8(ndr, "Data", r->Data, r->DataLength);

552

ndr_print_string(ndr, "Pad", r->Pad);

553

ndr_print_uint32(ndr, "Length2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->Length:r->Length2);

554

ndr->depth--;

555

}

556

557

_PUBLIC_ size_t ndr_size_EVENTLOGRECORD(const struct EVENTLOGRECORD *r, struct smb_iconv_convenience *ic, int flags)

558

{

559

return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_EVENTLOGRECORD, ic);

560

}

561

562

_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOGEOF(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOGEOF *r)

563

{

564

if (ndr_flags & NDR_SCALARS) {

565

NDR_CHECK(ndr_push_align(ndr, 4));

566

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x28));

567

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x11111111));

568

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x22222222));

569

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x33333333));

570

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x44444444));

571

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->BeginRecord));

572

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->EndRecord));

573

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->CurrentRecordNumber));

574

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->OldestRecordNumber));

575

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x28));

576

}

577

if (ndr_flags & NDR_BUFFERS) {

578

}

579

return NDR_ERR_SUCCESS;

580

}

581

582

_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOGEOF(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOGEOF *r)

583

{

584

if (ndr_flags & NDR_SCALARS) {

585

NDR_CHECK(ndr_pull_align(ndr, 4));

586

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordSizeBeginning));

587

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->One));

588

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Two));

589

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Three));

590

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->Four));

591

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->BeginRecord));

592

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->EndRecord));

593

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->CurrentRecordNumber));

594

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->OldestRecordNumber));

595

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->RecordSizeEnd));

596

}

597

if (ndr_flags & NDR_BUFFERS) {

598

}

599

return NDR_ERR_SUCCESS;

600

}

601

602

_PUBLIC_ void ndr_print_EVENTLOGEOF(struct ndr_print *ndr, const char *name, const struct EVENTLOGEOF *r)

603

{

604

ndr_print_struct(ndr, name, "EVENTLOGEOF");

605

ndr->depth++;

606

ndr_print_uint32(ndr, "RecordSizeBeginning", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x28:r->RecordSizeBeginning);

607

ndr_print_uint32(ndr, "One", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x11111111:r->One);

608

ndr_print_uint32(ndr, "Two", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x22222222:r->Two);

609

ndr_print_uint32(ndr, "Three", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x33333333:r->Three);

610

ndr_print_uint32(ndr, "Four", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x44444444:r->Four);

611

ndr_print_uint32(ndr, "BeginRecord", r->BeginRecord);

612

ndr_print_uint32(ndr, "EndRecord", r->EndRecord);

613

ndr_print_uint32(ndr, "CurrentRecordNumber", r->CurrentRecordNumber);

614

ndr_print_uint32(ndr, "OldestRecordNumber", r->OldestRecordNumber);

615

ndr_print_uint32(ndr, "RecordSizeEnd", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x28:r->RecordSizeEnd);

616

ndr->depth--;

617

}

618

619

_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOG_EVT_FILE(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOG_EVT_FILE *r)

620

{

621

uint32_t cntr_records_0;

622

if (ndr_flags & NDR_SCALARS) {

623

NDR_CHECK(ndr_push_align(ndr, 4));

624

NDR_CHECK(ndr_push_EVENTLOGHEADER(ndr, NDR_SCALARS, &r->hdr));

625

for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {

626

NDR_CHECK(ndr_push_EVENTLOGRECORD(ndr, NDR_SCALARS, &r->records[cntr_records_0]));

627

}

628

NDR_CHECK(ndr_push_EVENTLOGEOF(ndr, NDR_SCALARS, &r->eof));

629

}

630

if (ndr_flags & NDR_BUFFERS) {

631

for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {

632

NDR_CHECK(ndr_push_EVENTLOGRECORD(ndr, NDR_BUFFERS, &r->records[cntr_records_0]));

633

}

634

}

635

return NDR_ERR_SUCCESS;

636

}

637

638

_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOG_EVT_FILE(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOG_EVT_FILE *r)

639

{

640

uint32_t cntr_records_0;

641

TALLOC_CTX *_mem_save_records_0;

642

if (ndr_flags & NDR_SCALARS) {

643

NDR_CHECK(ndr_pull_align(ndr, 4));

644

NDR_CHECK(ndr_pull_EVENTLOGHEADER(ndr, NDR_SCALARS, &r->hdr));

645

NDR_PULL_ALLOC_N(ndr, r->records, r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber);

646

_mem_save_records_0 = NDR_PULL_GET_MEM_CTX(ndr);

647

NDR_PULL_SET_MEM_CTX(ndr, r->records, 0);

648

for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {

649

NDR_CHECK(ndr_pull_EVENTLOGRECORD(ndr, NDR_SCALARS, &r->records[cntr_records_0]));

650

}

651

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_records_0, 0);

652

NDR_CHECK(ndr_pull_EVENTLOGEOF(ndr, NDR_SCALARS, &r->eof));

653

}

654

if (ndr_flags & NDR_BUFFERS) {

655

_mem_save_records_0 = NDR_PULL_GET_MEM_CTX(ndr);

656

NDR_PULL_SET_MEM_CTX(ndr, r->records, 0);

657

for (cntr_records_0 = 0; cntr_records_0 < r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber; cntr_records_0++) {

658

NDR_CHECK(ndr_pull_EVENTLOGRECORD(ndr, NDR_BUFFERS, &r->records[cntr_records_0]));

659

}

660

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_records_0, 0);

661

}

662

return NDR_ERR_SUCCESS;

663

}

664

665

_PUBLIC_ void ndr_print_EVENTLOG_EVT_FILE(struct ndr_print *ndr, const char *name, const struct EVENTLOG_EVT_FILE *r)

666

{

667

uint32_t cntr_records_0;

668

ndr_print_struct(ndr, name, "EVENTLOG_EVT_FILE");

669

ndr->depth++;

670

ndr_print_EVENTLOGHEADER(ndr, "hdr", &r->hdr);

671

ndr->print(ndr, "%s: ARRAY(%d)", "records", (int)r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber);

672

ndr->depth++;

673

for (cntr_records_0=0;cntr_records_0<r->hdr.CurrentRecordNumber - r->hdr.OldestRecordNumber;cntr_records_0++) {

674

char *idx_0=NULL;

675

if (asprintf(&idx_0, "[%d]", cntr_records_0) != -1) {

676

ndr_print_EVENTLOGRECORD(ndr, "records", &r->records[cntr_records_0]);

677

free(idx_0);

678

}

679

}

680

ndr->depth--;

681

ndr_print_EVENTLOGEOF(ndr, "eof", &r->eof);

682

ndr->depth--;

683

}

684

685

_PUBLIC_ enum ndr_err_code ndr_push_EVENTLOG_FULL_INFORMATION(struct ndr_push *ndr, int ndr_flags, const struct EVENTLOG_FULL_INFORMATION *r)

686

{

687

if (ndr_flags & NDR_SCALARS) {

688

NDR_CHECK(ndr_push_align(ndr, 4));

689

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->full));

690

}

691

if (ndr_flags & NDR_BUFFERS) {

692

}

693

return NDR_ERR_SUCCESS;

694

}

695

696

_PUBLIC_ enum ndr_err_code ndr_pull_EVENTLOG_FULL_INFORMATION(struct ndr_pull *ndr, int ndr_flags, struct EVENTLOG_FULL_INFORMATION *r)

697

{

698

if (ndr_flags & NDR_SCALARS) {

699

NDR_CHECK(ndr_pull_align(ndr, 4));

700

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->full));

701

}

702

if (ndr_flags & NDR_BUFFERS) {

703

}

704

return NDR_ERR_SUCCESS;

705

}

706

707

_PUBLIC_ void ndr_print_EVENTLOG_FULL_INFORMATION(struct ndr_print *ndr, const char *name, const struct EVENTLOG_FULL_INFORMATION *r)

708

{

709

ndr_print_struct(ndr, name, "EVENTLOG_FULL_INFORMATION");

710

ndr->depth++;

711

ndr_print_uint32(ndr, "full", r->full);

712

ndr->depth--;

713

}

714

715

static enum ndr_err_code ndr_push_eventlog_ClearEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_ClearEventLogW *r)

716

{

717

if (flags & NDR_IN) {

718

if (r->in.handle == NULL) {

719

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

720

}

721

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

722

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.backupfile));

723

if (r->in.backupfile) {

724

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backupfile));

725

}

726

}

727

if (flags & NDR_OUT) {

728

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

729

}

730

return NDR_ERR_SUCCESS;

731

}

732

733

static enum ndr_err_code ndr_pull_eventlog_ClearEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_ClearEventLogW *r)

734

{

735

uint32_t _ptr_backupfile;

736

TALLOC_CTX *_mem_save_handle_0;

737

TALLOC_CTX *_mem_save_backupfile_0;

738

if (flags & NDR_IN) {

739

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

740

NDR_PULL_ALLOC(ndr, r->in.handle);

741

}

742

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

743

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

744

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

745

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

746

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_backupfile));

747

if (_ptr_backupfile) {

748

NDR_PULL_ALLOC(ndr, r->in.backupfile);

749

} else {

750

r->in.backupfile = NULL;

751

}

752

if (r->in.backupfile) {

753

_mem_save_backupfile_0 = NDR_PULL_GET_MEM_CTX(ndr);

754

NDR_PULL_SET_MEM_CTX(ndr, r->in.backupfile, 0);

755

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backupfile));

756

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backupfile_0, 0);

757

}

758

}

759

if (flags & NDR_OUT) {

760

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

761

}

762

return NDR_ERR_SUCCESS;

763

}

764

765

_PUBLIC_ void ndr_print_eventlog_ClearEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ClearEventLogW *r)

766

{

767

ndr_print_struct(ndr, name, "eventlog_ClearEventLogW");

768

ndr->depth++;

769

if (flags & NDR_SET_VALUES) {

770

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

771

}

772

if (flags & NDR_IN) {

773

ndr_print_struct(ndr, "in", "eventlog_ClearEventLogW");

774

ndr->depth++;

775

ndr_print_ptr(ndr, "handle", r->in.handle);

776

ndr->depth++;

777

ndr_print_policy_handle(ndr, "handle", r->in.handle);

778

ndr->depth--;

779

ndr_print_ptr(ndr, "backupfile", r->in.backupfile);

780

ndr->depth++;

781

if (r->in.backupfile) {

782

ndr_print_lsa_String(ndr, "backupfile", r->in.backupfile);

783

}

784

ndr->depth--;

785

ndr->depth--;

786

}

787

if (flags & NDR_OUT) {

788

ndr_print_struct(ndr, "out", "eventlog_ClearEventLogW");

789

ndr->depth++;

790

ndr_print_NTSTATUS(ndr, "result", r->out.result);

791

ndr->depth--;

792

}

793

ndr->depth--;

794

}

795

796

static enum ndr_err_code ndr_push_eventlog_BackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_BackupEventLogW *r)

797

{

798

if (flags & NDR_IN) {

799

if (r->in.handle == NULL) {

800

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

801

}

802

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

803

if (r->in.backup_filename == NULL) {

804

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

805

}

806

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_filename));

807

}

808

if (flags & NDR_OUT) {

809

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

810

}

811

return NDR_ERR_SUCCESS;

812

}

813

814

static enum ndr_err_code ndr_pull_eventlog_BackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_BackupEventLogW *r)

815

{

816

TALLOC_CTX *_mem_save_handle_0;

817

TALLOC_CTX *_mem_save_backup_filename_0;

818

if (flags & NDR_IN) {

819

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

820

NDR_PULL_ALLOC(ndr, r->in.handle);

821

}

822

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

823

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

824

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

825

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

826

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

827

NDR_PULL_ALLOC(ndr, r->in.backup_filename);

828

}

829

_mem_save_backup_filename_0 = NDR_PULL_GET_MEM_CTX(ndr);

830

NDR_PULL_SET_MEM_CTX(ndr, r->in.backup_filename, LIBNDR_FLAG_REF_ALLOC);

831

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_filename));

832

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backup_filename_0, LIBNDR_FLAG_REF_ALLOC);

833

}

834

if (flags & NDR_OUT) {

835

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

836

}

837

return NDR_ERR_SUCCESS;

838

}

839

840

_PUBLIC_ void ndr_print_eventlog_BackupEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_BackupEventLogW *r)

841

{

842

ndr_print_struct(ndr, name, "eventlog_BackupEventLogW");

843

ndr->depth++;

844

if (flags & NDR_SET_VALUES) {

845

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

846

}

847

if (flags & NDR_IN) {

848

ndr_print_struct(ndr, "in", "eventlog_BackupEventLogW");

849

ndr->depth++;

850

ndr_print_ptr(ndr, "handle", r->in.handle);

851

ndr->depth++;

852

ndr_print_policy_handle(ndr, "handle", r->in.handle);

853

ndr->depth--;

854

ndr_print_ptr(ndr, "backup_filename", r->in.backup_filename);

855

ndr->depth++;

856

ndr_print_lsa_String(ndr, "backup_filename", r->in.backup_filename);

857

ndr->depth--;

858

ndr->depth--;

859

}

860

if (flags & NDR_OUT) {

861

ndr_print_struct(ndr, "out", "eventlog_BackupEventLogW");

862

ndr->depth++;

863

ndr_print_NTSTATUS(ndr, "result", r->out.result);

864

ndr->depth--;

865

}

866

ndr->depth--;

867

}

868

869

static enum ndr_err_code ndr_push_eventlog_CloseEventLog(struct ndr_push *ndr, int flags, const struct eventlog_CloseEventLog *r)

870

{

871

if (flags & NDR_IN) {

872

if (r->in.handle == NULL) {

873

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

874

}

875

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

876

}

877

if (flags & NDR_OUT) {

878

if (r->out.handle == NULL) {

879

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

880

}

881

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

882

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

883

}

884

return NDR_ERR_SUCCESS;

885

}

886

887

static enum ndr_err_code ndr_pull_eventlog_CloseEventLog(struct ndr_pull *ndr, int flags, struct eventlog_CloseEventLog *r)

888

{

889

TALLOC_CTX *_mem_save_handle_0;

890

if (flags & NDR_IN) {

891

ZERO_STRUCT(r->out);

892

893

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

894

NDR_PULL_ALLOC(ndr, r->in.handle);

895

}

896

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

897

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

898

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

899

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

900

NDR_PULL_ALLOC(ndr, r->out.handle);

901

*r->out.handle = *r->in.handle;

902

}

903

if (flags & NDR_OUT) {

904

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

905

NDR_PULL_ALLOC(ndr, r->out.handle);

906

}

907

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

908

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

909

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

910

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

911

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

912

}

913

return NDR_ERR_SUCCESS;

914

}

915

916

_PUBLIC_ void ndr_print_eventlog_CloseEventLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_CloseEventLog *r)

917

{

918

ndr_print_struct(ndr, name, "eventlog_CloseEventLog");

919

ndr->depth++;

920

if (flags & NDR_SET_VALUES) {

921

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

922

}

923

if (flags & NDR_IN) {

924

ndr_print_struct(ndr, "in", "eventlog_CloseEventLog");

925

ndr->depth++;

926

ndr_print_ptr(ndr, "handle", r->in.handle);

927

ndr->depth++;

928

ndr_print_policy_handle(ndr, "handle", r->in.handle);

929

ndr->depth--;

930

ndr->depth--;

931

}

932

if (flags & NDR_OUT) {

933

ndr_print_struct(ndr, "out", "eventlog_CloseEventLog");

934

ndr->depth++;

935

ndr_print_ptr(ndr, "handle", r->out.handle);

936

ndr->depth++;

937

ndr_print_policy_handle(ndr, "handle", r->out.handle);

938

ndr->depth--;

939

ndr_print_NTSTATUS(ndr, "result", r->out.result);

940

ndr->depth--;

941

}

942

ndr->depth--;

943

}

944

945

static enum ndr_err_code ndr_push_eventlog_DeregisterEventSource(struct ndr_push *ndr, int flags, const struct eventlog_DeregisterEventSource *r)

946

{

947

if (flags & NDR_IN) {

948

if (r->in.handle == NULL) {

949

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

950

}

951

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

952

}

953

if (flags & NDR_OUT) {

954

if (r->out.handle == NULL) {

955

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

956

}

957

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

958

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

959

}

960

return NDR_ERR_SUCCESS;

961

}

962

963

static enum ndr_err_code ndr_pull_eventlog_DeregisterEventSource(struct ndr_pull *ndr, int flags, struct eventlog_DeregisterEventSource *r)

964

{

965

TALLOC_CTX *_mem_save_handle_0;

966

if (flags & NDR_IN) {

967

ZERO_STRUCT(r->out);

968

969

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

970

NDR_PULL_ALLOC(ndr, r->in.handle);

971

}

972

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

973

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

974

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

975

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

976

NDR_PULL_ALLOC(ndr, r->out.handle);

977

*r->out.handle = *r->in.handle;

978

}

979

if (flags & NDR_OUT) {

980

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

981

NDR_PULL_ALLOC(ndr, r->out.handle);

982

}

983

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

984

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

985

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

986

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

987

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

988

}

989

return NDR_ERR_SUCCESS;

990

}

991

992

_PUBLIC_ void ndr_print_eventlog_DeregisterEventSource(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_DeregisterEventSource *r)

993

{

994

ndr_print_struct(ndr, name, "eventlog_DeregisterEventSource");

995

ndr->depth++;

996

if (flags & NDR_SET_VALUES) {

997

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

998

}

999

if (flags & NDR_IN) {

1000

ndr_print_struct(ndr, "in", "eventlog_DeregisterEventSource");

1001

ndr->depth++;

1002

ndr_print_ptr(ndr, "handle", r->in.handle);

1003

ndr->depth++;

1004

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1005

ndr->depth--;

1006

ndr->depth--;

1007

}

1008

if (flags & NDR_OUT) {

1009

ndr_print_struct(ndr, "out", "eventlog_DeregisterEventSource");

1010

ndr->depth++;

1011

ndr_print_ptr(ndr, "handle", r->out.handle);

1012

ndr->depth++;

1013

ndr_print_policy_handle(ndr, "handle", r->out.handle);

1014

ndr->depth--;

1015

ndr_print_NTSTATUS(ndr, "result", r->out.result);

1016

ndr->depth--;

1017

}

1018

ndr->depth--;

1019

}

1020

1021

static enum ndr_err_code ndr_push_eventlog_GetNumRecords(struct ndr_push *ndr, int flags, const struct eventlog_GetNumRecords *r)

1022

{

1023

if (flags & NDR_IN) {

1024

if (r->in.handle == NULL) {

1025

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1026

}

1027

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1028

}

1029

if (flags & NDR_OUT) {

1030

if (r->out.number == NULL) {

1031

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1032

}

1033

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.number));

1034

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

1035

}

1036

return NDR_ERR_SUCCESS;

1037

}

1038

1039

static enum ndr_err_code ndr_pull_eventlog_GetNumRecords(struct ndr_pull *ndr, int flags, struct eventlog_GetNumRecords *r)

1040

{

1041

TALLOC_CTX *_mem_save_handle_0;

1042

TALLOC_CTX *_mem_save_number_0;

1043

if (flags & NDR_IN) {

1044

ZERO_STRUCT(r->out);

1045

1046

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1047

NDR_PULL_ALLOC(ndr, r->in.handle);

1048

}

1049

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1050

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1051

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1052

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1053

NDR_PULL_ALLOC(ndr, r->out.number);

1054

ZERO_STRUCTP(r->out.number);

1055

}

1056

if (flags & NDR_OUT) {

1057

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1058

NDR_PULL_ALLOC(ndr, r->out.number);

1059

}

1060

_mem_save_number_0 = NDR_PULL_GET_MEM_CTX(ndr);

1061

NDR_PULL_SET_MEM_CTX(ndr, r->out.number, LIBNDR_FLAG_REF_ALLOC);

1062

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.number));

1063

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_number_0, LIBNDR_FLAG_REF_ALLOC);

1064

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

1065

}

1066

return NDR_ERR_SUCCESS;

1067

}

1068

1069

_PUBLIC_ void ndr_print_eventlog_GetNumRecords(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetNumRecords *r)

1070

{

1071

ndr_print_struct(ndr, name, "eventlog_GetNumRecords");

1072

ndr->depth++;

1073

if (flags & NDR_SET_VALUES) {

1074

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1075

}

1076

if (flags & NDR_IN) {

1077

ndr_print_struct(ndr, "in", "eventlog_GetNumRecords");

1078

ndr->depth++;

1079

ndr_print_ptr(ndr, "handle", r->in.handle);

1080

ndr->depth++;

1081

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1082

ndr->depth--;

1083

ndr->depth--;

1084

}

1085

if (flags & NDR_OUT) {

1086

ndr_print_struct(ndr, "out", "eventlog_GetNumRecords");

1087

ndr->depth++;

1088

ndr_print_ptr(ndr, "number", r->out.number);

1089

ndr->depth++;

1090

ndr_print_uint32(ndr, "number", *r->out.number);

1091

ndr->depth--;

1092

ndr_print_NTSTATUS(ndr, "result", r->out.result);

1093

ndr->depth--;

1094

}

1095

ndr->depth--;

1096

}

1097

1098

static enum ndr_err_code ndr_push_eventlog_GetOldestRecord(struct ndr_push *ndr, int flags, const struct eventlog_GetOldestRecord *r)

1099

{

1100

if (flags & NDR_IN) {

1101

if (r->in.handle == NULL) {

1102

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1103

}

1104

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1105

}

1106

if (flags & NDR_OUT) {

1107

if (r->out.oldest_entry == NULL) {

1108

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1109

}

1110

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.oldest_entry));

1111

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

1112

}

1113

return NDR_ERR_SUCCESS;

1114

}

1115

1116

static enum ndr_err_code ndr_pull_eventlog_GetOldestRecord(struct ndr_pull *ndr, int flags, struct eventlog_GetOldestRecord *r)

1117

{

1118

TALLOC_CTX *_mem_save_handle_0;

1119

TALLOC_CTX *_mem_save_oldest_entry_0;

1120

if (flags & NDR_IN) {

1121

ZERO_STRUCT(r->out);

1122

1123

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1124

NDR_PULL_ALLOC(ndr, r->in.handle);

1125

}

1126

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1127

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1128

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1129

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1130

NDR_PULL_ALLOC(ndr, r->out.oldest_entry);

1131

ZERO_STRUCTP(r->out.oldest_entry);

1132

}

1133

if (flags & NDR_OUT) {

1134

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1135

NDR_PULL_ALLOC(ndr, r->out.oldest_entry);

1136

}

1137

_mem_save_oldest_entry_0 = NDR_PULL_GET_MEM_CTX(ndr);

1138

NDR_PULL_SET_MEM_CTX(ndr, r->out.oldest_entry, LIBNDR_FLAG_REF_ALLOC);

1139

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.oldest_entry));

1140

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_oldest_entry_0, LIBNDR_FLAG_REF_ALLOC);

1141

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

1142

}

1143

return NDR_ERR_SUCCESS;

1144

}

1145

1146

_PUBLIC_ void ndr_print_eventlog_GetOldestRecord(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetOldestRecord *r)

1147

{

1148

ndr_print_struct(ndr, name, "eventlog_GetOldestRecord");

1149

ndr->depth++;

1150

if (flags & NDR_SET_VALUES) {

1151

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1152

}

1153

if (flags & NDR_IN) {

1154

ndr_print_struct(ndr, "in", "eventlog_GetOldestRecord");

1155

ndr->depth++;

1156

ndr_print_ptr(ndr, "handle", r->in.handle);

1157

ndr->depth++;

1158

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1159

ndr->depth--;

1160

ndr->depth--;

1161

}

1162

if (flags & NDR_OUT) {

1163

ndr_print_struct(ndr, "out", "eventlog_GetOldestRecord");

1164

ndr->depth++;

1165

ndr_print_ptr(ndr, "oldest_entry", r->out.oldest_entry);

1166

ndr->depth++;

1167

ndr_print_uint32(ndr, "oldest_entry", *r->out.oldest_entry);

1168

ndr->depth--;

1169

ndr_print_NTSTATUS(ndr, "result", r->out.result);

1170

ndr->depth--;

1171

}

1172

ndr->depth--;

1173

}

1174

1175

static enum ndr_err_code ndr_push_eventlog_ChangeNotify(struct ndr_push *ndr, int flags, const struct eventlog_ChangeNotify *r)

1176

{

1177

if (flags & NDR_IN) {

1178

}

1179

if (flags & NDR_OUT) {

1180

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

1181

}

1182

return NDR_ERR_SUCCESS;

1183

}

1184

1185

static enum ndr_err_code ndr_pull_eventlog_ChangeNotify(struct ndr_pull *ndr, int flags, struct eventlog_ChangeNotify *r)

1186

{

1187

if (flags & NDR_IN) {

1188

}

1189

if (flags & NDR_OUT) {

1190

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

1191

}

1192

return NDR_ERR_SUCCESS;

1193

}

1194

1195

_PUBLIC_ void ndr_print_eventlog_ChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ChangeNotify *r)

1196

{

1197

ndr_print_struct(ndr, name, "eventlog_ChangeNotify");

1198

ndr->depth++;

1199

if (flags & NDR_SET_VALUES) {

1200

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1201

}

1202

if (flags & NDR_IN) {

1203

ndr_print_struct(ndr, "in", "eventlog_ChangeNotify");

1204

ndr->depth++;

1205

ndr->depth--;

1206

}

1207

if (flags & NDR_OUT) {

1208

ndr_print_struct(ndr, "out", "eventlog_ChangeNotify");

1209

ndr->depth++;

1210

ndr_print_NTSTATUS(ndr, "result", r->out.result);

1211

ndr->depth--;

1212

}

1213

ndr->depth--;

1214

}

1215

1216

static enum ndr_err_code ndr_push_eventlog_OpenEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_OpenEventLogW *r)

1217

{

1218

if (flags & NDR_IN) {

1219

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));

1220

if (r->in.unknown0) {

1221

NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));

1222

}

1223

if (r->in.logname == NULL) {

1224

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1225

}

1226

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.logname));

1227

if (r->in.servername == NULL) {

1228

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1229

}

1230

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));

1231

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));

1232

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));

1233

}

1234

if (flags & NDR_OUT) {

1235

if (r->out.handle == NULL) {

1236

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1237

}

1238

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

1239

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

1240

}

1241

return NDR_ERR_SUCCESS;

1242

}

1243

1244

static enum ndr_err_code ndr_pull_eventlog_OpenEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_OpenEventLogW *r)

1245

{

1246

uint32_t _ptr_unknown0;

1247

TALLOC_CTX *_mem_save_unknown0_0;

1248

TALLOC_CTX *_mem_save_logname_0;

1249

TALLOC_CTX *_mem_save_servername_0;

1250

TALLOC_CTX *_mem_save_handle_0;

1251

if (flags & NDR_IN) {

1252

ZERO_STRUCT(r->out);

1253

1254

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));

1255

if (_ptr_unknown0) {

1256

NDR_PULL_ALLOC(ndr, r->in.unknown0);

1257

} else {

1258

r->in.unknown0 = NULL;

1259

}

1260

if (r->in.unknown0) {

1261

_mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);

1262

NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);

1263

NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));

1264

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);

1265

}

1266

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1267

NDR_PULL_ALLOC(ndr, r->in.logname);

1268

}

1269

_mem_save_logname_0 = NDR_PULL_GET_MEM_CTX(ndr);

1270

NDR_PULL_SET_MEM_CTX(ndr, r->in.logname, LIBNDR_FLAG_REF_ALLOC);

1271

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.logname));

1272

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_logname_0, LIBNDR_FLAG_REF_ALLOC);

1273

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1274

NDR_PULL_ALLOC(ndr, r->in.servername);

1275

}

1276

_mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);

1277

NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);

1278

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));

1279

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);

1280

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));

1281

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));

1282

NDR_PULL_ALLOC(ndr, r->out.handle);

1283

ZERO_STRUCTP(r->out.handle);

1284

}

1285

if (flags & NDR_OUT) {

1286

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1287

NDR_PULL_ALLOC(ndr, r->out.handle);

1288

}

1289

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1290

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

1291

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

1292

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1293

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

1294

}

1295

return NDR_ERR_SUCCESS;

1296

}

1297

1298

_PUBLIC_ void ndr_print_eventlog_OpenEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenEventLogW *r)

1299

{

1300

ndr_print_struct(ndr, name, "eventlog_OpenEventLogW");

1301

ndr->depth++;

1302

if (flags & NDR_SET_VALUES) {

1303

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1304

}

1305

if (flags & NDR_IN) {

1306

ndr_print_struct(ndr, "in", "eventlog_OpenEventLogW");

1307

ndr->depth++;

1308

ndr_print_ptr(ndr, "unknown0", r->in.unknown0);

1309

ndr->depth++;

1310

if (r->in.unknown0) {

1311

ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);

1312

}

1313

ndr->depth--;

1314

ndr_print_ptr(ndr, "logname", r->in.logname);

1315

ndr->depth++;

1316

ndr_print_lsa_String(ndr, "logname", r->in.logname);

1317

ndr->depth--;

1318

ndr_print_ptr(ndr, "servername", r->in.servername);

1319

ndr->depth++;

1320

ndr_print_lsa_String(ndr, "servername", r->in.servername);

1321

ndr->depth--;

1322

ndr_print_uint32(ndr, "major_version", r->in.major_version);

1323

ndr_print_uint32(ndr, "minor_version", r->in.minor_version);

1324

ndr->depth--;

1325

}

1326

if (flags & NDR_OUT) {

1327

ndr_print_struct(ndr, "out", "eventlog_OpenEventLogW");

1328

ndr->depth++;

1329

ndr_print_ptr(ndr, "handle", r->out.handle);

1330

ndr->depth++;

1331

ndr_print_policy_handle(ndr, "handle", r->out.handle);

1332

ndr->depth--;

1333

ndr_print_NTSTATUS(ndr, "result", r->out.result);

1334

ndr->depth--;

1335

}

1336

ndr->depth--;

1337

}

1338

1339

static enum ndr_err_code ndr_push_eventlog_RegisterEventSourceW(struct ndr_push *ndr, int flags, const struct eventlog_RegisterEventSourceW *r)

1340

{

1341

if (flags & NDR_IN) {

1342

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));

1343

if (r->in.unknown0) {

1344

NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));

1345

}

1346

if (r->in.module_name == NULL) {

1347

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1348

}

1349

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.module_name));

1350

if (r->in.reg_module_name == NULL) {

1351

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1352

}

1353

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.reg_module_name));

1354

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));

1355

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));

1356

}

1357

if (flags & NDR_OUT) {

1358

if (r->out.log_handle == NULL) {

1359

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1360

}

1361

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.log_handle));

1362

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

1363

}

1364

return NDR_ERR_SUCCESS;

1365

}

1366

1367

static enum ndr_err_code ndr_pull_eventlog_RegisterEventSourceW(struct ndr_pull *ndr, int flags, struct eventlog_RegisterEventSourceW *r)

1368

{

1369

uint32_t _ptr_unknown0;

1370

TALLOC_CTX *_mem_save_unknown0_0;

1371

TALLOC_CTX *_mem_save_module_name_0;

1372

TALLOC_CTX *_mem_save_reg_module_name_0;

1373

TALLOC_CTX *_mem_save_log_handle_0;

1374

if (flags & NDR_IN) {

1375

ZERO_STRUCT(r->out);

1376

1377

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));

1378

if (_ptr_unknown0) {

1379

NDR_PULL_ALLOC(ndr, r->in.unknown0);

1380

} else {

1381

r->in.unknown0 = NULL;

1382

}

1383

if (r->in.unknown0) {

1384

_mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);

1385

NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);

1386

NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));

1387

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);

1388

}

1389

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1390

NDR_PULL_ALLOC(ndr, r->in.module_name);

1391

}

1392

_mem_save_module_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

1393

NDR_PULL_SET_MEM_CTX(ndr, r->in.module_name, LIBNDR_FLAG_REF_ALLOC);

1394

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.module_name));

1395

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_module_name_0, LIBNDR_FLAG_REF_ALLOC);

1396

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1397

NDR_PULL_ALLOC(ndr, r->in.reg_module_name);

1398

}

1399

_mem_save_reg_module_name_0 = NDR_PULL_GET_MEM_CTX(ndr);

1400

NDR_PULL_SET_MEM_CTX(ndr, r->in.reg_module_name, LIBNDR_FLAG_REF_ALLOC);

1401

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.reg_module_name));

1402

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reg_module_name_0, LIBNDR_FLAG_REF_ALLOC);

1403

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));

1404

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));

1405

NDR_PULL_ALLOC(ndr, r->out.log_handle);

1406

ZERO_STRUCTP(r->out.log_handle);

1407

}

1408

if (flags & NDR_OUT) {

1409

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1410

NDR_PULL_ALLOC(ndr, r->out.log_handle);

1411

}

1412

_mem_save_log_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1413

NDR_PULL_SET_MEM_CTX(ndr, r->out.log_handle, LIBNDR_FLAG_REF_ALLOC);

1414

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.log_handle));

1415

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_log_handle_0, LIBNDR_FLAG_REF_ALLOC);

1416

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

1417

}

1418

return NDR_ERR_SUCCESS;

1419

}

1420

1421

_PUBLIC_ void ndr_print_eventlog_RegisterEventSourceW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterEventSourceW *r)

1422

{

1423

ndr_print_struct(ndr, name, "eventlog_RegisterEventSourceW");

1424

ndr->depth++;

1425

if (flags & NDR_SET_VALUES) {

1426

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1427

}

1428

if (flags & NDR_IN) {

1429

ndr_print_struct(ndr, "in", "eventlog_RegisterEventSourceW");

1430

ndr->depth++;

1431

ndr_print_ptr(ndr, "unknown0", r->in.unknown0);

1432

ndr->depth++;

1433

if (r->in.unknown0) {

1434

ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);

1435

}

1436

ndr->depth--;

1437

ndr_print_ptr(ndr, "module_name", r->in.module_name);

1438

ndr->depth++;

1439

ndr_print_lsa_String(ndr, "module_name", r->in.module_name);

1440

ndr->depth--;

1441

ndr_print_ptr(ndr, "reg_module_name", r->in.reg_module_name);

1442

ndr->depth++;

1443

ndr_print_lsa_String(ndr, "reg_module_name", r->in.reg_module_name);

1444

ndr->depth--;

1445

ndr_print_uint32(ndr, "major_version", r->in.major_version);

1446

ndr_print_uint32(ndr, "minor_version", r->in.minor_version);

1447

ndr->depth--;

1448

}

1449

if (flags & NDR_OUT) {

1450

ndr_print_struct(ndr, "out", "eventlog_RegisterEventSourceW");

1451

ndr->depth++;

1452

ndr_print_ptr(ndr, "log_handle", r->out.log_handle);

1453

ndr->depth++;

1454

ndr_print_policy_handle(ndr, "log_handle", r->out.log_handle);

1455

ndr->depth--;

1456

ndr_print_NTSTATUS(ndr, "result", r->out.result);

1457

ndr->depth--;

1458

}

1459

ndr->depth--;

1460

}

1461

1462

static enum ndr_err_code ndr_push_eventlog_OpenBackupEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_OpenBackupEventLogW *r)

1463

{

1464

if (flags & NDR_IN) {

1465

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.unknown0));

1466

if (r->in.unknown0) {

1467

NDR_CHECK(ndr_push_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));

1468

}

1469

if (r->in.backup_logname == NULL) {

1470

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1471

}

1472

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_logname));

1473

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.major_version));

1474

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.minor_version));

1475

}

1476

if (flags & NDR_OUT) {

1477

if (r->out.handle == NULL) {

1478

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1479

}

1480

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));

1481

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

1482

}

1483

return NDR_ERR_SUCCESS;

1484

}

1485

1486

static enum ndr_err_code ndr_pull_eventlog_OpenBackupEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_OpenBackupEventLogW *r)

1487

{

1488

uint32_t _ptr_unknown0;

1489

TALLOC_CTX *_mem_save_unknown0_0;

1490

TALLOC_CTX *_mem_save_backup_logname_0;

1491

TALLOC_CTX *_mem_save_handle_0;

1492

if (flags & NDR_IN) {

1493

ZERO_STRUCT(r->out);

1494

1495

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_unknown0));

1496

if (_ptr_unknown0) {

1497

NDR_PULL_ALLOC(ndr, r->in.unknown0);

1498

} else {

1499

r->in.unknown0 = NULL;

1500

}

1501

if (r->in.unknown0) {

1502

_mem_save_unknown0_0 = NDR_PULL_GET_MEM_CTX(ndr);

1503

NDR_PULL_SET_MEM_CTX(ndr, r->in.unknown0, 0);

1504

NDR_CHECK(ndr_pull_eventlog_OpenUnknown0(ndr, NDR_SCALARS, r->in.unknown0));

1505

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_unknown0_0, 0);

1506

}

1507

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1508

NDR_PULL_ALLOC(ndr, r->in.backup_logname);

1509

}

1510

_mem_save_backup_logname_0 = NDR_PULL_GET_MEM_CTX(ndr);

1511

NDR_PULL_SET_MEM_CTX(ndr, r->in.backup_logname, LIBNDR_FLAG_REF_ALLOC);

1512

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.backup_logname));

1513

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_backup_logname_0, LIBNDR_FLAG_REF_ALLOC);

1514

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.major_version));

1515

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.minor_version));

1516

NDR_PULL_ALLOC(ndr, r->out.handle);

1517

ZERO_STRUCTP(r->out.handle);

1518

}

1519

if (flags & NDR_OUT) {

1520

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1521

NDR_PULL_ALLOC(ndr, r->out.handle);

1522

}

1523

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1524

NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);

1525

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));

1526

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1527

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

1528

}

1529

return NDR_ERR_SUCCESS;

1530

}

1531

1532

_PUBLIC_ void ndr_print_eventlog_OpenBackupEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenBackupEventLogW *r)

1533

{

1534

ndr_print_struct(ndr, name, "eventlog_OpenBackupEventLogW");

1535

ndr->depth++;

1536

if (flags & NDR_SET_VALUES) {

1537

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1538

}

1539

if (flags & NDR_IN) {

1540

ndr_print_struct(ndr, "in", "eventlog_OpenBackupEventLogW");

1541

ndr->depth++;

1542

ndr_print_ptr(ndr, "unknown0", r->in.unknown0);

1543

ndr->depth++;

1544

if (r->in.unknown0) {

1545

ndr_print_eventlog_OpenUnknown0(ndr, "unknown0", r->in.unknown0);

1546

}

1547

ndr->depth--;

1548

ndr_print_ptr(ndr, "backup_logname", r->in.backup_logname);

1549

ndr->depth++;

1550

ndr_print_lsa_String(ndr, "backup_logname", r->in.backup_logname);

1551

ndr->depth--;

1552

ndr_print_uint32(ndr, "major_version", r->in.major_version);

1553

ndr_print_uint32(ndr, "minor_version", r->in.minor_version);

1554

ndr->depth--;

1555

}

1556

if (flags & NDR_OUT) {

1557

ndr_print_struct(ndr, "out", "eventlog_OpenBackupEventLogW");

1558

ndr->depth++;

1559

ndr_print_ptr(ndr, "handle", r->out.handle);

1560

ndr->depth++;

1561

ndr_print_policy_handle(ndr, "handle", r->out.handle);

1562

ndr->depth--;

1563

ndr_print_NTSTATUS(ndr, "result", r->out.result);

1564

ndr->depth--;

1565

}

1566

ndr->depth--;

1567

}

1568

1569

static enum ndr_err_code ndr_push_eventlog_ReadEventLogW(struct ndr_push *ndr, int flags, const struct eventlog_ReadEventLogW *r)

1570

{

1571

if (flags & NDR_IN) {

1572

if (r->in.handle == NULL) {

1573

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1574

}

1575

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1576

NDR_CHECK(ndr_push_eventlogReadFlags(ndr, NDR_SCALARS, r->in.flags));

1577

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offset));

1578

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.number_of_bytes));

1579

}

1580

if (flags & NDR_OUT) {

1581

if (r->out.data == NULL) {

1582

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1583

}

1584

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.number_of_bytes));

1585

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.number_of_bytes));

1586

if (r->out.sent_size == NULL) {

1587

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1588

}

1589

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.sent_size));

1590

if (r->out.real_size == NULL) {

1591

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1592

}

1593

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.real_size));

1594

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

1595

}

1596

return NDR_ERR_SUCCESS;

1597

}

1598

1599

static enum ndr_err_code ndr_pull_eventlog_ReadEventLogW(struct ndr_pull *ndr, int flags, struct eventlog_ReadEventLogW *r)

1600

{

1601

TALLOC_CTX *_mem_save_handle_0;

1602

TALLOC_CTX *_mem_save_sent_size_0;

1603

TALLOC_CTX *_mem_save_real_size_0;

1604

if (flags & NDR_IN) {

1605

ZERO_STRUCT(r->out);

1606

1607

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1608

NDR_PULL_ALLOC(ndr, r->in.handle);

1609

}

1610

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1611

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1612

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1613

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1614

NDR_CHECK(ndr_pull_eventlogReadFlags(ndr, NDR_SCALARS, &r->in.flags));

1615

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offset));

1616

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.number_of_bytes));

1617

if (r->in.number_of_bytes > 0x7FFFF) {

1618

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

1619

}

1620

NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.number_of_bytes);

1621

memset(r->out.data, 0, (r->in.number_of_bytes) * sizeof(*r->out.data));

1622

NDR_PULL_ALLOC(ndr, r->out.sent_size);

1623

ZERO_STRUCTP(r->out.sent_size);

1624

NDR_PULL_ALLOC(ndr, r->out.real_size);

1625

ZERO_STRUCTP(r->out.real_size);

1626

}

1627

if (flags & NDR_OUT) {

1628

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));

1629

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1630

NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));

1631

}

1632

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));

1633

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1634

NDR_PULL_ALLOC(ndr, r->out.sent_size);

1635

}

1636

_mem_save_sent_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

1637

NDR_PULL_SET_MEM_CTX(ndr, r->out.sent_size, LIBNDR_FLAG_REF_ALLOC);

1638

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.sent_size));

1639

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sent_size_0, LIBNDR_FLAG_REF_ALLOC);

1640

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1641

NDR_PULL_ALLOC(ndr, r->out.real_size);

1642

}

1643

_mem_save_real_size_0 = NDR_PULL_GET_MEM_CTX(ndr);

1644

NDR_PULL_SET_MEM_CTX(ndr, r->out.real_size, LIBNDR_FLAG_REF_ALLOC);

1645

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.real_size));

1646

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_real_size_0, LIBNDR_FLAG_REF_ALLOC);

1647

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

1648

if (r->out.data) {

1649

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.number_of_bytes));

1650

}

1651

}

1652

return NDR_ERR_SUCCESS;

1653

}

1654

1655

_PUBLIC_ void ndr_print_eventlog_ReadEventLogW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReadEventLogW *r)

1656

{

1657

ndr_print_struct(ndr, name, "eventlog_ReadEventLogW");

1658

ndr->depth++;

1659

if (flags & NDR_SET_VALUES) {

1660

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1661

}

1662

if (flags & NDR_IN) {

1663

ndr_print_struct(ndr, "in", "eventlog_ReadEventLogW");

1664

ndr->depth++;

1665

ndr_print_ptr(ndr, "handle", r->in.handle);

1666

ndr->depth++;

1667

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1668

ndr->depth--;

1669

ndr_print_eventlogReadFlags(ndr, "flags", r->in.flags);

1670

ndr_print_uint32(ndr, "offset", r->in.offset);

1671

ndr_print_uint32(ndr, "number_of_bytes", r->in.number_of_bytes);

1672

ndr->depth--;

1673

}

1674

if (flags & NDR_OUT) {

1675

ndr_print_struct(ndr, "out", "eventlog_ReadEventLogW");

1676

ndr->depth++;

1677

ndr_print_ptr(ndr, "data", r->out.data);

1678

ndr->depth++;

1679

ndr_print_array_uint8(ndr, "data", r->out.data, r->in.number_of_bytes);

1680

ndr->depth--;

1681

ndr_print_ptr(ndr, "sent_size", r->out.sent_size);

1682

ndr->depth++;

1683

ndr_print_uint32(ndr, "sent_size", *r->out.sent_size);

1684

ndr->depth--;

1685

ndr_print_ptr(ndr, "real_size", r->out.real_size);

1686

ndr->depth++;

1687

ndr_print_uint32(ndr, "real_size", *r->out.real_size);

1688

ndr->depth--;

1689

ndr_print_NTSTATUS(ndr, "result", r->out.result);

1690

ndr->depth--;

1691

}

1692

ndr->depth--;

1693

}

1694

1695

static enum ndr_err_code ndr_push_eventlog_ReportEventW(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventW *r)

1696

{

1697

uint32_t cntr_strings_1;

1698

if (flags & NDR_IN) {

1699

if (r->in.handle == NULL) {

1700

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1701

}

1702

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1703

NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->in.timestamp));

1704

NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->in.event_type));

1705

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.event_category));

1706

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.event_id));

1707

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.num_of_strings));

1708

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));

1709

if (r->in.servername == NULL) {

1710

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

1711

}

1712

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));

1713

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user_sid));

1714

if (r->in.user_sid) {

1715

NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));

1716

}

1717

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings));

1718

if (r->in.strings) {

1719

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_of_strings));

1720

for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {

1721

}

1722

for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {

1723

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings[cntr_strings_1]));

1724

if (r->in.strings[cntr_strings_1]) {

1725

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));

1726

}

1727

}

1728

}

1729

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));

1730

if (r->in.data) {

1731

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));

1732

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_size));

1733

}

1734

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.flags));

1735

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.record_number));

1736

if (r->in.record_number) {

1737

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.record_number));

1738

}

1739

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.time_written));

1740

if (r->in.time_written) {

1741

NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->in.time_written));

1742

}

1743

}

1744

if (flags & NDR_OUT) {

1745

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.record_number));

1746

if (r->out.record_number) {

1747

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.record_number));

1748

}

1749

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.time_written));

1750

if (r->out.time_written) {

1751

NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->out.time_written));

1752

}

1753

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

1754

}

1755

return NDR_ERR_SUCCESS;

1756

}

1757

1758

static enum ndr_err_code ndr_pull_eventlog_ReportEventW(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventW *r)

1759

{

1760

uint32_t _ptr_user_sid;

1761

uint32_t _ptr_strings;

1762

uint32_t cntr_strings_1;

1763

uint32_t _ptr_data;

1764

uint32_t _ptr_record_number;

1765

uint32_t _ptr_time_written;

1766

TALLOC_CTX *_mem_save_handle_0;

1767

TALLOC_CTX *_mem_save_servername_0;

1768

TALLOC_CTX *_mem_save_user_sid_0;

1769

TALLOC_CTX *_mem_save_strings_0;

1770

TALLOC_CTX *_mem_save_strings_1;

1771

TALLOC_CTX *_mem_save_strings_2;

1772

TALLOC_CTX *_mem_save_data_0;

1773

TALLOC_CTX *_mem_save_record_number_0;

1774

TALLOC_CTX *_mem_save_time_written_0;

1775

if (flags & NDR_IN) {

1776

ZERO_STRUCT(r->out);

1777

1778

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1779

NDR_PULL_ALLOC(ndr, r->in.handle);

1780

}

1781

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

1782

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

1783

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

1784

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

1785

NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->in.timestamp));

1786

NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->in.event_type));

1787

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.event_category));

1788

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.event_id));

1789

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.num_of_strings));

1790

if (r->in.num_of_strings > 256) {

1791

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

1792

}

1793

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));

1794

if (r->in.data_size > 0x3FFFF) {

1795

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

1796

}

1797

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

1798

NDR_PULL_ALLOC(ndr, r->in.servername);

1799

}

1800

_mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);

1801

NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);

1802

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));

1803

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);

1804

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));

1805

if (_ptr_user_sid) {

1806

NDR_PULL_ALLOC(ndr, r->in.user_sid);

1807

} else {

1808

r->in.user_sid = NULL;

1809

}

1810

if (r->in.user_sid) {

1811

_mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);

1812

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_sid, 0);

1813

NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));

1814

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);

1815

}

1816

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));

1817

if (_ptr_strings) {

1818

NDR_PULL_ALLOC(ndr, r->in.strings);

1819

} else {

1820

r->in.strings = NULL;

1821

}

1822

if (r->in.strings) {

1823

_mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);

1824

NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);

1825

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.strings));

1826

NDR_PULL_ALLOC_N(ndr, r->in.strings, ndr_get_array_size(ndr, &r->in.strings));

1827

_mem_save_strings_1 = NDR_PULL_GET_MEM_CTX(ndr);

1828

NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);

1829

for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {

1830

}

1831

for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {

1832

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));

1833

if (_ptr_strings) {

1834

NDR_PULL_ALLOC(ndr, r->in.strings[cntr_strings_1]);

1835

} else {

1836

r->in.strings[cntr_strings_1] = NULL;

1837

}

1838

if (r->in.strings[cntr_strings_1]) {

1839

_mem_save_strings_2 = NDR_PULL_GET_MEM_CTX(ndr);

1840

NDR_PULL_SET_MEM_CTX(ndr, r->in.strings[cntr_strings_1], 0);

1841

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));

1842

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_2, 0);

1843

}

1844

}

1845

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_1, 0);

1846

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);

1847

}

1848

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));

1849

if (_ptr_data) {

1850

NDR_PULL_ALLOC(ndr, r->in.data);

1851

} else {

1852

r->in.data = NULL;

1853

}

1854

if (r->in.data) {

1855

_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);

1856

NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);

1857

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));

1858

NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));

1859

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));

1860

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);

1861

}

1862

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.flags));

1863

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));

1864

if (_ptr_record_number) {

1865

NDR_PULL_ALLOC(ndr, r->in.record_number);

1866

} else {

1867

r->in.record_number = NULL;

1868

}

1869

if (r->in.record_number) {

1870

_mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);

1871

NDR_PULL_SET_MEM_CTX(ndr, r->in.record_number, 0);

1872

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.record_number));

1873

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);

1874

}

1875

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));

1876

if (_ptr_time_written) {

1877

NDR_PULL_ALLOC(ndr, r->in.time_written);

1878

} else {

1879

r->in.time_written = NULL;

1880

}

1881

if (r->in.time_written) {

1882

_mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);

1883

NDR_PULL_SET_MEM_CTX(ndr, r->in.time_written, 0);

1884

NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->in.time_written));

1885

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);

1886

}

1887

if (r->in.strings) {

1888

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.strings, r->in.num_of_strings));

1889

}

1890

if (r->in.data) {

1891

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.data_size));

1892

}

1893

}

1894

if (flags & NDR_OUT) {

1895

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));

1896

if (_ptr_record_number) {

1897

NDR_PULL_ALLOC(ndr, r->out.record_number);

1898

} else {

1899

r->out.record_number = NULL;

1900

}

1901

if (r->out.record_number) {

1902

_mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);

1903

NDR_PULL_SET_MEM_CTX(ndr, r->out.record_number, 0);

1904

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.record_number));

1905

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);

1906

}

1907

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));

1908

if (_ptr_time_written) {

1909

NDR_PULL_ALLOC(ndr, r->out.time_written);

1910

} else {

1911

r->out.time_written = NULL;

1912

}

1913

if (r->out.time_written) {

1914

_mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);

1915

NDR_PULL_SET_MEM_CTX(ndr, r->out.time_written, 0);

1916

NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->out.time_written));

1917

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);

1918

}

1919

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

1920

}

1921

return NDR_ERR_SUCCESS;

1922

}

1923

1924

_PUBLIC_ void ndr_print_eventlog_ReportEventW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventW *r)

1925

{

1926

uint32_t cntr_strings_1;

1927

ndr_print_struct(ndr, name, "eventlog_ReportEventW");

1928

ndr->depth++;

1929

if (flags & NDR_SET_VALUES) {

1930

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

1931

}

1932

if (flags & NDR_IN) {

1933

ndr_print_struct(ndr, "in", "eventlog_ReportEventW");

1934

ndr->depth++;

1935

ndr_print_ptr(ndr, "handle", r->in.handle);

1936

ndr->depth++;

1937

ndr_print_policy_handle(ndr, "handle", r->in.handle);

1938

ndr->depth--;

1939

ndr_print_time_t(ndr, "timestamp", r->in.timestamp);

1940

ndr_print_eventlogEventTypes(ndr, "event_type", r->in.event_type);

1941

ndr_print_uint16(ndr, "event_category", r->in.event_category);

1942

ndr_print_uint32(ndr, "event_id", r->in.event_id);

1943

ndr_print_uint16(ndr, "num_of_strings", r->in.num_of_strings);

1944

ndr_print_uint32(ndr, "data_size", r->in.data_size);

1945

ndr_print_ptr(ndr, "servername", r->in.servername);

1946

ndr->depth++;

1947

ndr_print_lsa_String(ndr, "servername", r->in.servername);

1948

ndr->depth--;

1949

ndr_print_ptr(ndr, "user_sid", r->in.user_sid);

1950

ndr->depth++;

1951

if (r->in.user_sid) {

1952

ndr_print_dom_sid(ndr, "user_sid", r->in.user_sid);

1953

}

1954

ndr->depth--;

1955

ndr_print_ptr(ndr, "strings", r->in.strings);

1956

ndr->depth++;

1957

if (r->in.strings) {

1958

ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->in.num_of_strings);

1959

ndr->depth++;

1960

for (cntr_strings_1=0;cntr_strings_1<r->in.num_of_strings;cntr_strings_1++) {

1961

char *idx_1=NULL;

1962

if (asprintf(&idx_1, "[%d]", cntr_strings_1) != -1) {

1963

ndr_print_ptr(ndr, "strings", r->in.strings[cntr_strings_1]);

1964

ndr->depth++;

1965

if (r->in.strings[cntr_strings_1]) {

1966

ndr_print_lsa_String(ndr, "strings", r->in.strings[cntr_strings_1]);

1967

}

1968

ndr->depth--;

1969

free(idx_1);

1970

}

1971

}

1972

ndr->depth--;

1973

}

1974

ndr->depth--;

1975

ndr_print_ptr(ndr, "data", r->in.data);

1976

ndr->depth++;

1977

if (r->in.data) {

1978

ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_size);

1979

}

1980

ndr->depth--;

1981

ndr_print_uint16(ndr, "flags", r->in.flags);

1982

ndr_print_ptr(ndr, "record_number", r->in.record_number);

1983

ndr->depth++;

1984

if (r->in.record_number) {

1985

ndr_print_uint32(ndr, "record_number", *r->in.record_number);

1986

}

1987

ndr->depth--;

1988

ndr_print_ptr(ndr, "time_written", r->in.time_written);

1989

ndr->depth++;

1990

if (r->in.time_written) {

1991

ndr_print_time_t(ndr, "time_written", *r->in.time_written);

1992

}

1993

ndr->depth--;

1994

ndr->depth--;

1995

}

1996

if (flags & NDR_OUT) {

1997

ndr_print_struct(ndr, "out", "eventlog_ReportEventW");

1998

ndr->depth++;

1999

ndr_print_ptr(ndr, "record_number", r->out.record_number);

2000

ndr->depth++;

2001

if (r->out.record_number) {

2002

ndr_print_uint32(ndr, "record_number", *r->out.record_number);

2003

}

2004

ndr->depth--;

2005

ndr_print_ptr(ndr, "time_written", r->out.time_written);

2006

ndr->depth++;

2007

if (r->out.time_written) {

2008

ndr_print_time_t(ndr, "time_written", *r->out.time_written);

2009

}

2010

ndr->depth--;

2011

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2012

ndr->depth--;

2013

}

2014

ndr->depth--;

2015

}

2016

2017

static enum ndr_err_code ndr_push_eventlog_ClearEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_ClearEventLogA *r)

2018

{

2019

if (flags & NDR_IN) {

2020

}

2021

if (flags & NDR_OUT) {

2022

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2023

}

2024

return NDR_ERR_SUCCESS;

2025

}

2026

2027

static enum ndr_err_code ndr_pull_eventlog_ClearEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_ClearEventLogA *r)

2028

{

2029

if (flags & NDR_IN) {

2030

}

2031

if (flags & NDR_OUT) {

2032

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2033

}

2034

return NDR_ERR_SUCCESS;

2035

}

2036

2037

_PUBLIC_ void ndr_print_eventlog_ClearEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ClearEventLogA *r)

2038

{

2039

ndr_print_struct(ndr, name, "eventlog_ClearEventLogA");

2040

ndr->depth++;

2041

if (flags & NDR_SET_VALUES) {

2042

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2043

}

2044

if (flags & NDR_IN) {

2045

ndr_print_struct(ndr, "in", "eventlog_ClearEventLogA");

2046

ndr->depth++;

2047

ndr->depth--;

2048

}

2049

if (flags & NDR_OUT) {

2050

ndr_print_struct(ndr, "out", "eventlog_ClearEventLogA");

2051

ndr->depth++;

2052

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2053

ndr->depth--;

2054

}

2055

ndr->depth--;

2056

}

2057

2058

static enum ndr_err_code ndr_push_eventlog_BackupEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_BackupEventLogA *r)

2059

{

2060

if (flags & NDR_IN) {

2061

}

2062

if (flags & NDR_OUT) {

2063

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2064

}

2065

return NDR_ERR_SUCCESS;

2066

}

2067

2068

static enum ndr_err_code ndr_pull_eventlog_BackupEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_BackupEventLogA *r)

2069

{

2070

if (flags & NDR_IN) {

2071

}

2072

if (flags & NDR_OUT) {

2073

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2074

}

2075

return NDR_ERR_SUCCESS;

2076

}

2077

2078

_PUBLIC_ void ndr_print_eventlog_BackupEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_BackupEventLogA *r)

2079

{

2080

ndr_print_struct(ndr, name, "eventlog_BackupEventLogA");

2081

ndr->depth++;

2082

if (flags & NDR_SET_VALUES) {

2083

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2084

}

2085

if (flags & NDR_IN) {

2086

ndr_print_struct(ndr, "in", "eventlog_BackupEventLogA");

2087

ndr->depth++;

2088

ndr->depth--;

2089

}

2090

if (flags & NDR_OUT) {

2091

ndr_print_struct(ndr, "out", "eventlog_BackupEventLogA");

2092

ndr->depth++;

2093

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2094

ndr->depth--;

2095

}

2096

ndr->depth--;

2097

}

2098

2099

static enum ndr_err_code ndr_push_eventlog_OpenEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_OpenEventLogA *r)

2100

{

2101

if (flags & NDR_IN) {

2102

}

2103

if (flags & NDR_OUT) {

2104

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2105

}

2106

return NDR_ERR_SUCCESS;

2107

}

2108

2109

static enum ndr_err_code ndr_pull_eventlog_OpenEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_OpenEventLogA *r)

2110

{

2111

if (flags & NDR_IN) {

2112

}

2113

if (flags & NDR_OUT) {

2114

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2115

}

2116

return NDR_ERR_SUCCESS;

2117

}

2118

2119

_PUBLIC_ void ndr_print_eventlog_OpenEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenEventLogA *r)

2120

{

2121

ndr_print_struct(ndr, name, "eventlog_OpenEventLogA");

2122

ndr->depth++;

2123

if (flags & NDR_SET_VALUES) {

2124

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2125

}

2126

if (flags & NDR_IN) {

2127

ndr_print_struct(ndr, "in", "eventlog_OpenEventLogA");

2128

ndr->depth++;

2129

ndr->depth--;

2130

}

2131

if (flags & NDR_OUT) {

2132

ndr_print_struct(ndr, "out", "eventlog_OpenEventLogA");

2133

ndr->depth++;

2134

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2135

ndr->depth--;

2136

}

2137

ndr->depth--;

2138

}

2139

2140

static enum ndr_err_code ndr_push_eventlog_RegisterEventSourceA(struct ndr_push *ndr, int flags, const struct eventlog_RegisterEventSourceA *r)

2141

{

2142

if (flags & NDR_IN) {

2143

}

2144

if (flags & NDR_OUT) {

2145

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2146

}

2147

return NDR_ERR_SUCCESS;

2148

}

2149

2150

static enum ndr_err_code ndr_pull_eventlog_RegisterEventSourceA(struct ndr_pull *ndr, int flags, struct eventlog_RegisterEventSourceA *r)

2151

{

2152

if (flags & NDR_IN) {

2153

}

2154

if (flags & NDR_OUT) {

2155

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2156

}

2157

return NDR_ERR_SUCCESS;

2158

}

2159

2160

_PUBLIC_ void ndr_print_eventlog_RegisterEventSourceA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterEventSourceA *r)

2161

{

2162

ndr_print_struct(ndr, name, "eventlog_RegisterEventSourceA");

2163

ndr->depth++;

2164

if (flags & NDR_SET_VALUES) {

2165

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2166

}

2167

if (flags & NDR_IN) {

2168

ndr_print_struct(ndr, "in", "eventlog_RegisterEventSourceA");

2169

ndr->depth++;

2170

ndr->depth--;

2171

}

2172

if (flags & NDR_OUT) {

2173

ndr_print_struct(ndr, "out", "eventlog_RegisterEventSourceA");

2174

ndr->depth++;

2175

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2176

ndr->depth--;

2177

}

2178

ndr->depth--;

2179

}

2180

2181

static enum ndr_err_code ndr_push_eventlog_OpenBackupEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_OpenBackupEventLogA *r)

2182

{

2183

if (flags & NDR_IN) {

2184

}

2185

if (flags & NDR_OUT) {

2186

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2187

}

2188

return NDR_ERR_SUCCESS;

2189

}

2190

2191

static enum ndr_err_code ndr_pull_eventlog_OpenBackupEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_OpenBackupEventLogA *r)

2192

{

2193

if (flags & NDR_IN) {

2194

}

2195

if (flags & NDR_OUT) {

2196

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2197

}

2198

return NDR_ERR_SUCCESS;

2199

}

2200

2201

_PUBLIC_ void ndr_print_eventlog_OpenBackupEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_OpenBackupEventLogA *r)

2202

{

2203

ndr_print_struct(ndr, name, "eventlog_OpenBackupEventLogA");

2204

ndr->depth++;

2205

if (flags & NDR_SET_VALUES) {

2206

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2207

}

2208

if (flags & NDR_IN) {

2209

ndr_print_struct(ndr, "in", "eventlog_OpenBackupEventLogA");

2210

ndr->depth++;

2211

ndr->depth--;

2212

}

2213

if (flags & NDR_OUT) {

2214

ndr_print_struct(ndr, "out", "eventlog_OpenBackupEventLogA");

2215

ndr->depth++;

2216

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2217

ndr->depth--;

2218

}

2219

ndr->depth--;

2220

}

2221

2222

static enum ndr_err_code ndr_push_eventlog_ReadEventLogA(struct ndr_push *ndr, int flags, const struct eventlog_ReadEventLogA *r)

2223

{

2224

if (flags & NDR_IN) {

2225

}

2226

if (flags & NDR_OUT) {

2227

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2228

}

2229

return NDR_ERR_SUCCESS;

2230

}

2231

2232

static enum ndr_err_code ndr_pull_eventlog_ReadEventLogA(struct ndr_pull *ndr, int flags, struct eventlog_ReadEventLogA *r)

2233

{

2234

if (flags & NDR_IN) {

2235

}

2236

if (flags & NDR_OUT) {

2237

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2238

}

2239

return NDR_ERR_SUCCESS;

2240

}

2241

2242

_PUBLIC_ void ndr_print_eventlog_ReadEventLogA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReadEventLogA *r)

2243

{

2244

ndr_print_struct(ndr, name, "eventlog_ReadEventLogA");

2245

ndr->depth++;

2246

if (flags & NDR_SET_VALUES) {

2247

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2248

}

2249

if (flags & NDR_IN) {

2250

ndr_print_struct(ndr, "in", "eventlog_ReadEventLogA");

2251

ndr->depth++;

2252

ndr->depth--;

2253

}

2254

if (flags & NDR_OUT) {

2255

ndr_print_struct(ndr, "out", "eventlog_ReadEventLogA");

2256

ndr->depth++;

2257

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2258

ndr->depth--;

2259

}

2260

ndr->depth--;

2261

}

2262

2263

static enum ndr_err_code ndr_push_eventlog_ReportEventA(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventA *r)

2264

{

2265

if (flags & NDR_IN) {

2266

}

2267

if (flags & NDR_OUT) {

2268

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2269

}

2270

return NDR_ERR_SUCCESS;

2271

}

2272

2273

static enum ndr_err_code ndr_pull_eventlog_ReportEventA(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventA *r)

2274

{

2275

if (flags & NDR_IN) {

2276

}

2277

if (flags & NDR_OUT) {

2278

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2279

}

2280

return NDR_ERR_SUCCESS;

2281

}

2282

2283

_PUBLIC_ void ndr_print_eventlog_ReportEventA(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventA *r)

2284

{

2285

ndr_print_struct(ndr, name, "eventlog_ReportEventA");

2286

ndr->depth++;

2287

if (flags & NDR_SET_VALUES) {

2288

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2289

}

2290

if (flags & NDR_IN) {

2291

ndr_print_struct(ndr, "in", "eventlog_ReportEventA");

2292

ndr->depth++;

2293

ndr->depth--;

2294

}

2295

if (flags & NDR_OUT) {

2296

ndr_print_struct(ndr, "out", "eventlog_ReportEventA");

2297

ndr->depth++;

2298

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2299

ndr->depth--;

2300

}

2301

ndr->depth--;

2302

}

2303

2304

static enum ndr_err_code ndr_push_eventlog_RegisterClusterSvc(struct ndr_push *ndr, int flags, const struct eventlog_RegisterClusterSvc *r)

2305

{

2306

if (flags & NDR_IN) {

2307

}

2308

if (flags & NDR_OUT) {

2309

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2310

}

2311

return NDR_ERR_SUCCESS;

2312

}

2313

2314

static enum ndr_err_code ndr_pull_eventlog_RegisterClusterSvc(struct ndr_pull *ndr, int flags, struct eventlog_RegisterClusterSvc *r)

2315

{

2316

if (flags & NDR_IN) {

2317

}

2318

if (flags & NDR_OUT) {

2319

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2320

}

2321

return NDR_ERR_SUCCESS;

2322

}

2323

2324

_PUBLIC_ void ndr_print_eventlog_RegisterClusterSvc(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_RegisterClusterSvc *r)

2325

{

2326

ndr_print_struct(ndr, name, "eventlog_RegisterClusterSvc");

2327

ndr->depth++;

2328

if (flags & NDR_SET_VALUES) {

2329

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2330

}

2331

if (flags & NDR_IN) {

2332

ndr_print_struct(ndr, "in", "eventlog_RegisterClusterSvc");

2333

ndr->depth++;

2334

ndr->depth--;

2335

}

2336

if (flags & NDR_OUT) {

2337

ndr_print_struct(ndr, "out", "eventlog_RegisterClusterSvc");

2338

ndr->depth++;

2339

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2340

ndr->depth--;

2341

}

2342

ndr->depth--;

2343

}

2344

2345

static enum ndr_err_code ndr_push_eventlog_DeregisterClusterSvc(struct ndr_push *ndr, int flags, const struct eventlog_DeregisterClusterSvc *r)

2346

{

2347

if (flags & NDR_IN) {

2348

}

2349

if (flags & NDR_OUT) {

2350

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2351

}

2352

return NDR_ERR_SUCCESS;

2353

}

2354

2355

static enum ndr_err_code ndr_pull_eventlog_DeregisterClusterSvc(struct ndr_pull *ndr, int flags, struct eventlog_DeregisterClusterSvc *r)

2356

{

2357

if (flags & NDR_IN) {

2358

}

2359

if (flags & NDR_OUT) {

2360

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2361

}

2362

return NDR_ERR_SUCCESS;

2363

}

2364

2365

_PUBLIC_ void ndr_print_eventlog_DeregisterClusterSvc(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_DeregisterClusterSvc *r)

2366

{

2367

ndr_print_struct(ndr, name, "eventlog_DeregisterClusterSvc");

2368

ndr->depth++;

2369

if (flags & NDR_SET_VALUES) {

2370

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2371

}

2372

if (flags & NDR_IN) {

2373

ndr_print_struct(ndr, "in", "eventlog_DeregisterClusterSvc");

2374

ndr->depth++;

2375

ndr->depth--;

2376

}

2377

if (flags & NDR_OUT) {

2378

ndr_print_struct(ndr, "out", "eventlog_DeregisterClusterSvc");

2379

ndr->depth++;

2380

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2381

ndr->depth--;

2382

}

2383

ndr->depth--;

2384

}

2385

2386

static enum ndr_err_code ndr_push_eventlog_WriteClusterEvents(struct ndr_push *ndr, int flags, const struct eventlog_WriteClusterEvents *r)

2387

{

2388

if (flags & NDR_IN) {

2389

}

2390

if (flags & NDR_OUT) {

2391

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2392

}

2393

return NDR_ERR_SUCCESS;

2394

}

2395

2396

static enum ndr_err_code ndr_pull_eventlog_WriteClusterEvents(struct ndr_pull *ndr, int flags, struct eventlog_WriteClusterEvents *r)

2397

{

2398

if (flags & NDR_IN) {

2399

}

2400

if (flags & NDR_OUT) {

2401

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2402

}

2403

return NDR_ERR_SUCCESS;

2404

}

2405

2406

_PUBLIC_ void ndr_print_eventlog_WriteClusterEvents(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_WriteClusterEvents *r)

2407

{

2408

ndr_print_struct(ndr, name, "eventlog_WriteClusterEvents");

2409

ndr->depth++;

2410

if (flags & NDR_SET_VALUES) {

2411

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2412

}

2413

if (flags & NDR_IN) {

2414

ndr_print_struct(ndr, "in", "eventlog_WriteClusterEvents");

2415

ndr->depth++;

2416

ndr->depth--;

2417

}

2418

if (flags & NDR_OUT) {

2419

ndr_print_struct(ndr, "out", "eventlog_WriteClusterEvents");

2420

ndr->depth++;

2421

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2422

ndr->depth--;

2423

}

2424

ndr->depth--;

2425

}

2426

2427

static enum ndr_err_code ndr_push_eventlog_GetLogInformation(struct ndr_push *ndr, int flags, const struct eventlog_GetLogInformation *r)

2428

{

2429

if (flags & NDR_IN) {

2430

if (r->in.handle == NULL) {

2431

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2432

}

2433

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2434

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));

2435

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));

2436

}

2437

if (flags & NDR_OUT) {

2438

if (r->out.buffer == NULL) {

2439

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2440

}

2441

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.buf_size));

2442

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.buf_size));

2443

if (r->out.bytes_needed == NULL) {

2444

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2445

}

2446

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.bytes_needed));

2447

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2448

}

2449

return NDR_ERR_SUCCESS;

2450

}

2451

2452

static enum ndr_err_code ndr_pull_eventlog_GetLogInformation(struct ndr_pull *ndr, int flags, struct eventlog_GetLogInformation *r)

2453

{

2454

TALLOC_CTX *_mem_save_handle_0;

2455

TALLOC_CTX *_mem_save_bytes_needed_0;

2456

if (flags & NDR_IN) {

2457

ZERO_STRUCT(r->out);

2458

2459

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2460

NDR_PULL_ALLOC(ndr, r->in.handle);

2461

}

2462

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2463

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

2464

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2465

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2466

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));

2467

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.buf_size));

2468

if (r->in.buf_size > 1024) {

2469

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

2470

}

2471

NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.buf_size);

2472

memset(r->out.buffer, 0, (r->in.buf_size) * sizeof(*r->out.buffer));

2473

NDR_PULL_ALLOC(ndr, r->out.bytes_needed);

2474

ZERO_STRUCTP(r->out.bytes_needed);

2475

}

2476

if (flags & NDR_OUT) {

2477

NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));

2478

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2479

NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));

2480

}

2481

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));

2482

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2483

NDR_PULL_ALLOC(ndr, r->out.bytes_needed);

2484

}

2485

_mem_save_bytes_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);

2486

NDR_PULL_SET_MEM_CTX(ndr, r->out.bytes_needed, LIBNDR_FLAG_REF_ALLOC);

2487

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.bytes_needed));

2488

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bytes_needed_0, LIBNDR_FLAG_REF_ALLOC);

2489

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2490

if (r->out.buffer) {

2491

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.buf_size));

2492

}

2493

}

2494

return NDR_ERR_SUCCESS;

2495

}

2496

2497

_PUBLIC_ void ndr_print_eventlog_GetLogInformation(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_GetLogInformation *r)

2498

{

2499

ndr_print_struct(ndr, name, "eventlog_GetLogInformation");

2500

ndr->depth++;

2501

if (flags & NDR_SET_VALUES) {

2502

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2503

}

2504

if (flags & NDR_IN) {

2505

ndr_print_struct(ndr, "in", "eventlog_GetLogInformation");

2506

ndr->depth++;

2507

ndr_print_ptr(ndr, "handle", r->in.handle);

2508

ndr->depth++;

2509

ndr_print_policy_handle(ndr, "handle", r->in.handle);

2510

ndr->depth--;

2511

ndr_print_uint32(ndr, "level", r->in.level);

2512

ndr_print_uint32(ndr, "buf_size", r->in.buf_size);

2513

ndr->depth--;

2514

}

2515

if (flags & NDR_OUT) {

2516

ndr_print_struct(ndr, "out", "eventlog_GetLogInformation");

2517

ndr->depth++;

2518

ndr_print_ptr(ndr, "buffer", r->out.buffer);

2519

ndr->depth++;

2520

ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.buf_size);

2521

ndr->depth--;

2522

ndr_print_ptr(ndr, "bytes_needed", r->out.bytes_needed);

2523

ndr->depth++;

2524

ndr_print_uint32(ndr, "bytes_needed", *r->out.bytes_needed);

2525

ndr->depth--;

2526

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2527

ndr->depth--;

2528

}

2529

ndr->depth--;

2530

}

2531

2532

static enum ndr_err_code ndr_push_eventlog_FlushEventLog(struct ndr_push *ndr, int flags, const struct eventlog_FlushEventLog *r)

2533

{

2534

if (flags & NDR_IN) {

2535

if (r->in.handle == NULL) {

2536

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2537

}

2538

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2539

}

2540

if (flags & NDR_OUT) {

2541

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2542

}

2543

return NDR_ERR_SUCCESS;

2544

}

2545

2546

static enum ndr_err_code ndr_pull_eventlog_FlushEventLog(struct ndr_pull *ndr, int flags, struct eventlog_FlushEventLog *r)

2547

{

2548

TALLOC_CTX *_mem_save_handle_0;

2549

if (flags & NDR_IN) {

2550

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2551

NDR_PULL_ALLOC(ndr, r->in.handle);

2552

}

2553

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2554

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

2555

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2556

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2557

}

2558

if (flags & NDR_OUT) {

2559

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2560

}

2561

return NDR_ERR_SUCCESS;

2562

}

2563

2564

_PUBLIC_ void ndr_print_eventlog_FlushEventLog(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_FlushEventLog *r)

2565

{

2566

ndr_print_struct(ndr, name, "eventlog_FlushEventLog");

2567

ndr->depth++;

2568

if (flags & NDR_SET_VALUES) {

2569

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2570

}

2571

if (flags & NDR_IN) {

2572

ndr_print_struct(ndr, "in", "eventlog_FlushEventLog");

2573

ndr->depth++;

2574

ndr_print_ptr(ndr, "handle", r->in.handle);

2575

ndr->depth++;

2576

ndr_print_policy_handle(ndr, "handle", r->in.handle);

2577

ndr->depth--;

2578

ndr->depth--;

2579

}

2580

if (flags & NDR_OUT) {

2581

ndr_print_struct(ndr, "out", "eventlog_FlushEventLog");

2582

ndr->depth++;

2583

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2584

ndr->depth--;

2585

}

2586

ndr->depth--;

2587

}

2588

2589

static enum ndr_err_code ndr_push_eventlog_ReportEventAndSourceW(struct ndr_push *ndr, int flags, const struct eventlog_ReportEventAndSourceW *r)

2590

{

2591

uint32_t cntr_strings_1;

2592

if (flags & NDR_IN) {

2593

if (r->in.handle == NULL) {

2594

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2595

}

2596

NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2597

NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, r->in.timestamp));

2598

NDR_CHECK(ndr_push_eventlogEventTypes(ndr, NDR_SCALARS, r->in.event_type));

2599

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.event_category));

2600

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.event_id));

2601

if (r->in.sourcename == NULL) {

2602

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2603

}

2604

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sourcename));

2605

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.num_of_strings));

2606

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));

2607

if (r->in.servername == NULL) {

2608

return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");

2609

}

2610

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));

2611

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.user_sid));

2612

if (r->in.user_sid) {

2613

NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));

2614

}

2615

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings));

2616

if (r->in.strings) {

2617

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.num_of_strings));

2618

for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {

2619

}

2620

for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {

2621

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.strings[cntr_strings_1]));

2622

if (r->in.strings[cntr_strings_1]) {

2623

NDR_CHECK(ndr_push_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));

2624

}

2625

}

2626

}

2627

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data));

2628

if (r->in.data) {

2629

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));

2630

NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.data_size));

2631

}

2632

NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->in.flags));

2633

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.record_number));

2634

if (r->in.record_number) {

2635

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.record_number));

2636

}

2637

NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.time_written));

2638

if (r->in.time_written) {

2639

NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->in.time_written));

2640

}

2641

}

2642

if (flags & NDR_OUT) {

2643

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.record_number));

2644

if (r->out.record_number) {

2645

NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.record_number));

2646

}

2647

NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.time_written));

2648

if (r->out.time_written) {

2649

NDR_CHECK(ndr_push_time_t(ndr, NDR_SCALARS, *r->out.time_written));

2650

}

2651

NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->out.result));

2652

}

2653

return NDR_ERR_SUCCESS;

2654

}

2655

2656

static enum ndr_err_code ndr_pull_eventlog_ReportEventAndSourceW(struct ndr_pull *ndr, int flags, struct eventlog_ReportEventAndSourceW *r)

2657

{

2658

uint32_t _ptr_user_sid;

2659

uint32_t _ptr_strings;

2660

uint32_t cntr_strings_1;

2661

uint32_t _ptr_data;

2662

uint32_t _ptr_record_number;

2663

uint32_t _ptr_time_written;

2664

TALLOC_CTX *_mem_save_handle_0;

2665

TALLOC_CTX *_mem_save_sourcename_0;

2666

TALLOC_CTX *_mem_save_servername_0;

2667

TALLOC_CTX *_mem_save_user_sid_0;

2668

TALLOC_CTX *_mem_save_strings_0;

2669

TALLOC_CTX *_mem_save_strings_1;

2670

TALLOC_CTX *_mem_save_strings_2;

2671

TALLOC_CTX *_mem_save_data_0;

2672

TALLOC_CTX *_mem_save_record_number_0;

2673

TALLOC_CTX *_mem_save_time_written_0;

2674

if (flags & NDR_IN) {

2675

ZERO_STRUCT(r->out);

2676

2677

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2678

NDR_PULL_ALLOC(ndr, r->in.handle);

2679

}

2680

_mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);

2681

NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);

2682

NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));

2683

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);

2684

NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, &r->in.timestamp));

2685

NDR_CHECK(ndr_pull_eventlogEventTypes(ndr, NDR_SCALARS, &r->in.event_type));

2686

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.event_category));

2687

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.event_id));

2688

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2689

NDR_PULL_ALLOC(ndr, r->in.sourcename);

2690

}

2691

_mem_save_sourcename_0 = NDR_PULL_GET_MEM_CTX(ndr);

2692

NDR_PULL_SET_MEM_CTX(ndr, r->in.sourcename, LIBNDR_FLAG_REF_ALLOC);

2693

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sourcename));

2694

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sourcename_0, LIBNDR_FLAG_REF_ALLOC);

2695

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.num_of_strings));

2696

if (r->in.num_of_strings > 256) {

2697

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

2698

}

2699

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));

2700

if (r->in.data_size > 0x3FFFF) {

2701

return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");

2702

}

2703

if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {

2704

NDR_PULL_ALLOC(ndr, r->in.servername);

2705

}

2706

_mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);

2707

NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, LIBNDR_FLAG_REF_ALLOC);

2708

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.servername));

2709

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, LIBNDR_FLAG_REF_ALLOC);

2710

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_sid));

2711

if (_ptr_user_sid) {

2712

NDR_PULL_ALLOC(ndr, r->in.user_sid);

2713

} else {

2714

r->in.user_sid = NULL;

2715

}

2716

if (r->in.user_sid) {

2717

_mem_save_user_sid_0 = NDR_PULL_GET_MEM_CTX(ndr);

2718

NDR_PULL_SET_MEM_CTX(ndr, r->in.user_sid, 0);

2719

NDR_CHECK(ndr_pull_dom_sid(ndr, NDR_SCALARS, r->in.user_sid));

2720

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_sid_0, 0);

2721

}

2722

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));

2723

if (_ptr_strings) {

2724

NDR_PULL_ALLOC(ndr, r->in.strings);

2725

} else {

2726

r->in.strings = NULL;

2727

}

2728

if (r->in.strings) {

2729

_mem_save_strings_0 = NDR_PULL_GET_MEM_CTX(ndr);

2730

NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);

2731

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.strings));

2732

NDR_PULL_ALLOC_N(ndr, r->in.strings, ndr_get_array_size(ndr, &r->in.strings));

2733

_mem_save_strings_1 = NDR_PULL_GET_MEM_CTX(ndr);

2734

NDR_PULL_SET_MEM_CTX(ndr, r->in.strings, 0);

2735

for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {

2736

}

2737

for (cntr_strings_1 = 0; cntr_strings_1 < r->in.num_of_strings; cntr_strings_1++) {

2738

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_strings));

2739

if (_ptr_strings) {

2740

NDR_PULL_ALLOC(ndr, r->in.strings[cntr_strings_1]);

2741

} else {

2742

r->in.strings[cntr_strings_1] = NULL;

2743

}

2744

if (r->in.strings[cntr_strings_1]) {

2745

_mem_save_strings_2 = NDR_PULL_GET_MEM_CTX(ndr);

2746

NDR_PULL_SET_MEM_CTX(ndr, r->in.strings[cntr_strings_1], 0);

2747

NDR_CHECK(ndr_pull_lsa_String(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.strings[cntr_strings_1]));

2748

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_2, 0);

2749

}

2750

}

2751

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_1, 0);

2752

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_strings_0, 0);

2753

}

2754

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));

2755

if (_ptr_data) {

2756

NDR_PULL_ALLOC(ndr, r->in.data);

2757

} else {

2758

r->in.data = NULL;

2759

}

2760

if (r->in.data) {

2761

_mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);

2762

NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);

2763

NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));

2764

NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));

2765

NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));

2766

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);

2767

}

2768

NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->in.flags));

2769

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));

2770

if (_ptr_record_number) {

2771

NDR_PULL_ALLOC(ndr, r->in.record_number);

2772

} else {

2773

r->in.record_number = NULL;

2774

}

2775

if (r->in.record_number) {

2776

_mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);

2777

NDR_PULL_SET_MEM_CTX(ndr, r->in.record_number, 0);

2778

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.record_number));

2779

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);

2780

}

2781

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));

2782

if (_ptr_time_written) {

2783

NDR_PULL_ALLOC(ndr, r->in.time_written);

2784

} else {

2785

r->in.time_written = NULL;

2786

}

2787

if (r->in.time_written) {

2788

_mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);

2789

NDR_PULL_SET_MEM_CTX(ndr, r->in.time_written, 0);

2790

NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->in.time_written));

2791

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);

2792

}

2793

if (r->in.strings) {

2794

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.strings, r->in.num_of_strings));

2795

}

2796

if (r->in.data) {

2797

NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.data_size));

2798

}

2799

}

2800

if (flags & NDR_OUT) {

2801

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_record_number));

2802

if (_ptr_record_number) {

2803

NDR_PULL_ALLOC(ndr, r->out.record_number);

2804

} else {

2805

r->out.record_number = NULL;

2806

}

2807

if (r->out.record_number) {

2808

_mem_save_record_number_0 = NDR_PULL_GET_MEM_CTX(ndr);

2809

NDR_PULL_SET_MEM_CTX(ndr, r->out.record_number, 0);

2810

NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.record_number));

2811

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_record_number_0, 0);

2812

}

2813

NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time_written));

2814

if (_ptr_time_written) {

2815

NDR_PULL_ALLOC(ndr, r->out.time_written);

2816

} else {

2817

r->out.time_written = NULL;

2818

}

2819

if (r->out.time_written) {

2820

_mem_save_time_written_0 = NDR_PULL_GET_MEM_CTX(ndr);

2821

NDR_PULL_SET_MEM_CTX(ndr, r->out.time_written, 0);

2822

NDR_CHECK(ndr_pull_time_t(ndr, NDR_SCALARS, r->out.time_written));

2823

NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_written_0, 0);

2824

}

2825

NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->out.result));

2826

}

2827

return NDR_ERR_SUCCESS;

2828

}

2829

2830

_PUBLIC_ void ndr_print_eventlog_ReportEventAndSourceW(struct ndr_print *ndr, const char *name, int flags, const struct eventlog_ReportEventAndSourceW *r)

2831

{

2832

uint32_t cntr_strings_1;

2833

ndr_print_struct(ndr, name, "eventlog_ReportEventAndSourceW");

2834

ndr->depth++;

2835

if (flags & NDR_SET_VALUES) {

2836

ndr->flags |= LIBNDR_PRINT_SET_VALUES;

2837

}

2838

if (flags & NDR_IN) {

2839

ndr_print_struct(ndr, "in", "eventlog_ReportEventAndSourceW");

2840

ndr->depth++;

2841

ndr_print_ptr(ndr, "handle", r->in.handle);

2842

ndr->depth++;

2843

ndr_print_policy_handle(ndr, "handle", r->in.handle);

2844

ndr->depth--;

2845

ndr_print_time_t(ndr, "timestamp", r->in.timestamp);

2846

ndr_print_eventlogEventTypes(ndr, "event_type", r->in.event_type);

2847

ndr_print_uint16(ndr, "event_category", r->in.event_category);

2848

ndr_print_uint32(ndr, "event_id", r->in.event_id);

2849

ndr_print_ptr(ndr, "sourcename", r->in.sourcename);

2850

ndr->depth++;

2851

ndr_print_lsa_String(ndr, "sourcename", r->in.sourcename);

2852

ndr->depth--;

2853

ndr_print_uint16(ndr, "num_of_strings", r->in.num_of_strings);

2854

ndr_print_uint32(ndr, "data_size", r->in.data_size);

2855

ndr_print_ptr(ndr, "servername", r->in.servername);

2856

ndr->depth++;

2857

ndr_print_lsa_String(ndr, "servername", r->in.servername);

2858

ndr->depth--;

2859

ndr_print_ptr(ndr, "user_sid", r->in.user_sid);

2860

ndr->depth++;

2861

if (r->in.user_sid) {

2862

ndr_print_dom_sid(ndr, "user_sid", r->in.user_sid);

2863

}

2864

ndr->depth--;

2865

ndr_print_ptr(ndr, "strings", r->in.strings);

2866

ndr->depth++;

2867

if (r->in.strings) {

2868

ndr->print(ndr, "%s: ARRAY(%d)", "strings", (int)r->in.num_of_strings);

2869

ndr->depth++;

2870

for (cntr_strings_1=0;cntr_strings_1<r->in.num_of_strings;cntr_strings_1++) {

2871

char *idx_1=NULL;

2872

if (asprintf(&idx_1, "[%d]", cntr_strings_1) != -1) {

2873

ndr_print_ptr(ndr, "strings", r->in.strings[cntr_strings_1]);

2874

ndr->depth++;

2875

if (r->in.strings[cntr_strings_1]) {

2876

ndr_print_lsa_String(ndr, "strings", r->in.strings[cntr_strings_1]);

2877

}

2878

ndr->depth--;

2879

free(idx_1);

2880

}

2881

}

2882

ndr->depth--;

2883

}

2884

ndr->depth--;

2885

ndr_print_ptr(ndr, "data", r->in.data);

2886

ndr->depth++;

2887

if (r->in.data) {

2888

ndr_print_array_uint8(ndr, "data", r->in.data, r->in.data_size);

2889

}

2890

ndr->depth--;

2891

ndr_print_uint16(ndr, "flags", r->in.flags);

2892

ndr_print_ptr(ndr, "record_number", r->in.record_number);

2893

ndr->depth++;

2894

if (r->in.record_number) {

2895

ndr_print_uint32(ndr, "record_number", *r->in.record_number);

2896

}

2897

ndr->depth--;

2898

ndr_print_ptr(ndr, "time_written", r->in.time_written);

2899

ndr->depth++;

2900

if (r->in.time_written) {

2901

ndr_print_time_t(ndr, "time_written", *r->in.time_written);

2902

}

2903

ndr->depth--;

2904

ndr->depth--;

2905

}

2906

if (flags & NDR_OUT) {

2907

ndr_print_struct(ndr, "out", "eventlog_ReportEventAndSourceW");

2908

ndr->depth++;

2909

ndr_print_ptr(ndr, "record_number", r->out.record_number);

2910

ndr->depth++;

2911

if (r->out.record_number) {

2912

ndr_print_uint32(ndr, "record_number", *r->out.record_number);

2913

}

2914

ndr->depth--;

2915

ndr_print_ptr(ndr, "time_written", r->out.time_written);

2916

ndr->depth++;

2917

if (r->out.time_written) {

2918

ndr_print_time_t(ndr, "time_written", *r->out.time_written);

2919

}

2920

ndr->depth--;

2921

ndr_print_NTSTATUS(ndr, "result", r->out.result);

2922

ndr->depth--;

2923

}

2924

ndr->depth--;

2925

}

2926

2927

static const struct ndr_interface_call eventlog_calls[] = {

2928

{

2929

"eventlog_ClearEventLogW",

2930

sizeof(struct eventlog_ClearEventLogW),

2931

(ndr_push_flags_fn_t) ndr_push_eventlog_ClearEventLogW,

2932

(ndr_pull_flags_fn_t) ndr_pull_eventlog_ClearEventLogW,

2933

(ndr_print_function_t) ndr_print_eventlog_ClearEventLogW,

2934

false,

2935

2936

{

2937

"eventlog_BackupEventLogW",

2938

sizeof(struct eventlog_BackupEventLogW),

2939

(ndr_push_flags_fn_t) ndr_push_eventlog_BackupEventLogW,

2940

(ndr_pull_flags_fn_t) ndr_pull_eventlog_BackupEventLogW,

2941

(ndr_print_function_t) ndr_print_eventlog_BackupEventLogW,

2942

false,

2943

2944

{

2945

"eventlog_CloseEventLog",

2946

sizeof(struct eventlog_CloseEventLog),

2947

(ndr_push_flags_fn_t) ndr_push_eventlog_CloseEventLog,

2948

(ndr_pull_flags_fn_t) ndr_pull_eventlog_CloseEventLog,

2949

(ndr_print_function_t) ndr_print_eventlog_CloseEventLog,

2950

false,

2951

2952

{

2953

"eventlog_DeregisterEventSource",

2954

sizeof(struct eventlog_DeregisterEventSource),

2955

(ndr_push_flags_fn_t) ndr_push_eventlog_DeregisterEventSource,

2956

(ndr_pull_flags_fn_t) ndr_pull_eventlog_DeregisterEventSource,

2957

(ndr_print_function_t) ndr_print_eventlog_DeregisterEventSource,

2958

false,

2959

2960

{

2961

"eventlog_GetNumRecords",

2962

sizeof(struct eventlog_GetNumRecords),

2963

(ndr_push_flags_fn_t) ndr_push_eventlog_GetNumRecords,

2964

(ndr_pull_flags_fn_t) ndr_pull_eventlog_GetNumRecords,

2965

(ndr_print_function_t) ndr_print_eventlog_GetNumRecords,

2966

false,

2967

2968

{

2969

"eventlog_GetOldestRecord",

2970

sizeof(struct eventlog_GetOldestRecord),

2971

(ndr_push_flags_fn_t) ndr_push_eventlog_GetOldestRecord,

2972

(ndr_pull_flags_fn_t) ndr_pull_eventlog_GetOldestRecord,

2973

(ndr_print_function_t) ndr_print_eventlog_GetOldestRecord,

2974

false,

2975

2976

{

2977

"eventlog_ChangeNotify",

2978

sizeof(struct eventlog_ChangeNotify),

2979

(ndr_push_flags_fn_t) ndr_push_eventlog_ChangeNotify,

2980

(ndr_pull_flags_fn_t) ndr_pull_eventlog_ChangeNotify,

2981

(ndr_print_function_t) ndr_print_eventlog_ChangeNotify,

2982

false,

2983

2984

{

2985

"eventlog_OpenEventLogW",

2986

sizeof(struct eventlog_OpenEventLogW),

2987

(ndr_push_flags_fn_t) ndr_push_eventlog_OpenEventLogW,

2988

(ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenEventLogW,

2989

(ndr_print_function_t) ndr_print_eventlog_OpenEventLogW,

2990

false,

2991

2992

{

2993

"eventlog_RegisterEventSourceW",

2994

sizeof(struct eventlog_RegisterEventSourceW),

2995

(ndr_push_flags_fn_t) ndr_push_eventlog_RegisterEventSourceW,

2996

(ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterEventSourceW,

2997

(ndr_print_function_t) ndr_print_eventlog_RegisterEventSourceW,

2998

false,

2999

3000

{

3001

"eventlog_OpenBackupEventLogW",

3002

sizeof(struct eventlog_OpenBackupEventLogW),

3003

(ndr_push_flags_fn_t) ndr_push_eventlog_OpenBackupEventLogW,

3004

(ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenBackupEventLogW,

3005

(ndr_print_function_t) ndr_print_eventlog_OpenBackupEventLogW,

3006

false,

3007

3008

{

3009

"eventlog_ReadEventLogW",

3010

sizeof(struct eventlog_ReadEventLogW),

3011

(ndr_push_flags_fn_t) ndr_push_eventlog_ReadEventLogW,

3012

(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReadEventLogW,

3013

(ndr_print_function_t) ndr_print_eventlog_ReadEventLogW,

3014

false,

3015

3016

{

3017

"eventlog_ReportEventW",

3018

sizeof(struct eventlog_ReportEventW),

3019

(ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventW,

3020

(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventW,

3021

(ndr_print_function_t) ndr_print_eventlog_ReportEventW,

3022

false,

3023

3024

{

3025

"eventlog_ClearEventLogA",

3026

sizeof(struct eventlog_ClearEventLogA),

3027

(ndr_push_flags_fn_t) ndr_push_eventlog_ClearEventLogA,

3028

(ndr_pull_flags_fn_t) ndr_pull_eventlog_ClearEventLogA,

3029

(ndr_print_function_t) ndr_print_eventlog_ClearEventLogA,

3030

false,

3031

3032

{

3033

"eventlog_BackupEventLogA",

3034

sizeof(struct eventlog_BackupEventLogA),

3035

(ndr_push_flags_fn_t) ndr_push_eventlog_BackupEventLogA,

3036

(ndr_pull_flags_fn_t) ndr_pull_eventlog_BackupEventLogA,

3037

(ndr_print_function_t) ndr_print_eventlog_BackupEventLogA,

3038

false,

3039

3040

{

3041

"eventlog_OpenEventLogA",

3042

sizeof(struct eventlog_OpenEventLogA),

3043

(ndr_push_flags_fn_t) ndr_push_eventlog_OpenEventLogA,

3044

(ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenEventLogA,

3045

(ndr_print_function_t) ndr_print_eventlog_OpenEventLogA,

3046

false,

3047

3048

{

3049

"eventlog_RegisterEventSourceA",

3050

sizeof(struct eventlog_RegisterEventSourceA),

3051

(ndr_push_flags_fn_t) ndr_push_eventlog_RegisterEventSourceA,

3052

(ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterEventSourceA,

3053

(ndr_print_function_t) ndr_print_eventlog_RegisterEventSourceA,

3054

false,

3055

3056

{

3057

"eventlog_OpenBackupEventLogA",

3058

sizeof(struct eventlog_OpenBackupEventLogA),

3059

(ndr_push_flags_fn_t) ndr_push_eventlog_OpenBackupEventLogA,

3060

(ndr_pull_flags_fn_t) ndr_pull_eventlog_OpenBackupEventLogA,

3061

(ndr_print_function_t) ndr_print_eventlog_OpenBackupEventLogA,

3062

false,

3063

3064

{

3065

"eventlog_ReadEventLogA",

3066

sizeof(struct eventlog_ReadEventLogA),

3067

(ndr_push_flags_fn_t) ndr_push_eventlog_ReadEventLogA,

3068

(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReadEventLogA,

3069

(ndr_print_function_t) ndr_print_eventlog_ReadEventLogA,

3070

false,

3071

3072

{

3073

"eventlog_ReportEventA",

3074

sizeof(struct eventlog_ReportEventA),

3075

(ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventA,

3076

(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventA,

3077

(ndr_print_function_t) ndr_print_eventlog_ReportEventA,

3078

false,

3079

3080

{

3081

"eventlog_RegisterClusterSvc",

3082

sizeof(struct eventlog_RegisterClusterSvc),

3083

(ndr_push_flags_fn_t) ndr_push_eventlog_RegisterClusterSvc,

3084

(ndr_pull_flags_fn_t) ndr_pull_eventlog_RegisterClusterSvc,

3085

(ndr_print_function_t) ndr_print_eventlog_RegisterClusterSvc,

3086

false,

3087

3088

{

3089

"eventlog_DeregisterClusterSvc",

3090

sizeof(struct eventlog_DeregisterClusterSvc),

3091

(ndr_push_flags_fn_t) ndr_push_eventlog_DeregisterClusterSvc,

3092

(ndr_pull_flags_fn_t) ndr_pull_eventlog_DeregisterClusterSvc,

3093

(ndr_print_function_t) ndr_print_eventlog_DeregisterClusterSvc,

3094

false,

3095

3096

{

3097

"eventlog_WriteClusterEvents",

3098

sizeof(struct eventlog_WriteClusterEvents),

3099

(ndr_push_flags_fn_t) ndr_push_eventlog_WriteClusterEvents,

3100

(ndr_pull_flags_fn_t) ndr_pull_eventlog_WriteClusterEvents,

3101

(ndr_print_function_t) ndr_print_eventlog_WriteClusterEvents,

3102

false,

3103

3104

{

3105

"eventlog_GetLogInformation",

3106

sizeof(struct eventlog_GetLogInformation),

3107

(ndr_push_flags_fn_t) ndr_push_eventlog_GetLogInformation,

3108

(ndr_pull_flags_fn_t) ndr_pull_eventlog_GetLogInformation,

3109

(ndr_print_function_t) ndr_print_eventlog_GetLogInformation,

3110

false,

3111

3112

{

3113

"eventlog_FlushEventLog",

3114

sizeof(struct eventlog_FlushEventLog),

3115

(ndr_push_flags_fn_t) ndr_push_eventlog_FlushEventLog,

3116

(ndr_pull_flags_fn_t) ndr_pull_eventlog_FlushEventLog,

3117

(ndr_print_function_t) ndr_print_eventlog_FlushEventLog,

3118

false,

3119

3120

{

3121

"eventlog_ReportEventAndSourceW",

3122

sizeof(struct eventlog_ReportEventAndSourceW),

3123

(ndr_push_flags_fn_t) ndr_push_eventlog_ReportEventAndSourceW,

3124

(ndr_pull_flags_fn_t) ndr_pull_eventlog_ReportEventAndSourceW,

3125

(ndr_print_function_t) ndr_print_eventlog_ReportEventAndSourceW,

3126

false,

3127

3128

{ NULL, 0, NULL, NULL, NULL, false }

3129

};

3130

3131

static const char * const eventlog_endpoint_strings[] = {

3132

"ncacn_np:[\\pipe\\eventlog]",

3133

};

3134

3135

static const struct ndr_interface_string_array eventlog_endpoints = {

3136

.count = 1,

3137

.names = eventlog_endpoint_strings

3138

};

3139

3140

static const char * const eventlog_authservice_strings[] = {

3141

"host",

3142

};

3143

3144

static const struct ndr_interface_string_array eventlog_authservices = {

3145

.count = 1,

3146

.names = eventlog_authservice_strings

3147

};

3148

3149

3150

const struct ndr_interface_table ndr_table_eventlog = {

3151

.name = "eventlog",

3152

.syntax_id = {

3153

{0x82273fdc,0xe32a,0x18c3,{0x3f,0x78},{0x82,0x79,0x29,0xdc,0x23,0xea}},

3154

NDR_EVENTLOG_VERSION

3155

3156

.helpstring = NDR_EVENTLOG_HELPSTRING,

3157

.num_calls = 25,

3158

.calls = eventlog_calls,

3159

.endpoints = &eventlog_endpoints,

3160

.authservices = &eventlog_authservices

3161

};

3162