bb_store_spool.c File Reference

#include "gw-config.h"
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <errno.h>
#include "gwlib/gwlib.h"
#include "msg.h"
#include "sms.h"
#include "bearerbox.h"
#include "bb_store.h"

Go to the source code of this file.

Data Structures
struct	status

Macros
#define	MAX_DIRS   100

Functions
static int	store_spool_dump ()
static long	store_spool_messages ()
static int	for_each_file (const Octstr *dir_s, int ignore_err, void(*cb)(const Octstr *, void *), void *data)
static void	status_cb (const Octstr *filename, void *d)
static void	store_spool_for_each_message (void(*callback_fn)(Msg *msg, void *data), void *data)
static void	dispatch (const Octstr *filename, void *data)
static int	store_spool_load (void(*receive_msg)(Msg *))
static int	store_spool_save (Msg *msg)
static int	store_spool_save_ack (Msg *msg, ack_status_t status)
static void	store_spool_shutdown ()
int	store_spool_init (const Octstr *store_dir)

Variables
static Octstr *	spool
static Counter *	counter
static List *	loaded

Macro Definition Documentation

MAX_DIRS

#define MAX_DIRS   100

bb_store_spool.c - bearerbox box SMS storage/retrieval module using spool directory

Author: Alexander Malysh, 2006

Definition at line 80 of file bb_store_spool.c.

Referenced by store_spool_save().

Function Documentation

dispatch()

static void dispatch ( const Octstr *  filename, void *  data  )

static

Definition at line 175 of file bb_store_spool.c.

References counter, counter_increase(), status::data, error(), filename, msg, octstr_destroy(), octstr_get_cstr, octstr_read_file(), and store_msg_unpack.

Referenced by store_spool_load().

{
    Octstr *msg_s;
    Msg *msg;
    void(*receive_msg)(Msg*) = data;

    /* debug("", 0, "dispatch(%s,...) called", octstr_get_cstr(filename)); */

    msg_s = octstr_read_file(octstr_get_cstr(filename));
    if (msg_s == NULL)
        return;
    msg = store_msg_unpack(msg_s);
    octstr_destroy(msg_s);
    if (msg != NULL) {
        receive_msg(msg);
        counter_increase(counter);
    } else {
        error(0, "Could not unpack message `%s'", octstr_get_cstr(filename));
    }
}

for_each_file()

static int for_each_file ( const Octstr *  dir_s, int  ignore_err, void(*)(const Octstr *, void *)  cb, void *  data  )

static

Definition at line 100 of file bb_store_spool.c.

References error(), filename, octstr_destroy(), octstr_format(), and octstr_get_cstr.

Referenced by store_spool_for_each_message(), and store_spool_load().

{
    DIR *dir;
    struct dirent *ent;
    struct stat stat;
    int ret = 0;

    if ((dir = opendir(octstr_get_cstr(dir_s))) == NULL) {
        error(errno, "Could not open directory `%s'", octstr_get_cstr(dir_s));
        return -1;
    }
    while((ent = readdir(dir)) != NULL) {
        Octstr *filename;
        if (*(ent->d_name) == '.') /* skip hidden files */
            continue;
        filename = octstr_format("%S/%s", dir_s, ent->d_name);
        if (lstat(octstr_get_cstr(filename), &stat) == -1) {
            if (!ignore_err)
                error(errno, "Could not get stat for `%s'", octstr_get_cstr(filename));
            ret = -1;
        } else if (S_ISDIR(stat.st_mode) && for_each_file(filename, ignore_err, cb, data) == -1) {
            ret = -1;
        } else if (S_ISREG(stat.st_mode) && cb != NULL)
            cb(filename, data);
        octstr_destroy(filename);
        if (ret == -1 && ignore_err)
            ret = 0;
        else if (ret == -1)
            break;
    }
    closedir(dir);

    return ret;
}

status_cb()

static void status_cb ( const Octstr *  filename, void *  d  )

static

Definition at line 142 of file bb_store_spool.c.

References status::data, filename, msg, msg_destroy(), octstr_destroy(), octstr_get_cstr, octstr_read_file(), and store_msg_unpack.

Referenced by store_spool_for_each_message().

{
    struct status *data = d;
    Octstr *msg_s;
    Msg *msg;

    msg_s = octstr_read_file(octstr_get_cstr(filename));
    msg = store_msg_unpack(msg_s);
    octstr_destroy(msg_s);
    if (msg == NULL)
        return;

    data->callback_fn(msg, data->data);

    msg_destroy(msg);
}

store_spool_dump()

static int store_spool_dump ( )

static

Definition at line 87 of file bb_store_spool.c.

Referenced by store_spool_init().

{
    /* nothing todo */
    return 0;
}

store_spool_for_each_message()

static void store_spool_for_each_message ( void(*)(Msg *msg, void *data)  callback_fn, void *  data  )

static

Definition at line 160 of file bb_store_spool.c.

References status::callback_fn, status::data, for_each_file(), spool, and status_cb().

Referenced by store_spool_init().

{
    struct status d;

    if (spool == NULL)
        return;

    d.callback_fn = callback_fn;
    d.data = data;

    /* ignore error because files may disappear */
    for_each_file(spool, 1, status_cb, &d);
}

store_spool_init()

int store_spool_init

(

const Octstr *

fname

)

Init functions for different store types.

Definition at line 338 of file bb_store_spool.c.

References counter, counter_create(), error(), gwlist_add_producer(), gwlist_create, loaded, octstr_duplicate, octstr_get_cstr, spool, store_dump, store_for_each_message, store_load, store_messages, store_save, store_save_ack, store_shutdown, store_spool_dump(), store_spool_for_each_message(), store_spool_load(), store_spool_messages(), store_spool_save(), store_spool_save_ack(), and store_spool_shutdown().

Referenced by store_init().

{
    DIR *dir;

    store_messages = store_spool_messages;
    store_save = store_spool_save;
    store_save_ack = store_spool_save_ack;
    store_load = store_spool_load;
    store_dump = store_spool_dump;
    store_shutdown = store_spool_shutdown;
    store_for_each_message = store_spool_for_each_message;

    if (store_dir == NULL)
        return 0;

    /* check if we can open directory */
    if ((dir = opendir(octstr_get_cstr(store_dir))) == NULL) {
        error(errno, "Could not open directory `%s'", octstr_get_cstr(store_dir));
        return -1;
    }
    closedir(dir);

    loaded = gwlist_create();
    gwlist_add_producer(loaded);
    spool = octstr_duplicate(store_dir);
    counter = counter_create();

    return 0;
}

store_spool_load()

static int store_spool_load ( void(*)(Msg *)  receive_msg )

static

Definition at line 197 of file bb_store_spool.c.

References counter, counter_value(), dispatch(), for_each_file(), gwlist_remove_producer(), info(), loaded, and spool.

Referenced by store_spool_init().

{
    int rc;

    /* check if we are active */
    if (spool == NULL)
        return 0;
        
    /* sanity check */
    if (receive_msg == NULL)
        return -1;

    rc = for_each_file(spool, 0, dispatch, receive_msg);

    info(0, "Loaded %ld messages from store.", counter_value(counter));

    /* allow using of storage */
    gwlist_remove_producer(loaded);

    return rc;
}

store_spool_messages()

static long store_spool_messages ( )

static

Definition at line 94 of file bb_store_spool.c.

References counter, and counter_value().

Referenced by store_spool_init().

{
    return counter ? counter_value(counter) : -1;
}

store_spool_save()

static int store_spool_save ( Msg *  msg )

static

Definition at line 220 of file bb_store_spool.c.

References counter, counter_decrease(), counter_increase(), error(), filename, gwlist_consume(), loaded, MAX_DIRS, msg, MSG_PARAM_UNDEFINED, octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_hash_key(), octstr_len(), spool, store_msg_pack, uuid_generate(), uuid_is_null(), UUID_STR_LEN, and uuid_unparse().

Referenced by store_spool_init(), and store_spool_save_ack().

{
    char id[UUID_STR_LEN + 1];
    Octstr *id_s;

    /* always set msg id and timestamp */
    if (msg_type(msg) == sms && uuid_is_null(msg->sms.id))
        uuid_generate(msg->sms.id);

    if (msg_type(msg) == sms && msg->sms.time == MSG_PARAM_UNDEFINED)
        time(&msg->sms.time);

    if (spool == NULL)
        return 0;

    /* blocke here if store still not loaded */
    gwlist_consume(loaded);

    switch(msg_type(msg)) {
        case sms:
        {
            Octstr *os = store_msg_pack(msg);
            Octstr *filename, *dir;
            int fd;
            size_t wrc;

            if (os == NULL) {
                error(0, "Could not pack message.");
                return -1;
            }
            uuid_unparse(msg->sms.id, id);
            id_s = octstr_create(id);
            dir = octstr_format("%S/%ld", spool, octstr_hash_key(id_s) % MAX_DIRS);
            octstr_destroy(id_s);
            if (mkdir(octstr_get_cstr(dir), S_IRUSR|S_IWUSR|S_IXUSR) == -1 && errno != EEXIST) {
                error(errno, "Could not create directory `%s'.", octstr_get_cstr(dir));
                octstr_destroy(dir);
                octstr_destroy(os);
                return -1;
            }
            filename = octstr_format("%S/%s", dir, id);
            octstr_destroy(dir);
            if ((fd = open(octstr_get_cstr(filename), O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR)) == -1) {
                error(errno, "Could not open file `%s'.", octstr_get_cstr(filename));
                octstr_destroy(filename);
                octstr_destroy(os);
                return -1;
            }
            for (wrc = 0; wrc < octstr_len(os); ) {
                size_t rc = write(fd, octstr_get_cstr(os) + wrc, octstr_len(os) - wrc);
                if (rc == -1) {
                    /* remove file */
                    error(errno, "Could not write message to `%s'.", octstr_get_cstr(filename));
                    close(fd);
                    if (unlink(octstr_get_cstr(filename)) == -1)
                        error(errno, "Oops, Could not remove failed file `%s'.", octstr_get_cstr(filename));
                    octstr_destroy(os);
                    octstr_destroy(filename);
                    return -1;
                }
                wrc += rc;
            }
            close(fd);
            counter_increase(counter);
            octstr_destroy(filename);
            octstr_destroy(os);
            break;
        }
        case ack:
        {
            Octstr *filename;
            uuid_unparse(msg->ack.id, id);
            id_s = octstr_create(id);
            filename = octstr_format("%S/%ld/%s", spool, octstr_hash_key(id_s) % MAX_DIRS, id);
            octstr_destroy(id_s);
            if (unlink(octstr_get_cstr(filename)) == -1) {
                error(errno, "Could not unlink file `%s'.", octstr_get_cstr(filename));
                octstr_destroy(filename);
                return -1;
            }
            counter_decrease(counter);
            octstr_destroy(filename);
            break;
        }
        default:
            return -1;
    }

    return 0;
}

store_spool_save_ack()

static int store_spool_save_ack ( Msg *  msg, ack_status_t  status  )

static

Definition at line 312 of file bb_store_spool.c.

References msg, msg_create, msg_destroy(), status::status, store_spool_save(), and uuid_copy().

Referenced by store_spool_init().

{
    int ret;
    Msg *nack = msg_create(ack);

    nack->ack.nack = status;
    uuid_copy(nack->ack.id, msg->sms.id);
    nack->ack.time = msg->sms.time;
    ret = store_spool_save(nack);
    msg_destroy(nack);

    return ret;
}

store_spool_shutdown()

static void store_spool_shutdown ( )

static

Definition at line 327 of file bb_store_spool.c.

References counter, counter_destroy(), gwlist_destroy(), loaded, octstr_destroy(), and spool.

Referenced by store_spool_init().

{
    if (spool == NULL)
        return;
        
    counter_destroy(counter);
    octstr_destroy(spool);
    gwlist_destroy(loaded, NULL);
}

Variable Documentation

counter

Counter* counter

static

Definition at line 83 of file bb_store_spool.c.

Referenced by client_thread(), counter_create(), counter_decrease(), counter_destroy(), counter_increase(), counter_increase_with(), counter_set(), counter_value(), dispatch(), soap_send_loop(), store_spool_init(), store_spool_load(), store_spool_messages(), store_spool_save(), and store_spool_shutdown().

loaded

List* loaded

static

Definition at line 84 of file bb_store_spool.c.

Referenced by store_spool_init(), store_spool_load(), store_spool_save(), and store_spool_shutdown().

spool

Octstr* spool

static

Definition at line 82 of file bb_store_spool.c.

Referenced by store_spool_for_each_message(), store_spool_init(), store_spool_load(), store_spool_save(), and store_spool_shutdown().