generic.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.

Data Structures
struct	fieldmap
struct	generic_values

Functions
static void	fieldmap_destroy (struct fieldmap *fieldmap)
static struct fieldmap *	generic_get_field_map (CfgGroup *grp)
static void	generic_receive_sms (SMSCConn *conn, HTTPClient *client, List *headers, Octstr *body, List *cgivars)
static void	convert_charset (Msg *msg, Octstr *charset, Octstr **content_type)
static int	generic_send_sms (SMSCConn *conn, Msg *sms)
static void	generic_parse_reply (SMSCConn *conn, Msg *msg, int status, List *headers, Octstr *body)
static int	generic_init (SMSCConn *conn, CfgGroup *cfg)
static void	generic_destroy (SMSCConn *conn)

Variables
struct smsc_http_fn_callbacks	smsc_http_generic_callback

Function Documentation

convert_charset()

static void convert_charset ( Msg *  msg, Octstr *  charset, Octstr **  content_type  )

static

Definition at line 466 of file generic.c.

References charset, charset_convert(), content_type, DC_7BIT, DC_8BIT, DC_UCS2, error(), msg, octstr_format(), and octstr_get_cstr.

Referenced by generic_send_sms().

{
    switch (msg->sms.coding) {
    case DC_7BIT:
    default:
        if (charset_convert(msg->sms.msgdata, "UTF-8", octstr_get_cstr(charset)) == 0) {
            *content_type = octstr_format("application/x-www-form-urlencoded; charset=\"%s\"",
                    octstr_get_cstr(charset));
        } else {
            error(0, "Failed to convert msgdata from UTF-8 to %s, will leave as is",
                  octstr_get_cstr(charset));
            *content_type = octstr_format("application/x-www-form-urlencoded; charset=\"UTF-8\"");
        }
        break;
    case DC_UCS2:
        if (charset_convert(msg->sms.msgdata, "UTF-16BE", octstr_get_cstr(charset)) == 0) {
            *content_type = octstr_format("application/x-www-form-urlencoded; charset=\"%s\"",
                    octstr_get_cstr(charset));
        } else {
            error(0, "Failed to convert msgdata from UCS-2 to %s, will leave as is",
                  octstr_get_cstr(charset));
            *content_type = octstr_format("application/x-www-form-urlencoded; charset=\"UTF-16BE\"");
        }
        break;
    case DC_8BIT:
        *content_type = octstr_format("application/x-www-form-urlencoded");
        break;
    }
}

fieldmap_destroy()

static void fieldmap_destroy ( struct fieldmap *  fieldmap )

static

Definition at line 152 of file generic.c.

References fieldmap::account, fieldmap::binfo, fieldmap::coding, fieldmap::deferred, fieldmap::dlr_err, fieldmap::dlr_mask, fieldmap::dlr_mid, fieldmap::dlr_url, fieldmap::flash, fieldmap::foreign_id, fieldmap::from, fieldmap::mclass, fieldmap::message_sent, fieldmap::meta_data, fieldmap::mwi, octstr_destroy(), fieldmap::password, fieldmap::service, fieldmap::text, fieldmap::to, fieldmap::udh, fieldmap::username, and fieldmap::validity.

Referenced by generic_destroy().

{
    if (fieldmap == NULL)
        return;
    octstr_destroy(fieldmap->username);
    octstr_destroy(fieldmap->password);
    octstr_destroy(fieldmap->from);
    octstr_destroy(fieldmap->to);
    octstr_destroy(fieldmap->text);
    octstr_destroy(fieldmap->udh);
    octstr_destroy(fieldmap->service);
    octstr_destroy(fieldmap->account);
    octstr_destroy(fieldmap->binfo);
    octstr_destroy(fieldmap->meta_data);
    octstr_destroy(fieldmap->dlr_mask);
    octstr_destroy(fieldmap->dlr_err);
    octstr_destroy(fieldmap->dlr_url);
    octstr_destroy(fieldmap->dlr_mid);
    octstr_destroy(fieldmap->flash);
    octstr_destroy(fieldmap->mclass);
    octstr_destroy(fieldmap->mwi);
    octstr_destroy(fieldmap->coding);
    octstr_destroy(fieldmap->validity);
    octstr_destroy(fieldmap->deferred);
    octstr_destroy(fieldmap->foreign_id);
    octstr_destroy(fieldmap->message_sent);
    gw_free(fieldmap);
}

generic_destroy()

static void generic_destroy ( SMSCConn *  conn )

static

Definition at line 666 of file generic.c.

References conndata::data, smscconn::data, debug(), fieldmap_destroy(), generic_values::generic_foreign_id_regex, generic_values::map, generic_values::permfail_regex, generic_values::success_regex, and generic_values::tempfail_regex.

{
    ConnData *conndata;
    struct generic_values *values;

    if (conn == NULL || conn->data == NULL)
        return;

    conndata = conn->data;
    values = conndata->data;

    fieldmap_destroy(values->map);
    if (values->success_regex)
        gw_regex_destroy(values->success_regex);
    if (values->permfail_regex)
        gw_regex_destroy(values->permfail_regex);
    if (values->tempfail_regex)
        gw_regex_destroy(values->tempfail_regex);
    if (values->generic_foreign_id_regex)
        gw_regex_destroy(values->generic_foreign_id_regex);

    gw_free(values);
    conndata->data = NULL;

    debug("", 0, "generic destroy completed");
}

generic_get_field_map()

static struct fieldmap* generic_get_field_map ( CfgGroup *  grp )

static

Definition at line 185 of file generic.c.

References fieldmap::account, fieldmap::binfo, cfg_get, cfg_get_integer(), fieldmap::coding, fieldmap::deferred, fieldmap::dlr_err, fieldmap::dlr_mask, fieldmap::dlr_mid, fieldmap::dlr_url, fieldmap::flash, fieldmap::foreign_id, fieldmap::from, gw_assert(), HTTP_ACCEPTED, fieldmap::mclass, fieldmap::message_sent, fieldmap::meta_data, fieldmap::mwi, octstr_create, octstr_imm(), fieldmap::password, fieldmap::service, fieldmap::status_error, fieldmap::status_sent, fieldmap::text, fieldmap::to, fieldmap::udh, fieldmap::username, and fieldmap::validity.

Referenced by generic_init().

{
    struct fieldmap *fm = NULL;

    fm = gw_malloc(sizeof(*fm));
    gw_assert(fm != NULL);

    fm->username = cfg_get(grp, octstr_imm("generic-param-username"));
    if (fm->username == NULL)
        fm->username = octstr_create("username");
    fm->password = cfg_get(grp, octstr_imm("generic-param-password"));
    if (fm->password == NULL)
        fm->password = octstr_create("password");
    fm->from = cfg_get(grp, octstr_imm("generic-param-from"));
    if (fm->from == NULL)
        fm->from = octstr_create("from");
    fm->to = cfg_get(grp, octstr_imm("generic-param-to"));
    if (fm->to == NULL)
        fm->to = octstr_create("to");
    fm->text = cfg_get(grp, octstr_imm("generic-param-text"));
    if (fm->text == NULL)
        fm->text = octstr_create("text");
    fm->udh = cfg_get(grp, octstr_imm("generic-param-udh"));
    if (fm->udh == NULL)
        fm->udh = octstr_create("udh");
    /* "service" preloads the "username" parameter to mimic former behaviour */
    fm->service = cfg_get(grp, octstr_imm("generic-param-service"));
    if (fm->service == NULL)
        fm->service = octstr_create("username");
    fm->account = cfg_get(grp, octstr_imm("generic-param-account"));
    if (fm->account == NULL)
        fm->account = octstr_create("account");
    fm->binfo = cfg_get(grp, octstr_imm("generic-param-binfo"));
    if (fm->binfo == NULL)
        fm->binfo = octstr_create("binfo");
    fm->dlr_mask = cfg_get(grp, octstr_imm("generic-param-dlr-mask"));
    if (fm->dlr_mask == NULL)
        fm->dlr_mask = octstr_create("dlr-mask");
    fm->dlr_err = cfg_get(grp, octstr_imm("generic-param-dlr-err"));
    if (fm->dlr_err == NULL)
        fm->dlr_err = octstr_create("dlr-err");
    fm->dlr_url = cfg_get(grp, octstr_imm("generic-param-dlr-url"));
    if (fm->dlr_url == NULL)
        fm->dlr_url = octstr_create("dlr-url");
    fm->dlr_mid = cfg_get(grp, octstr_imm("generic-param-dlr-mid"));
    if (fm->dlr_mid == NULL)
        fm->dlr_mid = octstr_create("dlr-mid");
    fm->flash = cfg_get(grp, octstr_imm("generic-param-flash"));
    if (fm->flash == NULL)
        fm->flash = octstr_create("flash");
    fm->mclass = cfg_get(grp, octstr_imm("generic-param-mclass"));
    if (fm->mclass == NULL)
        fm->mclass = octstr_create("mclass");
    fm->mwi = cfg_get(grp, octstr_imm("generic-param-mwi"));
    if (fm->mwi == NULL)
        fm->mwi = octstr_create("mwi");
    fm->coding = cfg_get(grp, octstr_imm("generic-param-coding"));
    if (fm->coding == NULL)
        fm->coding = octstr_create("coding");
    fm->validity = cfg_get(grp, octstr_imm("generic-param-validity"));
    if (fm->validity == NULL)
        fm->validity = octstr_create("validity");
    fm->deferred = cfg_get(grp, octstr_imm("generic-param-deferred"));
    if (fm->deferred == NULL)
        fm->deferred = octstr_create("deferred");
    fm->foreign_id = cfg_get(grp, octstr_imm("generic-param-foreign-id"));
    if (fm->foreign_id == NULL)
        fm->foreign_id = octstr_create("foreign-id");
    fm->meta_data = cfg_get(grp, octstr_imm("generic-param-meta-data"));
    if (fm->meta_data == NULL)
        fm->meta_data = octstr_create("meta-data");
    fm->message_sent = cfg_get(grp, octstr_imm("generic-message-sent"));
    if (fm->message_sent == NULL)
        fm->message_sent = octstr_create("Sent");
    /* both success and error uses HTTP_ACCEPTED to mimic former behaviour */
    if (cfg_get_integer(&fm->status_sent, grp, octstr_imm("generic-status-sent")) == -1) {
        fm->status_sent = HTTP_ACCEPTED;
    }
    if (cfg_get_integer(&fm->status_error, grp, octstr_imm("generic-status-error")) == -1) {
        fm->status_error = HTTP_ACCEPTED;
    }

    return fm;
}

generic_init()

static int generic_init ( SMSCConn *  conn, CfgGroup *  cfg  )

static

Definition at line 613 of file generic.c.

References cfg, cfg_get, conndata::data, smscconn::data, debug(), error(), generic_values::generic_foreign_id_regex, generic_get_field_map(), smscconn::id, generic_values::map, octstr_destroy(), octstr_get_cstr, octstr_imm(), octstr_search_char(), panic, generic_values::permfail_regex, generic_values::success_regex, generic_values::tempfail_regex, and warning().

{
    Octstr *os;
    ConnData *conndata = conn->data;
    struct generic_values *values;

    conndata->data = values = gw_malloc(sizeof(*values));
    /* reset */
    memset(conndata->data, 0, sizeof(*values));

    values->success_regex = values->permfail_regex = values->tempfail_regex = NULL;
    values->generic_foreign_id_regex = NULL;

    values->map = generic_get_field_map(cfg);

    /* pre-compile regex expressions */
    if ((os = cfg_get(cfg, octstr_imm("status-success-regex"))) != NULL) {
        if ((values->success_regex = gw_regex_comp(os, REG_EXTENDED|REG_NOSUB)) == NULL)
            error(0, "HTTP[%s]: Could not compile pattern '%s' defined for variable 'status-success-regex'",
                  octstr_get_cstr(conn->id), octstr_get_cstr(os));
        octstr_destroy(os);
    } else {
        /* we need at least the criteria for a successful sent */
        error(0, "HTTP[%s]: 'status-success-regex' required for generic http smsc",
              octstr_get_cstr(conn->id));
        return -1;
    }
    if ((os = cfg_get(cfg, octstr_imm("status-permfail-regex"))) != NULL) {
        if ((values->permfail_regex = gw_regex_comp(os, REG_EXTENDED|REG_NOSUB)) == NULL)
            panic(0, "Could not compile pattern '%s' defined for variable 'status-permfail-regex'", octstr_get_cstr(os));
        octstr_destroy(os);
    }
    if ((os = cfg_get(cfg, octstr_imm("status-tempfail-regex"))) != NULL) {
        if ((values->tempfail_regex = gw_regex_comp(os, REG_EXTENDED|REG_NOSUB)) == NULL)
            panic(0, "Could not compile pattern '%s' defined for variable 'status-tempfail-regex'", octstr_get_cstr(os));
        octstr_destroy(os);
    }
    if ((os = cfg_get(cfg, octstr_imm("generic-foreign-id-regex"))) != NULL) {
        if ((values->generic_foreign_id_regex = gw_regex_comp(os, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s' defined for variable 'generic-foreign-id-regex'", octstr_get_cstr(os));
        else {
            /* check quickly that at least 1 group seems to be defined in the regex */
            if (octstr_search_char(os, '(', 0) == -1 || octstr_search_char(os, ')', 0) == -1)
                warning(0, "HTTP[%s]: No group defined in pattern '%s' for variable 'generic-foreign-id-regex'", octstr_get_cstr(conn->id), octstr_get_cstr(os));
        }
        octstr_destroy(os);
    }

    debug("", 0, "generic init completed");

    return 0;
}

generic_parse_reply()

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

static

Definition at line 547 of file generic.c.

References bb_smscconn_send_failed(), bb_smscconn_sent(), conndata::data, smscconn::data, debug(), dlr_add(), DLR_IS_ENABLED_DEVICE, error(), generic_values::generic_foreign_id_regex, smscconn::id, msg, octstr_copy, octstr_create, octstr_destroy(), octstr_dump, octstr_duplicate, octstr_get_cstr, generic_values::permfail_regex, SMSCCONN_FAILED_MALFORMED, SMSCCONN_FAILED_REJECTED, SMSCCONN_FAILED_TEMPORARILY, generic_values::success_regex, generic_values::tempfail_regex, UUID_STR_LEN, uuid_unparse(), and warning().

{
    ConnData *conndata = conn->data;
    struct generic_values *values = conndata->data;
    regmatch_t pmatch[2];
    Octstr *msgid = NULL;

    /*
     * Our generic type checks only content on the HTTP response body.
     * We use the pre-compiled regex to match against the states.
     * This is the most generic criteria (at the moment).
     */
    if ((values->success_regex != NULL) &&
        (gw_regex_exec(values->success_regex, body, 0, NULL, 0) == 0)) {
        /* SMSC ACK... the message id should be in the body */

        /* add to our own DLR storage */
        if (DLR_IS_ENABLED_DEVICE(msg->sms.dlr_mask)) {
            /* directive 'generic-foreign-id-regex' is present, fetch the foreign ID */
            if ((values->generic_foreign_id_regex != NULL)) {
                if (gw_regex_exec(values->generic_foreign_id_regex, body, sizeof(pmatch) / sizeof(regmatch_t), pmatch, 0) == 0) {
                    if (pmatch[1].rm_so != -1 && pmatch[1].rm_eo != -1) {
                        msgid = octstr_copy(body, pmatch[1].rm_so, pmatch[1].rm_eo - pmatch[1].rm_so);
                        debug("smsc.http.generic", 0, "HTTP[%s]: Found foreign message id <%s> in body.",
                              octstr_get_cstr(conn->id), octstr_get_cstr(msgid));
                        dlr_add(conn->id, msgid, msg, 0);
                        octstr_destroy(msgid);
                    }
                }
                if (msgid == NULL)
                    warning(0, "HTTP[%s]: Can't get the foreign message id from the HTTP body.",
                            octstr_get_cstr(conn->id));
            } else {
                char id[UUID_STR_LEN + 1];
                /* use own own UUID as msg ID in the DLR storage */
                uuid_unparse(msg->sms.id, id);
                msgid = octstr_create(id);
                dlr_add(conn->id, msgid, msg, 0);
                octstr_destroy(msgid);
            }
        }
        bb_smscconn_sent(conn, msg, NULL);
    }
    else if ((values->permfail_regex != NULL) &&
        (gw_regex_exec(values->permfail_regex, body, 0, NULL, 0) == 0)) {
        error(0, "HTTP[%s]: Message not accepted.", octstr_get_cstr(conn->id));
        bb_smscconn_send_failed(conn, msg,
            SMSCCONN_FAILED_MALFORMED, octstr_duplicate(body));
    }
    else if ((values->tempfail_regex != NULL) &&
        (gw_regex_exec(values->tempfail_regex, body, 0, NULL, 0) == 0)) {
        warning(0, "HTTP[%s]: Message temporary not accepted, will retry.",
                octstr_get_cstr(conn->id));
        bb_smscconn_send_failed(conn, msg,
            SMSCCONN_FAILED_TEMPORARILY, octstr_duplicate(body));
    }
    else {
        error(0, "HTTP[%s]: Message was rejected. SMSC response was:",
              octstr_get_cstr(conn->id));
        octstr_dump(body, 0);
        bb_smscconn_send_failed(conn, msg,
            SMSCCONN_FAILED_REJECTED, octstr_create("REJECTED"));
    }
}

generic_receive_sms()

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

static

Definition at line 270 of file generic.c.

References account, fieldmap::account, conndata::alt_charset, bb_smscconn_receive(), fieldmap::binfo, charset, client(), fieldmap::coding, conndata::data, smscconn::data, debug(), fieldmap::deferred, fieldmap::dlr_err, dlr_find(), fieldmap::dlr_mask, fieldmap::dlr_mid, DLR_UNDEFINED, error(), fieldmap::flash, from, fieldmap::from, gwlist_create, http_cgi_variable(), http_destroy_headers(), http_header_add(), http_header_get_content_type(), http_send_reply(), smscconn::id, generic_values::map, MAX_SMS_OCTETS, fieldmap::mclass, fieldmap::message_sent, meta_data, fieldmap::meta_data, meta_data_set_value(), METADATA_DLR_GROUP, METADATA_DLR_GROUP_ERRORCODE, msg, msg_create, msg_destroy(), msg_duplicate(), fieldmap::mwi, octstr_case_compare(), octstr_compare(), octstr_create, octstr_destroy(), octstr_duplicate, octstr_get_char(), octstr_get_cstr, octstr_imm(), octstr_len(), parse_cgivars(), conndata::password, fieldmap::password, report_mo, sms_charset_processing(), SMS_PARAM_UNDEFINED, fieldmap::status_error, fieldmap::status_sent, fieldmap::text, text, fieldmap::to, type, fieldmap::udh, urltrans_fill_escape_codes(), conndata::use_post, conndata::username, fieldmap::username, fieldmap::validity, and warning().

{
    ConnData *conndata = conn->data;
    struct generic_values *values = conndata->data;
    struct fieldmap *fm = values->map;
    Octstr *user, *pass, *from, *to, *text, *udh, *account, *binfo, *meta_data;
    Octstr *dlrmid, *dlrerr;
    Octstr *tmp_string, *retmsg;
    int dlrmask;
    List *reply_headers;
    int ret, retstatus;

    dlrmask = SMS_PARAM_UNDEFINED;

    /* Parse for HTTP POST data */
    if (conndata->use_post && octstr_len(body) > 0) {
        Octstr *type, *charset;

        type = charset = NULL;
        http_header_get_content_type(headers, &type, &charset);
        if (octstr_case_compare(type, octstr_imm("application/x-www-form-urlencoded")) == 0) {
            parse_cgivars(cgivars, body);
        } else {
            warning(0, "HTTP[%s]: Received HTTP POST with wrong content-type `%s', should be `application/x-www-form-urlencoded'.",
                    octstr_get_cstr(conn->id), octstr_get_cstr(type));
        }
        octstr_destroy(type);
        octstr_destroy(charset);
    }

    /* Parse enough parameters to validate the request */
    user = http_cgi_variable(cgivars, octstr_get_cstr(fm->username));
    pass = http_cgi_variable(cgivars, octstr_get_cstr(fm->password));
    from = http_cgi_variable(cgivars, octstr_get_cstr(fm->from));
    to = http_cgi_variable(cgivars, octstr_get_cstr(fm->to));
    text = http_cgi_variable(cgivars, octstr_get_cstr(fm->text));
    udh = http_cgi_variable(cgivars, octstr_get_cstr(fm->udh));
    dlrmid = http_cgi_variable(cgivars, octstr_get_cstr(fm->dlr_mid));
    tmp_string = http_cgi_variable(cgivars, octstr_get_cstr(fm->dlr_mask));
    if (tmp_string) {
        sscanf(octstr_get_cstr(tmp_string),"%d", &dlrmask);
    }
    dlrerr = http_cgi_variable(cgivars, octstr_get_cstr(fm->dlr_err));

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

    if ((conndata->username != NULL && conndata->password != NULL) &&
        (user == NULL || pass == NULL ||
        octstr_compare(user, conndata->username) != 0 ||
        octstr_compare(pass, conndata->password) != 0)) {
        error(0, "HTTP[%s]: Authorization failure",
              octstr_get_cstr(conn->id));
        retmsg = octstr_create("Authorization failed for sendsms");
        retstatus = fm->status_error;
    } else if (dlrmask != DLR_UNDEFINED && dlrmid != NULL) {
        /* we got a DLR, and we don't require additional values */
        Msg *dlrmsg;

        dlrmsg = dlr_find(conn->id,
            dlrmid, /* message id */
            to, /* destination */
            dlrmask, 0);

        if (dlrmsg != NULL) {
            dlrmsg->sms.sms_type = report_mo;
            dlrmsg->sms.msgdata = octstr_duplicate(text);
            dlrmsg->sms.account = octstr_duplicate(conndata->username);

            debug("smsc.http.generic", 0, "HTTP[%s]: Received DLR for DLR-URL <%s>",
                  octstr_get_cstr(conn->id), octstr_get_cstr(dlrmsg->sms.dlr_url));

            if (dlrerr != NULL) {
                /* pass errorcode as is */
                if (dlrmsg->sms.meta_data == NULL)
                    dlrmsg->sms.meta_data = octstr_create("");

                meta_data_set_value(dlrmsg->sms.meta_data, METADATA_DLR_GROUP,
                                    octstr_imm(METADATA_DLR_GROUP_ERRORCODE), dlrerr, 1);
            }

            Msg *resp = msg_duplicate(dlrmsg);
            ret = bb_smscconn_receive(conn, dlrmsg);
            if (ret == -1) {
                retmsg = octstr_create("Not accepted");
                retstatus = fm->status_error;
            } else {
                retmsg = urltrans_fill_escape_codes(fm->message_sent, resp);
                retstatus = fm->status_sent;
            }
            msg_destroy(resp);
        } 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(dlrmid),
                  octstr_get_cstr(to), dlrmask);
            retmsg = octstr_create("Unknown DLR, not accepted");
            retstatus = fm->status_error;
        }
    } else if (from == NULL || to == NULL || text == NULL) {
        error(0, "HTTP[%s]: Insufficient args",
              octstr_get_cstr(conn->id));
        retmsg = octstr_create("Insufficient args, rejected");
        retstatus = fm->status_error;
    } else if (udh != NULL && (octstr_len(udh) != octstr_get_char(udh, 0) + 1)) {
        error(0, "HTTP[%s]: UDH field misformed, rejected",
              octstr_get_cstr(conn->id));
        retmsg = octstr_create("UDH field misformed, rejected");
        retstatus = fm->status_error;
    } else if (udh != NULL && octstr_len(udh) > MAX_SMS_OCTETS) {
        error(0, "HTTP[%s]: UDH field is too long, rejected",
              octstr_get_cstr(conn->id));
        retmsg = octstr_create("UDH field is too long, rejected");
        retstatus = fm->status_error;
    }
    else {
        /* we got a normal MO SMS */
        Msg *msg;
        msg = msg_create(sms);

        /* Parse the rest of the parameters */
        tmp_string = http_cgi_variable(cgivars, octstr_get_cstr(fm->flash));
        if (tmp_string) {
            sscanf(octstr_get_cstr(tmp_string),"%ld", &msg->sms.mclass);
        }
        tmp_string = http_cgi_variable(cgivars, octstr_get_cstr(fm->mclass));
        if (tmp_string) {
            sscanf(octstr_get_cstr(tmp_string),"%ld", &msg->sms.mclass);
        }
        tmp_string = http_cgi_variable(cgivars, octstr_get_cstr(fm->mwi));
        if (tmp_string) {
            sscanf(octstr_get_cstr(tmp_string),"%ld", &msg->sms.mwi);
        }
        tmp_string = http_cgi_variable(cgivars, octstr_get_cstr(fm->coding));
        if (tmp_string) {
            sscanf(octstr_get_cstr(tmp_string),"%ld", &msg->sms.coding);
        }
        tmp_string = http_cgi_variable(cgivars, octstr_get_cstr(fm->validity));
        if (tmp_string) {
            sscanf(octstr_get_cstr(tmp_string),"%ld", &msg->sms.validity);
            msg->sms.validity = time(NULL) + msg->sms.validity * 60;
        }
        tmp_string = http_cgi_variable(cgivars, octstr_get_cstr(fm->deferred));
        if (tmp_string) {
            sscanf(octstr_get_cstr(tmp_string),"%ld", &msg->sms.deferred);
            msg->sms.deferred = time(NULL) + msg->sms.deferred * 60;
        }
        account = http_cgi_variable(cgivars, octstr_get_cstr(fm->account));
        binfo = http_cgi_variable(cgivars, octstr_get_cstr(fm->binfo));
        meta_data = http_cgi_variable(cgivars, octstr_get_cstr(fm->meta_data));

        debug("smsc.http.generic", 0, "HTTP[%s]: Constructing new SMS",
              octstr_get_cstr(conn->id));

        msg->sms.msgdata = octstr_duplicate(text);

        /* re-encode content if necessary */
        if (conndata->alt_charset &&
                sms_charset_processing(conndata->alt_charset, msg->sms.msgdata, msg->sms.coding) == -1) {
            error(0, "HTTP[%s]: Charset or body misformed, will leave it as it is.",
                  octstr_get_cstr(conn->id));
        }

        msg->sms.service = octstr_duplicate(user);
        msg->sms.sender = octstr_duplicate(from);
        msg->sms.receiver = octstr_duplicate(to);
        msg->sms.udhdata = octstr_duplicate(udh);
        msg->sms.smsc_id = octstr_duplicate(conn->id);
        msg->sms.time = time(NULL);
        msg->sms.account = octstr_duplicate(account);
        msg->sms.binfo = octstr_duplicate(binfo);
        msg->sms.meta_data = octstr_duplicate(meta_data);
        Msg *resp = msg_duplicate(msg);
        ret = bb_smscconn_receive(conn, msg);
        if (ret == -1) {
            retmsg = octstr_create("Not accepted");
            retstatus = fm->status_error;
        } else {
            retmsg = urltrans_fill_escape_codes(fm->message_sent, resp);
            retstatus = fm->status_sent;
        }
        msg_destroy(resp);
    }

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

    octstr_destroy(retmsg);
    http_destroy_headers(reply_headers);
}

generic_send_sms()

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

static

Definition at line 497 of file generic.c.

References conndata::alt_charset, content_type, convert_charset(), smscconn::data, debug(), gwlist_create, HTTPURLParse::host, http_destroy_headers(), http_header_add(), HTTP_METHOD_GET, HTTP_METHOD_POST, conndata::http_ref, http_start_request(), http_urlparse_destroy(), smscconn::id, octstr_destroy(), octstr_format(), octstr_get_cstr, parse_url(), HTTPURLParse::path, HTTPURLParse::port, HTTPURLParse::query, HTTPURLParse::scheme, conndata::send_url, url, urltrans_fill_escape_codes(), and conndata::use_post.

{
    ConnData *conndata = conn->data;
    Octstr *url = NULL;
    List *headers;
    HTTPURLParse *p;
    Octstr *content_type = NULL;

    /* Transcode payload if required. */
    if (conndata->alt_charset) {
        convert_charset(sms, conndata->alt_charset, &content_type);
    }
    else if (conndata->use_post) {
        /* set content-type for HTTP POST */
        content_type = octstr_format("application/x-www-form-urlencoded");
    }

    /* We use the escape code population function from our
     * URLTranslation module to fill in the appropriate values
     * into the URL scheme. */
    url = urltrans_fill_escape_codes(conndata->send_url, sms);

    headers = gwlist_create();

    /* Split now in HTTP GET or HTTP POST handling. */
    if (conndata->use_post && (p = parse_url(url)) != NULL) {
        octstr_destroy(url);
        url = octstr_format("%s%s:%ld%s",
                octstr_get_cstr(p->scheme), octstr_get_cstr(p->host),
                p->port, octstr_get_cstr(p->path));
        debug("smsc.http.generic", 0, "HTTP[%s]: Sending POST request <%s>",
              octstr_get_cstr(conn->id), octstr_get_cstr(url));
        http_header_add(headers, "Content-Type", octstr_get_cstr(content_type));
        http_start_request(conndata->http_ref, HTTP_METHOD_POST, url, headers,
                           p->query, 0, sms, NULL);
        http_urlparse_destroy(p);
    } else {
        debug("smsc.http.generic", 0, "HTTP[%s]: Sending GET request <%s>",
              octstr_get_cstr(conn->id), octstr_get_cstr(url));
        http_start_request(conndata->http_ref, HTTP_METHOD_GET, url, headers,
                           NULL, 0, sms, NULL);
    }

    octstr_destroy(url);
    octstr_destroy(content_type);
    http_destroy_headers(headers);

    return 0;
}

Variable Documentation

smsc_http_generic_callback

struct smsc_http_fn_callbacks smsc_http_generic_callback

Initial value:

= {
        .init = generic_init,
        .destroy = generic_destroy,
        .send_sms = generic_send_sms,
        .parse_reply = generic_parse_reply,
        .receive_sms = generic_receive_sms,
}

Definition at line 693 of file generic.c.