static void brunet_parse_reply(SMSCConn *conn, Msg *msg, int status,
List *headers, Octstr *body)
{
if (status == HTTP_OK || status == HTTP_ACCEPTED) {
Dict *param;
Octstr *status;
if ((param = brunet_parse_body(body)) != NULL &&
(status = dict_get(param, octstr_imm("Status"))) != NULL &&
octstr_case_compare(status, octstr_imm("0")) == 0) {
Octstr *msg_id;
/* pass the MessageId for this MT to the logging facility */
if ((msg_id = dict_get(param, octstr_imm("MessageId"))) != NULL)
msg->sms.binfo = octstr_duplicate(msg_id);
bb_smscconn_sent(conn, msg, NULL);
} else {
error(0, "HTTP[%s]: Message was malformed. 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 reponse `%s'.",
octstr_get_cstr(conn->id), octstr_get_cstr(body));
bb_smscconn_send_failed(conn, msg,
SMSCCONN_FAILED_REJECTED, octstr_duplicate(body));
}
}
static void kannel_parse_reply(SMSCConn *conn, Msg *msg, int status,
List *headers, Octstr *body)
{
/* Test on three cases:
* 1. an smsbox reply of an remote kannel instance
* 2. an smsc_http response (if used for MT to MO looping)
* 3. an smsbox reply of partly successful sendings */
if ((status == HTTP_OK || status == HTTP_ACCEPTED)
&& (octstr_case_compare(body, octstr_imm("0: Accepted for delivery")) == 0 ||
octstr_case_compare(body, octstr_imm("Sent.")) == 0 ||
octstr_case_compare(body, octstr_imm("Ok.")) == 0 ||
octstr_ncompare(body, octstr_imm("Result: OK"),10) == 0)) {
char id[UUID_STR_LEN + 1];
Octstr *mid;
/* create Octstr from UUID */
uuid_unparse(msg->sms.id, id);
mid = octstr_create(id);
/* add to our own DLR storage */
if (DLR_IS_ENABLED_DEVICE(msg->sms.dlr_mask))
dlr_add(conn->id, mid, msg, 0);
octstr_destroy(mid);
bb_smscconn_sent(conn, msg, NULL);
} else {
bb_smscconn_send_failed(conn, msg,
SMSCCONN_FAILED_MALFORMED, octstr_duplicate(body));
}
}
static int shutdown_cb(SMSCConn *conn, int finish_sending)
{
PrivData *privdata = conn->data;
debug("bb.sms", 0, "Shutting down SMSCConn FAKE, %s",
finish_sending ? "slow" : "instant");
/*
* Documentation claims this would have been done by smscconn.c,
* but isn't when this code is being written.
*/
conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;
privdata->shutdown = 1;
/*
* Separate from why_killed to avoid locking, as
* why_killed may be changed from outside?
*/
if (finish_sending == 0) {
Msg *msg;
while((msg = gwlist_extract_first(privdata->outgoing_queue)) != NULL) {
bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN, NULL);
}
}
gwthread_wakeup(privdata->connection_thread);
return 0;
}
static Connection *cgw_open_send_connection(SMSCConn *conn)
{
PrivData *privdata = conn->data;
int wait;
Connection *server;
Msg *msg;
wait = 0;
while (!privdata->shutdown) {
/* Change status only if the first attempt to form a
* connection fails, as it's possible that the SMSC closed the
* connection because of idle timeout and a new one will be
* created quickly. */
if (wait) {
if (conn->status == SMSCCONN_ACTIVE) {
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_RECONNECTING;
mutex_unlock(conn->flow_mutex);
}
while ((msg = gwlist_extract_first(privdata->outgoing_queue)))
bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_TEMPORARILY, NULL);
info(0, "smsc_cgw: waiting for %d minutes before trying to connect again", wait);
gwthread_sleep(wait * 60);
wait = wait > 5 ? 10 : wait * 2;
} else
wait = 1;
server = conn_open_tcp_with_port(privdata->host, privdata->port,
privdata->our_port, conn->our_host);
if (privdata->shutdown) {
conn_destroy(server);
return NULL;
}
if (server == NULL) {
error(0, "smsc_cgw: opening TCP connection to %s failed", octstr_get_cstr(privdata->host));
continue;
}
if (conn->status != SMSCCONN_ACTIVE) {
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_ACTIVE;
conn->connect_time = time(NULL);
mutex_unlock(conn->flow_mutex);
bb_smscconn_connected(conn);
}
return server;
}
return NULL;
}
static int wrapper_shutdown(SMSCConn *conn, int finish_sending)
{
SmscWrapper *wrap = conn->data;
debug("bb.sms", 0, "Shutting down SMSCConn %s, %s",
octstr_get_cstr(conn->name), finish_sending ? "slow" : "instant");
if (finish_sending == 0) {
Msg *msg;
while((msg = gwlist_extract_first(wrap->outgoing_queue))!=NULL) {
bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN, NULL);
}
}
gwlist_remove_producer(wrap->outgoing_queue);
gwthread_wakeup(wrap->sender_thread);
gwthread_wakeup(wrap->receiver_thread);
return 0;
}
static int sms_send(SMSCConn *conn, Msg *msg)
{
SmscWrapper *wrap = conn->data;
int ret;
debug("bb.sms", 0, "smscconn_sender (%s): sending message",
octstr_get_cstr(conn->name));
ret = smscenter_submit_msg(wrap->smsc, msg);
if (ret == -1) {
bb_smscconn_send_failed(conn, msg,
SMSCCONN_FAILED_REJECTED, octstr_create("REJECTED"));
if (reconnect(conn) == -1)
smscconn_shutdown(conn, 0);
return -1;
} else {
bb_smscconn_sent(conn, msg, NULL);
return 0;
}
}
static int reconnect(SMSCConn *conn)
{
SmscWrapper *wrap = conn->data;
Msg *msg;
int ret;
int wait = 1;
/* disable double-reconnect
* NOTE: it is still possible that we do double-connect if
* first thread gets through this if-statement and then
* execution switches to another thread.. this can be avoided
* via double-mutex system, but I do not feel it is worth it,
* maybe later --rpr
*/
if (conn->status == SMSCCONN_RECONNECTING) {
mutex_lock(wrap->reconnect_mutex); /* wait here */
mutex_unlock(wrap->reconnect_mutex);
return 0;
}
mutex_lock(wrap->reconnect_mutex);
debug("bb.sms", 0, "smsc_wrapper <%s>: reconnect started",
octstr_get_cstr(conn->name));
while((msg = gwlist_extract_first(wrap->outgoing_queue))!=NULL) {
bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_TEMPORARILY, NULL);
}
conn->status = SMSCCONN_RECONNECTING;
while(conn->why_killed == SMSCCONN_ALIVE) {
ret = smsc_reopen(wrap->smsc);
if (ret == 0) {
info(0, "Re-open of %s succeeded.", octstr_get_cstr(conn->name));
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_ACTIVE;
conn->connect_time = time(NULL);
mutex_unlock(conn->flow_mutex);
bb_smscconn_connected(conn);
break;
}
else if (ret == -2) {
error(0, "Re-open of %s failed permanently",
octstr_get_cstr(conn->name));
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_DISCONNECTED;
mutex_unlock(wrap->reconnect_mutex);
mutex_unlock(conn->flow_mutex);
return -1; /* permanent failure */
}
else {
error(0, "Re-open to <%s> failed, retrying after %d minutes...",
octstr_get_cstr(conn->name), wait);
gwthread_sleep(wait*60.0);
wait = wait > 10 ? 10 : wait * 2 + 1;
}
}
mutex_unlock(wrap->reconnect_mutex);
return 0;
}
static void wrapper_sender(void *arg)
{
Msg *msg;
SMSCConn *conn = arg;
SmscWrapper *wrap = conn->data;
/* Make sure we log into our own log-file if defined */
log_thread_to(conn->log_idx);
/* send messages to SMSC until our outgoing_list is empty and
* no producer anymore (we are set to shutdown) */
while(conn->status != SMSCCONN_DEAD) {
if ((msg = gwlist_consume(wrap->outgoing_queue)) == NULL)
break;
if (octstr_search_char(msg->sms.receiver, ' ', 0) != -1) {
/*
* multi-send: this should be implemented in corresponding
* SMSC protocol, but while we are waiting for that...
*/
int i;
Msg *newmsg;
/* split from spaces: in future, split with something more sensible,
* this is dangerous... (as space is url-encoded as '+')
*/
List *nlist = octstr_split_words(msg->sms.receiver);
debug("bb.sms", 0, "Handling multi-receiver message");
for(i=0; i < gwlist_len(nlist); i++) {
newmsg = msg_duplicate(msg);
octstr_destroy(newmsg->sms.receiver);
newmsg->sms.receiver = gwlist_get(nlist, i);
sms_send(conn, newmsg);
}
gwlist_destroy(nlist, NULL);
msg_destroy(msg);
}
else
sms_send(conn,msg);
}
/* cleanup, we are now dying */
debug("bb.sms", 0, "SMSCConn %s sender died, waiting for receiver",
octstr_get_cstr(conn->name));
conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;
if (conn->is_stopped) {
gwlist_remove_producer(wrap->stopped);
conn->is_stopped = 0;
}
gwthread_wakeup(wrap->receiver_thread);
gwthread_join(wrap->receiver_thread);
/* call 'failed' to all messages still in queue */
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_DEAD;
while((msg = gwlist_extract_first(wrap->outgoing_queue))!=NULL) {
bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN, NULL);
}
smscwrapper_destroy(wrap);
conn->data = NULL;
mutex_unlock(conn->flow_mutex);
bb_smscconn_killed();
}
/*
* Thread to handle finished sendings
*/
static void httpsmsc_send_cb(void *arg)
{
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));
}
}
/*
* Thread to send queued messages
*/
static void httpsmsc_sender(void *arg)
{
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();
}
}
static void cgw_sender(void *arg)
{
SMSCConn *conn = arg;
PrivData *privdata = conn->data;
Msg *msg = NULL;
Connection *server = NULL;
int l = 0;
int ret = 0;
conn->status = SMSCCONN_CONNECTING;
/* Make sure we log into our own log-file if defined */
log_thread_to(conn->log_idx);
while (!privdata->shutdown) {
/* check that connection is active */
if (conn->status != SMSCCONN_ACTIVE) {
if ((server = cgw_open_send_connection(conn)) == NULL) {
privdata->shutdown = 1;
error(0, "Unable to connect to CGW server");
return ;
}
conn->status = SMSCCONN_ACTIVE;
bb_smscconn_connected(conn);
} else {
ret = 0;
l = gwlist_len(privdata->outgoing_queue);
if (l > 0)
ret = cgw_send_loop(conn, server); /* send any messages in queue */
if (ret != -1) ret = cgw_wait_command(privdata, conn, server, 1); /* read ack's and delivery reports */
if (ret != -1) cgw_check_acks(privdata); /* check un-acked messages */
if (ret == -1) {
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_RECONNECTING;
mutex_unlock(conn->flow_mutex);
}
}
}
conn_destroy(server);
while ((msg = gwlist_extract_first(privdata->outgoing_queue)) != NULL)
bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN, NULL);
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_DEAD;
gwlist_destroy(privdata->outgoing_queue, NULL);
octstr_destroy(privdata->host);
octstr_destroy(privdata->allow_ip);
octstr_destroy(privdata->deny_ip);
gw_free(privdata);
conn->data = NULL;
mutex_unlock(conn->flow_mutex);
debug("bb.sms", 0, "smsc_cgw connection has completed shutdown.");
bb_smscconn_killed();
}
/******************************************************************************
* This function handles incoming operations. Used by both receiver and sender
* threads (i.e. sender thread uses this function for delivery and ack
* operations).
* Returns 1 if successfull, otherwise 0
*/
static int cgw_handle_op(SMSCConn *conn, Connection *server, struct cgwop *cgwop)
{
PrivData *privdata = conn->data;
Msg *msg = NULL;
Octstr *from, *app, *sid, *to, *msgtype, *msgdata; /* for messages */
Octstr *msid, *status, *txt; /* delivery reports */
Octstr *clid; /* for acks */
struct cgwop *reply = NULL;
long trn, stat; /* transaction number for ack */
Msg *dlrmsg = NULL, *origmsg = NULL;
Octstr *ts;
if (cgwop == NULL) return 0;
from = cgwop_get(cgwop, octstr_imm("from"));
app = cgwop_get(cgwop, octstr_imm("app"));
sid = cgwop_get(cgwop, octstr_imm("session-id"));
to = cgwop_get(cgwop, octstr_imm("to"));
msgtype = cgwop_get(cgwop, octstr_imm("type"));
msgdata = cgwop_get(cgwop, octstr_imm("msg"));
txt = cgwop_get(cgwop, octstr_imm("txt"));
msid = cgwop_get(cgwop, octstr_imm("msid"));
status = cgwop_get(cgwop, octstr_imm("status"));
clid = cgwop_get(cgwop, octstr_imm("client-id"));
if (clid != NULL)
{
octstr_parse_long(&trn, clid, 0, 10);
if ((trn < 0) || (trn >= CGW_TRN_MAX)) { /* invalid transaction number */
info(0, "cgw: Invalid transaction number: %d", (int) trn);
trn = -1;
return 0;
}
}
switch (cgwop->op)
{
case CGW_OP_MSG:
msg = msg_create(sms);
time(&msg->sms.time);
msg->sms.msgdata = cgw_decode_msg(octstr_duplicate(msgdata));
msg->sms.sender = octstr_duplicate(from);
msg->sms.receiver = octstr_duplicate(to);
msg->sms.smsc_id = octstr_duplicate(conn->id);
bb_smscconn_receive(conn, msg);
reply = cgwop_create(CGW_OP_OK, -1);
cgwop_add(reply, octstr_imm("session-id"), sid);
cgwop_send(server, reply); /* send reply */
cgwop_destroy(reply);
break;
case CGW_OP_DELIVERY:
if (privdata->dlr[trn]) {
octstr_parse_long(&stat, status, 0, 10);
origmsg = privdata->sendmsg[trn];
if (origmsg == NULL) break;
ts = octstr_create("");
octstr_append(ts, conn->id);
octstr_append_char(ts, '-');
octstr_append_decimal(ts, trn);
switch (stat) {
case 0: /* delivered */
dlrmsg = dlr_find(conn->id,
ts, /* timestamp */
msid, /* destination */
DLR_SUCCESS);
break;
case 1: /* buffered */
dlrmsg = dlr_find(conn->id,
ts, /* timestamp */
msid, /* destination */
DLR_BUFFERED);
break;
case 2: /* not delivered */
dlrmsg = dlr_find(conn->id,
ts, /* timestamp */
msid, /* destination */
DLR_FAIL);
break;
}
octstr_destroy(ts);
if (dlrmsg != NULL) {
dlrmsg->sms.msgdata = octstr_duplicate(txt);
bb_smscconn_receive(conn, dlrmsg);
}
}
break;
case CGW_OP_OK:
if (trn == -1) break; /* invalid transaction number */
/* info(0, "cgw: Got ACK: %s", octstr_get_cstr(clid)); */
privdata->sendtime[trn] = 0;
privdata->unacked--;
/* add delivery notification request if wanted */
msg = privdata->sendmsg[trn];
if (msg && msg->sms.dlr_url && DLR_IS_ENABLED_DEVICE(msg->sms.dlr_mask)) {
Octstr *ts;
ts = octstr_create("");
octstr_append(ts, conn->id);
octstr_append_char(ts, '-');
octstr_append_decimal(ts, trn);
dlr_add(conn->id, ts, msg);
octstr_destroy(ts);
privdata->dlr[trn] = 1;
} else {
privdata->dlr[trn] = 0;
}
/* mark as successfully sent */
bb_smscconn_sent(conn, msg, NULL);
break;
case CGW_OP_STATUS:
info(0, "CGW: Warning: Got session status");
/* op:status messages are sent by ProviderServer to tell if there are problems with
the session status. These are not wanted, and should never occur, as the delivery is
cancelled, and no end-user billing is done. */
break;
case CGW_OP_HELLO:
info(0, "CGW: Server said: %s", octstr_get_cstr(cgwop_get(cgwop, octstr_imm("hello"))));
break;
case CGW_OP_ERR:
if (trn == -1) break; /* invalid transaction number */
info(0, "CGW: Received error: %s", octstr_get_cstr(txt));
privdata->sendtime[trn] = 0;
privdata->unacked--;
bb_smscconn_send_failed(conn, privdata->sendmsg[trn],
SMSCCONN_FAILED_REJECTED, octstr_create("REJECTED"));
break;
default:
info(0, "cgw: Unknown operation: %d", cgwop->op);
return 0;
}
return 1;
}
static void fake_listener(void *arg)
{
SMSCConn *conn = arg;
PrivData *privdata = conn->data;
struct sockaddr_in client_addr;
socklen_t client_addr_len;
Octstr *ip;
Connection *client;
int s, ret;
Msg *msg;
/* Make sure we log into our own log-file if defined */
log_thread_to(conn->log_idx);
while (1) {
client_addr_len = sizeof(client_addr);
ret = gwthread_pollfd(privdata->listening_socket, POLLIN, -1);
if (ret == -1) {
if (errno == EINTR)
continue;
error(0, "Poll for fakesmsc connections failed, shutting down");
break;
}
if (privdata->shutdown)
break;
if (ret == 0)
/*
* This thread was woke up from elsewhere, but
* if we're not shutting down nothing to do here.
*/
continue;
s = accept(privdata->listening_socket, (struct sockaddr *)&client_addr,
&client_addr_len);
if (s == -1) {
warning(errno, "fake_listener: accept() failed, retrying...");
continue;
}
ip = host_ip(client_addr);
if (!is_allowed_ip(privdata->allow_ip, privdata->deny_ip, ip)) {
info(0, "Fakesmsc connection tried from denied host <%s>, "
"disconnected", octstr_get_cstr(ip));
octstr_destroy(ip);
close(s);
continue;
}
client = conn_wrap_fd(s, 0);
if (client == NULL) {
error(0, "fake_listener: conn_wrap_fd failed on accept()ed fd");
octstr_destroy(ip);
close(s);
continue;
}
conn_claim(client);
info(0, "Fakesmsc client connected from %s", octstr_get_cstr(ip));
octstr_destroy(ip);
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_ACTIVE;
conn->connect_time = time(NULL);
mutex_unlock(conn->flow_mutex);
bb_smscconn_connected(conn);
main_connection_loop(conn, client);
if (privdata->shutdown)
break;
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_RECONNECTING;
mutex_unlock(conn->flow_mutex);
while ((msg = gwlist_extract_first(privdata->outgoing_queue)) != NULL) {
bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_TEMPORARILY, NULL);
}
}
if (close(privdata->listening_socket) == -1)
warning(errno, "smsc_fake: couldn't close listening socket at shutdown");
mutex_lock(conn->flow_mutex);
conn->status = SMSCCONN_DEAD;
while ((msg = gwlist_extract_first(privdata->outgoing_queue)) != NULL) {
bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN, NULL);
}
gwlist_destroy(privdata->outgoing_queue, NULL);
octstr_destroy(privdata->allow_ip);
octstr_destroy(privdata->deny_ip);
gw_free(privdata);
conn->data = NULL;
mutex_unlock(conn->flow_mutex);
debug("bb.sms", 0, "smsc_fake connection has completed shutdown.");
bb_smscconn_killed();
}
static void main_connection_loop(SMSCConn *conn, Connection *client)
{
PrivData *privdata = conn->data;
Octstr *line;
Msg *msg;
double delay = 0;
if (conn->throughput > 0) {
delay = 1.0 / conn->throughput;
}
while (1) {
while (!conn->is_stopped && !privdata->shutdown &&
(line = conn_read_line(client)))
msg_to_bb(conn, line);
if (conn_error(client))
goto error;
if (conn_eof(client))
goto eof;
/*
* We won't get DLRs from fakesmsc itself, due that we don't have
* corresponding message IDs etc. We threat the DLR receiving here. So
* DLR "originate" from the protocol layer towards abstraction layer.
* This is all for pure debugging and testing.
*/
while ((msg = gwlist_extract_first(privdata->outgoing_queue)) != NULL) {
/* pass msg to fakesmsc daemon */
if (sms_to_client(client, msg) == 1) {
Msg *copy = msg_duplicate(msg);
/*
* Actually no guarantee of it having been really sent,
* but I suppose that doesn't matter since this interface
* is just for debugging anyway. The upper layer will send
* a SMSC success DLR if mask is set. Be aware that msg is
* destroyed in abstraction layer, that's why we use a copy
* afterwards to handle the final DLR.
*/
bb_smscconn_sent(conn, msg, NULL);
/* and now the final DLR */
if (DLR_IS_SUCCESS_OR_FAIL(copy->sms.dlr_mask)) {
Msg *dlrmsg;
Octstr *tmp;
int dlrstat = DLR_SUCCESS;
char id[UUID_STR_LEN + 1];
uuid_unparse(copy->sms.id, id);
tmp = octstr_create(id);
dlrmsg = dlr_find(conn->id,
tmp, /* smsc message id */
copy->sms.receiver, /* destination */
dlrstat, 0);
if (dlrmsg != NULL) {
/* XXX TODO: Provide a SMPP DLR text in msgdata */
bb_smscconn_receive(conn, dlrmsg);
} else {
error(0,"smsc_fale: got DLR but could not find message or "
"was not interested in it");
}
octstr_destroy(tmp);
}
msg_destroy(copy);
} else {
bb_smscconn_send_failed(conn, msg,
SMSCCONN_FAILED_REJECTED, octstr_create("REJECTED"));
goto error;
}
/* obey throughput speed limit, if any */
if (conn->throughput > 0) {
gwthread_sleep(delay);
}
}
if (privdata->shutdown) {
debug("bb.sms", 0, "smsc_fake shutting down, closing client socket");
conn_destroy(client);
return;
}
conn_wait(client, -1);
if (conn_error(client))
goto error;
if (conn_eof(client))
goto eof;
}
error:
info(0, "IO error to fakesmsc client. Closing connection.");
conn_destroy(client);
return;
eof:
info(0, "EOF from fakesmsc client. Closing connection.");
conn_destroy(client);
return;
}