ks_bquery.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_bquery.h"
#include "ks_malloc.h"

#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif

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

static int      idseq = 0;

static void
ks_bquery_bappend(ks_string_t *r, ks_base_t *b)
{
        ks_bquery_t     *q = KS_CAST(ks_bquery, b);

        ks_string_append(r, "d", 1);

        /* _, auth, combiners, composites, feeds, flags, ids */

        ks_string_append(r, "1:_", 3);
        ks_bappend(r, (ks_base_t *)ks_bquery_id_get(q));

        /* See ks_bquery_set_auth() for the magic that ensures that
         * q->credentials is correct */
        if (q->principal) {
                ks_string_append(r, "1:al", 4);
                ks_bappend(r, (ks_base_t *)q->principal);
                ks_bappend(r, (ks_base_t *)q->credentials);
                ks_string_append(r, "e", 1);
        }

        if (ks_array_length(&(q->combiners)) > 0) {
                // ks_string_append(r, "9:combiners", 11);
                ks_string_append(r, "1:c", 3);
                ks_bappend(r, (ks_base_t *)&(q->combiners));
        }

        if (ks_array_length(&(q->feeds)) > 0) {
                // ks_string_append(r, "5:feeds", 7);
                ks_string_append(r, "1:f", 3);
                ks_bappend(r, (ks_base_t *)&(q->feeds));
        }

        if (ks_number_get(&(q->flags)) != 0) {
                // ks_string_append(r, "5:flags", 7);
                ks_string_append(r, "2:fl", 4);
                ks_bappend(r, (ks_base_t *)&(q->flags));
        }

        if (ks_array_length(&(q->identities)) > 0) {
                // ks_string_append(r, "3:ids", 5);
                ks_string_append(r, "1:i", 3);
                ks_bappend(r, (ks_base_t *)&(q->identities));
        }

        if (ks_array_length(&(q->composites)) > 0) {
                // ks_string_append(r, "10:composites", 13);
                ks_string_append(r, "1:s", 3);
                ks_bappend(r, (ks_base_t *)&(q->composites));
        }

        ks_string_append(r, "e", 1);
}

static ks_type_t ks_type_bquery = {
        "ks_bquery",                     
        (ks_destroy_t)ks_bquery_free,    
        (ks_bappend_t)ks_bquery_bappend  
};

ks_type_t *
ks_bquery_type(void)
{
        return &ks_type_bquery;
}

ks_bquery_t *
ks_bquery_new(void)
{
        ks_bquery_t     *q = (ks_bquery_t *)ks_malloc(sizeof(ks_bquery_t));
        q->base.type = &ks_type_bquery;
        ks_array_init(&(q->feeds));
        ks_array_init(&(q->composites));
        ks_array_init(&(q->combiners));
        ks_array_init(&(q->identities));
        ks_number_init(&(q->flags), 0);
        q->principal = NULL;
        q->credentials = NULL;
        q->id = NULL;
        return q;
}

void
ks_bquery_free(ks_bquery_t *q)
{
        ks_array_fini(&(q->feeds));
        ks_array_fini(&(q->composites));
        ks_array_fini(&(q->combiners));
        ks_array_fini(&(q->identities));
        ks_number_fini(&(q->flags));
        if (q->id)
                ks_string_free(q->id);
        if (q->principal)
                ks_string_free(q->principal);
        if (q->credentials)
                ks_string_free(q->credentials);
        ks_free(q);
}

void
ks_bquery_id_set(ks_bquery_t *q, const char *id, size_t len)
{
        if (q->id)
                ks_string_set(q->id, id, len);
        else
                q->id = ks_string_new(id, len);
}

ks_string_t *
ks_bquery_id_get(ks_bquery_t *q)
{
        char             idbuf[64];
        if (q->id == NULL) {
                sprintf(idbuf, "lkc%d", idseq++);
                q->id = ks_string_new(idbuf, strlen(idbuf));
        }
        return q->id;
}

void
ks_bquery_feed_add(ks_bquery_t *q, const char *id)
{
        ks_string_t     *r = ks_string_new(id, strlen(id));
        ks_array_add(&(q->feeds), (ks_base_t *)r);
}

void
ks_bquery_composite_add(ks_bquery_t *q, const char *id)
{
        ks_string_t     *r = ks_string_new(id, strlen(id));
        ks_array_add(&(q->composites), (ks_base_t *)r);
}

void
ks_bquery_combiner_add(ks_bquery_t *q, const char *id)
{
        ks_string_t     *r = ks_string_new(id, strlen(id));
        ks_array_add(&(q->combiners), (ks_base_t *)r);
}

static ks_array_t *
ks_bquery_identity_add_ret(ks_bquery_t *q, const char *id, int idt)
{
        ks_array_t      *a = ks_array_new();
        ks_array_add(a, (ks_base_t *)ks_string_new(id, strlen(id)));
        ks_array_add(a, (ks_base_t *)ks_number_new(idt));
        ks_array_add(&(q->identities), (ks_base_t *)a);
        return a;
}

void
ks_bquery_identity_add(ks_bquery_t *q, const char *id, int idt)
{
        ks_bquery_identity_add_ret(q, id, idt);
}

void
ks_bquery_identity_add_tagged(ks_bquery_t *q,
                                const char *id, int idt, const char *tag)
{
        ks_array_t      *a = ks_bquery_identity_add_ret(q, id, idt);
        ks_array_add(a, (ks_base_t *)ks_string_new(tag, strlen(tag)));
}

void
ks_bquery_flags_set(ks_bquery_t *q, long flags)
{
        ks_number_set(&(q->flags), flags);
}

ks_string_t *
ks_bquery_packet(ks_bquery_t *q)
{
        ks_string_t     *r = ks_string_new("", 0);
        ks_bappend(r, (ks_base_t *)q);
        return r;
}

int
ks_bquery_has_auth(ks_bquery_t *q)
{
        return q->principal != NULL;
}

void
ks_bquery_set_auth(ks_bquery_t *q, const char *p, const char *c)
{
        const char      *creds;
        creds = c ? c : "";

        if (p != NULL) {
                if (q->principal != NULL)
                        ks_string_set(q->principal, p, strlen(p));
                else
                        q->principal = ks_string_new(p, strlen(p));
                if (q->credentials != NULL)
                        ks_string_set(q->credentials, creds, strlen(creds));
                else
                        q->credentials = ks_string_new(creds, strlen(creds));
        }
        else {
                if (q->principal != NULL) {
                        ks_string_free(q->principal);
                        q->principal = NULL;
                }
                if (q->credentials != NULL) {
                        ks_string_free(q->credentials);
                        q->credentials = NULL;
                }
        }
}

---