static void receive_smpp_thread(void *arg)
{
ESME *esme;
Octstr *os;
long len;
long sender_id;
SMPP_PDU *pdu;
esme = arg;
sender_id = -1;
len = 0;
while (!quitting && conn_wait(esme->conn, -1.0) != -1) {
for (;;) {
if (len == 0) {
len = smpp_pdu_read_len(esme->conn);
if (len == -1) {
error(0, "Client sent garbage, closing connection.");
goto error;
} else if (len == 0) {
if (conn_eof(esme->conn) || conn_error(esme->conn))
goto error;
break;
}
}
gw_assert(len > 0);
os = smpp_pdu_read_data(esme->conn, len);
if (os != NULL) {
len = 0;
pdu = smpp_pdu_unpack(NULL, os);
if (pdu == NULL) {
error(0, "PDU unpacking failed!");
octstr_dump(os, 0);
} else {
handle_pdu(esme, pdu);
smpp_pdu_destroy(pdu);
}
octstr_destroy(os);
} else if (conn_eof(esme->conn) || conn_error(esme->conn))
goto error;
else
break;
}
if (!quitting && esme->receiver && sender_id == -1)
sender_id = gwthread_create(send_smpp_thread, esme);
}
error:
if (sender_id != -1) {
quit();
gwthread_join(sender_id);
}
esme_destroy(esme);
quit();
debug("test.smpp", 0, "%s terminates.", __func__);
}
static void smsbox_thread(void *arg)
{
Connection *conn;
Msg *msg;
Octstr *os;
Octstr *reply_msg;
unsigned long count;
msg = msg_create(sms);
msg->sms.sender = octstr_create("123");
msg->sms.receiver = octstr_create("456");
msg->sms.msgdata = octstr_create("hello world");
reply_msg = msg_pack(msg);
msg_destroy(msg);
gwthread_sleep(1.0);
conn = conn_open_tcp(bearerbox_host, port_for_smsbox, NULL);
if (conn == NULL) {
gwthread_sleep(2.0);
conn = conn_open_tcp(bearerbox_host, port_for_smsbox, NULL);
if (conn == NULL)
panic(0, "Couldn't connect to bearerbox as smsbox");
}
while (!quitting && conn_wait(conn, -1.0) != -1) {
for (;;) {
os = conn_read_withlen(conn);
if (os == NULL) {
if (conn_eof(conn) || conn_error(conn))
goto error;
break;
}
msg = msg_unpack(os);
if (msg == NULL || msg->type == wdp_datagram)
error(0, "Bearerbox sent garbage to smsbox");
if (msg->type == sms) {
if (first_from_bb == (time_t) -1)
time(&first_from_bb);
count = counter_increase(num_from_bearerbox) + 1;
debug("test.smpp", 0,
"Bearerbox sent sms #%ld <%s> to smsbox, sending reply.",
count, octstr_get_cstr(msg->sms.msgdata));
if (count == max_to_esme)
info(0, "Bearerbox has sent all messages to smsbox.");
conn_write_withlen(conn, reply_msg);
counter_increase(num_to_bearerbox);
}
msg_destroy(msg);
octstr_destroy(os);
time(&last_to_bb);
}
}
error:
conn_destroy(conn);
octstr_destroy(reply_msg);
debug("test.smpp", 0, "%s terminates.", __func__);
}
static void cgw_receiver(SMSCConn *conn, Connection *server)
{
PrivData *privdata = conn->data;
Octstr *str = NULL;
struct cgwop *cgwop;
while (1) {
if (conn_eof(server)) {
info(0, "cgw: receive connection closed by SMSC");
return ;
}
if (conn_error(server)) {
error(0, "cgw: receive connection broken");
return ;
}
if (conn->is_stopped)
str = NULL;
cgwop = cgw_read_op(conn->data, conn, server, 0);
if (cgwop != NULL) {
cgw_handle_op(conn, server, cgwop);
cgwop_destroy(cgwop);
} else
conn_wait(server, -1);
if (privdata->shutdown)
break;
}
return ;
}
/* Copied from Kannel smsc_smpp.c */
static int smpp_listener_read_pdu(SMPPEsme *smpp_esme, long *len, SMPP_PDU **pdu)
{
Connection *conn = smpp_esme->conn;
if(conn == NULL) {
return -1;
}
Octstr *os;
if (*len == 0) {
*len = smpp_pdu_read_len(conn);
if (*len == -1) {
error(0, "SMPP[%s:%ld]: Client sent garbage, ignored.",
octstr_get_cstr(smpp_esme->system_id), smpp_esme->id);
*len = 0;
return -2;
} else if (*len == 0) {
if (conn_eof(conn) || conn_error(conn))
return -1;
return 0;
}
}
os = smpp_pdu_read_data(conn, *len);
if (os == NULL) {
if (conn_eof(conn) || conn_error(conn))
return -1;
return 0;
}
*len = 0;
*pdu = smpp_pdu_unpack(smpp_esme->system_id, os);
if (*pdu == NULL) {
error(0, "SMPP[%s]: PDU unpacking failed.",
octstr_get_cstr(smpp_esme->system_id));
debug("smpp.listener.read.pdu", 0, "SMPP[%s]: Failed PDU follows.",
octstr_get_cstr(smpp_esme->system_id));
octstr_dump(os, 0);
octstr_destroy(os);
return -2;
}
octstr_destroy(os);
return 1;
}
int read_from_bearerbox_real(Connection *conn, Msg **msg, double seconds)
{
int ret;
Octstr *pack;
pack = NULL;
*msg = NULL;
while (program_status != shutting_down) {
pack = conn_read_withlen(conn);
gw_claim_area(pack);
if (pack != NULL)
break;
if (conn_error(conn)) {
error(0, "Error reading from bearerbox, disconnecting.");
return -1;
}
if (conn_eof(conn)) {
error(0, "Connection closed by the bearerbox.");
return -1;
}
ret = conn_wait(conn, seconds);
if (ret < 0) {
error(0, "Connection to bearerbox broke.");
return -1;
}
else if (ret == 1) {
/* debug("gwlib.gwlib", 0, "Connection to bearerbox timed out after %.2f seconds.", seconds); */
return 1;
}
}
if (pack == NULL)
return -1;
*msg = msg_unpack(pack);
octstr_destroy(pack);
if (*msg == NULL) {
error(0, "Failed to unpack data!");
return -1;
}
return 0;
}
static Msg *read_from_box(Boxc *boxconn)
{
int ret;
Octstr *pack;
Msg *msg;
pack = NULL;
while (bb_status != BB_DEAD && boxconn->alive) {
/* XXX: if box doesn't send (just keep conn open) we block here while shutdown */
pack = conn_read_withlen(boxconn->conn);
gw_claim_area(pack);
if (pack != NULL)
break;
if (conn_error(boxconn->conn)) {
info(0, "Read error when reading from box <%s>, disconnecting",
octstr_get_cstr(boxconn->client_ip));
return NULL;
}
if (conn_eof(boxconn->conn)) {
info(0, "Connection closed by the box <%s>",
octstr_get_cstr(boxconn->client_ip));
return NULL;
}
ret = conn_wait(boxconn->conn, -1.0);
if (ret < 0) {
error(0, "Connection to box <%s> broke.",
octstr_get_cstr(boxconn->client_ip));
return NULL;
}
}
if (pack == NULL)
return NULL;
msg = msg_unpack(pack);
octstr_destroy(pack);
if (msg == NULL)
error(0, "Failed to unpack data!");
return msg;
}
int netserver_update(NETSERVER *s)
{
unsigned now = time_timestamp();
int i;
for(i = 0; i < s->max_clients; i++)
{
conn_update(&s->slots[i].conn);
if(s->slots[i].conn.state == NET_CONNSTATE_ERROR)
netserver_drop(s, i, conn_error(&s->slots[i].conn));
}
/* remove expired bans */
while(s->banpool_firstused && s->banpool_firstused->info.expires < now)
{
NETBAN *ban = s->banpool_firstused;
netserver_ban_remove_by_object(s, ban);
}
(void)now;
return 0;
}
int cgw_wait_command(PrivData *privdata, SMSCConn *conn, Connection *server, int timeout)
{
int ret;
struct cgwop *cgwop;
/* is there data to be read? */
ret = gwthread_pollfd(privdata->send_socket, POLLIN, 0.2);
if (ret != -1) {
/* read all waiting ops */
cgwop = cgw_read_op(privdata, conn, server, timeout);
if (cgwop != NULL) {
do {
if (conn_eof(server)) {
info(0, "cgw: Connection closed by SMSC");
conn->status = SMSCCONN_DISCONNECTED;
if (cgwop != NULL) cgwop_destroy(cgwop);
return -1;
}
if (conn_error(server)) {
error(0, "cgw: Error trying to read ACKs from SMSC");
if (cgwop != NULL) cgwop_destroy(cgwop);
return -1;
}
cgw_handle_op(conn, server, cgwop);
cgwop_destroy(cgwop);
} while ((cgwop = cgw_read_op(privdata, conn, server, timeout)) != NULL);
} else
conn_wait(server, 1); /* added because gwthread_pollfd
seems to always return 1. This will keep
the load on a reasonable level */
}
return 0;
}
/* The main program. */
int main(int argc, char **argv)
{
Connection *server;
Octstr *line;
Octstr **msgs;
int i;
int mptr, num_msgs;
long num_received, num_sent;
double first_received_at, last_received_at;
double first_sent_at, last_sent_at;
double start_time, end_time;
double delta;
int interactive, maxfd;
char *cptr;
char buffer[IN_BUFSIZE];
fd_set rset;
struct timeval alarm;
FILE *fp;
gwlib_init();
setup_signal_handlers();
host = octstr_create("localhost");
start_time = get_current_time();
mptr = get_and_set_debugs(argc, argv, check_args);
num_msgs = argc - mptr;
interactive = 0;
msgs = NULL;
fp = NULL;
if (num_msgs <= 0) {
interactive = 1;
num_msgs = 0;
info(0, "Entering interactive mode. Type your message on the command line");
/* set up file pointer to stdin */
fp = stdin;
/* initialize set for select */
FD_ZERO(&rset);
} else {
msgs = gw_malloc(sizeof(Octstr *) * num_msgs);
for (i = 0; i < num_msgs; i ++) {
msgs[i] = octstr_create(argv[mptr + i]);
octstr_append_char(msgs[i], 10); /* End of line */
}
info(0, "Host %s Port %d interval %.3f max-messages %ld",
octstr_get_cstr(host), port, interval, max_send);
srand((unsigned int) time(NULL));
}
info(0, "fakesmsc starting");
server = conn_open_tcp(host, port, NULL);
if (server == NULL)
panic(0, "Failed to open connection");
num_sent = 0;
num_received = 0;
first_received_at = 0;
first_sent_at = 0;
last_received_at = 0;
last_sent_at = 0;
/* infinitely loop */
while (1) {
/* Are we on interactive mode? */
if (interactive == 1) {
/* Check if we need to clean things up beforehand */
if ( num_msgs > 0 ) {
for (i = 0; i < num_msgs; i ++)
octstr_destroy(msgs[i]);
gw_free(msgs);
num_msgs = 0;
}
/* we want either the file pointer or timer */
FD_SET(fileno(fp), &rset);
/* get the largest file descriptor */
maxfd = fileno(fp) + 1;
/* set timer to go off in 3 seconds */
alarm.tv_sec = IN_TIMEOUT;
alarm.tv_usec = 0;
if (select(maxfd, &rset, NULL, NULL, &alarm) == -1)
goto over;
/* something went off, let's see if it's stdin */
if (FD_ISSET(fileno(fp), &rset)) { /* stdin is readable */
cptr = fgets(buffer, IN_BUFSIZE, stdin);
if( strlen( cptr ) < 2 )
goto rcv;
} else { /* timer kicked in */
goto rcv;
}
num_msgs = 1;
msgs = gw_malloc(sizeof(Octstr*));
msgs[0] = octstr_create(cptr);
}
/* if we still have something to send as MO message */
if (num_sent < max_send) {
Octstr *os = choose_message(msgs, num_msgs);
Octstr *msg = rnd > 0 ? randomize(os) : os;
if (conn_write(server, msg) == -1)
panic(0, "write failed");
++num_sent;
if (num_sent == max_send)
info(0, "fakesmsc: sent message %ld", num_sent);
else
debug("send", 0, "fakesmsc: sent message %ld", num_sent);
if (rnd > 0)
octstr_destroy(msg);
last_sent_at = get_current_time();
if (first_sent_at == 0)
first_sent_at = last_sent_at;
}
rcv:
do {
delta = interval * num_sent - (get_current_time() - first_sent_at);
if (delta < 0)
delta = 0;
if (num_sent >= max_send)
delta = -1;
conn_wait(server, delta);
if (conn_error(server) || conn_eof(server) || sigint_received)
goto over;
/* read as much as the smsc module provides us */
while ((line = conn_read_line(server))) {
last_received_at = get_current_time();
if (first_received_at == 0)
first_received_at = last_received_at;
++num_received;
if (num_received == max_send) {
info(0, "Got message %ld: <%s>", num_received,
octstr_get_cstr(line));
} else {
debug("receive", 0, "Got message %ld: <%s>", num_received,
octstr_get_cstr(line));
}
octstr_destroy(line);
}
} while (delta > 0 || num_sent >= max_send);
}
over:
conn_destroy(server);
/* destroy the MO messages */
for (i = 0; i < num_msgs; i ++)
octstr_destroy(msgs[i]);
gw_free(msgs);
end_time = get_current_time();
info(0, "fakesmsc: %ld messages sent and %ld received", num_sent, num_received);
info(0, "fakesmsc: total running time %.1f seconds", end_time - start_time);
delta = last_sent_at - first_sent_at;
if (delta == 0)
delta = .01;
if (num_sent > 1)
info(0, "fakesmsc: from first to last sent message %.1f s, "
"%.1f msgs/s", delta, (num_sent - 1) / delta);
delta = last_received_at - first_received_at;
if (delta == 0)
delta = .01;
if (num_received > 1)
info(0, "fakesmsc: from first to last received message %.1f s, "
"%.1f msgs/s", delta, (num_received - 1) / delta);
info(0, "fakesmsc: terminating");
return 0;
}
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;
}