bb_smscconn_cb.h File Reference

#include "msg.h"
#include "smscconn.h"

Go to the source code of this file.

Enumerations
enum	{   SMSCCONN_SUCCESS = 0, SMSCCONN_QUEUED, SMSCCONN_FAILED_SHUTDOWN, SMSCCONN_FAILED_REJECTED,   SMSCCONN_FAILED_MALFORMED, SMSCCONN_FAILED_TEMPORARILY, SMSCCONN_FAILED_DISCARDED, SMSCCONN_FAILED_QFULL,   SMSCCONN_FAILED_EXPIRED }

Functions
void	bb_smscconn_ready (SMSCConn *conn)
void	bb_smscconn_connected (SMSCConn *conn)
void	bb_smscconn_killed (void)
void	bb_smscconn_sent (SMSCConn *conn, Msg *sms, Octstr *reply)
void	bb_smscconn_send_failed (SMSCConn *conn, Msg *sms, int reason, Octstr *reply)
long	bb_smscconn_receive (SMSCConn *conn, Msg *sms)

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
SMSCCONN_SUCCESS
SMSCCONN_QUEUED
SMSCCONN_FAILED_SHUTDOWN
SMSCCONN_FAILED_REJECTED
SMSCCONN_FAILED_MALFORMED
SMSCCONN_FAILED_TEMPORARILY
SMSCCONN_FAILED_DISCARDED
SMSCCONN_FAILED_QFULL
SMSCCONN_FAILED_EXPIRED

Definition at line 107 of file bb_smscconn_cb.h.

     {
    SMSCCONN_SUCCESS = 0,
    SMSCCONN_QUEUED,
    SMSCCONN_FAILED_SHUTDOWN,
    SMSCCONN_FAILED_REJECTED,
    SMSCCONN_FAILED_MALFORMED,
    SMSCCONN_FAILED_TEMPORARILY,
    SMSCCONN_FAILED_DISCARDED,
    SMSCCONN_FAILED_QFULL,
    SMSCCONN_FAILED_EXPIRED
};

Function Documentation

bb_smscconn_connected()

void bb_smscconn_connected

(

SMSCConn *

conn

)

Definition at line 192 of file bb_smscconn.c.

References gwthread_wakeup(), and router_thread.

Referenced by at2_device_thread(), cgw_open_send_connection(), cgw_sender(), fake_listener(), handle_pdu(), httpsmsc_send_cb(), io_thread(), open_send_connection(), reconnect(), and soap_listener().

{
    if (router_thread >= 0)
        gwthread_wakeup(router_thread);
}

bb_smscconn_killed()

void bb_smscconn_killed

(

void

)

Definition at line 199 of file bb_smscconn.c.

References flow_threads, gwlist_remove_producer(), and incoming_sms.

Referenced by at2_device_thread(), cgw_sender(), cimd2_shutdown_cb(), emi2_sender(), fake_listener(), httpsmsc_receiver(), httpsmsc_sender(), io_thread(), oisd_shutdown_cb(), shutdown_cb(), soap_listener(), and wrapper_sender().

{
    /* NOTE: after status has been set to SMSCCONN_DEAD, bearerbox
     *   is free to release/delete 'conn'
     */
    gwlist_remove_producer(incoming_sms);
    gwlist_remove_producer(flow_threads);
}

bb_smscconn_ready()

void bb_smscconn_ready

(

SMSCConn *

conn

)

Definition at line 185 of file bb_smscconn.c.

References flow_threads, gwlist_add_producer(), and incoming_sms.

Referenced by smscconn_create().

{
    gwlist_add_producer(flow_threads);
    gwlist_add_producer(incoming_sms);
}

bb_smscconn_receive()

long bb_smscconn_receive	(	SMSCConn *	conn,
		Msg *	sms
	)

Definition at line 477 of file bb_smscconn.c.

References bb_alog_sms(), bb_smscconn_receive_internal(), black_list_receiver, black_list_receiver_regex, black_list_sender, black_list_sender_regex, concat_complete, concat_error, concat_handling_check_and_handle(), concat_none, concat_pending, counter_increase(), gw_rwlock_rdlock(), gw_rwlock_unlock(), handle_concatenated_mo, smscconn::id, incoming_sms_counter, incoming_sms_load, smscconn::incoming_sms_load, info(), load_increase, mo, msg_destroy(), normalize_number(), numhash_find_number(), octstr_create, octstr_get_cstr, panic, smscconn::received, report_mo, SMSCCONN_FAILED_REJECTED, SMSCCONN_FAILED_TEMPORARILY, SMSCCONN_SUCCESS, store_save, unified_prefix, smscconn::unified_prefix, white_black_list_lock, white_list_receiver, white_list_receiver_regex, white_list_sender, and white_list_sender_regex.

Referenced by at2_wait_modem_command(), bb_smscconn_send_failed(), bb_smscconn_sent(), brunet_receive_sms(), cgw_handle_op(), clickatell_receive_sms(), generic_receive_sms(), handle_operation(), handle_pdu(), io_thread(), kannel_receive_sms(), main_connection_loop(), msg_cb(), msg_to_bb(), soap_parse_dlr(), soap_parse_mo(), wrapper_receiver(), and xidris_receive_sms().

{
    char *uf;
    int ret;

    /*
     * first check whether msgdata data is NULL and set it to empty
     *  because seems too much kannels parts rely on msgdata not to be NULL.
     */
    if (sms->sms.msgdata == NULL)
        sms->sms.msgdata = octstr_create("");

    /*
     * First normalize in smsc level and then on global level.
     * In outbound direction it's vise versa, hence first global then smsc.
     */
    uf = (conn && conn->unified_prefix) ? octstr_get_cstr(conn->unified_prefix) : NULL;
    normalize_number(uf, &(sms->sms.sender));

    uf = unified_prefix ? octstr_get_cstr(unified_prefix) : NULL;
    normalize_number(uf, &(sms->sms.sender));

    /*
     * We don't perform white/black-listing for DLRs.
     * Fix sms type if not set already.
     */
    if (sms->sms.sms_type != report_mo) {
        sms->sms.sms_type = mo;

        gw_rwlock_rdlock(&white_black_list_lock);
        if (white_list_sender &&
                numhash_find_number(white_list_sender, sms->sms.sender) < 1) {
            gw_rwlock_unlock(&white_black_list_lock);
            info(0, "Number <%s> is not in white-list-sender, message discarded",
                 octstr_get_cstr(sms->sms.sender));
            bb_alog_sms(conn, sms, "REJECTED Receive SMS - not white-listed SMS");
            msg_destroy(sms);
            return SMSCCONN_FAILED_REJECTED;
        }

        if (white_list_sender_regex &&
                gw_regex_match_pre(white_list_sender_regex, sms->sms.sender) == 0) {
            gw_rwlock_unlock(&white_black_list_lock);
            info(0, "Number <%s> is not in white-list-sender, message discarded",
                 octstr_get_cstr(sms->sms.sender));
            bb_alog_sms(conn, sms, "REJECTED Receive SMS - not white-regex-listed SMS");
            msg_destroy(sms);
            return SMSCCONN_FAILED_REJECTED;
        }

        if (black_list_sender &&
                numhash_find_number(black_list_sender, sms->sms.sender) == 1) {
            gw_rwlock_unlock(&white_black_list_lock);
            info(0, "Number <%s> is in black-list-sender, message discarded",
                 octstr_get_cstr(sms->sms.sender));
            bb_alog_sms(conn, sms, "REJECTED Receive SMS - black-listed SMS");
            msg_destroy(sms);
            return SMSCCONN_FAILED_REJECTED;
        }

        if (black_list_sender_regex &&
                gw_regex_match_pre(black_list_sender_regex, sms->sms.sender) != 0) {
            gw_rwlock_unlock(&white_black_list_lock);
            info(0, "Number <%s> is in black-list-sender, message discarded",
                 octstr_get_cstr(sms->sms.sender));
            bb_alog_sms(conn, sms, "REJECTED Receive SMS - black-regex-listed SMS");
            msg_destroy(sms);
            return SMSCCONN_FAILED_REJECTED;
        }

        if (white_list_receiver &&
                numhash_find_number(white_list_receiver, sms->sms.receiver) < 1) {
            gw_rwlock_unlock(&white_black_list_lock);
            info(0, "Number <%s> is not in white-list-receiver, message discarded",
                 octstr_get_cstr(sms->sms.receiver));
            bb_alog_sms(conn, sms, "REJECTED Receive SMS - not white-listed SMS");
            msg_destroy(sms);
            return SMSCCONN_FAILED_REJECTED;
        }

        if (white_list_receiver_regex &&
                gw_regex_match_pre(white_list_receiver_regex, sms->sms.receiver) == 0) {
            gw_rwlock_unlock(&white_black_list_lock);
            info(0, "Number <%s> is not in white-list-receiver, message discarded",
                 octstr_get_cstr(sms->sms.receiver));
            bb_alog_sms(conn, sms, "REJECTED Receive SMS - not white-regex-listed SMS");
            msg_destroy(sms);
            return SMSCCONN_FAILED_REJECTED;
        }

        if (black_list_receiver &&
                numhash_find_number(black_list_receiver, sms->sms.receiver) == 1) {
            gw_rwlock_unlock(&white_black_list_lock);
            info(0, "Number <%s> is in black-list-receiver, message discarded",
                 octstr_get_cstr(sms->sms.receiver));
            bb_alog_sms(conn, sms, "REJECTED Receive SMS - black-listed SMS");
            msg_destroy(sms);
            return SMSCCONN_FAILED_REJECTED;
        }

        if (black_list_receiver_regex &&
                gw_regex_match_pre(black_list_receiver_regex, sms->sms.receiver) != 0) {
            gw_rwlock_unlock(&white_black_list_lock);
            info(0, "Number <%s> is in black-list-receiver, message discarded",
                 octstr_get_cstr(sms->sms.receiver));
            bb_alog_sms(conn, sms, "REJECTED Receive SMS - black-regex-listed SMS");
            msg_destroy(sms);
            return SMSCCONN_FAILED_REJECTED;
        }
        gw_rwlock_unlock(&white_black_list_lock);
    }

    /* write to store (if enabled) */
    if (store_save(sms) == -1) {
        msg_destroy(sms);
        return SMSCCONN_FAILED_TEMPORARILY;
    }

    /* Before routing to some box or re-routing, do concatenation handling
     * and replace copy as such.
     */
    if (handle_concatenated_mo && sms->sms.sms_type == mo) {
        ret = concat_handling_check_and_handle(&sms, (conn ? conn->id : NULL));
        switch(ret) {
        case concat_pending:
            counter_increase(incoming_sms_counter); /* ?? */
            load_increase(incoming_sms_load);
            if (conn != NULL) {
                counter_increase(conn->received);
                load_increase(conn->incoming_sms_load);
            }
            return SMSCCONN_SUCCESS;
        case concat_complete:
            /* Combined sms received! save new one since it is now combined. */
            break;
        case concat_error:
            /* failed to save, go away. */
            msg_destroy(sms);
            return SMSCCONN_FAILED_TEMPORARILY;
        case concat_none:
            break;
        default:
            panic(0, "Internal error: Unhandled concat result.");
            break;
        }
    }

    return bb_smscconn_receive_internal(conn, sms);
}

bb_smscconn_send_failed()

void bb_smscconn_send_failed	(	SMSCConn *	conn,
		Msg *	sms,
		int	reason,
		Octstr *	reply
	)

Definition at line 329 of file bb_smscconn.c.

References ack_failed, bb_alog_sms(), bb_smscconn_receive(), bb_smscconn_send_failed(), counter_increase(), create_dlr_from_msg(), DLR_IS_FAIL, DLR_IS_SMSC_FAIL, DLR_SMSC_FAIL, smscconn::failed, gwlist_produce(), handle_split(), smscconn::id, msg_destroy(), smscconn::name, octstr_create, octstr_destroy(), octstr_insert_data(), outgoing_sms, reply(), report_mt, sms_resend_retry, SMSCCONN_ACTIVE, SMSCCONN_FAILED_DISCARDED, SMSCCONN_FAILED_EXPIRED, SMSCCONN_FAILED_REJECTED, SMSCCONN_FAILED_SHUTDOWN, SMSCCONN_FAILED_TEMPORARILY, smscconn_status(), store_save_ack, and warning().

Referenced by at2_send_one_message(), at2_shutdown_cb(), bb_smscconn_send_failed(), brunet_parse_reply(), cgw_handle_op(), cgw_open_send_connection(), cgw_sender(), cgw_shutdown_cb(), cimd2_shutdown_cb(), cimd2_submit_msg(), clickatell_parse_reply(), do_queue_cleanup(), emi2_handle_smscreq(), emi2_sender(), fake_listener(), generic_parse_reply(), handle_pdu(), handle_split(), httpsmsc_send_cb(), httpsmsc_sender(), io_thread(), kannel_parse_reply(), main_connection_loop(), oisd_shutdown_cb(), oisd_submit_msg(), open_send_connection(), reconnect(), send_messages(), shutdown_cb(), sms_send(), smsc2_rout(), soap_listener(), soap_read_response(), soap_send_loop(), soap_shutdown_cb(), wrapper_sender(), wrapper_shutdown(), and xidris_parse_reply().

{
    if (sms->sms.split_parts != NULL) {
        handle_split(conn, sms, reason, reply);
        return;
    }
    
    switch (reason) {
    case SMSCCONN_FAILED_TEMPORARILY:
        /*
         * Check if SMSC link alive and if so increase resend_try and set resend_time.
         * If SMSC link is not active don't increase resend_try and don't set resend_time
         * because we don't want to delay messages due to a broken connection.
         */
       if (conn && smscconn_status(conn) == SMSCCONN_ACTIVE) {
            /*
             * Check if sms_resend_retry set and this msg has exceeded a limit also
             * honor "single shot" with sms_resend_retry set to zero.
             */
           if (sms_resend_retry >= 0 && sms->sms.resend_try >= sms_resend_retry) {
               warning(0, "Maximum retries for message exceeded, discarding it!");
               bb_smscconn_send_failed(NULL, sms, SMSCCONN_FAILED_DISCARDED, 
                                       octstr_create("Retries Exceeded"));
               break;
           }
           sms->sms.resend_try = (sms->sms.resend_try > 0 ? sms->sms.resend_try + 1 : 1);
           time(&sms->sms.resend_time);
       }
       gwlist_produce(outgoing_sms, sms);
       break;
       
    case SMSCCONN_FAILED_SHUTDOWN:
        gwlist_produce(outgoing_sms, sms);
        break;

    default:
        /* write NACK to store file */
        store_save_ack(sms, ack_failed);

        if (conn) counter_increase(conn->failed);
        if (reason == SMSCCONN_FAILED_DISCARDED) {
            if (sms->sms.sms_type != report_mt)
                bb_alog_sms(conn, sms, "DISCARDED SMS");
            else
                bb_alog_sms(conn, sms, "DISCARDED DLR");
        }
        else if (reason == SMSCCONN_FAILED_EXPIRED) {
            if (sms->sms.sms_type != report_mt)
                bb_alog_sms(conn, sms, "EXPIRED SMS");
            else
                bb_alog_sms(conn, sms, "EXPIRED DLR");
        }
        else if (reason == SMSCCONN_FAILED_REJECTED) {
            if (sms->sms.sms_type != report_mt)
                bb_alog_sms(conn, sms, "REJECTED Send SMS");
            else
                bb_alog_sms(conn, sms, "REJECTED Send DLR");
        }
        else {
            if (sms->sms.sms_type != report_mt)
                bb_alog_sms(conn, sms, "FAILED Send SMS");
            else
                bb_alog_sms(conn, sms, "FAILED Send DLR");
        }

        /* generate relay confirmancy message */
        if (DLR_IS_SMSC_FAIL(sms->sms.dlr_mask) || DLR_IS_FAIL(sms->sms.dlr_mask)) {
            Msg *dlrmsg;

            if (reply == NULL)
                reply = octstr_create("");

            octstr_insert_data(reply, 0, "NACK/", 5);
            dlrmsg = create_dlr_from_msg((conn ? (conn->id?conn->id:conn->name) : NULL), sms,
                                         reply, DLR_SMSC_FAIL);
            if (dlrmsg != NULL) {
                bb_smscconn_receive(conn, dlrmsg);
            }
        }

        msg_destroy(sms);
        break;
    }

    octstr_destroy(reply);
}

bb_smscconn_sent()

void bb_smscconn_sent	(	SMSCConn *	conn,
		Msg *	sms,
		Octstr *	reply
	)

Definition at line 281 of file bb_smscconn.c.

References ack_success, bb_alog_sms(), bb_smscconn_receive(), counter_increase(), create_dlr_from_msg(), DLR_IS_SMSC_SUCCESS, DLR_SMSC_SUCCESS, handle_split(), smscconn::id, load_increase, msg_destroy(), smscconn::name, octstr_create, octstr_destroy(), octstr_insert_data(), outgoing_dlr_counter, outgoing_dlr_load, smscconn::outgoing_dlr_load, outgoing_sms_counter, outgoing_sms_load, smscconn::outgoing_sms_load, reply(), report_mt, smscconn::sent, smscconn::sent_dlr, SMSCCONN_SUCCESS, and store_save_ack.

Referenced by at2_send_one_message(), brunet_parse_reply(), cgw_handle_op(), cimd2_submit_msg(), clickatell_parse_reply(), emi2_handle_smscreq(), generic_parse_reply(), handle_pdu(), handle_split(), kannel_parse_reply(), main_connection_loop(), msg_cb(), oisd_submit_msg(), sms_send(), soap_read_response(), and xidris_parse_reply().

{
    if (sms->sms.split_parts != NULL) {
        handle_split(conn, sms, SMSCCONN_SUCCESS, reply);
        return;
    }

    /* write ACK to store file */
    store_save_ack(sms, ack_success);

    if (sms->sms.sms_type != report_mt) {
        bb_alog_sms(conn, sms, "Sent SMS");
        counter_increase(outgoing_sms_counter);
        load_increase(outgoing_sms_load);
        if (conn != NULL) {
            counter_increase(conn->sent);
            load_increase(conn->outgoing_sms_load);
        }
    } else {
        bb_alog_sms(conn, sms, "Sent DLR");
        counter_increase(outgoing_dlr_counter);
        load_increase(outgoing_dlr_load);
        if (conn != NULL) {
            counter_increase(conn->sent_dlr);
            load_increase(conn->outgoing_dlr_load);
        }
    }

    /* generate relay confirmancy message */
    if (DLR_IS_SMSC_SUCCESS(sms->sms.dlr_mask)) {
        Msg *dlrmsg;

    if (reply == NULL)
        reply = octstr_create("");

    octstr_insert_data(reply, 0, "ACK/", 4);
        dlrmsg = create_dlr_from_msg((conn->id?conn->id:conn->name), sms,
                    reply, DLR_SMSC_SUCCESS);
        if (dlrmsg != NULL) {
            bb_smscconn_receive(conn, dlrmsg);
        }
    }

    msg_destroy(sms);
    octstr_destroy(reply);
}