/*
* 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;
}
static void wdp_router(void *arg)
{
Msg *msg;
gwlist_add_producer(flow_threads);
while (bb_status != BB_DEAD) {
if ((msg = gwlist_consume(outgoing_wdp)) == NULL)
break;
gw_assert(msg_type(msg) == wdp_datagram);
/*
if (msg->list == sms)
smsc_addwdp(msg);
else
*/
udp_addwdp(msg);
}
udp_die();
/* smsc_endwdp(); */
gwlist_remove_producer(flow_threads);
}
static void dispatch_into_queue(Msg *msg)
{
char id[UUID_STR_LEN + 1];
gw_assert(msg != NULL),
gw_assert(msg_type(msg) == sms);
switch (msg->sms.sms_type) {
case mt_push:
case mt_reply:
case report_mt:
gwlist_append(outgoing_sms, msg);
break;
case mo:
case report_mo:
gwlist_append(incoming_sms, msg);
break;
default:
uuid_unparse(msg->sms.id, id);
error(0, "Not handled sms_type %ld within store for message ID %s",
msg->sms.sms_type, id);
msg_destroy(msg);
break;
}
}
static int store_file_save_ack(Msg *msg, ack_status_t status)
{
Msg *mack;
int ret;
/* only sms are handled */
if (!msg || msg_type(msg) != sms)
return -1;
if (filename == NULL)
return 0;
mack = msg_create(ack);
if (!mack)
return -1;
mack->ack.time = msg->sms.time;
uuid_copy(mack->ack.id, msg->sms.id);
mack->ack.nack = status;
ret = store_save(mack);
msg_destroy(mack);
return ret;
}
static int anc_data_recv(struct msghdr *m, struct tipc_msg *msg,
struct tipc_port *tport)
{
u32 anc_data[3];
u32 err;
u32 dest_type;
int has_name;
int res;
if (likely(m->msg_controllen == 0))
return 0;
/* Optionally capture errored message object(s) */
err = msg ? msg_errcode(msg) : 0;
if (unlikely(err)) {
anc_data[0] = err;
anc_data[1] = msg_data_sz(msg);
if ((res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data)))
return res;
if (anc_data[1] &&
(res = put_cmsg(m, SOL_TIPC, TIPC_RETDATA, anc_data[1],
msg_data(msg))))
return res;
}
/* Optionally capture message destination object */
dest_type = msg ? msg_type(msg) : TIPC_DIRECT_MSG;
switch (dest_type) {
case TIPC_NAMED_MSG:
has_name = 1;
anc_data[0] = msg_nametype(msg);
anc_data[1] = msg_namelower(msg);
anc_data[2] = msg_namelower(msg);
break;
case TIPC_MCAST_MSG:
has_name = 1;
anc_data[0] = msg_nametype(msg);
anc_data[1] = msg_namelower(msg);
anc_data[2] = msg_nameupper(msg);
break;
case TIPC_CONN_MSG:
has_name = (tport->conn_type != 0);
anc_data[0] = tport->conn_type;
anc_data[1] = tport->conn_instance;
anc_data[2] = tport->conn_instance;
break;
default:
has_name = 0;
}
if (has_name &&
(res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data)))
return res;
return 0;
}
/**
* tipc_disc_rcv - handle incoming discovery message (request or response)
* @net: the applicable net namespace
* @buf: buffer containing message
* @bearer: bearer that message arrived on
*/
void tipc_disc_rcv(struct net *net, struct sk_buff *skb,
struct tipc_bearer *bearer)
{
struct tipc_net *tn = net_generic(net, tipc_net_id);
struct tipc_media_addr maddr;
struct sk_buff *rskb;
struct tipc_msg *hdr = buf_msg(skb);
u32 ddom = msg_dest_domain(hdr);
u32 onode = msg_prevnode(hdr);
u32 net_id = msg_bc_netid(hdr);
u32 mtyp = msg_type(hdr);
u32 signature = msg_node_sig(hdr);
u16 caps = msg_node_capabilities(hdr);
bool respond = false;
bool dupl_addr = false;
int err;
err = bearer->media->msg2addr(bearer, &maddr, msg_media_addr(hdr));
kfree_skb(skb);
if (err)
return;
/* Ensure message from node is valid and communication is permitted */
if (net_id != tn->net_id)
return;
if (maddr.broadcast)
return;
if (!tipc_addr_domain_valid(ddom))
return;
if (!tipc_addr_node_valid(onode))
return;
if (in_own_node(net, onode)) {
if (memcmp(&maddr, &bearer->addr, sizeof(maddr)))
disc_dupl_alert(bearer, tn->own_addr, &maddr);
return;
}
if (!tipc_in_scope(ddom, tn->own_addr))
return;
if (!tipc_in_scope(bearer->domain, onode))
return;
tipc_node_check_dest(net, onode, bearer, caps, signature,
&maddr, &respond, &dupl_addr);
if (dupl_addr)
disc_dupl_alert(bearer, onode, &maddr);
/* Send response, if necessary */
if (respond && (mtyp == DSC_REQ_MSG)) {
rskb = tipc_buf_acquire(MAX_H_SIZE, GFP_ATOMIC);
if (!rskb)
return;
tipc_disc_init_msg(net, rskb, DSC_RESP_MSG, bearer);
tipc_bearer_xmit_skb(net, bearer->identity, rskb, &maddr);
}
}
void bb_alog_sms(SMSCConn *conn, Msg *msg, const char *message)
{
Octstr *text = NULL;
gw_assert(msg_type(msg) == sms);
/* if we don't have any custom log, then use our "default" one */
if (custom_log_format == NULL) {
Octstr *udh;
const Octstr *cid;
text = msg->sms.msgdata ? octstr_duplicate(msg->sms.msgdata) : octstr_create("");
udh = msg->sms.udhdata ? octstr_duplicate(msg->sms.udhdata) : octstr_create("");
if (conn && smscconn_id(conn))
cid = smscconn_id(conn);
else if (conn && smscconn_name(conn))
cid = smscconn_name(conn);
else if (msg->sms.smsc_id)
cid = msg->sms.smsc_id;
else
cid = octstr_imm("");
if ((msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2))
octstr_binary_to_hex(text, 1);
else
octstr_convert_printable(text);
octstr_binary_to_hex(udh, 1);
alog("%s [SMSC:%s] [SVC:%s] [ACT:%s] [BINF:%s] [FID:%s] [META:%s] [from:%s] [to:%s] [flags:%ld:%ld:%ld:%ld:%ld] "
"[msg:%ld:%s] [udh:%ld:%s]",
message,
octstr_get_cstr(cid),
msg->sms.service ? octstr_get_cstr(msg->sms.service) : "",
msg->sms.account ? octstr_get_cstr(msg->sms.account) : "",
msg->sms.binfo ? octstr_get_cstr(msg->sms.binfo) : "",
msg->sms.foreign_id ? octstr_get_cstr(msg->sms.foreign_id) : "",
msg->sms.meta_data ? octstr_get_cstr(msg->sms.meta_data) : "",
msg->sms.sender ? octstr_get_cstr(msg->sms.sender) : "",
msg->sms.receiver ? octstr_get_cstr(msg->sms.receiver) : "",
msg->sms.mclass, msg->sms.coding, msg->sms.mwi, msg->sms.compress,
msg->sms.dlr_mask,
octstr_len(msg->sms.msgdata), octstr_get_cstr(text),
octstr_len(msg->sms.udhdata), octstr_get_cstr(udh)
);
octstr_destroy(udh);
} else {
text = get_pattern(conn, msg, message);
alog("%s", octstr_get_cstr(text));
}
octstr_destroy(text);
}
u32 tipc_msg_tot_importance(struct tipc_msg *m)
{
if (likely(msg_isdata(m))) {
if (likely(msg_orignode(m) == tipc_own_addr))
return msg_importance(m);
return msg_importance(m) + 4;
}
if ((msg_user(m) == MSG_FRAGMENTER) &&
(msg_type(m) == FIRST_FRAGMENT))
return msg_importance(msg_get_wrapped(m));
return msg_importance(m);
}
static int store_to_dict(Msg *msg)
{
Msg *copy;
Octstr *uuid_os;
char id[UUID_STR_LEN + 1];
/* always set msg id and timestamp */
if (msg_type(msg) == sms && uuid_is_null(msg->sms.id))
uuid_generate(msg->sms.id);
if (msg_type(msg) == sms && msg->sms.time == MSG_PARAM_UNDEFINED)
time(&msg->sms.time);
if (msg_type(msg) == sms) {
copy = msg_duplicate(msg);
uuid_unparse(copy->sms.id, id);
uuid_os = octstr_create(id);
dict_put(sms_dict, uuid_os, copy);
octstr_destroy(uuid_os);
last_dict_mod = time(NULL);
} else if (msg_type(msg) == ack) {
uuid_unparse(msg->ack.id, id);
uuid_os = octstr_create(id);
copy = dict_remove(sms_dict, uuid_os);
octstr_destroy(uuid_os);
if (copy == NULL) {
warning(0, "bb_store: get ACK of message not found "
"from store, strange?");
} else {
msg_destroy(copy);
last_dict_mod = time(NULL);
}
} else
return -1;
return 0;
}
static void boxc_sent_push(Boxc *conn, Msg *m)
{
Octstr *os;
char id[UUID_STR_LEN + 1];
if (conn->is_wap || !conn->sent || !m || msg_type(m) != sms)
return;
uuid_unparse(m->sms.id, id);
os = octstr_create(id);
dict_put(conn->sent, os, msg_duplicate(m));
semaphore_down(conn->pending);
octstr_destroy(os);
}
int smscenter_receive_msg(SMSCenter *smsc, Msg **msg)
{
int ret;
smscenter_lock(smsc);
switch (smsc->type) {
case SMSC_TYPE_CIMD:
ret = cimd_receive_msg(smsc, msg);
if (ret == -1)
goto error;
break;
case SMSC_TYPE_EMI_X25:
ret = emi_receive_msg(smsc, msg);
if (ret == -1)
goto error;
break;
case SMSC_TYPE_OIS:
ret = ois_receive_msg(smsc, msg);
if (ret == -1)
goto error;
break;
case SMSC_TYPE_SEMA_X28:
ret = sema_receive_msg(smsc, msg);
if (ret == -1)
goto error;
break;
default:
goto error;
}
smscenter_unlock(smsc);
/* If the SMSC didn't set the timestamp, set it here. */
if (ret == 1 && msg_type(*msg) == sms && (*msg)->sms.time == 0)
time(&(*msg)->sms.time);
return ret;
error:
smscenter_unlock(smsc);
return -1;
}
static void boxc_sender(void *arg)
{
Msg *msg;
Boxc *conn = arg;
gwlist_add_producer(flow_threads);
while (bb_status != BB_DEAD && conn->alive) {
/*
* Make sure there's no data left in the outgoing connection before
* doing the potentially blocking gwlist_consume()s
*/
conn_flush(conn->conn);
gwlist_consume(suspended); /* block here if suspended */
if ((msg = gwlist_consume(conn->incoming)) == NULL) {
/* tell sms/wapbox to die */
msg = msg_create(admin);
msg->admin.command = restart ? cmd_restart : cmd_shutdown;
send_msg(conn, msg);
msg_destroy(msg);
break;
}
if (msg_type(msg) == heartbeat) {
debug("bb.boxc", 0, "boxc_sender: catch an heartbeat - we are alive");
msg_destroy(msg);
continue;
}
boxc_sent_push(conn, msg);
if (!conn->alive || send_msg(conn, msg) == -1) {
/* we got message here */
boxc_sent_pop(conn, msg, NULL);
gwlist_produce(conn->retry, msg);
break;
}
msg_destroy(msg);
debug("bb.boxc", 0, "boxc_sender: sent message to <%s>",
octstr_get_cstr(conn->client_ip));
}
/* the client closes the connection, after that die in receiver */
/* conn->alive = 0; */
/* set conn to unroutable */
conn->routable = 0;
gwlist_remove_producer(flow_threads);
}
/*
* this thread listens to incoming_wdp list
* and then routs messages to proper wapbox
*/
static void wdp_to_wapboxes(void *arg)
{
List *route_info;
AddrPar *ap;
Boxc *conn;
Msg *msg;
int i;
gwlist_add_producer(flow_threads);
gwlist_add_producer(wapbox_list);
route_info = gwlist_create();
while(bb_status != BB_DEAD) {
gwlist_consume(suspended); /* block here if suspended */
if ((msg = gwlist_consume(incoming_wdp)) == NULL)
break;
gw_assert(msg_type(msg) == wdp_datagram);
conn = route_msg(route_info, msg);
if (conn == NULL) {
warning(0, "Cannot route message, discard it");
msg_destroy(msg);
continue;
}
gwlist_produce(conn->incoming, msg);
}
debug("bb", 0, "wdp_to_wapboxes: destroying lists");
while((ap = gwlist_extract_first(route_info)) != NULL)
ap_destroy(ap);
gw_assert(gwlist_len(route_info) == 0);
gwlist_destroy(route_info, NULL);
gwlist_lock(wapbox_list);
for(i=0; i < gwlist_len(wapbox_list); i++) {
conn = gwlist_get(wapbox_list, i);
gwlist_remove_producer(conn->incoming);
conn->alive = 0;
}
gwlist_unlock(wapbox_list);
gwlist_remove_producer(wapbox_list);
gwlist_remove_producer(flow_threads);
}
/*
* this function receives an WDP message and checks if a UDP
* service for this client has to be created
*/
static int udp_addwdp_from_client(Msg *msg)
{
Udpc *udpc;
Octstr *map_addr;
Octstr *os;
Octstr *source;
if (!udp_running) return -1;
assert(msg != NULL);
assert(msg_type(msg) == wdp_datagram);
/*
* Check if there is allready a bound UDP port for this mapping.
* If not create a mapping and bind the mapped UDP port
* The mapped port is simply 2x of the client port.
*/
if ((udpc = udpc_find_mapping(msg, 1)) == NULL) {
info(0, "Creating UDP mapping <%s:%ld> <-> <%s:%ld>",
octstr_get_cstr(msg->wdp_datagram.source_address),
msg->wdp_datagram.source_port,
octstr_get_cstr(msg->wdp_datagram.destination_address),
msg->wdp_datagram.source_port*2);
map_addr = udp_create_address(msg->wdp_datagram.source_address,
msg->wdp_datagram.source_port);
add_service(msg->wdp_datagram.source_port * 2,
octstr_get_cstr(interface_name), map_addr);
/* now we should find it in the udpc_list */
if ((udpc = udpc_find_mapping(msg, 1)) == NULL)
panic(0,"Could not find UDP mapping, internal error");
}
/* now swap the message addressing */
octstr_destroy(msg->wdp_datagram.source_address);
octstr_destroy(msg->wdp_datagram.destination_address);
os = octstr_duplicate(interface_name);
source = udp_create_address(os, msg->wdp_datagram.source_port * 2);
msg->wdp_datagram.source_address = udp_get_ip(source);
msg->wdp_datagram.source_port = udp_get_port(source);
msg->wdp_datagram.destination_address = octstr_duplicate(wapgw);
msg->wdp_datagram.destination_port = CONNECTION_ORIENTED_PORT;
octstr_destroy(os);
gwlist_produce(udpc->outgoing_list, msg);
return -1;
}
/*
* this function receives an WDP message and adds it to
* corresponding outgoing_list.
*/
static int udp_addwdp_from_server(Msg *msg)
{
Udpc *udpc;
Octstr *os;
Octstr *source;
if (!udp_running) return -1;
assert(msg != NULL);
assert(msg_type(msg) == wdp_datagram);
octstr_destroy(msg->wdp_datagram.source_address);
msg->wdp_datagram.source_address =
octstr_create(octstr_get_cstr(msg->wdp_datagram.destination_address));
msg->wdp_datagram.source_port = msg->wdp_datagram.destination_port;
if ((udpc = udpc_find_mapping(msg, 0)) == NULL)
/* there should have been one */
panic(0,"Could not find UDP mapping, internal error");
/* insert the found mapped destination */
octstr_destroy(msg->wdp_datagram.source_address);
octstr_destroy(msg->wdp_datagram.destination_address);
msg->wdp_datagram.destination_address = udp_get_ip(udpc->map_addr);
msg->wdp_datagram.destination_port = udp_get_port(udpc->map_addr);
/* now search for our inbound UDP socket */
os = octstr_duplicate(interface_name);
source = udp_create_address(os, server_port);
msg->wdp_datagram.source_address = udp_get_ip(source);
msg->wdp_datagram.source_port = udp_get_port(source);
if ((udpc = udpc_find_mapping(msg, 0)) == NULL)
panic(0,"Could not find main inbound UDP socket, internal error");
/*
* ok, got the destination, got the socket,
* now put it on the outbound queue
*/
gwlist_produce(udpc->outgoing_list, msg);
octstr_destroy(os);
return 0;
}
int ois_submit_msg(SMSCenter *smsc, const Msg *msg)
{
int ret;
ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
SAY(2, "ois_submit_msg");
ois_swap_buffering(smsc);
if (msg_type((Msg *)msg) != sms) {
error(0, "ois_submit_msg: can not handle message types other than smart_msg");
goto error;
}
if (smsc->socket == -1) {
ret = ois_open_sender(smsc);
if (ret < 0) {
goto error;
}
}
ret = ois_submit_sm_invoke(smsc, msg);
if (ret < 0) {
goto error_close;
}
++smsc->ois_ack_debt;
time(&smsc->ois_alive);
ret = 0;
goto out;
error_close:
if (smsc->ois_ack_debt != 0) {
warning(0, "ois_submit_msg: missing %d ack(s)...",
smsc->ois_ack_debt);
}
SAY(4, "ois_submit_msg: ois_disconnect in error_close");
ois_disconnect(smsc);
error:
SAY(2, "ois_submit_msg error");
ret = -1;
out:
ois_swap_buffering(smsc);
return ret;
}
static transform_indicator_t< SOURCE >
limit_then_transform(
unsigned int limit,
LAMBDA transformator )
{
ensure_signal< SOURCE >();
action_t act = [transformator]( const overlimit_context_t & ctx ) {
// Service request cannot be transformed.
// So ensure that is event, not service request.
impl::ensure_event_transform_reaction( ctx );
auto r = transformator();
impl::transform_reaction(
ctx, r.mbox(), r.msg_type(), r.message() );
};
return transform_indicator_t< SOURCE >{ limit, std::move( act ) };
}
static void dispatch_into_queue(Msg *msg)
{
gw_assert(msg != NULL),
gw_assert(msg_type(msg) == sms);
switch (msg->sms.sms_type) {
case mt_push:
case mt_reply:
case report_mt:
gwlist_append(outgoing_sms, msg);
break;
case mo:
case report_mo:
gwlist_append(incoming_sms, msg);
break;
default:
panic(0, "Not handled sms_type within store!");
}
}
static void service_router(void *arg)
{
Msg *msg;
gwlist_add_producer(flow_threads);
while (1) {
if ((msg = gwlist_consume(incoming_wdp)) == NULL)
break;
gw_assert(msg_type(msg) == wdp_datagram);
udp_addwdp_from_client(msg);
}
udp_die();
gwlist_remove_producer(flow_threads);
}
static transform_indicator_t< ARG >
limit_then_transform(
unsigned int limit,
LAMBDA transformator )
{
ensure_not_signal< ARG >();
action_t act = [transformator]( const overlimit_context_t & ctx ) {
// Service request cannot be transformed.
// So ensure that is event, not service request.
impl::ensure_event_transform_reaction( ctx );
const ARG & msg = dynamic_cast< const ARG & >(
*ctx.m_message.get() );
auto r = transformator( msg );
impl::transform_reaction(
ctx, r.mbox(), r.msg_type(), r.message() );
};
return transform_indicator_t< ARG >{ limit, std::move( act ) };
}
static WAPEvent *wdp_msg2event(Msg *msg)
{
WAPEvent *dgram = NULL;
gw_assert(msg_type(msg) == wdp_datagram);
if (msg->wdp_datagram.destination_port == server_port ||
msg->wdp_datagram.source_port == server_port ||
msg->wdp_datagram.destination_port == CONNECTION_ORIENTED_PORT ||
msg->wdp_datagram.source_port == CONNECTION_ORIENTED_PORT) {
dgram = wap_event_create(T_DUnitdata_Ind);
dgram->u.T_DUnitdata_Ind.addr_tuple = wap_addr_tuple_create(
msg->wdp_datagram.source_address,
msg->wdp_datagram.source_port,
msg->wdp_datagram.destination_address,
msg->wdp_datagram.destination_port);
dgram->u.T_DUnitdata_Ind.user_data =
octstr_duplicate(msg->wdp_datagram.user_data);
}
return 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;
}
void GpsController::GpsCallback(const std_msgs::String::ConstPtr& msg)
{
char a[100];
char nmea_type[7];
char temp[10];
int i = 0;
char lon_dir, lat_dir;
string str = msg->data;
while (str[i] != '\0') { a[i] = str[i]; i++; } //move everything into char array for access
for (i = 0; i < 6; i++)
nmea_type[i] = a[i];
string msg_type(nmea_type);
if (msg_type[4] == 'G' && msg_type[5] == 'A'){
msg_flag = true;
for (i = 18; i < 30; i++)
temp [i-18] = a[i];
lon_dir = a[31];
//cout << lon_dir << endl;
if (lon_dir == 'N')
CurrentWaypoint.lon = atof(temp)/100 - offWaypoint.lon;
else if (lon_dir == 'S')
CurrentWaypoint.lon = (-1)*(atof(temp)/100) - offWaypoint.lon;
for (i = 33; i < 45; i++)
temp [i-33] = a[i];
lat_dir = a[47];
//cout << lat_dir << endl;
if (lat_dir == 'E')
CurrentWaypoint.lat = atof(temp)/100 - offWaypoint.lat;
else if (lat_dir == 'W')
CurrentWaypoint.lat = (-1)*(atof(temp)/100) - offWaypoint.lat;
}
else{
msg_flag = false;
cout << "Did not receive proper gps data" << endl;
}
return;
}
/*
* this function receives an WDP message and adds it to
* corresponding outgoing_list.
*/
int udp_addwdp(Msg *msg)
{
int i;
Udpc *udpc, *def_udpc;
Octstr *ip;
def_udpc = NULL;
if (!udp_running) return -1;
assert(msg != NULL);
assert(msg_type(msg) == wdp_datagram);
gwlist_lock(udpc_list);
/* select in which list to add this */
for (i=0; i < gwlist_len(udpc_list); i++) {
udpc = gwlist_get(udpc_list, i);
if (msg->wdp_datagram.source_port == udp_get_port(udpc->addr)) {
def_udpc = udpc;
ip = udp_get_ip(udpc->addr);
if (octstr_compare(msg->wdp_datagram.source_address, ip) == 0) {
octstr_destroy(ip);
gwlist_produce(udpc->outgoing_list, msg);
gwlist_unlock(udpc_list);
return 0;
}
octstr_destroy(ip);
}
}
if (NULL != def_udpc) {
gwlist_produce(def_udpc->outgoing_list, msg);
gwlist_unlock(udpc_list);
return 0;
}
gwlist_unlock(udpc_list);
return -1;
}
void CALLBACK
fluid_winmidi_callback(HMIDIIN hmi, UINT wMsg, DWORD dwInstance, DWORD msg, DWORD extra)
{
fluid_winmidi_driver_t* dev = (fluid_winmidi_driver_t *) dwInstance;
switch (wMsg) {
case MIM_OPEN:
break;
case MIM_CLOSE:
break;
case MIM_DATA:
{
fluid_midi_event_t event;
event.type = msg_type(msg);
event.channel = msg_chan(msg);
event.param1 = msg_p1(msg);
event.param2 = msg_p2(msg);
(*dev->driver.handler)(dev->driver.data, &event);
}
break;
case MIM_LONGDATA:
break;
case MIM_ERROR:
break;
case MIM_LONGERROR:
break;
case MIM_MOREDATA:
break;
}
}
int smscconn_usable(SMSCConn *conn, Msg *msg)
{
gw_assert(conn != NULL);
gw_assert(msg != NULL && msg_type(msg) == sms);
if (conn->status == SMSCCONN_DEAD || conn->why_killed != SMSCCONN_ALIVE)
return -1;
/* if allowed-smsc-id set, then only allow this SMSC if message
* smsc-id matches any of its allowed SMSCes
*/
if (conn->allowed_smsc_id && (msg->sms.smsc_id == NULL ||
gwlist_search(conn->allowed_smsc_id, msg->sms.smsc_id, octstr_item_match) == NULL)) {
return -1;
}
/* ..if no allowed-smsc-id set but denied-smsc-id and message smsc-id
* is set, deny message if smsc-ids match */
else if (conn->denied_smsc_id && msg->sms.smsc_id != NULL &&
gwlist_search(conn->denied_smsc_id, msg->sms.smsc_id, octstr_item_match) != NULL) {
return -1;
}
if (conn->allowed_smsc_id_regex) {
if (msg->sms.smsc_id == NULL)
return -1;
if (gw_regex_match_pre(conn->allowed_smsc_id_regex, msg->sms.smsc_id) == 0)
return -1;
}
else if (conn->denied_smsc_id_regex && msg->sms.smsc_id != NULL) {
if (gw_regex_match_pre(conn->denied_smsc_id_regex, msg->sms.smsc_id) == 1)
return -1;
}
/* Have allowed */
if (conn->allowed_prefix && ! conn->denied_prefix &&
(does_prefix_match(conn->allowed_prefix, msg->sms.receiver) != 1))
return -1;
if (conn->allowed_prefix_regex && ! conn->denied_prefix_regex) {
if (gw_regex_match_pre(conn->allowed_prefix_regex, msg->sms.receiver) == 0)
return -1;
}
/* Have denied */
if (conn->denied_prefix && ! conn->allowed_prefix &&
(does_prefix_match(conn->denied_prefix, msg->sms.receiver) == 1))
return -1;
if (conn->denied_prefix_regex && ! conn->allowed_prefix_regex) {
if (gw_regex_match_pre(conn->denied_prefix_regex, msg->sms.receiver) == 1)
return -1;
}
/* Have allowed and denied */
if (conn->denied_prefix && conn->allowed_prefix &&
(does_prefix_match(conn->allowed_prefix, msg->sms.receiver) != 1) &&
(does_prefix_match(conn->denied_prefix, msg->sms.receiver) == 1) )
return -1;
if (conn->allowed_prefix_regex && conn->denied_prefix_regex) {
if (gw_regex_match_pre(conn->allowed_prefix_regex, msg->sms.receiver) == 0 &&
gw_regex_match_pre(conn->denied_prefix_regex, msg->sms.receiver) == 1)
return -1;
}
/* then see if it is preferred one */
if (conn->preferred_smsc_id && msg->sms.smsc_id != NULL &&
gwlist_search(conn->preferred_smsc_id, msg->sms.smsc_id, octstr_item_match) != NULL) {
return 1;
}
if (conn->preferred_prefix)
if (does_prefix_match(conn->preferred_prefix, msg->sms.receiver) == 1)
return 1;
if (conn->preferred_prefix_regex &&
gw_regex_match_pre(conn->preferred_prefix_regex, msg->sms.receiver) == 1) {
return 1;
}
return 0;
}
int handle_message( const char *way,
mbedtls_net_context *dst,
mbedtls_net_context *src )
{
int ret;
packet cur;
size_t id;
/* receive packet */
if( ( ret = mbedtls_net_recv( src, cur.buf, sizeof( cur.buf ) ) ) <= 0 )
{
mbedtls_printf( " ! mbedtls_net_recv returned %d\n", ret );
return( ret );
}
cur.len = ret;
cur.type = msg_type( cur.buf, cur.len );
cur.way = way;
cur.dst = dst;
print_packet( &cur, NULL );
id = cur.len % sizeof( dropped );
/* do we want to drop, delay, or forward it? */
if( ( opt.mtu != 0 &&
cur.len > (unsigned) opt.mtu ) ||
( opt.drop != 0 &&
strcmp( cur.type, "ApplicationData" ) != 0 &&
! ( opt.protect_hvr &&
strcmp( cur.type, "HelloVerifyRequest" ) == 0 ) &&
cur.len != (size_t) opt.protect_len &&
dropped[id] < DROP_MAX &&
rand() % opt.drop == 0 ) )
{
update_dropped( &cur );
}
else if( ( opt.delay_ccs == 1 &&
strcmp( cur.type, "ChangeCipherSpec" ) == 0 ) ||
( opt.delay != 0 &&
strcmp( cur.type, "ApplicationData" ) != 0 &&
! ( opt.protect_hvr &&
strcmp( cur.type, "HelloVerifyRequest" ) == 0 ) &&
prev.dst == NULL &&
cur.len != (size_t) opt.protect_len &&
dropped[id] < DROP_MAX &&
rand() % opt.delay == 0 ) )
{
memcpy( &prev, &cur, sizeof( packet ) );
}
else
{
/* forward and possibly duplicate */
if( ( ret = send_packet( &cur, "forwarded" ) ) != 0 )
return( ret );
/* send previously delayed message if any */
if( prev.dst != NULL )
{
ret = send_packet( &prev, "delayed" );
memset( &prev, 0, sizeof( packet ) );
if( ret != 0 )
return( ret );
}
}
return( 0 );
}
/**
* tipc_bclink_recv_pkt - receive a broadcast packet, and deliver upwards
*
* tipc_net_lock is read_locked, no other locks set
*/
void tipc_bclink_recv_pkt(struct sk_buff *buf)
{
struct tipc_msg *msg = buf_msg(buf);
struct tipc_node *node;
u32 next_in;
u32 seqno;
int deferred;
/* Screen out unwanted broadcast messages */
if (msg_mc_netid(msg) != tipc_net_id)
goto exit;
node = tipc_node_find(msg_prevnode(msg));
if (unlikely(!node))
goto exit;
tipc_node_lock(node);
if (unlikely(!node->bclink.recv_permitted))
goto unlock;
/* Handle broadcast protocol message */
if (unlikely(msg_user(msg) == BCAST_PROTOCOL)) {
if (msg_type(msg) != STATE_MSG)
goto unlock;
if (msg_destnode(msg) == tipc_own_addr) {
tipc_bclink_acknowledge(node, msg_bcast_ack(msg));
tipc_node_unlock(node);
spin_lock_bh(&bc_lock);
bcl->stats.recv_nacks++;
bclink->retransmit_to = node;
bclink_retransmit_pkt(msg_bcgap_after(msg),
msg_bcgap_to(msg));
spin_unlock_bh(&bc_lock);
} else {
tipc_node_unlock(node);
bclink_peek_nack(msg);
}
goto exit;
}
/* Handle in-sequence broadcast message */
seqno = msg_seqno(msg);
next_in = mod(node->bclink.last_in + 1);
if (likely(seqno == next_in)) {
receive:
/* Deliver message to destination */
if (likely(msg_isdata(msg))) {
spin_lock_bh(&bc_lock);
bclink_accept_pkt(node, seqno);
spin_unlock_bh(&bc_lock);
tipc_node_unlock(node);
if (likely(msg_mcast(msg)))
tipc_port_recv_mcast(buf, NULL);
else
kfree_skb(buf);
} else if (msg_user(msg) == MSG_BUNDLER) {
spin_lock_bh(&bc_lock);
bclink_accept_pkt(node, seqno);
bcl->stats.recv_bundles++;
bcl->stats.recv_bundled += msg_msgcnt(msg);
spin_unlock_bh(&bc_lock);
tipc_node_unlock(node);
tipc_link_recv_bundle(buf);
} else if (msg_user(msg) == MSG_FRAGMENTER) {
int ret = tipc_link_recv_fragment(&node->bclink.defragm,
&buf, &msg);
if (ret < 0)
goto unlock;
spin_lock_bh(&bc_lock);
bclink_accept_pkt(node, seqno);
bcl->stats.recv_fragments++;
if (ret > 0)
bcl->stats.recv_fragmented++;
spin_unlock_bh(&bc_lock);
tipc_node_unlock(node);
tipc_net_route_msg(buf);
} else if (msg_user(msg) == NAME_DISTRIBUTOR) {
spin_lock_bh(&bc_lock);
bclink_accept_pkt(node, seqno);
spin_unlock_bh(&bc_lock);
tipc_node_unlock(node);
tipc_named_recv(buf);
} else {
spin_lock_bh(&bc_lock);
bclink_accept_pkt(node, seqno);
spin_unlock_bh(&bc_lock);
tipc_node_unlock(node);
kfree_skb(buf);
}
buf = NULL;
/* Determine new synchronization state */
tipc_node_lock(node);
if (unlikely(!tipc_node_is_up(node)))
goto unlock;
if (node->bclink.last_in == node->bclink.last_sent)
goto unlock;
if (!node->bclink.deferred_head) {
node->bclink.oos_state = 1;
goto unlock;
}
msg = buf_msg(node->bclink.deferred_head);
seqno = msg_seqno(msg);
next_in = mod(next_in + 1);
if (seqno != next_in)
goto unlock;
/* Take in-sequence message from deferred queue & deliver it */
buf = node->bclink.deferred_head;
node->bclink.deferred_head = buf->next;
buf->next = NULL;
node->bclink.deferred_size--;
goto receive;
}
/* Handle out-of-sequence broadcast message */
if (less(next_in, seqno)) {
deferred = tipc_link_defer_pkt(&node->bclink.deferred_head,
&node->bclink.deferred_tail,
buf);
node->bclink.deferred_size += deferred;
bclink_update_last_sent(node, seqno);
buf = NULL;
} else
deferred = 0;
spin_lock_bh(&bc_lock);
if (deferred)
bcl->stats.deferred_recv++;
else
bcl->stats.duplicates++;
spin_unlock_bh(&bc_lock);
unlock:
tipc_node_unlock(node);
exit:
kfree_skb(buf);
}
void tipc_msg_dbg(struct print_buf *buf, struct tipc_msg *msg, const char *str)
{
u32 usr = msg_user(msg);
tipc_printf(buf, KERN_DEBUG);
tipc_printf(buf, str);
switch (usr) {
case MSG_BUNDLER:
tipc_printf(buf, "BNDL::");
tipc_printf(buf, "MSGS(%u):", msg_msgcnt(msg));
break;
case BCAST_PROTOCOL:
tipc_printf(buf, "BCASTP::");
break;
case MSG_FRAGMENTER:
tipc_printf(buf, "FRAGM::");
switch (msg_type(msg)) {
case FIRST_FRAGMENT:
tipc_printf(buf, "FIRST:");
break;
case FRAGMENT:
tipc_printf(buf, "BODY:");
break;
case LAST_FRAGMENT:
tipc_printf(buf, "LAST:");
break;
default:
tipc_printf(buf, "UNKNOWN:%x", msg_type(msg));
}
tipc_printf(buf, "NO(%u/%u):", msg_long_msgno(msg),
msg_fragm_no(msg));
break;
case TIPC_LOW_IMPORTANCE:
case TIPC_MEDIUM_IMPORTANCE:
case TIPC_HIGH_IMPORTANCE:
case TIPC_CRITICAL_IMPORTANCE:
tipc_printf(buf, "DAT%u:", msg_user(msg));
if (msg_short(msg)) {
tipc_printf(buf, "CON:");
break;
}
switch (msg_type(msg)) {
case TIPC_CONN_MSG:
tipc_printf(buf, "CON:");
break;
case TIPC_MCAST_MSG:
tipc_printf(buf, "MCST:");
break;
case TIPC_NAMED_MSG:
tipc_printf(buf, "NAM:");
break;
case TIPC_DIRECT_MSG:
tipc_printf(buf, "DIR:");
break;
default:
tipc_printf(buf, "UNKNOWN TYPE %u", msg_type(msg));
}
if (msg_reroute_cnt(msg))
tipc_printf(buf, "REROUTED(%u):",
msg_reroute_cnt(msg));
break;
case NAME_DISTRIBUTOR:
tipc_printf(buf, "NMD::");
switch (msg_type(msg)) {
case PUBLICATION:
tipc_printf(buf, "PUBL(%u):", (msg_size(msg) - msg_hdr_sz(msg)) / 20); /* Items */
break;
case WITHDRAWAL:
tipc_printf(buf, "WDRW:");
break;
default:
tipc_printf(buf, "UNKNOWN:%x", msg_type(msg));
}
if (msg_reroute_cnt(msg))
tipc_printf(buf, "REROUTED(%u):",
msg_reroute_cnt(msg));
break;
case CONN_MANAGER:
tipc_printf(buf, "CONN_MNG:");
switch (msg_type(msg)) {
case CONN_PROBE:
tipc_printf(buf, "PROBE:");
break;
case CONN_PROBE_REPLY:
tipc_printf(buf, "PROBE_REPLY:");
break;
case CONN_ACK:
tipc_printf(buf, "CONN_ACK:");
tipc_printf(buf, "ACK(%u):", msg_msgcnt(msg));
break;
default:
tipc_printf(buf, "UNKNOWN TYPE:%x", msg_type(msg));
}
if (msg_reroute_cnt(msg))
tipc_printf(buf, "REROUTED(%u):", msg_reroute_cnt(msg));
break;
case LINK_PROTOCOL:
switch (msg_type(msg)) {
case STATE_MSG:
tipc_printf(buf, "STATE:");
tipc_printf(buf, "%s:", msg_probe(msg) ? "PRB" : "");
tipc_printf(buf, "NXS(%u):", msg_next_sent(msg));
tipc_printf(buf, "GAP(%u):", msg_seq_gap(msg));
tipc_printf(buf, "LSTBC(%u):", msg_last_bcast(msg));
break;
case RESET_MSG:
tipc_printf(buf, "RESET:");
if (msg_size(msg) != msg_hdr_sz(msg))
tipc_printf(buf, "BEAR:%s:", msg_data(msg));
break;
case ACTIVATE_MSG:
tipc_printf(buf, "ACTIVATE:");
break;
default:
tipc_printf(buf, "UNKNOWN TYPE:%x", msg_type(msg));
}
tipc_printf(buf, "PLANE(%c):", msg_net_plane(msg));
tipc_printf(buf, "SESS(%u):", msg_session(msg));
break;
case CHANGEOVER_PROTOCOL:
tipc_printf(buf, "TUNL:");
switch (msg_type(msg)) {
case DUPLICATE_MSG:
tipc_printf(buf, "DUPL:");
break;
case ORIGINAL_MSG:
tipc_printf(buf, "ORIG:");
tipc_printf(buf, "EXP(%u)", msg_msgcnt(msg));
break;
default:
tipc_printf(buf, "UNKNOWN TYPE:%x", msg_type(msg));
}
break;
case LINK_CONFIG:
tipc_printf(buf, "CFG:");
switch (msg_type(msg)) {
case DSC_REQ_MSG:
tipc_printf(buf, "DSC_REQ:");
break;
case DSC_RESP_MSG:
tipc_printf(buf, "DSC_RESP:");
break;
default:
tipc_printf(buf, "UNKNOWN TYPE:%x:", msg_type(msg));
break;
}
break;
default:
tipc_printf(buf, "UNKNOWN USER:"******"NO_NAME:");
break;
case TIPC_ERR_NO_PORT:
tipc_printf(buf, "NO_PORT:");
break;
case TIPC_ERR_NO_NODE:
tipc_printf(buf, "NO_PROC:");
break;
case TIPC_ERR_OVERLOAD:
tipc_printf(buf, "OVERLOAD:");
break;
case TIPC_CONN_SHUTDOWN:
tipc_printf(buf, "SHUTDOWN:");
break;
default:
tipc_printf(buf, "UNKNOWN ERROR(%x):",
msg_errcode(msg));
}
default:
break;
}
tipc_printf(buf, "HZ(%u):", msg_hdr_sz(msg
static int store_spool_save(Msg *msg)
{
char id[UUID_STR_LEN + 1];
Octstr *id_s;
/* always set msg id and timestamp */
if (msg_type(msg) == sms && uuid_is_null(msg->sms.id))
uuid_generate(msg->sms.id);
if (msg_type(msg) == sms && msg->sms.time == MSG_PARAM_UNDEFINED)
time(&msg->sms.time);
if (spool == NULL)
return 0;
/* blocke here if store still not loaded */
gwlist_consume(loaded);
switch(msg_type(msg)) {
case sms:
{
Octstr *os = store_msg_pack(msg);
Octstr *filename, *dir;
int fd;
size_t wrc;
if (os == NULL) {
error(0, "Could not pack message.");
return -1;
}
uuid_unparse(msg->sms.id, id);
id_s = octstr_create(id);
dir = octstr_format("%S/%ld", spool, octstr_hash_key(id_s) % MAX_DIRS);
octstr_destroy(id_s);
if (mkdir(octstr_get_cstr(dir), S_IRUSR|S_IWUSR|S_IXUSR) == -1 && errno != EEXIST) {
error(errno, "Could not create directory `%s'.", octstr_get_cstr(dir));
octstr_destroy(dir);
octstr_destroy(os);
return -1;
}
filename = octstr_format("%S/%s", dir, id);
octstr_destroy(dir);
if ((fd = open(octstr_get_cstr(filename), O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR)) == -1) {
error(errno, "Could not open file `%s'.", octstr_get_cstr(filename));
octstr_destroy(filename);
octstr_destroy(os);
return -1;
}
for (wrc = 0; wrc < octstr_len(os); ) {
size_t rc = write(fd, octstr_get_cstr(os) + wrc, octstr_len(os) - wrc);
if (rc == -1) {
/* remove file */
error(errno, "Could not write message to `%s'.", octstr_get_cstr(filename));
close(fd);
if (unlink(octstr_get_cstr(filename)) == -1)
error(errno, "Oops, Could not remove failed file `%s'.", octstr_get_cstr(filename));
octstr_destroy(os);
octstr_destroy(filename);
return -1;
}
wrc += rc;
}
close(fd);
counter_increase(counter);
octstr_destroy(filename);
octstr_destroy(os);
break;
}
case ack:
{
Octstr *filename;
uuid_unparse(msg->ack.id, id);
id_s = octstr_create(id);
filename = octstr_format("%S/%ld/%s", spool, octstr_hash_key(id_s) % MAX_DIRS, id);
octstr_destroy(id_s);
if (unlink(octstr_get_cstr(filename)) == -1) {
error(errno, "Could not unlink file `%s'.", octstr_get_cstr(filename));
octstr_destroy(filename);
return -1;
}
counter_decrease(counter);
octstr_destroy(filename);
break;
}
default:
return -1;
}
return 0;
}
