smsc_http.c File Reference

#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
#include <limits.h>
#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.

Macros
#define	DEFAULT_CHARSET   "UTF-8"
#define	DEFAULT_UCS2_CHARSET   "UTF-16BE"

Functions
static void	conndata_destroy (ConnData *conndata)
static void	httpsmsc_receiver (void *arg)
static void	httpsmsc_sender (void *arg)
static void	httpsmsc_send_cb (void *arg)
static int	httpsmsc_send (SMSCConn *conn, Msg *msg)
static long	httpsmsc_queued (SMSCConn *conn)
static int	httpsmsc_shutdown (SMSCConn *conn, int finish_sending)
int	smsc_http_create (SMSCConn *conn, CfgGroup *cfg)

Macro Definition Documentation

DEFAULT_CHARSET

#define DEFAULT_CHARSET   "UTF-8"

Definition at line 133 of file smsc_http.c.

Referenced by httpsmsc_send().

DEFAULT_UCS2_CHARSET

#define DEFAULT_UCS2_CHARSET   "UTF-16BE"

Definition at line 134 of file smsc_http.c.

Referenced by httpsmsc_send().

Function Documentation

conndata_destroy()

static void conndata_destroy ( ConnData *  conndata )

static

Definition at line 136 of file smsc_http.c.

References conndata::allow_ip, conndata::alt_charset, counter_destroy(), conndata::dlr_url, gwlist_destroy(), http_caller_destroy(), conndata::http_ref, conndata::max_pending_sends, conndata::msg_to_send, octstr_destroy(), conndata::open_sends, conndata::password, semaphore_destroy(), conndata::send_url, conndata::system_id, and conndata::username.

Referenced by httpsmsc_receiver(), httpsmsc_sender(), and smsc_http_create().

{
    if (conndata == NULL)
        return;
    if (conndata->http_ref)
        http_caller_destroy(conndata->http_ref);
    octstr_destroy(conndata->allow_ip);
    octstr_destroy(conndata->send_url);
    octstr_destroy(conndata->dlr_url);
    octstr_destroy(conndata->username);
    octstr_destroy(conndata->password);
    octstr_destroy(conndata->system_id);
    octstr_destroy(conndata->alt_charset);
    counter_destroy(conndata->open_sends);
    gwlist_destroy(conndata->msg_to_send, NULL);
    if (conndata->max_pending_sends)
        semaphore_destroy(conndata->max_pending_sends);

    gw_free(conndata);
}

httpsmsc_queued()

static long httpsmsc_queued ( SMSCConn *  conn )

static

Definition at line 450 of file smsc_http.c.

References smscconn::data, gwlist_len(), smscconn::load, conndata::msg_to_send, SMSCCONN_DEAD, and smscconn::status.

Referenced by smsc_http_create().

{
    ConnData *conndata = conn->data;

    conn->load = (conndata ? (conn->status != SMSCCONN_DEAD ?
            gwlist_len(conndata->msg_to_send) : 0) : 0);

    return conn->load;
}

httpsmsc_receiver()

static void httpsmsc_receiver ( void *  arg )

static

Definition at line 161 of file smsc_http.c.

References conndata::allow_ip, bb_smscconn_killed(), conndata::callbacks, client(), conndata_destroy(), connect_denied(), counter_value(), smscconn::data, debug(), smsc_http_fn_callbacks::destroy, smscconn::flow_mutex, gwthread_join(), gwthread_wakeup(), http_accept_request(), http_caller_signal_shutdown(), http_cgivar_dump_into(), http_close_client(), http_close_port(), http_destroy_cgiargs(), http_destroy_headers(), conndata::http_ref, smscconn::id, info(), smscconn::log_idx, log_thread_to(), mutex_lock, mutex_unlock, octstr_append_char(), octstr_destroy(), octstr_get_cstr, conndata::open_sends, conndata::port, smsc_http_fn_callbacks::receive_sms, conndata::send_cb_thread, conndata::sender_thread, conndata::shutdown, SMSCCONN_DEAD, smscconn::status, and url.

Referenced by smsc_http_create().

{
    SMSCConn *conn = arg;
    ConnData *conndata = conn->data;
    HTTPClient *client;
    Octstr *ip, *url, *body;
    List *headers, *cgivars;

    /* Make sure we log into our own log-file if defined */
    log_thread_to(conn->log_idx);

    while (conndata->shutdown == 0) {
        /* reset */
        ip = url = body = NULL;
        headers = cgivars = NULL;

        /* XXX if conn->is_stopped, do not receive new messages.. */

        client = http_accept_request(conndata->port, &ip, &url,
                                     &headers, &body, &cgivars);
        if (client == NULL)
            break;

        if (cgivars != NULL) {
            octstr_append_char(url, '?');
            http_cgivar_dump_into(cgivars, url);
        }

        debug("smsc.http", 0, "HTTP[%s]: Got request `%s'",
              octstr_get_cstr(conn->id), octstr_get_cstr(url));

        if (connect_denied(conndata->allow_ip, ip)) {
            info(0, "HTTP[%s]: Connection `%s' tried from denied "
                    "host %s, ignored", octstr_get_cstr(conn->id),
                    octstr_get_cstr(url), octstr_get_cstr(ip));
            http_close_client(client);
        } else
            conndata->callbacks->receive_sms(conn, client, headers, body, cgivars);

        debug("smsc.http", 0, "HTTP[%s]: Destroying client information",
              octstr_get_cstr(conn->id));
        octstr_destroy(url);
        octstr_destroy(ip);
        octstr_destroy(body);
        http_destroy_headers(headers);
        http_destroy_cgiargs(cgivars);
    }
    debug("smsc.http", 0, "HTTP[%s]: httpsmsc_receiver dying",
          octstr_get_cstr(conn->id));

    conndata->shutdown = 1;
    http_close_port(conndata->port);

    /* unblock http_receive_result() if there are no open sends */
    if (counter_value(conndata->open_sends) == 0)
        http_caller_signal_shutdown(conndata->http_ref);

    if (conndata->sender_thread != -1) {
        gwthread_wakeup(conndata->sender_thread);
        gwthread_join(conndata->sender_thread);
    }
    if (conndata->send_cb_thread != -1) {
        gwthread_wakeup(conndata->send_cb_thread);
        gwthread_join(conndata->send_cb_thread);
    }

    mutex_lock(conn->flow_mutex);
    conn->status = SMSCCONN_DEAD;
    mutex_unlock(conn->flow_mutex);

    if (conndata->callbacks != NULL && conndata->callbacks->destroy != NULL)
        conndata->callbacks->destroy(conn);
    conn->data = NULL;
    conndata_destroy(conndata);
    bb_smscconn_killed();
}

httpsmsc_send()

static int httpsmsc_send ( SMSCConn *  conn, Msg *  msg  )

static

Definition at line 402 of file smsc_http.c.

References conndata::alt_charset, conndata::callbacks, charset_convert(), smscconn::data, DC_7BIT, DC_UCS2, DC_UNDEF, DEFAULT_CHARSET, DEFAULT_UCS2_CHARSET, error(), gwlist_produce(), msg, msg_duplicate(), conndata::msg_to_send, octstr_get_cstr, and smsc_http_fn_callbacks::send_sms.

Referenced by smsc_http_create().

{
    ConnData *conndata = conn->data;
    Msg *sms;


    /* don't crash if no send_sms handle defined */
    if (!conndata || !conndata->callbacks->send_sms)
        return -1;

    sms = msg_duplicate(msg);
    /* convert character encoding if required */
    if (conndata->alt_charset) {
        /*
         * Converted now to the target character set based on the
         * one we got in the msg, which is either UTF-8 (our normal
         * inter-box encoding), but may also be UCS-2, so beware.
         * In addition, IF we convert to an "extra" encoding here
         * we also revert the .coding vaue to DC_UNDEF, in order
         * that all API specific code doesn't indicate an encoding
         * which is no longer inside the payload here.
         */
        if (sms->sms.coding == DC_7BIT) {
            if (charset_convert(sms->sms.msgdata, DEFAULT_CHARSET,
                    octstr_get_cstr(conndata->alt_charset)) == 0) {
                sms->sms.coding = DC_UNDEF;
            } else {
                error(0, "Failed to convert msgdata from charset <%s> to <%s>, will send as is.",
                         DEFAULT_CHARSET, octstr_get_cstr(conndata->alt_charset));
            }
        }
        else if (sms->sms.coding == DC_UCS2) {
            if (charset_convert(sms->sms.msgdata, DEFAULT_UCS2_CHARSET,
                    octstr_get_cstr(conndata->alt_charset)) == 0) {
               sms->sms.coding = DC_UNDEF;
            } else {
                error(0, "Failed to convert msgdata from charset <%s> to <%s>, will send as is.",
                        DEFAULT_UCS2_CHARSET, octstr_get_cstr(conndata->alt_charset));
            }
        }
    }

    gwlist_produce(conndata->msg_to_send, sms);

    return 0;
}

httpsmsc_send_cb()

static void httpsmsc_send_cb ( void *  arg )

static

Definition at line 312 of file smsc_http.c.

References bb_smscconn_connected(), bb_smscconn_send_failed(), conndata::callbacks, smscconn::connect_time, counter_decrease(), counter_value(), smscconn::data, debug(), error(), smscconn::flow_mutex, gwthread_sleep(), http_destroy_headers(), http_receive_result, conndata::http_ref, smscconn::id, smscconn::log_idx, log_thread_to(), conndata::max_pending_sends, msg, mutex_lock, mutex_unlock, octstr_destroy(), octstr_get_cstr, conndata::open_sends, smsc_http_fn_callbacks::parse_reply, smscconn::reconnect_delay, semaphore_up(), conndata::shutdown, SMSCCONN_ACTIVE, SMSCCONN_FAILED_SHUTDOWN, SMSCCONN_FAILED_TEMPORARILY, SMSCCONN_RECONNECTING, smscconn::status, and warning().

Referenced by smsc_http_create().

{
    SMSCConn *conn = arg;
    ConnData *conndata = conn->data;
    Msg *msg;
    int status;
    List *headers;
    Octstr *final_url, *body;

    /* Make sure we log into our own log-file if defined */
    log_thread_to(conn->log_idx);

    while(conndata->shutdown == 0 || counter_value(conndata->open_sends)) {

        msg = http_receive_result(conndata->http_ref, &status,
                                  &final_url, &headers, &body);

        if (msg == NULL)
            break;  /* they told us to die, by unlocking */

        counter_decrease(conndata->open_sends);
        if (conndata->max_pending_sends)
            semaphore_up(conndata->max_pending_sends);

        /* Handle various states here. */

        /* request failed and we are not in shutdown mode */
        if (status == -1 && conndata->shutdown == 0) {
            error(0, "HTTP[%s]: Couldn't connect to SMS center."
                     "(retrying in %ld seconds) %ld.",
                     octstr_get_cstr(conn->id), conn->reconnect_delay, counter_value(conndata->open_sends));
            mutex_lock(conn->flow_mutex);
            conn->status = SMSCCONN_RECONNECTING;
            mutex_unlock(conn->flow_mutex);
            /* XXX how should we know whether it's temp. error ?? */
            bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_TEMPORARILY, NULL);
            /*
             * Just sleep reconnect delay and set conn to ACTIVE again;
             * otherwise if no pending request are here, we leave conn in
             * RECONNECTING state for ever and no routing (trials) take place.
             */
            if (counter_value(conndata->open_sends) == 0) {
                gwthread_sleep(conn->reconnect_delay);
                /* and now enable routing again */
                mutex_lock(conn->flow_mutex);
                conn->status = SMSCCONN_ACTIVE;
                time(&conn->connect_time);
                mutex_unlock(conn->flow_mutex);
                /* tell bearerbox core that we are connected again */
                bb_smscconn_connected(conn);
            }
            continue;
        }
        /* request failed and we *are* in shutdown mode, drop the message */
        else if (status == -1 && conndata->shutdown == 1) {
            bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN, NULL);
        }
        /* request succeeded */
        else {
            /* we received a response, so this link is considered online again */
            if (conn->status != SMSCCONN_ACTIVE) {
                mutex_lock(conn->flow_mutex);
                conn->status = SMSCCONN_ACTIVE;
                time(&conn->connect_time);
                mutex_unlock(conn->flow_mutex);
                /* tell bearerbox core that we are connected again */
                bb_smscconn_connected(conn);
            }
            conndata->callbacks->parse_reply(conn, msg, status, headers, body);
        }

        http_destroy_headers(headers);
        octstr_destroy(final_url);
        octstr_destroy(body);
    }
    debug("smsc.http", 0, "HTTP[%s]: httpsmsc_send_cb dying",
          octstr_get_cstr(conn->id));
    conndata->shutdown = 1;

    if (counter_value(conndata->open_sends)) {
        warning(0, "HTTP[%s]: Shutdown while <%ld> requests are pending.",
                octstr_get_cstr(conn->id), counter_value(conndata->open_sends));
    }
}

httpsmsc_sender()

static void httpsmsc_sender ( void *  arg )

static

Definition at line 242 of file smsc_http.c.

References bb_smscconn_killed(), bb_smscconn_send_failed(), conndata::callbacks, conndata_destroy(), counter_decrease(), counter_increase(), counter_value(), smscconn::data, delay, smsc_http_fn_callbacks::destroy, smscconn::flow_mutex, gwlist_consume(), gwlist_extract_first(), gwthread_join(), gwthread_sleep(), gwthread_wakeup(), http_caller_signal_shutdown(), conndata::http_ref, smscconn::log_idx, log_thread_to(), conndata::max_pending_sends, msg, conndata::msg_to_send, mutex_lock, mutex_unlock, conndata::open_sends, conndata::port, semaphore_down(), semaphore_up(), conndata::send_cb_thread, smsc_http_fn_callbacks::send_sms, conndata::shutdown, SMSCCONN_DEAD, SMSCCONN_FAILED_SHUTDOWN, smscconn::status, and smscconn::throughput.

Referenced by smsc_http_create().

{
    SMSCConn *conn = arg;
    ConnData *conndata = conn->data;
    Msg *msg;
    double delay = 0;

    /* Make sure we log into our own log-file if defined */
    log_thread_to(conn->log_idx);

    if (conn->throughput) {
        delay = 1.0 / conn->throughput;
    }

    while (conndata->shutdown == 0) {
        /* check if we can send ; otherwise block on semaphore */
        if (conndata->max_pending_sends)
            semaphore_down(conndata->max_pending_sends);

        if (conndata->shutdown) {
            if (conndata->max_pending_sends)
                semaphore_up(conndata->max_pending_sends);
            break;
        }

        msg = gwlist_consume(conndata->msg_to_send);
        if (msg == NULL)
            break;

        /* obey throughput speed limit, if any */
        if (conn->throughput > 0) {
            gwthread_sleep(delay);
        }
        counter_increase(conndata->open_sends);
        if (conndata->callbacks->send_sms(conn, msg) == -1) {
            counter_decrease(conndata->open_sends);
            if (conndata->max_pending_sends)
                semaphore_up(conndata->max_pending_sends);
        }
    }

    /* put outstanding sends back into global queue */
    while((msg = gwlist_extract_first(conndata->msg_to_send)))
        bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN, NULL);

    /* if there no receiver shutdown */
    if (conndata->port <= 0) {
        /* unblock http_receive_result() if there are no open sends */
        if (counter_value(conndata->open_sends) == 0)
            http_caller_signal_shutdown(conndata->http_ref);

        if (conndata->send_cb_thread != -1) {
            gwthread_wakeup(conndata->send_cb_thread);
            gwthread_join(conndata->send_cb_thread);
        }
        mutex_lock(conn->flow_mutex);
        conn->status = SMSCCONN_DEAD;
        mutex_unlock(conn->flow_mutex);

        if (conndata->callbacks != NULL && conndata->callbacks->destroy != NULL)
            conndata->callbacks->destroy(conn);
        conn->data = NULL;
        conndata_destroy(conndata);
        bb_smscconn_killed();
    }
}

httpsmsc_shutdown()

static int httpsmsc_shutdown ( SMSCConn *  conn, int  finish_sending  )

static

Definition at line 461 of file smsc_http.c.

References smscconn::data, debug(), smscconn::flow_mutex, gwlist_remove_producer(), gwthread_wakeup(), http_close_port(), smscconn::id, conndata::msg_to_send, mutex_lock, mutex_unlock, octstr_get_cstr, conndata::port, conndata::receive_thread, conndata::sender_thread, conndata::shutdown, SMSCCONN_KILLED_SHUTDOWN, and smscconn::why_killed.

Referenced by smsc_http_create().

{
    ConnData *conndata = conn->data;

    if (conndata == NULL)
        return 0;

    debug("httpsmsc_shutdown", 0, "HTTP[%s]: Shutting down",
          octstr_get_cstr(conn->id));

    mutex_lock(conn->flow_mutex);
    conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;

    conndata->shutdown = 1;

    if (conndata->port > 0)
        http_close_port(conndata->port);
    gwlist_remove_producer(conndata->msg_to_send);
    if (conndata->receive_thread != -1)
        gwthread_wakeup(conndata->receive_thread);
    if (conndata->sender_thread != -1)
        gwthread_wakeup(conndata->sender_thread);
    mutex_unlock(conn->flow_mutex);

    return 0;
}

smsc_http_create()

int smsc_http_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 489 of file smsc_http.c.

References conndata::allow_ip, conndata::alt_charset, conndata::callbacks, cfg, cfg_get, cfg_get_bool(), cfg_get_integer(), conndata_destroy(), smscconn::connect_time, counter_create(), conndata::data, smscconn::data, smsc_http_fn_callbacks::destroy, conndata::dlr_url, error(), gw_dlopen_get_symbol(), gwlist_add_producer(), gwlist_create, gwthread_create, http_caller_create(), http_open_port(), conndata::http_ref, httpsmsc_queued(), httpsmsc_receiver(), httpsmsc_send(), httpsmsc_send_cb(), httpsmsc_sender(), httpsmsc_shutdown(), smscconn::id, info(), smsc_http_fn_callbacks::init, conndata::max_pending_sends, conndata::mobile_originated, conndata::msg_to_send, smscconn::name, conndata::no_coding, conndata::no_sender, conndata::no_sep, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), conndata::open_sends, conndata::password, conndata::port, smscconn::queued, conndata::receive_thread, semaphore_create(), conndata::send_cb_thread, smscconn::send_msg, conndata::send_url, conndata::sender_thread, conndata::shutdown, smscconn::shutdown, SMSCCONN_ACTIVE, SMSCCONN_ACTIVE_RECV, SMSCCONN_DEAD, SMSCCONN_KILLED_CANNOT_CONNECT, ssl, smscconn::status, conndata::system_id, type, conndata::use_post, conndata::username, warning(), and smscconn::why_killed.

Referenced by smscconn_create().

{
    ConnData *conndata = NULL;
    Octstr *type = NULL, *callbackname = NULL;
    int ssl = 0;   /* indicate if SSL-enabled server should be used */
    long max_ps;

    if ((type = cfg_get(cfg, octstr_imm("system-type"))) == NULL) {
        error(0, "HTTP[%s]: 'system-type' missing in smsc 'http' record.",
              octstr_get_cstr(conn->id));
        octstr_destroy(type);
        return -1;
    }

    conndata = gw_malloc(sizeof(ConnData));
    /* reset conndata */
    memset(conndata, 0, sizeof(ConnData));

    conn->data = conndata;
    conndata->http_ref = NULL;
    conndata->data = NULL;

    if (cfg_get_integer(&conndata->port, cfg, octstr_imm("port")) == -1) {
        warning(0, "HTTP[%s]: 'port' not set in smsc 'http' group.",
              octstr_get_cstr(conn->id));
        conndata->port = -1;
    }

    conndata->allow_ip = cfg_get(cfg, octstr_imm("connect-allow-ip"));
    conndata->send_url = cfg_get(cfg, octstr_imm("send-url"));
    conndata->username = cfg_get(cfg, octstr_imm("smsc-username"));
    conndata->password = cfg_get(cfg, octstr_imm("smsc-password"));
    conndata->system_id = cfg_get(cfg, octstr_imm("system-id"));
    cfg_get_bool(&conndata->no_sender, cfg, octstr_imm("no-sender"));
    cfg_get_bool(&conndata->no_coding, cfg, octstr_imm("no-coding"));
    cfg_get_bool(&conndata->no_sep, cfg, octstr_imm("no-sep"));
    cfg_get_bool(&conndata->mobile_originated, cfg, octstr_imm("mobile-originated"));
    cfg_get_bool(&ssl, cfg, octstr_imm("use-ssl"));
    conndata->dlr_url = cfg_get(cfg, octstr_imm("dlr-url"));
    conndata->alt_charset = cfg_get(cfg, octstr_imm("alt-charset"));
    cfg_get_bool(&conndata->use_post, cfg, octstr_imm("use-post"));

    if (cfg_get_integer(&max_ps, cfg, octstr_imm("max-pending-submits")) == -1 || max_ps < 1)
        max_ps = 10;
    conndata->max_pending_sends = semaphore_create(max_ps);

    if (conndata->port <= 0 && conndata->send_url == NULL) {
        error(0, "HTTP[%s]: Sender and receiver disabled. Dummy SMSC not allowed.",
              octstr_get_cstr(conn->id));
        goto error;
    }
    if (conndata->send_url == NULL) {
        error(0, "HTTP[%s]: Sending not allowed. No 'send-url' specified.",
              octstr_get_cstr(conn->id));
        goto error;
    }

    /* callback struct is always in the format: smsc_http_XXX_callback where XXX is our type */
    callbackname = octstr_format("smsc_http_%S_callback", type);
    /* try to find the struct */
    if (gw_dlopen_get_symbol(NULL, octstr_get_cstr(callbackname), (void**)&conndata->callbacks) == -1 || conndata->callbacks == NULL) {
        error(0, "HTTP[%s]: system-type '%s' unknown smsc 'http' record.",
              octstr_get_cstr(conn->id), octstr_get_cstr(type));
        goto error;
    }

    if (conndata->callbacks != NULL && conndata->callbacks->init != NULL && conndata->callbacks->init(conn, cfg)) {
        error(0, "HTTP[%s]: submodule '%s' init failed.", octstr_get_cstr(conn->id), octstr_get_cstr(type));
        goto error;
    }

    conndata->open_sends = counter_create();
    conndata->msg_to_send = gwlist_create();
    gwlist_add_producer(conndata->msg_to_send);
    conndata->http_ref = http_caller_create();

    conn->name = octstr_format("HTTP%s:%S:%d", (ssl?"S":""), type, conndata->port);

    if (conndata->send_url != NULL) {
        conn->status = SMSCCONN_ACTIVE;
    } else {
        conn->status = SMSCCONN_ACTIVE_RECV;
    }

    conn->connect_time = time(NULL);

    conn->shutdown = httpsmsc_shutdown;
    conn->queued = httpsmsc_queued;
    conn->send_msg = httpsmsc_send;

    conndata->shutdown = 0;

    /* start receiver thread */
    if (conndata->port > 0) {
        if (http_open_port(conndata->port, ssl) == -1)
            goto error;
        if ((conndata->receive_thread = gwthread_create(httpsmsc_receiver, conn)) == -1)
            goto error;
    } else
        conndata->receive_thread = -1;

    /* start sender threads */
    if (conndata->send_url) {
        if ((conndata->send_cb_thread =
            gwthread_create(httpsmsc_send_cb, conn)) == -1)
        goto error;
        if ((conndata->sender_thread =
                gwthread_create(httpsmsc_sender, conn)) == -1)
        goto error;
    }
    else {
        conndata->send_cb_thread = conndata->sender_thread = -1;
    }

    info(0, "HTTP[%s]: Initiated and ready", octstr_get_cstr(conn->id));

    octstr_destroy(callbackname);
    octstr_destroy(type);
    return 0;

error:
    error(0, "HTTP[%s]: Failed to create HTTP SMSC connection",
          octstr_get_cstr(conn->id));

    if (conndata->callbacks != NULL && conndata->callbacks->destroy != NULL)
        conndata->callbacks->destroy(conn);
    conn->data = NULL;
    conndata_destroy(conndata);
    conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
    conn->status = SMSCCONN_DEAD;
    octstr_destroy(callbackname);
    octstr_destroy(type);
    return -1;
}