dlr_spool.c File Reference

#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 "dlr_p.h"
#include "sms.h"
#include "bb_store.h"

Go to the source code of this file.

Macros
#define	MD5_DIGEST_LEN   32
#define	SHA1_DIGEST_LEN   40
#define	OUR_DIGEST_LEN   MD5_DIGEST_LEN
#define	MAX_DIRS   100
#define	MAP(to, from)
#define	MAP(to, from)

Functions
static Octstr *	our_hash_func (Octstr *os)
static int	non_verified_file (const char *filename, const struct stat *sb, int tflag, void *ftwbuf)
static int	unlink_file (const char *filename, const struct stat *sb, int tflag, void *ftwbuf)
static int	for_each_file (const Octstr *dir_s, int ignore_err, int(*cb)(const char *, const struct stat *, int, void *))
static Octstr *	get_msg_filename (const Octstr *dir_s, const Octstr *hash, const Octstr *dst)
static Octstr *	get_msg_surrogate (const Octstr *dir_s, const Octstr *hash, const Octstr *dst, Octstr **filename)
static void	dlr_spool_add (struct dlr_entry *dlr)
static struct dlr_entry *	dlr_spool_get (const Octstr *smsc, const Octstr *ts, const Octstr *dst)
static void	dlr_spool_remove (const Octstr *smsc, const Octstr *ts, const Octstr *dst)
static void	dlr_spool_shutdown ()
static long	dlr_spool_messages (void)
static void	dlr_spool_flush (void)
struct dlr_storage *	dlr_init_spool (Cfg *cfg)

Variables
static Octstr *	spool_dir = NULL
static Counter *	counter
static struct dlr_storage	handles

Macro Definition Documentation

MAP [1/2]

#define MAP	(		to,
			from
	)

Value:

to = from; \
    from = NULL;

Referenced by dlr_spool_add(), and dlr_spool_get().

MAP [2/2]

#define MAP	(		to,
			from
	)

Value:

to = from; \
    from = NULL;

MAX_DIRS

#define MAX_DIRS   100

Definition at line 93 of file dlr_spool.c.

Referenced by dlr_spool_add(), dlr_spool_get(), and dlr_spool_remove().

MD5_DIGEST_LEN

#define MD5_DIGEST_LEN   32

Definition at line 84 of file dlr_spool.c.

OUR_DIGEST_LEN

#define OUR_DIGEST_LEN   MD5_DIGEST_LEN

Definition at line 89 of file dlr_spool.c.

Referenced by get_msg_filename().

SHA1_DIGEST_LEN

#define SHA1_DIGEST_LEN   40

Definition at line 85 of file dlr_spool.c.

Function Documentation

dlr_init_spool()

struct dlr_storage* dlr_init_spool

(

Cfg *

cfg

)

Definition at line 606 of file dlr_spool.c.

References cfg, cfg_get, cfg_get_single_group(), counter, counter_create(), for_each_file(), handles, non_verified_file(), octstr_imm(), panic, and spool_dir.

Referenced by dlr_init().

{
    CfgGroup *grp;

    if (!(grp = cfg_get_single_group(cfg, octstr_imm("core"))))
        panic(0, "DLR: spool: group 'core' is not specified!");

    if (!(spool_dir = cfg_get(grp, octstr_imm("dlr-spool"))))
        panic(0, "DLR: spool: directive 'dlr-spool' is not specified!");

#ifdef HAVE_LIBSSL
    OpenSSL_add_all_digests();
#endif

    counter = counter_create();

    /* we need to traverse the DLR spool to determine how
     * many entries we have. */
#ifdef VERIFIED
    for_each_file(spool_dir, 1, verified_file);
#else
    for_each_file(spool_dir, 1, non_verified_file);
#endif

    return &handles;
}

dlr_spool_add()

static void dlr_spool_add ( struct dlr_entry *  dlr )

static

Definition at line 369 of file dlr_spool.c.

References dlr_entry::boxc_id, counter, counter_increase(), dlr_entry::destination, dlr_entry_destroy(), error(), filename, MAP, dlr_entry::mask, MAX_DIRS, msg, msg_create, msg_destroy(), octstr_append(), octstr_binary_to_hex(), octstr_destroy(), octstr_duplicate, octstr_format(), octstr_get_cstr, octstr_hash_key(), octstr_len(), our_hash_func(), report_mt, dlr_entry::service, dlr_entry::smsc, dlr_entry::source, spool_dir, store_msg_pack, dlr_entry::timestamp, and dlr_entry::url.

{
    Msg *msg;
    Octstr *os, *hash, *dir, *filename;
    int fd;
    size_t wrc;

#define MAP(to, from) \
    to = from; \
    from = NULL;

    /* create a common message structure to contain our values */
    msg = msg_create(sms);
    msg->sms.sms_type = report_mt;
    MAP(msg->sms.smsc_id, dlr->smsc);
    MAP(msg->sms.foreign_id, dlr->timestamp);
    MAP(msg->sms.sender, dlr->source);
    MAP(msg->sms.receiver, dlr->destination);
    MAP(msg->sms.service, dlr->service);
    MAP(msg->sms.dlr_url, dlr->url);
    MAP(msg->sms.boxc_id, dlr->boxc_id);
    msg->sms.dlr_mask = dlr->mask;

    /* we got all values, destroy the structure now */
    dlr_entry_destroy(dlr);

    /* create hash value */
    os = octstr_duplicate(msg->sms.smsc_id);
    octstr_append(os, msg->sms.foreign_id);
    hash = our_hash_func(os);
    octstr_destroy(os);

    /* target directory */
    dir = octstr_format("%S/%ld", spool_dir, octstr_hash_key(hash) % MAX_DIRS);
    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(hash);
        msg_destroy(msg);
        return;
    }

    /*
     * Now also add the hex value of the destination.
     * This will be the part we look later into while
     * DLR resolving.
     */
    os = octstr_duplicate(msg->sms.receiver);
    octstr_binary_to_hex(os, 0);
    octstr_append(hash, os);
    octstr_destroy(os);

    /* target file */
    filename = octstr_format("%S/%S", dir, hash);
    octstr_destroy(dir);
    octstr_destroy(hash);
    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);
        msg_destroy(msg);
        return;
    }

    /* pack and write content to file */
    os = store_msg_pack(msg);
    msg_destroy(msg);
    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 DLR 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;
        }
        wrc += rc;
    }
    close(fd);
    counter_increase(counter);
    octstr_destroy(filename);
    octstr_destroy(os);
}

dlr_spool_flush()

static void dlr_spool_flush ( void  )

static

Definition at line 581 of file dlr_spool.c.

References counter, counter_set(), for_each_file(), spool_dir, and unlink_file().

{
    for_each_file(spool_dir, 1, unlink_file);
    counter_set(counter, 0);
}

dlr_spool_get()

static struct dlr_entry* dlr_spool_get ( const Octstr *  smsc, const Octstr *  ts, const Octstr *  dst  )

static

Definition at line 459 of file dlr_spool.c.

References dlr_entry::boxc_id, dlr_entry::destination, dlr_entry_create(), error(), filename, get_msg_surrogate(), MAP, dlr_entry::mask, MAX_DIRS, msg, msg_destroy(), octstr_append(), octstr_binary_to_hex(), octstr_destroy(), octstr_duplicate, octstr_format(), octstr_get_cstr, octstr_hash_key(), our_hash_func(), dlr_entry::service, dlr_entry::smsc, dlr_entry::source, spool_dir, store_msg_unpack, dlr_entry::timestamp, and dlr_entry::url.

{
    struct dlr_entry *ret = NULL;
    Octstr *os, *dst_min, *hash, *dir, *filename = NULL;
    Msg *msg;

    /* determine target dir and filename via hash */
    os = octstr_duplicate(smsc);
    octstr_append(os, ts);
    hash = our_hash_func(os);
    octstr_destroy(os);

    /* determine target dir */
    dir = octstr_format("%S/%ld", spool_dir, octstr_hash_key(hash) % MAX_DIRS);

    /* get content of msg surrogate */
    dst_min = octstr_duplicate(dst);
    if (dst_min)
        octstr_binary_to_hex(dst_min, 0);
    os = get_msg_surrogate(dir, hash, dst_min, &filename);
    octstr_destroy(dst_min);
    octstr_destroy(dir);
    octstr_destroy(hash);

    /* if there was no content */
    if (os == NULL) {
        octstr_destroy(filename);
        return NULL;
    }

    /* unpack */
    if ((msg = store_msg_unpack(os)) == NULL) {
        octstr_destroy(os);
        error(0, "Could not unpack DLR message `%s'", octstr_get_cstr(filename));
        octstr_destroy(filename);
        return ret;
    }

    octstr_destroy(os);
    octstr_destroy(filename);

#define MAP(to, from) \
    to = from; \
    from = NULL;

    /* map values to a struct dlr_entry */
    ret = dlr_entry_create();
    MAP(ret->smsc, msg->sms.smsc_id);
    MAP(ret->timestamp, msg->sms.foreign_id);
    MAP(ret->source, msg->sms.sender);
    MAP(ret->destination, msg->sms.receiver);
    MAP(ret->service, msg->sms.service);
    MAP(ret->url, msg->sms.dlr_url);
    MAP(ret->boxc_id, msg->sms.boxc_id);
    ret->mask = msg->sms.dlr_mask;

    msg_destroy(msg);

    return ret;
}

dlr_spool_messages()

static long dlr_spool_messages ( void  )

static

Definition at line 572 of file dlr_spool.c.

References counter, and counter_value().

{
    return counter_value(counter);
}

dlr_spool_remove()

static void dlr_spool_remove ( const Octstr *  smsc, const Octstr *  ts, const Octstr *  dst  )

static

Definition at line 524 of file dlr_spool.c.

References counter, counter_decrease(), error(), filename, get_msg_filename(), MAX_DIRS, octstr_append(), octstr_destroy(), octstr_duplicate, octstr_format(), octstr_get_cstr, octstr_hash_key(), our_hash_func(), dlr_entry::smsc, and spool_dir.

{
    Octstr *os, *hash, *dir, *filename;

    /* determine target dir and filename via hash */
    os = octstr_duplicate(smsc);
    octstr_append(os, ts);
    hash = our_hash_func(os);
    octstr_destroy(os);

    /* determine target dir */
    dir = octstr_format("%S/%ld", spool_dir, octstr_hash_key(hash) % MAX_DIRS);

    /* get msg surrogate filename */
    filename = get_msg_filename(dir, hash, dst);
    octstr_destroy(dir);
    octstr_destroy(hash);

    /* if there was no filename, then we didn't find it */
    if (filename == NULL) {
        return;
    }

    /* remove the file from the file system */
    if (unlink(octstr_get_cstr(filename)) == -1) {
        error(errno, "Could not unlink file `%s'.", octstr_get_cstr(filename));
        octstr_destroy(filename);
        return;
    }

    counter_decrease(counter);
    octstr_destroy(filename);
}

dlr_spool_shutdown()

static void dlr_spool_shutdown ( )

static

Definition at line 562 of file dlr_spool.c.

References counter, counter_destroy(), octstr_destroy(), and spool_dir.

{
    counter_destroy(counter);
    octstr_destroy(spool_dir);
}

for_each_file()

static int for_each_file ( const Octstr *  dir_s, int  ignore_err, int(*)(const char *, const struct stat *, int, void *)  cb  )

static

Definition at line 252 of file dlr_spool.c.

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

Referenced by dlr_init_spool(), and dlr_spool_flush().

{
    DIR *dir;
    struct dirent *ent;
    int ret = 0;
#ifndef _DIRENT_HAVE_D_TYPE
    struct stat stat;
#endif

    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 (!(strcmp((char*)ent->d_name, "." ) != 0 && strcmp((char*)ent->d_name, ".." ) != 0))
            continue;
        filename = octstr_format("%S/%s", dir_s, ent->d_name);
#ifdef _DIRENT_HAVE_D_TYPE
        if (ent->d_type == DT_DIR && for_each_file(filename, ignore_err, cb) == -1) {
            ret = -1;
        } else if (ent->d_type == DT_REG && cb != NULL) {
            cb(octstr_get_cstr(filename), NULL, 0, NULL);
        }
#else
        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) == -1) {
            ret = -1;
        } else if (S_ISREG(stat.st_mode) && cb != NULL)
            cb(octstr_get_cstr(filename), &stat, 0, NULL);
#endif
        octstr_destroy(filename);
        if (ret == -1 && ignore_err)
            ret = 0;
        else if (ret == -1)
            break;
    }
    closedir(dir);

    return ret;
}

get_msg_filename()

static Octstr* get_msg_filename ( const Octstr *  dir_s, const Octstr *  hash, const Octstr *  dst  )

static

Definition at line 300 of file dlr_spool.c.

References error(), found, octstr_copy, octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_len(), octstr_ncompare(), octstr_search(), and OUR_DIGEST_LEN.

Referenced by dlr_spool_remove(), and get_msg_surrogate().

{
    Octstr *ret;
    DIR *dir;
    struct dirent *ent;

    if ((dir = opendir(octstr_get_cstr(dir_s))) == NULL) {
        error(errno, "Could not open directory `%s'", octstr_get_cstr(dir_s));
        return NULL;
    }

    while ((ent = readdir(dir)) != NULL) {
        Octstr *fname = octstr_create((char*)ent->d_name);

        if (octstr_ncompare(fname, hash, OUR_DIGEST_LEN) == 0) {
            Octstr *addr;
            long addr_len = 0, pos = 0;

            /* this is a candidate */
            if (dst == NULL)
                goto found;

            /* check for the destination address suffix part */
            if ((addr_len = (octstr_len(fname) - OUR_DIGEST_LEN)) < 0 ||
                    (pos = (addr_len - octstr_len(dst))) < 0) {
                octstr_destroy(fname);
                continue;
            }
            addr = octstr_copy(fname, OUR_DIGEST_LEN, addr_len);

            /* if not found, then bail out*/
            if (octstr_search(addr, dst, pos) == -1) {
                octstr_destroy(addr);
                octstr_destroy(fname);
                continue;
            }
            octstr_destroy(addr);
found:
            /* found it */
            closedir(dir);
            ret = octstr_format("%S/%S", dir_s, fname);
            octstr_destroy(fname);
            return ret;
        }
        octstr_destroy(fname);
    }
    closedir(dir);

    return NULL;
}

get_msg_surrogate()

static Octstr* get_msg_surrogate ( const Octstr *  dir_s, const Octstr *  hash, const Octstr *  dst, Octstr **  filename  )

static

Definition at line 351 of file dlr_spool.c.

References filename, get_msg_filename(), octstr_get_cstr, and octstr_read_file().

Referenced by dlr_spool_get().

{
    /* get our msg filename */
    if ((*filename = get_msg_filename(dir_s, hash, dst)) == NULL)
        return NULL;

    return octstr_read_file(octstr_get_cstr(*filename));
}

non_verified_file()

static int non_verified_file ( const char *  filename, const struct stat *  sb, int  tflag, void *  ftwbuf  )

static

Definition at line 204 of file dlr_spool.c.

References counter, and counter_increase().

Referenced by dlr_init_spool().

{
#endif

    counter_increase(counter);

    return 0;
}

our_hash_func()

static Octstr* our_hash_func ( Octstr *  os )

static

Definition at line 123 of file dlr_spool.c.

References md5digest(), octstr_binary_to_hex(), octstr_create_from_data, octstr_get_cstr, and octstr_len().

Referenced by dlr_spool_add(), dlr_spool_get(), dlr_spool_remove(), and main().

{
#ifdef HAVE_LIBSSL
    /* use openssl's SHA1 */
    unsigned char hash[20];
    Octstr *ret;

    memset(hash, 0, sizeof(hash));
    
    SHA1((const unsigned char *)octstr_get_cstr(os), octstr_len(os), hash);
    
    ret = octstr_create_from_data((const char*)hash, sizeof(hash));
    octstr_binary_to_hex(ret, 0);
    return ret;
#else
    /* fallback to our own MD5 if we don't have openssl available */
    return md5digest(os);
#endif
}

unlink_file()

static int unlink_file ( const char *  filename, const struct stat *  sb, int  tflag, void *  ftwbuf  )

static

Definition at line 224 of file dlr_spool.c.

References error(), and filename.

Referenced by dlr_spool_flush().

{
#endif

    /* remove the file from the file system */
    if (unlink(filename) == -1) {
        error(errno, "Could not unlink file `%s'.", filename);
    }

    return 0;
}

Variable Documentation

counter

Counter* counter

static

Definition at line 112 of file dlr_spool.c.

Referenced by dlr_init_spool(), dlr_spool_add(), dlr_spool_flush(), dlr_spool_messages(), dlr_spool_remove(), dlr_spool_shutdown(), and non_verified_file().

handles

struct dlr_storage handles

static

Initial value:

= {
    .type = "spool",
    .dlr_add = dlr_spool_add,
    .dlr_get = dlr_spool_get,
    .dlr_remove = dlr_spool_remove,
    .dlr_shutdown = dlr_spool_shutdown,
    .dlr_messages = dlr_spool_messages,
    .dlr_flush = dlr_spool_flush
}

Definition at line 592 of file dlr_spool.c.

Referenced by dlr_init_spool().

spool_dir

Octstr* spool_dir = NULL

static

Definition at line 107 of file dlr_spool.c.

Referenced by dlr_init_spool(), dlr_spool_add(), dlr_spool_flush(), dlr_spool_get(), dlr_spool_remove(), and dlr_spool_shutdown().