LCOV - code coverage report
Current view: top level - source4/libcli/raw - rawnegotiate.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 51 70 72.9 %
Date: 2021-09-23 10:06:22 Functions: 4 5 80.0 %

          Line data    Source code
       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    SMB client negotiate context management functions
       5             : 
       6             :    Copyright (C) Andrew Tridgell 1994-2005
       7             :    Copyright (C) James Myers 2003 <myersjj@samba.org>
       8             :    
       9             :    This program is free software; you can redistribute it and/or modify
      10             :    it under the terms of the GNU General Public License as published by
      11             :    the Free Software Foundation; either version 3 of the License, or
      12             :    (at your option) any later version.
      13             :    
      14             :    This program is distributed in the hope that it will be useful,
      15             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      17             :    GNU General Public License for more details.
      18             :    
      19             :    You should have received a copy of the GNU General Public License
      20             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      21             : */
      22             : 
      23             : #include "includes.h"
      24             : #include <tevent.h>
      25             : #include "system/time.h"
      26             : #include "libcli/raw/libcliraw.h"
      27             : #include "libcli/raw/raw_proto.h"
      28             : #include "../libcli/smb/smbXcli_base.h"
      29             : #include "../lib/util/tevent_ntstatus.h"
      30             : 
      31        2774 : NTSTATUS smb_raw_negotiate_fill_transport(struct smbcli_transport *transport)
      32             : {
      33        2774 :         struct smbcli_negotiate *n = &transport->negotiate;
      34        2774 :         struct smbXcli_conn *c = transport->conn;
      35             :         NTTIME ntt;
      36             : 
      37        2774 :         n->protocol = smbXcli_conn_protocol(c);
      38        2774 :         if (n->protocol > PROTOCOL_NT1) {
      39           0 :                 return NT_STATUS_REVISION_MISMATCH;
      40             :         }
      41             : 
      42        2774 :         n->sec_mode = smb1cli_conn_server_security_mode(c);
      43        2774 :         n->max_mux  = smbXcli_conn_max_requests(c);
      44        2774 :         n->max_xmit = smb1cli_conn_max_xmit(c);
      45        2774 :         n->sesskey  = smb1cli_conn_server_session_key(c);
      46        2774 :         n->capabilities = smb1cli_conn_capabilities(c);;
      47             : 
      48             :         /* this time arrives in real GMT */
      49        2774 :         ntt = smbXcli_conn_server_system_time(c);
      50        2774 :         n->server_time = nt_time_to_unix(ntt);
      51        2774 :         n->server_zone = smb1cli_conn_server_time_zone(c);
      52             : 
      53        2774 :         if (n->capabilities & CAP_EXTENDED_SECURITY) {
      54        2752 :                 const DATA_BLOB *b = smbXcli_conn_server_gss_blob(c);
      55        2752 :                 if (b) {
      56        2752 :                         n->secblob = *b;
      57             :                 }
      58             :         } else {
      59          22 :                 const uint8_t *p = smb1cli_conn_server_challenge(c);
      60          22 :                 if (p) {
      61          22 :                         n->secblob = data_blob_const(p, 8);
      62             :                 }
      63             :         }
      64             : 
      65        2774 :         n->readbraw_supported = smb1cli_conn_server_readbraw(c);
      66        2774 :         n->readbraw_supported = smb1cli_conn_server_writebraw(c);
      67        2774 :         n->lockread_supported = smb1cli_conn_server_lockread(c);
      68             : 
      69        2774 :         return NT_STATUS_OK;
      70             : }
      71             : 
      72             : struct smb_raw_negotiate_state {
      73             :         struct smbcli_transport *transport;
      74             : };
      75             : 
      76             : static void smb_raw_negotiate_done(struct tevent_req *subreq);
      77             : 
      78        3450 : struct tevent_req *smb_raw_negotiate_send(TALLOC_CTX *mem_ctx,
      79             :                                           struct tevent_context *ev,
      80             :                                           struct smbcli_transport *transport,
      81             :                                           int minprotocol,
      82             :                                           int maxprotocol)
      83             : {
      84             :         struct tevent_req *req;
      85             :         struct smb_raw_negotiate_state *state;
      86             :         struct tevent_req *subreq;
      87        3450 :         uint32_t timeout_msec = transport->options.request_timeout * 1000;
      88             : 
      89        3450 :         req = tevent_req_create(mem_ctx, &state,
      90             :                                 struct smb_raw_negotiate_state);;
      91        3450 :         if (req == NULL) {
      92           0 :                 return NULL;
      93             :         }
      94        3450 :         state->transport = transport;
      95             : 
      96        3450 :         if (maxprotocol > PROTOCOL_NT1) {
      97           0 :                 maxprotocol = PROTOCOL_NT1;
      98             :         }
      99             : 
     100        3450 :         if (minprotocol > maxprotocol) {
     101          16 :                 minprotocol = maxprotocol;
     102             :         }
     103             : 
     104        3450 :         subreq = smbXcli_negprot_send(state, ev,
     105             :                                       transport->conn,
     106             :                                       timeout_msec,
     107             :                                       minprotocol,
     108             :                                       maxprotocol,
     109        3450 :                                       transport->options.max_credits);
     110        3450 :         if (tevent_req_nomem(subreq, req)) {
     111           0 :                 return tevent_req_post(req, ev);
     112             :         }
     113        3450 :         tevent_req_set_callback(subreq, smb_raw_negotiate_done, req);
     114             : 
     115        3450 :         return req;
     116             : }
     117             : 
     118        2856 : static void smb_raw_negotiate_done(struct tevent_req *subreq)
     119             : {
     120        2469 :         struct tevent_req *req =
     121        2856 :                 tevent_req_callback_data(subreq,
     122             :                 struct tevent_req);
     123        2469 :         struct smb_raw_negotiate_state *state =
     124        2856 :                 tevent_req_data(req,
     125             :                 struct smb_raw_negotiate_state);
     126             :         NTSTATUS status;
     127             : 
     128        2856 :         status = smbXcli_negprot_recv(subreq);
     129        2856 :         TALLOC_FREE(subreq);
     130        2856 :         if (tevent_req_nterror(req, status)) {
     131         174 :                 return;
     132             :         }
     133             : 
     134        2748 :         status = smb_raw_negotiate_fill_transport(state->transport);
     135        2748 :         if (tevent_req_nterror(req, status)) {
     136           0 :                 return;
     137             :         }
     138             : 
     139        2748 :         tevent_req_done(req);
     140             : }
     141             : 
     142             : /*
     143             :  Send a negprot command.
     144             : */
     145        2850 : NTSTATUS smb_raw_negotiate_recv(struct tevent_req *req)
     146             : {
     147        2850 :         return tevent_req_simple_recv_ntstatus(req);
     148             : }
     149             : 
     150             : 
     151             : /*
     152             :  Send a negprot command (sync interface)
     153             : */
     154           0 : NTSTATUS smb_raw_negotiate(struct smbcli_transport *transport, bool unicode,
     155             :                            int minprotocol, int maxprotocol)
     156             : {
     157             :         NTSTATUS status;
     158           0 :         struct tevent_req *subreq = NULL;
     159             :         bool ok;
     160             : 
     161           0 :         subreq = smb_raw_negotiate_send(transport,
     162             :                                         transport->ev,
     163             :                                         transport,
     164             :                                         minprotocol,
     165             :                                         maxprotocol);
     166           0 :         if (subreq == NULL) {
     167           0 :                 status = NT_STATUS_NO_MEMORY;
     168           0 :                 goto failed;
     169             :         }
     170             : 
     171           0 :         ok = tevent_req_poll(subreq, transport->ev);
     172           0 :         if (!ok) {
     173           0 :                 status = map_nt_error_from_unix_common(errno);
     174           0 :                 goto failed;
     175             :         }
     176             : 
     177           0 :         status = smb_raw_negotiate_recv(subreq);
     178             : 
     179           0 : failed:
     180           0 :         TALLOC_FREE(subreq);
     181           0 :         return status;
     182             : }

Generated by: LCOV version 1.13