/** * mate_keyring_memory_try_realloc: * @p: The pointer to reallocate or NULL to allocate a new block. * @sz: The new desired size of the memory block. * * Reallocate a block of mate-keyring non-pageable memory. * * Glib memory is also reallocated correctly when passed to this function. * If called with a null pointer, then a new block of memory is allocated. * If called with a zero size, then the block of memory is freed. * * If memory cannot be allocated, NULL is returned and the original block * of memory remains intact. * * Return value: The new block, or NULL if memory cannot be allocated. * The memory block should be freed with mate_keyring_memory_free() */ gpointer mate_keyring_memory_try_realloc (gpointer p, gulong sz) { gpointer n; if (!p) { return mate_keyring_memory_try_alloc (sz); } else if (!sz) { mate_keyring_memory_free (p); return NULL; } else if (!egg_secure_check (p)) { return g_try_realloc (p, sz); } /* First try and ask secure memory to reallocate */ n = egg_secure_realloc_full (p, sz, 0); g_assert (n); return n; }
static gboolean pem_parse_block (const gchar *data, gsize n_data, guchar **decoded, gsize *n_decoded, GHashTable **headers) { const gchar *x, *hbeg, *hend; const gchar *p, *end; gint state = 0; guint save = 0; g_assert (data); g_assert (n_data); g_assert (decoded); g_assert (n_decoded); p = data; end = p + n_data; hbeg = hend = NULL; /* Try and find a pair of blank lines with only white space between */ while (hend == NULL) { x = memchr (p, '\n', end - p); if (!x) break; ++x; while (isspace (*x)) { /* Found a second line, with only spaces between */ if (*x == '\n') { hbeg = data; hend = x; break; /* Found a space between two lines */ } else { ++x; } } /* Try next line */ p = x; } /* Headers found? */ if (hbeg && hend) { data = hend; n_data = end - data; } *n_decoded = (n_data * 3) / 4 + 1; if (egg_secure_check (data)) *decoded = egg_secure_alloc (*n_decoded); else *decoded = g_malloc0 (*n_decoded); g_return_val_if_fail (*decoded, FALSE); *n_decoded = g_base64_decode_step (data, n_data, *decoded, &state, &save); if (!*n_decoded) { egg_secure_free (*decoded); return FALSE; } if (headers && hbeg && hend) parse_header_lines (hbeg, hend, headers); return TRUE; }
/** * mate_keyring_memory_is_secure: * @p: The pointer to check * * Check if a pointer is in non-pageable memory allocated by mate-keyring. * * Return value: Whether the memory is non-pageable or not */ gboolean mate_keyring_memory_is_secure (gpointer p) { return egg_secure_check (p) ? TRUE : FALSE; }