Ignore:
Timestamp:
Nov 14, 2012, 12:59:34 PM (12 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to 3.6.0

File:
1 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified vendor/current/source4/torture/rpc/eventlog.c

    r414 r740  
    2222
    2323#include "includes.h"
    24 #include "torture/torture.h"
    2524#include "librpc/gen_ndr/ndr_eventlog.h"
    2625#include "librpc/gen_ndr/ndr_eventlog_c.h"
    27 #include "librpc/gen_ndr/ndr_lsa.h"
    28 #include "torture/rpc/rpc.h"
     26#include "torture/rpc/torture_rpc.h"
    2927#include "param/param.h"
    3028
    … …  
    3937
    4038static bool get_policy_handle(struct torture_context *tctx,
    41                               struct dcerpc_pipe *p,
     39                              struct dcerpc_binding_handle *b,
    4240                              struct policy_handle *handle)
    4341{
    … …  
    5957
    6058        torture_assert_ntstatus_ok(tctx,
    61                         dcerpc_eventlog_OpenEventLogW(p, tctx, &r),
     59                        dcerpc_eventlog_OpenEventLogW_r(b, tctx, &r),
    6260                        "OpenEventLog failed");
    6361
    … …  
    7573        struct policy_handle handle;
    7674        uint32_t number = 0;
    77 
    78         if (!get_policy_handle(tctx, p, &handle))
     75        struct dcerpc_binding_handle *b = p->binding_handle;
     76
     77        if (!get_policy_handle(tctx, b, &handle))
    7978                return false;
    8079
    … …  
    8483
    8584        torture_assert_ntstatus_ok(tctx,
    86                         dcerpc_eventlog_GetNumRecords(p, tctx, &r),
     85                        dcerpc_eventlog_GetNumRecords_r(b, tctx, &r),
    8786                        "GetNumRecords failed");
    88 
     87        torture_assert_ntstatus_ok(tctx, r.out.result,
     88                        "GetNumRecords failed");
    8989        torture_comment(tctx, "%d records\n", *r.out.number);
    9090
    … …  
    9292
    9393        torture_assert_ntstatus_ok(tctx,
    94                         dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
     94                        dcerpc_eventlog_CloseEventLog_r(b, tctx, &cr),
     95                        "CloseEventLog failed");
     96        torture_assert_ntstatus_ok(tctx, cr.out.result,
    9597                        "CloseEventLog failed");
    9698        return true;
    … …  
    104106        struct eventlog_CloseEventLog cr;
    105107        struct policy_handle handle;
     108        struct dcerpc_binding_handle *b = p->binding_handle;
    106109
    107110        uint32_t sent_size = 0;
    108111        uint32_t real_size = 0;
    109112
    110         if (!get_policy_handle(tctx, p, &handle))
     113        if (!get_policy_handle(tctx, b, &handle))
    111114                return false;
    112115
    … …  
    119122        r.out.real_size = &real_size;
    120123
    121         status = dcerpc_eventlog_ReadEventLogW(p, tctx, &r);
     124        torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_ReadEventLogW_r(b, tctx, &r),
     125                "ReadEventLog failed");
    122126
    123127        torture_assert_ntstatus_equal(tctx, r.out.result, NT_STATUS_INVALID_PARAMETER,
    … …  
    139143                r.out.real_size = &real_size;
    140144
    141                 status = dcerpc_eventlog_ReadEventLogW(p, tctx, &r);
     145                torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_ReadEventLogW_r(b, tctx, &r),
     146                        "ReadEventLogW failed");
    142147
    143148                if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_END_OF_FILE)) {
    … …  
    154159                r.out.data = talloc_array(tctx, uint8_t, r.in.number_of_bytes);
    155160
    156                 status = dcerpc_eventlog_ReadEventLogW(p, tctx, &r);
    157 
    158                 torture_assert_ntstatus_ok(tctx, status, "ReadEventLog failed");
     161                torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_ReadEventLogW_r(b, tctx, &r),
     162                        "ReadEventLogW failed");
     163
     164                torture_assert_ntstatus_ok(tctx, r.out.result, "ReadEventLog failed");
    159165
    160166                /* Decode a user-marshalled record */
    … …  
    166172                        dump_data(0, blob.data, blob.length);
    167173
    168                         ndr_err = ndr_pull_struct_blob_all(&blob, tctx,
    169                                 lp_iconv_convenience(tctx->lp_ctx), &rec,
     174                        ndr_err = ndr_pull_struct_blob_all(&blob, tctx, &rec,
    170175                                (ndr_pull_flags_fn_t)ndr_pull_EVENTLOGRECORD);
    171176                        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
    … …  
    186191                }
    187192
    188                 torture_assert_ntstatus_ok(tctx, status,
     193                torture_assert_ntstatus_ok(tctx, r.out.result,
    189194                                "ReadEventLog failed parsing event log record");
    190195
    … …  
    195200
    196201        torture_assert_ntstatus_ok(tctx,
    197                         dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
     202                        dcerpc_eventlog_CloseEventLog_r(b, tctx, &cr),
     203                        "CloseEventLog failed");
     204        torture_assert_ntstatus_ok(tctx, cr.out.result,
    198205                        "CloseEventLog failed");
    199206
    … …  
    207214        struct eventlog_CloseEventLog cr;
    208215        struct policy_handle handle;
     216        struct dcerpc_binding_handle *b = p->binding_handle;
    209217
    210218        uint32_t record_number = 0;
    … …  
    212220        struct lsa_String servername, *strings;
    213221
    214         if (!get_policy_handle(tctx, p, &handle))
     222        if (!get_policy_handle(tctx, b, &handle))
    215223                return false;
    216224
    … …  
    238246
    239247        torture_assert_ntstatus_ok(tctx,
    240                         dcerpc_eventlog_ReportEventW(p, tctx, &r),
     248                        dcerpc_eventlog_ReportEventW_r(b, tctx, &r),
    241249                        "ReportEventW failed");
    242250
    … …  
    246254
    247255        torture_assert_ntstatus_ok(tctx,
    248                         dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
    249                         "CloseEventLog failed");
     256                        dcerpc_eventlog_CloseEventLog_r(b, tctx, &cr),
     257                        "CloseEventLog failed");
     258        torture_assert_ntstatus_ok(tctx, cr.out.result,
     259                        "CloseEventLog failed");
     260
    250261        return true;
    251262}
    … …  
    257268        struct eventlog_CloseEventLog cr;
    258269        struct policy_handle handle;
    259 
    260         if (!get_policy_handle(tctx, p, &handle))
     270        struct dcerpc_binding_handle *b = p->binding_handle;
     271
     272        if (!get_policy_handle(tctx, b, &handle))
    261273                return false;
    262274
    … …  
    264276
    265277        /* Huh?  Does this RPC always return access denied? */
     278        torture_assert_ntstatus_ok(tctx,
     279                        dcerpc_eventlog_FlushEventLog_r(b, tctx, &r),
     280                        "FlushEventLog failed");
     281
    266282        torture_assert_ntstatus_equal(tctx,
    267                         dcerpc_eventlog_FlushEventLog(p, tctx, &r),
     283                        r.out.result,
    268284                        NT_STATUS_ACCESS_DENIED,
    269285                        "FlushEventLog failed");
    … …  
    272288
    273289        torture_assert_ntstatus_ok(tctx,
    274                         dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
     290                        dcerpc_eventlog_CloseEventLog_r(b, tctx, &cr),
     291                        "CloseEventLog failed");
     292        torture_assert_ntstatus_ok(tctx, cr.out.result,
    275293                        "CloseEventLog failed");
    276294
    … …  
    284302        struct eventlog_CloseEventLog cr;
    285303        struct policy_handle handle;
    286 
    287         if (!get_policy_handle(tctx, p, &handle))
     304        struct dcerpc_binding_handle *b = p->binding_handle;
     305
     306        if (!get_policy_handle(tctx, b, &handle))
    288307                return false;
    289308
    … …  
    292311
    293312        torture_assert_ntstatus_ok(tctx,
    294                         dcerpc_eventlog_ClearEventLogW(p, tctx, &r),
     313                        dcerpc_eventlog_ClearEventLogW_r(b, tctx, &r),
    295314                        "ClearEventLog failed");
    296 
    297         cr.in.handle = cr.out.handle = &handle;
    298 
    299         torture_assert_ntstatus_ok(tctx,
    300                         dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
     315        torture_assert_ntstatus_ok(tctx, r.out.result,
     316                        "ClearEventLog failed");
     317
     318        cr.in.handle = cr.out.handle = &handle;
     319
     320        torture_assert_ntstatus_ok(tctx,
     321                        dcerpc_eventlog_CloseEventLog_r(b, tctx, &cr),
     322                        "CloseEventLog failed");
     323        torture_assert_ntstatus_ok(tctx, cr.out.result,
    301324                        "CloseEventLog failed");
    302325
    … …  
    307330                                   struct dcerpc_pipe *p)
    308331{
    309         NTSTATUS status;
    310332        struct eventlog_GetLogInformation r;
    311333        struct eventlog_CloseEventLog cr;
    312334        struct policy_handle handle;
    313335        uint32_t bytes_needed = 0;
    314 
    315         if (!get_policy_handle(tctx, p, &handle))
     336        struct dcerpc_binding_handle *b = p->binding_handle;
     337
     338        if (!get_policy_handle(tctx, b, &handle))
    316339                return false;
    317340
    … …  
    322345        r.out.bytes_needed = &bytes_needed;
    323346
    324         status = dcerpc_eventlog_GetLogInformation(p, tctx, &r);
    325 
    326         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_INVALID_LEVEL,
     347        torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_GetLogInformation_r(b, tctx, &r),
     348                                   "GetLogInformation failed");
     349
     350        torture_assert_ntstatus_equal(tctx, r.out.result, NT_STATUS_INVALID_LEVEL,
    327351                                      "GetLogInformation failed");
    328352
    329353        r.in.level = 0;
    330354
    331         status = dcerpc_eventlog_GetLogInformation(p, tctx, &r);
    332 
    333         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_BUFFER_TOO_SMALL,
     355        torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_GetLogInformation_r(b, tctx, &r),
     356                                   "GetLogInformation failed");
     357
     358        torture_assert_ntstatus_equal(tctx, r.out.result, NT_STATUS_BUFFER_TOO_SMALL,
    334359                                      "GetLogInformation failed");
    335360
    … …  
    337362        r.out.buffer = talloc_array(tctx, uint8_t, bytes_needed);
    338363
    339         status = dcerpc_eventlog_GetLogInformation(p, tctx, &r);
    340 
    341         torture_assert_ntstatus_ok(tctx, status, "GetLogInformation failed");
    342 
    343         cr.in.handle = cr.out.handle = &handle;
    344 
    345         torture_assert_ntstatus_ok(tctx,
    346                         dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
     364        torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_GetLogInformation_r(b, tctx, &r),
     365                                   "GetLogInformation failed");
     366
     367        torture_assert_ntstatus_ok(tctx, r.out.result, "GetLogInformation failed");
     368
     369        cr.in.handle = cr.out.handle = &handle;
     370
     371        torture_assert_ntstatus_ok(tctx,
     372                        dcerpc_eventlog_CloseEventLog_r(b, tctx, &cr),
     373                        "CloseEventLog failed");
     374        torture_assert_ntstatus_ok(tctx, cr.out.result,
    347375                        "CloseEventLog failed");
    348376
    … …  
    356384        struct policy_handle handle;
    357385        struct eventlog_CloseEventLog cr;
    358 
    359         if (!get_policy_handle(tctx, p, &handle))
    360                 return false;
    361 
    362         cr.in.handle = cr.out.handle = &handle;
    363 
    364         torture_assert_ntstatus_ok(tctx,
    365                         dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
     386        struct dcerpc_binding_handle *b = p->binding_handle;
     387
     388        if (!get_policy_handle(tctx, b, &handle))
     389                return false;
     390
     391        cr.in.handle = cr.out.handle = &handle;
     392
     393        torture_assert_ntstatus_ok(tctx,
     394                        dcerpc_eventlog_CloseEventLog_r(b, tctx, &cr),
     395                        "CloseEventLog failed");
     396        torture_assert_ntstatus_ok(tctx, cr.out.result,
    366397                        "CloseEventLog failed");
    367398
    … …  
    372403                           struct dcerpc_pipe *p)
    373404{
    374         NTSTATUS status;
    375405        struct policy_handle handle, backup_handle;
    376406        struct eventlog_BackupEventLogW r;
    377         struct eventlog_OpenBackupEventLogW b;
     407        struct eventlog_OpenBackupEventLogW br;
    378408        struct eventlog_CloseEventLog cr;
    379409        const char *tmp;
    380410        struct lsa_String backup_filename;
    381411        struct eventlog_OpenUnknown0 unknown0;
    382 
    383         if (!get_policy_handle(tctx, p, &handle))
     412        struct dcerpc_binding_handle *b = p->binding_handle;
     413
     414        if (torture_setting_bool(tctx, "samba3", false)) {
     415                torture_skip(tctx, "skipping BackupLog test against samba");
     416        }
     417
     418        if (!get_policy_handle(tctx, b, &handle))
    384419                return false;
    385420
    … …  
    390425        r.in.backup_filename = &backup_filename;
    391426
    392         status = dcerpc_eventlog_BackupEventLogW(p, tctx, &r);
    393         torture_assert_ntstatus_equal(tctx, status,
     427        torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_BackupEventLogW_r(b, tctx, &r),
     428                "BackupEventLogW failed");
     429        torture_assert_ntstatus_equal(tctx, r.out.result,
    394430                NT_STATUS_OBJECT_PATH_SYNTAX_BAD, "BackupEventLogW failed");
    395431
    … …  
    400436        r.in.backup_filename = &backup_filename;
    401437
    402         status = dcerpc_eventlog_BackupEventLogW(p, tctx, &r);
    403         torture_assert_ntstatus_ok(tctx, status, "BackupEventLogW failed");
    404 
    405         status = dcerpc_eventlog_BackupEventLogW(p, tctx, &r);
    406         torture_assert_ntstatus_equal(tctx, status,
     438        torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_BackupEventLogW_r(b, tctx, &r),
     439                "BackupEventLogW failed");
     440        torture_assert_ntstatus_ok(tctx, r.out.result, "BackupEventLogW failed");
     441
     442        torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_BackupEventLogW_r(b, tctx, &r),
     443                "BackupEventLogW failed");
     444        torture_assert_ntstatus_equal(tctx, r.out.result,
    407445                NT_STATUS_OBJECT_NAME_COLLISION, "BackupEventLogW failed");
    408446
    … …  
    410448
    411449        torture_assert_ntstatus_ok(tctx,
    412                         dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
     450                        dcerpc_eventlog_CloseEventLog_r(b, tctx, &cr),
     451                        "BackupLog failed");
     452        torture_assert_ntstatus_ok(tctx, cr.out.result,
    413453                        "BackupLog failed");
    414454
    … …  
    416456        unknown0.unknown1 = 0x0001;
    417457
    418         b.in.unknown0 = &unknown0;
    419         b.in.backup_logname = &backup_filename;
    420         b.in.major_version = 1;
    421         b.in.minor_version = 1;
    422         b.out.handle = &backup_handle;
    423 
    424         status = dcerpc_eventlog_OpenBackupEventLogW(p, tctx, &b);
    425 
    426         torture_assert_ntstatus_ok(tctx, status, "OpenBackupEventLogW failed");
     458        br.in.unknown0 = &unknown0;
     459        br.in.backup_logname = &backup_filename;
     460        br.in.major_version = 1;
     461        br.in.minor_version = 1;
     462        br.out.handle = &backup_handle;
     463
     464        torture_assert_ntstatus_ok(tctx, dcerpc_eventlog_OpenBackupEventLogW_r(b, tctx, &br),
     465                "OpenBackupEventLogW failed");
     466
     467        torture_assert_ntstatus_ok(tctx, br.out.result, "OpenBackupEventLogW failed");
    427468
    428469        cr.in.handle = cr.out.handle = &backup_handle;
    429470
    430471        torture_assert_ntstatus_ok(tctx,
    431                         dcerpc_eventlog_CloseEventLog(p, tctx, &cr),
     472                        dcerpc_eventlog_CloseEventLog_r(b, tctx, &cr),
     473                        "CloseEventLog failed");
     474        torture_assert_ntstatus_ok(tctx, cr.out.result,
    432475                        "CloseEventLog failed");
    433476
    … …  
    441484        struct torture_test *test;
    442485
    443         suite = torture_suite_create(mem_ctx, "EVENTLOG");
     486        suite = torture_suite_create(mem_ctx, "eventlog");
    444487        tcase = torture_suite_add_rpc_iface_tcase(suite, "eventlog",
    445488                                                  &ndr_table_eventlog);
Note: See TracChangeset for help on using the changeset viewer.