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/rpc_client/cli_spoolss.c

    r429 r745  
    2424
    2525#include "includes.h"
    26 #include "../librpc/gen_ndr/cli_spoolss.h"
     26#include "rpc_client/rpc_client.h"
     27#include "../librpc/gen_ndr/ndr_spoolss_c.h"
     28#include "rpc_client/cli_spoolss.h"
    2729
    2830/**********************************************************************
    … …  
    4143        union spoolss_UserLevel userlevel;
    4244        struct spoolss_UserLevel1 level1;
     45
    4346
    4447        ZERO_STRUCT(devmode_ctr);
    … …  
    5558        userlevel.level1 = &level1;
    5659
    57         status = rpccli_spoolss_OpenPrinterEx(cli, mem_ctx,
     60        status = , mem_ctx,
    5861                                              printername,
    5962                                              NULL,
    … …  
    6568                                              &werror);
    6669
     70
     71
     72
     73
    6774        if (!W_ERROR_IS_OK(werror)) {
    6875                return werror;
    69         }
    70 
    71         if (!NT_STATUS_IS_OK(status)) {
    72                 return ntstatus_to_werror(status);
    7376        }
    7477
    … …  
    9295        uint32_t needed;
    9396        DATA_BLOB buffer;
    94 
    95         if (offered > 0) {
    96                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    97                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    98         }
    99 
    100         status = rpccli_spoolss_GetPrinterDriver(cli, mem_ctx,
     97        struct dcerpc_binding_handle *b = cli->binding_handle;
     98
     99        if (offered > 0) {
     100                buffer = data_blob_talloc_zero(mem_ctx, offered);
     101                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     102        }
     103
     104        status = dcerpc_spoolss_GetPrinterDriver(b, mem_ctx,
    101105                                                 handle,
    102106                                                 architecture,
    … …  
    107111                                                 &needed,
    108112                                                 &werror);
     113
     114
     115
    109116        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    110117                offered = needed;
    … …  
    112119                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    113120
    114                 status = rpccli_spoolss_GetPrinterDriver(cli, mem_ctx,
     121                status = , mem_ctx,
    115122                                                         handle,
    116123                                                         architecture,
    … …  
    121128                                                         &needed,
    122129                                                         &werror);
     130
     131
     132
    123133        }
    124134
    … …  
    146156        uint32_t needed;
    147157        DATA_BLOB buffer;
    148 
    149         if (offered > 0) {
    150                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    151                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    152         }
    153 
    154         status = rpccli_spoolss_GetPrinterDriver2(cli, mem_ctx,
     158        struct dcerpc_binding_handle *b = cli->binding_handle;
     159
     160        if (offered > 0) {
     161                buffer = data_blob_talloc_zero(mem_ctx, offered);
     162                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     163        }
     164
     165        status = dcerpc_spoolss_GetPrinterDriver2(b, mem_ctx,
    155166                                                  handle,
    156167                                                  architecture,
    … …  
    165176                                                  server_minor_version,
    166177                                                  &werror);
     178
     179
     180
     181
    167182        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    168183                offered = needed;
    … …  
    170185                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    171186
    172                 status = rpccli_spoolss_GetPrinterDriver2(cli, mem_ctx,
     187                status = , mem_ctx,
    173188                                                          handle,
    174189                                                          architecture,
    … …  
    184199                                                          &werror);
    185200        }
     201
     202
     203
    186204
    187205        return werror;
    … …  
    203221        struct spoolss_UserLevel1 level1;
    204222        struct policy_handle handle;
     223
    205224
    206225        ZERO_STRUCT(devmode_ctr);
    … …  
    219238        userlevel_ctr.user_info.level1 = &level1;
    220239
    221         status = rpccli_spoolss_AddPrinterEx(cli, mem_ctx,
     240        status = , mem_ctx,
    222241                                             cli->srv_name_slash,
    223242                                             info_ctr,
    … …  
    227246                                             &handle,
    228247                                             &result);
     248
     249
     250
     251
    229252        return result;
    230253}
    … …  
    245268        DATA_BLOB buffer;
    246269        uint32_t needed;
    247 
    248         if (offered > 0) {
    249                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    250                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    251         }
    252 
    253         status = rpccli_spoolss_GetPrinter(cli, mem_ctx,
     270        struct dcerpc_binding_handle *b = cli->binding_handle;
     271
     272        if (offered > 0) {
     273                buffer = data_blob_talloc_zero(mem_ctx, offered);
     274                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     275        }
     276
     277        status = dcerpc_spoolss_GetPrinter(b, mem_ctx,
    254278                                           handle,
    255279                                           level,
    … …  
    259283                                           &needed,
    260284                                           &werror);
    261 
    262         if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    263 
    264                 offered = needed;
    265                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    266                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    267 
    268                 status = rpccli_spoolss_GetPrinter(cli, mem_ctx,
     285        if (!NT_STATUS_IS_OK(status)) {
     286                return ntstatus_to_werror(status);
     287        }
     288
     289        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
     290
     291                offered = needed;
     292                buffer = data_blob_talloc_zero(mem_ctx, offered);
     293                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     294
     295                status = dcerpc_spoolss_GetPrinter(b, mem_ctx,
    269296                                                   handle,
    270297                                                   level,
    … …  
    275302                                                   &werror);
    276303        }
     304
     305
     306
    277307
    278308        return werror;
    … …  
    295325        uint32_t needed;
    296326        DATA_BLOB buffer;
    297 
    298         if (offered > 0) {
    299                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    300                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    301         }
    302 
    303         status = rpccli_spoolss_GetJob(cli, mem_ctx,
     327        struct dcerpc_binding_handle *b = cli->binding_handle;
     328
     329        if (offered > 0) {
     330                buffer = data_blob_talloc_zero(mem_ctx, offered);
     331                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     332        }
     333
     334        status = dcerpc_spoolss_GetJob(b, mem_ctx,
    304335                                       handle,
    305336                                       job_id,
    … …  
    310341                                       &needed,
    311342                                       &werror);
     343
     344
     345
    312346
    313347        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    … …  
    316350                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    317351
    318                 status = rpccli_spoolss_GetJob(cli, mem_ctx,
     352                status = , mem_ctx,
    319353                                               handle,
    320354                                               job_id,
    … …  
    326360                                               &werror);
    327361        }
     362
     363
     364
    328365
    329366        return werror;
    … …  
    346383        uint32_t needed;
    347384        DATA_BLOB buffer;
    348 
    349         if (offered > 0) {
    350                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    351                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    352         }
    353 
    354         status = rpccli_spoolss_EnumForms(cli, mem_ctx,
     385        struct dcerpc_binding_handle *b = cli->binding_handle;
     386
     387        if (offered > 0) {
     388                buffer = data_blob_talloc_zero(mem_ctx, offered);
     389                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     390        }
     391
     392        status = dcerpc_spoolss_EnumForms(b, mem_ctx,
    355393                                          handle,
    356394                                          level,
    … …  
    361399                                          &needed,
    362400                                          &werror);
     401
     402
     403
    363404
    364405        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    … …  
    367408                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    368409
    369                 status = rpccli_spoolss_EnumForms(cli, mem_ctx,
     410                status = , mem_ctx,
    370411                                                  handle,
    371412                                                  level,
    … …  
    377418                                                  &werror);
    378419        }
     420
     421
     422
    379423
    380424        return werror;
    … …  
    398442        uint32_t needed;
    399443        DATA_BLOB buffer;
    400 
    401         if (offered > 0) {
    402                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    403                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    404         }
    405 
    406         status = rpccli_spoolss_EnumPrintProcessors(cli, mem_ctx,
     444        struct dcerpc_binding_handle *b = cli->binding_handle;
     445
     446        if (offered > 0) {
     447                buffer = data_blob_talloc_zero(mem_ctx, offered);
     448                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     449        }
     450
     451        status = dcerpc_spoolss_EnumPrintProcessors(b, mem_ctx,
    407452                                                    servername,
    408453                                                    environment,
    … …  
    414459                                                    &needed,
    415460                                                    &werror);
     461
     462
     463
    416464
    417465        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    … …  
    420468                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    421469
    422                 status = rpccli_spoolss_EnumPrintProcessors(cli, mem_ctx,
     470                status = , mem_ctx,
    423471                                                            servername,
    424472                                                            environment,
    … …  
    431479                                                            &werror);
    432480        }
     481
     482
     483
    433484
    434485        return werror;
    … …  
    452503        uint32_t needed;
    453504        DATA_BLOB buffer;
    454 
    455         if (offered > 0) {
    456                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    457                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    458         }
    459 
    460         status = rpccli_spoolss_EnumPrintProcDataTypes(cli, mem_ctx,
     505        struct dcerpc_binding_handle *b = cli->binding_handle;
     506
     507        if (offered > 0) {
     508                buffer = data_blob_talloc_zero(mem_ctx, offered);
     509                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     510        }
     511
     512        status = dcerpc_spoolss_EnumPrintProcDataTypes(b, mem_ctx,
    461513                                                       servername,
    462514                                                       print_processor_name,
    … …  
    468520                                                       &needed,
    469521                                                       &werror);
     522
     523
     524
    470525
    471526        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    … …  
    474529                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    475530
    476                 status = rpccli_spoolss_EnumPrintProcDataTypes(cli, mem_ctx,
     531                status = , mem_ctx,
    477532                                                               servername,
    478533                                                               print_processor_name,
    … …  
    485540                                                               &werror);
    486541        }
     542
     543
     544
    487545
    488546        return werror;
    … …  
    505563        uint32_t needed;
    506564        DATA_BLOB buffer;
    507 
    508         if (offered > 0) {
    509                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    510                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    511         }
    512 
    513         status = rpccli_spoolss_EnumPorts(cli, mem_ctx,
     565        struct dcerpc_binding_handle *b = cli->binding_handle;
     566
     567        if (offered > 0) {
     568                buffer = data_blob_talloc_zero(mem_ctx, offered);
     569                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     570        }
     571
     572        status = dcerpc_spoolss_EnumPorts(b, mem_ctx,
    514573                                          servername,
    515574                                          level,
    … …  
    520579                                          &needed,
    521580                                          &werror);
     581
     582
     583
    522584
    523585        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    … …  
    526588                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    527589
    528                 status = rpccli_spoolss_EnumPorts(cli, mem_ctx,
     590                status = , mem_ctx,
    529591                                                  servername,
    530592                                                  level,
    … …  
    536598                                                  &werror);
    537599        }
     600
     601
     602
    538603
    539604        return werror;
    … …  
    556621        uint32_t needed;
    557622        DATA_BLOB buffer;
    558 
    559         if (offered > 0) {
    560                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    561                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    562         }
    563 
    564         status = rpccli_spoolss_EnumMonitors(cli, mem_ctx,
     623        struct dcerpc_binding_handle *b = cli->binding_handle;
     624
     625        if (offered > 0) {
     626                buffer = data_blob_talloc_zero(mem_ctx, offered);
     627                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     628        }
     629
     630        status = dcerpc_spoolss_EnumMonitors(b, mem_ctx,
    565631                                             servername,
    566632                                             level,
    … …  
    571637                                             &needed,
    572638                                             &werror);
     639
     640
     641
    573642
    574643        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    … …  
    577646                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    578647
    579                 status = rpccli_spoolss_EnumMonitors(cli, mem_ctx,
     648                status = , mem_ctx,
    580649                                                     servername,
    581650                                                     level,
    … …  
    586655                                                     &needed,
    587656                                                     &werror);
     657
     658
     659
    588660        }
    589661
    … …  
    609681        uint32_t needed;
    610682        DATA_BLOB buffer;
    611 
    612         if (offered > 0) {
    613                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    614                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    615         }
    616 
    617         status = rpccli_spoolss_EnumJobs(cli, mem_ctx,
     683        struct dcerpc_binding_handle *b = cli->binding_handle;
     684
     685        if (offered > 0) {
     686                buffer = data_blob_talloc_zero(mem_ctx, offered);
     687                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     688        }
     689
     690        status = dcerpc_spoolss_EnumJobs(b, mem_ctx,
    618691                                         handle,
    619692                                         firstjob,
    … …  
    626699                                         &needed,
    627700                                         &werror);
     701
     702
     703
    628704
    629705        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    … …  
    632708                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    633709
    634                 status = rpccli_spoolss_EnumJobs(cli, mem_ctx,
     710                status = , mem_ctx,
    635711                                                 handle,
    636712                                                 firstjob,
    … …  
    644720                                                 &werror);
    645721        }
     722
     723
     724
    646725
    647726        return werror;
    … …  
    665744        uint32_t needed;
    666745        DATA_BLOB buffer;
    667 
    668         if (offered > 0) {
    669                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    670                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    671         }
    672 
    673         status = rpccli_spoolss_EnumPrinterDrivers(cli, mem_ctx,
     746        struct dcerpc_binding_handle *b = cli->binding_handle;
     747
     748        if (offered > 0) {
     749                buffer = data_blob_talloc_zero(mem_ctx, offered);
     750                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     751        }
     752
     753        status = dcerpc_spoolss_EnumPrinterDrivers(b, mem_ctx,
    674754                                                   server,
    675755                                                   environment,
    … …  
    681761                                                   &needed,
    682762                                                   &werror);
     763
     764
     765
    683766
    684767        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    … …  
    687770                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    688771
    689                 status = rpccli_spoolss_EnumPrinterDrivers(cli, mem_ctx,
     772                status = , mem_ctx,
    690773                                                   server,
    691774                                                   environment,
    … …  
    698781                                                   &werror);
    699782        }
     783
     784
     785
    700786
    701787        return werror;
    … …  
    719805        uint32_t needed;
    720806        DATA_BLOB buffer;
    721 
    722         if (offered > 0) {
    723                 buffer = data_blob_talloc_zero(mem_ctx, offered);
    724                 W_ERROR_HAVE_NO_MEMORY(buffer.data);
    725         }
    726 
    727         status = rpccli_spoolss_EnumPrinters(cli, mem_ctx,
     807        struct dcerpc_binding_handle *b = cli->binding_handle;
     808
     809        if (offered > 0) {
     810                buffer = data_blob_talloc_zero(mem_ctx, offered);
     811                W_ERROR_HAVE_NO_MEMORY(buffer.data);
     812        }
     813
     814        status = dcerpc_spoolss_EnumPrinters(b, mem_ctx,
    728815                                             flags,
    729816                                             server,
    … …  
    735822                                             &needed,
    736823                                             &werror);
     824
     825
     826
    737827
    738828        if (W_ERROR_EQUAL(werror, WERR_INSUFFICIENT_BUFFER)) {
    … …  
    741831                W_ERROR_HAVE_NO_MEMORY(buffer.data);
    742832
    743                 status = rpccli_spoolss_EnumPrinters(cli, mem_ctx,
     833                status = , mem_ctx,
    744834                                                     flags,
    745835                                                     server,
    … …  
    752842                                                     &werror);
    753843        }
     844
     845
     846
    754847
    755848        return werror;
    … …  
    773866        uint32_t needed;
    774867        uint8_t *data;
     868
    775869
    776870        data = talloc_zero_array(mem_ctx, uint8_t, offered);
    777871        W_ERROR_HAVE_NO_MEMORY(data);
    778872
    779         status = rpccli_spoolss_GetPrinterData(cli, mem_ctx,
     873        status = , mem_ctx,
    780874                                               handle,
    781875                                               value_name,
    … …  
    785879                                               &needed,
    786880                                               &werror);
     881
     882
     883
    787884
    788885        if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
    … …  
    791888                W_ERROR_HAVE_NO_MEMORY(data);
    792889
    793                 status = rpccli_spoolss_GetPrinterData(cli, mem_ctx,
     890                status = , mem_ctx,
    794891                                                       handle,
    795892                                                       value_name,
    … …  
    800897                                                       &werror);
    801898        }
     899
     900
     901
    802902
    803903        *data_p = data;
    … …  
    823923        union spoolss_KeyNames _key_buffer;
    824924        uint32_t _ndr_size;
    825 
    826         status = rpccli_spoolss_EnumPrinterKey(cli, mem_ctx,
     925        struct dcerpc_binding_handle *b = cli->binding_handle;
     926
     927        status = dcerpc_spoolss_EnumPrinterKey(b, mem_ctx,
    827928                                               handle,
    828929                                               key_name,
    … …  
    832933                                               &needed,
    833934                                               &werror);
     935
     936
     937
    834938
    835939        if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
    836940                offered = needed;
    837                 status = rpccli_spoolss_EnumPrinterKey(cli, mem_ctx,
     941                status = , mem_ctx,
    838942                                                       handle,
    839943                                                       key_name,
    … …  
    844948                                                       &werror);
    845949        }
     950
     951
     952
    846953
    847954        *key_buffer = _key_buffer.string_array;
    … …  
    865972        WERROR werror;
    866973        uint32_t needed;
    867 
    868         status = rpccli_spoolss_EnumPrinterDataEx(cli, mem_ctx,
     974        struct dcerpc_binding_handle *b = cli->binding_handle;
     975
     976        status = dcerpc_spoolss_EnumPrinterDataEx(b, mem_ctx,
    869977                                                  handle,
    870978                                                  key_name,
    … …  
    874982                                                  &needed,
    875983                                                  &werror);
     984
     985
     986
    876987
    877988        if (W_ERROR_EQUAL(werror, WERR_MORE_DATA)) {
    878989                offered = needed;
    879990
    880                 status = rpccli_spoolss_EnumPrinterDataEx(cli, mem_ctx,
     991                status = , mem_ctx,
    881992                                                          handle,
    882993                                                          key_name,
    … …  
    887998                                                          &werror);
    888999        }
    889 
    890         return werror;
    891 }
     1000        if (!NT_STATUS_IS_OK(status)) {
     1001                return ntstatus_to_werror(status);
     1002        }
     1003
     1004        return werror;
     1005}
Note: See TracChangeset for help on using the changeset viewer.