1 /////////////////////////////////////////////////////////////////////////////// 2 // 3 /// \file common.h 4 /// \brief Common functions needed in many places in liblzma 5 // 6 // Author: Lasse Collin 7 // 8 // This file has been put into the public domain. 9 // You can do whatever you want with this file. 10 // 11 /////////////////////////////////////////////////////////////////////////////// 12 13 #include "common.h" 14 15 16 ///////////// 17 // Version // 18 ///////////// 19 20 extern LZMA_API(uint32_t) 21 lzma_version_number(void) 22 { 23 return LZMA_VERSION; 24 } 25 26 27 extern LZMA_API(const char *) 28 lzma_version_string(void) 29 { 30 return LZMA_VERSION_STRING; 31 } 32 33 34 /////////////////////// 35 // Memory allocation // 36 /////////////////////// 37 38 extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1) 39 lzma_alloc(size_t size, lzma_allocator *allocator) 40 { 41 // Some malloc() variants return NULL if called with size == 0. 42 if (size == 0) 43 size = 1; 44 45 void *ptr; 46 47 if (allocator != NULL && allocator->alloc != NULL) 48 ptr = allocator->alloc(allocator->opaque, 1, size); 49 else 50 ptr = malloc(size); 51 52 return ptr; 53 } 54 55 56 extern void 57 lzma_free(void *ptr, lzma_allocator *allocator) 58 { 59 if (allocator != NULL && allocator->free != NULL) 60 allocator->free(allocator->opaque, ptr); 61 else 62 free(ptr); 63 64 return; 65 } 66 67 68 ////////// 69 // Misc // 70 ////////// 71 72 extern size_t 73 lzma_bufcpy(const uint8_t *restrict in, size_t *restrict in_pos, 74 size_t in_size, uint8_t *restrict out, 75 size_t *restrict out_pos, size_t out_size) 76 { 77 const size_t in_avail = in_size - *in_pos; 78 const size_t out_avail = out_size - *out_pos; 79 const size_t copy_size = my_min(in_avail, out_avail); 80 81 memcpy(out + *out_pos, in + *in_pos, copy_size); 82 83 *in_pos += copy_size; 84 *out_pos += copy_size; 85 86 return copy_size; 87 } 88 89 90 extern lzma_ret 91 lzma_next_filter_init(lzma_next_coder *next, lzma_allocator *allocator, 92 const lzma_filter_info *filters) 93 { 94 lzma_next_coder_init(filters[0].init, next, allocator); 95 next->id = filters[0].id; 96 return filters[0].init == NULL 97 ? LZMA_OK : filters[0].init(next, allocator, filters); 98 } 99 100 101 extern lzma_ret 102 lzma_next_filter_update(lzma_next_coder *next, lzma_allocator *allocator, 103 const lzma_filter *reversed_filters) 104 { 105 // Check that the application isn't trying to change the Filter ID. 106 // End of filters is indicated with LZMA_VLI_UNKNOWN in both 107 // reversed_filters[0].id and next->id. 108 if (reversed_filters[0].id != next->id) 109 return LZMA_PROG_ERROR; 110 111 if (reversed_filters[0].id == LZMA_VLI_UNKNOWN) 112 return LZMA_OK; 113 114 assert(next->update != NULL); 115 return next->update(next->coder, allocator, NULL, reversed_filters); 116 } 117 118 119 extern void 120 lzma_next_end(lzma_next_coder *next, lzma_allocator *allocator) 121 { 122 if (next->init != (uintptr_t)(NULL)) { 123 // To avoid tiny end functions that simply call 124 // lzma_free(coder, allocator), we allow leaving next->end 125 // NULL and call lzma_free() here. 126 if (next->end != NULL) 127 next->end(next->coder, allocator); 128 else 129 lzma_free(next->coder, allocator); 130 131 // Reset the variables so the we don't accidentally think 132 // that it is an already initialized coder. 133 *next = LZMA_NEXT_CODER_INIT; 134 } 135 136 return; 137 } 138 139 140 ////////////////////////////////////// 141 // External to internal API wrapper // 142 ////////////////////////////////////// 143 144 extern lzma_ret 145 lzma_strm_init(lzma_stream *strm) 146 { 147 if (strm == NULL) 148 return LZMA_PROG_ERROR; 149 150 if (strm->internal == NULL) { 151 strm->internal = lzma_alloc(sizeof(lzma_internal), 152 strm->allocator); 153 if (strm->internal == NULL) 154 return LZMA_MEM_ERROR; 155 156 strm->internal->next = LZMA_NEXT_CODER_INIT; 157 } 158 159 strm->internal->supported_actions[LZMA_RUN] = false; 160 strm->internal->supported_actions[LZMA_SYNC_FLUSH] = false; 161 strm->internal->supported_actions[LZMA_FULL_FLUSH] = false; 162 strm->internal->supported_actions[LZMA_FINISH] = false; 163 strm->internal->sequence = ISEQ_RUN; 164 strm->internal->allow_buf_error = false; 165 166 strm->total_in = 0; 167 strm->total_out = 0; 168 169 return LZMA_OK; 170 } 171 172 173 extern LZMA_API(lzma_ret) 174 lzma_code(lzma_stream *strm, lzma_action action) 175 { 176 // Sanity checks 177 if ((strm->next_in == NULL && strm->avail_in != 0) 178 || (strm->next_out == NULL && strm->avail_out != 0) 179 || strm->internal == NULL 180 || strm->internal->next.code == NULL 181 || (unsigned int)(action) > LZMA_FINISH 182 || !strm->internal->supported_actions[action]) 183 return LZMA_PROG_ERROR; 184 185 // Check if unsupported members have been set to non-zero or non-NULL, 186 // which would indicate that some new feature is wanted. 187 if (strm->reserved_ptr1 != NULL 188 || strm->reserved_ptr2 != NULL 189 || strm->reserved_ptr3 != NULL 190 || strm->reserved_ptr4 != NULL 191 || strm->reserved_int1 != 0 192 || strm->reserved_int2 != 0 193 || strm->reserved_int3 != 0 194 || strm->reserved_int4 != 0 195 || strm->reserved_enum1 != LZMA_RESERVED_ENUM 196 || strm->reserved_enum2 != LZMA_RESERVED_ENUM) 197 return LZMA_OPTIONS_ERROR; 198 199 switch (strm->internal->sequence) { 200 case ISEQ_RUN: 201 switch (action) { 202 case LZMA_RUN: 203 break; 204 205 case LZMA_SYNC_FLUSH: 206 strm->internal->sequence = ISEQ_SYNC_FLUSH; 207 break; 208 209 case LZMA_FULL_FLUSH: 210 strm->internal->sequence = ISEQ_FULL_FLUSH; 211 break; 212 213 case LZMA_FINISH: 214 strm->internal->sequence = ISEQ_FINISH; 215 break; 216 } 217 218 break; 219 220 case ISEQ_SYNC_FLUSH: 221 // The same action must be used until we return 222 // LZMA_STREAM_END, and the amount of input must not change. 223 if (action != LZMA_SYNC_FLUSH 224 || strm->internal->avail_in != strm->avail_in) 225 return LZMA_PROG_ERROR; 226 227 break; 228 229 case ISEQ_FULL_FLUSH: 230 if (action != LZMA_FULL_FLUSH 231 || strm->internal->avail_in != strm->avail_in) 232 return LZMA_PROG_ERROR; 233 234 break; 235 236 case ISEQ_FINISH: 237 if (action != LZMA_FINISH 238 || strm->internal->avail_in != strm->avail_in) 239 return LZMA_PROG_ERROR; 240 241 break; 242 243 case ISEQ_END: 244 return LZMA_STREAM_END; 245 246 case ISEQ_ERROR: 247 default: 248 return LZMA_PROG_ERROR; 249 } 250 251 size_t in_pos = 0; 252 size_t out_pos = 0; 253 lzma_ret ret = strm->internal->next.code( 254 strm->internal->next.coder, strm->allocator, 255 strm->next_in, &in_pos, strm->avail_in, 256 strm->next_out, &out_pos, strm->avail_out, action); 257 258 strm->next_in += in_pos; 259 strm->avail_in -= in_pos; 260 strm->total_in += in_pos; 261 262 strm->next_out += out_pos; 263 strm->avail_out -= out_pos; 264 strm->total_out += out_pos; 265 266 strm->internal->avail_in = strm->avail_in; 267 268 switch (ret) { 269 case LZMA_OK: 270 // Don't return LZMA_BUF_ERROR when it happens the first time. 271 // This is to avoid returning LZMA_BUF_ERROR when avail_out 272 // was zero but still there was no more data left to written 273 // to next_out. 274 if (out_pos == 0 && in_pos == 0) { 275 if (strm->internal->allow_buf_error) 276 ret = LZMA_BUF_ERROR; 277 else 278 strm->internal->allow_buf_error = true; 279 } else { 280 strm->internal->allow_buf_error = false; 281 } 282 break; 283 284 case LZMA_STREAM_END: 285 if (strm->internal->sequence == ISEQ_SYNC_FLUSH 286 || strm->internal->sequence == ISEQ_FULL_FLUSH) 287 strm->internal->sequence = ISEQ_RUN; 288 else 289 strm->internal->sequence = ISEQ_END; 290 291 // Fall through 292 293 case LZMA_NO_CHECK: 294 case LZMA_UNSUPPORTED_CHECK: 295 case LZMA_GET_CHECK: 296 case LZMA_MEMLIMIT_ERROR: 297 // Something else than LZMA_OK, but not a fatal error, 298 // that is, coding may be continued (except if ISEQ_END). 299 strm->internal->allow_buf_error = false; 300 break; 301 302 default: 303 // All the other errors are fatal; coding cannot be continued. 304 assert(ret != LZMA_BUF_ERROR); 305 strm->internal->sequence = ISEQ_ERROR; 306 break; 307 } 308 309 return ret; 310 } 311 312 313 extern LZMA_API(void) 314 lzma_end(lzma_stream *strm) 315 { 316 if (strm != NULL && strm->internal != NULL) { 317 lzma_next_end(&strm->internal->next, strm->allocator); 318 lzma_free(strm->internal, strm->allocator); 319 strm->internal = NULL; 320 } 321 322 return; 323 } 324 325 326 extern LZMA_API(lzma_check) 327 lzma_get_check(const lzma_stream *strm) 328 { 329 // Return LZMA_CHECK_NONE if we cannot know the check type. 330 // It's a bug in the application if this happens. 331 if (strm->internal->next.get_check == NULL) 332 return LZMA_CHECK_NONE; 333 334 return strm->internal->next.get_check(strm->internal->next.coder); 335 } 336 337 338 extern LZMA_API(uint64_t) 339 lzma_memusage(const lzma_stream *strm) 340 { 341 uint64_t memusage; 342 uint64_t old_memlimit; 343 344 if (strm == NULL || strm->internal == NULL 345 || strm->internal->next.memconfig == NULL 346 || strm->internal->next.memconfig( 347 strm->internal->next.coder, 348 &memusage, &old_memlimit, 0) != LZMA_OK) 349 return 0; 350 351 return memusage; 352 } 353 354 355 extern LZMA_API(uint64_t) 356 lzma_memlimit_get(const lzma_stream *strm) 357 { 358 uint64_t old_memlimit; 359 uint64_t memusage; 360 361 if (strm == NULL || strm->internal == NULL 362 || strm->internal->next.memconfig == NULL 363 || strm->internal->next.memconfig( 364 strm->internal->next.coder, 365 &memusage, &old_memlimit, 0) != LZMA_OK) 366 return 0; 367 368 return old_memlimit; 369 } 370 371 372 extern LZMA_API(lzma_ret) 373 lzma_memlimit_set(lzma_stream *strm, uint64_t new_memlimit) 374 { 375 // Dummy variables to simplify memconfig functions 376 uint64_t old_memlimit; 377 uint64_t memusage; 378 379 if (strm == NULL || strm->internal == NULL 380 || strm->internal->next.memconfig == NULL) 381 return LZMA_PROG_ERROR; 382 383 if (new_memlimit != 0 && new_memlimit < LZMA_MEMUSAGE_BASE) 384 return LZMA_MEMLIMIT_ERROR; 385 386 return strm->internal->next.memconfig(strm->internal->next.coder, 387 &memusage, &old_memlimit, new_memlimit); 388 } 389