gpointer g_malloc0_n(gsize n_blocks,gsize n_block_bytes) { if(SIZE_OVERFLOWS(n_blocks,n_block_bytes)){ g_error ("%s: overflow allocating %"G_GSIZE_FORMAT"*%"G_GSIZE_FORMAT" bytes", G_STRLOC,n_blocks,n_block_bytes); } return g_malloc0(n_blocks * n_block_bytes); }
/** * g_try_malloc0_n: * @n_blocks: the number of blocks to allocate * @n_block_bytes: the size of each block in bytes * * This function is similar to g_try_malloc0(), allocating (@n_blocks * @n_block_bytes) bytes, * but care is taken to detect possible overflow during multiplication. * * Since: 2.24 * Returns: the allocated memory, or %NULL */ gpointer g_try_malloc0_n (gsize n_blocks, gsize n_block_bytes) { if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) return NULL; return g_try_malloc0 (n_blocks * n_block_bytes); }
void *spice_realloc_n(void *mem, size_t n_blocks, size_t n_block_bytes) { if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) { MALLOC_ERROR("spice_realloc_n: overflow allocating %lu*%lu bytes", (unsigned long)n_blocks, (unsigned long)n_block_bytes); } return spice_realloc(mem, n_blocks * n_block_bytes); }
/** * g_try_realloc_n: * @mem: (nullable): previously-allocated memory, or %NULL. * @n_blocks: the number of blocks to allocate * @n_block_bytes: the size of each block in bytes * * This function is similar to g_try_realloc(), allocating (@n_blocks * @n_block_bytes) bytes, * but care is taken to detect possible overflow during multiplication. * * Since: 2.24 * Returns: the allocated memory, or %NULL. */ gpointer g_try_realloc_n (gpointer mem, gsize n_blocks, gsize n_block_bytes) { if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) return NULL; return g_try_realloc (mem, n_blocks * n_block_bytes); }
gpointer g_malloc_n (gsize n_blocks, gsize n_block_bytes) { if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) { __android_log_print(ANDROID_LOG_ERROR, "memanalyze", "%s: overflow allocating %" G_GSIZE_FORMAT "*%" G_GSIZE_FORMAT " bytes", G_STRLOC, n_blocks, n_block_bytes); __builtin_unreachable(); } return mycalloc (n_blocks, n_block_bytes); }
gpointer g_malloc0_n (gsize n_blocks, gsize n_block_bytes) { if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) { if (G_UNLIKELY (!g_mem_initialized)) g_mem_init_nomessage(); g_error ("%s: overflow allocating %"G_GSIZE_FORMAT"*%"G_GSIZE_FORMAT" bytes", G_STRLOC, n_blocks, n_block_bytes); } return g_malloc0 (n_blocks * n_block_bytes); }
void *spice_malloc_n_m(size_t n_blocks, size_t n_block_bytes, size_t extra_size) { size_t size1, size2; if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) { MALLOC_ERROR("spice_malloc_n: overflow allocating %lu*%lu + %lubytes", (unsigned long)n_blocks, (unsigned long)n_block_bytes, (unsigned long)extra_size); } size1 = n_blocks * n_block_bytes; size2 = size1 + extra_size; if (size2 < size1) { MALLOC_ERROR("spice_malloc_n: overflow allocating %lu*%lu + %lubytes", (unsigned long)n_blocks, (unsigned long)n_block_bytes, (unsigned long)extra_size); } return spice_malloc(size2); }
/** * gdk_pixbuf_from_pixdata: * @pixdata: a #GdkPixdata to convert into a #GdkPixbuf. * @copy_pixels: whether to copy raw pixel data; run-length encoded * pixel data is always copied. * @error: location to store possible errors. * * Converts a #GdkPixdata to a #GdkPixbuf. If @copy_pixels is %TRUE or * if the pixel data is run-length-encoded, the pixel data is copied into * newly-allocated memory; otherwise it is reused. * * Returns: (transfer full): a new #GdkPixbuf. * Deprecated: 2.32: Use #GResource instead. **/ GdkPixbuf* gdk_pixbuf_from_pixdata (const GdkPixdata *pixdata, gboolean copy_pixels, GError **error) { guint encoding, bpp; guint8 *data = NULL; g_return_val_if_fail (pixdata != NULL, NULL); g_return_val_if_fail (pixdata->width > 0, NULL); g_return_val_if_fail (pixdata->height > 0, NULL); g_return_val_if_fail (pixdata->rowstride >= pixdata->width, NULL); g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB || (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGBA, NULL); g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_SAMPLE_WIDTH_MASK) == GDK_PIXDATA_SAMPLE_WIDTH_8, NULL); g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RAW || (pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RLE, NULL); g_return_val_if_fail (pixdata->pixel_data != NULL, NULL); bpp = (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB ? 3 : 4; encoding = pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK; g_debug ("gdk_pixbuf_from_pixdata() called on:"); g_debug ("\tEncoding %s", encoding == GDK_PIXDATA_ENCODING_RAW ? "raw" : "rle"); g_debug ("\tDimensions: %d x %d", pixdata->width, pixdata->height); g_debug ("\tRowstride: %d, Length: %d", pixdata->rowstride, pixdata->length); g_debug ("\tCopy pixels == %s", copy_pixels ? "true" : "false"); if (encoding == GDK_PIXDATA_ENCODING_RLE) copy_pixels = TRUE; /* Sanity check the length and dimensions */ if (SIZE_OVERFLOWS (pixdata->height, pixdata->rowstride)) { g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("Image pixel data corrupt")); return NULL; } if (encoding == GDK_PIXDATA_ENCODING_RAW && pixdata->length >= 1 && pixdata->length < pixdata->height * pixdata->rowstride - GDK_PIXDATA_HEADER_LENGTH) { g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("Image pixel data corrupt")); return NULL; } if (copy_pixels) { data = g_try_malloc_n (pixdata->height, pixdata->rowstride); if (!data) { g_set_error (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, g_dngettext(GETTEXT_PACKAGE, "failed to allocate image buffer of %u byte", "failed to allocate image buffer of %u bytes", pixdata->rowstride * pixdata->height), pixdata->rowstride * pixdata->height); return NULL; } } if (encoding == GDK_PIXDATA_ENCODING_RLE) { const guint8 *rle_buffer = pixdata->pixel_data; guint8 *rle_buffer_limit = NULL; guint8 *image_buffer = data; guint8 *image_limit = data + pixdata->rowstride * pixdata->height; gboolean check_overrun = FALSE; if (pixdata->length >= 1) rle_buffer_limit = pixdata->pixel_data + pixdata->length - GDK_PIXDATA_HEADER_LENGTH; while (image_buffer < image_limit && (rle_buffer_limit != NULL || rle_buffer > rle_buffer_limit)) { guint length; if (RLE_OVERRUN(1)) { check_overrun = TRUE; break; } length = *(rle_buffer++); if (length & 128) { length = length - 128; check_overrun = image_buffer + length * bpp > image_limit; if (check_overrun) length = (image_limit - image_buffer) / bpp; if (RLE_OVERRUN(bpp < 4 ? 3 : 4)) { check_overrun = TRUE; break; } if (bpp < 4) /* RGB */ do { memcpy (image_buffer, rle_buffer, 3); image_buffer += 3; } while (--length); else /* RGBA */ do { memcpy (image_buffer, rle_buffer, 4); image_buffer += 4; } while (--length); if (RLE_OVERRUN(bpp)) { check_overrun = TRUE; break; } rle_buffer += bpp; } else { length *= bpp; check_overrun = image_buffer + length > image_limit; if (check_overrun) length = image_limit - image_buffer; if (RLE_OVERRUN(length)) { check_overrun = TRUE; break; } memcpy (image_buffer, rle_buffer, length); image_buffer += length; rle_buffer += length; } } if (check_overrun) { g_free (data); g_set_error_literal (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_CORRUPT_IMAGE, _("Image pixel data corrupt")); return NULL; } } else if (copy_pixels) memcpy (data, pixdata->pixel_data, pixdata->rowstride * pixdata->height); else data = pixdata->pixel_data; return gdk_pixbuf_new_from_data (data, GDK_COLORSPACE_RGB, (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGBA, 8, pixdata->width, pixdata->height, pixdata->rowstride, copy_pixels ? (GdkPixbufDestroyNotify) g_free : NULL, data); }