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 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();
}
/*
* Thread to listen to HTTP requests from SMSC entity
*/
static void httpsmsc_receiver(void *arg)
{
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();
}
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();
}