glib/gio/gwin32file-sync-stream.c

/* gwin32file-sync-stream.c - a simple IStream implementation
 *
 * Copyright 2020 Руслан Ижбулатов
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, see <http://www.gnu.org/licenses/>.
 */

/* A COM object that implements an IStream backed by a file HANDLE.
 * Works just like `SHCreateStreamOnFileEx()`, but does not
 * support locking, and doesn't force us to link to libshlwapi.
 * Only supports synchronous access.
 */
#include "config.h"
#define COBJMACROS
#define INITGUID
#include <windows.h>

#include "gwin32file-sync-stream.h"

static HRESULT STDMETHODCALLTYPE _file_sync_stream_query_interface (IStream         *self_ptr,
                                                                    REFIID           ref_interface_guid,
                                                                    LPVOID          *output_object_ptr);
static ULONG STDMETHODCALLTYPE   _file_sync_stream_release         (IStream         *self_ptr);
static ULONG STDMETHODCALLTYPE   _file_sync_stream_add_ref         (IStream         *self_ptr);

static HRESULT STDMETHODCALLTYPE _file_sync_stream_read            (IStream         *self_ptr,
                                                                    void            *output_data,
                                                                    ULONG            bytes_to_read,
                                                                    ULONG           *output_bytes_read);

static HRESULT STDMETHODCALLTYPE _file_sync_stream_write           (IStream         *self_ptr,
                                                                    const void      *data,
                                                                    ULONG            bytes_to_write,
                                                                    ULONG           *output_bytes_written);


static HRESULT STDMETHODCALLTYPE _file_sync_stream_clone           (IStream         *self_ptr,
                                                                    IStream        **output_clone_ptr);
static HRESULT STDMETHODCALLTYPE _file_sync_stream_commit          (IStream         *self_ptr,
                                                                    DWORD            commit_flags);
static HRESULT STDMETHODCALLTYPE _file_sync_stream_copy_to         (IStream         *self_ptr,
                                                                    IStream         *output_stream,
                                                                    ULARGE_INTEGER   bytes_to_copy,
                                                                    ULARGE_INTEGER  *output_bytes_read,
                                                                    ULARGE_INTEGER  *output_bytes_written);
static HRESULT STDMETHODCALLTYPE _file_sync_stream_lock_region     (IStream         *self_ptr,
                                                                    ULARGE_INTEGER   lock_offset,
                                                                    ULARGE_INTEGER   lock_bytes,
                                                                    DWORD            lock_type);
static HRESULT STDMETHODCALLTYPE _file_sync_stream_revert          (IStream         *self_ptr);
static HRESULT STDMETHODCALLTYPE _file_sync_stream_seek            (IStream         *self_ptr,
                                                                    LARGE_INTEGER    move_distance,
                                                                    DWORD            origin,
                                                                    ULARGE_INTEGER  *output_new_position);
static HRESULT STDMETHODCALLTYPE _file_sync_stream_set_size        (IStream         *self_ptr,
                                                                    ULARGE_INTEGER   new_size);
static HRESULT STDMETHODCALLTYPE _file_sync_stream_stat            (IStream         *self_ptr,
                                                                    STATSTG         *output_stat,
                                                                    DWORD            flags);
static HRESULT STDMETHODCALLTYPE _file_sync_stream_unlock_region   (IStream         *self_ptr,
                                                                    ULARGE_INTEGER   lock_offset,
                                                                    ULARGE_INTEGER   lock_bytes,
                                                                    DWORD            lock_type);

static void _file_sync_stream_free (GWin32FileSyncStream *self);

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_query_interface (IStream *self_ptr,
                                   REFIID   ref_interface_guid,
                                   LPVOID  *output_object_ptr)
{
  *output_object_ptr = NULL;

  if (IsEqualGUID (ref_interface_guid, &IID_IUnknown))
    {
      IUnknown_AddRef ((IUnknown *) self_ptr);
      *output_object_ptr = self_ptr;
      return S_OK;
    }
  else if (IsEqualGUID (ref_interface_guid, &IID_IStream))
    {
      IStream_AddRef (self_ptr);
      *output_object_ptr = self_ptr;
      return S_OK;
    }

  return E_NOINTERFACE;
}

static ULONG STDMETHODCALLTYPE
_file_sync_stream_add_ref (IStream *self_ptr)
{
  GWin32FileSyncStream *self = (GWin32FileSyncStream *) self_ptr;

  return ++self->ref_count;
}

static ULONG STDMETHODCALLTYPE
_file_sync_stream_release (IStream *self_ptr)
{
  GWin32FileSyncStream *self = (GWin32FileSyncStream *) self_ptr;

  int ref_count = --self->ref_count;

  if (ref_count == 0)
    _file_sync_stream_free (self);

  return ref_count;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_read (IStream *self_ptr,
                        void    *output_data,
                        ULONG    bytes_to_read,
                        ULONG   *output_bytes_read)
{
  GWin32FileSyncStream *self = (GWin32FileSyncStream *) self_ptr;
  DWORD bytes_read;

  if (!ReadFile (self->file_handle, output_data, bytes_to_read, &bytes_read, NULL))
    {
      DWORD error = GetLastError ();
      return __HRESULT_FROM_WIN32 (error);
    }

  if (output_bytes_read)
    *output_bytes_read = bytes_read;

  return S_OK;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_write (IStream    *self_ptr,
                         const void *data,
                         ULONG       bytes_to_write,
                         ULONG      *output_bytes_written)
{
  GWin32FileSyncStream *self = (GWin32FileSyncStream *) self_ptr;
  DWORD bytes_written;

  if (!WriteFile (self->file_handle, data, bytes_to_write, &bytes_written, NULL))
    {
      DWORD error = GetLastError ();
      return __HRESULT_FROM_WIN32 (error);
    }

  if (output_bytes_written)
    *output_bytes_written = bytes_written;

  return S_OK;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_seek (IStream        *self_ptr,
                        LARGE_INTEGER   move_distance,
                        DWORD           origin,
                        ULARGE_INTEGER *output_new_position)
{
  GWin32FileSyncStream *self = (GWin32FileSyncStream *) self_ptr;
  LARGE_INTEGER new_position;
  DWORD move_method;

  switch (origin)
    {
    case STREAM_SEEK_SET:
      move_method = FILE_BEGIN;
      break;
    case STREAM_SEEK_CUR:
      move_method = FILE_CURRENT;
      break;
    case STREAM_SEEK_END:
      move_method = FILE_END;
      break;
    default:
      return E_INVALIDARG;
    }

  if (!SetFilePointerEx (self->file_handle, move_distance, &new_position, move_method))
    {
      DWORD error = GetLastError ();
      return __HRESULT_FROM_WIN32 (error);
    }

  (*output_new_position).QuadPart = new_position.QuadPart;

  return S_OK;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_set_size (IStream        *self_ptr,
                            ULARGE_INTEGER  new_size)
{
  GWin32FileSyncStream *self = (GWin32FileSyncStream *) self_ptr;
  FILE_END_OF_FILE_INFO info;

  info.EndOfFile.QuadPart = new_size.QuadPart;

  if (SetFileInformationByHandle (self->file_handle, FileEndOfFileInfo, &info, sizeof (info)))
    {
      DWORD error = GetLastError ();
      return __HRESULT_FROM_WIN32 (error);
    }

  return S_OK;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_copy_to (IStream        *self_ptr,
                           IStream        *output_stream,
                           ULARGE_INTEGER  bytes_to_copy,
                           ULARGE_INTEGER *output_bytes_read,
                           ULARGE_INTEGER *output_bytes_written)
{
  ULARGE_INTEGER counter;
  ULARGE_INTEGER written_counter;
  ULARGE_INTEGER read_counter;

  counter.QuadPart = bytes_to_copy.QuadPart;
  written_counter.QuadPart = 0;
  read_counter.QuadPart = 0;

  while (counter.QuadPart > 0)
    {
      HRESULT hr;
      ULONG bytes_read;
      ULONG bytes_written;
      ULONG bytes_index;
#define _INTERNAL_BUFSIZE 1024
      BYTE buffer[_INTERNAL_BUFSIZE];
#undef _INTERNAL_BUFSIZE
      ULONG buffer_size = sizeof (buffer);
      ULONG to_read = buffer_size;

      if (counter.QuadPart < buffer_size)
        to_read = (ULONG) counter.QuadPart;

      /* Because MS SDK has a function IStream_Read() with 3 arguments */
      hr = self_ptr->lpVtbl->Read (self_ptr, buffer, to_read, &bytes_read);
      if (!SUCCEEDED (hr))
        return hr;

      read_counter.QuadPart += bytes_read;

      if (bytes_read == 0)
        break;

      bytes_index = 0;

      while (bytes_index < bytes_read)
        {
          /* Because MS SDK has a function IStream_Write() with 3 arguments */
          hr = output_stream->lpVtbl->Write (output_stream, &buffer[bytes_index], bytes_read - bytes_index, &bytes_written);
          if (!SUCCEEDED (hr))
            return hr;

          if (bytes_written == 0)
            return __HRESULT_FROM_WIN32 (ERROR_WRITE_FAULT);

          bytes_index += bytes_written;
          written_counter.QuadPart += bytes_written;
        }
    }

  if (output_bytes_read)
    output_bytes_read->QuadPart = read_counter.QuadPart;
  if (output_bytes_written)
    output_bytes_written->QuadPart = written_counter.QuadPart;

  return S_OK;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_commit (IStream *self_ptr,
                          DWORD    commit_flags)
{
  GWin32FileSyncStream *self = (GWin32FileSyncStream *) self_ptr;

  if (!FlushFileBuffers (self->file_handle))
    {
      DWORD error = GetLastError ();
      return __HRESULT_FROM_WIN32 (error);
    }

  return S_OK;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_revert (IStream *self_ptr)
{
  return E_NOTIMPL;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_lock_region (IStream        *self_ptr,
                               ULARGE_INTEGER  lock_offset,
                               ULARGE_INTEGER  lock_bytes,
                               DWORD           lock_type)
{
  return STG_E_INVALIDFUNCTION;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_unlock_region (IStream        *self_ptr,
                                 ULARGE_INTEGER  lock_offset,
                                 ULARGE_INTEGER  lock_bytes,
                                 DWORD           lock_type)
{
  return STG_E_INVALIDFUNCTION;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_stat (IStream *self_ptr,
                        STATSTG *output_stat,
                        DWORD    flags)
{
  GWin32FileSyncStream *self = (GWin32FileSyncStream *) self_ptr;
  BOOL get_name = FALSE;
  FILE_BASIC_INFO bi;
  FILE_STANDARD_INFO si;

  if (output_stat == NULL)
    return STG_E_INVALIDPOINTER;

  switch (flags)
    {
    case STATFLAG_DEFAULT:
      get_name = TRUE;
      break;
    case STATFLAG_NONAME:
      get_name = FALSE;
      break;
    default:
      return STG_E_INVALIDFLAG;
    }

  if (!GetFileInformationByHandleEx (self->file_handle, FileBasicInfo, &bi, sizeof (bi)) ||
      !GetFileInformationByHandleEx (self->file_handle, FileStandardInfo, &si, sizeof (si)))
    {
      DWORD error = GetLastError ();
      return __HRESULT_FROM_WIN32 (error);
    }

  output_stat->type = STGTY_STREAM;
  output_stat->mtime.dwLowDateTime = bi.LastWriteTime.LowPart;
  output_stat->mtime.dwHighDateTime = bi.LastWriteTime.HighPart;
  output_stat->ctime.dwLowDateTime = bi.CreationTime.LowPart;
  output_stat->ctime.dwHighDateTime = bi.CreationTime.HighPart;
  output_stat->atime.dwLowDateTime = bi.LastAccessTime.LowPart;
  output_stat->atime.dwHighDateTime = bi.LastAccessTime.HighPart;
  output_stat->grfLocksSupported = 0;
  memset (&output_stat->clsid, 0, sizeof (CLSID));
  output_stat->grfStateBits = 0;
  output_stat->reserved = 0;
  output_stat->cbSize.QuadPart = si.EndOfFile.QuadPart;
  output_stat->grfMode = self->stgm_mode;

  if (get_name)
    {
      DWORD tries;
      wchar_t *buffer;

      /* Nothing in the documentation guarantees that the name
       * won't change between two invocations (one - to get the
       * buffer size, the other - to fill the buffer).
       * Re-try up to 5 times in case the required buffer size
       * doesn't match.
       */
      for (tries = 5; tries > 0; tries--)
        {
          DWORD buffer_size;
          DWORD buffer_size2;
          DWORD error;

          buffer_size = GetFinalPathNameByHandleW (self->file_handle, NULL, 0, 0);

          if (buffer_size == 0)
            {
              DWORD my_error = GetLastError ();
              return __HRESULT_FROM_WIN32 (my_error);
            }

          buffer = CoTaskMemAlloc (buffer_size);
          buffer[buffer_size - 1] = 0;
          buffer_size2 = GetFinalPathNameByHandleW (self->file_handle, buffer, buffer_size, 0);

          if (buffer_size2 < buffer_size)
            break;

          error = GetLastError ();
          CoTaskMemFree (buffer);
          if (buffer_size2 == 0)
            return __HRESULT_FROM_WIN32 (error);
        }

      if (tries == 0)
        return __HRESULT_FROM_WIN32 (ERROR_BAD_LENGTH);

      output_stat->pwcsName = buffer;
    }
  else
    output_stat->pwcsName = NULL;

  return S_OK;
}

static HRESULT STDMETHODCALLTYPE
_file_sync_stream_clone (IStream  *self_ptr,
                         IStream **output_clone_ptr)
{
  return E_NOTIMPL;
}

static IStreamVtbl _file_sync_stream_vtbl = {
  _file_sync_stream_query_interface,
  _file_sync_stream_add_ref,
  _file_sync_stream_release,
  _file_sync_stream_read,
  _file_sync_stream_write,
  _file_sync_stream_seek,
  _file_sync_stream_set_size,
  _file_sync_stream_copy_to,
  _file_sync_stream_commit,
  _file_sync_stream_revert,
  _file_sync_stream_lock_region,
  _file_sync_stream_unlock_region,
  _file_sync_stream_stat,
  _file_sync_stream_clone,
};

static void
_file_sync_stream_free (GWin32FileSyncStream *self)
{
  if (self->owns_handle)
    CloseHandle (self->file_handle);

  g_free (self);
}

/**
 * g_win32_file_sync_stream_new:
 * @handle: a Win32 HANDLE for a file.
 * @owns_handle: %TRUE if newly-created stream owns the handle
 *               (and closes it when destroyed)
 * @stgm_mode: a combination of [STGM constants](https://docs.microsoft.com/en-us/windows/win32/stg/stgm-constants)
 *             that specify the mode with which the stream
 *             is opened.
 * @output_hresult: (out) (optional): a HRESULT from the internal COM calls.
 *                                    Will be `S_OK` on success.
 *
 * Creates an IStream object backed by a HANDLE.
 *
 * @stgm_mode should match the mode of the @handle, otherwise the stream might
 * attempt to perform operations that the @handle does not allow. The implementation
 * itself ignores these flags completely, they are only used to report
 * the mode of the stream to third parties.
 *
 * The stream only does synchronous access and will never return `E_PENDING` on I/O.
 *
 * The returned stream object should be treated just like any other
 * COM object, and released via `IUnknown_Release()`.
 * its elements have been unreffed with g_object_unref().
 *
 * Returns: (nullable) (transfer full): a new IStream object on success, %NULL on failure.
 **/
IStream *
g_win32_file_sync_stream_new (HANDLE    file_handle,
                              gboolean  owns_handle,
                              DWORD     stgm_mode,
                              HRESULT  *output_hresult)
{
  GWin32FileSyncStream *new_stream;
  IStream *result;
  HRESULT hr;

  new_stream = g_new0 (GWin32FileSyncStream, 1);
  new_stream->self.lpVtbl = &_file_sync_stream_vtbl;

  hr = IUnknown_QueryInterface ((IUnknown *) new_stream, &IID_IStream, (void **) &result);
  if (!SUCCEEDED (hr))
    {
      g_free (new_stream);

      if (output_hresult)
        *output_hresult = hr;

      return NULL;
    }

  new_stream->stgm_mode = stgm_mode;
  new_stream->file_handle = file_handle;
  new_stream->owns_handle = owns_handle;

  if (output_hresult)
    *output_hresult = S_OK;

  return result;
}