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 event_context *ev,
 225                                               const char * host,
 226                                               const char **ports,
 227                                               const char * share,
 228                                               struct smbcli_options *options,
 229                                               struct smbcli_session_options *session_options,
 230                                               struct smb_iconv_convenience *iconv_convenience)
 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                                      cmdline_credentials, resolve_ctx,
 241                                      ev, options,
 242                                      session_options,
 243                                      iconv_convenience);
 244
 245         if (!NT_STATUS_IS_OK(ret)) {
 246                 fprintf(stderr, "%s: connecting to //%s/%s: %s\n",
 247                         PROGNAME, host, share, nt_errstr(ret));
 248                 return(NULL);
 249         }
 250
 251         return(cli);
 252 }
 253
 254 static int open_smb_file(struct smbcli_state * cli,
 255                         const char * path,
 256                         int options)
 257 {
 258         NTSTATUS        ret;
 259         union smb_open  o;
 260
 261         ZERO_STRUCT(o);
 262
 263         o.ntcreatex.level = RAW_OPEN_NTCREATEX;
 264         o.ntcreatex.in.fname = path;
 265
 266         /* TODO: It's not clear whether to use these flags or to use the
 267          * similarly named NTCREATEX flags in the create_options field.
 268          */
 269         if (options & DD_DIRECT_IO)
 270                 o.ntcreatex.in.flags |= FILE_FLAG_NO_BUFFERING;
 271
 272         if (options & DD_SYNC_IO)
 273                 o.ntcreatex.in.flags |= FILE_FLAG_WRITE_THROUGH;
 274
 275         o.ntcreatex.in.access_mask |=
 276                 (options & DD_WRITE) ? SEC_FILE_WRITE_DATA
 277                                         : SEC_FILE_READ_DATA;
 278
 279         /* Try to create the file only if we will be writing to it. */
 280         o.ntcreatex.in.open_disposition =
 281                 (options & DD_WRITE) ? NTCREATEX_DISP_OPEN_IF
 282                                         : NTCREATEX_DISP_OPEN;
 283
 284         o.ntcreatex.in.share_access =
 285                 NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
 286
 287         if (options & DD_OPLOCK) {
 288                 o.ntcreatex.in.flags |= NTCREATEX_FLAGS_REQUEST_OPLOCK;
 289         }
 290
 291         ret = smb_raw_open(cli->tree, NULL, &o);
 292         if (!NT_STATUS_IS_OK(ret)) {
 293                 fprintf(stderr, "%s: opening %s: %s\n",
 294                         PROGNAME, path, nt_errstr(ret));
 295                 return(-1);
 296         }
 297
 298         return(o.ntcreatex.out.file.fnum);
 299 }
 300
 301 static struct dd_iohandle * open_cifs_handle(struct resolve_context *resolve_ctx,
 302                                              struct event_context *ev,
 303                                              const char * host,
 304                                         const char **ports,
 305                                         const char * share,
 306                                         const char * path,
 307                                         uint64_t io_size,
 308                                         int options,
 309                                         struct smbcli_options *smb_options,
 310                                         struct smbcli_session_options *smb_session_options,
 311                                         struct smb_iconv_convenience *iconv_convenience)
 312 {
 313         struct cifs_handle * smbh;
 314
 315         if (path == NULL  || *path == '\0') {
 316                 fprintf(stderr, "%s: missing path name within share //%s/%s\n",
 317                         PROGNAME, host, share);
 318         }
 319
 320         DEBUG(4, ("opening SMB stream to //%s/%s for %s\n",
 321                 host, share, path));
 322
 323         if ((smbh = talloc_zero(NULL, struct cifs_handle)) == NULL) {
 324                 return(NULL);
 325         }
 326
 327         smbh->h.io_read = smb_read_func;
 328         smbh->h.io_write = smb_write_func;
 329         smbh->h.io_seek = smb_seek_func;
 330
 331         if ((smbh->cli = init_smb_session(resolve_ctx, ev, host, ports, share,
 332                                           smb_options, smb_session_options,
 333                                           iconv_convenience)) == NULL) {
 334                 return(NULL);
 335         }
 336
 337         DEBUG(4, ("connected to //%s/%s with xmit size of %u bytes\n",
 338                 host, share, smbh->cli->transport->negotiate.max_xmit));
 339
 340         smbh->fnum = open_smb_file(smbh->cli, path, options);
 341         return(&smbh->h);
 342 }
 343
 344 /* ------------------------------------------------------------------------- */
 345 /* Abstract IO interface.                                                    */
 346 /* ------------------------------------------------------------------------- */
 347
 348 struct dd_iohandle * dd_open_path(struct resolve_context *resolve_ctx,
 349                                   struct event_context *ev,
 350                                   const char * path,
 351                                   const char **ports,
 352                                 uint64_t io_size,
 353                                 int options,
 354                                 struct smbcli_options *smb_options,
 355                                 struct smbcli_session_options *smb_session_options,
 356                                 struct smb_iconv_convenience *iconv_convenience)
 357 {
 358         if (file_exist(path)) {
 359                 return(open_fd_handle(path, io_size, options));
 360         } else {
 361                 char * host;
 362                 char * share;
 363
 364                 if (smbcli_parse_unc(path, NULL, &host, &share)) {
 365                         const char * remain;
 366                         remain = strstr(path, share) + strlen(share);
 367
 368                         /* Skip over leading directory separators. */
 369                         while (*remain == '/' || *remain == '\\') { remain++; }
 370
 371                         return(open_cifs_handle(resolve_ctx, ev, host, ports,
 372                                                 share, remain,
 373                                                 io_size, options, smb_options,
 374                                                 smb_session_options,
 375                                                 iconv_convenience));
 376                 }
 377
 378                 return(open_fd_handle(path, io_size, options));
 379         }
 380 }
 381
 382 /* Fill the buffer till it has at least need_size bytes. Use read operations of
 383  * block_size bytes. Return the number of bytes read and fill buf_size with
 384  * the new buffer size.
 385  *
 386  * NOTE: The IO buffer is guaranteed to be big enough to fit
 387  * need_size + block_size bytes into it.
 388  */
 389 bool dd_fill_block(struct dd_iohandle * h,
 390                 uint8_t * buf,
 391                 uint64_t * buf_size,
 392                 uint64_t need_size,
 393                 uint64_t block_size)
 394 {
 395         uint64_t read_size;
 396
 397         SMB_ASSERT(block_size > 0);
 398         SMB_ASSERT(need_size > 0);
 399
 400         while (*buf_size < need_size) {
 401
 402                 if (!h->io_read(h, buf + (*buf_size), block_size, &read_size)) {
 403                         return(false);
 404                 }
 405
 406                 if (read_size == 0) {
 407                         h->io_flags |= DD_END_OF_FILE;
 408                         break;
 409                 }
 410
 411                 DEBUG(6, ("added %llu bytes to IO buffer (need %llu bytes)\n",
 412                         (unsigned long long)read_size,
 413                         (unsigned long long)need_size));
 414
 415                 *buf_size += read_size;
 416                 dd_stats.in.bytes += read_size;
 417
 418                 if (read_size == block_size) {
 419                         dd_stats.in.fblocks++;
 420                 } else {
 421                         DEBUG(3, ("partial read of %llu bytes (expected %llu)\n",
 422                                 (unsigned long long)read_size,
 423                                 (unsigned long long)block_size));
 424                         dd_stats.in.pblocks++;
 425                 }
 426         }
 427
 428         return(true);
 429 }
 430
 431 /* Flush a buffer that contains buf_size bytes. Use writes of block_size to do it,
 432  * and shift any remaining bytes back to the head of the buffer when there are
 433  * no more block_size sized IOs left.
 434  */
 435 bool dd_flush_block(struct dd_iohandle * h,
 436                 uint8_t * buf,
 437                 uint64_t * buf_size,
 438                 uint64_t block_size)
 439 {
 440         uint64_t write_size;
 441         uint64_t total_size = 0;
 442
 443         SMB_ASSERT(block_size > 0);
 444
 445         /* We have explicitly been asked to write a partial block. */
 446         if ((*buf_size) < block_size) {
 447
 448                 if (!h->io_write(h, buf, *buf_size, &write_size)) {
 449                         return(false);
 450                 }
 451
 452                 if (write_size == 0) {
 453                         fprintf(stderr, "%s: unexpectedly wrote 0 bytes\n",
 454                                         PROGNAME);
 455                         return(false);
 456                 }
 457
 458                 total_size += write_size;
 459                 dd_stats.out.bytes += write_size;
 460                 dd_stats.out.pblocks++;
 461         }
 462
 463         /* Write as many full blocks as there are in the buffer. */
 464         while (((*buf_size) - total_size) >= block_size) {
 465
 466                 if (!h->io_write(h, buf + total_size, block_size, &write_size)) {
 467                         return(false);
 468                 }
 469
 470                 if (write_size == 0) {
 471                         fprintf(stderr, "%s: unexpectedly wrote 0 bytes\n",
 472                                         PROGNAME);
 473                         return(false);
 474                 }
 475
 476                 if (write_size == block_size) {
 477                         dd_stats.out.fblocks++;
 478                 } else {
 479                         dd_stats.out.pblocks++;
 480                 }
 481
 482                 total_size += write_size;
 483                 dd_stats.out.bytes += write_size;
 484
 485                 DEBUG(6, ("flushed %llu bytes from IO buffer of %llu bytes (%llu remain)\n",
 486                         (unsigned long long)block_size,
 487                         (unsigned long long)block_size,
 488                         (unsigned long long)(block_size - total_size)));
 489         }
 490
 491         SMB_ASSERT(total_size > 0);
 492
 493         /* We have flushed as much of the IO buffer as we can while
 494          * still doing block_size'd operations. Shift any remaining data
 495          * to the front of the IO buffer.
 496          */
 497         if ((*buf_size) > total_size) {
 498                 uint64_t remain = (*buf_size) - total_size;
 499
 500                 DEBUG(3, ("shifting %llu remainder bytes to IO buffer head\n",
 501                         (unsigned long long)remain));
 502
 503                 memmove(buf, buf + total_size, remain);
 504                 (*buf_size) = remain;
 505         } else if ((*buf_size) == total_size) {
 506                 (*buf_size) = 0;
 507         } else {
 508                 /* Else buffer contains buf_size bytes that we will append
 509                  * to next time round.
 510                  */
 511                 DEBUG(3, ("%llu unflushed bytes left in IO buffer\n",
 512                         (unsigned long long)(*buf_size)));
 513         }
 514
 515         return(true);
 516 }
 517
 518 /* vim: set sw=8 sts=8 ts=8 tw=79 : */