source: vendor/3.5.10/source4/client/cifsddio.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 13.2 KB
Line 
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
33struct 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
41static 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
55static 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
74static 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
93static 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
142struct 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
152static bool smb_seek_func(void * handle, uint64_t offset)
153{
154 IO_HANDLE_TO_SMB(handle)->offset = offset;
155 return(true);
156}
157
158static 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
194static 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
223static 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
258static 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
305static 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
356struct 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 */
401bool 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 */
447bool 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 : */
Note: See TracBrowser for help on using the repository browser.