Cómo Deshacer un realloc exitoso. (Lenguaje C)

Estoy intentando programar una estructura de datos que tiene dos campos implementados con un array dinámico. Al intentar programar la función que se encargará de aumentar la capacidad de la estructura, me encuentro con el siguiente problema.

Si hago dos realloc() secuenciales y compruebo tras el primero que se ha reasignado bien mi array:

• ¿Qué pasa si el segundo realloc() me falla?
• ¿Cómo puedo devolver el espacio reasignado a su tamaño original?
• ¿Un realloc() con el tamaño anterior sería infalible? ¿O tendría que comprobar también si éste se pudo realizar?

Como estoy solicitando menos memoria, no debería generar ningún problema, ¿o sí? De no ser así, entraría en un problema recurrente. ¿Cómo puedo hacer un programa que gestione bien esta memoria?

Gracias de antemano. Adjunto el código incompleto y la EdD.

  struct _Graph {
    Node **nodes; /*!<Dynamic array with the graph nodes */
    List **plconnect; /*!<Adjacency dynamic array list */
    int num_nodes; /*!<Total number of nodes in the graph */
    int num_edges; /*!<Total number of connections in the graph */
    int capacity; /*!<Current size of the dynamically allocated array */
  } ;

  Status graph_increaseCapacity(Graph *g) {
    Node **n = NULL;
    List **l = NULL;
    int i;
    int new_capacity = g->capacity * INCR;
    
    n = realloc(g->nodes, new_capacity * sizeof(Node *));
    if (n == NULL) {
        return ERROR;
    }
    l = realloc(g->plconnect, new_capacity * sizeof(List *));
    if(l == NULL){
        /*Código de error para deshacer el realloc*/
    }
    
    g->capacity = new_capacity;
    g->nodes = n;
    g->plconnect = l;
    
    for (i = (g->num_nodes); i < g->capacity; i++) {
        g->nodes[i] = NULL;
        g->plconnect[i] = NULL;
    }
    return OK;
}