root/librpc/gen_ndr/srv_eventlog.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. api_eventlog_ClearEventLogW
  2. api_eventlog_BackupEventLogW
  3. api_eventlog_CloseEventLog
  4. api_eventlog_DeregisterEventSource
  5. api_eventlog_GetNumRecords
  6. api_eventlog_GetOldestRecord
  7. api_eventlog_ChangeNotify
  8. api_eventlog_OpenEventLogW
  9. api_eventlog_RegisterEventSourceW
  10. api_eventlog_OpenBackupEventLogW
  11. api_eventlog_ReadEventLogW
  12. api_eventlog_ReportEventW
  13. api_eventlog_ClearEventLogA
  14. api_eventlog_BackupEventLogA
  15. api_eventlog_OpenEventLogA
  16. api_eventlog_RegisterEventSourceA
  17. api_eventlog_OpenBackupEventLogA
  18. api_eventlog_ReadEventLogA
  19. api_eventlog_ReportEventA
  20. api_eventlog_RegisterClusterSvc
  21. api_eventlog_DeregisterClusterSvc
  22. api_eventlog_WriteClusterEvents
  23. api_eventlog_GetLogInformation
  24. api_eventlog_FlushEventLog
  25. api_eventlog_ReportEventAndSourceW
  26. eventlog_get_pipe_fns
  27. rpc_eventlog_dispatch
  28. rpc_eventlog_init

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * server auto-generated by pidl. DO NOT MODIFY!
   4  */
   5 
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/srv_eventlog.h"
   8 
   9 static bool api_eventlog_ClearEventLogW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
  10 {
  11         const struct ndr_interface_call *call;
  12         struct ndr_pull *pull;
  13         struct ndr_push *push;
  14         enum ndr_err_code ndr_err;
  15         DATA_BLOB blob;
  16         struct eventlog_ClearEventLogW *r;
  17 
  18         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLEAREVENTLOGW];
  19 
  20         r = talloc(talloc_tos(), struct eventlog_ClearEventLogW);
  21         if (r == NULL) {
  22                 return false;
  23         }
  24 
  25         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  26                 talloc_free(r);
  27                 return false;
  28         }
  29 
  30         pull = ndr_pull_init_blob(&blob, r, NULL);
  31         if (pull == NULL) {
  32                 talloc_free(r);
  33                 return false;
  34         }
  35 
  36         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  37         ndr_err = call->ndr_pull(pull, NDR_IN, r);
  38         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  39                 talloc_free(r);
  40                 return false;
  41         }
  42 
  43         if (DEBUGLEVEL >= 10) {
  44                 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogW, r);
  45         }
  46 
  47         r->out.result = _eventlog_ClearEventLogW(p, r);
  48 
  49         if (p->rng_fault_state) {
  50                 talloc_free(r);
  51                 /* Return true here, srv_pipe_hnd.c will take care */
  52                 return true;
  53         }
  54 
  55         if (DEBUGLEVEL >= 10) {
  56                 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogW, r);
  57         }
  58 
  59         push = ndr_push_init_ctx(r, NULL);
  60         if (push == NULL) {
  61                 talloc_free(r);
  62                 return false;
  63         }
  64 
  65         ndr_err = call->ndr_push(push, NDR_OUT, r);
  66         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  67                 talloc_free(r);
  68                 return false;
  69         }
  70 
  71         blob = ndr_push_blob(push);
  72         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  73                 talloc_free(r);
  74                 return false;
  75         }
  76 
  77         talloc_free(r);
  78 
  79         return true;
  80 }
  81 
  82 static bool api_eventlog_BackupEventLogW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
  83 {
  84         const struct ndr_interface_call *call;
  85         struct ndr_pull *pull;
  86         struct ndr_push *push;
  87         enum ndr_err_code ndr_err;
  88         DATA_BLOB blob;
  89         struct eventlog_BackupEventLogW *r;
  90 
  91         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_BACKUPEVENTLOGW];
  92 
  93         r = talloc(talloc_tos(), struct eventlog_BackupEventLogW);
  94         if (r == NULL) {
  95                 return false;
  96         }
  97 
  98         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  99                 talloc_free(r);
 100                 return false;
 101         }
 102 
 103         pull = ndr_pull_init_blob(&blob, r, NULL);
 104         if (pull == NULL) {
 105                 talloc_free(r);
 106                 return false;
 107         }
 108 
 109         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 110         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 111         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 112                 talloc_free(r);
 113                 return false;
 114         }
 115 
 116         if (DEBUGLEVEL >= 10) {
 117                 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogW, r);
 118         }
 119 
 120         r->out.result = _eventlog_BackupEventLogW(p, r);
 121 
 122         if (p->rng_fault_state) {
 123                 talloc_free(r);
 124                 /* Return true here, srv_pipe_hnd.c will take care */
 125                 return true;
 126         }
 127 
 128         if (DEBUGLEVEL >= 10) {
 129                 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogW, r);
 130         }
 131 
 132         push = ndr_push_init_ctx(r, NULL);
 133         if (push == NULL) {
 134                 talloc_free(r);
 135                 return false;
 136         }
 137 
 138         ndr_err = call->ndr_push(push, NDR_OUT, r);
 139         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 140                 talloc_free(r);
 141                 return false;
 142         }
 143 
 144         blob = ndr_push_blob(push);
 145         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 146                 talloc_free(r);
 147                 return false;
 148         }
 149 
 150         talloc_free(r);
 151 
 152         return true;
 153 }
 154 
 155 static bool api_eventlog_CloseEventLog(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 156 {
 157         const struct ndr_interface_call *call;
 158         struct ndr_pull *pull;
 159         struct ndr_push *push;
 160         enum ndr_err_code ndr_err;
 161         DATA_BLOB blob;
 162         struct eventlog_CloseEventLog *r;
 163 
 164         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLOSEEVENTLOG];
 165 
 166         r = talloc(talloc_tos(), struct eventlog_CloseEventLog);
 167         if (r == NULL) {
 168                 return false;
 169         }
 170 
 171         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 172                 talloc_free(r);
 173                 return false;
 174         }
 175 
 176         pull = ndr_pull_init_blob(&blob, r, NULL);
 177         if (pull == NULL) {
 178                 talloc_free(r);
 179                 return false;
 180         }
 181 
 182         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 183         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 184         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 185                 talloc_free(r);
 186                 return false;
 187         }
 188 
 189         if (DEBUGLEVEL >= 10) {
 190                 NDR_PRINT_IN_DEBUG(eventlog_CloseEventLog, r);
 191         }
 192 
 193         ZERO_STRUCT(r->out);
 194         r->out.handle = r->in.handle;
 195         r->out.result = _eventlog_CloseEventLog(p, r);
 196 
 197         if (p->rng_fault_state) {
 198                 talloc_free(r);
 199                 /* Return true here, srv_pipe_hnd.c will take care */
 200                 return true;
 201         }
 202 
 203         if (DEBUGLEVEL >= 10) {
 204                 NDR_PRINT_OUT_DEBUG(eventlog_CloseEventLog, r);
 205         }
 206 
 207         push = ndr_push_init_ctx(r, NULL);
 208         if (push == NULL) {
 209                 talloc_free(r);
 210                 return false;
 211         }
 212 
 213         ndr_err = call->ndr_push(push, NDR_OUT, r);
 214         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 215                 talloc_free(r);
 216                 return false;
 217         }
 218 
 219         blob = ndr_push_blob(push);
 220         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 221                 talloc_free(r);
 222                 return false;
 223         }
 224 
 225         talloc_free(r);
 226 
 227         return true;
 228 }
 229 
 230 static bool api_eventlog_DeregisterEventSource(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 231 {
 232         const struct ndr_interface_call *call;
 233         struct ndr_pull *pull;
 234         struct ndr_push *push;
 235         enum ndr_err_code ndr_err;
 236         DATA_BLOB blob;
 237         struct eventlog_DeregisterEventSource *r;
 238 
 239         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_DEREGISTEREVENTSOURCE];
 240 
 241         r = talloc(talloc_tos(), struct eventlog_DeregisterEventSource);
 242         if (r == NULL) {
 243                 return false;
 244         }
 245 
 246         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 247                 talloc_free(r);
 248                 return false;
 249         }
 250 
 251         pull = ndr_pull_init_blob(&blob, r, NULL);
 252         if (pull == NULL) {
 253                 talloc_free(r);
 254                 return false;
 255         }
 256 
 257         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 258         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 259         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 260                 talloc_free(r);
 261                 return false;
 262         }
 263 
 264         if (DEBUGLEVEL >= 10) {
 265                 NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, r);
 266         }
 267 
 268         ZERO_STRUCT(r->out);
 269         r->out.handle = r->in.handle;
 270         r->out.result = _eventlog_DeregisterEventSource(p, r);
 271 
 272         if (p->rng_fault_state) {
 273                 talloc_free(r);
 274                 /* Return true here, srv_pipe_hnd.c will take care */
 275                 return true;
 276         }
 277 
 278         if (DEBUGLEVEL >= 10) {
 279                 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterEventSource, r);
 280         }
 281 
 282         push = ndr_push_init_ctx(r, NULL);
 283         if (push == NULL) {
 284                 talloc_free(r);
 285                 return false;
 286         }
 287 
 288         ndr_err = call->ndr_push(push, NDR_OUT, r);
 289         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 290                 talloc_free(r);
 291                 return false;
 292         }
 293 
 294         blob = ndr_push_blob(push);
 295         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 296                 talloc_free(r);
 297                 return false;
 298         }
 299 
 300         talloc_free(r);
 301 
 302         return true;
 303 }
 304 
 305 static bool api_eventlog_GetNumRecords(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 306 {
 307         const struct ndr_interface_call *call;
 308         struct ndr_pull *pull;
 309         struct ndr_push *push;
 310         enum ndr_err_code ndr_err;
 311         DATA_BLOB blob;
 312         struct eventlog_GetNumRecords *r;
 313 
 314         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETNUMRECORDS];
 315 
 316         r = talloc(talloc_tos(), struct eventlog_GetNumRecords);
 317         if (r == NULL) {
 318                 return false;
 319         }
 320 
 321         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 322                 talloc_free(r);
 323                 return false;
 324         }
 325 
 326         pull = ndr_pull_init_blob(&blob, r, NULL);
 327         if (pull == NULL) {
 328                 talloc_free(r);
 329                 return false;
 330         }
 331 
 332         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 333         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 334         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 335                 talloc_free(r);
 336                 return false;
 337         }
 338 
 339         if (DEBUGLEVEL >= 10) {
 340                 NDR_PRINT_IN_DEBUG(eventlog_GetNumRecords, r);
 341         }
 342 
 343         ZERO_STRUCT(r->out);
 344         r->out.number = talloc_zero(r, uint32_t);
 345         if (r->out.number == NULL) {
 346                 talloc_free(r);
 347                 return false;
 348         }
 349 
 350         r->out.result = _eventlog_GetNumRecords(p, r);
 351 
 352         if (p->rng_fault_state) {
 353                 talloc_free(r);
 354                 /* Return true here, srv_pipe_hnd.c will take care */
 355                 return true;
 356         }
 357 
 358         if (DEBUGLEVEL >= 10) {
 359                 NDR_PRINT_OUT_DEBUG(eventlog_GetNumRecords, r);
 360         }
 361 
 362         push = ndr_push_init_ctx(r, NULL);
 363         if (push == NULL) {
 364                 talloc_free(r);
 365                 return false;
 366         }
 367 
 368         ndr_err = call->ndr_push(push, NDR_OUT, r);
 369         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 370                 talloc_free(r);
 371                 return false;
 372         }
 373 
 374         blob = ndr_push_blob(push);
 375         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 376                 talloc_free(r);
 377                 return false;
 378         }
 379 
 380         talloc_free(r);
 381 
 382         return true;
 383 }
 384 
 385 static bool api_eventlog_GetOldestRecord(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 386 {
 387         const struct ndr_interface_call *call;
 388         struct ndr_pull *pull;
 389         struct ndr_push *push;
 390         enum ndr_err_code ndr_err;
 391         DATA_BLOB blob;
 392         struct eventlog_GetOldestRecord *r;
 393 
 394         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETOLDESTRECORD];
 395 
 396         r = talloc(talloc_tos(), struct eventlog_GetOldestRecord);
 397         if (r == NULL) {
 398                 return false;
 399         }
 400 
 401         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 402                 talloc_free(r);
 403                 return false;
 404         }
 405 
 406         pull = ndr_pull_init_blob(&blob, r, NULL);
 407         if (pull == NULL) {
 408                 talloc_free(r);
 409                 return false;
 410         }
 411 
 412         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 413         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 414         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 415                 talloc_free(r);
 416                 return false;
 417         }
 418 
 419         if (DEBUGLEVEL >= 10) {
 420                 NDR_PRINT_IN_DEBUG(eventlog_GetOldestRecord, r);
 421         }
 422 
 423         ZERO_STRUCT(r->out);
 424         r->out.oldest_entry = talloc_zero(r, uint32_t);
 425         if (r->out.oldest_entry == NULL) {
 426                 talloc_free(r);
 427                 return false;
 428         }
 429 
 430         r->out.result = _eventlog_GetOldestRecord(p, r);
 431 
 432         if (p->rng_fault_state) {
 433                 talloc_free(r);
 434                 /* Return true here, srv_pipe_hnd.c will take care */
 435                 return true;
 436         }
 437 
 438         if (DEBUGLEVEL >= 10) {
 439                 NDR_PRINT_OUT_DEBUG(eventlog_GetOldestRecord, r);
 440         }
 441 
 442         push = ndr_push_init_ctx(r, NULL);
 443         if (push == NULL) {
 444                 talloc_free(r);
 445                 return false;
 446         }
 447 
 448         ndr_err = call->ndr_push(push, NDR_OUT, r);
 449         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 450                 talloc_free(r);
 451                 return false;
 452         }
 453 
 454         blob = ndr_push_blob(push);
 455         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 456                 talloc_free(r);
 457                 return false;
 458         }
 459 
 460         talloc_free(r);
 461 
 462         return true;
 463 }
 464 
 465 static bool api_eventlog_ChangeNotify(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 466 {
 467         const struct ndr_interface_call *call;
 468         struct ndr_pull *pull;
 469         struct ndr_push *push;
 470         enum ndr_err_code ndr_err;
 471         DATA_BLOB blob;
 472         struct eventlog_ChangeNotify *r;
 473 
 474         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CHANGENOTIFY];
 475 
 476         r = talloc(talloc_tos(), struct eventlog_ChangeNotify);
 477         if (r == NULL) {
 478                 return false;
 479         }
 480 
 481         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 482                 talloc_free(r);
 483                 return false;
 484         }
 485 
 486         pull = ndr_pull_init_blob(&blob, r, NULL);
 487         if (pull == NULL) {
 488                 talloc_free(r);
 489                 return false;
 490         }
 491 
 492         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 493         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 494         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 495                 talloc_free(r);
 496                 return false;
 497         }
 498 
 499         if (DEBUGLEVEL >= 10) {
 500                 NDR_PRINT_IN_DEBUG(eventlog_ChangeNotify, r);
 501         }
 502 
 503         r->out.result = _eventlog_ChangeNotify(p, r);
 504 
 505         if (p->rng_fault_state) {
 506                 talloc_free(r);
 507                 /* Return true here, srv_pipe_hnd.c will take care */
 508                 return true;
 509         }
 510 
 511         if (DEBUGLEVEL >= 10) {
 512                 NDR_PRINT_OUT_DEBUG(eventlog_ChangeNotify, r);
 513         }
 514 
 515         push = ndr_push_init_ctx(r, NULL);
 516         if (push == NULL) {
 517                 talloc_free(r);
 518                 return false;
 519         }
 520 
 521         ndr_err = call->ndr_push(push, NDR_OUT, r);
 522         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 523                 talloc_free(r);
 524                 return false;
 525         }
 526 
 527         blob = ndr_push_blob(push);
 528         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 529                 talloc_free(r);
 530                 return false;
 531         }
 532 
 533         talloc_free(r);
 534 
 535         return true;
 536 }
 537 
 538 static bool api_eventlog_OpenEventLogW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 539 {
 540         const struct ndr_interface_call *call;
 541         struct ndr_pull *pull;
 542         struct ndr_push *push;
 543         enum ndr_err_code ndr_err;
 544         DATA_BLOB blob;
 545         struct eventlog_OpenEventLogW *r;
 546 
 547         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGW];
 548 
 549         r = talloc(talloc_tos(), struct eventlog_OpenEventLogW);
 550         if (r == NULL) {
 551                 return false;
 552         }
 553 
 554         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 555                 talloc_free(r);
 556                 return false;
 557         }
 558 
 559         pull = ndr_pull_init_blob(&blob, r, NULL);
 560         if (pull == NULL) {
 561                 talloc_free(r);
 562                 return false;
 563         }
 564 
 565         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 566         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 567         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 568                 talloc_free(r);
 569                 return false;
 570         }
 571 
 572         if (DEBUGLEVEL >= 10) {
 573                 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogW, r);
 574         }
 575 
 576         ZERO_STRUCT(r->out);
 577         r->out.handle = talloc_zero(r, struct policy_handle);
 578         if (r->out.handle == NULL) {
 579                 talloc_free(r);
 580                 return false;
 581         }
 582 
 583         r->out.result = _eventlog_OpenEventLogW(p, r);
 584 
 585         if (p->rng_fault_state) {
 586                 talloc_free(r);
 587                 /* Return true here, srv_pipe_hnd.c will take care */
 588                 return true;
 589         }
 590 
 591         if (DEBUGLEVEL >= 10) {
 592                 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogW, r);
 593         }
 594 
 595         push = ndr_push_init_ctx(r, NULL);
 596         if (push == NULL) {
 597                 talloc_free(r);
 598                 return false;
 599         }
 600 
 601         ndr_err = call->ndr_push(push, NDR_OUT, r);
 602         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 603                 talloc_free(r);
 604                 return false;
 605         }
 606 
 607         blob = ndr_push_blob(push);
 608         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 609                 talloc_free(r);
 610                 return false;
 611         }
 612 
 613         talloc_free(r);
 614 
 615         return true;
 616 }
 617 
 618 static bool api_eventlog_RegisterEventSourceW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 619 {
 620         const struct ndr_interface_call *call;
 621         struct ndr_pull *pull;
 622         struct ndr_push *push;
 623         enum ndr_err_code ndr_err;
 624         DATA_BLOB blob;
 625         struct eventlog_RegisterEventSourceW *r;
 626 
 627         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEW];
 628 
 629         r = talloc(talloc_tos(), struct eventlog_RegisterEventSourceW);
 630         if (r == NULL) {
 631                 return false;
 632         }
 633 
 634         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 635                 talloc_free(r);
 636                 return false;
 637         }
 638 
 639         pull = ndr_pull_init_blob(&blob, r, NULL);
 640         if (pull == NULL) {
 641                 talloc_free(r);
 642                 return false;
 643         }
 644 
 645         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 646         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 647         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 648                 talloc_free(r);
 649                 return false;
 650         }
 651 
 652         if (DEBUGLEVEL >= 10) {
 653                 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, r);
 654         }
 655 
 656         ZERO_STRUCT(r->out);
 657         r->out.log_handle = talloc_zero(r, struct policy_handle);
 658         if (r->out.log_handle == NULL) {
 659                 talloc_free(r);
 660                 return false;
 661         }
 662 
 663         r->out.result = _eventlog_RegisterEventSourceW(p, r);
 664 
 665         if (p->rng_fault_state) {
 666                 talloc_free(r);
 667                 /* Return true here, srv_pipe_hnd.c will take care */
 668                 return true;
 669         }
 670 
 671         if (DEBUGLEVEL >= 10) {
 672                 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceW, r);
 673         }
 674 
 675         push = ndr_push_init_ctx(r, NULL);
 676         if (push == NULL) {
 677                 talloc_free(r);
 678                 return false;
 679         }
 680 
 681         ndr_err = call->ndr_push(push, NDR_OUT, r);
 682         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 683                 talloc_free(r);
 684                 return false;
 685         }
 686 
 687         blob = ndr_push_blob(push);
 688         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 689                 talloc_free(r);
 690                 return false;
 691         }
 692 
 693         talloc_free(r);
 694 
 695         return true;
 696 }
 697 
 698 static bool api_eventlog_OpenBackupEventLogW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 699 {
 700         const struct ndr_interface_call *call;
 701         struct ndr_pull *pull;
 702         struct ndr_push *push;
 703         enum ndr_err_code ndr_err;
 704         DATA_BLOB blob;
 705         struct eventlog_OpenBackupEventLogW *r;
 706 
 707         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGW];
 708 
 709         r = talloc(talloc_tos(), struct eventlog_OpenBackupEventLogW);
 710         if (r == NULL) {
 711                 return false;
 712         }
 713 
 714         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 715                 talloc_free(r);
 716                 return false;
 717         }
 718 
 719         pull = ndr_pull_init_blob(&blob, r, NULL);
 720         if (pull == NULL) {
 721                 talloc_free(r);
 722                 return false;
 723         }
 724 
 725         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 726         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 727         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 728                 talloc_free(r);
 729                 return false;
 730         }
 731 
 732         if (DEBUGLEVEL >= 10) {
 733                 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, r);
 734         }
 735 
 736         ZERO_STRUCT(r->out);
 737         r->out.handle = talloc_zero(r, struct policy_handle);
 738         if (r->out.handle == NULL) {
 739                 talloc_free(r);
 740                 return false;
 741         }
 742 
 743         r->out.result = _eventlog_OpenBackupEventLogW(p, r);
 744 
 745         if (p->rng_fault_state) {
 746                 talloc_free(r);
 747                 /* Return true here, srv_pipe_hnd.c will take care */
 748                 return true;
 749         }
 750 
 751         if (DEBUGLEVEL >= 10) {
 752                 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogW, r);
 753         }
 754 
 755         push = ndr_push_init_ctx(r, NULL);
 756         if (push == NULL) {
 757                 talloc_free(r);
 758                 return false;
 759         }
 760 
 761         ndr_err = call->ndr_push(push, NDR_OUT, r);
 762         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 763                 talloc_free(r);
 764                 return false;
 765         }
 766 
 767         blob = ndr_push_blob(push);
 768         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 769                 talloc_free(r);
 770                 return false;
 771         }
 772 
 773         talloc_free(r);
 774 
 775         return true;
 776 }
 777 
 778 static bool api_eventlog_ReadEventLogW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 779 {
 780         const struct ndr_interface_call *call;
 781         struct ndr_pull *pull;
 782         struct ndr_push *push;
 783         enum ndr_err_code ndr_err;
 784         DATA_BLOB blob;
 785         struct eventlog_ReadEventLogW *r;
 786 
 787         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGW];
 788 
 789         r = talloc(talloc_tos(), struct eventlog_ReadEventLogW);
 790         if (r == NULL) {
 791                 return false;
 792         }
 793 
 794         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 795                 talloc_free(r);
 796                 return false;
 797         }
 798 
 799         pull = ndr_pull_init_blob(&blob, r, NULL);
 800         if (pull == NULL) {
 801                 talloc_free(r);
 802                 return false;
 803         }
 804 
 805         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 806         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 807         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 808                 talloc_free(r);
 809                 return false;
 810         }
 811 
 812         if (DEBUGLEVEL >= 10) {
 813                 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogW, r);
 814         }
 815 
 816         ZERO_STRUCT(r->out);
 817         r->out.data = talloc_zero_array(r, uint8_t, r->in.number_of_bytes);
 818         if (r->out.data == NULL) {
 819                 talloc_free(r);
 820                 return false;
 821         }
 822 
 823         r->out.sent_size = talloc_zero(r, uint32_t);
 824         if (r->out.sent_size == NULL) {
 825                 talloc_free(r);
 826                 return false;
 827         }
 828 
 829         r->out.real_size = talloc_zero(r, uint32_t);
 830         if (r->out.real_size == NULL) {
 831                 talloc_free(r);
 832                 return false;
 833         }
 834 
 835         r->out.result = _eventlog_ReadEventLogW(p, r);
 836 
 837         if (p->rng_fault_state) {
 838                 talloc_free(r);
 839                 /* Return true here, srv_pipe_hnd.c will take care */
 840                 return true;
 841         }
 842 
 843         if (DEBUGLEVEL >= 10) {
 844                 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogW, r);
 845         }
 846 
 847         push = ndr_push_init_ctx(r, NULL);
 848         if (push == NULL) {
 849                 talloc_free(r);
 850                 return false;
 851         }
 852 
 853         ndr_err = call->ndr_push(push, NDR_OUT, r);
 854         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 855                 talloc_free(r);
 856                 return false;
 857         }
 858 
 859         blob = ndr_push_blob(push);
 860         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 861                 talloc_free(r);
 862                 return false;
 863         }
 864 
 865         talloc_free(r);
 866 
 867         return true;
 868 }
 869 
 870 static bool api_eventlog_ReportEventW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 871 {
 872         const struct ndr_interface_call *call;
 873         struct ndr_pull *pull;
 874         struct ndr_push *push;
 875         enum ndr_err_code ndr_err;
 876         DATA_BLOB blob;
 877         struct eventlog_ReportEventW *r;
 878 
 879         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTW];
 880 
 881         r = talloc(talloc_tos(), struct eventlog_ReportEventW);
 882         if (r == NULL) {
 883                 return false;
 884         }
 885 
 886         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 887                 talloc_free(r);
 888                 return false;
 889         }
 890 
 891         pull = ndr_pull_init_blob(&blob, r, NULL);
 892         if (pull == NULL) {
 893                 talloc_free(r);
 894                 return false;
 895         }
 896 
 897         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 898         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 899         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 900                 talloc_free(r);
 901                 return false;
 902         }
 903 
 904         if (DEBUGLEVEL >= 10) {
 905                 NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, r);
 906         }
 907 
 908         ZERO_STRUCT(r->out);
 909         r->out.record_number = r->in.record_number;
 910         r->out.time_written = r->in.time_written;
 911         r->out.result = _eventlog_ReportEventW(p, r);
 912 
 913         if (p->rng_fault_state) {
 914                 talloc_free(r);
 915                 /* Return true here, srv_pipe_hnd.c will take care */
 916                 return true;
 917         }
 918 
 919         if (DEBUGLEVEL >= 10) {
 920                 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventW, r);
 921         }
 922 
 923         push = ndr_push_init_ctx(r, NULL);
 924         if (push == NULL) {
 925                 talloc_free(r);
 926                 return false;
 927         }
 928 
 929         ndr_err = call->ndr_push(push, NDR_OUT, r);
 930         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 931                 talloc_free(r);
 932                 return false;
 933         }
 934 
 935         blob = ndr_push_blob(push);
 936         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 937                 talloc_free(r);
 938                 return false;
 939         }
 940 
 941         talloc_free(r);
 942 
 943         return true;
 944 }
 945 
 946 static bool api_eventlog_ClearEventLogA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
 947 {
 948         const struct ndr_interface_call *call;
 949         struct ndr_pull *pull;
 950         struct ndr_push *push;
 951         enum ndr_err_code ndr_err;
 952         DATA_BLOB blob;
 953         struct eventlog_ClearEventLogA *r;
 954 
 955         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_CLEAREVENTLOGA];
 956 
 957         r = talloc(talloc_tos(), struct eventlog_ClearEventLogA);
 958         if (r == NULL) {
 959                 return false;
 960         }
 961 
 962         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 963                 talloc_free(r);
 964                 return false;
 965         }
 966 
 967         pull = ndr_pull_init_blob(&blob, r, NULL);
 968         if (pull == NULL) {
 969                 talloc_free(r);
 970                 return false;
 971         }
 972 
 973         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 974         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 975         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 976                 talloc_free(r);
 977                 return false;
 978         }
 979 
 980         if (DEBUGLEVEL >= 10) {
 981                 NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogA, r);
 982         }
 983 
 984         r->out.result = _eventlog_ClearEventLogA(p, r);
 985 
 986         if (p->rng_fault_state) {
 987                 talloc_free(r);
 988                 /* Return true here, srv_pipe_hnd.c will take care */
 989                 return true;
 990         }
 991 
 992         if (DEBUGLEVEL >= 10) {
 993                 NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogA, r);
 994         }
 995 
 996         push = ndr_push_init_ctx(r, NULL);
 997         if (push == NULL) {
 998                 talloc_free(r);
 999                 return false;
1000         }
1001 
1002         ndr_err = call->ndr_push(push, NDR_OUT, r);
1003         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1004                 talloc_free(r);
1005                 return false;
1006         }
1007 
1008         blob = ndr_push_blob(push);
1009         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1010                 talloc_free(r);
1011                 return false;
1012         }
1013 
1014         talloc_free(r);
1015 
1016         return true;
1017 }
1018 
1019 static bool api_eventlog_BackupEventLogA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1020 {
1021         const struct ndr_interface_call *call;
1022         struct ndr_pull *pull;
1023         struct ndr_push *push;
1024         enum ndr_err_code ndr_err;
1025         DATA_BLOB blob;
1026         struct eventlog_BackupEventLogA *r;
1027 
1028         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_BACKUPEVENTLOGA];
1029 
1030         r = talloc(talloc_tos(), struct eventlog_BackupEventLogA);
1031         if (r == NULL) {
1032                 return false;
1033         }
1034 
1035         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1036                 talloc_free(r);
1037                 return false;
1038         }
1039 
1040         pull = ndr_pull_init_blob(&blob, r, NULL);
1041         if (pull == NULL) {
1042                 talloc_free(r);
1043                 return false;
1044         }
1045 
1046         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1047         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1048         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1049                 talloc_free(r);
1050                 return false;
1051         }
1052 
1053         if (DEBUGLEVEL >= 10) {
1054                 NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogA, r);
1055         }
1056 
1057         r->out.result = _eventlog_BackupEventLogA(p, r);
1058 
1059         if (p->rng_fault_state) {
1060                 talloc_free(r);
1061                 /* Return true here, srv_pipe_hnd.c will take care */
1062                 return true;
1063         }
1064 
1065         if (DEBUGLEVEL >= 10) {
1066                 NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogA, r);
1067         }
1068 
1069         push = ndr_push_init_ctx(r, NULL);
1070         if (push == NULL) {
1071                 talloc_free(r);
1072                 return false;
1073         }
1074 
1075         ndr_err = call->ndr_push(push, NDR_OUT, r);
1076         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1077                 talloc_free(r);
1078                 return false;
1079         }
1080 
1081         blob = ndr_push_blob(push);
1082         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1083                 talloc_free(r);
1084                 return false;
1085         }
1086 
1087         talloc_free(r);
1088 
1089         return true;
1090 }
1091 
1092 static bool api_eventlog_OpenEventLogA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1093 {
1094         const struct ndr_interface_call *call;
1095         struct ndr_pull *pull;
1096         struct ndr_push *push;
1097         enum ndr_err_code ndr_err;
1098         DATA_BLOB blob;
1099         struct eventlog_OpenEventLogA *r;
1100 
1101         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENEVENTLOGA];
1102 
1103         r = talloc(talloc_tos(), struct eventlog_OpenEventLogA);
1104         if (r == NULL) {
1105                 return false;
1106         }
1107 
1108         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1109                 talloc_free(r);
1110                 return false;
1111         }
1112 
1113         pull = ndr_pull_init_blob(&blob, r, NULL);
1114         if (pull == NULL) {
1115                 talloc_free(r);
1116                 return false;
1117         }
1118 
1119         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1120         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1121         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1122                 talloc_free(r);
1123                 return false;
1124         }
1125 
1126         if (DEBUGLEVEL >= 10) {
1127                 NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogA, r);
1128         }
1129 
1130         r->out.result = _eventlog_OpenEventLogA(p, r);
1131 
1132         if (p->rng_fault_state) {
1133                 talloc_free(r);
1134                 /* Return true here, srv_pipe_hnd.c will take care */
1135                 return true;
1136         }
1137 
1138         if (DEBUGLEVEL >= 10) {
1139                 NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogA, r);
1140         }
1141 
1142         push = ndr_push_init_ctx(r, NULL);
1143         if (push == NULL) {
1144                 talloc_free(r);
1145                 return false;
1146         }
1147 
1148         ndr_err = call->ndr_push(push, NDR_OUT, r);
1149         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1150                 talloc_free(r);
1151                 return false;
1152         }
1153 
1154         blob = ndr_push_blob(push);
1155         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1156                 talloc_free(r);
1157                 return false;
1158         }
1159 
1160         talloc_free(r);
1161 
1162         return true;
1163 }
1164 
1165 static bool api_eventlog_RegisterEventSourceA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1166 {
1167         const struct ndr_interface_call *call;
1168         struct ndr_pull *pull;
1169         struct ndr_push *push;
1170         enum ndr_err_code ndr_err;
1171         DATA_BLOB blob;
1172         struct eventlog_RegisterEventSourceA *r;
1173 
1174         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTEREVENTSOURCEA];
1175 
1176         r = talloc(talloc_tos(), struct eventlog_RegisterEventSourceA);
1177         if (r == NULL) {
1178                 return false;
1179         }
1180 
1181         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1182                 talloc_free(r);
1183                 return false;
1184         }
1185 
1186         pull = ndr_pull_init_blob(&blob, r, NULL);
1187         if (pull == NULL) {
1188                 talloc_free(r);
1189                 return false;
1190         }
1191 
1192         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1193         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1194         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1195                 talloc_free(r);
1196                 return false;
1197         }
1198 
1199         if (DEBUGLEVEL >= 10) {
1200                 NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceA, r);
1201         }
1202 
1203         r->out.result = _eventlog_RegisterEventSourceA(p, r);
1204 
1205         if (p->rng_fault_state) {
1206                 talloc_free(r);
1207                 /* Return true here, srv_pipe_hnd.c will take care */
1208                 return true;
1209         }
1210 
1211         if (DEBUGLEVEL >= 10) {
1212                 NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceA, r);
1213         }
1214 
1215         push = ndr_push_init_ctx(r, NULL);
1216         if (push == NULL) {
1217                 talloc_free(r);
1218                 return false;
1219         }
1220 
1221         ndr_err = call->ndr_push(push, NDR_OUT, r);
1222         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1223                 talloc_free(r);
1224                 return false;
1225         }
1226 
1227         blob = ndr_push_blob(push);
1228         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1229                 talloc_free(r);
1230                 return false;
1231         }
1232 
1233         talloc_free(r);
1234 
1235         return true;
1236 }
1237 
1238 static bool api_eventlog_OpenBackupEventLogA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1239 {
1240         const struct ndr_interface_call *call;
1241         struct ndr_pull *pull;
1242         struct ndr_push *push;
1243         enum ndr_err_code ndr_err;
1244         DATA_BLOB blob;
1245         struct eventlog_OpenBackupEventLogA *r;
1246 
1247         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_OPENBACKUPEVENTLOGA];
1248 
1249         r = talloc(talloc_tos(), struct eventlog_OpenBackupEventLogA);
1250         if (r == NULL) {
1251                 return false;
1252         }
1253 
1254         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1255                 talloc_free(r);
1256                 return false;
1257         }
1258 
1259         pull = ndr_pull_init_blob(&blob, r, NULL);
1260         if (pull == NULL) {
1261                 talloc_free(r);
1262                 return false;
1263         }
1264 
1265         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1266         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1267         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1268                 talloc_free(r);
1269                 return false;
1270         }
1271 
1272         if (DEBUGLEVEL >= 10) {
1273                 NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogA, r);
1274         }
1275 
1276         r->out.result = _eventlog_OpenBackupEventLogA(p, r);
1277 
1278         if (p->rng_fault_state) {
1279                 talloc_free(r);
1280                 /* Return true here, srv_pipe_hnd.c will take care */
1281                 return true;
1282         }
1283 
1284         if (DEBUGLEVEL >= 10) {
1285                 NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogA, r);
1286         }
1287 
1288         push = ndr_push_init_ctx(r, NULL);
1289         if (push == NULL) {
1290                 talloc_free(r);
1291                 return false;
1292         }
1293 
1294         ndr_err = call->ndr_push(push, NDR_OUT, r);
1295         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1296                 talloc_free(r);
1297                 return false;
1298         }
1299 
1300         blob = ndr_push_blob(push);
1301         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1302                 talloc_free(r);
1303                 return false;
1304         }
1305 
1306         talloc_free(r);
1307 
1308         return true;
1309 }
1310 
1311 static bool api_eventlog_ReadEventLogA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1312 {
1313         const struct ndr_interface_call *call;
1314         struct ndr_pull *pull;
1315         struct ndr_push *push;
1316         enum ndr_err_code ndr_err;
1317         DATA_BLOB blob;
1318         struct eventlog_ReadEventLogA *r;
1319 
1320         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_READEVENTLOGA];
1321 
1322         r = talloc(talloc_tos(), struct eventlog_ReadEventLogA);
1323         if (r == NULL) {
1324                 return false;
1325         }
1326 
1327         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1328                 talloc_free(r);
1329                 return false;
1330         }
1331 
1332         pull = ndr_pull_init_blob(&blob, r, NULL);
1333         if (pull == NULL) {
1334                 talloc_free(r);
1335                 return false;
1336         }
1337 
1338         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1339         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1340         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1341                 talloc_free(r);
1342                 return false;
1343         }
1344 
1345         if (DEBUGLEVEL >= 10) {
1346                 NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogA, r);
1347         }
1348 
1349         r->out.result = _eventlog_ReadEventLogA(p, r);
1350 
1351         if (p->rng_fault_state) {
1352                 talloc_free(r);
1353                 /* Return true here, srv_pipe_hnd.c will take care */
1354                 return true;
1355         }
1356 
1357         if (DEBUGLEVEL >= 10) {
1358                 NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogA, r);
1359         }
1360 
1361         push = ndr_push_init_ctx(r, NULL);
1362         if (push == NULL) {
1363                 talloc_free(r);
1364                 return false;
1365         }
1366 
1367         ndr_err = call->ndr_push(push, NDR_OUT, r);
1368         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1369                 talloc_free(r);
1370                 return false;
1371         }
1372 
1373         blob = ndr_push_blob(push);
1374         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1375                 talloc_free(r);
1376                 return false;
1377         }
1378 
1379         talloc_free(r);
1380 
1381         return true;
1382 }
1383 
1384 static bool api_eventlog_ReportEventA(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1385 {
1386         const struct ndr_interface_call *call;
1387         struct ndr_pull *pull;
1388         struct ndr_push *push;
1389         enum ndr_err_code ndr_err;
1390         DATA_BLOB blob;
1391         struct eventlog_ReportEventA *r;
1392 
1393         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTA];
1394 
1395         r = talloc(talloc_tos(), struct eventlog_ReportEventA);
1396         if (r == NULL) {
1397                 return false;
1398         }
1399 
1400         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1401                 talloc_free(r);
1402                 return false;
1403         }
1404 
1405         pull = ndr_pull_init_blob(&blob, r, NULL);
1406         if (pull == NULL) {
1407                 talloc_free(r);
1408                 return false;
1409         }
1410 
1411         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1412         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1413         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1414                 talloc_free(r);
1415                 return false;
1416         }
1417 
1418         if (DEBUGLEVEL >= 10) {
1419                 NDR_PRINT_IN_DEBUG(eventlog_ReportEventA, r);
1420         }
1421 
1422         r->out.result = _eventlog_ReportEventA(p, r);
1423 
1424         if (p->rng_fault_state) {
1425                 talloc_free(r);
1426                 /* Return true here, srv_pipe_hnd.c will take care */
1427                 return true;
1428         }
1429 
1430         if (DEBUGLEVEL >= 10) {
1431                 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventA, r);
1432         }
1433 
1434         push = ndr_push_init_ctx(r, NULL);
1435         if (push == NULL) {
1436                 talloc_free(r);
1437                 return false;
1438         }
1439 
1440         ndr_err = call->ndr_push(push, NDR_OUT, r);
1441         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1442                 talloc_free(r);
1443                 return false;
1444         }
1445 
1446         blob = ndr_push_blob(push);
1447         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1448                 talloc_free(r);
1449                 return false;
1450         }
1451 
1452         talloc_free(r);
1453 
1454         return true;
1455 }
1456 
1457 static bool api_eventlog_RegisterClusterSvc(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1458 {
1459         const struct ndr_interface_call *call;
1460         struct ndr_pull *pull;
1461         struct ndr_push *push;
1462         enum ndr_err_code ndr_err;
1463         DATA_BLOB blob;
1464         struct eventlog_RegisterClusterSvc *r;
1465 
1466         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REGISTERCLUSTERSVC];
1467 
1468         r = talloc(talloc_tos(), struct eventlog_RegisterClusterSvc);
1469         if (r == NULL) {
1470                 return false;
1471         }
1472 
1473         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1474                 talloc_free(r);
1475                 return false;
1476         }
1477 
1478         pull = ndr_pull_init_blob(&blob, r, NULL);
1479         if (pull == NULL) {
1480                 talloc_free(r);
1481                 return false;
1482         }
1483 
1484         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1485         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1486         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1487                 talloc_free(r);
1488                 return false;
1489         }
1490 
1491         if (DEBUGLEVEL >= 10) {
1492                 NDR_PRINT_IN_DEBUG(eventlog_RegisterClusterSvc, r);
1493         }
1494 
1495         r->out.result = _eventlog_RegisterClusterSvc(p, r);
1496 
1497         if (p->rng_fault_state) {
1498                 talloc_free(r);
1499                 /* Return true here, srv_pipe_hnd.c will take care */
1500                 return true;
1501         }
1502 
1503         if (DEBUGLEVEL >= 10) {
1504                 NDR_PRINT_OUT_DEBUG(eventlog_RegisterClusterSvc, r);
1505         }
1506 
1507         push = ndr_push_init_ctx(r, NULL);
1508         if (push == NULL) {
1509                 talloc_free(r);
1510                 return false;
1511         }
1512 
1513         ndr_err = call->ndr_push(push, NDR_OUT, r);
1514         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1515                 talloc_free(r);
1516                 return false;
1517         }
1518 
1519         blob = ndr_push_blob(push);
1520         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1521                 talloc_free(r);
1522                 return false;
1523         }
1524 
1525         talloc_free(r);
1526 
1527         return true;
1528 }
1529 
1530 static bool api_eventlog_DeregisterClusterSvc(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1531 {
1532         const struct ndr_interface_call *call;
1533         struct ndr_pull *pull;
1534         struct ndr_push *push;
1535         enum ndr_err_code ndr_err;
1536         DATA_BLOB blob;
1537         struct eventlog_DeregisterClusterSvc *r;
1538 
1539         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_DEREGISTERCLUSTERSVC];
1540 
1541         r = talloc(talloc_tos(), struct eventlog_DeregisterClusterSvc);
1542         if (r == NULL) {
1543                 return false;
1544         }
1545 
1546         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1547                 talloc_free(r);
1548                 return false;
1549         }
1550 
1551         pull = ndr_pull_init_blob(&blob, r, NULL);
1552         if (pull == NULL) {
1553                 talloc_free(r);
1554                 return false;
1555         }
1556 
1557         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1558         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1559         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1560                 talloc_free(r);
1561                 return false;
1562         }
1563 
1564         if (DEBUGLEVEL >= 10) {
1565                 NDR_PRINT_IN_DEBUG(eventlog_DeregisterClusterSvc, r);
1566         }
1567 
1568         r->out.result = _eventlog_DeregisterClusterSvc(p, r);
1569 
1570         if (p->rng_fault_state) {
1571                 talloc_free(r);
1572                 /* Return true here, srv_pipe_hnd.c will take care */
1573                 return true;
1574         }
1575 
1576         if (DEBUGLEVEL >= 10) {
1577                 NDR_PRINT_OUT_DEBUG(eventlog_DeregisterClusterSvc, r);
1578         }
1579 
1580         push = ndr_push_init_ctx(r, NULL);
1581         if (push == NULL) {
1582                 talloc_free(r);
1583                 return false;
1584         }
1585 
1586         ndr_err = call->ndr_push(push, NDR_OUT, r);
1587         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1588                 talloc_free(r);
1589                 return false;
1590         }
1591 
1592         blob = ndr_push_blob(push);
1593         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1594                 talloc_free(r);
1595                 return false;
1596         }
1597 
1598         talloc_free(r);
1599 
1600         return true;
1601 }
1602 
1603 static bool api_eventlog_WriteClusterEvents(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1604 {
1605         const struct ndr_interface_call *call;
1606         struct ndr_pull *pull;
1607         struct ndr_push *push;
1608         enum ndr_err_code ndr_err;
1609         DATA_BLOB blob;
1610         struct eventlog_WriteClusterEvents *r;
1611 
1612         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_WRITECLUSTEREVENTS];
1613 
1614         r = talloc(talloc_tos(), struct eventlog_WriteClusterEvents);
1615         if (r == NULL) {
1616                 return false;
1617         }
1618 
1619         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1620                 talloc_free(r);
1621                 return false;
1622         }
1623 
1624         pull = ndr_pull_init_blob(&blob, r, NULL);
1625         if (pull == NULL) {
1626                 talloc_free(r);
1627                 return false;
1628         }
1629 
1630         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1631         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1632         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1633                 talloc_free(r);
1634                 return false;
1635         }
1636 
1637         if (DEBUGLEVEL >= 10) {
1638                 NDR_PRINT_IN_DEBUG(eventlog_WriteClusterEvents, r);
1639         }
1640 
1641         r->out.result = _eventlog_WriteClusterEvents(p, r);
1642 
1643         if (p->rng_fault_state) {
1644                 talloc_free(r);
1645                 /* Return true here, srv_pipe_hnd.c will take care */
1646                 return true;
1647         }
1648 
1649         if (DEBUGLEVEL >= 10) {
1650                 NDR_PRINT_OUT_DEBUG(eventlog_WriteClusterEvents, r);
1651         }
1652 
1653         push = ndr_push_init_ctx(r, NULL);
1654         if (push == NULL) {
1655                 talloc_free(r);
1656                 return false;
1657         }
1658 
1659         ndr_err = call->ndr_push(push, NDR_OUT, r);
1660         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1661                 talloc_free(r);
1662                 return false;
1663         }
1664 
1665         blob = ndr_push_blob(push);
1666         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1667                 talloc_free(r);
1668                 return false;
1669         }
1670 
1671         talloc_free(r);
1672 
1673         return true;
1674 }
1675 
1676 static bool api_eventlog_GetLogInformation(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1677 {
1678         const struct ndr_interface_call *call;
1679         struct ndr_pull *pull;
1680         struct ndr_push *push;
1681         enum ndr_err_code ndr_err;
1682         DATA_BLOB blob;
1683         struct eventlog_GetLogInformation *r;
1684 
1685         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_GETLOGINFORMATION];
1686 
1687         r = talloc(talloc_tos(), struct eventlog_GetLogInformation);
1688         if (r == NULL) {
1689                 return false;
1690         }
1691 
1692         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1693                 talloc_free(r);
1694                 return false;
1695         }
1696 
1697         pull = ndr_pull_init_blob(&blob, r, NULL);
1698         if (pull == NULL) {
1699                 talloc_free(r);
1700                 return false;
1701         }
1702 
1703         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1704         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1705         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1706                 talloc_free(r);
1707                 return false;
1708         }
1709 
1710         if (DEBUGLEVEL >= 10) {
1711                 NDR_PRINT_IN_DEBUG(eventlog_GetLogInformation, r);
1712         }
1713 
1714         ZERO_STRUCT(r->out);
1715         r->out.buffer = talloc_zero_array(r, uint8_t, r->in.buf_size);
1716         if (r->out.buffer == NULL) {
1717                 talloc_free(r);
1718                 return false;
1719         }
1720 
1721         r->out.bytes_needed = talloc_zero(r, uint32_t);
1722         if (r->out.bytes_needed == NULL) {
1723                 talloc_free(r);
1724                 return false;
1725         }
1726 
1727         r->out.result = _eventlog_GetLogInformation(p, r);
1728 
1729         if (p->rng_fault_state) {
1730                 talloc_free(r);
1731                 /* Return true here, srv_pipe_hnd.c will take care */
1732                 return true;
1733         }
1734 
1735         if (DEBUGLEVEL >= 10) {
1736                 NDR_PRINT_OUT_DEBUG(eventlog_GetLogInformation, r);
1737         }
1738 
1739         push = ndr_push_init_ctx(r, NULL);
1740         if (push == NULL) {
1741                 talloc_free(r);
1742                 return false;
1743         }
1744 
1745         ndr_err = call->ndr_push(push, NDR_OUT, r);
1746         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1747                 talloc_free(r);
1748                 return false;
1749         }
1750 
1751         blob = ndr_push_blob(push);
1752         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1753                 talloc_free(r);
1754                 return false;
1755         }
1756 
1757         talloc_free(r);
1758 
1759         return true;
1760 }
1761 
1762 static bool api_eventlog_FlushEventLog(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1763 {
1764         const struct ndr_interface_call *call;
1765         struct ndr_pull *pull;
1766         struct ndr_push *push;
1767         enum ndr_err_code ndr_err;
1768         DATA_BLOB blob;
1769         struct eventlog_FlushEventLog *r;
1770 
1771         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_FLUSHEVENTLOG];
1772 
1773         r = talloc(talloc_tos(), struct eventlog_FlushEventLog);
1774         if (r == NULL) {
1775                 return false;
1776         }
1777 
1778         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1779                 talloc_free(r);
1780                 return false;
1781         }
1782 
1783         pull = ndr_pull_init_blob(&blob, r, NULL);
1784         if (pull == NULL) {
1785                 talloc_free(r);
1786                 return false;
1787         }
1788 
1789         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1790         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1791         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1792                 talloc_free(r);
1793                 return false;
1794         }
1795 
1796         if (DEBUGLEVEL >= 10) {
1797                 NDR_PRINT_IN_DEBUG(eventlog_FlushEventLog, r);
1798         }
1799 
1800         r->out.result = _eventlog_FlushEventLog(p, r);
1801 
1802         if (p->rng_fault_state) {
1803                 talloc_free(r);
1804                 /* Return true here, srv_pipe_hnd.c will take care */
1805                 return true;
1806         }
1807 
1808         if (DEBUGLEVEL >= 10) {
1809                 NDR_PRINT_OUT_DEBUG(eventlog_FlushEventLog, r);
1810         }
1811 
1812         push = ndr_push_init_ctx(r, NULL);
1813         if (push == NULL) {
1814                 talloc_free(r);
1815                 return false;
1816         }
1817 
1818         ndr_err = call->ndr_push(push, NDR_OUT, r);
1819         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1820                 talloc_free(r);
1821                 return false;
1822         }
1823 
1824         blob = ndr_push_blob(push);
1825         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1826                 talloc_free(r);
1827                 return false;
1828         }
1829 
1830         talloc_free(r);
1831 
1832         return true;
1833 }
1834 
1835 static bool api_eventlog_ReportEventAndSourceW(pipes_struct *p)
     /* [<][>][^][v][top][bottom][index][help] */
1836 {
1837         const struct ndr_interface_call *call;
1838         struct ndr_pull *pull;
1839         struct ndr_push *push;
1840         enum ndr_err_code ndr_err;
1841         DATA_BLOB blob;
1842         struct eventlog_ReportEventAndSourceW *r;
1843 
1844         call = &ndr_table_eventlog.calls[NDR_EVENTLOG_REPORTEVENTANDSOURCEW];
1845 
1846         r = talloc(talloc_tos(), struct eventlog_ReportEventAndSourceW);
1847         if (r == NULL) {
1848                 return false;
1849         }
1850 
1851         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1852                 talloc_free(r);
1853                 return false;
1854         }
1855 
1856         pull = ndr_pull_init_blob(&blob, r, NULL);
1857         if (pull == NULL) {
1858                 talloc_free(r);
1859                 return false;
1860         }
1861 
1862         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1863         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1864         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1865                 talloc_free(r);
1866                 return false;
1867         }
1868 
1869         if (DEBUGLEVEL >= 10) {
1870                 NDR_PRINT_IN_DEBUG(eventlog_ReportEventAndSourceW, r);
1871         }
1872 
1873         ZERO_STRUCT(r->out);
1874         r->out.record_number = r->in.record_number;
1875         r->out.time_written = r->in.time_written;
1876         r->out.result = _eventlog_ReportEventAndSourceW(p, r);
1877 
1878         if (p->rng_fault_state) {
1879                 talloc_free(r);
1880                 /* Return true here, srv_pipe_hnd.c will take care */
1881                 return true;
1882         }
1883 
1884         if (DEBUGLEVEL >= 10) {
1885                 NDR_PRINT_OUT_DEBUG(eventlog_ReportEventAndSourceW, r);
1886         }
1887 
1888         push = ndr_push_init_ctx(r, NULL);
1889         if (push == NULL) {
1890                 talloc_free(r);
1891                 return false;
1892         }
1893 
1894         ndr_err = call->ndr_push(push, NDR_OUT, r);
1895         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1896                 talloc_free(r);
1897                 return false;
1898         }
1899 
1900         blob = ndr_push_blob(push);
1901         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1902                 talloc_free(r);
1903                 return false;
1904         }
1905 
1906         talloc_free(r);
1907 
1908         return true;
1909 }
1910 
1911 
1912 /* Tables */
1913 static struct api_struct api_eventlog_cmds[] = 
1914 {
1915         {"EVENTLOG_CLEAREVENTLOGW", NDR_EVENTLOG_CLEAREVENTLOGW, api_eventlog_ClearEventLogW},
1916         {"EVENTLOG_BACKUPEVENTLOGW", NDR_EVENTLOG_BACKUPEVENTLOGW, api_eventlog_BackupEventLogW},
1917         {"EVENTLOG_CLOSEEVENTLOG", NDR_EVENTLOG_CLOSEEVENTLOG, api_eventlog_CloseEventLog},
1918         {"EVENTLOG_DEREGISTEREVENTSOURCE", NDR_EVENTLOG_DEREGISTEREVENTSOURCE, api_eventlog_DeregisterEventSource},
1919         {"EVENTLOG_GETNUMRECORDS", NDR_EVENTLOG_GETNUMRECORDS, api_eventlog_GetNumRecords},
1920         {"EVENTLOG_GETOLDESTRECORD", NDR_EVENTLOG_GETOLDESTRECORD, api_eventlog_GetOldestRecord},
1921         {"EVENTLOG_CHANGENOTIFY", NDR_EVENTLOG_CHANGENOTIFY, api_eventlog_ChangeNotify},
1922         {"EVENTLOG_OPENEVENTLOGW", NDR_EVENTLOG_OPENEVENTLOGW, api_eventlog_OpenEventLogW},
1923         {"EVENTLOG_REGISTEREVENTSOURCEW", NDR_EVENTLOG_REGISTEREVENTSOURCEW, api_eventlog_RegisterEventSourceW},
1924         {"EVENTLOG_OPENBACKUPEVENTLOGW", NDR_EVENTLOG_OPENBACKUPEVENTLOGW, api_eventlog_OpenBackupEventLogW},
1925         {"EVENTLOG_READEVENTLOGW", NDR_EVENTLOG_READEVENTLOGW, api_eventlog_ReadEventLogW},
1926         {"EVENTLOG_REPORTEVENTW", NDR_EVENTLOG_REPORTEVENTW, api_eventlog_ReportEventW},
1927         {"EVENTLOG_CLEAREVENTLOGA", NDR_EVENTLOG_CLEAREVENTLOGA, api_eventlog_ClearEventLogA},
1928         {"EVENTLOG_BACKUPEVENTLOGA", NDR_EVENTLOG_BACKUPEVENTLOGA, api_eventlog_BackupEventLogA},
1929         {"EVENTLOG_OPENEVENTLOGA", NDR_EVENTLOG_OPENEVENTLOGA, api_eventlog_OpenEventLogA},
1930         {"EVENTLOG_REGISTEREVENTSOURCEA", NDR_EVENTLOG_REGISTEREVENTSOURCEA, api_eventlog_RegisterEventSourceA},
1931         {"EVENTLOG_OPENBACKUPEVENTLOGA", NDR_EVENTLOG_OPENBACKUPEVENTLOGA, api_eventlog_OpenBackupEventLogA},
1932         {"EVENTLOG_READEVENTLOGA", NDR_EVENTLOG_READEVENTLOGA, api_eventlog_ReadEventLogA},
1933         {"EVENTLOG_REPORTEVENTA", NDR_EVENTLOG_REPORTEVENTA, api_eventlog_ReportEventA},
1934         {"EVENTLOG_REGISTERCLUSTERSVC", NDR_EVENTLOG_REGISTERCLUSTERSVC, api_eventlog_RegisterClusterSvc},
1935         {"EVENTLOG_DEREGISTERCLUSTERSVC", NDR_EVENTLOG_DEREGISTERCLUSTERSVC, api_eventlog_DeregisterClusterSvc},
1936         {"EVENTLOG_WRITECLUSTEREVENTS", NDR_EVENTLOG_WRITECLUSTEREVENTS, api_eventlog_WriteClusterEvents},
1937         {"EVENTLOG_GETLOGINFORMATION", NDR_EVENTLOG_GETLOGINFORMATION, api_eventlog_GetLogInformation},
1938         {"EVENTLOG_FLUSHEVENTLOG", NDR_EVENTLOG_FLUSHEVENTLOG, api_eventlog_FlushEventLog},
1939         {"EVENTLOG_REPORTEVENTANDSOURCEW", NDR_EVENTLOG_REPORTEVENTANDSOURCEW, api_eventlog_ReportEventAndSourceW},
1940 };
1941 
1942 void eventlog_get_pipe_fns(struct api_struct **fns, int *n_fns)
     /* [<][>][^][v][top][bottom][index][help] */
1943 {
1944         *fns = api_eventlog_cmds;
1945         *n_fns = sizeof(api_eventlog_cmds) / sizeof(struct api_struct);
1946 }
1947 
1948 NTSTATUS rpc_eventlog_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
     /* [<][>][^][v][top][bottom][index][help] */
1949 {
1950         if (cli->pipes_struct == NULL) {
1951                 return NT_STATUS_INVALID_PARAMETER;
1952         }
1953 
1954         switch (opnum)
1955         {
1956                 case NDR_EVENTLOG_CLEAREVENTLOGW: {
1957                         struct eventlog_ClearEventLogW *r = (struct eventlog_ClearEventLogW *)_r;
1958                         r->out.result = _eventlog_ClearEventLogW(cli->pipes_struct, r);
1959                         return NT_STATUS_OK;
1960                 }
1961 
1962                 case NDR_EVENTLOG_BACKUPEVENTLOGW: {
1963                         struct eventlog_BackupEventLogW *r = (struct eventlog_BackupEventLogW *)_r;
1964                         r->out.result = _eventlog_BackupEventLogW(cli->pipes_struct, r);
1965                         return NT_STATUS_OK;
1966                 }
1967 
1968                 case NDR_EVENTLOG_CLOSEEVENTLOG: {
1969                         struct eventlog_CloseEventLog *r = (struct eventlog_CloseEventLog *)_r;
1970                         ZERO_STRUCT(r->out);
1971                         r->out.handle = r->in.handle;
1972                         r->out.result = _eventlog_CloseEventLog(cli->pipes_struct, r);
1973                         return NT_STATUS_OK;
1974                 }
1975 
1976                 case NDR_EVENTLOG_DEREGISTEREVENTSOURCE: {
1977                         struct eventlog_DeregisterEventSource *r = (struct eventlog_DeregisterEventSource *)_r;
1978                         ZERO_STRUCT(r->out);
1979                         r->out.handle = r->in.handle;
1980                         r->out.result = _eventlog_DeregisterEventSource(cli->pipes_struct, r);
1981                         return NT_STATUS_OK;
1982                 }
1983 
1984                 case NDR_EVENTLOG_GETNUMRECORDS: {
1985                         struct eventlog_GetNumRecords *r = (struct eventlog_GetNumRecords *)_r;
1986                         ZERO_STRUCT(r->out);
1987                         r->out.number = talloc_zero(mem_ctx, uint32_t);
1988                         if (r->out.number == NULL) {
1989                         return NT_STATUS_NO_MEMORY;
1990                         }
1991 
1992                         r->out.result = _eventlog_GetNumRecords(cli->pipes_struct, r);
1993                         return NT_STATUS_OK;
1994                 }
1995 
1996                 case NDR_EVENTLOG_GETOLDESTRECORD: {
1997                         struct eventlog_GetOldestRecord *r = (struct eventlog_GetOldestRecord *)_r;
1998                         ZERO_STRUCT(r->out);
1999                         r->out.oldest_entry = talloc_zero(mem_ctx, uint32_t);
2000                         if (r->out.oldest_entry == NULL) {
2001                         return NT_STATUS_NO_MEMORY;
2002                         }
2003 
2004                         r->out.result = _eventlog_GetOldestRecord(cli->pipes_struct, r);
2005                         return NT_STATUS_OK;
2006                 }
2007 
2008                 case NDR_EVENTLOG_CHANGENOTIFY: {
2009                         struct eventlog_ChangeNotify *r = (struct eventlog_ChangeNotify *)_r;
2010                         r->out.result = _eventlog_ChangeNotify(cli->pipes_struct, r);
2011                         return NT_STATUS_OK;
2012                 }
2013 
2014                 case NDR_EVENTLOG_OPENEVENTLOGW: {
2015                         struct eventlog_OpenEventLogW *r = (struct eventlog_OpenEventLogW *)_r;
2016                         ZERO_STRUCT(r->out);
2017                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2018                         if (r->out.handle == NULL) {
2019                         return NT_STATUS_NO_MEMORY;
2020                         }
2021 
2022                         r->out.result = _eventlog_OpenEventLogW(cli->pipes_struct, r);
2023                         return NT_STATUS_OK;
2024                 }
2025 
2026                 case NDR_EVENTLOG_REGISTEREVENTSOURCEW: {
2027                         struct eventlog_RegisterEventSourceW *r = (struct eventlog_RegisterEventSourceW *)_r;
2028                         ZERO_STRUCT(r->out);
2029                         r->out.log_handle = talloc_zero(mem_ctx, struct policy_handle);
2030                         if (r->out.log_handle == NULL) {
2031                         return NT_STATUS_NO_MEMORY;
2032                         }
2033 
2034                         r->out.result = _eventlog_RegisterEventSourceW(cli->pipes_struct, r);
2035                         return NT_STATUS_OK;
2036                 }
2037 
2038                 case NDR_EVENTLOG_OPENBACKUPEVENTLOGW: {
2039                         struct eventlog_OpenBackupEventLogW *r = (struct eventlog_OpenBackupEventLogW *)_r;
2040                         ZERO_STRUCT(r->out);
2041                         r->out.handle = talloc_zero(mem_ctx, struct policy_handle);
2042                         if (r->out.handle == NULL) {
2043                         return NT_STATUS_NO_MEMORY;
2044                         }
2045 
2046                         r->out.result = _eventlog_OpenBackupEventLogW(cli->pipes_struct, r);
2047                         return NT_STATUS_OK;
2048                 }
2049 
2050                 case NDR_EVENTLOG_READEVENTLOGW: {
2051                         struct eventlog_ReadEventLogW *r = (struct eventlog_ReadEventLogW *)_r;
2052                         ZERO_STRUCT(r->out);
2053                         r->out.data = talloc_zero_array(mem_ctx, uint8_t, r->in.number_of_bytes);
2054                         if (r->out.data == NULL) {
2055                         return NT_STATUS_NO_MEMORY;
2056                         }
2057 
2058                         r->out.sent_size = talloc_zero(mem_ctx, uint32_t);
2059                         if (r->out.sent_size == NULL) {
2060                         return NT_STATUS_NO_MEMORY;
2061                         }
2062 
2063                         r->out.real_size = talloc_zero(mem_ctx, uint32_t);
2064                         if (r->out.real_size == NULL) {
2065                         return NT_STATUS_NO_MEMORY;
2066                         }
2067 
2068                         r->out.result = _eventlog_ReadEventLogW(cli->pipes_struct, r);
2069                         return NT_STATUS_OK;
2070                 }
2071 
2072                 case NDR_EVENTLOG_REPORTEVENTW: {
2073                         struct eventlog_ReportEventW *r = (struct eventlog_ReportEventW *)_r;
2074                         ZERO_STRUCT(r->out);
2075                         r->out.record_number = r->in.record_number;
2076                         r->out.time_written = r->in.time_written;
2077                         r->out.result = _eventlog_ReportEventW(cli->pipes_struct, r);
2078                         return NT_STATUS_OK;
2079                 }
2080 
2081                 case NDR_EVENTLOG_CLEAREVENTLOGA: {
2082                         struct eventlog_ClearEventLogA *r = (struct eventlog_ClearEventLogA *)_r;
2083                         r->out.result = _eventlog_ClearEventLogA(cli->pipes_struct, r);
2084                         return NT_STATUS_OK;
2085                 }
2086 
2087                 case NDR_EVENTLOG_BACKUPEVENTLOGA: {
2088                         struct eventlog_BackupEventLogA *r = (struct eventlog_BackupEventLogA *)_r;
2089                         r->out.result = _eventlog_BackupEventLogA(cli->pipes_struct, r);
2090                         return NT_STATUS_OK;
2091                 }
2092 
2093                 case NDR_EVENTLOG_OPENEVENTLOGA: {
2094                         struct eventlog_OpenEventLogA *r = (struct eventlog_OpenEventLogA *)_r;
2095                         r->out.result = _eventlog_OpenEventLogA(cli->pipes_struct, r);
2096                         return NT_STATUS_OK;
2097                 }
2098 
2099                 case NDR_EVENTLOG_REGISTEREVENTSOURCEA: {
2100                         struct eventlog_RegisterEventSourceA *r = (struct eventlog_RegisterEventSourceA *)_r;
2101                         r->out.result = _eventlog_RegisterEventSourceA(cli->pipes_struct, r);
2102                         return NT_STATUS_OK;
2103                 }
2104 
2105                 case NDR_EVENTLOG_OPENBACKUPEVENTLOGA: {
2106                         struct eventlog_OpenBackupEventLogA *r = (struct eventlog_OpenBackupEventLogA *)_r;
2107                         r->out.result = _eventlog_OpenBackupEventLogA(cli->pipes_struct, r);
2108                         return NT_STATUS_OK;
2109                 }
2110 
2111                 case NDR_EVENTLOG_READEVENTLOGA: {
2112                         struct eventlog_ReadEventLogA *r = (struct eventlog_ReadEventLogA *)_r;
2113                         r->out.result = _eventlog_ReadEventLogA(cli->pipes_struct, r);
2114                         return NT_STATUS_OK;
2115                 }
2116 
2117                 case NDR_EVENTLOG_REPORTEVENTA: {
2118                         struct eventlog_ReportEventA *r = (struct eventlog_ReportEventA *)_r;
2119                         r->out.result = _eventlog_ReportEventA(cli->pipes_struct, r);
2120                         return NT_STATUS_OK;
2121                 }
2122 
2123                 case NDR_EVENTLOG_REGISTERCLUSTERSVC: {
2124                         struct eventlog_RegisterClusterSvc *r = (struct eventlog_RegisterClusterSvc *)_r;
2125                         r->out.result = _eventlog_RegisterClusterSvc(cli->pipes_struct, r);
2126                         return NT_STATUS_OK;
2127                 }
2128 
2129                 case NDR_EVENTLOG_DEREGISTERCLUSTERSVC: {
2130                         struct eventlog_DeregisterClusterSvc *r = (struct eventlog_DeregisterClusterSvc *)_r;
2131                         r->out.result = _eventlog_DeregisterClusterSvc(cli->pipes_struct, r);
2132                         return NT_STATUS_OK;
2133                 }
2134 
2135                 case NDR_EVENTLOG_WRITECLUSTEREVENTS: {
2136                         struct eventlog_WriteClusterEvents *r = (struct eventlog_WriteClusterEvents *)_r;
2137                         r->out.result = _eventlog_WriteClusterEvents(cli->pipes_struct, r);
2138                         return NT_STATUS_OK;
2139                 }
2140 
2141                 case NDR_EVENTLOG_GETLOGINFORMATION: {
2142                         struct eventlog_GetLogInformation *r = (struct eventlog_GetLogInformation *)_r;
2143                         ZERO_STRUCT(r->out);
2144                         r->out.buffer = talloc_zero_array(mem_ctx, uint8_t, r->in.buf_size);
2145                         if (r->out.buffer == NULL) {
2146                         return NT_STATUS_NO_MEMORY;
2147                         }
2148 
2149                         r->out.bytes_needed = talloc_zero(mem_ctx, uint32_t);
2150                         if (r->out.bytes_needed == NULL) {
2151                         return NT_STATUS_NO_MEMORY;
2152                         }
2153 
2154                         r->out.result = _eventlog_GetLogInformation(cli->pipes_struct, r);
2155                         return NT_STATUS_OK;
2156                 }
2157 
2158                 case NDR_EVENTLOG_FLUSHEVENTLOG: {
2159                         struct eventlog_FlushEventLog *r = (struct eventlog_FlushEventLog *)_r;
2160                         r->out.result = _eventlog_FlushEventLog(cli->pipes_struct, r);
2161                         return NT_STATUS_OK;
2162                 }
2163 
2164                 case NDR_EVENTLOG_REPORTEVENTANDSOURCEW: {
2165                         struct eventlog_ReportEventAndSourceW *r = (struct eventlog_ReportEventAndSourceW *)_r;
2166                         ZERO_STRUCT(r->out);
2167                         r->out.record_number = r->in.record_number;
2168                         r->out.time_written = r->in.time_written;
2169                         r->out.result = _eventlog_ReportEventAndSourceW(cli->pipes_struct, r);
2170                         return NT_STATUS_OK;
2171                 }
2172 
2173                 default:
2174                         return NT_STATUS_NOT_IMPLEMENTED;
2175         }
2176 }
2177 
2178 NTSTATUS rpc_eventlog_init(void)
     /* [<][>][^][v][top][bottom][index][help] */
2179 {
2180         return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "eventlog", "eventlog", &ndr_table_eventlog, api_eventlog_cmds, sizeof(api_eventlog_cmds) / sizeof(struct api_struct));
2181 }

/* [<][>][^][v][top][bottom][index][help] */