X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fblock.c;h=a757e3cf2d487753602ca57282b3e905d2940095;hb=4917bfb899bf9d93ec1efb737980b2eb69f3125f;hp=7e94ec9419f682d2fc4fe3ed4afee25ad7b37aed;hpb=5365c5866ef6ea65ee2deaeea8a978d1f0657bbc;p=vlc

diff --git a/src/misc/block.c b/src/misc/block.c
index 7e94ec9419..a757e3cf2d 100644
--- a/src/misc/block.c
+++ b/src/misc/block.c
@@ -28,7 +28,8 @@
 # include "config.h"
 #endif
 
-#include <vlc/vlc.h>
+#include <vlc_common.h>
+#include <sys/stat.h>
 #include "vlc_block.h"
 
 /*****************************************************************************
@@ -105,7 +106,13 @@ block_t *block_Alloc( size_t i_size )
 block_t *block_Realloc( block_t *p_block, ssize_t i_prebody, size_t i_body )
 {
     block_sys_t *p_sys = (block_sys_t *)p_block;
-    ssize_t i_buffer_size;
+    ssize_t i_buffer_size = i_prebody + i_body;
+
+    if( i_buffer_size <= 0 )
+    {
+        block_Release( p_block );
+        return NULL;
+    }
 
     if( p_block->pf_release != BlockRelease )
     {
@@ -119,14 +126,6 @@ block_t *block_Realloc( block_t *p_block, ssize_t i_prebody, size_t i_body )
         p_block = p_dup;
     }
 
-    i_buffer_size = i_prebody + i_body;
-
-    if( i_buffer_size <= 0 )
-    {
-        block_Release( p_block );
-        return NULL;
-    }
-
     /* Adjust reserved header if there is enough room */
     if( p_block->p_buffer - i_prebody > p_sys->p_allocated_buffer &&
         p_block->p_buffer - i_prebody < p_sys->p_allocated_buffer +
@@ -208,6 +207,16 @@ static void block_mmap_Release (block_t *block)
     free (p_sys);
 }
 
+/**
+ * Creates a block from a virtual address memory mapping (mmap).
+ * This is provided by LibVLC so that mmap blocks can safely be deallocated
+ * even after the allocating plugin has been unloaded from memory.
+ *
+ * @param addr base address of the mapping (as returned by mmap)
+ * @param length length (bytes) of the mapping (as passed to mmap)
+ * @return NULL if addr is MAP_FAILED, or an error occurred (in the later
+ * case, munmap(addr, length) is invoked before returning).
+ */
 block_t *block_mmap_Alloc (void *addr, size_t length)
 {
     if (addr == MAP_FAILED)
@@ -226,8 +235,106 @@ block_t *block_mmap_Alloc (void *addr, size_t length)
     block->length = length;
     return &block->self;
 }
+#else
+block_t *block_mmap_Alloc (void *addr, size_t length)
+{
+    (void)addr; (void)length; return NULL;
+}
+#endif
+
+
+#ifdef WIN32
+static
+ssize_t pread (int fd, void *buf, size_t count, off_t offset)
+{
+    HANDLE handle = (HANDLE)(intptr_t)_get_osfhandle (fd);
+    if (handle == INVALID_HANDLE_VALUE)
+        return -1;
+
+    OVERLAPPED olap = { .Offset = offset, .OffsetHigh = (offset >> 32), };
+    DWORD written;
+    /* This braindead API will override the file pointer even if we specify
+     * an explicit read offset... So do not expect this to mix well with
+     * regular read() calls. */
+    if (ReadFile (handle, buf, count, &written, &olap))
+        return written;
+    return -1;
+}
+#endif
+
+/**
+ * Loads a file into a block of memory. If possible a private file mapping is
+ * created. Otherwise, the file is read normally. On 32-bits platforms, this
+ * function will not work for very large files, due to memory space
+ * constraints.
+ *
+ * @param fd file descriptor to load from
+ * @return a new block with the file content at p_buffer, and file length at
+ * i_buffer (release it with block_Release()), or NULL upon error (see errno).
+ */
+block_t *block_File (int fd)
+{
+    size_t length;
+    struct stat st;
+
+    /* First, get the file size */
+    if (fstat (fd, &st))
+        return NULL;
+
+    /* st_size is meaningful for regular files, shared memory and typed memory.
+     * It's also meaning for symlinks, but that's not possible with fstat().
+     * In other cases, it's undefined, and we should really not go further. */
+#ifndef S_TYPEISSHM
+# define S_TYPEISSHM( buf ) (0)
+#endif
+    if (S_ISDIR (st.st_mode))
+    {
+        errno = EISDIR;
+        return NULL;
+    }
+    if (!S_ISREG (st.st_mode) && !S_TYPEISSHM (&st))
+    {
+        errno = ESPIPE;
+        return NULL;
+    }
+
+    /* Prevent an integer overflow in mmap() and malloc() */
+    if (st.st_size >= SIZE_MAX)
+    {
+        errno = ENOMEM;
+        return NULL;
+    }
+    length = (size_t)st.st_size;
+
+#ifdef HAVE_MMAP
+    if (length > 0)
+    {
+        void *addr;
+
+        addr = mmap (NULL, length, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
+        if (addr != MAP_FAILED)
+            return block_mmap_Alloc (addr, length);
+    }
 #endif
 
+    /* If mmap() is not implemented by the OS _or_ the filesystem... */
+    block_t *block = block_Alloc (length);
+    if (block == NULL)
+        return NULL;
+
+    for (size_t i = 0; i < length;)
+    {
+        ssize_t len = pread (fd, block->p_buffer + i, length - i, i);
+        if (len == -1)
+        {
+            block_Release (block);
+            return NULL;
+        }
+        i += len;
+    }
+    return block;
+}
+
 /*****************************************************************************
  * block_fifo_t management
  *****************************************************************************/
@@ -243,14 +350,14 @@ struct block_fifo_t
     bool          b_force_wake;
 };
 
-block_fifo_t *__block_FifoNew( vlc_object_t *p_obj )
+block_fifo_t *block_FifoNew( void )
 {
-    block_fifo_t *p_fifo;
+    block_fifo_t *p_fifo = malloc( sizeof( block_fifo_t ) );
+    if( !p_fifo )
+        return NULL;
 
-    p_fifo = malloc( sizeof( block_fifo_t ) );
-    if( !p_fifo ) return NULL;
-    vlc_mutex_init( p_obj, &p_fifo->lock );
-    vlc_cond_init( p_obj, &p_fifo->wait );
+    vlc_mutex_init( &p_fifo->lock );
+    vlc_cond_init( NULL, &p_fifo->wait );
     p_fifo->p_first = NULL;
     p_fifo->pp_last = &p_fifo->p_first;
     p_fifo->i_depth = p_fifo->i_size = 0;