ks_response.c

Go to the documentation of this file.

/*
 * libkarmaclient - A C Library to the Karmasphere Reputation Server
 * Copyright (C) 2006 Karmasphere <http://www.karmasphere.com/>
 *  - Shevek <shevek@karmasphere.com>
 *  - Dave Stewart <dave.stewart@karmasphere.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 */

#include "ks_config.h"
#include "ks_response.h"
#include "ks_bparse.h"
#include "ks_number.h"

#ifdef HAVE_STRING_H
#include <string.h>
#endif

static void
ks_response_bappend(ks_string_t *r, ks_base_t *b)
{
        ks_response_t   *e = KS_CAST(ks_response, b);
        if (e->response != NULL)
                ks_bappend(r, (ks_base_t *)e->response);
        else if (e->error != NULL)
                ks_bappend(r, (ks_base_t *)e->error);
        else
                ks_string_append(r, "4:null", 6);
}

static ks_type_t ks_type_response = {
        "ks_response",                                    
        (ks_destroy_t)ks_response_free,   
        (ks_bappend_t)ks_response_bappend 
};

ks_type_t *
ks_response_type(void)
{
        return &ks_type_response;
}

static ks_response_t *
ks_response_new()
{
        ks_response_t   *e = (ks_response_t *)ks_malloc(sizeof(ks_response_t));
        e->base.type = &ks_type_response;
        e->response = NULL;
        e->error = NULL;
        return e;
}

ks_response_t *
ks_response_bparse(const char *data, int len)
{
        ks_base_t               *b = ks_bparse(data, len);
        ks_response_t   *e = NULL;

        if (b == NULL) {
                /* Error already reported by parser. */
        }
        else if (b->type == ks_assoc_type()) {
                e = ks_response_new();
                e->response = KS_CAST(ks_assoc, b);
        }
        else if (b->type == ks_string_type()) {
                e = ks_response_new();
                e->error = KS_CAST(ks_string, b);
        }
        else {
                ks_error("Returned packet from server was not ks_assoc: %s",
                                                b->type->name);
                ks_destroy(b);
        }

        return e;
}

void
ks_response_free(ks_response_t *e)
{
        if (e->response != NULL)
                ks_assoc_free(e->response);
        if (e->error != NULL)
                ks_string_free(e->error);
        ks_free(e);
}

ks_string_t *
ks_response_error(ks_response_t *e)
{
        ks_string_t     *s;
        ks_base_t       *b;

        if (e->error != NULL)
                return e->error;

        if (e->response != NULL) {
                b = ks_assoc_get(e->response, "error", 5);
                if (b != NULL) {
                        s = ks_response_message(e);
                        if (s != NULL)
                                return s;
                        e->error = ks_string_new("Unknown error", 13);
                        return e->error;
                }
        }

        return NULL;
}

ks_string_t *
ks_response_message(ks_response_t *e)
{
        ks_base_t       *b = ks_assoc_get(e->response, "message", 7);
        if (b != NULL)
                return KS_CAST(ks_string, b);
        return NULL;
}

ks_string_t *
ks_response_id(ks_response_t *e)
{
        ks_base_t       *b;
        if (e->response == NULL)
                return NULL;
        b = ks_assoc_get(e->response, "_", 1);
        if (b == NULL)
                return NULL;
        return KS_CAST(ks_string, b);
}

long
ks_response_time(ks_response_t *e)
{
        ks_number_t     *n;
        ks_base_t       *b;
        if (e->response == NULL)
                return -1;
        b = ks_assoc_get(e->response, "t", 1);
        if (b == NULL)
                b = ks_assoc_get(e->response, "time", 4);
        if (b == NULL)
                return -1;
        n = KS_CAST(ks_number, b);
        return ks_number_get(n);
}

ks_assoc_t *
ks_response_combinations(ks_response_t *e)
{
        ks_base_t       *b;
        if (e->response == NULL)
                return NULL;
        b = ks_assoc_get(e->response, "c", 1);
        if (b == NULL)
                b = ks_assoc_get(e->response, "combiners", 9);
        if (b == NULL)
                return NULL;
        return KS_CAST(ks_assoc, b);
}

/* XXX If key is null, then get the first one? */
ks_combination_t *
ks_response_combination(ks_response_t *e, const char *key)
{
        ks_assoc_t      *s = ks_response_combinations(e);
        ks_base_t       *b;
        if (s == NULL)
                return NULL;
        b = ks_assoc_get(s, key, strlen(key));
        if (b == NULL)
                return NULL;
        return KS_CAST(ks_assoc, b);
}

int
ks_response_combinations_size(ks_response_t *e)
{
        ks_assoc_t      *s = ks_response_combinations(e);
        if (s == NULL)
                return 0;
        return ks_assoc_size(s);
}

static ks_array_t *
ks_response_facts(ks_response_t *e)
{
        ks_base_t       *b;
        if (e->response == NULL)
                return NULL;
        b = ks_assoc_get(e->response, "f", 5);
        if (b == NULL)
                b = ks_assoc_get(e->response, "facts", 5);
        if (b == NULL)
                return NULL;
        return KS_CAST(ks_array, b);
}

int
ks_response_facts_length(ks_response_t *e)
{
        ks_array_t      *a = ks_response_facts(e);
        if (a == NULL)
                return 0;
        return ks_array_length(a);
}

ks_fact_t *
ks_response_fact(ks_response_t *e, int idx)
{
        ks_array_t      *a = ks_response_facts(e);
        if (a == NULL)
                return NULL;
        return (ks_fact_t *)ks_array_get(a, idx);
}

---