Non-pageable Memory

## Non-pageable Memory Non-pageable Memory — Secure non-pageable memory |

## Synopsis

    #define             gcr_secure_memory_new               (type,
                                                             n_objects)
    gpointer            gcr_secure_memory_alloc             (gsize size);
    gpointer            gcr_secure_memory_try_alloc         (gsize size);
    gpointer            gcr_secure_memory_realloc           (gpointer memory,
                                                             gsize size);
    gpointer            gcr_secure_memory_try_realloc       (gpointer memory,
                                                             gsize size);
    gchar *             gcr_secure_memory_strdup            (const gchar *string);
    void                gcr_secure_memory_strfree           (gchar *string);
    void                gcr_secure_memory_free              (gpointer memory);
    gboolean            gcr_secure_memory_is_secure         (gpointer memory);

## Description

Normal allocated memory can be paged to disk at the whim of the operating system. This can be a problem for sensitive information like passwords, keys and secrets.

The Gcr library holds passwords and keys in non-pageable, or locked memory. This is only possible if the OS contains support for it.

These functions allow applications to use secure memory to hold passwords and other sensitive information.

## Details

### gcr_secure_memory_new()

    #define             gcr_secure_memory_new(type, n_objects)

Allocate objects in non-pageable memory.

`type` : | C type of the objects to allocate
`n_objects` : | number of objects to allocate
Returns : | the new block of memory. [transfer full]

### gcr_secure_memory_alloc ()

    gpointer            gcr_secure_memory_alloc             (gsize size);

Allocate a block of non-pageable memory.

If non-pageable memory cannot be allocated then normal memory will be returned.

`size` : | The new desired size of the memory block.
Returns : | new memory block which should be freed with `gcr_secure_memory_free()`. [transfer full]

### gcr_secure_memory_try_alloc ()

    gpointer            gcr_secure_memory_try_alloc         (gsize size);

Allocate a block of non-pageable memory.

If non-pageable memory cannot be allocated, then `NULL` is returned.

`size` : | new desired size of the memory block
Returns : | new block, or `NULL` if memory cannot be allocated; memory block should be freed with `gcr_secure_memory_free()`. [transfer full]

### gcr_secure_memory_realloc ()

    gpointer            gcr_secure_memory_realloc           (gpointer memory,
                                                             gsize size);

Reallocate a block of non-pageable memory.

Glib memory is also reallocated correctly. 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 non-pageable memory cannot be allocated then normal memory will be returned.

`memory` : | pointer to reallocate or `NULL` to allocate a new block. [allow-none]
`size` : | new desired size of the memory block, or 0 to free the memory
Returns : | new block, or `NULL` if the block was freed; memory block should be freed with `gcr_secure_memory_free()`. [transfer full]

### gcr_secure_memory_try_realloc ()

    gpointer            gcr_secure_memory_try_realloc       (gpointer memory,
                                                             gsize size);

Reallocate a block of 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.

`memory` : | pointer to reallocate or `NULL` to allocate a new block. [allow-none]
`size` : | new desired size of the memory block
Returns : | the new block, or `NULL` if memory cannot be allocated; the memory block should be freed with `gcr_secure_memory_free()`. [transfer full]

### gcr_secure_memory_strdup ()

    gchar *             gcr_secure_memory_strdup            (const gchar *string);

Copy a string into non-pageable memory. If the input string is `NULL`, then `NULL` will be returned.

`string` : | null terminated string to copy. [allow-none]
Returns : | copied string, should be freed with `gcr_secure_memory_free()`

### gcr_secure_memory_strfree ()

    void                gcr_secure_memory_strfree           (gchar *string);

Free a string, whether securely allocated using these functions or not. This will also clear out the contents of the string so they do not remain in memory.

`string` : | null terminated string to fere. [allow-none]

### gcr_secure_memory_free ()

    void                gcr_secure_memory_free              (gpointer memory);

Free a block of non-pageable memory.

Glib memory is also freed correctly when passed to this function. If called with a `NULL` pointer then no action is taken.

`memory` : | pointer to the beginning of the block of memory to free. [allow-none]

### gcr_secure_memory_is_secure ()

    gboolean            gcr_secure_memory_is_secure         (gpointer memory);

Check if a pointer is in non-pageable memory allocated by.

`memory` : | pointer to check
Returns : | whether the memory is secure non-pageable memory allocated by the Gcr library or not