1 /*- 2 * Copyright (c) 2003-2007 Tim Kientzle 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #include "archive_platform.h" 27 __FBSDID("$FreeBSD: src/lib/libarchive/archive_read_open_memory.c,v 1.6 2007/07/06 15:51:59 kientzle Exp $"); 28 29 #include <errno.h> 30 #include <stdlib.h> 31 #include <string.h> 32 33 #include "archive.h" 34 35 /* 36 * Glue to read an archive from a block of memory. 37 * 38 * This is mostly a huge help in building test harnesses; 39 * test programs can build archives in memory and read them 40 * back again without having to mess with files on disk. 41 */ 42 43 struct read_memory_data { 44 const unsigned char *start; 45 const unsigned char *p; 46 const unsigned char *end; 47 ssize_t read_size; 48 }; 49 50 static int memory_read_close(struct archive *, void *); 51 static int memory_read_open(struct archive *, void *); 52 static int64_t memory_read_seek(struct archive *, void *, int64_t offset, int whence); 53 static int64_t memory_read_skip(struct archive *, void *, int64_t request); 54 static ssize_t memory_read(struct archive *, void *, const void **buff); 55 56 int 57 archive_read_open_memory(struct archive *a, const void *buff, size_t size) 58 { 59 return archive_read_open_memory2(a, buff, size, size); 60 } 61 62 /* 63 * Don't use _open_memory2() in production code; the archive_read_open_memory() 64 * version is the one you really want. This is just here so that 65 * test harnesses can exercise block operations inside the library. 66 */ 67 int 68 archive_read_open_memory2(struct archive *a, const void *buff, 69 size_t size, size_t read_size) 70 { 71 struct read_memory_data *mine; 72 73 mine = (struct read_memory_data *)calloc(1, sizeof(*mine)); 74 if (mine == NULL) { 75 archive_set_error(a, ENOMEM, "No memory"); 76 return (ARCHIVE_FATAL); 77 } 78 mine->start = mine->p = (const unsigned char *)buff; 79 mine->end = mine->start + size; 80 mine->read_size = read_size; 81 archive_read_set_open_callback(a, memory_read_open); 82 archive_read_set_read_callback(a, memory_read); 83 archive_read_set_seek_callback(a, memory_read_seek); 84 archive_read_set_skip_callback(a, memory_read_skip); 85 archive_read_set_close_callback(a, memory_read_close); 86 archive_read_set_callback_data(a, mine); 87 return (archive_read_open1(a)); 88 } 89 90 /* 91 * There's nothing to open. 92 */ 93 static int 94 memory_read_open(struct archive *a, void *client_data) 95 { 96 (void)a; /* UNUSED */ 97 (void)client_data; /* UNUSED */ 98 return (ARCHIVE_OK); 99 } 100 101 /* 102 * This is scary simple: Just advance a pointer. Limiting 103 * to read_size is not technically necessary, but it exercises 104 * more of the internal logic when used with a small block size 105 * in a test harness. Production use should not specify a block 106 * size; then this is much faster. 107 */ 108 static ssize_t 109 memory_read(struct archive *a, void *client_data, const void **buff) 110 { 111 struct read_memory_data *mine = (struct read_memory_data *)client_data; 112 ssize_t size; 113 114 (void)a; /* UNUSED */ 115 *buff = mine->p; 116 size = mine->end - mine->p; 117 if (size > mine->read_size) 118 size = mine->read_size; 119 mine->p += size; 120 return (size); 121 } 122 123 /* 124 * Advancing is just as simple. Again, this is doing more than 125 * necessary in order to better exercise internal code when used 126 * as a test harness. 127 */ 128 static int64_t 129 memory_read_skip(struct archive *a, void *client_data, int64_t skip) 130 { 131 struct read_memory_data *mine = (struct read_memory_data *)client_data; 132 133 (void)a; /* UNUSED */ 134 if ((int64_t)skip > (int64_t)(mine->end - mine->p)) 135 skip = mine->end - mine->p; 136 /* Round down to block size. */ 137 skip /= mine->read_size; 138 skip *= mine->read_size; 139 mine->p += skip; 140 return (skip); 141 } 142 143 /* 144 * Seeking. 145 */ 146 static int64_t 147 memory_read_seek(struct archive *a, void *client_data, int64_t offset, int whence) 148 { 149 struct read_memory_data *mine = (struct read_memory_data *)client_data; 150 151 (void)a; /* UNUSED */ 152 switch (whence) { 153 case SEEK_SET: 154 mine->p = mine->start + offset; 155 break; 156 case SEEK_CUR: 157 mine->p += offset; 158 break; 159 case SEEK_END: 160 mine->p = mine->end + offset; 161 break; 162 default: 163 return ARCHIVE_FATAL; 164 } 165 if (mine->p < mine->start) { 166 mine->p = mine->start; 167 return ARCHIVE_FAILED; 168 } 169 if (mine->p > mine->end) { 170 mine->p = mine->end; 171 return ARCHIVE_FAILED; 172 } 173 return (mine->p - mine->start); 174 } 175 176 /* 177 * Close is just cleaning up our one small bit of data. 178 */ 179 static int 180 memory_read_close(struct archive *a, void *client_data) 181 { 182 struct read_memory_data *mine = (struct read_memory_data *)client_data; 183 (void)a; /* UNUSED */ 184 free(mine); 185 return (ARCHIVE_OK); 186 } 187