Ignore:
Timestamp:
Nov 24, 2016, 1:14:11 PM (9 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to version 4.4.3

File:
1 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/source3/client/client.c

    r860 r988  
    2727#include "rpc_client/cli_pipe.h"
    2828#include "client/client_proto.h"
     29#include "client/clitar_proto.h"
    2930#include "../librpc/gen_ndr/ndr_srvsvc_c.h"
    3031#include "../lib/util/select.h"
    … …  
    3738#include "trans2.h"
    3839#include "libsmb/nmblib.h"
     40#include "include/ntioctl.h"
     41#include "../libcli/smb/smbXcli_base.h"
    3942
    4043#ifndef REGISTER
    … …  
    4548
    4649extern bool override_logfile;
    47 extern char tar_type;
    4850
    4951static int port = 0;
    5052static char *service;
    5153static char *desthost;
    52 static char *calling_name;
    5354static bool grepable = false;
    5455static char *cmdstr = NULL;
    5556const char *cmd_ptr = NULL;
    5657
    57 static int io_bufsize = 524288;
     58static int io_bufsize = 0; /* we use the default size */
     59static int io_timeout = (CLIENT_TIMEOUT/1000); /* Per operation timeout (in seconds). */
    5860
    5961static int name_type = 0x20;
    60 static int max_protocol = PROTOCOL_NT1;
     62static int max_protocol = -1;
    6163
    6264static int process_tok(char *tok);
    … …  
    6567#define CREATE_ACCESS_READ READ_CONTROL_ACCESS
    6668
    67 /* 30 second timeout on most commands */
    68 #define CLIENT_TIMEOUT (30*1000)
    69 #define SHORT_TIMEOUT (5*1000)
    70 
    7169/* value for unused fid field in trans2 secondary request */
    7270#define FID_UNUSED (0xFFFF)
    … …  
    7775static bool translation = false;
    7876static bool have_ip;
    79 
    80 /* clitar bits insert */
    81 extern int blocksize;
    82 extern bool tar_inc;
    83 extern bool tar_reset;
    84 /* clitar bits end */
    8577
    8678static bool prompt = true;
    … …  
    8981static bool showacls = false;
    9082bool lowercase = false;
     83static bool backup_intent = false;
    9184
    9285static struct sockaddr_storage dest_ss;
    … …  
    234227
    235228        i = 0;
    236         while (i < (n - 1) && (i < BUFFER_SIZE)) {
     229        while (i < (n - 1)) {
    237230                if ((c = x_getc(f)) == EOF) {
    238231                        break;
    … …  
    251244struct push_state {
    252245        XFILE *f;
    253         SMB_OFF_T nread;
     246        off_t nread;
    254247};
    255248
    … …  
    306299static int do_dskattr(void)
    307300{
    308         int total, bsize, avail;
     301        uint64_t total, bsize, avail;
    309302        struct cli_state *targetcli = NULL;
    310303        char *targetpath = NULL;
    … …  
    312305        NTSTATUS status;
    313306
    314         if ( !cli_resolve_path(ctx, "", auth_info, cli, client_get_cur_dir(), &targetcli, &targetpath)) {
    315                 d_printf("Error in dskattr: %s\n", cli_errstr(cli));
    316                 return 1;
    317         }
    318 
    319         status = cli_dskattr(targetcli, &bsize, &total, &avail);
     307        status = cli_resolve_path(ctx, "", auth_info, cli,
     308                                  client_get_cur_dir(), &targetcli,
     309                                  &targetpath);
    320310        if (!NT_STATUS_IS_OK(status)) {
    321311                d_printf("Error in dskattr: %s\n", nt_errstr(status));
    … …  
    323313        }
    324314
    325         d_printf("\n\t\t%d blocks of size %d. %d blocks available\n",
    326                  total, bsize, avail);
     315        status = cli_disk_size(targetcli, targetpath, &bsize, &total, &avail);
     316        if (!NT_STATUS_IS_OK(status)) {
     317                d_printf("Error in dskattr: %s\n", nt_errstr(status));
     318                return 1;
     319        }
     320
     321        d_printf("\n\t\t%" PRIu64
     322                " blocks of size %" PRIu64
     323                ". %" PRIu64 " blocks available\n",
     324                total, bsize, avail);
    327325
    328326        return 0;
    … …  
    363361        struct cli_state *targetcli = NULL;
    364362        SMB_STRUCT_STAT sbuf;
    365         uint32 attributes;
     363        uint32_t attributes;
    366364        int ret = 1;
    367365        TALLOC_CTX *ctx = talloc_stackframe();
     366        NTSTATUS status;
    368367
    369368        newdir = talloc_strdup(ctx, new_dir);
    … …  
    407406        client_set_cur_dir(new_cd);
    408407
    409         if ( !cli_resolve_path(ctx, "", auth_info, cli, new_cd, &targetcli, &targetpath)) {
    410                 d_printf("cd %s: %s\n", new_cd, cli_errstr(cli));
     408        status = cli_resolve_path(ctx, "", auth_info, cli, new_cd,
     409                                  &targetcli, &targetpath);
     410        if (!NT_STATUS_IS_OK(status)) {
     411                d_printf("cd %s: %s\n", new_cd, nt_errstr(status));
    411412                client_set_cur_dir(saved_dir);
    412413                goto out;
    … …  
    421422           Except Win9x doesn't support the qpathinfo_basic() call..... */
    422423
    423         if (targetcli->protocol > PROTOCOL_LANMAN2 && !targetcli->win95) {
    424                 NTSTATUS status;
     424        if (smbXcli_conn_protocol(targetcli->conn) > PROTOCOL_LANMAN2 && !targetcli->win95) {
    425425
    426426                status = cli_qpathinfo_basic(targetcli, targetpath, &sbuf,
    … …  
    438438                }
    439439        } else {
    440                 NTSTATUS status;
    441440
    442441                targetpath = talloc_asprintf(ctx,
    … …  
    549548                d_printf("  %-30s%7.7s %8.0f  %s",
    550549                         finfo->name,
    551                          attrib_string(finfo->mode),
     550                         attrib_string(talloc_tos(), finfo->mode),
    552551                        (double)finfo->size,
    553552                        time_to_asc(t));
    … …  
    571570                /* print file meta date header */
    572571                d_printf( "FILENAME:%s\n", finfo->name);
    573                 d_printf( "MODE:%s\n", attrib_string(finfo->mode));
     572                d_printf( "MODE:%s\n", attrib_string(talloc_tos(), finfo->mode));
    574573                d_printf( "SIZE:%.0f\n", (double)finfo->size);
    575574                d_printf( "MTIME:%s", time_to_asc(t));
    … …  
    577576                                      CREATE_ACCESS_READ, 0,
    578577                                      FILE_SHARE_READ|FILE_SHARE_WRITE,
    579                                       FILE_OPEN, 0x0, 0x0, &fnum);
     578                                      FILE_OPEN, 0x0, 0x0, &fnum, NULL);
    580579                if (!NT_STATUS_IS_OK(status)) {
    581580                        DEBUG( 0, ("display_finfo() Failed to open %s: %s\n",
    … …  
    583582                } else {
    584583                        struct security_descriptor *sd = NULL;
    585                         sd = cli_query_secdesc(cli_state, fnum, ctx);
    586                         if (!sd) {
     584                        status = cli_query_secdesc(cli_state, fnum,
     585                                                   ctx, &sd);
     586                        if (!NT_STATUS_IS_OK(status)) {
    587587                                DEBUG( 0, ("display_finfo() failed to "
    588                                         "get security descriptor: %s",
    589                                         cli_errstr(cli_state)));
    590                                 status = cli_nt_error(cli_state);
     588                                           "get security descriptor: %s",
     589                                           nt_errstr(status)));
    591590                        } else {
    592591                                display_sec_desc(sd);
    … …  
    704703        }
    705704        if (do_list_queue) {
    706                 safe_strcpy_base(do_list_queue + do_list_queue_end,
     705                strlcpy_base(do_list_queue + do_list_queue_end,
    707706                                 entry, do_list_queue, do_list_queue_size);
    708707                do_list_queue_end = new_end;
    … …  
    815814
    816815NTSTATUS do_list(const char *mask,
    817                         uint16 attribute,
     816                        uint16_t attribute,
    818817                        NTSTATUS (*fn)(struct cli_state *cli_state, struct file_info *,
    819818                                   const char *dir),
    … …  
    859858                        /* check for dfs */
    860859
    861                         if ( !cli_resolve_path(ctx, "", auth_info, cli, head, &targetcli, &targetpath ) ) {
    862                                 d_printf("do_list: [%s] %s\n", head, cli_errstr(cli));
     860                        status = cli_resolve_path(ctx, "", auth_info, cli,
     861                                                  head, &targetcli,
     862                                                  &targetpath);
     863                        if (!NT_STATUS_IS_OK(status)) {
     864                                d_printf("do_list: [%s] %s\n", head,
     865                                         nt_errstr(status));
    863866                                remove_do_list_queue_head();
    864867                                continue;
    … …  
    898901        } else {
    899902                /* check for dfs */
    900                 if (cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetpath)) {
    901 
     903                status = cli_resolve_path(ctx, "", auth_info, cli, mask,
     904                                          &targetcli, &targetpath);
     905                if (NT_STATUS_IS_OK(status)) {
    902906                        status = cli_list(targetcli, targetpath, attribute,
    903907                                          do_list_helper, targetcli);
    … …  
    909913                        TALLOC_FREE(targetpath);
    910914                } else {
    911                         d_printf("do_list: [%s] %s\n", mask, cli_errstr(cli));
    912                         ret_status = cli_nt_error(cli);
     915                        d_printf("do_list: [%s] %s\n", mask, nt_errstr(status));
     916                        ret_status = status;
    913917                }
    914918        }
    … …  
    926930{
    927931        TALLOC_CTX *ctx = talloc_tos();
    928         uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
     932        uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
    929933        char *mask = NULL;
    930934        char *buf = NULL;
    … …  
    976980{
    977981        TALLOC_CTX *ctx = talloc_tos();
    978         uint16 attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
     982        uint16_t attribute = FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
    979983        char *mask = NULL;
    980984        char *buf = NULL;
    … …  
    10601064        bool newhandle = false;
    10611065        struct timespec tp_start;
    1062         uint16 attr;
    1063         SMB_OFF_T size;
     1066        uint16_t attr;
     1067        off_t size;
    10641068        off_t start = 0;
    1065         SMB_OFF_T nread = 0;
     1069        off_t nread = 0;
    10661070        int rc = 0;
    10671071        struct cli_state *targetcli = NULL;
    … …  
    10761080
    10771081        if (lowercase) {
    1078                 strlower_m(lname);
    1079         }
    1080 
    1081         if (!cli_resolve_path(ctx, "", auth_info, cli, rname, &targetcli, &targetname ) ) {
    1082                 d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
     1082                if (!strlower_m(lname)) {
     1083                        d_printf("strlower_m %s failed\n", lname);
     1084                        return 1;
     1085                }
     1086        }
     1087
     1088        status = cli_resolve_path(ctx, "", auth_info, cli, rname, &targetcli,
     1089                                  &targetname);
     1090        if (!NT_STATUS_IS_OK(status)) {
     1091                d_printf("Failed to open %s: %s\n", rname, nt_errstr(status));
    10831092                return 1;
    10841093        }
    … …  
    10971106        } else {
    10981107                if (reget) {
    1099                         handle = sys_open(lname, O_WRONLY|O_CREAT, 0644);
     1108                        handle = open(lname, O_WRONLY|O_CREAT, 0644);
    11001109                        if (handle >= 0) {
    1101                                 start = sys_lseek(handle, 0, SEEK_END);
     1110                                start = lseek(handle, 0, SEEK_END);
    11021111                                if (start == -1) {
    11031112                                        d_printf("Error seeking local file\n");
    … …  
    11061115                        }
    11071116                } else {
    1108                         handle = sys_open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
     1117                        handle = open(lname, O_WRONLY|O_CREAT|O_TRUNC, 0644);
    11091118                }
    11101119                newhandle = true;
    … …  
    11501159
    11511160        if (archive_level >= 2 && (attr & FILE_ATTRIBUTE_ARCHIVE)) {
    1152                 cli_setatr(cli, rname, attr & ~(uint16)FILE_ATTRIBUTE_ARCHIVE, 0);
     1161                cli_setatr(cli, rname, attr & ~(uint16_t)FILE_ATTRIBUTE_ARCHIVE, 0);
    11531162        }
    11541163
    … …  
    12841293        string_replace(finfo->name,'\\','/');
    12851294        if (lowercase) {
    1286                 strlower_m(finfo->name);
     1295                if (!strlower_m(finfo->name)) {
     1296                        return NT_STATUS_INVALID_PARAMETER;
     1297                }
    12871298        }
    12881299
    … …  
    13481359        int fd;
    13491360        int rc = 0;
     1361        mode_t mask;
    13501362
    13511363        rname = talloc_strdup(ctx, client_get_cur_dir());
    … …  
    13581370                return 1;
    13591371        }
     1372        mask = umask(S_IRWXO | S_IRWXG);
    13601373        fd = mkstemp(lname);
     1374        umask(mask);
    13611375        if (fd == -1) {
    13621376                d_printf("failed to create temporary file for more\n");
    … …  
    14061420{
    14071421        TALLOC_CTX *ctx = talloc_tos();
    1408         uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
     1422        uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
    14091423        char *mget_mask = NULL;
    14101424        char *buf = NULL;
    … …  
    14701484        NTSTATUS status;
    14711485
    1472         if (!cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli, &targetname)) {
    1473                 d_printf("mkdir %s: %s\n", name, cli_errstr(cli));
     1486        status = cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli,
     1487                                  &targetname);
     1488        if (!NT_STATUS_IS_OK(status)) {
     1489                d_printf("mkdir %s: %s\n", name, nt_errstr(status));
    14741490                return false;
    14751491        }
    … …  
    15261542        char *mask = NULL;
    15271543        char *buf = NULL;
     1544        NTSTATUS status;
    15281545
    15291546        mask = talloc_strdup(ctx, client_get_cur_dir());
    … …  
    15561573                }
    15571574
    1558                 if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
     1575                status = cli_resolve_path(ctx, "", auth_info, cli, mask,
     1576                                          &targetcli, &targetname);
     1577                if (!NT_STATUS_IS_OK(status)) {
    15591578                        return 1;
    15601579                }
    … …  
    16161635static char *attr_str(TALLOC_CTX *mem_ctx, uint16_t mode)
    16171636{
    1618         char *attrs = TALLOC_ZERO_ARRAY(mem_ctx, char, 17);
     1637        char *attrs = talloc_zero_array(mem_ctx, char, 17);
    16191638        int i = 0;
    16201639
    … …  
    16711690        fstring altname;
    16721691        struct timespec b_time, a_time, m_time, c_time;
    1673         SMB_OFF_T size;
     1692        off_t size;
    16741693        uint16_t mode;
    1675         SMB_INO_T ino;
    16761694        NTTIME tmp;
    16771695        uint16_t fnum;
    … …  
    16871705                d_printf("%s getting alt name for %s\n", nt_errstr(status),
    16881706                         name);
    1689                 return false;
     1707                /*
     1708                 * Ignore not supported or not implemented, it does not
     1709                 * hurt if we can't list alternate names.
     1710                 */
     1711                if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED) ||
     1712                    NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
     1713                        altname[0] = '\0';
     1714                } else {
     1715                        return false;
     1716                }
    16901717        }
    16911718        d_printf("altname: %s\n", altname);
    16921719
    1693         status = cli_qpathinfo2(cli, name, &b_time, &a_time, &m_time, &c_time,
    1694                                 &size, &mode, &ino);
     1720        status = cli_qpathinfo3(cli, name, &b_time, &a_time, &m_time, &c_time,
     1721                                &size, &mode, NULL);
    16951722        if (!NT_STATUS_IS_OK(status)) {
    16961723                d_printf("%s getting pathinfo for %s\n", nt_errstr(status),
    … …  
    16991726        }
    17001727
    1701         unix_timespec_to_nt_time(&tmp, b_time);
     1728        tmp = unix_timespec_to_nt_time(b_time);
    17021729        d_printf("create_time:    %s\n", nt_time_string(talloc_tos(), tmp));
    17031730
    1704         unix_timespec_to_nt_time(&tmp, a_time);
     1731        tmp = unix_timespec_to_nt_time(a_time);
    17051732        d_printf("access_time:    %s\n", nt_time_string(talloc_tos(), tmp));
    17061733
    1707         unix_timespec_to_nt_time(&tmp, m_time);
     1734        tmp = unix_timespec_to_nt_time(m_time);
    17081735        d_printf("write_time:     %s\n", nt_time_string(talloc_tos(), tmp));
    17091736
    1710         unix_timespec_to_nt_time(&tmp, c_time);
     1737        tmp = unix_timespec_to_nt_time(c_time);
    17111738        d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
    17121739
    … …  
    17241751                d_printf("stream: [%s], %lld bytes\n", streams[i].name,
    17251752                         (unsigned long long)streams[i].size);
     1753        }
     1754
     1755        if (mode & FILE_ATTRIBUTE_REPARSE_POINT) {
     1756                char *subst, *print;
     1757                uint32_t flags;
     1758
     1759                status = cli_readlink(cli, name, talloc_tos(), &subst, &print,
     1760                                      &flags);
     1761                if (!NT_STATUS_IS_OK(status)) {
     1762                        d_fprintf(stderr, "cli_readlink returned %s\n",
     1763                                  nt_errstr(status));
     1764                } else {
     1765                        d_printf("symlink: subst=[%s], print=[%s], flags=%x\n",
     1766                                 subst, print, flags);
     1767                        TALLOC_FREE(subst);
     1768                        TALLOC_FREE(print);
     1769                }
    17261770        }
    17271771
    … …  
    17311775                              FILE_SHARE_READ|FILE_SHARE_WRITE
    17321776                              |FILE_SHARE_DELETE,
    1733                               FILE_OPEN, 0x0, 0x0, &fnum);
     1777                              FILE_OPEN, 0x0, 0x0, &fnum, NULL);
    17341778        if (!NT_STATUS_IS_OK(status)) {
    17351779                /*
    … …  
    17521796                snap_name = talloc_asprintf(talloc_tos(), "%s%s",
    17531797                                            snapshots[i], name);
    1754                 status = cli_qpathinfo2(cli, snap_name, &b_time, &a_time,
     1798                status = cli_qpathinfo3(cli, snap_name, &b_time, &a_time,
    17551799                                        &m_time, &c_time, &size,
    17561800                                        NULL, NULL);
    … …  
    17611805                        continue;
    17621806                }
    1763                 unix_timespec_to_nt_time(&tmp, b_time);
     1807                tmp = unix_timespec_to_nt_time(b_time);
    17641808                d_printf("create_time:    %s\n", nt_time_string(talloc_tos(), tmp));
    1765                 unix_timespec_to_nt_time(&tmp, a_time);
     1809                tmp = unix_timespec_to_nt_time(a_time);
    17661810                d_printf("access_time:    %s\n", nt_time_string(talloc_tos(), tmp));
    1767                 unix_timespec_to_nt_time(&tmp, m_time);
     1811                tmp =unix_timespec_to_nt_time(m_time);
    17681812                d_printf("write_time:     %s\n", nt_time_string(talloc_tos(), tmp));
    1769                 unix_timespec_to_nt_time(&tmp, c_time);
     1813                tmp = unix_timespec_to_nt_time(c_time);
    17701814                d_printf("change_time:    %s\n", nt_time_string(talloc_tos(), tmp));
    17711815                d_printf("size: %d\n", (int)size);
    … …  
    17731817
    17741818        TALLOC_FREE(snapshots);
     1819        cli_close(cli, fnum);
    17751820
    17761821        return 0;
    … …  
    18151860        uint16_t fnum;
    18161861        XFILE *f;
    1817         SMB_OFF_T start = 0;
     1862        off_t start = 0;
    18181863        int rc = 0;
    18191864        struct timespec tp_start;
    … …  
    18231868        NTSTATUS status;
    18241869
    1825         if (!cli_resolve_path(ctx, "", auth_info, cli, rname, &targetcli, &targetname)) {
    1826                 d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli));
     1870        status = cli_resolve_path(ctx, "", auth_info, cli, rname,
     1871                                  &targetcli, &targetname);
     1872        if (!NT_STATUS_IS_OK(status)) {
     1873                d_printf("Failed to open %s: %s\n", rname, nt_errstr(status));
    18271874                return 1;
    18281875        }
    … …  
    20492096                      const char *expression, bool match)
    20502097{
    2051         SMB_STRUCT_DIR *dir;
     2098        DIR *dir;
    20522099        struct file_list *entry;
    20532100        struct stat statbuf;
    … …  
    20572104        const char *dname;
    20582105
    2059         dir = sys_opendir(directory);
     2106        dir = opendir(directory);
    20602107        if (!dir)
    20612108                return -1;
    … …  
    20862133                                if (ret == -1) {
    20872134                                        SAFE_FREE(path);
    2088                                         sys_closedir(dir);
     2135                                        closedir(dir);
    20892136                                        return -1;
    20902137                                }
    … …  
    20932140                        if (!entry) {
    20942141                                d_printf("Out of memory in file_find\n");
    2095                                 sys_closedir(dir);
     2142                                closedir(dir);
    20962143                                return -1;
    20972144                        }
    … …  
    21042151        }
    21052152
    2106         sys_closedir(dir);
     2153        closedir(dir);
    21072154        return 0;
    21082155}
    … …  
    22132260                return 0;
    22142261        } else {
    2215                 d_printf("Error cancelling job %d : %s\n",job,cli_errstr(cli));
     2262                NTSTATUS status = cli_nt_error(cli);
     2263                d_printf("Error cancelling job %d : %s\n",
     2264                         job, nt_errstr(status));
    22162265                return 1;
    22172266        }
    … …  
    22652314                                        "%s-%d",
    22662315                                        p+1,
    2267                                         (int)sys_getpid());
     2316                                        (int)getpid());
    22682317        }
    22692318        if (strequal(lname,"-")) {
    22702319                rname = talloc_asprintf(ctx,
    22712320                                "stdin-%d",
    2272                                 (int)sys_getpid());
     2321                                (int)getpid());
    22732322        }
    22742323        if (!rname) {
    … …  
    23422391        char *buf = NULL;
    23432392        NTSTATUS status = NT_STATUS_OK;
    2344         uint16 attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
     2393        uint16_t attribute = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN;
    23452394
    23462395        if (recurse) {
    … …  
    23772426        char *mask = NULL;
    23782427        char *buf = NULL;
    2379         uint16 attribute;
     2428        uint16_t attribute;
    23802429        struct cli_state *targetcli;
    23812430        char *targetname = NULL;
    … …  
    23872436        }
    23882437
    2389         attribute = (uint16)strtol(buf, (char **)NULL, 16);
     2438        attribute = (uint16_t)strtol(buf, (char **)NULL, 16);
    23902439
    23912440        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    24012450        }
    24022451
    2403         if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
    2404                 d_printf("cmd_wdel %s: %s\n", mask, cli_errstr(cli));
     2452        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
     2453                                  &targetname);
     2454        if (!NT_STATUS_IS_OK(status)) {
     2455                d_printf("cmd_wdel %s: %s\n", mask, nt_errstr(status));
    24052456                return 1;
    24062457        }
    … …  
    24252476        struct cli_state *targetcli;
    24262477        uint16_t fnum = (uint16_t)-1;
     2478        NTSTATUS status;
    24272479
    24282480        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    24382490        }
    24392491
    2440         if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
    2441                 d_printf("open %s: %s\n", mask, cli_errstr(cli));
    2442                 return 1;
    2443         }
    2444 
    2445         if (!NT_STATUS_IS_OK(cli_ntcreate(targetcli, targetname, 0,
     2492        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
     2493                                  &targetname);
     2494        if (!NT_STATUS_IS_OK(status)) {
     2495                d_printf("open %s: %s\n", mask, nt_errstr(status));
     2496                return 1;
     2497        }
     2498
     2499        status = cli_ntcreate(targetcli, targetname, 0,
    24462500                        FILE_READ_DATA|FILE_WRITE_DATA, 0,
    2447                         FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
    2448                 if (NT_STATUS_IS_OK(cli_ntcreate(targetcli, targetname, 0,
     2501                        FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN,
     2502                        0x0, 0x0, &fnum, NULL);
     2503        if (!NT_STATUS_IS_OK(status)) {
     2504                status = cli_ntcreate(targetcli, targetname, 0,
    24492505                                FILE_READ_DATA, 0,
    2450                                 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN, 0x0, 0x0, &fnum))) {
     2506                                FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN,
     2507                                0x0, 0x0, &fnum, NULL);
     2508                if (NT_STATUS_IS_OK(status)) {
    24512509                        d_printf("open file %s: for read/write fnum %d\n", targetname, fnum);
    24522510                } else {
    2453                         d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
     2511                        d_printf("Failed to open file %s. %s\n",
     2512                                 targetname, nt_errstr(status));
    24542513                }
    24552514        } else {
    … …  
    25142573        mode_t mode;
    25152574        uint16_t fnum;
     2575        NTSTATUS status;
    25162576
    25172577        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    25332593        mode = (mode_t)strtol(buf, (char **)NULL, 8);
    25342594
    2535         if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
    2536                 d_printf("posix_open %s: %s\n", mask, cli_errstr(cli));
    2537                 return 1;
    2538         }
    2539 
    2540         if (!NT_STATUS_IS_OK(cli_posix_open(targetcli, targetname, O_CREAT|O_RDWR, mode, &fnum))) {
    2541                 if (NT_STATUS_IS_OK(cli_posix_open(targetcli, targetname, O_CREAT|O_RDONLY, mode, &fnum))) {
    2542                         d_printf("posix_open file %s: for readonly fnum %d\n", targetname, fnum);
     2595        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
     2596                                  &targetname);
     2597        if (!NT_STATUS_IS_OK(status)) {
     2598                d_printf("posix_open %s: %s\n", mask, nt_errstr(status));
     2599                return 1;
     2600        }
     2601
     2602        status = cli_posix_open(targetcli, targetname, O_CREAT|O_RDWR, mode,
     2603                                &fnum);
     2604        if (!NT_STATUS_IS_OK(status)) {
     2605                status = cli_posix_open(targetcli, targetname,
     2606                                        O_CREAT|O_RDONLY, mode, &fnum);
     2607                if (!NT_STATUS_IS_OK(status)) {
     2608                        d_printf("Failed to open file %s. %s\n", targetname,
     2609                                 nt_errstr(status));
    25432610                } else {
    2544                         d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
     2611                        d_printf("posix_open file %s: for readonly fnum %d\n",
     2612                                 targetname, fnum);
    25452613                }
    25462614        } else {
    2547                 d_printf("posix_open file %s: for read/write fnum %d\n", targetname, fnum);
     2615                d_printf("posix_open file %s: for read/write fnum %d\n",
     2616                         targetname, fnum);
    25482617        }
    25492618
    … …  
    25592628        struct cli_state *targetcli;
    25602629        mode_t mode;
     2630        NTSTATUS status;
    25612631
    25622632        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    25782648        mode = (mode_t)strtol(buf, (char **)NULL, 8);
    25792649
    2580         if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
    2581                 d_printf("posix_mkdir %s: %s\n", mask, cli_errstr(cli));
    2582                 return 1;
    2583         }
    2584 
    2585         if (!NT_STATUS_IS_OK(cli_posix_mkdir(targetcli, targetname, mode))) {
    2586                 d_printf("Failed to open file %s. %s\n", targetname, cli_errstr(cli));
     2650        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
     2651                                  &targetname);
     2652        if (!NT_STATUS_IS_OK(status)) {
     2653                d_printf("posix_mkdir %s: %s\n", mask, nt_errstr(status));
     2654                return 1;
     2655        }
     2656
     2657        status = cli_posix_mkdir(targetcli, targetname, mode);
     2658        if (!NT_STATUS_IS_OK(status)) {
     2659                d_printf("Failed to open file %s. %s\n",
     2660                         targetname, nt_errstr(status));
    25872661        } else {
    25882662                d_printf("posix_mkdir created directory %s\n", targetname);
    … …  
    25982672        char *targetname = NULL;
    25992673        struct cli_state *targetcli;
     2674        NTSTATUS status;
    26002675
    26012676        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    26112686        }
    26122687
    2613         if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
    2614                 d_printf("posix_unlink %s: %s\n", mask, cli_errstr(cli));
    2615                 return 1;
    2616         }
    2617 
    2618         if (!NT_STATUS_IS_OK(cli_posix_unlink(targetcli, targetname))) {
    2619                 d_printf("Failed to unlink file %s. %s\n", targetname, cli_errstr(cli));
     2688        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
     2689                                  &targetname);
     2690        if (!NT_STATUS_IS_OK(status)) {
     2691                d_printf("posix_unlink %s: %s\n", mask, nt_errstr(status));
     2692                return 1;
     2693        }
     2694
     2695        status = cli_posix_unlink(targetcli, targetname);
     2696        if (!NT_STATUS_IS_OK(status)) {
     2697                d_printf("Failed to unlink file %s. %s\n",
     2698                         targetname, nt_errstr(status));
    26202699        } else {
    26212700                d_printf("posix_unlink deleted file %s\n", targetname);
    … …  
    26322711        char *targetname = NULL;
    26332712        struct cli_state *targetcli;
     2713        NTSTATUS status;
    26342714
    26352715        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    26452725        }
    26462726
    2647         if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
    2648                 d_printf("posix_rmdir %s: %s\n", mask, cli_errstr(cli));
    2649                 return 1;
    2650         }
    2651 
    2652         if (!NT_STATUS_IS_OK(cli_posix_rmdir(targetcli, targetname))) {
    2653                 d_printf("Failed to unlink directory %s. %s\n", targetname, cli_errstr(cli));
     2727        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
     2728                                  &targetname);
     2729        if (!NT_STATUS_IS_OK(status)) {
     2730                d_printf("posix_rmdir %s: %s\n", mask, nt_errstr(status));
     2731                return 1;
     2732        }
     2733
     2734        status = cli_posix_rmdir(targetcli, targetname);
     2735        if (!NT_STATUS_IS_OK(status)) {
     2736                d_printf("Failed to unlink directory %s. %s\n",
     2737                         targetname, nt_errstr(status));
    26542738        } else {
    26552739                d_printf("posix_rmdir deleted directory %s\n", targetname);
    … …  
    26642748        char *buf = NULL;
    26652749        int fnum;
     2750        NTSTATUS status;
    26662751
    26672752        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    26722757        fnum = atoi(buf);
    26732758        /* We really should use the targetcli here.... */
    2674         if (!NT_STATUS_IS_OK(cli_close(cli, fnum))) {
    2675                 d_printf("close %d: %s\n", fnum, cli_errstr(cli));
     2759        status = cli_close(cli, fnum);
     2760        if (!NT_STATUS_IS_OK(status)) {
     2761                d_printf("close %d: %s\n", fnum, nt_errstr(status));
    26762762                return 1;
    26772763        }
    … …  
    26822768{
    26832769        TALLOC_CTX *ctx = talloc_tos();
    2684         uint16 major, minor;
    2685         uint32 caplow, caphigh;
     2770        uint16_t major, minor;
     2771        uint32_t caplow, caphigh;
    26862772        char *caps;
    26872773        NTSTATUS status;
    … …  
    27912877        enum brl_type lock_type;
    27922878        int fnum;
     2879        NTSTATUS status;
    27932880
    27942881        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    28262913        len = (uint64_t)strtol(buf, (char **)NULL, 16);
    28272914
    2828         if (!NT_STATUS_IS_OK(cli_posix_lock(cli, fnum, start, len, true, lock_type))) {
    2829                 d_printf("lock failed %d: %s\n", fnum, cli_errstr(cli));
     2915        status = cli_posix_lock(cli, fnum, start, len, true, lock_type);
     2916        if (!NT_STATUS_IS_OK(status)) {
     2917                d_printf("lock failed %d: %s\n", fnum, nt_errstr(status));
    28302918        }
    28312919
    … …  
    28392927        uint64_t start, len;
    28402928        int fnum;
     2929        NTSTATUS status;
    28412930
    28422931        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    28602949        len = (uint64_t)strtol(buf, (char **)NULL, 16);
    28612950
    2862         if (!NT_STATUS_IS_OK(cli_posix_unlock(cli, fnum, start, len))) {
    2863                 d_printf("unlock failed %d: %s\n", fnum, cli_errstr(cli));
     2951        status = cli_posix_unlock(cli, fnum, start, len);
     2952        if (!NT_STATUS_IS_OK(status)) {
     2953                d_printf("unlock failed %d: %s\n", fnum, nt_errstr(status));
    28642954        }
    28652955
    … …  
    28792969        char *targetname = NULL;
    28802970        struct cli_state *targetcli;
     2971        NTSTATUS status;
    28812972
    28822973        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    28922983        }
    28932984
    2894         if (!cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli, &targetname)) {
    2895                 d_printf("rmdir %s: %s\n", mask, cli_errstr(cli));
    2896                 return 1;
    2897         }
    2898 
    2899         if (!NT_STATUS_IS_OK(cli_rmdir(targetcli, targetname))) {
     2985        status = cli_resolve_path(ctx, "", auth_info, cli, mask, &targetcli,
     2986                                  &targetname);
     2987        if (!NT_STATUS_IS_OK(status)) {
     2988                d_printf("rmdir %s: %s\n", mask, nt_errstr(status));
     2989                return 1;
     2990        }
     2991
     2992        status = cli_rmdir(targetcli, targetname);
     2993        if (!NT_STATUS_IS_OK(status)) {
    29002994                d_printf("%s removing remote directory file %s\n",
    2901                          cli_errstr(targetcli),mask);
     2995                         nt_errstr(status), mask);
    29022996        }
    29032997
    … …  
    29183012        char *targetname = NULL;
    29193013        struct cli_state *targetcli;
     3014        NTSTATUS status;
    29203015
    29213016        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
    … …  
    29393034        }
    29403035
    2941         if (!cli_resolve_path(ctx, "", auth_info, cli, oldname, &targetcli, &targetname)) {
    2942                 d_printf("link %s: %s\n", oldname, cli_errstr(cli));
     3036        status = cli_resolve_path(ctx, "", auth_info, cli, oldname, &targetcli,
     3037                                  &targetname);
     3038        if (!NT_STATUS_IS_OK(status)) {
     3039                d_printf("link %s: %s\n", oldname, nt_errstr(status));
    29433040                return 1;
    29443041        }
    … …  
    29493046        }
    29503047
    2951         if (!NT_STATUS_IS_OK(cli_posix_hardlink(targetcli, targetname, newname))) {
    2952                 d_printf("%s linking files (%s -> %s)\n", cli_errstr(targetcli), newname, oldname);
     3048        status = cli_posix_hardlink(targetcli, targetname, newname);
     3049        if (!NT_STATUS_IS_OK(status)) {
     3050                d_printf("%s linking files (%s -> %s)\n",
     3051                         nt_errstr(status), newname, oldname);
    29533052                return 1;
    29543053        }
    … …  
    29683067        char linkname[PATH_MAX+1];
    29693068        struct cli_state *targetcli;
     3069        NTSTATUS status;
    29703070
    29713071        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    … …  
    29813081        }
    29823082
    2983         if (!cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli, &targetname)) {
    2984                 d_printf("readlink %s: %s\n", name, cli_errstr(cli));
     3083        status = cli_resolve_path(ctx, "", auth_info, cli, name, &targetcli,
     3084                                  &targetname);
     3085        if (!NT_STATUS_IS_OK(status)) {
     3086                d_printf("readlink %s: %s\n", name, nt_errstr(status));
    29853087                return 1;
    29863088        }
    … …  
    29913093        }
    29923094
    2993         if (!NT_STATUS_IS_OK(cli_posix_readlink(targetcli, name,
    2994                         linkname, PATH_MAX+1))) {
     3095        status = cli_posix_readlink(targetcli, name, linkname, PATH_MAX+1);
     3096        if (!NT_STATUS_IS_OK(status)) {
    29953097                d_printf("%s readlink on file %s\n",
    2996                         cli_errstr(targetcli), name);
     3098                         nt_errstr(status), name);
    29973099                return 1;
    29983100        }
    … …  
    30163118        char *buf2 = NULL;
    30173119        struct cli_state *newcli;
     3120        NTSTATUS status;
    30183121
    30193122        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
    … …  
    30253128        oldname = buf;
    30263129
    3027         newname = talloc_asprintf(ctx,
    3028                         "%s%s",
    3029                         client_get_cur_dir(),
    3030                         buf2);
    3031         if (!newname) {
    3032                 return 1;
    3033         }
    3034 
    3035         /* New name must be present in share namespace. */
    3036         if (!cli_resolve_path(ctx, "", auth_info, cli, newname, &newcli, &newname)) {
    3037                 d_printf("link %s: %s\n", oldname, cli_errstr(cli));
    3038                 return 1;
    3039         }
    3040 
    3041         if (!SERVER_HAS_UNIX_CIFS(newcli)) {
    3042                 d_printf("Server doesn't support UNIX CIFS calls.\n");
    3043                 return 1;
    3044         }
    3045 
    3046         if (!NT_STATUS_IS_OK(cli_posix_symlink(newcli, oldname, newname))) {
     3130        if (SERVER_HAS_UNIX_CIFS(cli)) {
     3131                newname = talloc_asprintf(ctx, "%s%s", client_get_cur_dir(),
     3132                                          buf2);
     3133                if (!newname) {
     3134                        return 1;
     3135                }
     3136                /* New name must be present in share namespace. */
     3137                status = cli_resolve_path(ctx, "", auth_info, cli, newname,
     3138                                          &newcli, &newname);
     3139                if (!NT_STATUS_IS_OK(status)) {
     3140                        d_printf("link %s: %s\n", oldname, nt_errstr(status));
     3141                        return 1;
     3142                }
     3143                status = cli_posix_symlink(newcli, oldname, newname);
     3144        } else {
     3145                status = cli_symlink(
     3146                        cli, oldname, buf2,
     3147                        buf2[0] == '\\' ? 0 : SYMLINK_FLAG_RELATIVE);
     3148        }
     3149
     3150        if (!NT_STATUS_IS_OK(status)) {
    30473151                d_printf("%s symlinking files (%s -> %s)\n",
    3048                         cli_errstr(newcli), newname, newname);
     3152                         nt_errstr(status), oldname, newname);
    30493153                return 1;
    30503154        }
    … …  
    30663170        struct cli_state *targetcli;
    30673171        mode_t mode;
     3172        NTSTATUS status;
    30683173
    30693174        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
    … …  
    30823187        mode = (mode_t)strtol(buf, NULL, 8);
    30833188
    3084         if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
    3085                 d_printf("chmod %s: %s\n", src, cli_errstr(cli));
     3189        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
     3190                                  &targetname);
     3191        if (!NT_STATUS_IS_OK(status)) {
     3192                d_printf("chmod %s: %s\n", src, nt_errstr(status));
    30863193                return 1;
    30873194        }
    … …  
    30923199        }
    30933200
    3094         if (!NT_STATUS_IS_OK(cli_posix_chmod(targetcli, targetname, mode))) {
     3201        status = cli_posix_chmod(targetcli, targetname, mode);
     3202        if (!NT_STATUS_IS_OK(status)) {
    30953203                d_printf("%s chmod file %s 0%o\n",
    3096                         cli_errstr(targetcli), src, (unsigned int)mode);
     3204                         nt_errstr(status), src, (unsigned int)mode);
    30973205                return 1;
    30983206        }
    … …  
    32143322        char *targetname = NULL;
    32153323        struct cli_state *targetcli;
    3216         uint16 major, minor;
    3217         uint32 caplow, caphigh;
     3324        uint16_t major, minor;
     3325        uint32_t caplow, caphigh;
    32183326        char *retbuf = NULL;
    32193327        size_t rb_size = 0;
    32203328        SMB_STRUCT_STAT sbuf;
    3221         uint16 num_file_acls = 0;
    3222         uint16 num_dir_acls = 0;
    3223         uint16 i;
     3329        uint16_t num_file_acls = 0;
     3330        uint16_t num_dir_acls = 0;
     3331        uint16_t i;
    32243332        NTSTATUS status;
    32253333
    … …  
    32363344        }
    32373345
    3238         if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
    3239                 d_printf("stat %s: %s\n", src, cli_errstr(cli));
     3346        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
     3347                                  &targetname);
     3348        if (!NT_STATUS_IS_OK(status)) {
     3349                d_printf("stat %s: %s\n", src, nt_errstr(status));
    32403350                return 1;
    32413351        }
    … …  
    32603370        }
    32613371
     3372        status = cli_posix_stat(targetcli, targetname, &sbuf);
    32623373        if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli, targetname, &sbuf))) {
    32633374                d_printf("%s getfacl doing a stat on file %s\n",
    3264                         cli_errstr(targetcli), src);
    3265                 return 1;
    3266         }
    3267 
    3268         if (!NT_STATUS_IS_OK(cli_posix_getfacl(targetcli, targetname, ctx, &rb_size, &retbuf))) {
     3375                         nt_errstr(status), src);
     3376                return 1;
     3377        }
     3378
     3379        status = cli_posix_getacl(targetcli, targetname, ctx, &rb_size, &retbuf);
     3380        if (!NT_STATUS_IS_OK(status)) {
    32693381                d_printf("%s getfacl file %s\n",
    3270                         cli_errstr(targetcli), src);
     3382                         nt_errstr(status), src);
    32713383                return 1;
    32723384        }
    … …  
    32973409
    32983410        for (i = 0; i < num_file_acls; i++) {
    3299                 uint32 uorg;
     3411                uint32_t uorg;
    33003412                fstring permstring;
    33013413                unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+(i*SMB_POSIX_ACL_ENTRY_SIZE));
    … …  
    33343446
    33353447        for (i = 0; i < num_dir_acls; i++) {
    3336                 uint32 uorg;
     3448                uint32_t uorg;
    33373449                fstring permstring;
    33383450                unsigned char tagtype = CVAL(retbuf, SMB_POSIX_ACL_HEADER_SIZE+((i+num_file_acls)*SMB_POSIX_ACL_ENTRY_SIZE));
    … …  
    33733485}
    33743486
    3375 static void printf_cb(const char *buf, void *private_data)
    3376 {
    3377         printf("%s", buf);
    3378 }
    3379 
    33803487/****************************************************************************
    33813488 Get the EA list of a file
    … …  
    34053512        }
    34063513
    3407         if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
    3408                               &targetname)) {
    3409                 d_printf("stat %s: %s\n", src, cli_errstr(cli));
     3514        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
     3515                                  &targetname);
     3516        if (!NT_STATUS_IS_OK(status)) {
     3517                d_printf("stat %s: %s\n", src, nt_errstr(status));
    34103518                return 1;
    34113519        }
    … …  
    34203528        for (i=0; i<num_eas; i++) {
    34213529                d_printf("%s (%d) =\n", eas[i].name, (int)eas[i].flags);
    3422                 dump_data_cb(eas[i].value.data, eas[i].value.length, false,
    3423                              printf_cb, NULL);
     3530                dump_data_file(eas[i].value.data, eas[i].value.length, false,
     3531                               stdout);
    34243532                d_printf("\n");
    34253533        }
    … …  
    34613569        }
    34623570
    3463         if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
    3464                               &targetname)) {
    3465                 d_printf("stat %s: %s\n", src, cli_errstr(cli));
     3571        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
     3572                                  &targetname);
     3573        if (!NT_STATUS_IS_OK(status)) {
     3574                d_printf("stat %s: %s\n", src, nt_errstr(status));
    34663575                return 1;
    34673576        }
    … …  
    34923601        struct tm *lt;
    34933602        time_t tmp_time;
     3603        NTSTATUS status;
    34943604
    34953605        if (!next_token_talloc(ctx, &cmd_ptr,&name,NULL)) {
    … …  
    35053615        }
    35063616
    3507         if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
    3508                 d_printf("stat %s: %s\n", src, cli_errstr(cli));
     3617        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
     3618                                  &targetname);
     3619        if (!NT_STATUS_IS_OK(status)) {
     3620                d_printf("stat %s: %s\n", src, nt_errstr(status));
    35093621                return 1;
    35103622        }
    … …  
    35153627        }
    35163628
    3517         if (!NT_STATUS_IS_OK(cli_posix_stat(targetcli, targetname, &sbuf))) {
     3629        status = cli_posix_stat(targetcli, targetname, &sbuf);
     3630        if (!NT_STATUS_IS_OK(status)) {
    35183631                d_printf("%s stat file %s\n",
    3519                         cli_errstr(targetcli), src);
     3632                         nt_errstr(status), src);
    35203633                return 1;
    35213634        }
    … …  
    35913704        struct cli_state *targetcli;
    35923705        char *targetname = NULL;
     3706        NTSTATUS status;
    35933707
    35943708        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
    … …  
    36093723                return 1;
    36103724        }
    3611         if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname) ) {
    3612                 d_printf("chown %s: %s\n", src, cli_errstr(cli));
     3725        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
     3726                                  &targetname);
     3727        if (!NT_STATUS_IS_OK(status)) {
     3728                d_printf("chown %s: %s\n", src, nt_errstr(status));
    36133729                return 1;
    36143730        }
    … …  
    36193735        }
    36203736
    3621         if (!NT_STATUS_IS_OK(cli_posix_chown(targetcli, targetname, uid, gid))) {
     3737        status = cli_posix_chown(targetcli, targetname, uid, gid);
     3738        if (!NT_STATUS_IS_OK(status)) {
    36223739                d_printf("%s chown file %s uid=%d, gid=%d\n",
    3623                         cli_errstr(targetcli), src, (int)uid, (int)gid);
     3740                         nt_errstr(status), src, (int)uid, (int)gid);
    36243741                return 1;
    36253742        }
    … …  
    36403757        char *targetsrc;
    36413758        char *targetdest;
     3759        NTSTATUS status;
    36423760
    36433761        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
    … …  
    36633781        }
    36643782
    3665         if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetsrc)) {
    3666                 d_printf("rename %s: %s\n", src, cli_errstr(cli));
    3667                 return 1;
    3668         }
    3669 
    3670         if (!cli_resolve_path(ctx, "", auth_info, cli, dest, &targetcli, &targetdest)) {
    3671                 d_printf("rename %s: %s\n", dest, cli_errstr(cli));
    3672                 return 1;
    3673         }
    3674 
    3675         if (!NT_STATUS_IS_OK(cli_rename(targetcli, targetsrc, targetdest))) {
     3783        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
     3784                                  &targetsrc);
     3785        if (!NT_STATUS_IS_OK(status)) {
     3786                d_printf("rename %s: %s\n", src, nt_errstr(status));
     3787                return 1;
     3788        }
     3789
     3790        status = cli_resolve_path(ctx, "", auth_info, cli, dest, &targetcli,
     3791                                  &targetdest);
     3792        if (!NT_STATUS_IS_OK(status)) {
     3793                d_printf("rename %s: %s\n", dest, nt_errstr(status));
     3794                return 1;
     3795        }
     3796
     3797        status = cli_rename(targetcli, targetsrc, targetdest);
     3798        if (!NT_STATUS_IS_OK(status)) {
    36763799                d_printf("%s renaming files %s -> %s \n",
    3677                         cli_errstr(targetcli),
     3800                        nt_errstr(status),
    36783801                        targetsrc,
    36793802                        targetdest);
    … …  
    36843807}
    36853808
    3686 /****************************************************************************
    3687  Print the volume name.
    3688 ****************************************************************************/
    3689 
    3690 static int cmd_volume(void)
    3691 {
    3692         fstring volname;
    3693         uint32 serial_num;
    3694         time_t create_date;
    3695         NTSTATUS status;
    3696 
    3697         status = cli_get_fs_volume_info(cli, volname, &serial_num,
    3698                                         &create_date);
    3699         if (!NT_STATUS_IS_OK(status)) {
    3700                 d_printf("Error %s getting volume info\n", nt_errstr(status));
    3701                 return 1;
    3702         }
    3703 
    3704         d_printf("Volume: |%s| serial number 0x%x\n",
    3705                         volname, (unsigned int)serial_num);
    3706         return 0;
    3707 }
    3708 
    3709 /****************************************************************************
    3710  Hard link files using the NT call.
    3711 ****************************************************************************/
    3712 
    3713 static int cmd_hardlink(void)
     3809struct scopy_timing {
     3810        struct timespec tp_start;
     3811};
     3812
     3813static int scopy_status(off_t written, void *priv)
     3814{
     3815        struct timespec tp_end;
     3816        unsigned int scopy_total_time_ms;
     3817        struct scopy_timing *st = priv;
     3818
     3819        clock_gettime_mono(&tp_end);
     3820        scopy_total_time_ms = nsec_time_diff(&tp_end,&st->tp_start)/1000000;
     3821
     3822        DEBUG(5,("Copied %jd bytes at an average %3.1f kb/s\n",
     3823                 (intmax_t)written, written / (1.024*scopy_total_time_ms)));
     3824
     3825        return true;
     3826}
     3827
     3828/****************************************************************************
     3829 Server-Side copy some file.
     3830****************************************************************************/
     3831
     3832static int cmd_scopy(void)
    37143833{
    37153834        TALLOC_CTX *ctx = talloc_tos();
    … …  
    37173836        char *buf, *buf2;
    37183837        struct cli_state *targetcli;
    3719         char *targetname;
     3838        char *targetsrc;
     3839        char *targetdest;
     3840        uint32_t DesiredAccess, ShareAccess, CreateDisposition, CreateOptions;
     3841        struct smb_create_returns cr;
     3842        uint16_t destfnum = (uint16_t)-1;
     3843        uint16_t srcfnum = (uint16_t)-1;
     3844        off_t written = 0;
     3845        struct scopy_timing st;
     3846        int rc = 0;
     3847        NTSTATUS status;
    37203848
    37213849        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
    3722             !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
    3723                 d_printf("hardlink <src> <dest>\n");
     3850                        !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
     3851                d_printf("scopy <src> <dest>\n");
    37243852                return 1;
    37253853        }
    … …  
    37413869        }
    37423870
    3743         if (!cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli, &targetname)) {
    3744                 d_printf("hardlink %s: %s\n", src, cli_errstr(cli));
    3745                 return 1;
    3746         }
    3747 
    3748         if (!NT_STATUS_IS_OK(cli_nt_hardlink(targetcli, targetname, dest))) {
    3749                 d_printf("%s doing an NT hard link of files\n",cli_errstr(targetcli));
     3871        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
     3872                        &targetsrc);
     3873        if (!NT_STATUS_IS_OK(status)) {
     3874                d_printf("scopy %s: %s\n", src, nt_errstr(status));
     3875                return 1;
     3876        }
     3877
     3878        status = cli_resolve_path(ctx, "", auth_info, cli, dest, &targetcli,
     3879                        &targetdest);
     3880        if (!NT_STATUS_IS_OK(status)) {
     3881                d_printf("scopy %s: %s\n", dest, nt_errstr(status));
     3882                return 1;
     3883        }
     3884
     3885
     3886        DesiredAccess = (FILE_READ_DATA|FILE_READ_EA|FILE_READ_ATTRIBUTES|
     3887                        READ_CONTROL_ACCESS|SYNCHRONIZE_ACCESS);
     3888        ShareAccess = FILE_SHARE_READ|FILE_SHARE_DELETE;
     3889        CreateDisposition = FILE_OPEN;
     3890        CreateOptions = (FILE_SEQUENTIAL_ONLY|FILE_NON_DIRECTORY_FILE|
     3891                        FILE_OPEN_REPARSE_POINT);
     3892        status = cli_ntcreate(targetcli, targetsrc, 0, DesiredAccess, 0,
     3893                        ShareAccess, CreateDisposition, CreateOptions, 0x0,
     3894                        &srcfnum, &cr);
     3895        if (!NT_STATUS_IS_OK(status)) {
     3896                d_printf("Failed to open file %s. %s\n",
     3897                                targetsrc, nt_errstr(status));
     3898                return 1;
     3899        }
     3900
     3901        DesiredAccess = (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_READ_EA|
     3902                        FILE_WRITE_EA|FILE_READ_ATTRIBUTES|FILE_WRITE_ATTRIBUTES|
     3903                        DELETE_ACCESS|READ_CONTROL_ACCESS|WRITE_DAC_ACCESS|SYNCHRONIZE_ACCESS);
     3904        ShareAccess = FILE_SHARE_NONE;
     3905        CreateDisposition = FILE_CREATE;
     3906        CreateOptions = FILE_SEQUENTIAL_ONLY|FILE_NON_DIRECTORY_FILE;
     3907        status = cli_ntcreate(targetcli, targetdest, 0, DesiredAccess,
     3908                        FILE_ATTRIBUTE_ARCHIVE, ShareAccess, CreateDisposition,
     3909                        CreateOptions, 0x0, &destfnum, NULL);
     3910        if (!NT_STATUS_IS_OK(status)) {
     3911                d_printf("Failed to create file %s. %s\n",
     3912                                targetdest, nt_errstr(status));
     3913                cli_close(targetcli, srcfnum);
     3914                return 1;
     3915        }
     3916
     3917        clock_gettime_mono(&st.tp_start);
     3918        status = cli_splice(targetcli, targetcli, srcfnum, destfnum,
     3919                        cr.end_of_file, 0, 0, &written, scopy_status, &st);
     3920        if (!NT_STATUS_IS_OK(status)) {
     3921                d_printf("%s copying file %s -> %s \n",
     3922                                nt_errstr(status),
     3923                                targetsrc,
     3924                                targetdest);
     3925                rc = 1;
     3926        }
     3927
     3928        status = cli_close(targetcli, srcfnum);
     3929        if (!NT_STATUS_IS_OK(status)) {
     3930                d_printf("Error %s closing remote source file\n", nt_errstr(status));
     3931                rc = 1;
     3932        }
     3933        status = cli_close(targetcli, destfnum);
     3934        if (!NT_STATUS_IS_OK(status)) {
     3935                d_printf("Error %s closing remote dest file\n", nt_errstr(status));
     3936                rc = 1;
     3937        }
     3938
     3939        return rc;
     3940}
     3941
     3942/****************************************************************************
     3943 Print the volume name.
     3944****************************************************************************/
     3945
     3946static int cmd_volume(void)
     3947{
     3948        char *volname;
     3949        uint32_t serial_num;
     3950        time_t create_date;
     3951        NTSTATUS status;
     3952
     3953        status = cli_get_fs_volume_info(cli, talloc_tos(),
     3954                                        &volname, &serial_num,
     3955                                        &create_date);
     3956        if (!NT_STATUS_IS_OK(status)) {
     3957                d_printf("Error %s getting volume info\n", nt_errstr(status));
     3958                return 1;
     3959        }
     3960
     3961        d_printf("Volume: |%s| serial number 0x%x\n",
     3962                        volname, (unsigned int)serial_num);
     3963        return 0;
     3964}
     3965
     3966/****************************************************************************
     3967 Hard link files using the NT call.
     3968****************************************************************************/
     3969
     3970static int cmd_hardlink(void)
     3971{
     3972        TALLOC_CTX *ctx = talloc_tos();
     3973        char *src, *dest;
     3974        char *buf, *buf2;
     3975        struct cli_state *targetcli;
     3976        char *targetname;
     3977        NTSTATUS status;
     3978
     3979        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL) ||
     3980            !next_token_talloc(ctx, &cmd_ptr,&buf2,NULL)) {
     3981                d_printf("hardlink <src> <dest>\n");
     3982                return 1;
     3983        }
     3984
     3985        src = talloc_asprintf(ctx,
     3986                        "%s%s",
     3987                        client_get_cur_dir(),
     3988                        buf);
     3989        if (!src) {
     3990                return 1;
     3991        }
     3992
     3993        dest = talloc_asprintf(ctx,
     3994                        "%s%s",
     3995                        client_get_cur_dir(),
     3996                        buf2);
     3997        if (!dest) {
     3998                return 1;
     3999        }
     4000
     4001        status = cli_resolve_path(ctx, "", auth_info, cli, src, &targetcli,
     4002                                  &targetname);
     4003        if (!NT_STATUS_IS_OK(status)) {
     4004                d_printf("hardlink %s: %s\n", src, nt_errstr(status));
     4005                return 1;
     4006        }
     4007
     4008        status = cli_nt_hardlink(targetcli, targetname, dest);
     4009        if (!NT_STATUS_IS_OK(status)) {
     4010                d_printf("%s doing an NT hard link of files\n",
     4011                         nt_errstr(status));
    37504012                return 1;
    37514013        }
    … …  
    37944056
    37954057/****************************************************************************
     4058 Watch directory changes
     4059****************************************************************************/
     4060
     4061static int cmd_notify(void)
     4062{
     4063        TALLOC_CTX *frame = talloc_stackframe();
     4064        char *name, *buf;
     4065        NTSTATUS status;
     4066        uint16_t fnum;
     4067
     4068        name = talloc_strdup(talloc_tos(), client_get_cur_dir());
     4069        if (name == NULL) {
     4070                goto fail;
     4071        }
     4072        if (!next_token_talloc(talloc_tos(), &cmd_ptr, &buf, NULL)) {
     4073                goto usage;
     4074        }
     4075        name = talloc_asprintf_append(name, "%s", buf);
     4076        if (name == NULL) {
     4077                goto fail;
     4078        }
     4079        status = cli_ntcreate(
     4080                cli, name, 0, FILE_READ_DATA, 0,
     4081                FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
     4082                FILE_OPEN, 0, 0, &fnum, NULL);
     4083        if (!NT_STATUS_IS_OK(status)) {
     4084                d_printf("Could not open file: %s\n", nt_errstr(status));
     4085                goto fail;
     4086        }
     4087
     4088        while (1) {
     4089                uint32_t i, num_changes;
     4090                struct notify_change *changes;
     4091
     4092                status = cli_notify(cli, fnum, 1000, FILE_NOTIFY_CHANGE_ALL,
     4093                                    true,
     4094                                    talloc_tos(), &num_changes, &changes);
     4095                if (!NT_STATUS_IS_OK(status)) {
     4096                        d_printf("notify returned %s\n",
     4097                                 nt_errstr(status));
     4098                        goto fail;
     4099                }
     4100                for (i=0; i<num_changes; i++) {
     4101                        printf("%4.4x %s\n", changes[i].action,
     4102                               changes[i].name);
     4103                }
     4104                TALLOC_FREE(changes);
     4105        }
     4106usage:
     4107        d_printf("notify <file>\n");
     4108fail:
     4109        TALLOC_FREE(frame);
     4110        return 1;
     4111}
     4112
     4113/****************************************************************************
    37964114 Set the archive level.
    37974115****************************************************************************/
    … …  
    38124130
    38134131/****************************************************************************
     4132 Toggle the backup_intent state.
     4133****************************************************************************/
     4134
     4135static int cmd_backup(void)
     4136{
     4137        backup_intent = !backup_intent;
     4138        cli_set_backup_intent(cli, backup_intent);
     4139        DEBUG(2,("backup intent is now %s\n",backup_intent?"on":"off"));
     4140        return 1;
     4141}
     4142
     4143/****************************************************************************
    38144144 Toggle the lowercaseflag.
    38154145****************************************************************************/
    … …  
    38874217                }
    38884218        }
    3889         d = TALLOC_ARRAY(ctx, char, PATH_MAX+1);
     4219        d = sys_getwd();
    38904220        if (!d) {
    38914221                return 1;
    38924222        }
    3893         DEBUG(2,("the local directory is now %s\n",sys_getwd(d)));
     4223        DEBUG(2,("the local directory is now %s\n",d));
     4224        SAFE_FREE(d);
    38944225        return 0;
    38954226}
    … …  
    39844315 ****************************************************************************/
    39854316
    3986 static void browse_fn(const char *name, uint32 m,
     4317static void browse_fn(const char *name, uint32_t m,
    39874318                      const char *comment, void *state)
    39884319{
    … …  
    40274358        struct dcerpc_binding_handle *b;
    40284359
    4029         status = cli_rpc_pipe_open_noauth(cli, &ndr_table_srvsvc.syntax_id,
     4360        status = cli_rpc_pipe_open_noauth(cli, &ndr_table_srvsvc,
    40304361                                          &pipe_hnd);
    40314362
    … …  
    40854416        }
    40864417
    4087         if((ret = cli_RNetShareEnum(cli, browse_fn, NULL)) == -1)
    4088                 d_printf("Error returning browse list: %s\n", cli_errstr(cli));
     4418        if((ret = cli_RNetShareEnum(cli, browse_fn, NULL)) == -1) {
     4419                NTSTATUS status = cli_nt_error(cli);
     4420                d_printf("Error returning browse list: %s\n",
     4421                         nt_errstr(status));
     4422        }
    40894423
    40904424        return (ret != -1);
    … …  
    40954429****************************************************************************/
    40964430
    4097 static void server_fn(const char *name, uint32 m,
     4431static void server_fn(const char *name, uint32_t m,
    40984432                      const char *comment, void *state)
    40994433{
    … …  
    41464480
    41474481        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    4148                 d_printf("Current VUID is %d\n", cli->vuid);
     4482                d_printf("Current VUID is %d\n",
     4483                         cli_state_get_uid(cli));
    41494484                return 0;
    41504485        }
    41514486
    4152         cli->vuid = atoi(buf);
     4487        cli_state_set_uid(cli, atoi(buf));
    41534488        return 0;
    41544489}
    … …  
    41704505
    41714506        if (!next_token_talloc(ctx, &cmd_ptr,&l_password,NULL)) {
    4172                 char *pass = getpass("Password: ");
    4173                 if (pass) {
    4174                         l_password = talloc_strdup(ctx,pass);
     4507                char pwd[256] = {0};
     4508                int rc;
     4509
     4510                rc = samba_getpass("Password: ", pwd, sizeof(pwd), false, false);
     4511                if (rc == 0) {
     4512                        l_password = talloc_strdup(ctx, pwd);
    41754513                }
    41764514        }
    … …  
    41884526        }
    41894527
    4190         d_printf("Current VUID is %d\n", cli->vuid);
     4528        d_printf("Current VUID is %d\n", cli_state_get_uid(cli));
     4529        return 0;
     4530}
     4531
     4532/**
     4533 * close the session
     4534 */
     4535
     4536static int cmd_logoff(void)
     4537{
     4538        NTSTATUS status;
     4539
     4540        status = cli_ulogoff(cli);
     4541        if (!NT_STATUS_IS_OK(status)) {
     4542                d_printf("logoff failed: %s\n", nt_errstr(status));
     4543                return -1;
     4544        }
     4545
     4546        d_printf("logoff successful\n");
     4547        return 0;
     4548}
     4549
     4550
     4551/**
     4552 * tree connect (connect to a share)
     4553 */
     4554
     4555static int cmd_tcon(void)
     4556{
     4557        TALLOC_CTX *ctx = talloc_tos();
     4558        char *sharename;
     4559        NTSTATUS status;
     4560
     4561        if (!next_token_talloc(ctx, &cmd_ptr, &sharename, NULL)) {
     4562                d_printf("tcon <sharename>\n");
     4563                return 0;
     4564        }
     4565
     4566        if (!sharename) {
     4567                return 1;
     4568        }
     4569
     4570        status = cli_tree_connect(cli, sharename, "?????", "", 0);
     4571        if (!NT_STATUS_IS_OK(status)) {
     4572                d_printf("tcon failed: %s\n", nt_errstr(status));
     4573                return -1;
     4574        }
     4575
     4576        talloc_free(sharename);
     4577
     4578        d_printf("tcon to %s successful, tid: %u\n", sharename,
     4579                 cli_state_get_tid(cli));
     4580        return 0;
     4581}
     4582
     4583/**
     4584 * tree disconnect (disconnect from a share)
     4585 */
     4586
     4587static int cmd_tdis(void)
     4588{
     4589        NTSTATUS status;
     4590
     4591        status = cli_tdis(cli);
     4592        if (!NT_STATUS_IS_OK(status)) {
     4593                d_printf("tdis failed: %s\n", nt_errstr(status));
     4594                return -1;
     4595        }
     4596
     4597        d_printf("tdis successful\n");
     4598        return 0;
     4599}
     4600
     4601
     4602/**
     4603 * get or set tid
     4604 */
     4605
     4606static int cmd_tid(void)
     4607{
     4608        TALLOC_CTX *ctx = talloc_tos();
     4609        char *tid_str;
     4610
     4611        if (!next_token_talloc(ctx, &cmd_ptr, &tid_str, NULL)) {
     4612                if (cli_state_has_tcon(cli)) {
     4613                        d_printf("current tid is %d\n", cli_state_get_tid(cli));
     4614                } else {
     4615                        d_printf("no tcon currently\n");
     4616                }
     4617        } else {
     4618                uint16_t tid = atoi(tid_str);
     4619                cli_state_set_tid(cli, tid);
     4620        }
     4621
    41914622        return 0;
    41924623}
    … …  
    42124643        struct cli_state *targetcli;
    42134644        char *targetpath;
    4214 
    4215         if (!cli_resolve_path(ctx, "", auth_info, cli, client_get_cur_dir(),
    4216                                 &targetcli, &targetpath ) ) {
    4217                 d_printf("showconnect %s: %s\n", cur_dir, cli_errstr(cli));
    4218                 return 1;
    4219         }
    4220 
    4221         d_printf("//%s/%s\n", targetcli->desthost, targetcli->share);
    4222         return 0;
     4645        NTSTATUS status;
     4646
     4647        status = cli_resolve_path(ctx, "", auth_info, cli,
     4648                                  client_get_cur_dir(), &targetcli,
     4649                                  &targetpath);
     4650        if (!NT_STATUS_IS_OK(status)) {
     4651                d_printf("showconnect %s: %s\n", cur_dir, nt_errstr(status));
     4652                return 1;
     4653        }
     4654
     4655        d_printf("//%s/%s\n", smbXcli_conn_remote_name(targetcli->conn), targetcli->share);
     4656        return 0;
     4657}
     4658
     4659/**
     4660 * set_remote_attr - set DOS attributes of a remote file
     4661 * @filename: path to the file name
     4662 * @new_attr: attribute bit mask to use
     4663 * @mode: one of ATTR_SET or ATTR_UNSET
     4664 *
     4665 * Update the file attributes with the one provided.
     4666 */
     4667int set_remote_attr(const char *filename, uint16_t new_attr, int mode)
     4668{
     4669        extern struct cli_state *cli;
     4670        uint16_t old_attr;
     4671        NTSTATUS status;
     4672
     4673        status = cli_getatr(cli, filename, &old_attr, NULL, NULL);
     4674        if (!NT_STATUS_IS_OK(status)) {
     4675                d_printf("cli_getatr failed: %s\n", nt_errstr(status));
     4676                return 1;
     4677        }
     4678
     4679        if (mode == ATTR_SET) {
     4680                new_attr |= old_attr;
     4681        } else {
     4682                new_attr = old_attr & ~new_attr;
     4683        }
     4684
     4685        status = cli_setatr(cli, filename, new_attr, 0);
     4686        if (!NT_STATUS_IS_OK(status)) {
     4687                d_printf("cli_setatr failed: %s\n", nt_errstr(status));
     4688                return 1;
     4689        }
     4690
     4691        return 0;
     4692}
     4693
     4694/**
     4695 * cmd_setmode - interactive command to set DOS attributes
     4696 *
     4697 * Read a filename and mode from the client command line and update
     4698 * the file DOS attributes.
     4699 */
     4700int cmd_setmode(void)
     4701{
     4702        const extern char *cmd_ptr;
     4703        char *buf;
     4704        char *fname = NULL;
     4705        uint16_t attr[2] = {0};
     4706        int mode = ATTR_SET;
     4707        int err = 0;
     4708        bool ok;
     4709        TALLOC_CTX *ctx = talloc_new(NULL);
     4710        if (ctx == NULL) {
     4711                return 1;
     4712        }
     4713
     4714        ok = next_token_talloc(ctx, &cmd_ptr, &buf, NULL);
     4715        if (!ok) {
     4716                d_printf("setmode <filename> <[+|-]rsha>\n");
     4717                err = 1;
     4718                goto out;
     4719        }
     4720
     4721        fname = talloc_asprintf(ctx,
     4722                                "%s%s",
     4723                                client_get_cur_dir(),
     4724                                buf);
     4725        if (fname == NULL) {
     4726                err = 1;
     4727                goto out;
     4728        }
     4729
     4730        while (next_token_talloc(ctx, &cmd_ptr, &buf, NULL)) {
     4731                const char *s = buf;
     4732
     4733                while (*s) {
     4734                        switch (*s++) {
     4735                        case '+':
     4736                                mode = ATTR_SET;
     4737                                break;
     4738                        case '-':
     4739                                mode = ATTR_UNSET;
     4740                                break;
     4741                        case 'r':
     4742                                attr[mode] |= FILE_ATTRIBUTE_READONLY;
     4743                                break;
     4744                        case 'h':
     4745                                attr[mode] |= FILE_ATTRIBUTE_HIDDEN;
     4746                                break;
     4747                        case 's':
     4748                                attr[mode] |= FILE_ATTRIBUTE_SYSTEM;
     4749                                break;
     4750                        case 'a':
     4751                                attr[mode] |= FILE_ATTRIBUTE_ARCHIVE;
     4752                                break;
     4753                        default:
     4754                                d_printf("setmode <filename> <perm=[+|-]rsha>\n");
     4755                                err = 1;
     4756                                goto out;
     4757                        }
     4758                }
     4759        }
     4760
     4761        if (attr[ATTR_SET] == 0 && attr[ATTR_UNSET] == 0) {
     4762                d_printf("setmode <filename> <[+|-]rsha>\n");
     4763                err = 1;
     4764                goto out;
     4765        }
     4766
     4767        DEBUG(2, ("perm set %d %d\n", attr[ATTR_SET], attr[ATTR_UNSET]));
     4768
     4769        /* ignore return value: server might not store DOS attributes */
     4770        set_remote_attr(fname, attr[ATTR_SET], ATTR_SET);
     4771        set_remote_attr(fname, attr[ATTR_UNSET], ATTR_UNSET);
     4772out:
     4773        talloc_free(ctx);
     4774        return err;
    42234775}
    42244776
    … …  
    42344786
    42354787        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
    4236                 if (!smb_encrypt) {
    4237                         d_printf("iosize <n> or iosize 0x<n>. "
    4238                                 "Minimum is 16384 (0x4000), "
    4239                                 "max is 16776960 (0xFFFF00)\n");
     4788                if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
     4789                        if (!smb_encrypt) {
     4790                                d_printf("iosize <n> or iosize 0x<n>. "
     4791                                        "Minimum is 0 (default), "
     4792                                        "max is 16776960 (0xFFFF00)\n");
     4793                        } else {
     4794                                d_printf("iosize <n> or iosize 0x<n>. "
     4795                                        "(Encrypted connection) ,"
     4796                                        "Minimum is 0 (default), "
     4797                                        "max is 130048 (0x1FC00)\n");
     4798                        }
    42404799                } else {
    4241                         d_printf("iosize <n> or iosize 0x<n>. "
    4242                                 "(Encrypted connection) ,"
    4243                                 "Minimum is 16384 (0x4000), "
    4244                                 "max is 130048 (0x1FC00)\n");
     4800                        d_printf("iosize <n> or iosize 0x<n>.\n");
    42454801                }
    42464802                return 1;
    … …  
    42484804
    42494805        iosize = strtol(buf,NULL,0);
    4250         if (smb_encrypt && (iosize < 0x4000 || iosize > 0xFC00)) {
    4251                 d_printf("iosize out of range for encrypted "
    4252                         "connection (min = 16384 (0x4000), "
    4253                         "max = 130048 (0x1FC00)");
    4254                 return 1;
    4255         } else if (!smb_encrypt && (iosize < 0x4000 || iosize > 0xFFFF00)) {
    4256                 d_printf("iosize out of range (min = 16384 (0x4000), "
    4257                         "max = 16776960 (0xFFFF00)");
    4258                 return 1;
     4806        if (smbXcli_conn_protocol(cli->conn) < PROTOCOL_SMB2_02) {
     4807                if (smb_encrypt && (iosize < 0 || iosize > 0xFC00)) {
     4808                        d_printf("iosize out of range for encrypted "
     4809                                "connection (min = 0 (default), "
     4810                                "max = 130048 (0x1FC00)\n");
     4811                        return 1;
     4812                } else if (!smb_encrypt && (iosize < 0 || iosize > 0xFFFF00)) {
     4813                        d_printf("iosize out of range (min = 0 (default), "
     4814                                "max = 16776960 (0xFFFF00)\n");
     4815                        return 1;
     4816                }
    42594817        }
    42604818
    … …  
    42634821        return 0;
    42644822}
     4823
     4824/****************************************************************************
     4825 timeout command
     4826***************************************************************************/
     4827
     4828static int cmd_timeout(void)
     4829{
     4830        TALLOC_CTX *ctx = talloc_tos();
     4831        char *buf;
     4832
     4833        if (!next_token_talloc(ctx, &cmd_ptr,&buf,NULL)) {
     4834                unsigned int old_timeout = cli_set_timeout(cli, 0);
     4835                cli_set_timeout(cli, old_timeout);
     4836                d_printf("timeout <n> (per-operation timeout "
     4837                        "in seconds - currently %u).\n",
     4838                        old_timeout/1000);
     4839                return 1;
     4840        }
     4841
     4842        io_timeout = strtol(buf,NULL,0);
     4843        cli_set_timeout(cli, io_timeout*1000);
     4844        d_printf("io_timeout per operation is now %d\n", io_timeout);
     4845        return 0;
     4846}
     4847
    42654848
    42664849/****************************************************************************
    … …  
    43074890  {"altname",cmd_altname,"<file> show alt name",{COMPL_NONE,COMPL_NONE}},
    43084891  {"archive",cmd_archive,"<level>\n0=ignore archive bit\n1=only get archive files\n2=only get archive files and reset archive bit\n3=get all files and reset archive bit",{COMPL_NONE,COMPL_NONE}},
     4892  {"backup",cmd_backup,"toggle backup intent state",{COMPL_NONE,COMPL_NONE}},
    43094893  {"blocksize",cmd_block,"blocksize <number> (default 20)",{COMPL_NONE,COMPL_NONE}},
    43104894  {"cancel",cmd_cancel,"<jobid> cancel a print queue entry",{COMPL_NONE,COMPL_NONE}},
    43114895  {"case_sensitive",cmd_setcase,"toggle the case sensitive flag to server",{COMPL_NONE,COMPL_NONE}},
    43124896  {"cd",cmd_cd,"[directory] change/report the remote directory",{COMPL_REMOTE,COMPL_NONE}},
    4313   {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_REMOTE}},
    4314   {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_REMOTE}},
    4315   {"close",cmd_close,"<fid> close a file given a fid",{COMPL_REMOTE,COMPL_REMOTE}},
     4897  {"chmod",cmd_chmod,"<src> <mode> chmod a file using UNIX permission",{COMPL_REMOTE,COMPL_NONE}},
     4898  {"chown",cmd_chown,"<src> <uid> <gid> chown a file using UNIX uids and gids",{COMPL_REMOTE,COMPL_NONE}},
     4899  {"close",cmd_close,"<fid> close a file given a fid",{COMPL_REMOTE,COMPL_NONE}},
    43164900  {"del",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
    43174901  {"dir",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
    … …  
    43204904  {"exit",cmd_quit,"logoff the server",{COMPL_NONE,COMPL_NONE}},
    43214905  {"get",cmd_get,"<remote name> [local name] get a file",{COMPL_REMOTE,COMPL_LOCAL}},
    4322   {"getfacl",cmd_getfacl,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE,COMPL_LOCAL}},
     4906  {"getfacl",cmd_getfacl,"<file name> get the POSIX ACL on a file (UNIX extensions only)",{COMPL_REMOTE,COMPL_NONE}},
    43234907  {"geteas", cmd_geteas, "<file name> get the EA list of a file",
    4324    {COMPL_REMOTE, COMPL_LOCAL}},
     4908   {COMPL_REMOTE, COMPL_NONE}},
    43254909  {"hardlink",cmd_hardlink,"<src> <dest> create a Windows hard link",{COMPL_REMOTE,COMPL_REMOTE}},
    43264910  {"help",cmd_help,"[command] give help on a command",{COMPL_NONE,COMPL_NONE}},
    … …  
    43304914  {"link",cmd_link,"<oldname> <newname> create a UNIX hard link",{COMPL_REMOTE,COMPL_REMOTE}},
    43314915  {"lock",cmd_lock,"lock <fnum> [r|w] <hex-start> <hex-len> : set a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},
    4332   {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}}, 
     4916  {"lowercase",cmd_lowercase,"toggle lowercasing of filenames for get",{COMPL_NONE,COMPL_NONE}},
    43334917  {"ls",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
    43344918  {"l",cmd_dir,"<mask> list the contents of the current directory",{COMPL_REMOTE,COMPL_NONE}},
    … …  
    43374921  {"mget",cmd_mget,"<mask> get all the matching files",{COMPL_REMOTE,COMPL_NONE}},
    43384922  {"mkdir",cmd_mkdir,"<directory> make a directory",{COMPL_NONE,COMPL_NONE}},
    4339   {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}}, 
     4923  {"more",cmd_more,"<remote name> view a remote file with your pager",{COMPL_REMOTE,COMPL_NONE}},
    43404924  {"mput",cmd_mput,"<mask> put all matching files",{COMPL_REMOTE,COMPL_NONE}},
    43414925  {"newer",cmd_newer,"<file> only mget files newer than the specified local file",{COMPL_LOCAL,COMPL_NONE}},
     4926  {"notify",cmd_notify,"<file>Get notified of dir changes",{COMPL_REMOTE,COMPL_NONE}},
    43424927  {"open",cmd_open,"<mask> open a file",{COMPL_REMOTE,COMPL_NONE}},
    43434928  {"posix", cmd_posix, "turn on all POSIX capabilities", {COMPL_REMOTE,COMPL_NONE}},
    … …  
    43484933  {"posix_unlink",cmd_posix_unlink,"<name> removes a file using POSIX interface",{COMPL_REMOTE,COMPL_NONE}},
    43494934  {"print",cmd_print,"<file name> print a file",{COMPL_NONE,COMPL_NONE}},
    4350   {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}}, 
     4935  {"prompt",cmd_prompt,"toggle prompting for filenames for mget and mput",{COMPL_NONE,COMPL_NONE}},
    43514936  {"put",cmd_put,"<local name> [remote name] put a file",{COMPL_LOCAL,COMPL_REMOTE}},
    43524937  {"pwd",cmd_pwd,"show current remote directory (same as 'cd' with no args)",{COMPL_NONE,COMPL_NONE}},
    … …  
    43564941  {"readlink",cmd_readlink,"filename Do a UNIX extensions readlink call on a symlink",{COMPL_REMOTE,COMPL_REMOTE}},
    43574942  {"rd",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
    4358   {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}}, 
     4943  {"recurse",cmd_recurse,"toggle directory recursion for mget and mput",{COMPL_NONE,COMPL_NONE}},
    43594944  {"reget",cmd_reget,"<remote name> [local name] get a file restarting at end of local file",{COMPL_REMOTE,COMPL_LOCAL}},
    43604945  {"rename",cmd_rename,"<src> <dest> rename some files",{COMPL_REMOTE,COMPL_REMOTE}},
    43614946  {"reput",cmd_reput,"<local name> [remote name] put a file restarting at end of remote file",{COMPL_LOCAL,COMPL_REMOTE}},
    43624947  {"rm",cmd_del,"<mask> delete all matching files",{COMPL_REMOTE,COMPL_NONE}},
    4363   {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_NONE,COMPL_NONE}},
    4364   {"showacls",cmd_showacls,"toggle if ACLs are shown or not",{COMPL_NONE,COMPL_NONE}}, 
     4948  {"rmdir",cmd_rmdir,"<directory> remove a directory",{COMPL_REMOTE,COMPL_NONE}},
     4949  {"showacls",cmd_showacls,"toggle if ACLs are shown or not",{COMPL_NONE,COMPL_NONE}},
    43654950  {"setea", cmd_setea, "<file name> <eaname> <eaval> Set an EA of a file",
    43664951   {COMPL_REMOTE, COMPL_LOCAL}},
    4367   {"setmode",cmd_setmode,"filename <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},
    4368   {"stat",cmd_stat,"filename Do a UNIX extensions stat call on a file",{COMPL_REMOTE,COMPL_REMOTE}},
     4952  {"setmode",cmd_setmode,"<file name> <setmode string> change modes of file",{COMPL_REMOTE,COMPL_NONE}},
     4953  {"scopy",cmd_scopy,"<src> <dest> server-side copy file",{COMPL_REMOTE,COMPL_REMOTE}},
     4954  {"stat",cmd_stat,"<file name> Do a UNIX extensions stat call on a file",{COMPL_REMOTE,COMPL_NONE}},
    43694955  {"symlink",cmd_symlink,"<oldname> <newname> create a UNIX symlink",{COMPL_REMOTE,COMPL_REMOTE}},
    43704956  {"tar",cmd_tar,"tar <c|x>[IXFqbgNan] current directory to/from <file name>",{COMPL_NONE,COMPL_NONE}},
    43714957  {"tarmode",cmd_tarmode,"<full|inc|reset|noreset> tar's behaviour towards archive bits",{COMPL_NONE,COMPL_NONE}},
     4958  {"timeout",cmd_timeout,"timeout <number> - set the per-operation timeout in seconds (default 20)",{COMPL_NONE,COMPL_NONE}},
    43724959  {"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},
    43734960  {"unlock",cmd_unlock,"unlock <fnum> <hex-start> <hex-len> : remove a POSIX lock",{COMPL_REMOTE,COMPL_REMOTE}},
    … …  
    43784965  {"listconnect",cmd_list_connect,"list open connections",{COMPL_NONE,COMPL_NONE}},
    43794966  {"showconnect",cmd_show_connect,"display the current active connection",{COMPL_NONE,COMPL_NONE}},
     4967  {"tcon",cmd_tcon,"connect to a share" ,{COMPL_NONE,COMPL_NONE}},
     4968  {"tdis",cmd_tdis,"disconnect from a share",{COMPL_NONE,COMPL_NONE}},
     4969  {"tid",cmd_tid,"show or set the current tid (tree-id)",{COMPL_NONE,COMPL_NONE}},
     4970  {"logoff",cmd_logoff,"log off (close the session)",{COMPL_NONE,COMPL_NONE}},
    43804971  {"..",cmd_cd_oneup,"change the remote directory (up one level)",{COMPL_REMOTE,COMPL_NONE}},
    43814972
    … …  
    44585049
    44595050        if (!cli) {
    4460                 cli = cli_cm_open(talloc_tos(), NULL,
    4461                                 have_ip ? dest_ss_str : desthost,
    4462                                 service, auth_info,
    4463                                 true, smb_encrypt,
    4464                                 max_protocol, port, name_type);
    4465                 if (!cli) {
     5051                NTSTATUS status;
     5052
     5053                status = cli_cm_open(talloc_tos(), NULL,
     5054                                     have_ip ? dest_ss_str : desthost,
     5055                                     service, auth_info,
     5056                                     true, smb_encrypt,
     5057                                     max_protocol, port, name_type,
     5058                                     &cli);
     5059                if (!NT_STATUS_IS_OK(status)) {
    44665060                        return 1;
    44675061                }
     5062                cli_set_timeout(cli, io_timeout*1000);
    44685063        }
    44695064
    … …  
    46385233        }
    46395234
    4640         if (!cli_resolve_path(ctx, "", auth_info, cli, dirmask, &targetcli, &targetpath)) {
     5235        status = cli_resolve_path(ctx, "", auth_info, cli, dirmask, &targetcli,
     5236                                  &targetpath);
     5237        if (!NT_STATUS_IS_OK(status)) {
    46415238                goto cleanup;
    46425239        }
    … …  
    46765273        info.matches[0] = SMB_STRNDUP(info.matches[1], info.samelen);
    46775274        info.matches[info.count] = NULL;
     5275        TALLOC_FREE(ctx);
    46785276        return info.matches;
    46795277
    … …  
    47885386        struct timespec now;
    47895387        time_t t;
    4790         int ret, revents;
     5388        NTSTATUS status;
     5389        unsigned char garbage[16];
    47915390
    47925391        clock_gettime_mono(&now);
    … …  
    47985397        last_t = t;
    47995398
    4800  again:
    4801 
    4802         if (cli->fd == -1)
     5399        /* Ping the server to keep the connection alive using SMBecho. */
     5400        memset(garbage, 0xf0, sizeof(garbage));
     5401        status = cli_echo(cli, 1, data_blob_const(garbage, sizeof(garbage)));
     5402        if (NT_STATUS_IS_OK(status)) {
    48035403                return;
    4804 
    4805         /* We deliberately use receive_smb_raw instead of
    4806            client_receive_smb as we want to receive
    4807            session keepalives and then drop them here.
    4808         */
    4809 
    4810         ret = poll_intr_one_fd(cli->fd, POLLIN|POLLHUP, 0, &revents);
    4811 
    4812         if ((ret > 0) && (revents & (POLLIN|POLLHUP|POLLERR))) {
    4813                 NTSTATUS status;
    4814                 size_t len;
    4815 
    4816                 set_smb_read_error(&cli->smb_rw_error, SMB_READ_OK);
    4817 
    4818                 status = receive_smb_raw(cli->fd, cli->inbuf, cli->bufsize, 0, 0, &len);
    4819 
    4820                 if (!NT_STATUS_IS_OK(status)) {
    4821                         DEBUG(0, ("Read from server failed, maybe it closed "
    4822                                   "the connection\n"));
    4823 
    4824                         finished = true;
    4825                         smb_readline_done();
    4826                         if (NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE)) {
    4827                                 set_smb_read_error(&cli->smb_rw_error,
    4828                                                    SMB_READ_EOF);
    4829                                 return;
    4830                         }
    4831 
    4832                         if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
    4833                                 set_smb_read_error(&cli->smb_rw_error,
    4834                                                    SMB_READ_TIMEOUT);
    4835                                 return;
    4836                         }
    4837 
    4838                         set_smb_read_error(&cli->smb_rw_error, SMB_READ_ERROR);
    4839                         return;
    4840                 }
    4841                 if(CVAL(cli->inbuf,0) != SMBkeepalive) {
    4842                         DEBUG(0, ("Read from server "
    4843                                 "returned unexpected packet!\n"));
    4844                         return;
    4845                 }
    4846 
    4847                 goto again;
    4848         }
    4849 
    4850         /* Ping the server to keep the connection alive using SMBecho. */
    4851         {
    4852                 NTSTATUS status;
    4853                 unsigned char garbage[16];
    4854                 memset(garbage, 0xf0, sizeof(garbage));
    4855                 status = cli_echo(cli, 1, data_blob_const(garbage, sizeof(garbage)));
    4856 
    4857                 if (NT_STATUS_IS_OK(status)) {
    4858                         return;
    4859                 }
    4860 
    4861                 if (!cli_state_is_connected(cli)) {
    4862                         DEBUG(0, ("SMBecho failed (%s). The connection is "
    4863                                 "disconnected now\n", nt_errstr(status)));
    4864                         finished = true;
    4865                         smb_readline_done();
    4866                 }
     5404        }
     5405
     5406        if (!cli_state_is_connected(cli)) {
     5407                DEBUG(0,("SMBecho failed (%s). The connection is "
     5408                         "disconnected now\n", nt_errstr(status)));
     5409                finished = true;
     5410                smb_readline_done();
    48675411        }
    48685412}
    … …  
    49345478{
    49355479        int rc = 0;
    4936 
    4937         cli = cli_cm_open(talloc_tos(), NULL,
    4938                         have_ip ? dest_ss_str : desthost,
    4939                         service, auth_info, true, smb_encrypt,
    4940                         max_protocol, port, name_type);
    4941         if (!cli) {
    4942                 return 1;
    4943         }
     5480        NTSTATUS status;
     5481
     5482        status = cli_cm_open(talloc_tos(), NULL,
     5483                             have_ip ? dest_ss_str : desthost,
     5484                             service, auth_info, true, smb_encrypt,
     5485                             max_protocol, port, name_type, &cli);
     5486        if (!NT_STATUS_IS_OK(status)) {
     5487                return 1;
     5488        }
     5489
     5490        cli_set_timeout(cli, io_timeout*1000);
    49445491
    49455492        if (base_directory && *base_directory) {
    … …  
    49675514static int do_host_query(const char *query_host)
    49685515{
    4969         cli = cli_cm_open(talloc_tos(), NULL,
    4970                         have_ip ? dest_ss_str : query_host, "IPC$", auth_info, true, smb_encrypt,
    4971                         max_protocol, port, name_type);
    4972         if (!cli)
    4973                 return 1;
    4974 
     5516        NTSTATUS status;
     5517
     5518        status = cli_cm_open(talloc_tos(), NULL,
     5519                             have_ip ? dest_ss_str : query_host,
     5520                             "IPC$", auth_info, true, smb_encrypt,
     5521                             max_protocol, port, name_type, &cli);
     5522        if (!NT_STATUS_IS_OK(status)) {
     5523                return 1;
     5524        }
     5525
     5526        cli_set_timeout(cli, io_timeout*1000);
    49755527        browse_host(true);
    49765528
    … …  
    49875539        }
    49885540
    4989         if (port != 139) {
     5541        if (port != NBT_SMB_PORT) {
    49905542
    49915543                /* Workgroups simply don't make sense over anything
    … …  
    49935545
    49945546                cli_shutdown(cli);
    4995                 cli = cli_cm_open(talloc_tos(), NULL,
    4996                                 have_ip ? dest_ss_str : query_host, "IPC$",
    4997                                 auth_info, true, smb_encrypt,
    4998                                 max_protocol, 139, name_type);
     5547                status = cli_cm_open(talloc_tos(), NULL,
     5548                                     have_ip ? dest_ss_str : query_host,
     5549                                     "IPC$", auth_info, true, smb_encrypt,
     5550                                     max_protocol, NBT_SMB_PORT, name_type,
     5551                                     &cli);
     5552                if (!NT_STATUS_IS_OK(status)) {
     5553                        cli = NULL;
     5554                }
    49995555        }
    50005556
    50015557        if (cli == NULL) {
    50025558                d_printf("NetBIOS over TCP disabled -- no workgroup available\n");
    5003                 return 1;
    5004         }
    5005 
     5559                return 0;
     5560        }
     5561
     5562        cli_set_timeout(cli, io_timeout*1000);
    50065563        list_servers(lp_workgroup());
    50075564
    … …  
    50175574static int do_tar_op(const char *base_directory)
    50185575{
    5019         int ret;
     5576        struct tar *tar_ctx = tar_get_ctx();
     5577        int ret = 0;
    50205578
    50215579        /* do we already have a connection? */
    50225580        if (!cli) {
    5023                 cli = cli_cm_open(talloc_tos(), NULL,
    5024                         have_ip ? dest_ss_str : desthost,
    5025                         service, auth_info, true, smb_encrypt,
    5026                         max_protocol, port, name_type);
    5027                 if (!cli)
    5028                         return 1;
    5029         }
    5030 
    5031         recurse=true;
     5581                NTSTATUS status;
     5582
     5583                status = cli_cm_open(talloc_tos(), NULL,
     5584                                     have_ip ? dest_ss_str : desthost,
     5585                                     service, auth_info, true, smb_encrypt,
     5586                                     max_protocol, port, name_type, &cli);
     5587                if (!NT_STATUS_IS_OK(status)) {
     5588            ret = 1;
     5589            goto out;
     5590                }
     5591                cli_set_timeout(cli, io_timeout*1000);
     5592        }
     5593
     5594        recurse = true;
    50325595
    50335596        if (base_directory && *base_directory)  {
    50345597                ret = do_cd(base_directory);
    50355598                if (ret) {
    5036                         cli_shutdown(cli);
    5037                         return ret;
    5038                 }
    5039         }
    5040 
    5041         ret=process_tar();
    5042 
     5599            goto out_cli;
     5600                }
     5601        }
     5602
     5603        ret = tar_process(tar_ctx);
     5604
     5605 out_cli:
    50435606        cli_shutdown(cli);
    5044 
    5045         return(ret);
     5607 out:
     5608        return ret;
    50465609}
    50475610
    … …  
    50525615static int do_message_op(struct user_auth_info *a_info)
    50535616{
    5054         struct sockaddr_storage ss;
    5055         struct nmb_name called, calling;
    5056         fstring server_name;
    5057         char name_type_hex[10];
    5058         int msg_port;
    50595617        NTSTATUS status;
    50605618
    5061         make_nmb_name(&calling, calling_name, 0x0);
    5062         make_nmb_name(&called , desthost, name_type);
    5063 
    5064         fstrcpy(server_name, desthost);
    5065         snprintf(name_type_hex, sizeof(name_type_hex), "#%X", name_type);
    5066         fstrcat(server_name, name_type_hex);
    5067 
    5068         zero_sockaddr(&ss);
    5069         if (have_ip)
    5070                 ss = dest_ss;
    5071 
    5072         /* we can only do messages over port 139 (to windows clients at least) */
    5073 
    5074         msg_port = port ? port : 139;
    5075 
    5076         if (!(cli=cli_initialise())) {
    5077                 d_printf("Connection to %s failed\n", desthost);
    5078                 return 1;
    5079         }
    5080         cli_set_port(cli, msg_port);
    5081 
    5082         status = cli_connect(cli, server_name, &ss);
     5619        status = cli_connect_nb(desthost, have_ip ? &dest_ss : NULL,
     5620                                port ? port : NBT_SMB_PORT, name_type,
     5621                                lp_netbios_name(), SMB_SIGNING_DEFAULT, 0, &cli);
    50835622        if (!NT_STATUS_IS_OK(status)) {
    50845623                d_printf("Connection to %s failed. Error %s\n", desthost, nt_errstr(status));
    … …  
    50865625        }
    50875626
    5088         if (!cli_session_request(cli, &calling, &called)) {
    5089                 d_printf("session request failed\n");
    5090                 cli_shutdown(cli);
    5091                 return 1;
    5092         }
    5093 
     5627        cli_set_timeout(cli, io_timeout*1000);
    50945628        send_message(get_cmdline_auth_info_username(a_info));
    50955629        cli_shutdown(cli);
    … …  
    51025636****************************************************************************/
    51035637
    5104  int main(int argc,char *argv[])
    5105 {
     5638int main(int argc,char *argv[])
     5639{
     5640        const char **const_argv = discard_const_p(const char *, argv);
    51065641        char *base_directory = NULL;
    51075642        int opt;
    … …  
    51125647        char *p;
    51135648        int rc = 0;
    5114         fstring new_workgroup;
    51155649        bool tar_opt = false;
    51165650        bool service_opt = false;
     5651        struct tar *tar_ctx = tar_get_ctx();
     5652
    51175653        struct poptOption long_options[] = {
    51185654                POPT_AUTOHELP
    … …  
    51265662                { "tar", 'T', POPT_ARG_STRING, NULL, 'T', "Command line tar", "<c|x>IXFqgbNan" },
    51275663                { "directory", 'D', POPT_ARG_STRING, NULL, 'D', "Start from directory", "DIR" },
    5128                 { "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" }, 
     5664                { "command", 'c', POPT_ARG_STRING, &cmdstr, 'c', "Execute semicolon separated commands" },
    51295665                { "send-buffer", 'b', POPT_ARG_INT, &io_bufsize, 'b', "Changes the transmit/send buffer", "BYTES" },
     5666                { "timeout", 't', POPT_ARG_INT, &io_timeout, 'b', "Changes the per-operation timeout", "SECONDS" },
    51305667                { "port", 'p', POPT_ARG_INT, &port, 'p', "Port to connect to", "PORT" },
    51315668                { "grepable", 'g', POPT_ARG_NONE, NULL, 'g', "Produce grepable output" },
    … …  
    51425679        }
    51435680
    5144         /* initialize the workgroup name so we can determine whether or
    5145            not it was set by a command line option */
    5146 
    5147         set_global_myworkgroup( "" );
    5148         set_global_myname( "" );
    5149 
    51505681        /* set default debug level to 1 regardless of what smb.conf sets */
    51515682        setup_logging( "smbclient", DEBUG_DEFAULT_STDERR );
    5152         load_case_tables();
     5683        smb_init_locale();
    51535684
    51545685        lp_set_cmdline("log level", "1");
    … …  
    51615692
    51625693        /* skip argv(0) */
    5163         pc = poptGetContext("smbclient", argc, (const char **) argv, long_options, 0);
     5694        pc = poptGetContext("smbclient", argc, const_argv, long_options, 0);
    51645695        poptSetOtherOptionHelp(pc, "service <password>");
    5165 
    5166         lp_set_in_client(true); /* Make sure that we tell lp_load we are */
    51675696
    51685697        while ((opt = poptGetNextOpt(pc)) != -1) {
    … …  
    51935722                                                       poptGetArg(pc));
    51945723                }
     5724
    51955725
    51965726                switch (opt) {
    … …  
    52065736                        }
    52075737                        if( !port )
    5208                                 port = 139;
     5738                                port = NBT_SMB_PORT;
    52095739                        message = true;
    52105740                        break;
    … …  
    52305760                        break;
    52315761                case 'm':
    5232                         max_protocol = interpret_protocol(poptGetOptArg(pc), max_protocol);
     5762                        lp_set_cmdline("client max protocol", poptGetOptArg(pc));
    52335763                        break;
    52345764                case 'T':
    … …  
    52375767                        {
    52385768                                int i;
     5769
    52395770                                for (i = 1; i < argc; i++) {
    52405771                                        if (strncmp("-T", argv[i],2)==0)
    … …  
    52425773                                }
    52435774                                i++;
    5244                                 if (!tar_parseargs(argc, argv, poptGetOptArg(pc), i)) {
     5775                                if (tar_parse_args(tar_ctx, poptGetOptArg(pc),
     5776                                                   const_argv + i, argc - i)) {
    52455777                                        poptPrintUsage(pc, stderr, 0);
    52465778                                        exit(1);
    … …  
    52935825        }
    52945826
    5295         /* save the workgroup...
    5296 
    5297            FIXME!! do we need to do this for other options as well
    5298            (or maybe a generic way to keep lp_load() from overwriting
    5299            everything)?  */
    5300 
    5301         fstrcpy( new_workgroup, lp_workgroup() );
    5302         calling_name = talloc_strdup(frame, global_myname() );
    5303         if (!calling_name) {
    5304                 exit(ENOMEM);
    5305         }
    5306 
    53075827        if ( override_logfile )
    5308                 setup_logging( lp_logfile(), DEBUG_FILE );
    5309 
    5310         if (!lp_load(get_dyn_CONFIGFILE(),true,false,false,true)) {
     5828                setup_logging( lp_logfile(talloc_tos()), DEBUG_FILE );
     5829
     5830        if (!lp_load_client(get_dyn_CONFIGFILE())) {
    53115831                fprintf(stderr, "%s: Can't load %s - run testparm to debug it\n",
    53125832                        argv[0], get_dyn_CONFIGFILE());
    … …  
    53385858        }
    53395859
    5340         if ( strlen(new_workgroup) != 0 ) {
    5341                 set_global_myworkgroup( new_workgroup );
    5342         }
    5343 
    5344         if ( strlen(calling_name) != 0 ) {
    5345                 set_global_myname( calling_name );
    5346         } else {
    5347                 TALLOC_FREE(calling_name);
    5348                 calling_name = talloc_strdup(frame, global_myname() );
    5349         }
    5350 
    53515860        smb_encrypt = get_cmdline_auth_info_smb_encrypt(auth_info);
    53525861        if (!init_names()) {
    … …  
    53565865
    53575866        if(new_name_resolve_order)
    5358                 lp_set_name_resolve_order(new_name_resolve_order);
    5359 
    5360         if (!tar_type && !query_host && !service && !message) {
     5867                lp_set_cmdline("name resolve order", new_name_resolve_order);
     5868
     5869        if (!tar_to_process(tar_ctx) && !query_host && !service && !message) {
    53615870                poptPrintUsage(pc, stderr, 0);
    53625871                exit(1);
    … …  
    53645873
    53655874        poptFreeContext(pc);
     5875        popt_burn_cmdline_password(argc, argv);
    53665876
    53675877        DEBUG(3,("Client started (version %s).\n", samba_version_string()));
    … …  
    53705880        set_cmdline_auth_info_getpass(auth_info);
    53715881
    5372         if (tar_type) {
     5882        max_protocol = lp_client_max_protocol();
     5883
     5884        if (tar_to_process(tar_ctx)) {
    53735885                if (cmdstr)
    53745886                        process_command_string(cmdstr);
    5375                 return do_tar_op(base_directory);
    5376         }
    5377 
    5378         if (query_host && *query_host) {
     5887                rc = do_tar_op(base_directory);
     5888        } else if (query_host && *query_host) {
    53795889                char *qhost = query_host;
    53805890                char *slash;
    … …  
    53945904                }
    53955905
    5396                 return do_host_query(qhost);
    5397         }
    5398 
    5399         if (message) {
    5400                 return do_message_op(auth_info);
    5401         }
    5402 
    5403         if (process(base_directory)) {
    5404                 return 1;
     5906                rc = do_host_query(qhost);
     5907        } else if (message) {
     5908                rc = do_message_op(auth_info);
     5909        } else if (process(base_directory)) {
     5910                rc = 1;
    54055911        }
    54065912
Note: See TracChangeset for help on using the changeset viewer.