src/w_file_win32.c

   1 // Emacs style mode select   -*- C++ -*-
   2 //-----------------------------------------------------------------------------
   3 //
   4 // Copyright(C) 1993-1996 Id Software, Inc.
   5 // Copyright(C) 2008 Simon Howard
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License
   9 // as published by the Free Software Foundation; either version 2
  10 // of the License, or (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, write to the Free Software
  19 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20 // 02111-1307, USA.
  21 //
  22 // DESCRIPTION:
  23 //      WAD I/O functions.
  24 //
  25 //-----------------------------------------------------------------------------
  26
  27 #include "config.h"
  28
  29 #ifdef _WIN32
  30
  31 #include <stdio.h>
  32
  33 #define WIN32_LEAN_AND_MEAN
  34 #include <windows.h>
  35
  36 #include "i_system.h"
  37 #include "w_file.h"
  38 #include "z_zone.h"
  39
  40 // This constant doesn't exist in VC6:
  41
  42 #ifndef INVALID_SET_FILE_POINTER
  43 #define INVALID_SET_FILE_POINTER 0xffffffff
  44 #endif
  45
  46 typedef struct
  47 {
  48     wad_file_t wad;
  49     HANDLE handle;
  50     HANDLE handle_map;
  51 } win32_wad_file_t;
  52
  53 extern wad_file_class_t win32_wad_file;
  54
  55 static void MapFile(win32_wad_file_t *wad, char *filename)
  56 {
  57     wad->handle_map = CreateFileMapping(wad->handle,
  58                                         NULL,
  59                                         PAGE_WRITECOPY,
  60                                         0,
  61                                         0,
  62                                         NULL);
  63
  64     if (wad->handle_map == NULL)
  65     {
  66         fprintf(stderr, "W_Win32_OpenFile: Unable to CreateFileMapping() "
  67                         "for %s\n", filename);
  68         return;
  69     }
  70
  71     wad->wad.mapped = MapViewOfFile(wad->handle_map,
  72                                     FILE_MAP_COPY,
  73                                     0, 0, 0);
  74
  75     if (wad->wad.mapped == NULL)
  76     {
  77         fprintf(stderr, "W_Win32_OpenFile: Unable to MapViewOfFile() for %s\n",
  78                         filename);
  79     }
  80 }
  81
  82 unsigned int GetFileLength(HANDLE handle)
  83 {
  84     DWORD result;
  85
  86     result = SetFilePointer(handle, 0, NULL, FILE_END);
  87
  88     if (result == INVALID_SET_FILE_POINTER)
  89     {
  90         I_Error("W_Win32_OpenFile: Failed to read file length");
  91     }
  92
  93     return result;
  94 }
  95
  96 static wad_file_t *W_Win32_OpenFile(char *path)
  97 {
  98     win32_wad_file_t *result;
  99     wchar_t wpath[MAX_PATH + 1];
 100     HANDLE handle;
 101
 102     // Open the file:
 103
 104     MultiByteToWideChar(CP_OEMCP, 0,
 105                         path, strlen(path) + 1,
 106                         wpath, sizeof(wpath));
 107
 108     handle = CreateFileW(wpath,
 109                          GENERIC_READ,
 110                          FILE_SHARE_READ,
 111                          NULL,
 112                          OPEN_EXISTING,
 113                          FILE_ATTRIBUTE_NORMAL,
 114                          NULL);
 115
 116     if (handle == INVALID_HANDLE_VALUE)
 117     {
 118         return NULL;
 119     }
 120
 121     // Create a new win32_wad_file_t to hold the file handle.
 122
 123     result = Z_Malloc(sizeof(win32_wad_file_t), PU_STATIC, 0);
 124     result->wad.file_class = &win32_wad_file;
 125     result->wad.length = GetFileLength(handle);
 126     result->handle = handle;
 127
 128     // Try to map the file into memory with mmap:
 129
 130     MapFile(result, path);
 131
 132     return &result->wad;
 133 }
 134
 135 static void W_Win32_CloseFile(wad_file_t *wad)
 136 {
 137     win32_wad_file_t *win32_wad;
 138
 139     win32_wad = (win32_wad_file_t *) wad;
 140
 141     // If mapped, unmap it.
 142
 143     if (win32_wad->wad.mapped != NULL)
 144     {
 145         UnmapViewOfFile(win32_wad->wad.mapped);
 146     }
 147
 148     if (win32_wad->handle_map != NULL)
 149     {
 150         CloseHandle(win32_wad->handle_map);
 151     }
 152
 153     // Close the file
 154
 155     if (win32_wad->handle != NULL)
 156     {
 157         CloseHandle(win32_wad->handle);
 158     }
 159
 160     Z_Free(win32_wad);
 161 }
 162
 163 // Read data from the specified position in the file into the
 164 // provided buffer.  Returns the number of bytes read.
 165
 166 size_t W_Win32_Read(wad_file_t *wad, unsigned int offset,
 167                    void *buffer, size_t buffer_len)
 168 {
 169     win32_wad_file_t *win32_wad;
 170     DWORD bytes_read;
 171     DWORD result;
 172
 173     win32_wad = (win32_wad_file_t *) wad;
 174
 175     // Jump to the specified position in the file.
 176
 177     result = SetFilePointer(win32_wad->handle, offset, NULL, FILE_BEGIN);
 178
 179     if (result == INVALID_SET_FILE_POINTER)
 180     {
 181         I_Error("W_Win32_Read: Failed to set file pointer to %i",
 182                 offset);
 183     }
 184
 185     // Read into the buffer.
 186
 187     if (!ReadFile(win32_wad->handle, buffer, buffer_len, &bytes_read, NULL))
 188     {
 189         I_Error("W_Win32_Read: Error reading from file");
 190     }
 191
 192     return bytes_read;
 193 }
 194
 195
 196 wad_file_class_t win32_wad_file =
 197 {
 198     W_Win32_OpenFile,
 199     W_Win32_CloseFile,
 200     W_Win32_Read,
 201 };
 202
 203
 204 #endif /* #ifdef _WIN32 */
 205