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/torture/scanner.c

    r414 r745  
    33   SMB torture tester - scanning functions
    44   Copyright (C) Andrew Tridgell 2001
    5    
     5
    66   This program is free software; you can redistribute it and/or modify
    77   it under the terms of the GNU General Public License as published by
    88   the Free Software Foundation; either version 3 of the License, or
    99   (at your option) any later version.
    10    
     10
    1111   This program is distributed in the hope that it will be useful,
    1212   but WITHOUT ANY WARRANTY; without even the implied warranty of
    1313   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    1414   GNU General Public License for more details.
    15    
     15
    1616   You should have received a copy of the GNU General Public License
    1717   along with this program.  If not, see <http://www.gnu.org/licenses/>.
     
    1919
    2020#include "includes.h"
     21#include "system/filesys.h"
     22#include "torture/proto.h"
     23#include "libsmb/libsmb.h"
    2124
    2225#define VERBOSE 0
     
    5053static NTSTATUS try_trans2(struct cli_state *cli,
    5154                         int op,
    52                          char *param, char *data,
    53                          int param_len, int data_len,
    54                          unsigned int *rparam_len, unsigned int *rdata_len)
    55 {
    56         uint16 setup = op;
    57         char *rparam=NULL, *rdata=NULL;
    58 
    59         if (!cli_send_trans(cli, SMBtrans2,
    60                             NULL,                           /* name */
    61                             -1, 0,                          /* fid, flags */
    62                             &setup, 1, 0,                   /* setup, length, max */
    63                             param, param_len, 2,            /* param, length, max */
    64                             data, data_len, cli->max_xmit   /* data, length, max */
    65                            )) {
    66                 return cli_nt_error(cli);
    67         }
    68 
    69         cli_receive_trans(cli, SMBtrans2,
    70                            &rparam, rparam_len,
    71                            &rdata, rdata_len);
    72 
    73         SAFE_FREE(rdata);
    74         SAFE_FREE(rparam);
    75 
    76         return cli_nt_error(cli);
     55                         uint8_t *param, uint8_t *data,
     56                         uint32_t param_len, uint32_t data_len,
     57                         uint32_t *rparam_len, uint32_t *rdata_len)
     58{
     59        uint16_t setup[1];
     60        uint8_t *rparam=NULL, *rdata=NULL;
     61        NTSTATUS status;
     62
     63        SSVAL(setup+0, 0, op);
     64
     65        status = cli_trans(talloc_tos(), cli, SMBtrans2,
     66                           NULL, -1, /* name, fid */
     67                           op, 0,
     68                           NULL, 0, 0, /* setup */
     69                           param, param_len, 2,
     70                           data, data_len, cli->max_xmit,
     71                           NULL,                /* recv_flags2 */
     72                           NULL, 0, NULL,       /* rsetup */
     73                           &rparam, 0, rparam_len,
     74                           &rdata, 0, rdata_len);
     75
     76        TALLOC_FREE(rdata);
     77        TALLOC_FREE(rparam);
     78
     79        return status;
    7780}
    7881
     
    8184                             const char *format,
    8285                             int op, int level,
    83                              char *param, char *data,
    84                              int param_len, int *data_len,
    85                              unsigned int *rparam_len, unsigned int *rdata_len)
     86                             uint8_t *param, uint8_t *data,
     87                             uint32_t param_len, uint32_t *data_len,
     88                             uint32_t *rparam_len, uint32_t *rdata_len)
    8689{
    8790        NTSTATUS ret=NT_STATUS_OK;
     
    116119                        int fnum, int dnum, const char *fname)
    117120{
    118         int data_len = 0;
    119         int param_len = 0;
    120         unsigned int rparam_len, rdata_len;
    121         char param[PARAM_SIZE], data[DATA_SIZE];
     121        uint32_t data_len = 0;
     122        uint32_t param_len = 0;
     123        uint32_t rparam_len, rdata_len;
     124        uint8_t param[PARAM_SIZE], data[DATA_SIZE];
    122125        NTSTATUS status;
    123126
     
    171174        status = try_trans2_len(cli, "newfile", op, level, param, data, param_len, &data_len,
    172175                                &rparam_len, &rdata_len);
    173         cli_unlink(cli, "\\newfile.dat", aSYSTEM | aHIDDEN);
     176        cli_unlink(cli, "\\newfile.dat", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
    174177        cli_rmdir(cli, "\\newfile.dat");
    175178        if (NT_STATUS_IS_OK(status)) return True;
     
    259262****************************************************************************/
    260263static NTSTATUS try_nttrans(struct cli_state *cli,
    261                          int op,
    262                          char *param, char *data,
    263                          int param_len, int data_len,
    264                          unsigned int *rparam_len, unsigned int *rdata_len)
    265 {
    266         char *rparam=NULL, *rdata=NULL;
    267 
    268         if (!cli_send_nt_trans(cli, op,
    269                                0,   
    270                                NULL, 0, 0,
    271                                param, param_len, 2,            /* param, length, max */
    272                                data, data_len, cli->max_xmit   /* data, length, max */
    273                            )) {
    274                 return cli_nt_error(cli);
    275         }
    276 
    277         cli_receive_nt_trans(cli,
    278                              &rparam, rparam_len,
    279                              &rdata, rdata_len);
    280 
     264                            int op,
     265                            uint8_t *param, uint8_t *data,
     266                            int32_t param_len, uint32_t data_len,
     267                            uint32_t *rparam_len,
     268                            uint32_t *rdata_len)
     269{
     270        uint8_t *rparam=NULL, *rdata=NULL;
     271        NTSTATUS status;
     272
     273        status = cli_trans(talloc_tos(), cli, SMBnttrans,
     274                           NULL, -1, /* name, fid */
     275                           op, 0,
     276                           NULL, 0, 0, /* setup */
     277                           param, param_len, 2,
     278                           data, data_len, cli->max_xmit,
     279                           NULL,                /* recv_flags2 */
     280                           NULL, 0, NULL,       /* rsetup */
     281                           &rparam, 0, rparam_len,
     282                           &rdata, 0, rdata_len);
    281283        SAFE_FREE(rdata);
    282284        SAFE_FREE(rparam);
    283285
    284         return cli_nt_error(cli);
     286        return status;
    285287}
    286288
     
    289291                             const char *format,
    290292                             int op, int level,
    291                              char *param, char *data,
    292                              int param_len, int *data_len,
    293                              unsigned int *rparam_len, unsigned int *rdata_len)
     293                             uint8_t *param, uint8_t *data,
     294                             int param_len, uint32_t *data_len,
     295                             uint32_t *rparam_len, uint32_t *rdata_len)
    294296{
    295297        NTSTATUS ret=NT_STATUS_OK;
     
    324326                        int fnum, int dnum, const char *fname)
    325327{
    326         int data_len = 0;
    327         int param_len = 0;
    328         unsigned int rparam_len, rdata_len;
    329         char param[PARAM_SIZE], data[DATA_SIZE];
     328        uint32_t data_len = 0;
     329        uint32_t param_len = 0;
     330        uint32_t rparam_len, rdata_len;
     331        uint8_t param[PARAM_SIZE], data[DATA_SIZE];
    330332        NTSTATUS status;
    331333
     
    379381        status = try_nttrans_len(cli, "newfile", op, level, param, data, param_len, &data_len,
    380382                                &rparam_len, &rdata_len);
    381         cli_unlink(cli, "\\newfile.dat", aSYSTEM | aHIDDEN);
     383        cli_unlink(cli, "\\newfile.dat", FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
    382384        cli_rmdir(cli, "\\newfile.dat");
    383385        if (NT_STATUS_IS_OK(status)) return True;
Note: See TracChangeset for help on using the changeset viewer.