eccodes-2.23.0-Source/python/grib_interface.c

/*
 * (C) Copyright 2005- ECMWF.
 *
 * This software is licensed under the terms of the Apache Licence Version 2.0
 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
 *
 * In applying this licence, ECMWF does not waive the privileges and immunities granted to it by
 * virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
 */

#include "grib_api_internal.h"
#include "assert.h"

#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif

#if HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif

#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif

#include <ctype.h>
#include <errno.h>

#if GRIB_PTHREADS
static pthread_once_t once                 = PTHREAD_ONCE_INIT;
static pthread_mutex_t handle_mutex        = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t index_mutex         = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t multi_handle_mutex  = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t iterator_mutex      = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t keys_iterator_mutex = PTHREAD_MUTEX_INITIALIZER;

static void init()
{
    pthread_mutexattr_t attr;

    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    pthread_mutex_init(&handle_mutex, &attr);
    pthread_mutex_init(&index_mutex, &attr);
    pthread_mutex_init(&multi_handle_mutex, &attr);
    pthread_mutex_init(&iterator_mutex, &attr);
    pthread_mutex_init(&keys_iterator_mutex, &attr);
    pthread_mutexattr_destroy(&attr);
}
#elif GRIB_OMP_THREADS
static int once = 0;
static omp_nest_lock_t handle_mutex;
static omp_nest_lock_t index_mutex;
static omp_nest_lock_t multi_handle_mutex;
static omp_nest_lock_t iterator_mutex;
static omp_nest_lock_t keys_iterator_mutex;

static void init()
{
    GRIB_OMP_CRITICAL(lock_python)
    {
        if (once == 0) {
            omp_init_nest_lock(&handle_mutex);
            omp_init_nest_lock(&index_mutex);
            omp_init_nest_lock(&multi_handle_mutex);
            omp_init_nest_lock(&iterator_mutex);
            omp_init_nest_lock(&keys_iterator_mutex);
            once = 1;
        }
    }
}
#endif

int GRIB_NULL         = -1;
int GRIB_NULL_NEAREST = -1;

typedef struct l_grib_file l_grib_file;

struct l_grib_file
{
    int id;
    FILE* f;
    l_grib_file* next;
};

typedef struct l_grib_handle l_grib_handle;

struct l_grib_handle
{
    int id;
    grib_handle* h;
    l_grib_handle* next;
};

typedef struct l_grib_index l_grib_index;

struct l_grib_index
{
    int id;
    grib_index* h;
    l_grib_index* next;
};

typedef struct l_grib_multi_handle l_grib_multi_handle;

struct l_grib_multi_handle
{
    int id;
    grib_multi_handle* h;
    l_grib_multi_handle* next;
};

typedef struct l_grib_iterator l_grib_iterator;

struct l_grib_iterator
{
    int id;
    grib_iterator* i;
    l_grib_iterator* next;
};

typedef struct l_grib_keys_iterator l_grib_keys_iterator;
struct l_grib_keys_iterator
{
    int id;
    grib_keys_iterator* i;
    l_grib_keys_iterator* next;
};

typedef struct l_bufr_keys_iterator l_bufr_keys_iterator;
struct l_bufr_keys_iterator
{
    int id;
    bufr_keys_iterator* i;
    l_bufr_keys_iterator* next;
};

static l_grib_handle* handle_set                    = NULL;
static l_grib_index* index_set                      = NULL;
static l_grib_multi_handle* multi_handle_set        = NULL;
static l_grib_file* file_set                        = NULL;
static l_grib_iterator* iterator_set                = NULL;
static l_grib_keys_iterator* keys_iterator_set      = NULL;
static l_bufr_keys_iterator* bufr_keys_iterator_set = NULL;

static int push_file(FILE* f)
{
    l_grib_file* current  = file_set;
    l_grib_file* previous = file_set;
    l_grib_file* new      = NULL;
    int myindex           = 1;

    if (!file_set) {
        file_set       = malloc(sizeof(l_grib_file));
        file_set->id   = myindex;
        file_set->f    = f;
        file_set->next = NULL;
        return myindex;
    }

    while (current) {
        if (current->id < 0) {
            current->id = -(current->id);
            current->f  = f;
            return current->id;
        }
        else {
            myindex++;
            previous = current;
            current  = current->next;
        }
    }

    new            = malloc(sizeof(l_grib_file));
    new->id        = myindex;
    new->f         = f;
    new->next      = current;
    previous->next = new;
    return myindex;
}

static void _push_handle(grib_handle* h, int* gid)
{
    l_grib_handle* current  = handle_set;
    l_grib_handle* previous = handle_set;
    l_grib_handle* new      = NULL;
    int myindex             = 1;

    if (*gid > 0) {
        while (current) {
            if (current->id == *gid) break;
            current = current->next;
        }
        if (current) {
            grib_handle_delete(current->h);
            current->h = h;
            return;
        }
    }

    current = handle_set;

    if (!handle_set) {
        handle_set       = malloc(sizeof(l_grib_handle));
        handle_set->id   = myindex;
        handle_set->h    = h;
        handle_set->next = NULL;
        *gid             = myindex;
        return;
    }

    while (current) {
        if (current->id < 0) {
            current->id = -(current->id);
            current->h  = h;
            *gid        = current->id;
            return;
        }
        else {
            myindex++;
            previous = current;
            current  = current->next;
        }
    }

    new            = malloc(sizeof(l_grib_handle));
    new->id        = myindex;
    new->h         = h;
    new->next      = current;
    previous->next = new;

    *gid = myindex;
    return;
}

static void _push_index(grib_index* h, int* gid)
{
    l_grib_index* current  = index_set;
    l_grib_index* previous = index_set;
    l_grib_index* new      = NULL;
    int myindex            = 1;

    if (*gid > 0) {
        while (current) {
            if (current->id == *gid) break;
            current = current->next;
        }
        if (current) {
            grib_index_delete(current->h);
            current->h = h;
            return;
        }
    }

    current = index_set;

    if (!index_set) {
        index_set       = malloc(sizeof(l_grib_index));
        index_set->id   = myindex;
        index_set->h    = h;
        index_set->next = NULL;
        *gid            = myindex;
        return;
    }

    while (current) {
        if (current->id < 0) {
            current->id = -(current->id);
            current->h  = h;
            *gid        = current->id;
            return;
        }
        else {
            myindex++;
            previous = current;
            current  = current->next;
        }
    }

    new            = malloc(sizeof(l_grib_index));
    new->id        = myindex;
    new->h         = h;
    new->next      = current;
    previous->next = new;

    *gid = myindex;
    return;
}

static void _push_multi_handle(grib_multi_handle* h, int* gid)
{
    l_grib_multi_handle* current  = multi_handle_set;
    l_grib_multi_handle* previous = multi_handle_set;
    l_grib_multi_handle* new      = NULL;
    int myindex                   = 1;

    if (*gid > 0) {
        while (current) {
            if (current->id == *gid) break;
            current = current->next;
        }
        if (current) {
            grib_multi_handle_delete(current->h);
            current->h = h;
            return;
        }
    }

    current = multi_handle_set;

    if (!multi_handle_set) {
        multi_handle_set       = malloc(sizeof(l_grib_multi_handle));
        multi_handle_set->id   = myindex;
        multi_handle_set->h    = h;
        multi_handle_set->next = NULL;
        *gid                   = myindex;
        return;
    }

    while (current) {
        if (current->id < 0) {
            current->id = -(current->id);
            current->h  = h;
            *gid        = current->id;
            return;
        }
        else {
            myindex++;
            previous = current;
            current  = current->next;
        }
    }

    new            = malloc(sizeof(l_grib_multi_handle));
    new->id        = myindex;
    new->h         = h;
    new->next      = current;
    previous->next = new;

    *gid = myindex;
    return;
}

static void push_handle(grib_handle* h, int* gid)
{
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&handle_mutex)
    _push_handle(h, gid);
    GRIB_MUTEX_UNLOCK(&handle_mutex)
    return;
}

static void push_index(grib_index* h, int* gid)
{
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&index_mutex)
    _push_index(h, gid);
    GRIB_MUTEX_UNLOCK(&index_mutex)
    return;
}

static void push_multi_handle(grib_multi_handle* h, int* gid)
{
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&multi_handle_mutex)
    _push_multi_handle(h, gid);
    GRIB_MUTEX_UNLOCK(&multi_handle_mutex)
    return;
}

static int _push_iterator(grib_iterator* i)
{
    l_grib_iterator* current  = iterator_set;
    l_grib_iterator* previous = iterator_set;
    l_grib_iterator* new      = NULL;
    int myindex               = 1;

    if (!iterator_set) {
        iterator_set       = malloc(sizeof(l_grib_iterator));
        iterator_set->id   = myindex;
        iterator_set->i    = i;
        iterator_set->next = NULL;
        return myindex;
    }

    while (current) {
        if (current->id < 0) {
            current->id = -(current->id);
            current->i  = i;
            return current->id;
        }
        else {
            myindex++;
            previous = current;
            current  = current->next;
        }
    }

    new            = malloc(sizeof(l_grib_iterator));
    new->id        = myindex;
    new->i         = i;
    new->next      = current;
    previous->next = new;

    return myindex;
}

static int push_iterator(grib_iterator* i)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&iterator_mutex)
    ret = _push_iterator(i);
    GRIB_MUTEX_UNLOCK(&iterator_mutex)
    return ret;
}

static int _push_keys_iterator(grib_keys_iterator* i)
{
    l_grib_keys_iterator* current  = keys_iterator_set;
    l_grib_keys_iterator* previous = keys_iterator_set;
    l_grib_keys_iterator* new      = NULL;
    int myindex                    = 1;

    if (!keys_iterator_set) {
        keys_iterator_set       = malloc(sizeof(l_grib_keys_iterator));
        keys_iterator_set->id   = myindex;
        keys_iterator_set->i    = i;
        keys_iterator_set->next = NULL;
        return myindex;
    }

    while (current) {
        if (current->id < 0) {
            current->id = -(current->id);
            current->i  = i;
            return current->id;
        }
        else {
            myindex++;
            previous = current;
            current  = current->next;
        }
    }
    if (!previous) return -1;

    new            = malloc(sizeof(l_grib_keys_iterator));
    new->id        = myindex;
    new->i         = i;
    new->next      = current;
    previous->next = new;

    return myindex;
}
static int push_keys_iterator(grib_keys_iterator* i)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&keys_iterator_mutex)
    ret = _push_keys_iterator(i);
    GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
    return ret;
}

//BUFR keys iterator
static int _push_bufr_keys_iterator(bufr_keys_iterator* i)
{
    l_bufr_keys_iterator* current  = bufr_keys_iterator_set;
    l_bufr_keys_iterator* previous = bufr_keys_iterator_set;
    l_bufr_keys_iterator* the_new  = NULL;
    int myindex                    = 1;

    if (!bufr_keys_iterator_set) {
        bufr_keys_iterator_set = (l_bufr_keys_iterator*)malloc(sizeof(l_bufr_keys_iterator));
        Assert(bufr_keys_iterator_set);
        bufr_keys_iterator_set->id   = myindex;
        bufr_keys_iterator_set->i    = i;
        bufr_keys_iterator_set->next = NULL;
        return myindex;
    }

    while (current) {
        if (current->id < 0) {
            current->id = -(current->id);
            current->i  = i;
            return current->id;
        }
        else {
            myindex++;
            previous = current;
            current  = current->next;
        }
    }
    if (!previous) return -1;

    the_new = (l_bufr_keys_iterator*)malloc(sizeof(l_bufr_keys_iterator));
    Assert(the_new);
    the_new->id    = myindex;
    the_new->i     = i;
    the_new->next  = current;
    previous->next = the_new;

    return myindex;
}
static int push_bufr_keys_iterator(bufr_keys_iterator* i)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init);
    GRIB_MUTEX_LOCK(&keys_iterator_mutex);
    ret = _push_bufr_keys_iterator(i);
    GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
    return ret;
}


static grib_handle* _get_handle(int handle_id)
{
    l_grib_handle* current = handle_set;

    while (current) {
        if (current->id == handle_id) return current->h;
        current = current->next;
    }

    return NULL;
}

static grib_index* _get_index(int index_id)
{
    l_grib_index* current = index_set;

    while (current) {
        if (current->id == index_id) return current->h;
        current = current->next;
    }

    return NULL;
}

static grib_multi_handle* _get_multi_handle(int multi_handle_id)
{
    l_grib_multi_handle* current = multi_handle_set;

    while (current) {
        if (current->id == multi_handle_id) return current->h;
        current = current->next;
    }

    return NULL;
}

static grib_handle* get_handle(int handle_id)
{
    grib_handle* h = NULL;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&handle_mutex)
    h = _get_handle(handle_id);
    GRIB_MUTEX_UNLOCK(&handle_mutex)
    return h;
}

static grib_index* get_index(int index_id)
{
    grib_index* h = NULL;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&index_mutex)
    h = _get_index(index_id);
    GRIB_MUTEX_UNLOCK(&index_mutex)
    return h;
}

static grib_multi_handle* get_multi_handle(int multi_handle_id)
{
    grib_multi_handle* h = NULL;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&multi_handle_mutex)
    h = _get_multi_handle(multi_handle_id);
    GRIB_MUTEX_UNLOCK(&multi_handle_mutex)
    return h;
}

static FILE* get_file(int file_id)
{
    l_grib_file* current = file_set;
    while (current) {
        if (current->id == file_id) return current->f;
        current = current->next;
    }
    return NULL;
}

static grib_iterator* _get_iterator(int iterator_id)
{
    l_grib_iterator* current = iterator_set;

    while (current) {
        if (current->id == iterator_id) return current->i;
        current = current->next;
    }
    return NULL;
}
static grib_iterator* get_iterator(int iterator_id)
{
    grib_iterator* i = NULL;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&iterator_mutex)
    i = _get_iterator(iterator_id);
    GRIB_MUTEX_UNLOCK(&iterator_mutex)
    return i;
}

static grib_keys_iterator* _get_keys_iterator(int keys_iterator_id)
{
    l_grib_keys_iterator* current = keys_iterator_set;

    while (current) {
        if (current->id == keys_iterator_id) return current->i;
        current = current->next;
    }
    return NULL;
}
static grib_keys_iterator* get_keys_iterator(int keys_iterator_id)
{
    grib_keys_iterator* i = NULL;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&keys_iterator_mutex)
    i = _get_keys_iterator(keys_iterator_id);
    GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
    return i;
}

//BUFR keys iterator
static bufr_keys_iterator* _get_bufr_keys_iterator(int keys_iterator_id)
{
    l_bufr_keys_iterator* current = bufr_keys_iterator_set;

    while (current) {
        if (current->id == keys_iterator_id) return current->i;
        current = current->next;
    }
    return NULL;
}
static bufr_keys_iterator* get_bufr_keys_iterator(int keys_iterator_id)
{
    bufr_keys_iterator* i = NULL;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&keys_iterator_mutex)
    i = _get_bufr_keys_iterator(keys_iterator_id);
    GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
    return i;
}


static int clear_file(int file_id)
{
    l_grib_file* current = file_set;
    int ret              = 0;
    while (current) {
        if (current->id == file_id) {
            current->id = -(current->id);
            if (current->f) {
                ret = fclose(current->f);
                if (0 == ret) {
                    return GRIB_SUCCESS;
                }
                else {
                    return GRIB_IO_PROBLEM;
                }
            }
            return GRIB_SUCCESS;
        }
        current = current->next;
    }
    return GRIB_INVALID_FILE;
}

static int _clear_handle(int handle_id)
{
    l_grib_handle* current = handle_set;

    /* look for the input grib id to release it */
    while (current) {
        if (current->id == handle_id) {
            current->id = -(current->id);
            if (current->h) return grib_handle_delete(current->h);
        }
        current = current->next;
    }

    /* fail with invalid grib id if not found */
    return GRIB_INVALID_GRIB;
}

static int _clear_index(int index_id)
{
    l_grib_index* current = index_set;

    while (current) {
        if (current->id == index_id) {
            current->id = -(current->id);
            if (current->h) {
                grib_index_delete(current->h);
                return GRIB_SUCCESS;
            }
        }
        current = current->next;
    }
    return GRIB_SUCCESS;
}

static int _clear_multi_handle(int multi_handle_id)
{
    l_grib_multi_handle* current = multi_handle_set;

    while (current) {
        if (current->id == multi_handle_id) {
            current->id = -(current->id);
            if (current->h) return grib_multi_handle_delete(current->h);
        }
        current = current->next;
    }
    return GRIB_SUCCESS;
}

static int clear_handle(int handle_id)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&handle_mutex)
    ret = _clear_handle(handle_id);
    GRIB_MUTEX_UNLOCK(&handle_mutex)
    return ret;
}

static int clear_index(int index_id)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&index_mutex)
    ret = _clear_index(index_id);
    GRIB_MUTEX_UNLOCK(&index_mutex)
    return ret;
}

static int clear_multi_handle(int multi_handle_id)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&multi_handle_mutex)
    ret = _clear_multi_handle(multi_handle_id);
    GRIB_MUTEX_UNLOCK(&multi_handle_mutex)
    return ret;
}

static int _clear_iterator(int iterator_id)
{
    l_grib_iterator* current = iterator_set;

    while (current) {
        if (current->id == iterator_id) {
            current->id = -(current->id);
            return grib_iterator_delete(current->i);
        }
        current = current->next;
    }
    return GRIB_INVALID_ITERATOR;
}

static int clear_iterator(int iterator_id)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&iterator_mutex)
    ret = _clear_iterator(iterator_id);
    GRIB_MUTEX_UNLOCK(&iterator_mutex)
    return ret;
}

static int _clear_keys_iterator(int keys_iterator_id)
{
    l_grib_keys_iterator* current = keys_iterator_set;

    while (current) {
        if (current->id == keys_iterator_id) {
            current->id = -(current->id);
            return grib_keys_iterator_delete(current->i);
        }
        current = current->next;
    }
    return GRIB_INVALID_KEYS_ITERATOR;
}
static int clear_keys_iterator(int keys_iterator_id)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&keys_iterator_mutex)
    ret = _clear_keys_iterator(keys_iterator_id);
    GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
    return ret;
}

//BUFR keys iterator
static int _clear_bufr_keys_iterator(int keys_iterator_id)
{
    l_bufr_keys_iterator* current = bufr_keys_iterator_set;

    while (current) {
        if (current->id == keys_iterator_id) {
            current->id = -(current->id);
            return codes_bufr_keys_iterator_delete(current->i);
        }
        current = current->next;
    }
    return GRIB_INVALID_KEYS_ITERATOR;
}
static int clear_bufr_keys_iterator(int keys_iterator_id)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init);
    GRIB_MUTEX_LOCK(&keys_iterator_mutex);
    ret = _clear_bufr_keys_iterator(keys_iterator_id);
    GRIB_MUTEX_UNLOCK(&keys_iterator_mutex);
    return ret;
}

int grib_c_read_any_from_file(int* fid, char* buffer, int* nbytes)
{
    grib_context* c;
    int err     = 0;
    size_t size = (size_t)nbytes;
    FILE* f     = get_file(*fid);

    if (f) {
        c       = grib_context_get_default();
        err     = grib_read_any_from_file(c, f, buffer, &size);
        *nbytes = size;
        return err;
    }
    else {
        return GRIB_INVALID_FILE;
    }
}

int grib_c_write_file(int* fid, char* buffer, int* nbytes)
{
    grib_context* c;
    FILE* f = get_file(*fid);

    if (f) {
        int ioerr;
        c = grib_context_get_default();
        if (fwrite(buffer, 1, *nbytes, f) != *nbytes) {
            ioerr = errno;
            grib_context_log(c, (GRIB_LOG_ERROR) | (GRIB_LOG_PERROR), "IO ERROR: %s", strerror(ioerr));
            return GRIB_IO_PROBLEM;
        }
        return GRIB_SUCCESS;
    }
    else {
        return GRIB_INVALID_FILE;
    }
}

int grib_c_read_file(int* fid, char* buffer, int* nbytes)
{
    grib_context* c;
    FILE* f = get_file(*fid);

    if (f) {
        int ioerr;
        c = grib_context_get_default();
        if (fread(buffer, 1, *nbytes, f) != *nbytes) {
            ioerr = errno;
            grib_context_log(c, (GRIB_LOG_ERROR) | (GRIB_LOG_PERROR), "IO ERROR: %s", strerror(ioerr));
            return GRIB_IO_PROBLEM;
        }
        return GRIB_SUCCESS;
    }
    else {
        return GRIB_INVALID_FILE;
    }
}

int grib_c_open_file(int* fid, char* name, char* op)
{
    FILE* f   = NULL;
    int ioerr = 0;
    int ret   = GRIB_SUCCESS;

    /*TODO Proper context passed as external parameter */
    grib_context* context = grib_context_get_default();

    f = fopen(name, op);

    if (!f) {
        ioerr = errno;
        grib_context_log(context, (GRIB_LOG_ERROR) | (GRIB_LOG_PERROR), "IO ERROR: %s: %s", strerror(ioerr), name);
        *fid = -1;
        ret  = GRIB_IO_PROBLEM;
    }
    else {
        *fid = push_file(f);
        ret  = GRIB_SUCCESS;
    }
    return ret;
}

int grib_c_close_file(int* fid)
{
    return clear_file(*fid);
}

int grib_c_multi_support_on(void)
{
    grib_multi_support_on(0);
    return GRIB_SUCCESS;
}

int grib_c_multi_support_off(void)
{
    grib_multi_support_off(0);
    return GRIB_SUCCESS;
}

static int _grib_c_iterator_new_(int* gid, int* iterid, int* mode)
{
    int err = 0;
    grib_handle* h;
    grib_iterator* iter;

    h = get_handle(*gid);
    if (!h) {
        *iterid = -1;
        return GRIB_NULL_HANDLE;
    }
    iter = grib_iterator_new(h, *mode, &err);
    if (iter)
        *iterid = push_iterator(iter);
    else
        *iterid = -1;
    return err;
}

int grib_c_iterator_new(int* gid, int* iterid, int* mode)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&iterator_mutex)
    ret = _grib_c_iterator_new_(gid, iterid, mode);
    GRIB_MUTEX_UNLOCK(&iterator_mutex)
    return ret;
}

int grib_c_iterator_next(int* iterid, double* lat, double* lon, double* value)
{
    grib_iterator* iter = get_iterator(*iterid);
    if (!iter) return GRIB_INVALID_ITERATOR;
    return grib_iterator_next(iter, lat, lon, value);
}

int grib_c_iterator_delete(int* iterid)
{
    return clear_iterator(*iterid);
}

static int _grib_c_keys_iterator_new_(int* gid, int* iterid, char* name_space)
{
    int err = 0;
    grib_handle* h;
    grib_keys_iterator* iter;

    h = get_handle(*gid);
    if (!h) {
        *iterid = -1;
        return GRIB_NULL_HANDLE;
    }
    iter = grib_keys_iterator_new(h, 0, name_space);
    if (iter)
        *iterid = push_keys_iterator(iter);
    else
        *iterid = -1;
    return err;
}
int grib_c_keys_iterator_new(int* gid, int* iterid, char* name_space)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&keys_iterator_mutex)
    ret = _grib_c_keys_iterator_new_(gid, iterid, name_space);
    GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
    return ret;
}
int grib_c_keys_iterator_next(int* iterid)
{
    int ret = 0;

    grib_keys_iterator* iter = get_keys_iterator(*iterid);

    if (!iter) return GRIB_INVALID_KEYS_ITERATOR;

    ret = grib_keys_iterator_next(iter);

    return ret;
}
int grib_c_keys_iterator_delete(int* iterid)
{
    return clear_keys_iterator(*iterid);
}
int grib_c_keys_iterator_get_name(int* iterid, char* name, int len)
{
    size_t lsize   = len;
    char buf[1024] = {0,};

    grib_keys_iterator* kiter = get_keys_iterator(*iterid);

    if (!kiter) return GRIB_INVALID_KEYS_ITERATOR;
    if (grib_keys_iterator_get_accessor(kiter) == NULL)
        return GRIB_INVALID_KEYS_ITERATOR;

    sprintf(buf, "%s", grib_keys_iterator_get_name(kiter));
    lsize = strlen(buf);

    if (len < lsize) return GRIB_ARRAY_TOO_SMALL;

    memcpy(name, buf, lsize);
    name[lsize] = '\0';

    return 0;
}
int grib_c_keys_iterator_rewind(int* kiter)
{
    grib_keys_iterator* i = get_keys_iterator(*kiter);

    if (!i) return GRIB_INVALID_KEYS_ITERATOR;
    return grib_keys_iterator_rewind(i);
}

/*BUFR keys iterator*/
static int _codes_c_bufr_keys_iterator_new_(int* gid, int* iterid)
{
    int err = 0;
    grib_handle* h;
    bufr_keys_iterator* iter;

    h = get_handle(*gid);
    if (!h) {
        *iterid = -1;
        return GRIB_NULL_HANDLE;
    }
    iter = codes_bufr_keys_iterator_new(h, 0);
    if (iter)
        *iterid = push_bufr_keys_iterator(iter);
    else
        *iterid = -1;
    return err;
}
int codes_c_bufr_keys_iterator_new(int* gid, int* iterid)
{
    int ret = 0;
    GRIB_MUTEX_INIT_ONCE(&once, &init)
    GRIB_MUTEX_LOCK(&keys_iterator_mutex)
    ret = _codes_c_bufr_keys_iterator_new_(gid, iterid);
    GRIB_MUTEX_UNLOCK(&keys_iterator_mutex)
    return ret;
}

int codes_c_bufr_keys_iterator_next(int* iterid)
{
    int ret                  = 0;
    bufr_keys_iterator* iter = get_bufr_keys_iterator(*iterid);

    if (!iter) return GRIB_INVALID_KEYS_ITERATOR;

    ret = codes_bufr_keys_iterator_next(iter);
    return ret;
}

int codes_c_bufr_keys_iterator_get_name(int* iterid, char* name, int len)
{
    size_t lsize   = len;
    char buf[1024] = {0,};

    bufr_keys_iterator* kiter = get_bufr_keys_iterator(*iterid);

    if (!kiter) return GRIB_INVALID_KEYS_ITERATOR;
    if (codes_bufr_keys_iterator_get_accessor(kiter) == NULL)
        return GRIB_INVALID_KEYS_ITERATOR;

    sprintf(buf, "%s", codes_bufr_keys_iterator_get_name(kiter));
    lsize = strlen(buf);

    if (len < lsize) return GRIB_ARRAY_TOO_SMALL;

    memcpy(name, buf, lsize);
    name[lsize] = '\0';

    return 0;
}

int codes_c_bufr_keys_iterator_rewind(int* kiter)
{
    bufr_keys_iterator* i = get_bufr_keys_iterator(*kiter);

    if (!i) return GRIB_INVALID_KEYS_ITERATOR;
    return codes_bufr_keys_iterator_rewind(i);
}

int codes_c_bufr_keys_iterator_delete(int* iterid)
{
    return clear_bufr_keys_iterator(*iterid);
}


int grib_c_gribex_mode_on(void)
{
    grib_gribex_mode_on(0);
    return GRIB_SUCCESS;
}

int grib_c_gribex_mode_off(void)
{
    grib_gribex_mode_off(0);
    return GRIB_SUCCESS;
}

int grib_c_skip_computed(int* iterid)
{
    grib_keys_iterator* iter = get_keys_iterator(*iterid);
    if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
    return grib_keys_iterator_set_flags(iter, GRIB_KEYS_ITERATOR_SKIP_COMPUTED);
}

int grib_c_skip_coded(int* iterid)
{
    grib_keys_iterator* iter = get_keys_iterator(*iterid);
    if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
    return grib_keys_iterator_set_flags(iter, GRIB_KEYS_ITERATOR_SKIP_CODED);
}

int grib_c_skip_edition_specific(int* iterid)
{
    grib_keys_iterator* iter = get_keys_iterator(*iterid);
    if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
    return grib_keys_iterator_set_flags(iter, GRIB_KEYS_ITERATOR_SKIP_EDITION_SPECIFIC);
}

int grib_c_skip_duplicates(int* iterid)
{
    grib_keys_iterator* iter = get_keys_iterator(*iterid);
    if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
    return grib_keys_iterator_set_flags(iter, GRIB_KEYS_ITERATOR_SKIP_DUPLICATES);
}

int grib_c_skip_read_only(int* iterid)
{
    grib_keys_iterator* iter = get_keys_iterator(*iterid);
    if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
    return grib_keys_iterator_set_flags(iter, GRIB_KEYS_ITERATOR_SKIP_READ_ONLY);
}

int grib_c_skip_function(int* iterid)
{
    grib_keys_iterator* iter = get_keys_iterator(*iterid);
    if (!iter) return GRIB_INVALID_KEYS_ITERATOR;
    return grib_keys_iterator_set_flags(iter, GRIB_KEYS_ITERATOR_SKIP_FUNCTION);
}

int grib_c_new_from_message(int* gid, void* buffer, size_t* bufsize)
{
    grib_handle* h = NULL;
    h              = grib_handle_new_from_message_copy(0, buffer, *bufsize);
    if (h) {
        push_handle(h, gid);
        return GRIB_SUCCESS;
    }

    *gid = -1;
    return GRIB_INTERNAL_ERROR;
}

int grib_c_new_from_message_copy(int* gid, void* buffer, size_t* bufsize)
{
    grib_handle* h = NULL;
    h              = grib_handle_new_from_message_copy(0, buffer, *bufsize);
    if (h) {
        push_handle(h, gid);
        return GRIB_SUCCESS;
    }

    *gid = -1;
    return GRIB_INTERNAL_ERROR;
}

int grib_c_grib_new_from_samples(int* gid, char* name)
{
    grib_handle* h = NULL;

    h = grib_handle_new_from_samples(NULL, name);
    /*   grib_context_set_debug(h->context,1);*/

    if (h) {
        push_handle(h, gid);
        return GRIB_SUCCESS;
    }

    *gid = -1;
    return GRIB_FILE_NOT_FOUND;
}

int grib_c_bufr_new_from_samples(int* gid, char* name)
{
    grib_handle* h = NULL;

    h = codes_bufr_handle_new_from_samples(NULL, name);
    /*   grib_context_set_debug(h->context,1);*/

    if (h) {
        push_handle(h, gid);
        return GRIB_SUCCESS;
    }

    *gid = -1;
    return GRIB_FILE_NOT_FOUND;
}

int grib_c_clone(int* gidsrc, int* giddest)
{
    grib_handle* src  = get_handle(*gidsrc);
    grib_handle* dest = NULL;

    if (src) {
        dest = grib_handle_clone(src);
        if (dest) {
            push_handle(dest, giddest);
            return GRIB_SUCCESS;
        }
    }

    *giddest = -1;
    return GRIB_INVALID_GRIB;
}

int grib_c_copy_namespace(int* gidsrc, char* name, int* giddest)
{
    grib_handle* src  = get_handle(*gidsrc);
    grib_handle* dest = get_handle(*giddest);

    if (src && dest)
        return grib_copy_namespace(dest, name, src);

    return GRIB_INVALID_GRIB;
}

int grib_c_count_in_file(FILE* f, int* n)
{
    int err = 0;
    if (f) err = grib_count_in_file(0, f, n);
    return err;
}

int grib_c_new_gts_from_file(FILE* f, int headers_only, int* gid)
{
    grib_handle* h = NULL;
    int err        = 0;

    if (f) {
        h = gts_new_from_file(0, f, &err);

        if (h) {
            push_handle(h, gid);
            return GRIB_SUCCESS;
        }
        else {
            *gid = -1;
            return GRIB_END_OF_FILE;
        }
    }

    *gid = -1;
    return GRIB_INVALID_FILE;
}

int grib_c_new_metar_from_file(FILE* f, int headers_only, int* gid)
{
    grib_handle* h = NULL;
    int err        = 0;

    if (f) {
        h = metar_new_from_file(0, f, &err);

        if (h) {
            push_handle(h, gid);
            return GRIB_SUCCESS;
        }
        else {
            *gid = -1;
            return GRIB_END_OF_FILE;
        }
    }

    *gid = -1;
    return GRIB_INVALID_FILE;
}

int grib_c_new_any_from_file(FILE* f, int headers_only, int* gid)
{
    grib_handle* h = NULL;
    int err        = 0;
    if (f) {
        h = codes_handle_new_from_file(0, f, PRODUCT_ANY, &err);
        if (h) {
            push_handle(h, gid);
            return GRIB_SUCCESS;
        }
        else {
            *gid = -1;
            return GRIB_END_OF_FILE;
        }
    }

    *gid = -1;
    return GRIB_INVALID_FILE;
}

int grib_c_new_bufr_from_file(FILE* f, int headers_only, int* gid)
{
    grib_handle* h = NULL;
    int err        = 0;

    if (f) {
        /* h = bufr_new_from_file(0,f,headers_only,&err); */
        h = codes_handle_new_from_file(0, f, PRODUCT_BUFR, &err);

        if (h) {
            push_handle(h, gid);
            return GRIB_SUCCESS;
        }
        else {
            *gid = -1;
            return GRIB_END_OF_FILE;
        }
    }

    *gid = -1;
    return GRIB_INVALID_FILE;
}

int grib_c_new_from_file(FILE* f, int* gid, int headers_only)
{
    grib_handle* h = NULL;
    int err        = 0;

    if (f) {
        h = grib_new_from_file(0, f, headers_only, &err);

        if (h) {
            push_handle(h, gid);
            return GRIB_SUCCESS;
        }
        else {
            *gid = -1;
            if (err == GRIB_SUCCESS) {
                return GRIB_END_OF_FILE;
            }
            else {
                /* A real error occurred */
                return err;
            }
        }
    }

    *gid = -1;
    return GRIB_INVALID_FILE;
}

int grib_c_new_from_index(int* iid, int* gid)
{
    int err       = 0;
    grib_index* i = get_index(*iid);

    grib_handle* h = NULL;

    if (i) {
        h = grib_handle_new_from_index(i, &err);
        if (h) {
            push_handle(h, gid);
            return GRIB_SUCCESS;
        }
        else {
            *gid = -1;
            return GRIB_END_OF_INDEX;
        }
    }

    *gid = -1;
    return GRIB_INVALID_INDEX;
}

int grib_c_index_new_from_file(char* file, char* keys, int* gid)
{
    int err       = 0;
    grib_index* i = NULL;

    if (*file) {
        i = grib_index_new_from_file(0, file, keys, &err);
        if (i) {
            push_index(i, gid);
            return GRIB_SUCCESS;
        }
        else {
            *gid = -1;
            return GRIB_END_OF_FILE;
        }
    }

    *gid = -1;
    return GRIB_INVALID_FILE;
}

int grib_c_index_add_file(int* iid, char* file)
{
    grib_index* i = get_index(*iid);
    int err       = GRIB_SUCCESS;

    if (!i) {
        return GRIB_INVALID_INDEX;
    }
    else {
        err = grib_index_add_file(i, file);
        return err;
    }
}

int grib_c_index_release(int* hid)
{
    return clear_index(*hid);
}

int grib_c_multi_release(int* hid)
{
    return clear_multi_handle(*hid);
}

int grib_c_release(int* hid)
{
    return clear_handle(*hid);
}

int grib_c_dump(int* gid)
{
    grib_handle* h = get_handle(*gid);

    if (!h)
        return GRIB_INVALID_GRIB;
    else
        grib_dump_content(h, stdout, "wmo", 0, NULL);

    return GRIB_SUCCESS;
}

int grib_c_print(int* gid, char* key)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    grib_dumper* d = NULL;

    if (!h) {
        return GRIB_INVALID_GRIB;
    }
    else {
        d   = grib_dumper_factory("serialize", h, stdout, 0, 0);
        err = grib_print(h, key, d);
        grib_dumper_delete(d);
        return err;
    }
}

int grib_c_get_error_string(int* err, char* buf, int len)
{
    const char* err_msg = grib_get_error_message(*err);
    size_t erlen        = strlen(err_msg);
    if (len <= erlen) return GRIB_ARRAY_TOO_SMALL;

    strncpy(buf, err_msg, (size_t)erlen);
    buf[erlen] = '\0';

    return GRIB_SUCCESS;
}

int grib_c_get_size_int(int* gid, char* key, int* val)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    size_t tsize   = 0;

    if (!h) {
        return GRIB_INVALID_GRIB;
    }
    else {
        err  = grib_get_size(h, key, &tsize);
        *val = tsize;
        return err;
    }
}

int grib_c_get_message_offset(int* gid, size_t* offset)
{
    int err = GRIB_SUCCESS;
    off_t myoffset;
    grib_handle* h = get_handle(*gid);

    if (!h)
        return GRIB_INVALID_GRIB;
    else {
        err     = grib_get_message_offset(h, &myoffset);
        *offset = myoffset;
        return err;
    }
}

int grib_c_get_message_size(int* gid, size_t* size)
{
    grib_handle* h = get_handle(*gid);

    if (!h)
        return GRIB_INVALID_GRIB;
    else
        return grib_get_message_size(h, size);
}

int grib_c_get_string_length(int* gid, char* key, size_t* val)
{
    grib_handle* h = get_handle(*gid);

    if (!h)
        return GRIB_INVALID_GRIB;
    else
        return grib_get_string_length(h, key, val);
}

int grib_c_get_size_long(int* gid, char* key, long* val)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    size_t tsize   = 0;

    if (!h) {
        return GRIB_INVALID_GRIB;
    }
    else {
        err  = grib_get_size(h, key, &tsize);
        *val = tsize;
        return err;
    }
}

int grib_c_index_get_size_int(int* gid, char* key, int* val)
{
    grib_index* h = get_index(*gid);
    int err       = GRIB_SUCCESS;
    size_t tsize  = 0;

    if (!h) {
        return GRIB_INVALID_GRIB;
    }
    else {
        err  = grib_index_get_size(h, key, &tsize);
        *val = tsize;
        return err;
    }
}

int grib_c_index_get_size_long(int* gid, char* key, long* val)
{
    grib_index* h = get_index(*gid);
    int err       = GRIB_SUCCESS;
    size_t tsize  = 0;

    if (!h) {
        return GRIB_INVALID_GRIB;
    }
    else {
        err  = grib_index_get_size(h, key, &tsize);
        *val = tsize;
        return err;
    }
}

int grib_c_get_int(int* gid, char* key, int* val)
{
    grib_handle* h = get_handle(*gid);
    long long_val;
    int err = GRIB_SUCCESS;

    if (!h) return GRIB_INVALID_GRIB;
    err  = grib_get_long(h, key, &long_val);
    *val = long_val;
    return err;
}

int grib_c_get_long(int* gid, char* key, long* val)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;

    if (!h) return GRIB_INVALID_GRIB;
    err = grib_get_long(h, key, val);
    return err;
}

int grib_c_get_double(int* gid, char* key, double* val)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;

    if (!h) return GRIB_INVALID_GRIB;
    err = grib_get_double(h, key, val);
    return err;
}

int grib_c_get_int_array(int* gid, char* key, int* val, int* size)
{
    grib_handle* h = get_handle(*gid);
    long* long_val = NULL;
    int err        = GRIB_SUCCESS;
    size_t lsize   = *size;

    if (!h) return GRIB_INVALID_GRIB;

    if (sizeof(long) == sizeof(int)) {
        long_val = (long*)val;
        err      = grib_get_long_array(h, key, long_val, &lsize);
        *size    = lsize;
        return err;
    }
    if (*size)
        long_val = grib_context_malloc(h->context, (*size) * (sizeof(long)));
    else
        long_val = grib_context_malloc(h->context, (sizeof(long)));

    if (!long_val) return GRIB_OUT_OF_MEMORY;
    err = grib_get_long_array(h, key, long_val, &lsize);

    for (*size = 0; *size < lsize; (*size)++)
        val[*size] = long_val[*size];

    grib_context_free(h->context, long_val);
    return err;
}

int grib_c_get_long_array(int* gid, char* key, long* val, int* size)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    size_t lsize   = *size;

    if (!h) return GRIB_INVALID_GRIB;

    err   = grib_get_long_array(h, key, val, &lsize);
    *size = lsize;

    return err;
}

int grib_c_index_get_string(int* gid, char* key, char* val, int* eachsize, int* size)
{
    grib_index* h = get_index(*gid);
    int err       = GRIB_SUCCESS;
    int i;
    size_t lsize = *size;
    char** bufval;
    char* p = val;

    if (!h) return GRIB_INVALID_GRIB;

    bufval = (char**)grib_context_malloc_clear(h->context, sizeof(char*) * *size);

    err   = grib_index_get_string(h, key, bufval, &lsize);
    *size = lsize;

    if (err) return err;

    for (i = 0; i < lsize; i++) {
        int l = strlen(bufval[i]);
        int j;
        if (*eachsize < l) {
            grib_context_free(h->context, bufval);
            printf("eachsize=%d strlen(bufval[i])=%d\n", *eachsize, (unsigned int)strlen(bufval[i]));
            return GRIB_ARRAY_TOO_SMALL;
        }
        memcpy(p, bufval[i], l);
        p += l;
        for (j = 0; j < *eachsize - l; j++)
            *(p++) = ' ';
    }
    grib_context_free(h->context, bufval);

    return err;
}

int grib_c_index_get_long(int* gid, char* key, long* val, int* size)
{
    grib_index* h = get_index(*gid);
    int err       = GRIB_SUCCESS;
    size_t lsize  = *size;

    if (!h) return GRIB_INVALID_GRIB;
    err   = grib_index_get_long(h, key, val, &lsize);
    *size = lsize;
    return err;
}

int grib_c_index_get_int(int* gid, char* key, int* val, int* size)
{
    grib_index* h = get_index(*gid);
    int err       = GRIB_SUCCESS;
    size_t lsize  = *size;
    long* lval    = 0;
    int i;

    if (!h) return GRIB_INVALID_GRIB;

    lval = grib_context_malloc(h->context, sizeof(long) * *size);
    if (!lval) return GRIB_OUT_OF_MEMORY;

    err = grib_index_get_long(h, key, lval, &lsize);
    for (i = 0; i < lsize; i++)
        val[i] = lval[i];

    *size = lsize;
    return err;
}

int grib_c_index_get_real8(int* gid, char* key, double* val, int* size)
{
    grib_index* h = get_index(*gid);
    int err       = GRIB_SUCCESS;
    size_t lsize  = *size;

    if (!h) return GRIB_INVALID_GRIB;
    err   = grib_index_get_double(h, key, val, &lsize);
    *size = lsize;
    return err;
}

int grib_c_set_int_array(int* gid, char* key, int* val, int* size)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    long* long_val = NULL;
    size_t lsize   = *size;

    if (!h) return GRIB_INVALID_GRIB;

    if (sizeof(long) == sizeof(int)) {
        long_val = (long*)val;
        return grib_set_long_array(h, key, long_val, lsize);
    }

    if (lsize)
        long_val = grib_context_malloc(h->context, (lsize) * (sizeof(long)));
    else
        long_val = grib_context_malloc(h->context, (sizeof(long)));

    if (!long_val) return GRIB_OUT_OF_MEMORY;

    for (lsize = 0; lsize < (*size); lsize++)
        long_val[lsize] = val[lsize];

    err = grib_set_long_array(h, key, long_val, lsize);

    grib_context_free(h->context, long_val);
    return err;
}

int grib_c_set_long_array(int* gid, char* key, long* val, int* size)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    size_t lsize   = *size;

    if (!h) return GRIB_INVALID_GRIB;

    return grib_set_long_array(h, key, val, lsize);

    return err;
}

int grib_c_set_int(int* gid, char* key, int* val)
{
    grib_handle* h = get_handle(*gid);
    long long_val  = *val;
    if (!h) return GRIB_INVALID_GRIB;
    return grib_set_long(h, key, long_val);
}

int grib_c_set_long(int* gid, char* key, long* val)
{
    grib_handle* h = get_handle(*gid);
    if (!h) return GRIB_INVALID_GRIB;
    return grib_set_long(h, key, *val);
}

int grib_c_set_missing(int* gid, char* key)
{
    grib_handle* h = get_handle(*gid);
    if (!h) return GRIB_INVALID_GRIB;

    return grib_set_missing(h, key);
}

/*
 * Submits all keys with the given values in one go.
 * 'keyvals' is a string of the form:
 *    key1=val1,key2=val2,key3=val3
 */
int grib_c_set_key_vals(int* gid, char* keyvals)
{
    grib_handle* h = get_handle(*gid);
    if (!h) return GRIB_INVALID_GRIB;
    {
        int err                  = GRIB_SUCCESS;
        grib_values values[1024] = {{0,},};
        int count = 1000; /* max. num key/val pairs */
        if ((err = parse_keyval_string(NULL, keyvals, 1, GRIB_TYPE_UNDEFINED, values, &count)) != GRIB_SUCCESS) {
            return err;
        }
        if ((err = grib_set_values(h, values, count)) != GRIB_SUCCESS) {
            return err;
        }
    }
    return GRIB_SUCCESS;
}

int grib_c_is_missing(int* gid, char* key, int* isMissing)
{
    int err        = 0;
    grib_handle* h = get_handle(*gid);
    if (!h) return GRIB_INVALID_GRIB;

    *isMissing = grib_is_missing(h, key, &err);
    return err;
}

int grib_c_is_defined(int* gid, char* key, int* isDefined)
{
    grib_handle* h = get_handle(*gid);
    if (!h) return GRIB_INVALID_GRIB;

    *isDefined = grib_is_defined(h, key);
    return GRIB_SUCCESS;
}

int grib_c_set_real4(int* gid, char* key, float* val)
{
    grib_handle* h = get_handle(*gid);
    double val8    = *val;
    if (!h) return GRIB_INVALID_GRIB;

    return grib_set_double(h, key, val8);
}

int grib_c_get_real4_element(int* gid, char* key, int* index, float* val)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    double val8    = 0;

    if (!h) return GRIB_INVALID_GRIB;

    err  = grib_get_double_element(h, key, *index, &val8);
    *val = val8;
    return err;
}

int grib_c_get_real4_elements(int* gid, char* key, int* index, float* val, int* size)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    size_t lsize   = *size;
    long i         = 0;
    double* val8   = NULL;

    if (!h) return GRIB_INVALID_GRIB;

    if (*size)
        val8 = grib_context_malloc(h->context, (*size) * (sizeof(double)));
    else
        val8 = grib_context_malloc(h->context, sizeof(double));

    if (!val8) return GRIB_OUT_OF_MEMORY;


    err = grib_get_double_elements(h, key, index, (long)lsize, val8);

    for (i = 0; i < lsize; (i)++)
        val[i] = val8[i];

    grib_context_free(h->context, val8);

    return err;
}

int grib_c_get_real4(int* gid, char* key, float* val)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    double val8    = 0;

    if (!h) return GRIB_INVALID_GRIB;

    err  = grib_get_double(h, key, &val8);
    *val = val8;
    return err;
}

int grib_c_get_real4_array(int* gid, char* key, float* val, int* size)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    size_t lsize   = *size;
    double* val8   = NULL;

    if (!h) return GRIB_INVALID_GRIB;

    if (*size)
        val8 = grib_context_malloc(h->context, (*size) * (sizeof(double)));
    else
        val8 = grib_context_malloc(h->context, sizeof(double));

    if (!val8) return GRIB_OUT_OF_MEMORY;

    err = grib_get_double_array(h, key, val8, &lsize);

    for (*size = 0; *size < lsize; (*size)++)
        val[*size] = val8[*size];

    grib_context_free(h->context, val8);

    return err;
}

int grib_c_set_real4_array(int* gid, char* key, float* val, int* size)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    size_t lsize   = *size;
    double* val8   = NULL;

    if (!h) return GRIB_INVALID_GRIB;

    if (*size)
        val8 = grib_context_malloc(h->context, lsize * (sizeof(double)));
    else
        val8 = grib_context_malloc(h->context, sizeof(double));

    if (!val8) return GRIB_OUT_OF_MEMORY;

    for (lsize = 0; lsize < *size; lsize++)
        val8[lsize] = val[lsize];

    err = grib_set_double_array(h, key, val8, lsize);
    grib_context_free(h->context, val8);
    return err;
}

int grib_c_index_select_real8(int* gid, char* key, double* val)
{
    grib_index* h = get_index(*gid);

    if (!h) return GRIB_INVALID_GRIB;
    return grib_index_select_double(h, key, *val);
}

int grib_c_index_select_string(int* gid, char* key, char* val)
{
    grib_index* h = get_index(*gid);

    if (!h) return GRIB_INVALID_GRIB;
    return grib_index_select_string(h, key, val);
}

int grib_c_index_select_int(int* gid, char* key, int* val)
{
    grib_index* h = get_index(*gid);
    long lval     = *val;

    if (!h) return GRIB_INVALID_GRIB;
    return grib_index_select_long(h, key, lval);
}

int grib_c_index_select_long(int* gid, char* key, long* val)
{
    grib_index* h = get_index(*gid);

    if (!h) return GRIB_INVALID_GRIB;
    return grib_index_select_long(h, key, *val);
}

int grib_c_set_real8(int* gid, char* key, double* val)
{
    grib_handle* h = get_handle(*gid);

    if (!h) return GRIB_INVALID_GRIB;
    return grib_set_double(h, key, *val);
}

int grib_c_get_real8(int* gid, char* key, double* val)
{
    grib_handle* h = get_handle(*gid);

    if (!h) return GRIB_INVALID_GRIB;

    return grib_get_double(h, key, val);
}

int grib_c_set_double(int* gid, char* key, double* val)
{
    grib_handle* h = get_handle(*gid);

    if (!h) return GRIB_INVALID_GRIB;

    return grib_set_double(h, key, *val);
}

int grib_c_get_real8_element(int* gid, char* key, int* index, double* val)
{
    grib_handle* h = get_handle(*gid);

    if (!h) return GRIB_INVALID_GRIB;

    return grib_get_double_element(h, key, *index, val);
}

int grib_c_get_real8_elements(int* gid, char* key, int* index, double* val, int* size)
{
    grib_handle* h = get_handle(*gid);

    if (!h) return GRIB_INVALID_GRIB;

    return grib_get_double_elements(h, key, index, *size, val);
}

int grib_c_find_nearest_four_single(int* gid, int* is_lsm,
                                    double* inlat, double* inlon,
                                    double* outlats, double* outlons,
                                    double* values, double* distances,
                                    int* indexes)
{
    grib_nearest* nearest = NULL;
    int err = 0, result = 0;
    unsigned long flags = 0;
    size_t len          = 4;
    grib_handle* h      = get_handle(*gid);

    if (!h) return GRIB_INVALID_GRIB;

    nearest = grib_nearest_new(h, &err);
    if (err != GRIB_SUCCESS) return err;

    result = grib_nearest_find(nearest, h, *inlat, *inlon,
                               flags, outlats, outlons, values, distances, indexes, &len);
    grib_nearest_delete(nearest);
    return result;
}

int grib_c_find_nearest_single(int* gid, int* is_lsm,
                               double* inlats, double* inlons,
                               double* outlats, double* outlons,
                               double* values, double* distances,
                               int* indexes)
{
    grib_handle* h = get_handle(*gid);

    if (!h) return GRIB_INVALID_GRIB;

    return grib_nearest_find_multiple(h, *is_lsm,
                                      inlats, inlons, 1, outlats, outlons,
                                      values, distances, indexes);
}

int grib_c_find_nearest_multiple(int* gid, int* is_lsm,
                                 double* inlats, double* inlons,
                                 double* outlats, double* outlons,
                                 double* values, double* distances,
                                 int* indexes, int* npoints)
{
    grib_handle* h = get_handle(*gid);

    if (!h) return GRIB_INVALID_GRIB;

    return grib_nearest_find_multiple(h, *is_lsm,
                                      inlats, inlons, *npoints, outlats, outlons,
                                      values, distances, indexes);
}

int grib_c_get_real8_array(int* gid, char* key, double* val, int* size)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    size_t lsize   = *size;

    if (!h) {
        return GRIB_INVALID_GRIB;
    }
    else {
        err   = grib_get_double_array(h, key, val, &lsize);
        *size = lsize;
        return err;
    }
}

int grib_c_set_real8_array(int* gid, char* key, double* val, int* size)
{
    grib_handle* h = get_handle(*gid);

    size_t lsize = *size;

    if (!h) return GRIB_INVALID_GRIB;

    return grib_set_double_array(h, key, val, lsize);
}

int grib_c_set_double_array(int* gid, char* key, double* val, int* size)
{
    grib_handle* h = get_handle(*gid);

    size_t lsize = *size;

    if (!h) return GRIB_INVALID_GRIB;

    return grib_set_double_array(h, key, val, lsize);
}

int grib_c_get_string(int* gid, char* key, char* val, size_t* lsize)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;

    if (!h) return GRIB_INVALID_GRIB;

    err = grib_get_string(h, key, val, lsize);

    return err;
}

int grib_c_get_string_array(int* gid, char* key, char** val, size_t* lsize)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;

    if (!h) return GRIB_INVALID_GRIB;

    err = grib_get_string_array(h, key, val, lsize);

    return err;
}

int grib_c_set_string(int* gid, char* key, char* val, int len2)
{
    grib_handle* h = get_handle(*gid);

    size_t lsize = len2;

    if (!h) return GRIB_INVALID_GRIB;

    return grib_set_string(h, key, val, &lsize);
}

int grib_c_set_string_array(int* gid, char* key, const char** val)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    size_t lsize   = 0;

    if (!h) return GRIB_INVALID_GRIB;

    /* Note: The array passed in will have its final entry as NULL */
    /* so to find its size we just iterate thru it. */
    /* See typemap for char** in swig interface file */
    while (val[lsize]) {
        ++lsize;
    }
    err = grib_set_string_array(h, key, val, lsize);
    return err;
}

int grib_c_get_data_real4(int* gid, float* lats, float* lons, float* values, size_t* size)
{
    grib_handle* h = get_handle(*gid);
    int err        = GRIB_SUCCESS;
    double *lat8 = NULL, *lon8 = NULL, *val8 = NULL;
    size_t i = 0;

    if (!h) return GRIB_INVALID_GRIB;

    val8 = grib_context_malloc(h->context, (*size) * (sizeof(double)));
    if (!val8) return GRIB_OUT_OF_MEMORY;
    lon8 = grib_context_malloc(h->context, (*size) * (sizeof(double)));
    if (!lon8) return GRIB_OUT_OF_MEMORY;
    lat8 = grib_context_malloc(h->context, (*size) * (sizeof(double)));
    if (!lat8) return GRIB_OUT_OF_MEMORY;

    err = grib_get_data(h, lat8, lon8, val8);

    for (i = 0; i < *size; i++) {
        values[i] = val8[i];
        lats[i]   = lat8[i];
        lons[i]   = lon8[i];
    }

    grib_context_free(h->context, val8);
    grib_context_free(h->context, lat8);
    grib_context_free(h->context, lon8);

    return err;
}
/*
int grib_c_get_data_real8(int* gid,double* lats, double* lons,double* values,size_t* size)
{
    grib_handle *h = get_handle(*gid);
    return grib_get_data(h,lats,lons,values);
}
*/
int grib_c_copy_message(int* gid, void* mess, size_t* len)
{
    grib_handle* h = get_handle(*gid);
    if (!h)
        return GRIB_INVALID_GRIB;

    if (*len < h->buffer->ulength) {
        grib_context_log(h->context, GRIB_LOG_ERROR, "grib_copy_message: buffer=%ld message size=%ld", *len, h->buffer->ulength);
        return GRIB_BUFFER_TOO_SMALL;
    }

    memcpy(mess, h->buffer->data, h->buffer->ulength);
    *len = h->buffer->ulength;
    return GRIB_SUCCESS;
}

int grib_c_bufr_copy_data(int* msgid_src, int* msgid_dst)
{
    int err           = 0;
    grib_handle* src  = get_handle(*msgid_src);
    grib_handle* dest = get_handle(*msgid_dst);
    if (!src || !dest) {
        return GRIB_INVALID_GRIB;
    }

    err = codes_bufr_copy_data(src, dest);
    return err;
}

void grib_c_check(int* err, char* call, char* str)
{
    grib_context* c = grib_context_get_default();
    if (*err == GRIB_SUCCESS || *err == GRIB_END_OF_FILE) return;
    grib_context_log(c, GRIB_LOG_ERROR, "%s: %s %s",
                     call, str, grib_get_error_message(*err));
    exit(*err);
}

int grib_c_write(int* gid, FILE* f)
{
    grib_handle* h   = get_handle(*gid);
    const void* mess = NULL;
    size_t mess_len  = 0;

    if (!f) return GRIB_INVALID_FILE;
    if (!h) return GRIB_INVALID_GRIB;

    grib_get_message(h, &mess, &mess_len);
    if (fwrite(mess, 1, mess_len, f) != mess_len) {
        perror("grib_write");
        return GRIB_IO_PROBLEM;
    }

    return GRIB_SUCCESS;
}

int grib_c_multi_new(int* mgid)
{
    grib_multi_handle* mh = grib_multi_handle_new(0);
    if (!mh) return GRIB_INVALID_GRIB;
    push_multi_handle(mh, mgid);
    return GRIB_SUCCESS;
}

int grib_c_multi_write(int* gid, FILE* f)
{
    grib_multi_handle* h = get_multi_handle(*gid);

    if (!f) return GRIB_INVALID_FILE;
    if (!h) return GRIB_INVALID_GRIB;

    return grib_multi_handle_write(h, f);
}

int grib_c_multi_append(int* ingid, int* sec, int* mgid)
{
    grib_handle* h        = get_handle(*ingid);
    grib_multi_handle* mh = get_multi_handle(*mgid);

    if (!h) return GRIB_INVALID_GRIB;

    if (!mh) {
        mh = grib_multi_handle_new(h->context);
        push_multi_handle(mh, mgid);
    }

    return grib_multi_handle_append(h, *sec, mh);
}

int grib_c_get_native_type(int* gid, char* key, int* type)
{
    grib_handle* h = get_handle(*gid);

    if (!h) return GRIB_INVALID_GRIB;

    return grib_get_native_type(h, key, type);
}

int grib_c_index_write(int* gid, char* file)
{
    grib_index* i = get_index(*gid);
    int err       = GRIB_SUCCESS;

    if (!i) {
        return GRIB_INVALID_GRIB;
    }
    else {
        err = grib_index_write(i, file);
        return err;
    }
}

int grib_c_index_read(char* file, int* gid)
{
    int err       = 0;
    grib_index* i = NULL;

    if (*file) {
        i = grib_index_read(0, file, &err);
        if (i) {
            push_index(i, gid);
            return GRIB_SUCCESS;
        }
        else {
            *gid = -1;
            return GRIB_END_OF_FILE;
        }
    }

    *gid = -1;
    return GRIB_INVALID_FILE;
}

void no_fail_on_wrong_length(int flag)
{
    grib_context* c = grib_context_get_default();
    int value;
    assert(c != NULL);
    value                      = (flag != 0) ? 1 : 0;
    c->no_fail_on_wrong_length = value;
}

void grib_c_gts_header_on(void)
{
    grib_context* c = grib_context_get_default();
    assert(c != NULL);
    grib_gts_header_on(c);
}

void grib_c_gts_header_off(void)
{
    grib_context* c = grib_context_get_default();
    assert(c != NULL);
    grib_gts_header_off(c);
}

long grib_c_get_api_version(void)
{
    return grib_get_api_version();
}

int grib_c_get_message(int* gid, const void** msg, size_t* size)
{
    grib_handle* h = get_handle(*gid);
    return grib_get_message(h, msg, size);
}

void grib_c_set_definitions_path(const char* path)
{
    grib_context* c = grib_context_get_default();
    grib_context_set_definitions_path(c, path);
}

void grib_c_set_samples_path(const char* path)
{
    grib_context* c = grib_context_get_default();
    grib_context_set_samples_path(c, path);
}


int codes_c_bufr_multi_element_constant_arrays_on(void)
{
    codes_bufr_multi_element_constant_arrays_on(NULL);
    return GRIB_SUCCESS;
}
int codes_c_bufr_multi_element_constant_arrays_off(void)
{
    codes_bufr_multi_element_constant_arrays_off(NULL);
    return GRIB_SUCCESS;
}