LCOV - code coverage report
Current view: top level - source4/torture/rpc - srvsvc.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 427 612 69.8 %
Date: 2021-09-23 10:06:22 Functions: 21 25 84.0 %

          Line data    Source code
       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             :    test suite for srvsvc rpc operations
       4             : 
       5             :    Copyright (C) Stefan (metze) Metzmacher 2003
       6             :    
       7             :    This program is free software; you can redistribute it and/or modify
       8             :    it under the terms of the GNU General Public License as published by
       9             :    the Free Software Foundation; either version 3 of the License, or
      10             :    (at your option) any later version.
      11             :    
      12             :    This program is distributed in the hope that it will be useful,
      13             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :    GNU General Public License for more details.
      16             :    
      17             :    You should have received a copy of the GNU General Public License
      18             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      19             : */
      20             : 
      21             : #include "includes.h"
      22             : #include "librpc/gen_ndr/ndr_srvsvc_c.h"
      23             : #include "torture/rpc/torture_rpc.h"
      24             : 
      25             : /**************************/
      26             : /* srvsvc_NetCharDev      */
      27             : /**************************/
      28           0 : static bool test_NetCharDevGetInfo(struct dcerpc_pipe *p, struct torture_context *tctx,
      29             :                                 const char *devname)
      30             : {
      31             :         NTSTATUS status;
      32             :         struct srvsvc_NetCharDevGetInfo r;
      33             :         union srvsvc_NetCharDevInfo info;
      34           0 :         uint32_t levels[] = {0, 1};
      35             :         int i;
      36           0 :         struct dcerpc_binding_handle *b = p->binding_handle;
      37             : 
      38           0 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
      39           0 :         r.in.device_name = devname;
      40           0 :         r.out.info = &info;
      41             : 
      42           0 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
      43           0 :                 r.in.level = levels[i];
      44           0 :                 torture_comment(tctx, "Testing NetCharDevGetInfo level %u on device '%s'\n",
      45             :                         r.in.level, r.in.device_name);
      46           0 :                 status = dcerpc_srvsvc_NetCharDevGetInfo_r(b, tctx, &r);
      47           0 :                 torture_assert_ntstatus_ok(tctx, status, "NetCharDevGetInfo failed");
      48           0 :                 torture_assert_werr_ok(tctx, r.out.result, "NetCharDevGetInfo failed");
      49             :         }
      50             : 
      51           0 :         return true;
      52             : }
      53             : 
      54           0 : static bool test_NetCharDevControl(struct dcerpc_pipe *p, struct torture_context *tctx,
      55             :                                 const char *devname)
      56             : {
      57             :         NTSTATUS status;
      58             :         struct srvsvc_NetCharDevControl r;
      59           0 :         uint32_t opcodes[] = {0, 1};
      60             :         int i;
      61           0 :         struct dcerpc_binding_handle *b = p->binding_handle;
      62             : 
      63           0 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
      64           0 :         r.in.device_name = devname;
      65             : 
      66           0 :         for (i=0;i<ARRAY_SIZE(opcodes);i++) {
      67           0 :                 ZERO_STRUCT(r.out);
      68           0 :                 r.in.opcode = opcodes[i];
      69           0 :                 torture_comment(tctx, "Testing NetCharDevControl opcode %u on device '%s'\n", 
      70             :                         r.in.opcode, r.in.device_name);
      71           0 :                 status = dcerpc_srvsvc_NetCharDevControl_r(b, tctx, &r);
      72           0 :                 torture_assert_ntstatus_ok(tctx, status, "NetCharDevControl failed");
      73           0 :                 torture_assert_werr_ok(tctx, r.out.result, "NetCharDevControl failed");
      74             :         }
      75             : 
      76           0 :         return true;
      77             : }
      78             : 
      79           7 : static bool test_NetCharDevEnum(struct torture_context *tctx, 
      80             :                                                                 struct dcerpc_pipe *p)
      81             : {
      82             :         NTSTATUS status;
      83             :         struct srvsvc_NetCharDevEnum r;
      84             :         struct srvsvc_NetCharDevInfoCtr info_ctr;
      85             :         struct srvsvc_NetCharDevCtr0 c0;
      86             :         struct srvsvc_NetCharDevCtr0 c1;
      87           7 :         uint32_t totalentries = 0;
      88           7 :         uint32_t levels[] = {0, 1};
      89             :         int i;
      90           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
      91             : 
      92           7 :         ZERO_STRUCT(info_ctr);
      93             : 
      94           7 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
      95           7 :         r.in.info_ctr = &info_ctr;
      96           7 :         r.in.max_buffer = (uint32_t)-1;
      97           7 :         r.in.resume_handle = NULL;
      98           7 :         r.out.info_ctr = &info_ctr;
      99           7 :         r.out.totalentries = &totalentries;
     100             : 
     101          13 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     102             :                 int j;
     103             : 
     104          10 :                 info_ctr.level = levels[i];
     105             : 
     106          10 :                 switch(info_ctr.level) {
     107           7 :                 case 0:
     108           7 :                         ZERO_STRUCT(c0);
     109           7 :                         info_ctr.ctr.ctr0 = &c0;
     110           7 :                         break;
     111           3 :                 case 1:
     112           3 :                         ZERO_STRUCT(c1);
     113           3 :                         info_ctr.ctr.ctr0 = &c1;
     114           3 :                         break;
     115             :                 }
     116             : 
     117          10 :                 torture_comment(tctx, "Testing NetCharDevEnum level %u\n", info_ctr.level);
     118          10 :                 status = dcerpc_srvsvc_NetCharDevEnum_r(b, tctx, &r);
     119          10 :                 torture_assert_ntstatus_ok(tctx, status, "NetCharDevEnum failed");
     120           6 :                 if (!W_ERROR_IS_OK(r.out.result)) {
     121           6 :                         torture_comment(tctx, "NetCharDevEnum failed: %s\n", win_errstr(r.out.result));
     122           6 :                         continue;
     123             :                 }
     124             : 
     125             :                 /* call test_NetCharDevGetInfo and test_NetCharDevControl for each returned share */
     126           0 :                 if (info_ctr.level == 1) {
     127           0 :                         for (j=0;j<r.out.info_ctr->ctr.ctr1->count;j++) {
     128             :                                 const char *device;
     129           0 :                                 device = r.out.info_ctr->ctr.ctr1->array[j].device;
     130           0 :                                 if (!test_NetCharDevGetInfo(p, tctx, device)) {
     131           0 :                                         return false;
     132             :                                 }
     133           0 :                                 if (!test_NetCharDevControl(p, tctx, device)) {
     134           0 :                                         return false;
     135             :                                 }
     136             :                         }
     137             :                 }
     138             :         }
     139             : 
     140           3 :         return true;
     141             : }
     142             : 
     143             : /**************************/
     144             : /* srvsvc_NetCharDevQ     */
     145             : /**************************/
     146           0 : static bool test_NetCharDevQGetInfo(struct dcerpc_pipe *p, struct torture_context *tctx,
     147             :                                 const char *devicequeue)
     148             : {
     149             :         NTSTATUS status;
     150             :         struct srvsvc_NetCharDevQGetInfo r;
     151             :         union srvsvc_NetCharDevQInfo info;
     152           0 :         uint32_t levels[] = {0, 1};
     153             :         int i;
     154           0 :         struct dcerpc_binding_handle *b = p->binding_handle;
     155             : 
     156           0 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
     157           0 :         r.in.queue_name = devicequeue;
     158           0 :         r.in.user = talloc_asprintf(tctx,"Administrator");
     159           0 :         r.out.info = &info;
     160             : 
     161           0 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     162           0 :                 r.in.level = levels[i];
     163           0 :                 torture_comment(tctx, "Testing NetCharDevQGetInfo level %u on devicequeue '%s'\n",
     164             :                         r.in.level, r.in.queue_name);
     165           0 :                 status = dcerpc_srvsvc_NetCharDevQGetInfo_r(b, tctx, &r);
     166           0 :                 torture_assert_ntstatus_ok(tctx, status, "NetCharDevQGetInfo failed");
     167           0 :                 torture_assert_werr_ok(tctx, r.out.result, "NetCharDevQGetInfo failed");
     168             :         }
     169             : 
     170           0 :         return true;
     171             : }
     172             : 
     173             : #if 0
     174             : static bool test_NetCharDevQSetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
     175             :                                 const char *devicequeue)
     176             : {
     177             :         NTSTATUS status;
     178             :         struct srvsvc_NetCharDevQSetInfo r;
     179             :         uint32_t parm_error;
     180             :         uint32_t levels[] = {0, 1};
     181             :         int i;
     182             :         bool ret = true;
     183             :         struct dcerpc_binding_handle *b = p->binding_handle;
     184             : 
     185             :         r.in.server_unc = talloc_asprintf(mem_ctx,"\\\\%s",dcerpc_server_name(p));
     186             :         r.in.queue_name = devicequeue;
     187             : 
     188             :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     189             :                 ZERO_STRUCT(r.out);
     190             :                 parm_error = 0;
     191             :                 r.in.level = levels[i];
     192             :                 d_printf("testing NetCharDevQSetInfo level %u on devicequeue '%s'\n", 
     193             :                         r.in.level, devicequeue);
     194             :                 switch (r.in.level) {
     195             :                 case 0:
     196             :                         r.in.info.info0 = talloc(mem_ctx, struct srvsvc_NetCharDevQInfo0);
     197             :                         r.in.info.info0->device = r.in.queue_name;
     198             :                         break;
     199             :                 case 1:
     200             :                         r.in.info.info1 = talloc(mem_ctx, struct srvsvc_NetCharDevQInfo1);
     201             :                         r.in.info.info1->device = r.in.queue_name;
     202             :                         r.in.info.info1->priority = 0x000;
     203             :                         r.in.info.info1->devices = r.in.queue_name;
     204             :                         r.in.info.info1->users = 0x000;
     205             :                         r.in.info.info1->num_ahead = 0x000;
     206             :                         break;
     207             :                 default:
     208             :                         break;
     209             :                 }
     210             :                 r.in.parm_error = &parm_error;
     211             :                 status = dcerpc_srvsvc_NetCharDevQSetInfo_r(b, mem_ctx, &r);
     212             :                 if (!NT_STATUS_IS_OK(status)) {
     213             :                         d_printf("NetCharDevQSetInfo level %u on devicequeue '%s' failed - %s\n",
     214             :                                 r.in.level, r.in.queue_name, nt_errstr(status));
     215             :                         ret = false;
     216             :                         continue;
     217             :                 }
     218             :                 if (!W_ERROR_IS_OK(r.out.result)) {
     219             :                         d_printf("NetCharDevQSetInfo level %u on devicequeue '%s' failed - %s\n",
     220             :                                 r.in.level, r.in.queue_name, win_errstr(r.out.result));
     221             :                         continue;
     222             :                 }
     223             :         }
     224             : 
     225             :         return ret;
     226             : }
     227             : #endif
     228             : 
     229           7 : static bool test_NetCharDevQEnum(struct torture_context *tctx, 
     230             :                                  struct dcerpc_pipe *p)
     231             : {
     232             :         NTSTATUS status;
     233             :         struct srvsvc_NetCharDevQEnum r;
     234             :         struct srvsvc_NetCharDevQInfoCtr info_ctr;
     235             :         struct srvsvc_NetCharDevQCtr0 c0;
     236             :         struct srvsvc_NetCharDevQCtr1 c1;
     237           7 :         uint32_t totalentries = 0;
     238           7 :         uint32_t levels[] = {0, 1};
     239             :         int i;
     240           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
     241             : 
     242           7 :         ZERO_STRUCT(info_ctr);
     243             : 
     244           7 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
     245           7 :         r.in.user = talloc_asprintf(tctx,"%s","Administrator");
     246           7 :         r.in.info_ctr = &info_ctr;
     247           7 :         r.in.max_buffer = (uint32_t)-1;
     248           7 :         r.in.resume_handle = NULL;
     249           7 :         r.out.totalentries = &totalentries;
     250           7 :         r.out.info_ctr = &info_ctr;
     251             : 
     252          13 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     253             :                 int j;
     254             : 
     255          10 :                 info_ctr.level = levels[i];
     256             : 
     257          10 :                 switch (info_ctr.level) {
     258           7 :                 case 0:
     259           7 :                         ZERO_STRUCT(c0);
     260           7 :                         info_ctr.ctr.ctr0 = &c0;
     261           7 :                         break;
     262           3 :                 case 1:
     263           3 :                         ZERO_STRUCT(c1);
     264           3 :                         info_ctr.ctr.ctr1 = &c1;
     265           3 :                         break;
     266             :                 }
     267          10 :                 torture_comment(tctx, "Testing NetCharDevQEnum level %u\n", info_ctr.level);
     268          10 :                 status = dcerpc_srvsvc_NetCharDevQEnum_r(b, tctx, &r);
     269          10 :                 torture_assert_ntstatus_ok(tctx, status, "NetCharDevQEnum failed");
     270           6 :                 if (!W_ERROR_IS_OK(r.out.result)) {
     271           6 :                         torture_comment(tctx, "NetCharDevQEnum failed: %s\n", win_errstr(r.out.result));
     272           6 :                         continue;
     273             :                 }
     274             : 
     275             :                 /* call test_NetCharDevGetInfo and test_NetCharDevControl for each returned share */
     276           0 :                 if (info_ctr.level == 1) {
     277           0 :                         for (j=0;j<r.out.info_ctr->ctr.ctr1->count;j++) {
     278             :                                 const char *device;
     279           0 :                                 device = r.out.info_ctr->ctr.ctr1->array[j].device;
     280           0 :                                 if (!test_NetCharDevQGetInfo(p, tctx, device)) {
     281           0 :                                         return false;
     282             :                                 }
     283             :                         }
     284             :                 }
     285             :         }
     286             : 
     287           3 :         return true;
     288             : }
     289             : 
     290             : /**************************/
     291             : /* srvsvc_NetConn         */
     292             : /**************************/
     293           7 : static bool test_NetConnEnum(struct torture_context *tctx,
     294             :                              struct dcerpc_pipe *p)
     295             : {
     296             :         NTSTATUS status;
     297             :         struct srvsvc_NetConnEnum r;
     298             :         struct srvsvc_NetConnInfoCtr info_ctr;
     299             :         struct srvsvc_NetConnCtr0 c0;
     300             :         struct srvsvc_NetConnCtr1 c1;
     301           7 :         uint32_t totalentries = 0;
     302           7 :         uint32_t levels[] = {0, 1};
     303             :         int i;
     304           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
     305             : 
     306           7 :         ZERO_STRUCT(info_ctr);
     307             : 
     308           7 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
     309           7 :         r.in.path = talloc_asprintf(tctx,"%s","IPC$");
     310           7 :         r.in.info_ctr = &info_ctr;
     311           7 :         r.in.max_buffer = (uint32_t)-1;
     312           7 :         r.in.resume_handle = NULL;
     313           7 :         r.out.totalentries = &totalentries;
     314           7 :         r.out.info_ctr = &info_ctr;
     315             : 
     316          21 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     317          14 :                 info_ctr.level = levels[i];
     318             : 
     319          14 :                 switch (info_ctr.level) {
     320           7 :                 case 0:
     321           7 :                         ZERO_STRUCT(c0);
     322           7 :                         info_ctr.ctr.ctr0 = &c0;
     323           7 :                         break;
     324           7 :                 case 1:
     325           7 :                         ZERO_STRUCT(c1);
     326           7 :                         info_ctr.ctr.ctr1 = &c1;
     327           7 :                         break;
     328             :                 }
     329             : 
     330          14 :                 torture_comment(tctx, "Testing NetConnEnum level %u\n", info_ctr.level);
     331          14 :                 status = dcerpc_srvsvc_NetConnEnum_r(b, tctx, &r);
     332          14 :                 torture_assert_ntstatus_ok(tctx, status, "NetConnEnum failed");
     333          14 :                 if (!W_ERROR_IS_OK(r.out.result)) {
     334           6 :                         torture_comment(tctx, "NetConnEnum failed: %s\n", win_errstr(r.out.result));
     335             :                 }
     336             :         }
     337             : 
     338           7 :         return true;
     339             : }
     340             : 
     341             : /**************************/
     342             : /* srvsvc_NetFile         */
     343             : /**************************/
     344           7 : static bool test_NetFileEnum(struct torture_context *tctx,
     345             :                              struct dcerpc_pipe *p)
     346             : {
     347             :         NTSTATUS status;
     348             :         struct srvsvc_NetFileEnum r;
     349             :         struct srvsvc_NetFileInfoCtr info_ctr;
     350             :         struct srvsvc_NetFileCtr2 c2;
     351             :         struct srvsvc_NetFileCtr3 c3;
     352           7 :         uint32_t totalentries = 0;
     353           7 :         uint32_t levels[] = {2, 3};
     354             :         int i;
     355           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
     356             : 
     357           7 :         ZERO_STRUCT(info_ctr);
     358             : 
     359           7 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
     360           7 :         r.in.path = NULL;
     361           7 :         r.in.user = NULL;
     362           7 :         r.in.info_ctr = &info_ctr;
     363           7 :         r.in.max_buffer = (uint32_t)4096;
     364           7 :         r.in.resume_handle = NULL;
     365           7 :         r.out.totalentries = &totalentries;
     366           7 :         r.out.info_ctr = &info_ctr;
     367             : 
     368          21 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     369          14 :                 info_ctr.level = levels[i];
     370             : 
     371          14 :                 switch (info_ctr.level) {
     372           7 :                 case 2:
     373           7 :                         ZERO_STRUCT(c2);
     374           7 :                         info_ctr.ctr.ctr2 = &c2;
     375           7 :                         break;
     376           7 :                 case 3:
     377           7 :                         ZERO_STRUCT(c3);
     378           7 :                         info_ctr.ctr.ctr3 = &c3;
     379           7 :                         break;
     380             :                 }
     381          14 :                 torture_comment(tctx, "Testing NetFileEnum level %u\n", info_ctr.level);
     382          14 :                 status = dcerpc_srvsvc_NetFileEnum_r(b, tctx, &r);
     383          14 :                 torture_assert_ntstatus_ok(tctx, status, "NetFileEnum failed");
     384          14 :                 if (!W_ERROR_IS_OK(r.out.result)) {
     385          10 :                         torture_comment(tctx, "NetFileEnum failed: %s\n", win_errstr(r.out.result));
     386             :                 }
     387             :         }
     388             : 
     389           7 :         return true;
     390             : }
     391             : 
     392             : /**************************/
     393             : /* srvsvc_NetSess         */
     394             : /**************************/
     395           7 : static bool test_NetSessEnum(struct torture_context *tctx,
     396             :                              struct dcerpc_pipe *p)
     397             : {
     398             :         NTSTATUS status;
     399             :         struct srvsvc_NetSessEnum r;
     400             :         struct srvsvc_NetSessInfoCtr info_ctr;
     401             :         struct srvsvc_NetSessCtr0 c0;
     402             :         struct srvsvc_NetSessCtr1 c1;
     403             :         struct srvsvc_NetSessCtr2 c2;
     404             :         struct srvsvc_NetSessCtr10 c10;
     405             :         struct srvsvc_NetSessCtr502 c502;
     406           7 :         uint32_t totalentries = 0;
     407           7 :         uint32_t levels[] = {0, 1, 2, 10, 502};
     408             :         int i;
     409           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
     410             : 
     411           7 :         ZERO_STRUCT(info_ctr);
     412             : 
     413           7 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
     414           7 :         r.in.client = NULL;
     415           7 :         r.in.user = NULL;
     416           7 :         r.in.info_ctr = &info_ctr;
     417           7 :         r.in.max_buffer = (uint32_t)-1;
     418           7 :         r.in.resume_handle = NULL;
     419           7 :         r.out.totalentries = &totalentries;
     420           7 :         r.out.info_ctr = &info_ctr;
     421             : 
     422          42 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     423          35 :                 info_ctr.level = levels[i];
     424             : 
     425          35 :                 switch (info_ctr.level) {
     426           7 :                 case 0:
     427           7 :                         ZERO_STRUCT(c0);
     428           7 :                         info_ctr.ctr.ctr0 = &c0;
     429           7 :                         break;
     430           7 :                 case 1:
     431           7 :                         ZERO_STRUCT(c1);
     432           7 :                         info_ctr.ctr.ctr1 = &c1;
     433           7 :                         break;
     434           7 :                 case 2:
     435           7 :                         ZERO_STRUCT(c2);
     436           7 :                         info_ctr.ctr.ctr2 = &c2;
     437           7 :                         break;
     438           7 :                 case 10:
     439           7 :                         ZERO_STRUCT(c10);
     440           7 :                         info_ctr.ctr.ctr10 = &c10;
     441           7 :                         break;
     442           7 :                 case 502:
     443           7 :                         ZERO_STRUCT(c502);
     444           7 :                         info_ctr.ctr.ctr502 = &c502;
     445           7 :                         break;
     446             :                 }
     447             : 
     448          35 :                 torture_comment(tctx, "Testing NetSessEnum level %u\n", info_ctr.level);
     449          35 :                 status = dcerpc_srvsvc_NetSessEnum_r(b, tctx, &r);
     450          35 :                 torture_assert_ntstatus_ok(tctx, status, "NetSessEnum failed");
     451          35 :                 if (!W_ERROR_IS_OK(r.out.result)) {
     452          27 :                         torture_comment(tctx, "NetSessEnum failed: %s\n", win_errstr(r.out.result));
     453             :                 }
     454             :         }
     455             : 
     456           7 :         return true;
     457             : }
     458             : 
     459             : /**************************/
     460             : /* srvsvc_NetShare        */
     461             : /**************************/
     462          50 : static bool test_NetShareCheck(struct dcerpc_pipe *p, struct torture_context *tctx,
     463             :                                const char *device_name)
     464             : {
     465             :         NTSTATUS status;
     466             :         struct srvsvc_NetShareCheck r;
     467             :         enum srvsvc_ShareType type;
     468          50 :         struct dcerpc_binding_handle *b = p->binding_handle;
     469             : 
     470          50 :         r.in.server_unc = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
     471          50 :         r.in.device_name = device_name;
     472          50 :         r.out.type = &type;
     473             : 
     474          50 :         torture_comment(tctx, 
     475             :                         "Testing NetShareCheck on device '%s'\n", r.in.device_name);
     476             : 
     477          50 :         status = dcerpc_srvsvc_NetShareCheck_r(b, tctx, &r);
     478          50 :         torture_assert_ntstatus_ok(tctx, status, "dcerpc_srvsvc_NetShareCheck failed");
     479          42 :         torture_assert_werr_ok(tctx, r.out.result, "NetShareCheck failed");
     480             : 
     481          42 :         return true;
     482             : }
     483             : 
     484          57 : static bool test_NetShareGetInfo(struct torture_context *tctx, 
     485             :                                  struct dcerpc_pipe *p,
     486             :                                  const char *sharename, bool admin)
     487             : {
     488             :         NTSTATUS status;
     489             :         struct srvsvc_NetShareGetInfo r;
     490             :         union srvsvc_NetShareInfo info;
     491             :         struct {
     492             :                 uint32_t level;
     493             :                 WERROR anon_status;
     494             :                 WERROR admin_status;
     495          57 :         } levels[] = {
     496             :                  { 0,           WERR_OK,                WERR_OK },
     497             :                  { 1,           WERR_OK,                WERR_OK },
     498             :                  { 2,           WERR_ACCESS_DENIED,     WERR_OK },
     499             :                  { 501,         WERR_OK,                WERR_OK },
     500             :                  { 502,         WERR_ACCESS_DENIED,     WERR_OK },
     501             :                  { 1005,        WERR_OK,                WERR_OK },
     502             :         };
     503             :         int i;
     504          57 :         struct dcerpc_binding_handle *b = p->binding_handle;
     505             : 
     506          57 :         r.in.server_unc = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
     507          57 :         r.in.share_name = sharename;
     508          57 :         r.out.info = &info;
     509             : 
     510         351 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     511             :                 WERROR expected;
     512             : 
     513         306 :                 r.in.level = levels[i].level;
     514         306 :                 expected = levels[i].anon_status;
     515         306 :                 if (admin) expected = levels[i].admin_status;
     516             : 
     517         306 :                 torture_comment(tctx, "Testing NetShareGetInfo level %u on share '%s'\n", 
     518             :                        r.in.level, r.in.share_name);
     519             : 
     520         306 :                 status = dcerpc_srvsvc_NetShareGetInfo_r(b, tctx, &r);
     521         306 :                 torture_assert_ntstatus_ok(tctx, status, "NetShareGetInfo failed");
     522         306 :                 torture_assert_werr_equal(tctx, r.out.result, expected, "NetShareGetInfo failed");
     523             : 
     524         542 :                 if (r.in.level != 2) continue;
     525          53 :                 if (!r.out.info->info2 || !r.out.info->info2->path) continue;
     526          50 :                 if (!test_NetShareCheck(p, tctx, r.out.info->info2->path)) {
     527           8 :                         return false;
     528             :                 }
     529             :         }
     530             : 
     531          45 :         return true;
     532             : }
     533             : 
     534           7 : static bool test_NetShareGetInfoAdminFull(struct torture_context *tctx, 
     535             :                                           struct dcerpc_pipe *p)
     536             : {
     537           7 :         return test_NetShareGetInfo(tctx, p, "IPC$", true);
     538             : }
     539             : 
     540           7 : static bool test_NetShareGetInfoAdminAnon(struct torture_context *tctx, 
     541             :                                           struct dcerpc_pipe *p)
     542             : {
     543           7 :         return test_NetShareGetInfo(tctx, p, "IPC$", false);
     544             : }
     545             : 
     546           0 : static bool test_NetShareAddSetDel(struct torture_context *tctx, 
     547             :                                    struct dcerpc_pipe *p)
     548             : {
     549             :         NTSTATUS status;
     550             :         struct srvsvc_NetShareAdd a;
     551             :         struct srvsvc_NetShareSetInfo r;
     552             :         struct srvsvc_NetShareGetInfo q;
     553             :         struct srvsvc_NetShareDel d;
     554             :         struct sec_desc_buf sd_buf;
     555             :         union srvsvc_NetShareInfo info;
     556             :         struct {
     557             :                 uint32_t level;
     558             :                 WERROR expected;
     559           0 :         } levels[] = {
     560             :                  { 0,           WERR_INVALID_LEVEL },
     561             :                  { 1,           WERR_OK },
     562             :                  { 2,           WERR_OK },
     563             :                  { 501,         WERR_INVALID_LEVEL },
     564             :                  { 502,         WERR_OK },
     565             :                  { 1004,        WERR_OK },
     566             :                  { 1005,        WERR_OK },
     567             :                  { 1006,        WERR_OK },
     568             : /*               { 1007,        WERR_OK }, */
     569             :                  { 1501,        WERR_OK },
     570             :         };
     571             :         int i;
     572           0 :         struct dcerpc_binding_handle *b = p->binding_handle;
     573             : 
     574           0 :         a.in.server_unc = r.in.server_unc = q.in.server_unc = d.in.server_unc =
     575           0 :                 talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
     576           0 :         r.in.share_name = talloc_strdup(tctx, "testshare");
     577             : 
     578           0 :         info.info2 = talloc(tctx, struct srvsvc_NetShareInfo2);
     579           0 :         info.info2->name = r.in.share_name;
     580           0 :         info.info2->type = STYPE_DISKTREE;
     581           0 :         info.info2->comment = talloc_strdup(tctx, "test comment");
     582           0 :         info.info2->permissions = 123434566;
     583           0 :         info.info2->max_users = -1;
     584           0 :         info.info2->current_users = 0;
     585           0 :         info.info2->path = talloc_strdup(tctx, "C:\\");
     586           0 :         info.info2->password = NULL;
     587             : 
     588           0 :         a.in.info = &info;
     589           0 :         a.in.level = 2;
     590           0 :         a.in.parm_error = NULL;
     591             : 
     592           0 :         status = dcerpc_srvsvc_NetShareAdd_r(b, tctx, &a);
     593           0 :         torture_assert_ntstatus_ok(tctx, status, "NetShareAdd level 2 on share 'testshare' failed");
     594           0 :         torture_assert_werr_ok(tctx, a.out.result, "NetShareAdd level 2 on share 'testshare' failed");
     595             : 
     596           0 :         r.in.parm_error = NULL;
     597             : 
     598           0 :         q.in.level = 502;
     599             : 
     600           0 :         for (i = 0; i < ARRAY_SIZE(levels); i++) {
     601             : 
     602           0 :                 r.in.level = levels[i].level;
     603           0 :                 ZERO_STRUCT(r.out);
     604             : 
     605           0 :                 torture_comment(tctx, "Testing NetShareSetInfo level %u on share '%s'\n", 
     606             :                        r.in.level, r.in.share_name);
     607             : 
     608           0 :                 switch (levels[i].level) {
     609           0 :                 case 0:
     610           0 :                         info.info0 = talloc(tctx, struct srvsvc_NetShareInfo0);
     611           0 :                         info.info0->name = r.in.share_name;
     612           0 :                         break;
     613           0 :                 case 1:
     614           0 :                         info.info1 = talloc(tctx, struct srvsvc_NetShareInfo1);
     615           0 :                         info.info1->name = r.in.share_name;
     616           0 :                         info.info1->type = STYPE_DISKTREE;
     617           0 :                         info.info1->comment = talloc_strdup(tctx, "test comment 1");
     618           0 :                         break;
     619           0 :                 case 2: 
     620           0 :                         info.info2 = talloc(tctx, struct srvsvc_NetShareInfo2);
     621           0 :                         info.info2->name = r.in.share_name;
     622           0 :                         info.info2->type = STYPE_DISKTREE;
     623           0 :                         info.info2->comment = talloc_strdup(tctx, "test comment 2");
     624           0 :                         info.info2->permissions = 0;
     625           0 :                         info.info2->max_users = 2;
     626           0 :                         info.info2->current_users = 1;
     627           0 :                         info.info2->path = talloc_strdup(tctx, "::BLaH::"); /* "C:\\"); */
     628           0 :                         info.info2->password = NULL;
     629           0 :                         break;
     630           0 :                 case 501:
     631           0 :                         info.info501 = talloc(tctx, struct srvsvc_NetShareInfo501);
     632           0 :                         info.info501->name = r.in.share_name;
     633           0 :                         info.info501->type = STYPE_DISKTREE;
     634           0 :                         info.info501->comment = talloc_strdup(tctx, "test comment 501");
     635           0 :                         info.info501->csc_policy = 0;
     636           0 :                         break;
     637           0 :                 case 502:
     638           0 :                         ZERO_STRUCT(sd_buf);
     639           0 :                         info.info502 = talloc(tctx, struct srvsvc_NetShareInfo502);
     640           0 :                         info.info502->name = r.in.share_name;
     641           0 :                         info.info502->type = STYPE_DISKTREE;
     642           0 :                         info.info502->comment = talloc_strdup(tctx, "test comment 502");
     643           0 :                         info.info502->permissions = 0;
     644           0 :                         info.info502->max_users = 502;
     645           0 :                         info.info502->current_users = 1;
     646           0 :                         info.info502->path = talloc_strdup(tctx, "C:\\");
     647           0 :                         info.info502->password = NULL;
     648           0 :                         info.info502->sd_buf = sd_buf;
     649           0 :                         break;
     650           0 :                 case 1004:
     651           0 :                         info.info1004 = talloc(tctx, struct srvsvc_NetShareInfo1004);
     652           0 :                         info.info1004->comment = talloc_strdup(tctx, "test comment 1004");
     653           0 :                         break;
     654           0 :                 case 1005:
     655           0 :                         info.info1005 = talloc(tctx, struct srvsvc_NetShareInfo1005);
     656           0 :                         info.info1005->dfs_flags = 0;
     657           0 :                         break;
     658           0 :                 case 1006:
     659           0 :                         info.info1006 = talloc(tctx, struct srvsvc_NetShareInfo1006);
     660           0 :                         info.info1006->max_users = 1006;
     661           0 :                         break;
     662             : /*              case 1007:
     663             :                         info.info1007 = talloc(tctx, struct srvsvc_NetShareInfo1007);
     664             :                         info.info1007->flags = 0;
     665             :                         info.info1007->alternate_directory_name = talloc_strdup(tctx, "test");
     666             :                         break;
     667             : */
     668           0 :                 case 1501:
     669           0 :                         info.info1501 = talloc_zero(tctx, struct sec_desc_buf);
     670           0 :                         break;
     671             :                 }
     672             : 
     673           0 :                 r.in.info = &info;
     674             : 
     675           0 :                 status = dcerpc_srvsvc_NetShareSetInfo_r(b, tctx, &r);
     676           0 :                 torture_assert_ntstatus_ok(tctx, status, "NetShareGetInfo failed");
     677           0 :                 torture_assert_werr_equal(tctx, r.out.result, levels[i].expected, "NetShareSetInfo failed");
     678             :                 
     679           0 :                 q.in.share_name = r.in.share_name;
     680           0 :                 q.out.info = &info;
     681             : 
     682           0 :                 status = dcerpc_srvsvc_NetShareGetInfo_r(b, tctx, &q);
     683           0 :                 torture_assert_ntstatus_ok(tctx, status, "NetShareGetInfo failed");
     684           0 :                 torture_assert_werr_ok(tctx, q.out.result, "NetShareGetInfo failed");
     685             : 
     686           0 :                 torture_assert_str_equal(tctx, q.out.info->info502->name, r.in.share_name,
     687             :                                          "share name invalid");
     688             : 
     689           0 :                 switch (levels[i].level) {
     690           0 :                 case 0:
     691           0 :                         break;
     692           0 :                 case 1:
     693           0 :                         torture_assert_str_equal(tctx, q.out.info->info502->comment, "test comment 1", "comment");
     694           0 :                         break;
     695           0 :                 case 2:
     696           0 :                         torture_assert_str_equal(tctx, q.out.info->info2->comment, "test comment 2", "comment");
     697           0 :                         torture_assert_int_equal(tctx, q.out.info->info2->max_users, 2, "max users");
     698           0 :                         torture_assert_str_equal(tctx, q.out.info->info2->path, "C:\\", "path");
     699           0 :                         break;
     700           0 :                 case 501:
     701           0 :                         torture_assert_str_equal(tctx, q.out.info->info501->comment, "test comment 501", "comment");
     702           0 :                         break;
     703           0 :                 case 502:
     704           0 :                         torture_assert_str_equal(tctx, q.out.info->info502->comment, "test comment 502", "comment");
     705           0 :                         torture_assert_int_equal(tctx, q.out.info->info502->max_users, 502, "max users");
     706           0 :                         torture_assert_str_equal(tctx, q.out.info->info502->path, "C:\\", "path");
     707           0 :                         break;
     708           0 :                 case 1004:
     709           0 :                         torture_assert_str_equal(tctx, q.out.info->info1004->comment, "test comment 1004",
     710             :                                                  "comment");
     711           0 :                         break;
     712           0 :                 case 1005:
     713           0 :                         break;
     714           0 :                 case 1006:
     715           0 :                         torture_assert_int_equal(tctx, q.out.info->info1006->max_users, 1006, "Max users");
     716           0 :                         break;
     717             : /*              case 1007:
     718             :                         break;
     719             : */
     720           0 :                 case 1501:
     721           0 :                         break;
     722             :                 }
     723             :         }
     724             : 
     725           0 :         d.in.share_name = r.in.share_name;
     726           0 :         d.in.reserved = 0;
     727             : 
     728           0 :         status = dcerpc_srvsvc_NetShareDel_r(b, tctx, &d);
     729           0 :         torture_assert_ntstatus_ok(tctx, status, "NetShareDel on share 'testshare502' failed");
     730           0 :         torture_assert_werr_ok(tctx, a.out.result, "NetShareDel on share 'testshare502' failed");
     731             : 
     732           0 :         return true;
     733             : }
     734             : 
     735             : /**************************/
     736             : /* srvsvc_NetShare        */
     737             : /**************************/
     738          14 : static bool test_NetShareEnumAll(struct torture_context *tctx, 
     739             :                                  struct dcerpc_pipe *p, 
     740             :                                  bool admin)
     741             : {
     742             :         NTSTATUS status;
     743             :         struct srvsvc_NetShareEnumAll r;
     744             :         struct srvsvc_NetShareInfoCtr info_ctr;
     745             :         struct srvsvc_NetShareCtr0 c0;
     746             :         struct srvsvc_NetShareCtr1 c1;
     747             :         struct srvsvc_NetShareCtr2 c2;
     748             :         struct srvsvc_NetShareCtr501 c501;
     749             :         struct srvsvc_NetShareCtr502 c502;
     750          14 :         uint32_t totalentries = 0;
     751             :         struct {
     752             :                 uint32_t level;
     753             :                 WERROR anon_status;
     754             :                 WERROR admin_status;
     755          14 :         } levels[] = {
     756             :                  { 0,   WERR_OK,                WERR_OK },
     757             :                  { 1,   WERR_OK,                WERR_OK },
     758             :                  { 2,   WERR_ACCESS_DENIED,     WERR_OK },
     759             :                  { 501, WERR_ACCESS_DENIED,     WERR_OK },
     760             :                  { 502, WERR_ACCESS_DENIED,     WERR_OK },
     761             :         };
     762             :         int i;
     763             :         uint32_t resume_handle;
     764          14 :         struct dcerpc_binding_handle *b = p->binding_handle;
     765             : 
     766          14 :         ZERO_STRUCT(info_ctr);
     767             : 
     768          14 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
     769          14 :         r.in.info_ctr = &info_ctr;
     770          14 :         r.in.max_buffer = (uint32_t)-1;
     771          14 :         r.in.resume_handle = &resume_handle;
     772          14 :         r.out.resume_handle = &resume_handle;
     773          14 :         r.out.totalentries = &totalentries;
     774          14 :         r.out.info_ctr = &info_ctr;
     775             : 
     776          60 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     777             : 
     778             :                 int j;
     779             :                 WERROR expected;
     780             : 
     781          54 :                 info_ctr.level = levels[i].level;
     782             : 
     783          54 :                 switch (info_ctr.level) {
     784          14 :                 case 0:
     785          14 :                         ZERO_STRUCT(c0);
     786          14 :                         info_ctr.ctr.ctr0 = &c0;
     787          14 :                         break;
     788          14 :                 case 1:
     789          14 :                         ZERO_STRUCT(c1);
     790          14 :                         info_ctr.ctr.ctr1 = &c1;
     791          14 :                         break;
     792          14 :                 case 2:
     793          14 :                         ZERO_STRUCT(c2);
     794          14 :                         info_ctr.ctr.ctr2 = &c2;
     795          14 :                         break;
     796           6 :                 case 501:
     797           6 :                         ZERO_STRUCT(c501);
     798           6 :                         info_ctr.ctr.ctr501 = &c501;
     799           6 :                         break;
     800           6 :                 case 502:
     801           6 :                         ZERO_STRUCT(c502);
     802           6 :                         info_ctr.ctr.ctr502 = &c502;
     803           6 :                         break;
     804             :                 }
     805             : 
     806          54 :                 expected = levels[i].anon_status;
     807          54 :                 if (admin) expected = levels[i].admin_status;
     808             : 
     809          54 :                 resume_handle = 0;
     810             : 
     811          54 :                 torture_comment(tctx, "Testing NetShareEnumAll level %u\n", info_ctr.level);
     812          54 :                 status = dcerpc_srvsvc_NetShareEnumAll_r(b, tctx, &r);
     813          54 :                 torture_assert_ntstatus_ok(tctx, status, "NetShareEnumAll failed");
     814          54 :                 torture_assert_werr_equal(tctx, r.out.result, expected, "NetShareEnumAll failed");
     815             : 
     816             :                 /* call srvsvc_NetShareGetInfo for each returned share */
     817          50 :                 if (info_ctr.level == 2 && r.out.info_ctr->ctr.ctr2) {
     818          49 :                         for (j=0;j<r.out.info_ctr->ctr.ctr2->count;j++) {
     819             :                                 const char *name;
     820          43 :                                 name = r.out.info_ctr->ctr.ctr2->array[j].name;
     821          43 :                                 if (!test_NetShareGetInfo(tctx, p, name, admin)) {
     822           4 :                                         return false;
     823             :                                 }
     824             :                         }
     825             :                 }
     826             :         }
     827             : 
     828           6 :         return true;
     829             : }
     830             : 
     831           7 : static bool test_NetShareEnumAllFull(struct torture_context *tctx,
     832             :                               struct dcerpc_pipe *p)
     833             : {
     834           7 :         return test_NetShareEnumAll(tctx, p, true);
     835             : }
     836             : 
     837           7 : static bool test_NetShareEnumAllAnon(struct torture_context *tctx,
     838             :                               struct dcerpc_pipe *p)
     839             : {
     840           7 :         return test_NetShareEnumAll(tctx, p, false);
     841             : }
     842             : 
     843          14 : static bool test_NetShareEnum(struct torture_context *tctx,
     844             :                               struct dcerpc_pipe *p, bool admin)
     845             : {
     846             :         NTSTATUS status;
     847             :         struct srvsvc_NetShareEnum r;
     848             :         struct srvsvc_NetShareInfoCtr info_ctr;
     849             :         struct srvsvc_NetShareCtr0 c0;
     850             :         struct srvsvc_NetShareCtr1 c1;
     851             :         struct srvsvc_NetShareCtr2 c2;
     852             :         struct srvsvc_NetShareCtr501 c501;
     853             :         struct srvsvc_NetShareCtr502 c502;
     854          14 :         uint32_t totalentries = 0;
     855             :         struct {
     856             :                 uint32_t level;
     857             :                 WERROR anon_status;
     858             :                 WERROR admin_status;
     859          14 :         } levels[] = {
     860             :                  { 0,   WERR_OK,                WERR_OK },
     861             :                  { 1,   WERR_OK,                WERR_OK },
     862             :                  { 2,   WERR_ACCESS_DENIED,     WERR_OK },
     863             :                  { 501, WERR_INVALID_LEVEL,     WERR_INVALID_LEVEL },
     864             :                  { 502, WERR_ACCESS_DENIED,     WERR_OK },
     865             :         };
     866             :         int i;
     867          14 :         struct dcerpc_binding_handle *b = p->binding_handle;
     868             : 
     869          14 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
     870          14 :         r.in.info_ctr = &info_ctr;
     871          14 :         r.in.max_buffer = (uint32_t)-1;
     872          14 :         r.in.resume_handle = NULL;
     873          14 :         r.out.totalentries = &totalentries;
     874          14 :         r.out.info_ctr = &info_ctr;
     875             : 
     876          64 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     877             :                 WERROR expected;
     878             : 
     879          58 :                 info_ctr.level = levels[i].level;
     880             : 
     881          58 :                 switch (info_ctr.level) {
     882          14 :                 case 0:
     883          14 :                         ZERO_STRUCT(c0);
     884          14 :                         info_ctr.ctr.ctr0 = &c0;
     885          14 :                         break;
     886          14 :                 case 1:
     887          14 :                         ZERO_STRUCT(c1);
     888          14 :                         info_ctr.ctr.ctr1 = &c1;
     889          14 :                         break;
     890          14 :                 case 2:
     891          14 :                         ZERO_STRUCT(c2);
     892          14 :                         info_ctr.ctr.ctr2 = &c2;
     893          14 :                         break;
     894          10 :                 case 501:
     895          10 :                         ZERO_STRUCT(c501);
     896          10 :                         info_ctr.ctr.ctr501 = &c501;
     897          10 :                         break;
     898           6 :                 case 502:
     899           6 :                         ZERO_STRUCT(c502);
     900           6 :                         info_ctr.ctr.ctr502 = &c502;
     901           6 :                         break;
     902             :                 }
     903             : 
     904          58 :                 expected = levels[i].anon_status;
     905          58 :                 if (admin) expected = levels[i].admin_status;
     906             : 
     907          58 :                 torture_comment(tctx, "Testing NetShareEnum level %u\n", info_ctr.level);
     908          58 :                 status = dcerpc_srvsvc_NetShareEnum_r(b, tctx, &r);
     909          58 :                 torture_assert_ntstatus_ok(tctx, status, "NetShareEnum failed");
     910          58 :                 torture_assert_werr_equal(tctx, r.out.result, expected, "NetShareEnum failed");
     911             :         }
     912             : 
     913           6 :         return true;
     914             : }
     915             : 
     916           7 : static bool test_NetShareEnumFull(struct torture_context *tctx,
     917             :                                   struct dcerpc_pipe *p)
     918             : {
     919           7 :         return test_NetShareEnum(tctx, p, true);
     920             : }
     921             : 
     922           7 : static bool test_NetShareEnumAnon(struct torture_context *tctx,
     923             :                                   struct dcerpc_pipe *p)
     924             : {
     925           7 :         return test_NetShareEnum(tctx, p, false);
     926             : }
     927             : 
     928             : /**************************/
     929             : /* srvsvc_NetSrv          */
     930             : /**************************/
     931           7 : static bool test_NetSrvGetInfo(struct torture_context *tctx, 
     932             :                                struct dcerpc_pipe *p)
     933             : {
     934             :         NTSTATUS status;
     935             :         struct srvsvc_NetSrvGetInfo r;
     936             :         union srvsvc_NetSrvInfo info;
     937           7 :         uint32_t levels[] = {100, 101, 102, 502, 503};
     938             :         int i;
     939           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
     940             : 
     941           7 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
     942             : 
     943          42 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     944          35 :                 r.in.level = levels[i];
     945          35 :                 r.out.info = &info;
     946          35 :                 torture_comment(tctx, "Testing NetSrvGetInfo level %u\n", r.in.level);
     947          35 :                 status = dcerpc_srvsvc_NetSrvGetInfo_r(b, tctx, &r);
     948          35 :                 torture_assert_ntstatus_ok(tctx, status, "NetSrvGetInfo failed");
     949          35 :                 if (!W_ERROR_IS_OK(r.out.result)) {
     950          14 :                         torture_comment(tctx, "NetSrvGetInfo failed: %s\n", win_errstr(r.out.result));
     951             :                 }
     952             :         }
     953             : 
     954           7 :         return true;
     955             : }
     956             : 
     957             : /**************************/
     958             : /* srvsvc_NetDisk         */
     959             : /**************************/
     960           7 : static bool test_NetDiskEnum(struct torture_context *tctx, 
     961             :                              struct dcerpc_pipe *p)
     962             : {
     963             :         NTSTATUS status;
     964             :         struct srvsvc_NetDiskEnum r;
     965             :         struct srvsvc_NetDiskInfo info;
     966           7 :         uint32_t totalentries = 0;
     967           7 :         uint32_t levels[] = {0};
     968             :         int i;
     969           7 :         uint32_t resume_handle=0;
     970           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
     971             : 
     972           7 :         ZERO_STRUCT(info);
     973           7 :         ZERO_STRUCT(r);
     974             : 
     975           7 :         r.in.server_unc = NULL;
     976           7 :         r.in.resume_handle = &resume_handle;
     977           7 :         r.in.info = &info;
     978           7 :         r.out.info = &info;
     979           7 :         r.out.totalentries = &totalentries;
     980           7 :         r.out.resume_handle = &resume_handle;
     981             : 
     982          14 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
     983           7 :                 ZERO_STRUCTP(r.out.info);
     984           7 :                 r.in.level = levels[i];
     985           7 :                 torture_comment(tctx, "Testing NetDiskEnum level %u\n", r.in.level);
     986           7 :                 status = dcerpc_srvsvc_NetDiskEnum_r(b, tctx, &r);
     987           7 :                 torture_assert_ntstatus_ok(tctx, status, "NetDiskEnum failed");
     988           7 :                 torture_assert_werr_ok(tctx, r.out.result, "NetDiskEnum failed");
     989             :         }
     990             : 
     991           7 :         return true;
     992             : }
     993             : 
     994             : /**************************/
     995             : /* srvsvc_NetTransport    */
     996             : /**************************/
     997           7 : static bool test_NetTransportEnum(struct torture_context *tctx, 
     998             :                                   struct dcerpc_pipe *p)
     999             : {
    1000             :         NTSTATUS status;
    1001             :         struct srvsvc_NetTransportEnum r;
    1002             :         struct srvsvc_NetTransportInfoCtr transports;
    1003             :         struct srvsvc_NetTransportCtr0 ctr0;
    1004             :         struct srvsvc_NetTransportCtr1 ctr1;
    1005             : 
    1006           7 :         uint32_t totalentries = 0;
    1007           7 :         uint32_t levels[] = {0, 1};
    1008             :         int i;
    1009           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
    1010             : 
    1011           7 :         ZERO_STRUCT(transports);
    1012             : 
    1013           7 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s", dcerpc_server_name(p));
    1014           7 :         r.in.transports = &transports;
    1015           7 :         r.in.max_buffer = (uint32_t)-1;
    1016           7 :         r.in.resume_handle = NULL;
    1017           7 :         r.out.totalentries = &totalentries;
    1018           7 :         r.out.transports = &transports;
    1019             : 
    1020          13 :         for (i=0;i<ARRAY_SIZE(levels);i++) {
    1021          10 :                 transports.level = levels[i];
    1022          10 :                 switch (transports.level) {
    1023           7 :                 case 0:
    1024           7 :                         ZERO_STRUCT(ctr0);
    1025           7 :                         transports.ctr.ctr0 = &ctr0;
    1026           7 :                         break;
    1027           3 :                 case 1:
    1028           3 :                         ZERO_STRUCT(ctr1);
    1029           3 :                         transports.ctr.ctr1 = &ctr1;
    1030           3 :                         break;
    1031             :                 }
    1032          10 :                 torture_comment(tctx, "Testing NetTransportEnum level %u\n", transports.level);
    1033          10 :                 status = dcerpc_srvsvc_NetTransportEnum_r(b, tctx, &r);
    1034          10 :                 torture_assert_ntstatus_ok(tctx, status, "NetTransportEnum failed");
    1035           6 :                 if (!W_ERROR_IS_OK(r.out.result)) {
    1036           6 :                         torture_comment(tctx, "unexpected result: %s\n", win_errstr(r.out.result));
    1037             :                 }
    1038             :         }
    1039             : 
    1040           3 :         return true;
    1041             : }
    1042             : 
    1043             : /**************************/
    1044             : /* srvsvc_NetRemoteTOD    */
    1045             : /**************************/
    1046           7 : static bool test_NetRemoteTOD(struct torture_context *tctx, 
    1047             :                               struct dcerpc_pipe *p)
    1048             : {
    1049             :         NTSTATUS status;
    1050             :         struct srvsvc_NetRemoteTOD r;
    1051           7 :         struct srvsvc_NetRemoteTODInfo *info = NULL;
    1052           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
    1053             : 
    1054           7 :         r.in.server_unc = talloc_asprintf(tctx,"\\\\%s",dcerpc_server_name(p));
    1055           7 :         r.out.info = &info;
    1056             : 
    1057           7 :         torture_comment(tctx, "Testing NetRemoteTOD\n");
    1058           7 :         status = dcerpc_srvsvc_NetRemoteTOD_r(b, tctx, &r);
    1059           7 :         torture_assert_ntstatus_ok(tctx, status, "NetRemoteTOD failed");
    1060           7 :         torture_assert_werr_ok(tctx, r.out.result, "NetRemoteTOD failed");
    1061             : 
    1062           7 :         return true;
    1063             : }
    1064             : 
    1065             : /**************************/
    1066             : /* srvsvc_NetName         */
    1067             : /**************************/
    1068             : 
    1069           7 : static bool test_NetNameValidate(struct torture_context *tctx, 
    1070             :                                                                  struct dcerpc_pipe *p)
    1071             : {
    1072             :         NTSTATUS status;
    1073             :         struct srvsvc_NetNameValidate r;
    1074             :         char *invalidc;
    1075             :         char *name;
    1076             :         int i, n, min, max;
    1077           7 :         struct dcerpc_binding_handle *b = p->binding_handle;
    1078             : 
    1079           7 :         r.in.server_unc = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
    1080           7 :         r.in.flags = 0x0;
    1081             : 
    1082           7 :         d_printf("Testing NetNameValidate\n");
    1083             : 
    1084             :         /* valid path types only between 1 and 13 */
    1085          98 :         for (i = 1; i < 14; i++) {
    1086             : 
    1087          91 : again:
    1088             :                 /* let's limit ourselves to a maximum of 4096 bytes */
    1089         182 :                 r.in.name = name = talloc_array(tctx, char, 4097);
    1090         182 :                 max = 4096;
    1091         182 :                 min = 0;
    1092         182 :                 n = max;
    1093             : 
    1094             :                 while (1) {
    1095             : 
    1096             :                         /* Find maximum length accepted by this type */
    1097        4082 :                         ZERO_STRUCT(r.out);
    1098        2444 :                         r.in.name_type = i;
    1099        2444 :                         memset(name, 'A', n);
    1100        2444 :                         name[n] = '\0';
    1101             : 
    1102        2444 :                         status = dcerpc_srvsvc_NetNameValidate_r(b, tctx, &r);
    1103        2444 :                         if (!NT_STATUS_IS_OK(status)) {
    1104           0 :                                 d_printf("NetNameValidate failed while checking maximum size (%s)\n",
    1105             :                                                 nt_errstr(status));
    1106           0 :                                 break;
    1107             :                         }
    1108             : 
    1109        2444 :                         if (W_ERROR_IS_OK(r.out.result)) {
    1110          26 :                                 min = n;
    1111          26 :                                 n += (max - min + 1)/2;
    1112          26 :                                 if (n == min) {
    1113             :                                         /*
    1114             :                                          * We did not move, so
    1115             :                                          * do not loop forever
    1116             :                                          */
    1117           8 :                                         break;
    1118             :                                 }
    1119          18 :                                 continue;
    1120             :                                 
    1121             :                         } else {
    1122        2418 :                                 if ((min + 1) >= max) break; /* found it */
    1123             :                                 
    1124        2244 :                                 max = n;
    1125        2244 :                                 n -= (max - min)/2;
    1126        2244 :                                 continue;
    1127             :                         }
    1128             :                 }
    1129             : 
    1130         182 :                 talloc_free(name);
    1131             : 
    1132         182 :                 d_printf("Maximum length for type %2d, flags %08x: %d\n", i, r.in.flags, max);
    1133             : 
    1134             :                 /* find invalid chars for this type check only ASCII between 0x20 and 0x7e */
    1135             : 
    1136         182 :                 invalidc = talloc_strdup(tctx, "");
    1137             : 
    1138       17290 :                 for (n = 0x20; n < 0x7e; n++) {
    1139       17108 :                         r.in.name = name = talloc_asprintf(tctx, "%c", (char)n);
    1140             : 
    1141       17108 :                         status = dcerpc_srvsvc_NetNameValidate_r(b, tctx, &r);
    1142       17108 :                         if (!NT_STATUS_IS_OK(status)) {
    1143           0 :                                 d_printf("NetNameValidate failed while checking valid chars (%s)\n",
    1144             :                                                 nt_errstr(status));
    1145           0 :                                 break;
    1146             :                         }
    1147             : 
    1148       17108 :                         if (!W_ERROR_IS_OK(r.out.result)) {
    1149       16006 :                                 invalidc = talloc_asprintf_append_buffer(invalidc, "%c", (char)n);
    1150             :                         }
    1151             : 
    1152       17108 :                         talloc_free(name);
    1153             :                 }
    1154             : 
    1155         182 :                 d_printf(" Invalid chars for type %2d, flags %08x: \"%s\"\n", i, r.in.flags, invalidc);
    1156             : 
    1157             :                 /* only two values are accepted for flags: 0x0 and 0x80000000 */
    1158         182 :                 if (r.in.flags == 0x0) {
    1159          91 :                         r.in.flags = 0x80000000;
    1160          91 :                         goto again;
    1161             :                 }
    1162             : 
    1163          91 :                 r.in.flags = 0x0;
    1164             :         }
    1165             : 
    1166           7 :         return true;
    1167             : }
    1168             : 
    1169        2355 : struct torture_suite *torture_rpc_srvsvc(TALLOC_CTX *mem_ctx)
    1170             : {
    1171        2355 :         struct torture_suite *suite = torture_suite_create(mem_ctx, "srvsvc");
    1172             :         struct torture_rpc_tcase *tcase;
    1173             :         struct torture_test *test;
    1174             : 
    1175        2355 :         tcase = torture_suite_add_rpc_iface_tcase(suite, "srvsvc (admin access)", &ndr_table_srvsvc);
    1176             : 
    1177        2355 :         torture_rpc_tcase_add_test(tcase, "NetCharDevEnum", test_NetCharDevEnum);
    1178        2355 :         torture_rpc_tcase_add_test(tcase, "NetCharDevQEnum", test_NetCharDevQEnum);
    1179        2355 :         torture_rpc_tcase_add_test(tcase, "NetConnEnum", test_NetConnEnum);
    1180        2355 :         torture_rpc_tcase_add_test(tcase, "NetFileEnum", test_NetFileEnum);
    1181        2355 :         torture_rpc_tcase_add_test(tcase, "NetSessEnum", test_NetSessEnum);
    1182        2355 :         torture_rpc_tcase_add_test(tcase, "NetShareEnumAll", test_NetShareEnumAllFull);
    1183        2355 :         torture_rpc_tcase_add_test(tcase, "NetSrvGetInfo", test_NetSrvGetInfo);
    1184        2355 :         torture_rpc_tcase_add_test(tcase, "NetDiskEnum", test_NetDiskEnum);
    1185        2355 :         torture_rpc_tcase_add_test(tcase, "NetTransportEnum", test_NetTransportEnum);
    1186        2355 :         torture_rpc_tcase_add_test(tcase, "NetRemoteTOD", test_NetRemoteTOD);
    1187        2355 :         torture_rpc_tcase_add_test(tcase, "NetShareEnum", test_NetShareEnumFull);
    1188        2355 :         torture_rpc_tcase_add_test(tcase, "NetShareGetInfo", test_NetShareGetInfoAdminFull);
    1189        2355 :         test = torture_rpc_tcase_add_test(tcase, "NetShareAddSetDel", 
    1190             :                                            test_NetShareAddSetDel);
    1191        2355 :         test->dangerous = true;
    1192        2355 :         torture_rpc_tcase_add_test(tcase, "NetNameValidate", test_NetNameValidate);
    1193             :         
    1194        2355 :         tcase = torture_suite_add_anon_rpc_iface_tcase(suite, 
    1195             :                                                     "srvsvc anonymous access", 
    1196             :                                                     &ndr_table_srvsvc);
    1197             : 
    1198        2355 :         torture_rpc_tcase_add_test(tcase, "NetShareEnumAll", 
    1199             :                                    test_NetShareEnumAllAnon);
    1200        2355 :         torture_rpc_tcase_add_test(tcase, "NetShareEnum", 
    1201             :                                    test_NetShareEnumAnon);
    1202        2355 :         torture_rpc_tcase_add_test(tcase, "NetShareGetInfo", 
    1203             :                                    test_NetShareGetInfoAdminAnon);
    1204             : 
    1205        2355 :         return suite;
    1206             : }

Generated by: LCOV version 1.13