/*
* Send a message to the bearerbox for delivery to a phone.
* Return >= 0 for success & count of splitted sms messages,
* -1 for failure. Does not destroy the msg.
*/
static int send_message(Msg *msg)
{
unsigned long msg_count;
List *list;
gw_assert(msg != NULL);
gw_assert(msg_type(msg) == sms);
/*
* Encode our smsbox-id to the msg structure.
* This will allow bearerbox to return specific answers to the
* same smsbox, mainly for DLRs and SMS proxy modes.
*/
if (smsbox_id != NULL) {
msg->sms.boxc_id = octstr_duplicate(smsbox_id);
}
list = sms_split(msg, NULL, NULL, NULL, NULL, 1, 0, 100, MAX_SMS_OCTETS);
msg_count = gwlist_len(list);
gwlist_destroy(list, msg_destroy_item);
debug("sms", 0, "message length %ld, sending %ld messages",
octstr_len(msg->sms.msgdata), msg_count);
if (delay > 0)
gwthread_sleep(delay);
/* pass message to bearerbox */
if (deliver_to_bearerbox(msg) != 0)
return -1;
return msg_count;
}
/*
* Send IP datagram as it is, segment SMS datagram if necessary.
*/
static void dispatch_datagram(WAPEvent *dgram)
{
Msg *msg, *part;
List *sms_datagrams;
static unsigned long msg_sequence = 0L; /* Used only by this function */
msg = part = NULL;
sms_datagrams = NULL;
if (dgram == NULL) {
error(0, "WDP: dispatch_datagram received empty datagram, ignoring.");
}
else if (dgram->type != T_DUnitdata_Req) {
warning(0, "WDP: dispatch_datagram received event of unexpected type.");
wap_event_dump(dgram);
}
else if (dgram->u.T_DUnitdata_Req.address_type == ADDR_IPV4) {
#ifdef HAVE_WTLS_OPENSSL
if (dgram->u.T_DUnitdata_Req.addr_tuple->local->port >= WTLS_CONNECTIONLESS_PORT)
wtls_dispatch_resp(dgram);
else
#endif /* HAVE_WTLS_OPENSSL */
{
msg = pack_ip_datagram(dgram);
write_to_bearerbox(msg);
}
} else {
msg_sequence = counter_increase(sequence_counter) & 0xff;
msg = pack_sms_datagram(dgram);
sms_datagrams = sms_split(msg, NULL, NULL, NULL, NULL, concatenation,
msg_sequence, max_messages, MAX_SMS_OCTETS);
debug("wap",0,"WDP (wapbox): delivering %ld segments to bearerbox",
gwlist_len(sms_datagrams));
while ((part = gwlist_extract_first(sms_datagrams)) != NULL) {
write_to_bearerbox(part);
}
gwlist_destroy(sms_datagrams, NULL);
msg_destroy(msg);
}
wap_event_destroy(dgram);
}
/*
* Send a message to the bearerbox for delivery to a phone.
* Return >= 0 for success & count of splitted sms messages,
* -1 for failure. Does not destroy the msg.
*/
static int send_message(Msg *msg)
{
unsigned long msg_count;
List *list;
gw_assert(msg != NULL);
gw_assert(msg_type(msg) == sms);
/*
* Encode our smsbox-id to the msg structure.
* This will allow bearerbox to return specific answers to the
* same smsbox, mainly for DLRs and SMS proxy modes.
*
* In addition the -x flag can be used to identify the mtbatch
* instance with an own smsbox-id, but let the normal smsbox
* daemons handle the DLRs coming back, as the mtbatch shuts down
* after all MTs have been injected. It's not meant to process
* the DLR messages.
*/
if (no_smsbox_id == 0 && smsbox_id != NULL) {
msg->sms.boxc_id = octstr_duplicate(smsbox_id);
}
list = sms_split(msg, NULL, NULL, NULL, NULL, 1, 0, 100, MAX_SMS_OCTETS);
msg_count = gwlist_len(list);
gwlist_destroy(list, msg_destroy_item);
debug("sms", 0, "message length %ld, sending %ld messages",
octstr_len(msg->sms.msgdata), msg_count);
if (delay > 0)
gwthread_sleep(delay);
/* pass message to bearerbox */
if (deliver_to_bearerbox(msg) != 0)
return -1;
return msg_count;
}
int smscconn_send(SMSCConn *conn, Msg *msg)
{
int ret = -1;
List *parts = NULL;
gw_assert(conn != NULL);
mutex_lock(conn->flow_mutex);
if (conn->status == SMSCCONN_DEAD || conn->why_killed != SMSCCONN_ALIVE) {
mutex_unlock(conn->flow_mutex);
return -1;
}
/* if this a retry of splitted message, don't unify prefix and don't try to split */
if (msg->sms.split_parts == NULL) {
/* normalize the destination number for this smsc */
char *uf = conn->unified_prefix ? octstr_get_cstr(conn->unified_prefix) : NULL;
normalize_number(uf, &(msg->sms.receiver));
/* split msg */
parts = sms_split(msg, NULL, NULL, NULL, NULL, 1,
counter_increase(split_msg_counter) & 0xff, 0xff, conn->max_sms_octets);
if (gwlist_len(parts) == 1) {
/* don't create split_parts of sms fit into one */
gwlist_destroy(parts, msg_destroy_item);
parts = NULL;
}
}
if (parts == NULL)
ret = conn->send_msg(conn, msg);
else {
long i, parts_len = gwlist_len(parts);
struct split_parts *split = gw_malloc(sizeof(*split));
/* must duplicate, because smsc2_route will destroy this msg */
split->orig = msg_duplicate(msg);
split->parts_left = counter_create();
split->status = SMSCCONN_SUCCESS;
counter_set(split->parts_left, parts_len);
split->smsc_conn = conn;
debug("bb.sms.splits", 0, "new split_parts created %p", split);
for (i = 0; i < parts_len; i++) {
msg = gwlist_get(parts, i);
msg->sms.split_parts = split;
ret = conn->send_msg(conn, msg);
if (ret < 0) {
if (i == 0) {
counter_destroy(split->parts_left);
gwlist_destroy(parts, msg_destroy_item);
gw_free(split);
mutex_unlock(conn->flow_mutex);
return ret;
}
/*
* Some parts were sent. So handle this within
* bb_smscconn_XXX().
*/
split->status = SMSCCONN_FAILED_REJECTED;
counter_increase_with(split->parts_left, -(parts_len - i));
warning(0, "Could not send all parts of a split message");
break;
}
}
gwlist_destroy(parts, msg_destroy_item);
}
mutex_unlock(conn->flow_mutex);
return ret;
}
