Ignore:
Timestamp:
Nov 27, 2012, 4:43:17 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: updated trunk to 3.6.0

Location:
trunk/server
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source3/rpcclient/cmd_eventlog.c

    r414 r745  
    2121#include "includes.h"
    2222#include "rpcclient.h"
    23 #include "../librpc/gen_ndr/cli_eventlog.h"
     23#include "../librpc/gen_ndr/ndr_eventlog.h"
     24#include "../librpc/gen_ndr/ndr_eventlog_c.h"
     25#include "rpc_client/init_lsa.h"
    2426
    2527static NTSTATUS get_eventlog_handle(struct rpc_pipe_client *cli,
    … …  
    2830                                    struct policy_handle *handle)
    2931{
    30         NTSTATUS status;
     32        NTSTATUS status, result;
    3133        struct eventlog_OpenUnknown0 unknown0;
    3234        struct lsa_String logname, servername;
     35        struct dcerpc_binding_handle *b = cli->binding_handle;
    3336
    3437        unknown0.unknown0 = 0x005c;
    … …  
    3841        init_lsa_String(&servername, NULL);
    3942
    40         status = rpccli_eventlog_OpenEventLogW(cli, mem_ctx,
     43        status = dcerpc_eventlog_OpenEventLogW(b, mem_ctx,
    4144                                               &unknown0,
    4245                                               &logname,
    … …  
    4447                                               0x00000001, /* major */
    4548                                               0x00000001, /* minor */
    46                                                handle);
    47         if (!NT_STATUS_IS_OK(status)) {
    48                 return status;
    49         }
    50 
    51         return NT_STATUS_OK;
     49                                               handle,
     50                                               &result);
     51        if (!NT_STATUS_IS_OK(status)) {
     52                return status;
     53        }
     54
     55        return result;
    5256}
    5357
    … …  
    5862{
    5963        NTSTATUS status = NT_STATUS_OK;
    60         struct policy_handle handle;
     64        NTSTATUS result = NT_STATUS_OK;
     65        struct policy_handle handle;
     66        struct dcerpc_binding_handle *b = cli->binding_handle;
    6167
    6268        uint32_t flags = EVENTLOG_BACKWARDS_READ |
    … …  
    98104                uint32_t pos = 0;
    99105
    100                 status = rpccli_eventlog_ReadEventLogW(cli, mem_ctx,
     106                status = dcerpc_eventlog_ReadEventLogW(b, mem_ctx,
    101107                                                       &handle,
    102108                                                       flags,
    … …  
    105111                                                       data,
    106112                                                       &sent_size,
    107                                                        &real_size);
    108                 if (NT_STATUS_EQUAL(status, NT_STATUS_BUFFER_TOO_SMALL) &&
     113                                                       &real_size,
     114                                                       &result);
     115                if (!NT_STATUS_IS_OK(status)) {
     116                        return status;
     117                }
     118                if (NT_STATUS_EQUAL(result, NT_STATUS_BUFFER_TOO_SMALL) &&
    109119                    real_size > 0 ) {
    110120                        number_of_bytes = real_size;
    … …  
    113123                                goto done;
    114124                        }
    115                         status = rpccli_eventlog_ReadEventLogW(cli, mem_ctx,
     125                        status = dcerpc_eventlog_ReadEventLogW(b, mem_ctx,
    116126                                                               &handle,
    117127                                                               flags,
    … …  
    120130                                                               data,
    121131                                                               &sent_size,
    122                                                                &real_size);
     132                                                               &real_size,
     133                                                               &result);
     134                        if (!NT_STATUS_IS_OK(status)) {
     135                                return status;
     136                        }
    123137                }
    124138
    125                 if (!NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE) &&
    126                     !NT_STATUS_IS_OK(status)) {
     139                if (!NT_STATUS_EQUAL(result, NT_STATUS_END_OF_FILE) &&
     140                    !NT_STATUS_IS_OK(result)) {
    127141                        goto done;
    128142                }
    … …  
    136150                        blob = data_blob_const(data + pos, size);
    137151                        /* dump_data(0, blob.data, blob.length); */
    138                         ndr_err = ndr_pull_struct_blob_all(&blob, mem_ctx, NULL, &r,
     152                        ndr_err = ndr_pull_struct_blob_all(&blob, mem_ctx, &r,
    139153                                           (ndr_pull_flags_fn_t)ndr_pull_EVENTLOGRECORD);
    140154                        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
    … …  
    156170                offset++;
    157171
    158         } while (NT_STATUS_IS_OK(status));
    159 
    160  done:
    161         rpccli_eventlog_CloseEventLog(cli, mem_ctx, &handle);
     172        } while (NT_STATUS_IS_OK(result));
     173
     174 done:
     175        dcerpc_eventlog_CloseEventLog(b, mem_ctx, &handle, &result);
    162176
    163177        return status;
    … …  
    169183                                        const char **argv)
    170184{
    171         NTSTATUS status;
     185        NTSTATUS status, result;
    172186        struct policy_handle handle;
    173187        uint32_t number = 0;
     188        struct dcerpc_binding_handle *b = cli->binding_handle;
    174189
    175190        if (argc != 2) {
    … …  
    183198        }
    184199
    185         status = rpccli_eventlog_GetNumRecords(cli, mem_ctx,
     200        status = dcerpc_eventlog_GetNumRecords(b, mem_ctx,
    186201                                               &handle,
    187                                                &number);
    188         if (!NT_STATUS_IS_OK(status)) {
     202                                               &number,
     203                                               &result);
     204        if (!NT_STATUS_IS_OK(status)) {
     205                goto done;
     206        }
     207        if (!NT_STATUS_IS_OK(result)) {
     208                status = result;
    189209                goto done;
    190210        }
    … …  
    193213
    194214 done:
    195         rpccli_eventlog_CloseEventLog(cli, mem_ctx, &handle);
     215        dcerpc_eventlog_CloseEventLog(b, mem_ctx, &handle, &result);
    196216
    197217        return status;
    … …  
    203223                                          const char **argv)
    204224{
    205         NTSTATUS status;
     225        NTSTATUS status, result;
    206226        struct policy_handle handle;
    207227        uint32_t oldest_entry = 0;
     228        struct dcerpc_binding_handle *b = cli->binding_handle;
    208229
    209230        if (argc != 2) {
    … …  
    217238        }
    218239
    219         status = rpccli_eventlog_GetOldestRecord(cli, mem_ctx,
     240        status = dcerpc_eventlog_GetOldestRecord(b, mem_ctx,
    220241                                                 &handle,
    221                                                  &oldest_entry);
    222         if (!NT_STATUS_IS_OK(status)) {
     242                                                 &oldest_entry,
     243                                                 &result);
     244        if (!NT_STATUS_IS_OK(status)) {
     245                goto done;
     246        }
     247        if (!NT_STATUS_IS_OK(result)) {
     248                status = result;
    223249                goto done;
    224250        }
    … …  
    227253
    228254 done:
    229         rpccli_eventlog_CloseEventLog(cli, mem_ctx, &handle);
     255        dcerpc_eventlog_CloseEventLog(b, mem_ctx, &handle, &result);
    230256
    231257        return status;
    … …  
    237263                                         const char **argv)
    238264{
    239         NTSTATUS status;
    240         struct policy_handle handle;
     265        NTSTATUS status, result;
     266        struct policy_handle handle;
     267        struct dcerpc_binding_handle *b = cli->binding_handle;
    241268
    242269        uint16_t num_of_strings = 1;
    … …  
    266293        init_lsa_String(&servername, NULL);
    267294
    268         status = rpccli_eventlog_ReportEventW(cli, mem_ctx,
     295        status = dcerpc_eventlog_ReportEventW(b, mem_ctx,
    269296                                              &handle,
    270297                                              time(NULL),
    … …  
    280307                                              0, /* flags */
    281308                                              &record_number,
    282                                               &time_written);
    283 
    284         if (!NT_STATUS_IS_OK(status)) {
     309                                              &time_written,
     310                                              &result);
     311
     312        if (!NT_STATUS_IS_OK(status)) {
     313                goto done;
     314        }
     315        if (!NT_STATUS_IS_OK(result)) {
     316                status = result;
    285317                goto done;
    286318        }
    … …  
    290322
    291323 done:
    292         rpccli_eventlog_CloseEventLog(cli, mem_ctx, &handle);
     324        dcerpc_eventlog_CloseEventLog(b, mem_ctx, &handle, &result);
    293325
    294326        return status;
    … …  
    300332                                               const char **argv)
    301333{
    302         NTSTATUS status;
    303         struct policy_handle handle;
     334        NTSTATUS status, result;
     335        struct policy_handle handle;
     336        struct dcerpc_binding_handle *b = cli->binding_handle;
    304337
    305338        uint16_t num_of_strings = 1;
    … …  
    330363        init_lsa_String(&sourcename, "rpcclient");
    331364
    332         status = rpccli_eventlog_ReportEventAndSourceW(cli, mem_ctx,
     365        status = dcerpc_eventlog_ReportEventAndSourceW(b, mem_ctx,
    333366                                                       &handle,
    334367                                                       time(NULL),
    … …  
    345378                                                       0, /* flags */
    346379                                                       &record_number,
    347                                                        &time_written);
    348         if (!NT_STATUS_IS_OK(status)) {
     380                                                       &time_written,
     381                                                       &result);
     382        if (!NT_STATUS_IS_OK(status)) {
     383                goto done;
     384        }
     385        if (!NT_STATUS_IS_OK(result)) {
     386                status = result;
    349387                goto done;
    350388        }
    … …  
    354392
    355393 done:
    356         rpccli_eventlog_CloseEventLog(cli, mem_ctx, &handle);
     394        dcerpc_eventlog_CloseEventLog(b, mem_ctx, &handle, &result);
    357395
    358396        return status;
    … …  
    364402                                              const char **argv)
    365403{
    366         NTSTATUS status;
     404        NTSTATUS status, result;
    367405        struct policy_handle log_handle;
    368406        struct lsa_String module_name, reg_module_name;
    369407        struct eventlog_OpenUnknown0 unknown0;
     408        struct dcerpc_binding_handle *b = cli->binding_handle;
    370409
    371410        unknown0.unknown0 = 0x005c;
    … …  
    380419        init_lsa_String(&reg_module_name, NULL);
    381420
    382         status = rpccli_eventlog_RegisterEventSourceW(cli, mem_ctx,
     421        status = dcerpc_eventlog_RegisterEventSourceW(b, mem_ctx,
    383422                                                      &unknown0,
    384423                                                      &module_name,
    … …  
    386425                                                      1, /* major_version */
    387426                                                      1, /* minor_version */
    388                                                       &log_handle);
    389         if (!NT_STATUS_IS_OK(status)) {
    390                 goto done;
    391         }
    392 
    393  done:
    394         rpccli_eventlog_DeregisterEventSource(cli, mem_ctx, &log_handle);
     427                                                      &log_handle,
     428                                                      &result);
     429        if (!NT_STATUS_IS_OK(status)) {
     430                goto done;
     431        }
     432        if (!NT_STATUS_IS_OK(result)) {
     433                status = result;
     434                goto done;
     435        }
     436
     437 done:
     438        dcerpc_eventlog_DeregisterEventSource(b, mem_ctx, &log_handle, &result);
    395439
    396440        return status;
    … …  
    402446                                       const char **argv)
    403447{
    404         NTSTATUS status;
     448        NTSTATUS status, result;
    405449        struct policy_handle handle;
    406450        struct lsa_String backup_filename;
    407451        const char *tmp;
     452        struct dcerpc_binding_handle *b = cli->binding_handle;
    408453
    409454        if (argc != 3) {
    … …  
    425470        init_lsa_String(&backup_filename, tmp);
    426471
    427         status = rpccli_eventlog_BackupEventLogW(cli, mem_ctx,
     472        status = dcerpc_eventlog_BackupEventLogW(b, mem_ctx,
    428473                                                 &handle,
    429                                                  &backup_filename);
    430 
    431  done:
    432         rpccli_eventlog_CloseEventLog(cli, mem_ctx, &handle);
     474                                                 &backup_filename,
     475                                                 &result);
     476        if (!NT_STATUS_IS_OK(status)) {
     477                goto done;
     478        }
     479        if (!NT_STATUS_IS_OK(result)) {
     480                status = result;
     481                goto done;
     482        }
     483
     484 done:
     485        dcerpc_eventlog_CloseEventLog(b, mem_ctx, &handle, &result);
    433486
    434487        return status;
    … …  
    440493                                     const char **argv)
    441494{
    442         NTSTATUS status;
     495        NTSTATUS status, result;
    443496        struct policy_handle handle;
    444497        uint8_t *buffer = NULL;
    445498        uint32_t buf_size = 0;
    446499        uint32_t bytes_needed = 0;
     500        struct dcerpc_binding_handle *b = cli->binding_handle;
    447501
    448502        if (argc != 2) {
    … …  
    456510        }
    457511
    458         status = rpccli_eventlog_GetLogInformation(cli, mem_ctx,
     512        status = dcerpc_eventlog_GetLogInformation(b, mem_ctx,
    459513                                                   &handle,
    460514                                                   0, /* level */
    461515                                                   buffer,
    462516                                                   buf_size,
    463                                                    &bytes_needed);
    464         if (!NT_STATUS_IS_OK(status) &&
    465             !NT_STATUS_EQUAL(status, NT_STATUS_BUFFER_TOO_SMALL)) {
     517                                                   &bytes_needed,
     518                                                   &result);
     519        if (!NT_STATUS_IS_OK(status)) {
     520                goto done;
     521        }
     522        if (!NT_STATUS_IS_OK(result) &&
     523            !NT_STATUS_EQUAL(result, NT_STATUS_BUFFER_TOO_SMALL)) {
    466524                goto done;
    467525        }
    … …  
    474532        }
    475533
    476         status = rpccli_eventlog_GetLogInformation(cli, mem_ctx,
     534        status = dcerpc_eventlog_GetLogInformation(b, mem_ctx,
    477535                                                   &handle,
    478536                                                   0, /* level */
    479537                                                   buffer,
    480538                                                   buf_size,
    481                                                    &bytes_needed);
    482         if (!NT_STATUS_IS_OK(status)) {
    483                 goto done;
    484         }
    485 
    486  done:
    487         rpccli_eventlog_CloseEventLog(cli, mem_ctx, &handle);
     539                                                   &bytes_needed,
     540                                                   &result);
     541        if (!NT_STATUS_IS_OK(status)) {
     542                goto done;
     543        }
     544        if (!NT_STATUS_IS_OK(result)) {
     545                status = result;
     546                goto done;
     547        }
     548
     549 done:
     550        dcerpc_eventlog_CloseEventLog(b, mem_ctx, &handle, &result);
    488551
    489552        return status;
Note: See TracChangeset for help on using the changeset viewer.