When defining services or urls to send messages, the new %D parameter gets replaced with the complete meta-data information available.

However, there wasn’t any way to use only part of that data when posting to url’s. This is why I’ve created this patch that allows you to use individual meta-data fields in your urls.

USAGE

To use it, a new set of parameters is defined, with the following format:

%#group#parameter#

Where group is the meta-data group (for example: smpp, http or foo) and parameter is the individual meta-data parameter you want to replace.

For example, let’s suppose we’re using a generic http-smsc, and we want to pass a couple of extra parameters for a dynamic username and password (some aggregators do that). Right now, that would require patching the source code and inventing some method to pass the extra parameters from the sendsms interface.

With the patch applied, this would be as simple as this:

1. Pass the meta-data parameter on the sendsms request (urlencoded):

?http?user=Alex&pass=bar

2. Define the send-url parameter on your http-smsc to pass those parameters:

send-url = http://myhost/sms?….&username=%#http#user#&password=#http#pass#

Note: I’m defining the http group here, but it could be anything, even the smpp group coming from an smpp bind, in which case the syntax would be #smpp#username# instead.

Download the patch from here.

Please try it and let me know if it works for you.

This patch implements an sleep and retry mechanism when calling dlr_get(). This aims to solve that problem.

2 new core parameters are defined:

dlr-retry-count -> How many times do we attempt to fetch the dlr? Default: 1
dlr-retry-delay -> How many milliseconds do we sleep before retrying? Default: 0

So, if you don’t set these parameters the behaviour remains as it was before patching. However, if you, for instance, set:

dlr-retry-count = 3
dlr-retry-delay = 200

Kannel will try 3 times in total (the original plus 2 more), pausing 200ms (0.2 seconds) before each attempt. If after the third attempt the DLR’s still missing, Kannel will display a warning as usual.

Download the patch from here: kannel-dlr-retry

Please try it and let me know what you think.

Regards,

Alex

A problem you may have faced with dlrs on Kannel: If you’re using dlrs and have more than one bind to a given carrier, you need to name them all the same. Otherwise, if the dlr come back over a different bind than the one you’ve used to send the MT message in the first place, Kannel won’t be able to match them, since they won’t share the same “smsc” field.

This is usually OK. However, you lose the ability to control the binds independently: you cannot shutdown a single bind, for example. The problem worsens yet more if your binds are to different data centers (some carriers have redundant SMSC’s on geographycally distant places).

That’s why I’ve created this patch that adds a new configuration option to SMSC groups:

smsc-dlr-alias

Using this parameter, you can define an alias to use when storing dlrs, so they will match despite being sent/received over different binds.

For example:

…

#carrier link 1

group                      = smsc

smsc                       = smpp

smsc-id                  = “link1″

smsc-dlr-alias     = “myalias”

allowed-smsc-id = “link1;mylink”

host                        = “1.1.1.1″

…

#carrier link 2

group                      = smsc

smsc                       = smpp

smsc-id                  = “link2″

smsc-dlr-alias     = “myalias”

allowed-smsc-id = “link2;mylink”

host                        = “1.1.1.1″

…

Using this configuration, you just have to use the “&smsc=mylink” parameter on your send-sms url. The dlr will be stored using the alias “myalias” no matter which of these 2 routes the message takes. When getting the response back, again, it will be matched against “myalias”.

Download the patch here.

Please try it and let me know what you think.

Regards,

Alex

Today’s patch uses that functionality to implement the DLR storage on MS-SQL and Sybase DB Engines.

To use this, you need to:

1. Patch Kannel to support FreeTDS (see yesterday’s link).
2. Patch Kannel using this patch, to add support for DLR’s over FreeTDS.
3. ./configure –with-mssql=[optional path] [--other-switches]
4. make
5. sudo make install
6. Configure dlr-storage = mssql
7. Configure the DB connection (see yesterday’s article for details).
8. Configure the dlr-db group (see the userguide for details).

A simple example:

group = core
…
dlr-storage = mssql
…

group = mssql-connection
id = msdlr
username = myuser
password = mypass
server = mssql
database = mydb

#DLR Configuration
group = dlr-db
id = msdlr
table = dlr
field-smsc = smsc
field-timestamp = ts
field-destination = destination
field-source = source
field-service = service
field-url = url
field-mask = mask
field-status = status
field-boxc-id = boxc

Here is the patch: kannel-dlr-mssql

That’s all. Please try it and let me know.

Regards,

Alex

The following article is now old news:

I’ve been working integrating Kannel with FreeTDS, an open source project that provides a free, open source driver for the tabular data system protocol used on MS-SQL and Sybase DB Engines.

The result is a DBPool module that makes Kannel capable of talking with MS-SQL and Sybase DB’s.

To use this module you need to have FreeTDS installed on your kannel box (either by compiling the source code or installing binary packages). If you’re installing from packages, do not forget to install the development packages as well (otherwise you won’t be able to compile Kannel).

Once you’ve installed FreeTDS, configure the freetds.conf and make sure that everything works properly. Hint: use the tsql command line utility and try connecting to your DB server).

To compile this into Kannel, you need to download and apply this patch. Since it touches the configure template, you need to bootstrap the code afterwards. In short:

1. Download the patch kannel-dbpool-mssql to Kannel’s source root directory
2. Apply the patch: patch -p0 < kannel-dbpool-mssql.patch
3. ./bootstrap.sh (only the first time after applying the patch)
4. ./configure –with-mssql=[optional path] [--other-switches]
5. make
6. sudo make install

Now, to configure the DB-Link, you need to add a dbpool group to kannel’s configuration files. It should look similar to this:

group = mssql-connection
id = mssql-db
username = myuser
password = mypass
server = server_name
database =my_db_name

Note: server_name should match the [server_name] group for the DB link on your freetds.conf file.

Right now, this patch only adds the functionality to make Kannel FreeTDS-capable. I’m adding support for DLR’s and SqlBox soon, so stay tuned!

Here’s the patch: kannel-dbpool-mssql

As usual, please try it and let me know how it goes.

Regards,

Alex

Fundamental differences with the previous version:

1. The DB table is now created automatically at startup (if it didn’t exist).

2. Cleaned up code aiming at supporting other DB engines apart from MySQL.

3. Added documentation.

Please download the patches here:

kannel-store-db

kannel-store-db-docs

Again, this is far from stable. It needs further testing and confirmation before rolling up into production.

Regards,

Alex

That’s why I’ve created these simple store-manipulation program: store_tools.

What store_tools do is to read the store location and format from your kannel.conf file and allows you to perform a series of commands with it. The available commands are:

NOTE: Since the delete command modifies the store, you should do it with kannel stopped.

Please download the patch here: kannel_store_tools

Please try it and let me know if it works for you.

-Alex-

lock-timeout can be set to the number of milliseconds that sqlite waits before throwing a “BUSY” error. Because locking on sqlite is done AT THE DATABASE LEVEL, it can be a serious issue because any write operation would lock the entire database, so this option aims to ease the risk of getting locks.

If it’s not set, the default sqlite behaviour is maintained.

Here’s the patch:

kannel-sqlite-pool-patches

As usual, please try it and let me know what you think.