0ceb69e3b15ed7a232b0f998aeec65e041e1673d
[gd/samba-autobuild/.git] / source4 / client / cifsddio.c
1 /*
2    CIFSDD - dd for SMB.
3    IO routines, generic and specific.
4
5    Copyright (C) James Peach 2005-2006
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "system/filesys.h"
23 #include "libcli/libcli.h"
24 #include "lib/cmdline/popt_common.h"
25
26 #include "cifsdd.h"
27
28 /* ------------------------------------------------------------------------- */
29 /* UNIX file descriptor IO.                                                  */
30 /* ------------------------------------------------------------------------- */
31
32 struct fd_handle
33 {
34         struct dd_iohandle      h;
35         int                     fd;
36 };
37
38 #define IO_HANDLE_TO_FD(h) (((struct fd_handle *)(h))->fd)
39
40 static bool fd_seek_func(void * handle, uint64_t offset)
41 {
42         ssize_t ret;
43
44         ret = lseek(IO_HANDLE_TO_FD(handle), offset, SEEK_SET);
45         if (ret < 0) {
46                 fprintf(stderr, "%s: seek failed: %s\n",
47                                 PROGNAME, strerror(errno));
48                 return(false);
49         }
50
51         return(true);
52 }
53
54 static bool fd_read_func(void * handle,
55                         uint8_t * buf,
56                         uint64_t wanted,
57                         uint64_t * actual)
58 {
59         ssize_t ret;
60
61         ret = read(IO_HANDLE_TO_FD(handle), buf, wanted);
62         if (ret < 0) {
63                 fprintf(stderr, "%s: %llu byte read failed: %s\n",
64                                 PROGNAME, (unsigned long long)wanted,
65                                 strerror(errno));
66                 return(false);
67         }
68
69         *actual = (uint64_t)ret;
70         return(true);
71 }
72
73 static bool fd_write_func(void * handle,
74                         uint8_t * buf,
75                         uint64_t wanted,
76                         uint64_t * actual)
77 {
78         ssize_t ret;
79
80         ret = write(IO_HANDLE_TO_FD(handle), buf, wanted);
81         if (ret < 0) {
82                 fprintf(stderr, "%s: %llu byte write failed: %s\n",
83                                 PROGNAME, (unsigned long long)wanted,
84                                 strerror(errno));
85                 return(false);
86         }
87
88         *actual = (uint64_t)ret;
89         return(true);
90 }
91
92 static struct dd_iohandle * open_fd_handle(const char * path,
93                                         uint64_t io_size,
94                                         int options)
95 {
96         struct fd_handle * fdh;
97         int oflags = 0;
98
99         DEBUG(4, ("opening fd stream for %s\n", path));
100         if ((fdh = talloc_zero(NULL, struct fd_handle)) == NULL) {
101                 return(NULL);
102         }
103
104         fdh->h.io_read = fd_read_func;
105         fdh->h.io_write = fd_write_func;
106         fdh->h.io_seek = fd_seek_func;
107
108         if (options & DD_DIRECT_IO) {
109 #ifdef HAVE_OPEN_O_DIRECT
110                 oflags |= O_DIRECT;
111 #else
112                 DEBUG(1, ("no support for direct IO on this platform\n"));
113 #endif
114         }
115
116         if (options & DD_SYNC_IO)
117                 oflags |= O_SYNC;
118
119         oflags |= (options & DD_WRITE) ?  (O_WRONLY | O_CREAT) : (O_RDONLY);
120
121         fdh->fd = open(path, oflags, 0644);
122         if (fdh->fd < 0) {
123                 fprintf(stderr, "%s: %s: %s\n",
124                         PROGNAME, path, strerror(errno));
125                 talloc_free(fdh);
126                 return(NULL);
127         }
128
129         if (options & DD_OPLOCK) {
130                 DEBUG(2, ("FIXME: take local oplock on %s\n", path));
131         }
132
133         SMB_ASSERT((void *)fdh == (void *)&fdh->h);
134         return(&fdh->h);
135 }
136
137 /* ------------------------------------------------------------------------- */
138 /* CIFS client IO.                                                           */
139 /* ------------------------------------------------------------------------- */
140
141 struct cifs_handle
142 {
143         struct dd_iohandle      h;
144         struct smbcli_state *   cli;
145         int                     fnum;
146         uint64_t                offset;
147 };
148
149 #define IO_HANDLE_TO_SMB(h) ((struct cifs_handle *)(h))
150
151 static bool smb_seek_func(void * handle, uint64_t offset)
152 {
153         IO_HANDLE_TO_SMB(handle)->offset = offset;
154         return(true);
155 }
156
157 static bool smb_read_func(void * handle, uint8_t * buf, uint64_t wanted,
158                           uint64_t * actual)
159 {
160         NTSTATUS                ret;
161         union smb_read          r;
162         struct cifs_handle *    smbh;
163
164         ZERO_STRUCT(r);
165         smbh = IO_HANDLE_TO_SMB(handle);
166
167         r.generic.level         = RAW_READ_READX;
168         r.readx.in.file.fnum    = smbh->fnum;
169         r.readx.in.offset       = smbh->offset;
170         r.readx.in.mincnt       = wanted;
171         r.readx.in.maxcnt       = wanted;
172         r.readx.out.data        = buf;
173
174         /* FIXME: Should I really set readx.in.remaining? That just seems
175          * redundant.
176          */
177         ret = smb_raw_read(smbh->cli->tree, &r);
178         if (!NT_STATUS_IS_OK(ret)) {
179                 fprintf(stderr, "%s: %llu byte read failed: %s\n",
180                                 PROGNAME, (unsigned long long)wanted,
181                                 nt_errstr(ret));
182                 return(false);
183         }
184
185         /* Trap integer wrap. */
186         SMB_ASSERT((smbh->offset + r.readx.out.nread) >= smbh->offset);
187
188         *actual = r.readx.out.nread;
189         smbh->offset += r.readx.out.nread;
190         return(true);
191 }
192
193 static bool smb_write_func(void * handle, uint8_t * buf, uint64_t wanted,
194                            uint64_t * actual)
195 {
196         NTSTATUS                ret;
197         union smb_write         w;
198         struct cifs_handle *    smbh;
199
200         ZERO_STRUCT(w);
201         smbh = IO_HANDLE_TO_SMB(handle);
202
203         w.generic.level         = RAW_WRITE_WRITEX;
204         w.writex.in.file.fnum   = smbh->fnum;
205         w.writex.in.offset      = smbh->offset;
206         w.writex.in.count       = wanted;
207         w.writex.in.data        = buf;
208
209         ret = smb_raw_write(smbh->cli->tree, &w);
210         if (!NT_STATUS_IS_OK(ret)) {
211                 fprintf(stderr, "%s: %llu byte write failed: %s\n",
212                                 PROGNAME, (unsigned long long)wanted,
213                                 nt_errstr(ret));
214                 return(false);
215         }
216
217         *actual = w.writex.out.nwritten;
218         smbh->offset += w.writex.out.nwritten;
219         return(true);
220 }
221
222 static struct smbcli_state * init_smb_session(struct resolve_context *resolve_ctx,
223                                               struct tevent_context *ev,
224                                               const char * host,
225                                               const char **ports,
226                                               const char * share,
227                                               const char *socket_options,
228                                               struct smbcli_options *options,
229                                               struct smbcli_session_options *session_options,
230                                               struct gensec_settings *gensec_settings)
231 {
232         NTSTATUS                ret;
233         struct smbcli_state *   cli = NULL;
234
235         /* When we support SMB URLs, we can get different user credentials for
236          * each connection, but for now, we just use the same one for both.
237          */
238         ret = smbcli_full_connection(NULL, &cli, host, ports, share,
239                                      NULL /* devtype */,
240                                      socket_options,
241                                      cmdline_credentials, resolve_ctx,
242                                      ev, options,
243                                      session_options,
244                                      gensec_settings);
245
246         if (!NT_STATUS_IS_OK(ret)) {
247                 fprintf(stderr, "%s: connecting to //%s/%s: %s\n",
248                         PROGNAME, host, share, nt_errstr(ret));
249                 return(NULL);
250         }
251
252         return(cli);
253 }
254
255 static int open_smb_file(struct smbcli_state * cli,
256                         const char * path,
257                         int options)
258 {
259         NTSTATUS        ret;
260         union smb_open  o;
261
262         ZERO_STRUCT(o);
263
264         o.ntcreatex.level = RAW_OPEN_NTCREATEX;
265         o.ntcreatex.in.fname = path;
266
267         /* TODO: It's not clear whether to use these flags or to use the
268          * similarly named NTCREATEX flags in the create_options field.
269          */
270         if (options & DD_DIRECT_IO)
271                 o.ntcreatex.in.flags |= FILE_FLAG_NO_BUFFERING;
272
273         if (options & DD_SYNC_IO)
274                 o.ntcreatex.in.flags |= FILE_FLAG_WRITE_THROUGH;
275
276         o.ntcreatex.in.access_mask |=
277                 (options & DD_WRITE) ? SEC_FILE_WRITE_DATA
278                                         : SEC_FILE_READ_DATA;
279
280         /* Try to create the file only if we will be writing to it. */
281         o.ntcreatex.in.open_disposition =
282                 (options & DD_WRITE) ? NTCREATEX_DISP_OPEN_IF
283                                         : NTCREATEX_DISP_OPEN;
284
285         o.ntcreatex.in.share_access =
286                 NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
287
288         if (options & DD_OPLOCK) {
289                 o.ntcreatex.in.flags |= NTCREATEX_FLAGS_REQUEST_OPLOCK;
290         }
291
292         ret = smb_raw_open(cli->tree, NULL, &o);
293         if (!NT_STATUS_IS_OK(ret)) {
294                 fprintf(stderr, "%s: opening %s: %s\n",
295                         PROGNAME, path, nt_errstr(ret));
296                 return(-1);
297         }
298
299         return(o.ntcreatex.out.file.fnum);
300 }
301
302 static struct dd_iohandle * open_cifs_handle(struct resolve_context *resolve_ctx,
303                                              struct tevent_context *ev,
304                                              const char * host,
305                                         const char **ports,
306                                         const char * share,
307                                         const char * path,
308                                         uint64_t io_size,
309                                         int options,
310                                         const char *socket_options,
311                                         struct smbcli_options *smb_options,
312                                         struct smbcli_session_options *smb_session_options,
313                                         struct gensec_settings *gensec_settings)
314 {
315         struct cifs_handle * smbh;
316
317         if (path == NULL  || *path == '\0') {
318                 fprintf(stderr, "%s: missing path name within share //%s/%s\n",
319                         PROGNAME, host, share);
320         }
321
322         DEBUG(4, ("opening SMB stream to //%s/%s for %s\n",
323                 host, share, path));
324
325         if ((smbh = talloc_zero(NULL, struct cifs_handle)) == NULL) {
326                 return(NULL);
327         }
328
329         smbh->h.io_read = smb_read_func;
330         smbh->h.io_write = smb_write_func;
331         smbh->h.io_seek = smb_seek_func;
332
333         if ((smbh->cli = init_smb_session(resolve_ctx, ev, host, ports, share,
334                                           socket_options,
335                                           smb_options, smb_session_options,
336                                           gensec_settings)) == NULL) {
337                 return(NULL);
338         }
339
340         DEBUG(4, ("connected to //%s/%s with xmit size of %u bytes\n",
341                 host, share, smbh->cli->transport->negotiate.max_xmit));
342
343         smbh->fnum = open_smb_file(smbh->cli, path, options);
344         return(&smbh->h);
345 }
346
347 /* ------------------------------------------------------------------------- */
348 /* Abstract IO interface.                                                    */
349 /* ------------------------------------------------------------------------- */
350
351 struct dd_iohandle * dd_open_path(struct resolve_context *resolve_ctx, 
352                                   struct tevent_context *ev,
353                                   const char * path,
354                                   const char **ports,
355                                 uint64_t io_size,
356                                 int options,
357                                 const char *socket_options,
358                                 struct smbcli_options *smb_options,
359                                 struct smbcli_session_options *smb_session_options,
360                                 struct gensec_settings *gensec_settings)
361 {
362         if (file_exist(path)) {
363                 return(open_fd_handle(path, io_size, options));
364         } else {
365                 char * host;
366                 char * share;
367
368                 if (smbcli_parse_unc(path, NULL, &host, &share)) {
369                         const char * remain;
370                         remain = strstr(path, share) + strlen(share);
371
372                         /* Skip over leading directory separators. */
373                         while (*remain == '/' || *remain == '\\') { remain++; }
374
375                         return(open_cifs_handle(resolve_ctx, ev, host, ports,
376                                                 share, remain,
377                                                 io_size, options, 
378                                                 socket_options, smb_options,
379                                                 smb_session_options,
380                                                 gensec_settings));
381                 }
382
383                 return(open_fd_handle(path, io_size, options));
384         }
385 }
386
387 /* Fill the buffer till it has at least need_size bytes. Use read operations of
388  * block_size bytes. Return the number of bytes read and fill buf_size with
389  * the new buffer size.
390  *
391  * NOTE: The IO buffer is guaranteed to be big enough to fit
392  * need_size + block_size bytes into it.
393  */
394 bool dd_fill_block(struct dd_iohandle * h,
395                 uint8_t * buf,
396                 uint64_t * buf_size,
397                 uint64_t need_size,
398                 uint64_t block_size)
399 {
400         uint64_t read_size;
401
402         SMB_ASSERT(block_size > 0);
403         SMB_ASSERT(need_size > 0);
404
405         while (*buf_size < need_size) {
406
407                 if (!h->io_read(h, buf + (*buf_size), block_size, &read_size)) {
408                         return(false);
409                 }
410
411                 if (read_size == 0) {
412                         h->io_flags |= DD_END_OF_FILE;
413                         break;
414                 }
415
416                 DEBUG(6, ("added %llu bytes to IO buffer (need %llu bytes)\n",
417                         (unsigned long long)read_size,
418                         (unsigned long long)need_size));
419
420                 *buf_size += read_size;
421                 dd_stats.in.bytes += read_size;
422
423                 if (read_size == block_size) {
424                         dd_stats.in.fblocks++;
425                 } else {
426                         DEBUG(3, ("partial read of %llu bytes (expected %llu)\n",
427                                 (unsigned long long)read_size,
428                                 (unsigned long long)block_size));
429                         dd_stats.in.pblocks++;
430                 }
431         }
432
433         return(true);
434 }
435
436 /* Flush a buffer that contains buf_size bytes. Use writes of block_size to do it,
437  * and shift any remaining bytes back to the head of the buffer when there are
438  * no more block_size sized IOs left.
439  */
440 bool dd_flush_block(struct dd_iohandle * h,
441                 uint8_t * buf,
442                 uint64_t * buf_size,
443                 uint64_t block_size)
444 {
445         uint64_t write_size;
446         uint64_t total_size = 0;
447
448         SMB_ASSERT(block_size > 0);
449
450         /* We have explicitly been asked to write a partial block. */
451         if ((*buf_size) < block_size) {
452
453                 if (!h->io_write(h, buf, *buf_size, &write_size)) {
454                         return(false);
455                 }
456
457                 if (write_size == 0) {
458                         fprintf(stderr, "%s: unexpectedly wrote 0 bytes\n",
459                                         PROGNAME);
460                         return(false);
461                 }
462
463                 total_size += write_size;
464                 dd_stats.out.bytes += write_size;
465                 dd_stats.out.pblocks++;
466         }
467
468         /* Write as many full blocks as there are in the buffer. */
469         while (((*buf_size) - total_size) >= block_size) {
470
471                 if (!h->io_write(h, buf + total_size, block_size, &write_size)) {
472                         return(false);
473                 }
474
475                 if (write_size == 0) {
476                         fprintf(stderr, "%s: unexpectedly wrote 0 bytes\n",
477                                         PROGNAME);
478                         return(false);
479                 }
480
481                 if (write_size == block_size) {
482                         dd_stats.out.fblocks++;
483                 } else {
484                         dd_stats.out.pblocks++;
485                 }
486
487                 total_size += write_size;
488                 dd_stats.out.bytes += write_size;
489
490                 DEBUG(6, ("flushed %llu bytes from IO buffer of %llu bytes (%llu remain)\n",
491                         (unsigned long long)block_size,
492                         (unsigned long long)block_size,
493                         (unsigned long long)(block_size - total_size)));
494         }
495
496         SMB_ASSERT(total_size > 0);
497
498         /* We have flushed as much of the IO buffer as we can while
499          * still doing block_size'd operations. Shift any remaining data
500          * to the front of the IO buffer.
501          */
502         if ((*buf_size) > total_size) {
503                 uint64_t remain = (*buf_size) - total_size;
504
505                 DEBUG(3, ("shifting %llu remainder bytes to IO buffer head\n",
506                         (unsigned long long)remain));
507
508                 memmove(buf, buf + total_size, remain);
509                 (*buf_size) = remain;
510         } else if ((*buf_size) == total_size) {
511                 (*buf_size) = 0;
512         } else {
513                 /* Else buffer contains buf_size bytes that we will append
514                  * to next time round.
515                  */
516                 DEBUG(3, ("%llu unflushed bytes left in IO buffer\n",
517                         (unsigned long long)(*buf_size)));
518         }
519
520         return(true);
521 }
522
523 /* vim: set sw=8 sts=8 ts=8 tw=79 : */