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