Line data    Source code

       1             : /* 
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    Copyright (C) Volker Lendecke 2005
       5             :    
       6             :    This program is free software; you can redistribute it and/or modify
       7             :    it under the terms of the GNU General Public License as published by
       8             :    the Free Software Foundation; either version 3 of the License, or
       9             :    (at your option) any later version.
      10             :    
      11             :    This program is distributed in the hope that it will be useful,
      12             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             :    GNU General Public License for more details.
      15             :    
      16             :    You should have received a copy of the GNU General Public License
      17             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      18             : */
      19             : /*
      20             :   a composite API for loading a whole file into memory
      21             : */
      22             : 
      23             : #include "includes.h"
      24             : #include "libcli/composite/composite.h"
      25             : #include "libcli/smb_composite/smb_composite.h"
      26             : #include "libcli/resolve/resolve.h"
      27             : 
      28             : enum fetchfile_stage {FETCHFILE_CONNECT,
      29             :                       FETCHFILE_READ};
      30             : 
      31             : struct fetchfile_state {
      32             :         enum fetchfile_stage stage;
      33             :         struct smb_composite_fetchfile *io;
      34             :         struct composite_context *creq;
      35             :         struct smb_composite_connect *connect;
      36             :         struct smb_composite_loadfile *loadfile;
      37             : };
      38             : 
      39             : static void fetchfile_composite_handler(struct composite_context *req);
      40             : 
      41          10 : static NTSTATUS fetchfile_connect(struct composite_context *c,
      42             :                                   struct smb_composite_fetchfile *io)
      43             : {
      44             :         NTSTATUS status;
      45             :         struct fetchfile_state *state;
      46          10 :         state = talloc_get_type(c->private_data, struct fetchfile_state);
      47             : 
      48          10 :         status = smb_composite_connect_recv(state->creq, c);
      49          10 :         NT_STATUS_NOT_OK_RETURN(status);
      50             : 
      51          10 :         state->loadfile = talloc(state, struct smb_composite_loadfile);
      52          10 :         NT_STATUS_HAVE_NO_MEMORY(state->loadfile);
      53             : 
      54          10 :         state->loadfile->in.fname = io->in.filename;
      55             : 
      56          10 :         state->creq = smb_composite_loadfile_send(state->connect->out.tree,
      57             :                                                  state->loadfile);
      58          10 :         NT_STATUS_HAVE_NO_MEMORY(state->creq);
      59             : 
      60          10 :         state->creq->async.private_data = c;
      61          10 :         state->creq->async.fn = fetchfile_composite_handler;
      62             : 
      63          10 :         state->stage = FETCHFILE_READ;
      64             : 
      65          10 :         return NT_STATUS_OK;
      66             : }
      67             : 
      68          10 : static NTSTATUS fetchfile_read(struct composite_context *c,
      69             :                                struct smb_composite_fetchfile *io)
      70             : {
      71             :         NTSTATUS status;
      72             :         struct fetchfile_state *state;
      73          10 :         state = talloc_get_type(c->private_data, struct fetchfile_state);
      74             : 
      75          10 :         status = smb_composite_loadfile_recv(state->creq, NULL);
      76          10 :         NT_STATUS_NOT_OK_RETURN(status);
      77             : 
      78          10 :         io->out.data = state->loadfile->out.data;
      79          10 :         io->out.size = state->loadfile->out.size;
      80             : 
      81          10 :         c->state = COMPOSITE_STATE_DONE;
      82          10 :         if (c->async.fn)
      83          10 :                 c->async.fn(c);
      84             : 
      85          10 :         return NT_STATUS_OK;
      86             : }
      87             : 
      88          20 : static void fetchfile_state_handler(struct composite_context *c)
      89             : {
      90             :         struct fetchfile_state *state;
      91             :         NTSTATUS status;
      92             :         
      93          20 :         state = talloc_get_type(c->private_data, struct fetchfile_state);
      94             : 
      95             :         /* when this handler is called, the stage indicates what
      96             :            call has just finished */
      97          20 :         switch (state->stage) {
      98          10 :         case FETCHFILE_CONNECT:
      99          10 :                 status = fetchfile_connect(c, state->io);
     100          10 :                 break;
     101          10 :         case FETCHFILE_READ:
     102          10 :                 status = fetchfile_read(c, state->io);
     103          10 :                 break;
     104           0 :         default:
     105           0 :                 status = NT_STATUS_UNSUCCESSFUL;
     106           0 :                 break;
     107             :         }
     108             : 
     109          20 :         if (!NT_STATUS_IS_OK(status)) {
     110           0 :                 c->status = status;
     111           0 :                 c->state = COMPOSITE_STATE_ERROR;
     112           0 :                 if (c->async.fn) {
     113           0 :                         c->async.fn(c);
     114             :                 }
     115             :         }
     116          20 : }
     117             : 
     118          20 : static void fetchfile_composite_handler(struct composite_context *creq)
     119             : {
     120          20 :         struct composite_context *c = talloc_get_type(creq->async.private_data, 
     121             :                                                       struct composite_context);
     122          20 :         fetchfile_state_handler(c);
     123          20 : }
     124             : 
     125          10 : struct composite_context *smb_composite_fetchfile_send(struct smb_composite_fetchfile *io,
     126             :                                                        struct tevent_context *event_ctx)
     127             : {
     128             :         struct composite_context *c;
     129             :         struct fetchfile_state *state;
     130             : 
     131          10 :         c = talloc_zero(NULL, struct composite_context);
     132          10 :         if (c == NULL) goto failed;
     133             : 
     134          10 :         state = talloc(c, struct fetchfile_state);
     135          10 :         if (state == NULL) goto failed;
     136             : 
     137          10 :         state->connect = talloc_zero(state, struct smb_composite_connect);
     138          10 :         if (state->connect == NULL) goto failed;
     139             : 
     140          10 :         state->io = io;
     141             : 
     142          10 :         state->connect->in.dest_host    = io->in.dest_host;
     143          10 :         state->connect->in.dest_ports   = io->in.ports;
     144          10 :         state->connect->in.socket_options = io->in.socket_options;
     145          10 :         state->connect->in.called_name  = io->in.called_name;
     146          10 :         state->connect->in.service      = io->in.service;
     147          10 :         state->connect->in.service_type = io->in.service_type;
     148          10 :         state->connect->in.credentials  = io->in.credentials;
     149          10 :         state->connect->in.fallback_to_anonymous = false;
     150          10 :         state->connect->in.workgroup    = io->in.workgroup;
     151          10 :         state->connect->in.gensec_settings = io->in.gensec_settings;
     152             : 
     153          10 :         state->connect->in.options        = io->in.options;
     154          10 :         state->connect->in.session_options = io->in.session_options;
     155             : 
     156          10 :         state->creq = smb_composite_connect_send(state->connect, state, 
     157             :                                                  io->in.resolve_ctx, event_ctx);
     158          10 :         if (state->creq == NULL) goto failed;
     159             : 
     160          10 :         state->creq->async.private_data = c;
     161          10 :         state->creq->async.fn = fetchfile_composite_handler;
     162             : 
     163          10 :         c->state = COMPOSITE_STATE_IN_PROGRESS;
     164          10 :         state->stage = FETCHFILE_CONNECT;
     165          10 :         c->private_data = state;
     166             : 
     167          10 :         return c;
     168           0 :  failed:
     169           0 :         talloc_free(c);
     170           0 :         return NULL;
     171             : }
     172             : 
     173          10 : NTSTATUS smb_composite_fetchfile_recv(struct composite_context *c,
     174             :                                       TALLOC_CTX *mem_ctx)
     175             : {
     176             :         NTSTATUS status;
     177             : 
     178          10 :         status = composite_wait(c);
     179             : 
     180          10 :         if (NT_STATUS_IS_OK(status)) {
     181          10 :                 struct fetchfile_state *state = talloc_get_type(c->private_data, struct fetchfile_state);
     182          10 :                 talloc_steal(mem_ctx, state->io->out.data);
     183             :         }
     184             : 
     185          10 :         talloc_free(c);
     186          10 :         return status;
     187             : }
     188             : 
     189           0 : NTSTATUS smb_composite_fetchfile(struct smb_composite_fetchfile *io,
     190             :                                  TALLOC_CTX *mem_ctx)
     191             : {
     192           0 :         struct composite_context *c = smb_composite_fetchfile_send(io, NULL);
     193           0 :         return smb_composite_fetchfile_recv(c, mem_ctx);
     194             : }