Make cli_negprot async

diff --git a/source3/include/proto.h b/source3/include/proto.h
index 8ec15da5d841f4da9c172bb753cddc89c5aa1e91..212bbf0df76f5fe6b25aa9561fb65c59c77bc5dd 100644 (file)
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -2366,6 +2366,10 @@ bool cli_send_tconX(struct cli_state *cli,
 bool cli_tdis(struct cli_state *cli);
 void cli_negprot_sendsync(struct cli_state *cli);
 NTSTATUS cli_negprot(struct cli_state *cli);
+struct async_req *cli_negprot_send(TALLOC_CTX *mem_ctx,
+                                  struct event_context *ev,
+                                  struct cli_state *cli);
+NTSTATUS cli_negprot_recv(struct async_req *req);
 bool cli_session_request(struct cli_state *cli,
                         struct nmb_name *calling, struct nmb_name *called);
 NTSTATUS cli_connect(struct cli_state *cli,

diff --git a/source3/libsmb/cliconnect.c b/source3/libsmb/cliconnect.c
index f34b38106a9561745ee01736c8b20d6c8bee6b5f..b5287774f539a440138672b7497bea736ebdbd22 100644 (file)
--- a/source3/libsmb/cliconnect.c
+++ b/source3/libsmb/cliconnect.c
@@ -1241,59 +1241,69 @@ void cli_negprot_sendsync(struct cli_state *cli)
  Send a negprot command.
 ****************************************************************************/
 
-NTSTATUS cli_negprot(struct cli_state *cli)
+struct async_req *cli_negprot_send(TALLOC_CTX *mem_ctx,
+                                  struct event_context *ev,
+                                  struct cli_state *cli)
 {
-       char *p;
+       struct async_req *result;
+       uint8_t *bytes = NULL;
        int numprots;
-       int plength;
 
        if (cli->protocol < PROTOCOL_NT1)
                cli->use_spnego = False;
 
-       memset(cli->outbuf,'\0',smb_size);
-
-       plength = 0;
-
        /* setup the protocol strings */
        for (numprots=0; numprots < ARRAY_SIZE(prots); numprots++) {
+               uint8_t c = 2;
                if (prots[numprots].prot > cli->protocol) {
                        break;
                }
-               plength += strlen(prots[numprots].name)+2;
-       }
-
-       cli_set_message(cli->outbuf,0,plength,True);
-
-       p = smb_buf(cli->outbuf);
-       for (numprots=0; numprots < ARRAY_SIZE(prots); numprots++) {
-               if (prots[numprots].prot > cli->protocol) {
-                       break;
+               bytes = (uint8_t *)talloc_append_blob(
+                       talloc_tos(), bytes, data_blob_const(&c, sizeof(c)));
+               if (bytes == NULL) {
+                       return NULL;
+               }
+               bytes = smb_bytes_push_str(bytes, false, prots[numprots].name);
+               if (bytes == NULL) {
+                       return NULL;
                }
-               *p++ = 2;
-               p += clistr_push(cli, p, prots[numprots].name, -1, STR_TERMINATE);
        }
 
-       SCVAL(cli->outbuf,smb_com,SMBnegprot);
-       cli_setup_packet(cli);
+       result = cli_request_send(mem_ctx, ev, cli, SMBnegprot, 0, 0, NULL,
+                                 talloc_get_size(bytes), bytes);
+       TALLOC_FREE(bytes);
+       return result;
+}
 
-       SCVAL(smb_buf(cli->outbuf),0,2);
+NTSTATUS cli_negprot_recv(struct async_req *req)
+{
+       struct cli_request *cli_req = talloc_get_type_abort(
+               req->private_data, struct cli_request);
+       struct cli_state *cli = cli_req->cli;
+       uint8_t wct;
+       uint16_t *vwv;
+       uint16_t num_bytes;
+       uint8_t *bytes;
+       NTSTATUS status;
+       uint16_t protnum;
 
-       cli_send_smb(cli);
-       if (!cli_receive_smb(cli)) {
-               return NT_STATUS_UNEXPECTED_IO_ERROR;
+       if (async_req_is_error(req, &status)) {
+               return status;
        }
 
-       show_msg(cli->inbuf);
-
-       if (cli_is_error(cli)) {
-               return cli_nt_error(cli);
+       status = cli_pull_reply(req, &wct, &vwv, &num_bytes, &bytes);
+       if (!NT_STATUS_IS_OK(status)) {
+               return status;
        }
 
-       if ((int)SVAL(cli->inbuf,smb_vwv0) >= numprots) {
+       protnum = SVAL(vwv, 0);
+
+       if ((protnum >= ARRAY_SIZE(prots))
+           || (prots[protnum].prot > cli_req->cli->protocol)) {
                return NT_STATUS_INVALID_NETWORK_RESPONSE;
        }
 
-       cli->protocol = prots[SVAL(cli->inbuf,smb_vwv0)].prot;  
+       cli->protocol = prots[protnum].prot;
 
        if ((cli->protocol < PROTOCOL_NT1) && cli->sign_info.mandatory_signing) {
                DEBUG(0,("cli_negprot: SMB signing is mandatory and the selected protocol level doesn't support it.\n"));
@@ -1303,17 +1313,17 @@ NTSTATUS cli_negprot(struct cli_state *cli)
        if (cli->protocol >= PROTOCOL_NT1) {    
                struct timespec ts;
                /* NT protocol */
-               cli->sec_mode = CVAL(cli->inbuf,smb_vwv1);
-               cli->max_mux = SVAL(cli->inbuf, smb_vwv1+1);
-               cli->max_xmit = IVAL(cli->inbuf,smb_vwv3+1);
-               cli->sesskey = IVAL(cli->inbuf,smb_vwv7+1);
-               cli->serverzone = SVALS(cli->inbuf,smb_vwv15+1);
+               cli->sec_mode = CVAL(vwv + 1, 0);
+               cli->max_mux = SVAL(vwv + 1, 1);
+               cli->max_xmit = IVAL(vwv + 3, 1);
+               cli->sesskey = IVAL(vwv + 7, 1);
+               cli->serverzone = SVALS(vwv + 15, 1);
                cli->serverzone *= 60;
                /* this time arrives in real GMT */
-               ts = interpret_long_date(cli->inbuf+smb_vwv11+1);
+               ts = interpret_long_date(((char *)(vwv+11))+1);
                cli->servertime = ts.tv_sec;
-               cli->secblob = data_blob(smb_buf(cli->inbuf),smb_buflen(cli->inbuf));
-               cli->capabilities = IVAL(cli->inbuf,smb_vwv9+1);
+               cli->secblob = data_blob(bytes, num_bytes);
+               cli->capabilities = IVAL(vwv + 9, 1);
                if (cli->capabilities & CAP_RAW_MODE) {
                        cli->readbraw_supported = True;
                        cli->writebraw_supported = True;      
@@ -1321,9 +1331,10 @@ NTSTATUS cli_negprot(struct cli_state *cli)
                /* work out if they sent us a workgroup */
                if (!(cli->capabilities & CAP_EXTENDED_SECURITY) &&
                    smb_buflen(cli->inbuf) > 8) {
-                       clistr_pull(cli, cli->server_domain, 
-                                   smb_buf(cli->inbuf)+8, sizeof(cli->server_domain),
-                                   smb_buflen(cli->inbuf)-8, STR_UNICODE|STR_NOALIGN);
+                       clistr_pull(cli, cli->server_domain,
+                                   bytes+8, sizeof(cli->server_domain),
+                                   num_bytes-8,
+                                   STR_UNICODE|STR_NOALIGN);
                }
 
                /*
@@ -1361,17 +1372,18 @@ NTSTATUS cli_negprot(struct cli_state *cli)
 
        } else if (cli->protocol >= PROTOCOL_LANMAN1) {
                cli->use_spnego = False;
-               cli->sec_mode = SVAL(cli->inbuf,smb_vwv1);
-               cli->max_xmit = SVAL(cli->inbuf,smb_vwv2);
-               cli->max_mux = SVAL(cli->inbuf, smb_vwv3); 
-               cli->sesskey = IVAL(cli->inbuf,smb_vwv6);
-               cli->serverzone = SVALS(cli->inbuf,smb_vwv10);
+               cli->sec_mode = SVAL(vwv + 1, 0);
+               cli->max_xmit = SVAL(vwv + 2, 0);
+               cli->max_mux = SVAL(vwv + 3, 0);
+               cli->sesskey = IVAL(vwv + 6, 0);
+               cli->serverzone = SVALS(vwv + 10, 0);
                cli->serverzone *= 60;
                /* this time is converted to GMT by make_unix_date */
-               cli->servertime = cli_make_unix_date(cli,cli->inbuf+smb_vwv8);
-               cli->readbraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x1) != 0);
-               cli->writebraw_supported = ((SVAL(cli->inbuf,smb_vwv5) & 0x2) != 0);
-               cli->secblob = data_blob(smb_buf(cli->inbuf),smb_buflen(cli->inbuf));
+               cli->servertime = cli_make_unix_date(
+                       cli, (char *)(vwv + 8));
+               cli->readbraw_supported = ((SVAL(vwv + 5, 0) & 0x1) != 0);
+               cli->writebraw_supported = ((SVAL(vwv + 5, 0) & 0x2) != 0);
+               cli->secblob = data_blob(bytes, num_bytes);
        } else {
                /* the old core protocol */
                cli->use_spnego = False;
@@ -1388,6 +1400,41 @@ NTSTATUS cli_negprot(struct cli_state *cli)
        return NT_STATUS_OK;
 }
 
+NTSTATUS cli_negprot(struct cli_state *cli)
+{
+       TALLOC_CTX *frame = talloc_stackframe();
+       struct event_context *ev;
+       struct async_req *req;
+       NTSTATUS status = NT_STATUS_NO_MEMORY;
+
+       if (cli->fd_event != NULL) {
+               /*
+                * Can't use sync call while an async call is in flight
+                */
+               cli_set_error(cli, NT_STATUS_INVALID_PARAMETER);
+               goto fail;
+       }
+
+       ev = event_context_init(frame);
+       if (ev == NULL) {
+               goto fail;
+       }
+
+       req = cli_negprot_send(frame, ev, cli);
+       if (req == NULL) {
+               goto fail;
+       }
+
+       while (req->state < ASYNC_REQ_DONE) {
+               event_loop_once(ev);
+       }
+
+       status = cli_negprot_recv(req);
+ fail:
+       TALLOC_FREE(frame);
+       return status;
+}
+
 /****************************************************************************
  Send a session request. See rfc1002.txt 4.3 and 4.3.2.
 ****************************************************************************/