s3: libsmbclient: Add new function SMBC_readdirplus_ctx().

[Samba.git] / source4 / client / cifsddio.c

/*
   CIFSDD - dd for SMB.
   IO routines, generic and specific.

   Copyright (C) James Peach 2005-2006

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "includes.h"
#include "system/filesys.h"
#include "libcli/libcli.h"
#include "lib/cmdline/popt_common.h"

#include "cifsdd.h"

/* ------------------------------------------------------------------------- */
/* UNIX file descriptor IO.                                                  */
/* ------------------------------------------------------------------------- */

struct fd_handle
{
        struct dd_iohandle      h;
        int                     fd;
};

#define IO_HANDLE_TO_FD(h) (((struct fd_handle *)(h))->fd)

static bool fd_seek_func(void * handle, uint64_t offset)
{
        ssize_t ret;

        ret = lseek(IO_HANDLE_TO_FD(handle), offset, SEEK_SET);
        if (ret < 0) {
                fprintf(stderr, "%s: seek failed: %s\n",
                                PROGNAME, strerror(errno));
                return(false);
        }

        return(true);
}

static bool fd_read_func(void * handle,
                        uint8_t * buf,
                        uint64_t wanted,
                        uint64_t * actual)
{
        ssize_t ret;

        ret = read(IO_HANDLE_TO_FD(handle), buf, wanted);
        if (ret < 0) {
                fprintf(stderr, "%s: %llu byte read failed: %s\n",
                                PROGNAME, (unsigned long long)wanted,
                                strerror(errno));
                return(false);
        }

        *actual = (uint64_t)ret;
        return(true);
}

static bool fd_write_func(void * handle,
                        uint8_t * buf,
                        uint64_t wanted,
                        uint64_t * actual)
{
        ssize_t ret;

        ret = write(IO_HANDLE_TO_FD(handle), buf, wanted);
        if (ret < 0) {
                fprintf(stderr, "%s: %llu byte write failed: %s\n",
                                PROGNAME, (unsigned long long)wanted,
                                strerror(errno));
                return(false);
        }

        *actual = (uint64_t)ret;
        return(true);
}

static struct dd_iohandle * open_fd_handle(const char * path,
                                        uint64_t io_size,
                                        int options)
{
        struct fd_handle * fdh;
        int oflags = 0;

        DEBUG(4, ("opening fd stream for %s\n", path));
        if ((fdh = talloc_zero(NULL, struct fd_handle)) == NULL) {
                return(NULL);
        }

        fdh->h.io_read = fd_read_func;
        fdh->h.io_write = fd_write_func;
        fdh->h.io_seek = fd_seek_func;

        if (options & DD_DIRECT_IO) {
#ifdef HAVE_OPEN_O_DIRECT
                oflags |= O_DIRECT;
#else
                DEBUG(1, ("no support for direct IO on this platform\n"));
#endif
        }

        if (options & DD_SYNC_IO)
                oflags |= O_SYNC;

        oflags |= (options & DD_WRITE) ?  (O_WRONLY | O_CREAT) : (O_RDONLY);

        fdh->fd = open(path, oflags, 0644);
        if (fdh->fd < 0) {
                fprintf(stderr, "%s: %s: %s\n",
                        PROGNAME, path, strerror(errno));
                talloc_free(fdh);
                return(NULL);
        }

        if (options & DD_OPLOCK) {
                DEBUG(2, ("FIXME: take local oplock on %s\n", path));
        }

        SMB_ASSERT((void *)fdh == (void *)&fdh->h);
        return(&fdh->h);
}

/* ------------------------------------------------------------------------- */
/* CIFS client IO.                                                           */
/* ------------------------------------------------------------------------- */

struct cifs_handle
{
        struct dd_iohandle      h;
        struct smbcli_state *   cli;
        int                     fnum;
        uint64_t                offset;
};

#define IO_HANDLE_TO_SMB(h) ((struct cifs_handle *)(h))

static bool smb_seek_func(void * handle, uint64_t offset)
{
        IO_HANDLE_TO_SMB(handle)->offset = offset;
        return(true);
}

static bool smb_read_func(void * handle, uint8_t * buf, uint64_t wanted,
                          uint64_t * actual)
{
        NTSTATUS                ret;
        union smb_read          r;
        struct cifs_handle *    smbh;

        ZERO_STRUCT(r);
        smbh = IO_HANDLE_TO_SMB(handle);

        r.generic.level         = RAW_READ_READX;
        r.readx.in.file.fnum    = smbh->fnum;
        r.readx.in.offset       = smbh->offset;
        r.readx.in.mincnt       = wanted;
        r.readx.in.maxcnt       = wanted;
        r.readx.out.data        = buf;

        /* FIXME: Should I really set readx.in.remaining? That just seems
         * redundant.
         */
        ret = smb_raw_read(smbh->cli->tree, &r);
        if (!NT_STATUS_IS_OK(ret)) {
                fprintf(stderr, "%s: %llu byte read failed: %s\n",
                                PROGNAME, (unsigned long long)wanted,
                                nt_errstr(ret));
                return(false);
        }

        /* Trap integer wrap. */
        SMB_ASSERT((smbh->offset + r.readx.out.nread) >= smbh->offset);

        *actual = r.readx.out.nread;
        smbh->offset += r.readx.out.nread;
        return(true);
}

static bool smb_write_func(void * handle, uint8_t * buf, uint64_t wanted,
                           uint64_t * actual)
{
        NTSTATUS                ret;
        union smb_write         w;
        struct cifs_handle *    smbh;

        ZERO_STRUCT(w);
        smbh = IO_HANDLE_TO_SMB(handle);

        w.generic.level         = RAW_WRITE_WRITEX;
        w.writex.in.file.fnum   = smbh->fnum;
        w.writex.in.offset      = smbh->offset;
        w.writex.in.count       = wanted;
        w.writex.in.data        = buf;

        ret = smb_raw_write(smbh->cli->tree, &w);
        if (!NT_STATUS_IS_OK(ret)) {
                fprintf(stderr, "%s: %llu byte write failed: %s\n",
                                PROGNAME, (unsigned long long)wanted,
                                nt_errstr(ret));
                return(false);
        }

        *actual = w.writex.out.nwritten;
        smbh->offset += w.writex.out.nwritten;
        return(true);
}

static struct smbcli_state * init_smb_session(struct resolve_context *resolve_ctx,
                                              struct tevent_context *ev,
                                              const char * host,
                                              const char **ports,
                                              const char * share,
                                              const char *socket_options,
                                              struct smbcli_options *options,
                                              struct smbcli_session_options *session_options,
                                              struct gensec_settings *gensec_settings)
{
        NTSTATUS                ret;
        struct smbcli_state *   cli = NULL;

        /* When we support SMB URLs, we can get different user credentials for
         * each connection, but for now, we just use the same one for both.
         */
        ret = smbcli_full_connection(NULL, &cli, host, ports, share,
                                NULL /* devtype */,
                                socket_options,
                                popt_get_cmdline_credentials(),
                                resolve_ctx,
                                ev, options,
                                session_options,
                                gensec_settings);

        if (!NT_STATUS_IS_OK(ret)) {
                fprintf(stderr, "%s: connecting to //%s/%s: %s\n",
                        PROGNAME, host, share, nt_errstr(ret));
                return(NULL);
        }

        return(cli);
}

static int open_smb_file(struct smbcli_state * cli,
                        const char * path,
                        int options)
{
        NTSTATUS        ret;
        union smb_open  o;

        ZERO_STRUCT(o);

        o.ntcreatex.level = RAW_OPEN_NTCREATEX;
        o.ntcreatex.in.fname = path;

        /* TODO: It's not clear whether to use these flags or to use the
         * similarly named NTCREATEX flags in the create_options field.
         */
        if (options & DD_DIRECT_IO)
                o.ntcreatex.in.flags |= FILE_FLAG_NO_BUFFERING;

        if (options & DD_SYNC_IO)
                o.ntcreatex.in.flags |= FILE_FLAG_WRITE_THROUGH;

        o.ntcreatex.in.access_mask |=
                (options & DD_WRITE) ? SEC_FILE_WRITE_DATA
                                        : SEC_FILE_READ_DATA;

        /* Try to create the file only if we will be writing to it. */
        o.ntcreatex.in.open_disposition =
                (options & DD_WRITE) ? NTCREATEX_DISP_OPEN_IF
                                        : NTCREATEX_DISP_OPEN;

        o.ntcreatex.in.share_access =
                NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;

        if (options & DD_OPLOCK) {
                o.ntcreatex.in.flags |= NTCREATEX_FLAGS_REQUEST_OPLOCK;
        }

        ret = smb_raw_open(cli->tree, NULL, &o);
        if (!NT_STATUS_IS_OK(ret)) {
                fprintf(stderr, "%s: opening %s: %s\n",
                        PROGNAME, path, nt_errstr(ret));
                return(-1);
        }

        return(o.ntcreatex.out.file.fnum);
}

static struct dd_iohandle * open_cifs_handle(struct resolve_context *resolve_ctx,
                                             struct tevent_context *ev,
                                             const char * host,
                                        const char **ports,
                                        const char * share,
                                        const char * path,
                                        uint64_t io_size,
                                        int options,
                                        const char *socket_options,
                                        struct smbcli_options *smb_options,
                                        struct smbcli_session_options *smb_session_options,
                                        struct gensec_settings *gensec_settings)
{
        struct cifs_handle * smbh;

        if (path == NULL  || *path == '\0') {
                fprintf(stderr, "%s: missing path name within share //%s/%s\n",
                        PROGNAME, host, share);
        }

        DEBUG(4, ("opening SMB stream to //%s/%s for %s\n",
                host, share, path));

        if ((smbh = talloc_zero(NULL, struct cifs_handle)) == NULL) {
                return(NULL);
        }

        smbh->h.io_read = smb_read_func;
        smbh->h.io_write = smb_write_func;
        smbh->h.io_seek = smb_seek_func;

        if ((smbh->cli = init_smb_session(resolve_ctx, ev, host, ports, share,
                                          socket_options,
                                          smb_options, smb_session_options,
                                          gensec_settings)) == NULL) {
                return(NULL);
        }

        DEBUG(4, ("connected to //%s/%s with xmit size of %u bytes\n",
                host, share, smbh->cli->transport->negotiate.max_xmit));

        smbh->fnum = open_smb_file(smbh->cli, path, options);
        return(&smbh->h);
}

/* ------------------------------------------------------------------------- */
/* Abstract IO interface.                                                    */
/* ------------------------------------------------------------------------- */

struct dd_iohandle * dd_open_path(struct resolve_context *resolve_ctx, 
                                  struct tevent_context *ev,
                                  const char * path,
                                  const char **ports,
                                uint64_t io_size,
                                int options,
                                const char *socket_options,
                                struct smbcli_options *smb_options,
                                struct smbcli_session_options *smb_session_options,
                                struct gensec_settings *gensec_settings)
{
        if (file_exist(path)) {
                return(open_fd_handle(path, io_size, options));
        } else {
                char * host;
                char * share;

                if (smbcli_parse_unc(path, NULL, &host, &share)) {
                        const char * remain;
                        remain = strstr(path, share) + strlen(share);

                        /* Skip over leading directory separators. */
                        while (*remain == '/' || *remain == '\\') { remain++; }

                        return(open_cifs_handle(resolve_ctx, ev, host, ports,
                                                share, remain,
                                                io_size, options, 
                                                socket_options, smb_options,
                                                smb_session_options,
                                                gensec_settings));
                }

                return(open_fd_handle(path, io_size, options));
        }
}

/* Fill the buffer till it has at least need_size bytes. Use read operations of
 * block_size bytes. Return the number of bytes read and fill buf_size with
 * the new buffer size.
 *
 * NOTE: The IO buffer is guaranteed to be big enough to fit
 * need_size + block_size bytes into it.
 */
bool dd_fill_block(struct dd_iohandle * h,
                uint8_t * buf,
                uint64_t * buf_size,
                uint64_t need_size,
                uint64_t block_size)
{
        uint64_t read_size;

        SMB_ASSERT(block_size > 0);
        SMB_ASSERT(need_size > 0);

        while (*buf_size < need_size) {

                if (!h->io_read(h, buf + (*buf_size), block_size, &read_size)) {
                        return(false);
                }

                if (read_size == 0) {
                        h->io_flags |= DD_END_OF_FILE;
                        break;
                }

                DEBUG(6, ("added %llu bytes to IO buffer (need %llu bytes)\n",
                        (unsigned long long)read_size,
                        (unsigned long long)need_size));

                *buf_size += read_size;
                dd_stats.in.bytes += read_size;

                if (read_size == block_size) {
                        dd_stats.in.fblocks++;
                } else {
                        DEBUG(3, ("partial read of %llu bytes (expected %llu)\n",
                                (unsigned long long)read_size,
                                (unsigned long long)block_size));
                        dd_stats.in.pblocks++;
                }
        }

        return(true);
}

/* Flush a buffer that contains buf_size bytes. Use writes of block_size to do it,
 * and shift any remaining bytes back to the head of the buffer when there are
 * no more block_size sized IOs left.
 */
bool dd_flush_block(struct dd_iohandle * h,
                uint8_t * buf,
                uint64_t * buf_size,
                uint64_t block_size)
{
        uint64_t write_size;
        uint64_t total_size = 0;

        SMB_ASSERT(block_size > 0);

        /* We have explicitly been asked to write a partial block. */
        if ((*buf_size) < block_size) {

                if (!h->io_write(h, buf, *buf_size, &write_size)) {
                        return(false);
                }

                if (write_size == 0) {
                        fprintf(stderr, "%s: unexpectedly wrote 0 bytes\n",
                                        PROGNAME);
                        return(false);
                }

                total_size += write_size;
                dd_stats.out.bytes += write_size;
                dd_stats.out.pblocks++;
        }

        /* Write as many full blocks as there are in the buffer. */
        while (((*buf_size) - total_size) >= block_size) {

                if (!h->io_write(h, buf + total_size, block_size, &write_size)) {
                        return(false);
                }

                if (write_size == 0) {
                        fprintf(stderr, "%s: unexpectedly wrote 0 bytes\n",
                                        PROGNAME);
                        return(false);
                }

                if (write_size == block_size) {
                        dd_stats.out.fblocks++;
                } else {
                        dd_stats.out.pblocks++;
                }

                total_size += write_size;
                dd_stats.out.bytes += write_size;

                DEBUG(6, ("flushed %llu bytes from IO buffer of %llu bytes (%llu remain)\n",
                        (unsigned long long)block_size,
                        (unsigned long long)block_size,
                        (unsigned long long)(block_size - total_size)));
        }

        SMB_ASSERT(total_size > 0);

        /* We have flushed as much of the IO buffer as we can while
         * still doing block_size'd operations. Shift any remaining data
         * to the front of the IO buffer.
         */
        if ((*buf_size) > total_size) {
                uint64_t remain = (*buf_size) - total_size;

                DEBUG(3, ("shifting %llu remainder bytes to IO buffer head\n",
                        (unsigned long long)remain));

                memmove(buf, buf + total_size, remain);
                (*buf_size) = remain;
        } else if ((*buf_size) == total_size) {
                (*buf_size) = 0;
        } else {
                /* Else buffer contains buf_size bytes that we will append
                 * to next time round.
                 */
                DEBUG(3, ("%llu unflushed bytes left in IO buffer\n",
                        (unsigned long long)(*buf_size)));
        }

        return(true);
}

/* vim: set sw=8 sts=8 ts=8 tw=79 : */