clickatell.c File Reference

#include "gwlib/gwlib.h"
#include "smscconn.h"
#include "smscconn_p.h"
#include "bb_smscconn_cb.h"
#include "msg.h"
#include "sms.h"
#include "dlr.h"
#include "urltrans.h"
#include "meta_data.h"
#include "../smsc_http_p.h"

Go to the source code of this file.

Functions
static int	clickatell_send_sms (SMSCConn *conn, Msg *sms)
static Dict *	clickatell_parse_body (Octstr *body)
static void	clickatell_parse_reply (SMSCConn *conn, Msg *msg, int status, List *headers, Octstr *body)
static void	clickatell_receive_sms (SMSCConn *conn, HTTPClient *client, List *headers, Octstr *body, List *cgivars)

Variables
struct smsc_http_fn_callbacks	smsc_http_clickatell_callback

Function Documentation

clickatell_parse_body()

static Dict* clickatell_parse_body ( Octstr *  body )

static

Definition at line 161 of file clickatell.c.

References dict_create(), dict_put(), gwlist_destroy(), gwlist_extract_first(), gwlist_len(), octstr_compare(), octstr_destroy(), octstr_imm(), and octstr_split_words().

Referenced by clickatell_parse_reply().

{
    Dict *param = NULL;
    List *words = NULL;
    long len;
    Octstr *word, *value;

    words = octstr_split_words(body);
    if ((len = gwlist_len(words)) > 1) {
        word = gwlist_extract_first(words);
        if (octstr_compare(word, octstr_imm("ID:")) == 0) {
            value = gwlist_extract_first(words);
            param = dict_create(4, (void(*)(void *)) octstr_destroy);
            dict_put(param, octstr_imm("ID"), value);
        } else if (octstr_compare(word, octstr_imm("ERR:")) == 0) {
            value = gwlist_extract_first(words);
            param = dict_create(4, (void(*)(void *)) octstr_destroy);
            dict_put(param, octstr_imm("ERR"), value);
        }
        octstr_destroy(word);
    }
    gwlist_destroy(words, (void(*)(void *)) octstr_destroy);

    return param;
}

clickatell_parse_reply()

static void clickatell_parse_reply ( SMSCConn *  conn, Msg *  msg, int  status, List *  headers, Octstr *  body  )

static

Definition at line 188 of file clickatell.c.

References bb_smscconn_send_failed(), bb_smscconn_sent(), clickatell_parse_body(), dict_destroy(), dict_get(), dlr_add(), DLR_IS_ENABLED_DEVICE, error(), HTTP_ACCEPTED, HTTP_OK, smscconn::id, msg, octstr_duplicate, octstr_get_cstr, octstr_imm(), SMSCCONN_FAILED_MALFORMED, and SMSCCONN_FAILED_REJECTED.

{
    if (status == HTTP_OK || status == HTTP_ACCEPTED) {
        Dict *param;
        Octstr *msgid;

        if ((param = clickatell_parse_body(body)) != NULL &&
            (msgid = dict_get(param, octstr_imm("ID"))) != NULL &&
            msgid != NULL) {

            /* SMSC ACK.. now we have the message id. */
            if (DLR_IS_ENABLED_DEVICE(msg->sms.dlr_mask))
                dlr_add(conn->id, msgid, msg, 0);

            bb_smscconn_sent(conn, msg, NULL);

        } else {
            error(0, "HTTP[%s]: Message was malformed or error was returned. SMSC response `%s'.",
                  octstr_get_cstr(conn->id), octstr_get_cstr(body));
            bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_MALFORMED, octstr_duplicate(body));
        }
        dict_destroy(param);

    } else {
        error(0, "HTTP[%s]: Message was rejected. SMSC response `%s'.",
              octstr_get_cstr(conn->id), octstr_get_cstr(body));
        bb_smscconn_send_failed(conn, msg,
                SMSCCONN_FAILED_REJECTED, octstr_duplicate(body));
    }
}

clickatell_receive_sms()

static void clickatell_receive_sms ( SMSCConn *  conn, HTTPClient *  client, List *  headers, Octstr *  body, List *  cgivars  )

static

Definition at line 221 of file clickatell.c.

References bb_smscconn_receive(), charset, client(), debug(), DLR_BUFFERED, DLR_EXPIRED, DLR_FAIL, dlr_find(), DLR_SUCCESS, DLR_UNKNOWN, error(), from, gw_mktime(), gwlist_create, http_cgi_variable(), http_destroy_headers(), HTTP_FORBIDDEN, http_header_add(), HTTP_OK, http_send_reply(), HTTP_UNAUTHORIZED, smscconn::id, mo, msg_create, octstr_create, octstr_destroy(), octstr_duplicate, octstr_get_cstr, octstr_len(), report_mo, and text.

{
    List *reply_headers;
    int ret;
    Octstr *apimsgid, *status, *timestamp, *retmsg, *dest, *charge;
    Octstr *api_id, *from, *to, *text, *charset, *udh;
    int httpstatus = HTTP_UNAUTHORIZED, dlrstat;
    Msg *dlrmsg, *momsg;
    struct tm tm;

    /* dlr parameters */
    apimsgid = http_cgi_variable(cgivars, "apiMsgId");
    status = http_cgi_variable(cgivars, "status");
    /* timestamp is for both DLR & MO */
    timestamp = http_cgi_variable(cgivars, "timestamp");
    dest = http_cgi_variable(cgivars, "to");
    charge = http_cgi_variable(cgivars, "charge");
    /* MO parameters */
    api_id = http_cgi_variable(cgivars, "api_id");
    from = http_cgi_variable(cgivars, "from");
    to = http_cgi_variable(cgivars, "to");
    text = http_cgi_variable(cgivars, "text");
    charset = http_cgi_variable(cgivars, "charset");
    udh = http_cgi_variable(cgivars, "udh");

    debug("smsc.http.clickatell", 0, "HTTP[%s]: Received a request",
          octstr_get_cstr(conn->id));

    if (api_id != NULL && from != NULL && to != NULL && timestamp != NULL && text != NULL && charset != NULL && udh != NULL) {
        /* we received an MO message */
        debug("smsc.http.clickatell", 0, "HTTP[%s]: Received MO message from %s: <%s>",
                octstr_get_cstr(conn->id), octstr_get_cstr(from), octstr_get_cstr(text));
        momsg = msg_create(sms);
        momsg->sms.sms_type = mo;
        momsg->sms.sender = octstr_duplicate(from);
        momsg->sms.receiver = octstr_duplicate(to);
        momsg->sms.msgdata = octstr_duplicate(text);
        momsg->sms.charset = octstr_duplicate(charset);
        momsg->sms.service = octstr_duplicate(api_id);
        momsg->sms.binfo = octstr_duplicate(api_id);
            momsg->sms.smsc_id = octstr_duplicate(conn->id);
        if (octstr_len(udh) > 0) {
            momsg->sms.udhdata = octstr_duplicate(udh);
        }
        strptime(octstr_get_cstr(timestamp), "%Y-%m-%d %H:%M:%S", &tm);
        momsg->sms.time = gw_mktime(&tm);

        /* note: implicit msg_destroy */
        ret = bb_smscconn_receive(conn, momsg);
        httpstatus = HTTP_OK;
        retmsg = octstr_create("Thanks");
    } else if (apimsgid == NULL || status == NULL || timestamp == NULL || dest == NULL) {
        error(0, "HTTP[%s]: Insufficient args.",
              octstr_get_cstr(conn->id));
        httpstatus = HTTP_OK;
        retmsg = octstr_create("Insufficient arguments, rejected.");
    } else {
        /* we received a DLR */
        switch (atoi(octstr_get_cstr(status))) {
            case  1: /* message unknown */
            case  5: /* error with message */
            case  6: /* user cancelled message */
            case  7: /* error delivering message */
            case  9: /* routing error */
            case 12: /* out of credit */
            case 13: /* message cancelled by Clickatell */
            case 14: /* maximum MT limit exceeded */
                dlrstat = DLR_FAIL; /* delivery failure */
                break;
            case 10: /* message expired */
                dlrstat = DLR_EXPIRED;
                break;
            case  2: /* message queued */
            case  3: /* delivered to gateway */
            case 11: /* message queued for later delivery */
                dlrstat = DLR_BUFFERED; /* message buffered */
                break;
            case  4: /* received by recipient */
            case  8: /* OK */
                dlrstat = DLR_SUCCESS; /* message received */
                break;
            default: /* unknown status code */
                dlrstat = DLR_UNKNOWN;
                break;
        }
        dlrmsg = dlr_find(conn->id,
            apimsgid, /* smsc message id */
            dest, /* destination */
            dlrstat, 0);

        if (dlrmsg != NULL) {
            /* dlrmsg->sms.msgdata = octstr_duplicate(apimsgid); */
            dlrmsg->sms.sms_type = report_mo;
            dlrmsg->sms.time = atoi(octstr_get_cstr(timestamp));
            if (charge) {
                /* unsure if smsbox relays the binfo field to dlrs.
                   But it is here in case they will start to do it. */
                dlrmsg->sms.binfo = octstr_duplicate(charge);
            }

            ret = bb_smscconn_receive(conn, dlrmsg);
            httpstatus = (ret == 0 ? HTTP_OK : HTTP_FORBIDDEN);
            retmsg = octstr_create("Sent");
        } else {
            error(0,"HTTP[%s]: got DLR but could not find message or was not interested "
                    "in it id<%s> dst<%s>, type<%d>",
            octstr_get_cstr(conn->id), octstr_get_cstr(apimsgid),
            octstr_get_cstr(dest), dlrstat);
            httpstatus = HTTP_OK;
            retmsg = octstr_create("Thanks");
        }
    }

    reply_headers = gwlist_create();
    http_header_add(reply_headers, "Content-Type", "text/plain");
    debug("smsc.http.clickatell", 0, "HTTP[%s]: Sending reply `%s'.",
          octstr_get_cstr(conn->id), octstr_get_cstr(retmsg));
    http_send_reply(client, httpstatus, reply_headers, retmsg);

    octstr_destroy(retmsg);
    http_destroy_headers(reply_headers);
}

clickatell_send_sms()

static int clickatell_send_sms ( SMSCConn *  conn, Msg *  sms  )

static

Definition at line 78 of file clickatell.c.

References conndata::alt_charset, smscconn::data, DC_8BIT, DC_UCS2, debug(), DLR_BUFFERED, DLR_EXPIRED, DLR_FAIL, DLR_IS_ENABLED_DEVICE, DLR_SUCCESS, http_create_empty_headers(), http_destroy_headers(), HTTP_METHOD_GET, conndata::http_ref, http_start_request(), smscconn::id, conndata::mobile_originated, conndata::no_sender, octstr_append_cstr(), octstr_create, octstr_destroy(), octstr_format(), octstr_format_append(), octstr_get_cstr, octstr_imm(), octstr_len(), octstr_replace(), conndata::password, conndata::send_url, SMS_PARAM_UNDEFINED, conndata::system_id, url, conndata::username, UUID_STR_LEN, and uuid_unparse().

{
    ConnData *conndata = conn->data;
    Octstr *url, *os;
    char id[UUID_STR_LEN + 1];
    List *headers;

    /* form the basic URL */
    url = octstr_format("%S/sendmsg?to=%E&api_id=%E&user=%E&password=%E",
        conndata->send_url, sms->sms.receiver,
        conndata->system_id, conndata->username, conndata->password);

    /* append 'from' parameter */
    if (!conndata->no_sender)
        octstr_format_append(url, "&from=%E", sms->sms.sender);

    /* append 'mo' parameter */
    if (conndata->mobile_originated)
        octstr_append_cstr(url, "&mo=1");

    /* append 'validity' parameter */
    if (sms->sms.validity != SMS_PARAM_UNDEFINED)
        octstr_format_append(url, "&validity=%ld", (sms->sms.validity - time(NULL)) / 60);

    /* append MD5 digest as msg ID from our UUID */
    uuid_unparse(sms->sms.id, id);
    os = octstr_create(id);
    octstr_replace(os, octstr_imm("-"), octstr_imm(""));
    octstr_format_append(url, "&cliMsgId=%E", os);
    octstr_destroy(os);

    /* append UDH header */
    if(octstr_len(sms->sms.udhdata)) {
        octstr_format_append(url, "&udh=%H", sms->sms.udhdata);
    }

    if(sms->sms.coding == DC_8BIT) {
        octstr_format_append(url, "&data=%H&mclass=%d", sms->sms.msgdata, sms->sms.mclass);
    } else if(sms->sms.coding == DC_UCS2) {
        octstr_format_append(url, "&unicode=1&text=%H", sms->sms.msgdata);
    } else {
        octstr_format_append(url, "&text=%E", sms->sms.msgdata);
        if (conndata->alt_charset) {
            octstr_format_append(url, "&charset=%E", conndata->alt_charset);
        } else {
            octstr_append_cstr(url, "&charset=UTF-8");
        }
    }

    /* append 'callback' parameter */
    if (DLR_IS_ENABLED_DEVICE(sms->sms.dlr_mask)) {
        int callback = 0;
        if (sms->sms.dlr_mask & DLR_BUFFERED)
            callback |= 0x01;
        if (sms->sms.dlr_mask & (DLR_SUCCESS | DLR_EXPIRED))
            callback |= 0x02;
        if (sms->sms.dlr_mask & DLR_FAIL)
            callback |= 0x04;
        octstr_format_append(url, "&callback=%d", callback);
    }

    headers = http_create_empty_headers();
    debug("smsc.http.clickatell", 0, "HTTP[%s]: Sending request <%s>",
          octstr_get_cstr(conn->id), octstr_get_cstr(url));

    /*
     * Clickatell requires optionally an SSL-enabled HTTP client call, this is handled
     * transparently by the Kannel HTTP layer module.
     */
    http_start_request(conndata->http_ref, HTTP_METHOD_GET, url, headers, NULL, 0, sms, NULL);

    octstr_destroy(url);
    http_destroy_headers(headers);

    return 0;
}

Variable Documentation

smsc_http_clickatell_callback

struct smsc_http_fn_callbacks smsc_http_clickatell_callback

Initial value:

= {
    .send_sms = clickatell_send_sms,
    .parse_reply = clickatell_parse_reply,
    .receive_sms = clickatell_receive_sms,
}

Definition at line 345 of file clickatell.c.