/*
* Returns bearerbox ip address. Resolve it, if the address is localhost. Do
* not panic here. Even if we cannot do push, we still can do pull.
*/
static Octstr *name(Octstr *in)
{
if (octstr_compare(in, octstr_imm("localhost")) != 0)
return octstr_duplicate(in);
else
return octstr_duplicate(get_official_ip());
}
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));
}
}
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);
}
Capability *wsp_cap_duplicate(Capability *cap) {
Capability *new_cap;
if (!cap)
return NULL;
new_cap = wsp_cap_create(cap->id,
octstr_duplicate(cap->name),
octstr_duplicate(cap->data));
new_cap->accept = cap->accept;
return new_cap;
}
/*
* Add address from state machine.
*/
void add_wtls_address(Msg * msg, WTLSMachine * wtls_machine)
{
debug("wap.wtls", 0, "adding address");
msg->wdp_datagram.source_address =
octstr_duplicate(wtls_machine->addr_tuple->local->address);
msg->wdp_datagram.source_port = wtls_machine->addr_tuple->local->port;
msg->wdp_datagram.destination_address =
octstr_duplicate(wtls_machine->addr_tuple->remote->address);
msg->wdp_datagram.destination_port =
wtls_machine->addr_tuple->remote->port;
}
static DBConf *oracle_create_conf(Octstr *user,Octstr *pass, Octstr *db)
{
DBConf *conf;
conf = gw_malloc(sizeof(DBConf));
conf->oracle = gw_malloc(sizeof(OracleConf));
conf->oracle->username = octstr_duplicate(user);
conf->oracle->password = octstr_duplicate(pass);
conf->oracle->tnsname = octstr_duplicate(db);
return conf;
}
static int sms_to_client(Connection *client, Msg *msg)
{
Octstr *line;
Octstr *msgdata = NULL; /* NULL to allow octstr_destroy */
char *contents;
int len;
debug("bb.sms", 0, "smsc_fake: sending message to client");
// msg_dump(msg, 0);
line = octstr_duplicate(msg->sms.sender);
octstr_append_char(line, ' ');
octstr_append(line, msg->sms.receiver);
if (octstr_len(msg->sms.udhdata)) {
octstr_append(line, octstr_imm(" udh "));
msgdata = octstr_duplicate(msg->sms.udhdata);
octstr_url_encode(msgdata);
octstr_append(line, msgdata);
octstr_destroy(msgdata);
octstr_append_char(line, ' ');
msgdata = octstr_duplicate(msg->sms.msgdata);
octstr_url_encode(msgdata);
octstr_append(line, msgdata);
} else {
contents = octstr_get_cstr(msg->sms.msgdata);
len = octstr_len(msg->sms.msgdata);
while (len > 0) {
len--;
if (contents[len] < 32 || contents[len] > 126) {
octstr_append(line, octstr_imm(" data "));
msgdata = octstr_duplicate(msg->sms.msgdata);
octstr_url_encode(msgdata);
octstr_append(line, msgdata);
goto notelse; /* C lacks "else" clause for while loops */
}
}
octstr_append(line, octstr_imm(" text "));
octstr_append(line, msg->sms.msgdata);
}
notelse:
octstr_append_char(line, 10);
if (conn_write(client, line) == -1) {
octstr_destroy(msgdata);
octstr_destroy(line);
return -1;
}
octstr_destroy(msgdata);
octstr_destroy(line);
return 1;
}
static void make_unit_push_request(WAPEvent *e)
{
WAPEvent *wsp_event;
List *push_headers;
Octstr *smsc_id;
Octstr *dlr_url;
Octstr *smsbox_id;
Octstr *push_body;
Octstr *service_name;
gw_assert(e->type == Po_Unit_Push_Req);
gw_assert(e->u.Po_Unit_Push_Req.addr_tuple);
gw_assert(e->u.Po_Unit_Push_Req.service_name);
smsc_id = octstr_duplicate(e->u.Po_Unit_Push_Req.smsc_id);
dlr_url = octstr_duplicate(e->u.Po_Unit_Push_Req.dlr_url);
smsbox_id = octstr_duplicate(e->u.Po_Unit_Push_Req.smsbox_id);
push_body = octstr_duplicate(e->u.Po_Unit_Push_Req.push_body);
service_name = octstr_duplicate(e->u.Po_Unit_Push_Req.service_name);
push_headers = add_push_flag(e);
wsp_event = wap_event_create(S_Unit_Push_Req);
wsp_event->u.S_Unit_Push_Req.addr_tuple =
wap_addr_tuple_duplicate(e->u.Po_Unit_Push_Req.addr_tuple);
wsp_event->u.S_Unit_Push_Req.push_id = e->u.Po_Unit_Push_Req.push_id;
wsp_event->u.S_Unit_Push_Req.push_headers = push_headers;
wsp_event->u.S_Unit_Push_Req.address_type =
e->u.Po_Unit_Push_Req.address_type;
if (smsc_id != NULL)
wsp_event->u.S_Unit_Push_Req.smsc_id = smsc_id;
else
wsp_event->u.S_Unit_Push_Req.smsc_id = NULL;
if (dlr_url != NULL)
wsp_event->u.S_Unit_Push_Req.dlr_url = dlr_url;
else
wsp_event->u.S_Unit_Push_Req.dlr_url = NULL;
wsp_event->u.S_Unit_Push_Req.dlr_mask = e->u.Po_Unit_Push_Req.dlr_mask;
if (smsbox_id != NULL)
wsp_event->u.S_Unit_Push_Req.smsbox_id = smsbox_id;
else
wsp_event->u.S_Unit_Push_Req.smsbox_id = NULL;
wsp_event->u.S_Unit_Push_Req.service_name = service_name;
if (push_body != NULL)
wsp_event->u.S_Unit_Push_Req.push_body = push_body;
else
wsp_event->u.S_Unit_Push_Req.push_body = NULL;
dispatch_to_wsp_unit(wsp_event);
debug("wap.push.ota", 0, "OTA: made connectionless session service"
" request");
}
static DBConf *mysql_create_conf(Octstr *user, Octstr *pass, Octstr *db, Octstr *host)
{
DBConf *conf;
conf = gw_malloc(sizeof(DBConf));
conf->mysql = gw_malloc(sizeof(MySQLConf));
conf->mysql->username = octstr_duplicate(user);
conf->mysql->password = octstr_duplicate(pass);
conf->mysql->database = octstr_duplicate(db);
conf->mysql->host = octstr_duplicate(host);
return conf;
}
static void cgwop_add(struct cgwop *cgwop, Octstr *name, Octstr *value)
{
if (cgwop->num_fields < CGWOP_MAXARGS)
{
cgwop->name[cgwop->num_fields] = octstr_duplicate(name);
cgwop->value[cgwop->num_fields] = octstr_duplicate(value);
cgwop->num_fields++;
} else
{
info(0, "cgw: CGWOP_MAXARGS exceeded.");
}
}
static int sms_to_client(Connection *client, Msg *msg)
{
Octstr *line;
Octstr *msgdata = NULL; /* NULL to allow octstr_destroy */
debug("bb.sms", 0, "smsc_fake: sending message to client");
/* msg_dump(msg, 0); */
line = octstr_duplicate(msg->sms.sender);
octstr_append_char(line, ' ');
octstr_append(line, msg->sms.receiver);
if (octstr_len(msg->sms.udhdata)) {
octstr_append(line, octstr_imm(" udh "));
msgdata = octstr_duplicate(msg->sms.udhdata);
octstr_url_encode(msgdata);
octstr_append(line, msgdata);
octstr_destroy(msgdata);
octstr_append(line, octstr_imm(" data "));
msgdata = octstr_duplicate(msg->sms.msgdata);
octstr_url_encode(msgdata);
octstr_append(line, msgdata);
} else {
if (msg->sms.coding == DC_8BIT) {
octstr_append(line, octstr_imm(" data "));
msgdata = octstr_duplicate(msg->sms.msgdata);
octstr_url_encode(msgdata);
octstr_append(line, msgdata);
}
else if (msg->sms.coding == DC_UCS2) {
octstr_append(line, octstr_imm(" ucs-2 "));
msgdata = octstr_duplicate(msg->sms.msgdata);
octstr_url_encode(msgdata);
octstr_append(line, msgdata);
}
else {
octstr_append(line, octstr_imm(" text "));
octstr_append(line, msg->sms.msgdata);
}
}
octstr_append_char(line, 10);
if (conn_write(client, line) == -1) {
octstr_destroy(msgdata);
octstr_destroy(line);
return -1;
}
octstr_destroy(msgdata);
octstr_destroy(line);
return 1;
}
Msg* create_dlr_from_msg(const Octstr *smsc, const Msg *msg, const Octstr *reply, long stat)
{
Msg *dlrmsg;
if (msg == NULL)
return NULL;
/* generate DLR */
debug("dlr.dlr", 0,"SMSC[%s]: creating DLR message",
(smsc ? octstr_get_cstr(smsc) : "UNKNOWN"));
dlrmsg = msg_create(sms);
gw_assert(dlrmsg != NULL);
dlrmsg->sms.service = octstr_duplicate(msg->sms.service);
dlrmsg->sms.dlr_mask = stat;
dlrmsg->sms.sms_type = report_mo;
dlrmsg->sms.smsc_id = octstr_duplicate(smsc ? smsc : msg->sms.smsc_id);
dlrmsg->sms.sender = octstr_duplicate(msg->sms.sender);
dlrmsg->sms.receiver = octstr_duplicate(msg->sms.receiver);
dlrmsg->sms.dlr_url = octstr_duplicate(msg->sms.dlr_url);
dlrmsg->sms.msgdata = octstr_duplicate(reply);
dlrmsg->sms.boxc_id = octstr_duplicate(msg->sms.boxc_id);
dlrmsg->sms.foreign_id = octstr_duplicate(msg->sms.foreign_id);
time(&dlrmsg->sms.time);
debug("dlr.dlr", 0,"SMSC[%s]: DLR = %s",
(smsc ? octstr_get_cstr(smsc) : "UNKNOWN"),
(dlrmsg->sms.dlr_url ? octstr_get_cstr(dlrmsg->sms.dlr_url) : ""));
return dlrmsg;
}
int ota_pack_message(Msg **msg, Octstr *ota_doc, Octstr *doc_type,
Octstr *from, Octstr *phone_number, Octstr *sec, Octstr *pin)
{
Octstr *ota_binary;
*msg = msg_create(sms);
(*msg)->sms.sms_type = mt_push;
ota_pack_udh(msg, doc_type);
if (ota_compile(ota_doc, octstr_imm("UTF-8"), &ota_binary) == -1)
goto cerror;
if (!ota_pack_push_headers(msg, doc_type, sec, pin, ota_binary))
goto herror;
octstr_format_append((*msg)->sms.msgdata, "%S", ota_binary);
(*msg)->sms.sender = octstr_duplicate(from);
(*msg)->sms.receiver = octstr_duplicate(phone_number);
(*msg)->sms.coding = DC_8BIT;
(*msg)->sms.time = time(NULL);
octstr_dump((*msg)->sms.msgdata, 0);
info(0, "/cgi-bin/sendota: XML request for target <%s>", octstr_get_cstr(phone_number));
octstr_destroy(ota_binary);
octstr_destroy(ota_doc);
octstr_destroy(doc_type);
octstr_destroy(from);
octstr_destroy(sec);
octstr_destroy(pin);
return 0;
herror:
octstr_destroy(ota_binary);
octstr_destroy(ota_doc);
octstr_destroy(doc_type);
octstr_destroy(from);
octstr_destroy(sec);
octstr_destroy(pin);
return -2;
cerror:
octstr_destroy(ota_doc);
octstr_destroy(doc_type);
octstr_destroy(from);
octstr_destroy(sec);
octstr_destroy(pin);
return -1;
}
/*
* 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;
}
int main(int argc, char **argv)
{
Octstr *data, *filename, *hex;
gwlib_init();
get_and_set_debugs(argc, argv, NULL);
if (argc < 2)
panic(0, "Syntax: %s <file>\n", argv[0]);
filename = octstr_create(argv[1]);
data = octstr_read_file(octstr_get_cstr(filename));
if (data == NULL)
panic(0, "Cannot read file.");
/*
* We test if this is a text/plain file with hex values in it.
* Therefore copy the data and trail off any CR and LF from
* beginning and end and test if the result is only hex chars.
* If yes, then convert to binary before dumping.
*/
hex = octstr_duplicate(data);
octstr_strip_crlfs(hex);
if (octstr_is_all_hex(hex)) {
debug("",0,"Trying to converting from hex to binary.");
if (octstr_hex_to_binary(hex) == 0) {
FILE *f = fopen(argv[2], "w");
debug("",0,"Convertion was successfull. Writing binary content to file `%s'",
argv[2]);
octstr_destroy(data);
data = octstr_duplicate(hex);
octstr_print(f, data);
fclose(f);
} else {
debug("",0,"Failed to convert from hex?!");
}
}
debug("",0,"Dumping file `%s':", octstr_get_cstr(filename));
octstr_dump(data, 0);
octstr_destroy(data);
octstr_destroy(hex);
gwlib_shutdown();
return 0;
}
/*
* 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;
}
/*
* Add reroute information to the connection data. Where the priority
* is in the order: reroute, reroute-smsc-id, reroute-receiver.
*/
static void init_reroute(SMSCConn *conn, CfgGroup *grp)
{
Octstr *rule;
long i;
if (cfg_get_bool(&conn->reroute_dlr, grp, octstr_imm("reroute-dlr")) == -1)
conn->reroute_dlr = 0;
info(0, "DLR rerouting for smsc id <%s> %s.", octstr_get_cstr(conn->id), (conn->reroute_dlr?"enabled":"disabled"));
if (cfg_get_bool(&conn->reroute, grp, octstr_imm("reroute")) != -1) {
debug("smscconn",0,"Adding general internal routing for smsc id <%s>",
octstr_get_cstr(conn->id));
return;
}
if ((conn->reroute_to_smsc = cfg_get(grp, octstr_imm("reroute-smsc-id"))) != NULL) {
/* reroute all messages to a specific smsc-id */
debug("smscconn",0,"Adding internal routing: smsc id <%s> to smsc id <%s>",
octstr_get_cstr(conn->id), octstr_get_cstr(conn->reroute_to_smsc));
return;
}
if ((rule = cfg_get(grp, octstr_imm("reroute-receiver"))) != NULL) {
List *routes;
/* create hash disctionary for this smsc-id */
conn->reroute_by_receiver = dict_create(100, (void(*)(void *)) octstr_destroy);
routes = octstr_split(rule, octstr_imm(";"));
for (i = 0; i < gwlist_len(routes); i++) {
Octstr *item = gwlist_get(routes, i);
Octstr *smsc, *receiver;
List *receivers;
/* first word is the smsc-id, all other are the receivers */
receivers = octstr_split(item, octstr_imm(","));
smsc = gwlist_extract_first(receivers);
if (smsc)
octstr_strip_blanks(smsc);
while((receiver = gwlist_extract_first(receivers))) {
octstr_strip_blanks(receiver);
debug("smscconn",0,"Adding internal routing for smsc id <%s>: "
"receiver <%s> to smsc id <%s>",
octstr_get_cstr(conn->id), octstr_get_cstr(receiver),
octstr_get_cstr(smsc));
if (!dict_put_once(conn->reroute_by_receiver, receiver, octstr_duplicate(smsc)))
panic(0, "Could not set internal routing for smsc id <%s>: "
"receiver <%s> to smsc id <%s>, because receiver has already routing entry!",
octstr_get_cstr(conn->id), octstr_get_cstr(receiver),
octstr_get_cstr(smsc));
octstr_destroy(receiver);
}
octstr_destroy(smsc);
gwlist_destroy(receivers, octstr_destroy_item);
}
octstr_destroy(rule);
gwlist_destroy(routes, octstr_destroy_item);
}
}
static Msg *sms_receive(SMSCConn *conn)
{
SmscWrapper *wrap = conn->data;
int ret;
Msg *newmsg = NULL;
if (smscenter_pending_smsmessage(wrap->smsc) == 1) {
ret = smscenter_receive_msg(wrap->smsc, &newmsg);
if (ret == 1) {
/* if any smsc_id available, use it */
newmsg->sms.smsc_id = octstr_duplicate(conn->id);
return newmsg;
} else if (ret == 0) { /* "NEVER" happens */
warning(0, "SMSC %s: Pending message returned '1', "
"but nothing to receive!", octstr_get_cstr(conn->name));
msg_destroy(newmsg);
return NULL;
} else {
msg_destroy(newmsg);
if (reconnect(conn) == -1)
smscconn_shutdown(conn, 0);
return NULL;
}
}
return NULL;
}
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));
}
}
int store_spool_init(const Octstr *store_dir)
{
DIR *dir;
store_messages = store_spool_messages;
store_save = store_spool_save;
store_save_ack = store_spool_save_ack;
store_load = store_spool_load;
store_dump = store_spool_dump;
store_shutdown = store_spool_shutdown;
store_status = store_spool_status;
if (store_dir == NULL)
return 0;
/* check if we can open directory */
if ((dir = opendir(octstr_get_cstr(store_dir))) == NULL) {
error(errno, "Could not open directory `%s'", octstr_get_cstr(store_dir));
return -1;
}
closedir(dir);
loaded = gwlist_create();
gwlist_add_producer(loaded);
spool = octstr_duplicate(store_dir);
counter = counter_create();
return 0;
}
static void sql_to_bearerbox(void *arg)
{
Boxc *boxc;
boxc = gw_malloc(sizeof(Boxc));
boxc->bearerbox_connection = connect_to_bearerbox_real(bearerbox_host, bearerbox_port, bearerbox_port_ssl, NULL /* bb_our_host */);
boxc->smsbox_connection = NULL;
boxc->client_ip = NULL;
boxc->alive = 1;
boxc->connect_time = time(NULL);
boxc->boxc_id = octstr_duplicate(sqlbox_id);
if (boxc->bearerbox_connection == NULL) {
boxc_destroy(boxc);
return;
}
gwthread_create(bearerbox_to_sql, boxc);
identify_to_bearerbox(boxc);
if (gw_sql_fetch_msg_list == NULL || gw_sql_save_list == NULL || limit_per_cycle <= 1) {
sql_single(boxc);
}
else {
sql_list(boxc);
}
boxc_destroy(boxc);
}
/* P_hash as described in WAP WTLS section 11.3.2 */
Octstr *wtls_P_hash(Octstr * secret, Octstr * seed, int byteLength,
WTLSMachine * wtls_machine)
{
Octstr *a;
Octstr *aPrev;
Octstr *aPlusSeed;
Octstr *hashTemp;
Octstr *hashedData;
hashedData = octstr_create("");
/* start with A(1) = HMAC_hash(secret, seed) */
aPrev = octstr_duplicate(seed);
do {
/* A(i) */
a = wtls_hmac_hash(secret, aPrev, SHA_80);
aPlusSeed = octstr_cat(a, seed);
/* HMAC */
hashTemp = wtls_hmac_hash(secret, aPlusSeed, SHA_80);
octstr_destroy(aPlusSeed);
octstr_append(hashedData, hashTemp);
octstr_destroy(hashTemp);
/* Update a(i-1) */
octstr_destroy(aPrev);
aPrev = a;
} while (octstr_len(hashedData) < byteLength);
octstr_destroy(aPrev);
return (hashedData);
}
/*
* Remove matching entry from the spool.
*/
static void dlr_spool_remove(const Octstr *smsc, const Octstr *ts, const Octstr *dst)
{
Octstr *os, *hash, *dir, *filename;
/* determine target dir and filename via hash */
os = octstr_duplicate(smsc);
octstr_append(os, ts);
hash = our_hash_func(os);
octstr_destroy(os);
/* determine target dir */
dir = octstr_format("%S/%ld", spool_dir, octstr_hash_key(hash) % MAX_DIRS);
/* get msg surrogate filename */
filename = get_msg_filename(dir, hash, dst);
octstr_destroy(dir);
octstr_destroy(hash);
/* if there was no filename, then we didn't find it */
if (filename == NULL) {
return;
}
/* remove the file from the file system */
if (unlink(octstr_get_cstr(filename)) == -1) {
error(errno, "Could not unlink file `%s'.", octstr_get_cstr(filename));
octstr_destroy(filename);
return;
}
counter_decrease(counter);
octstr_destroy(filename);
}
int main(int argc, char **argv)
{
Octstr *os1, *os2;
gwlib_init();
os1 = octstr_create("");
octstr_append_from_hex(os1, "411810124550421715161a");
os2 = octstr_duplicate(os1);
debug("", 0, "Orginal GSM charset data:");
octstr_dump(os1, 0);
charset_gsm_to_utf8(os1);
debug("", 0, "Same data mapped to URT-8 charset:");
octstr_dump(os1, 0);
charset_utf8_to_gsm(os1);
debug("", 0, "Same data mapped back again to GSM charset:");
octstr_dump(os1, 0);
if (octstr_compare(os1, os2) != 0)
panic(0, "Data is not the same after re-mapping!");
else
debug("",0,"Data is same, ok.");
octstr_destroy(os1);
octstr_destroy(os2);
gwlib_shutdown();
return 0;
}
Octstr *mime_entity_body(MIMEEntity *m)
{
Octstr *os, *body;
ParseContext *context;
MIMEEntity *e;
gw_assert(m != NULL && m->headers != NULL);
/* For non-multipart, return body directly. */
if (mime_entity_num_parts(m) == 0)
return octstr_duplicate(m->body);
os = mime_entity_to_octstr(m);
context = parse_context_create(os);
e = mime_entity_create();
/* parse the headers up to the body */
if ((read_mime_headers(context, e->headers) != 0) || e->headers == NULL) {
debug("mime.parse",0,"Failed to read MIME headers in Octstr block:");
octstr_dump(os, 0);
mime_entity_destroy(e);
parse_context_destroy(context);
return NULL;
}
/* the rest is the body */
body = parse_get_rest(context);
octstr_destroy(os);
mime_entity_destroy(e);
parse_context_destroy(context);
return body;
}
/*
* NB: This data includes bearer information. We use IPv4 values. Address Type
* is defined in wsp, table 16, p. 65
*/
static Octstr *pack_server_address(void)
{
Octstr *address,
*ip_address;
unsigned char address_len;
long port;
int bearer_type;
bearer_type = GSM_CSD_IPV4;
port = CONNECTED_PORT;
mutex_lock(bearerbox->mutex);
ip_address = octstr_duplicate(bearerbox->address);
address_len = octstr_len(bearerbox->address);
mutex_unlock(bearerbox->mutex);
address = octstr_create("");
octstr_append_char(address, address_len);
octstr_set_bits(address, 0, 1, 1); /* bearer type included */
octstr_set_bits(address, 1, 1, 1); /* port number included */
octstr_append_char(address, bearer_type);
octstr_append_decimal(address, port);
octstr_append(address, ip_address);
octstr_destroy(ip_address);
return address;
}
static void make_confirmed_push_request(WAPEvent *e)
{
WAPEvent *wsp_event;
List *push_headers;
gw_assert(e->type == Po_ConfirmedPush_Req);
push_headers = add_push_flag(e);
wsp_event = wap_event_create(S_ConfirmedPush_Req);
wsp_event->u.S_ConfirmedPush_Req.server_push_id =
e->u.Po_ConfirmedPush_Req.server_push_id;
wsp_event->u.S_ConfirmedPush_Req.push_headers = push_headers;
if (e->u.Po_ConfirmedPush_Req.push_body != NULL)
wsp_event->u.S_ConfirmedPush_Req.push_body =
octstr_duplicate(e->u.Po_ConfirmedPush_Req.push_body);
else
wsp_event->u.S_ConfirmedPush_Req.push_body = NULL;
wsp_event->u.S_ConfirmedPush_Req.session_id =
e->u.Po_ConfirmedPush_Req.session_handle;
debug("wap.push.ota", 0, "OTA: making confirmed push request to wsp");
dispatch_to_wsp(wsp_event);
}
static WSP_PDU *make_push_pdu(WAPEvent *e)
{
WSP_PDU *pdu;
List *headers;
pdu = wsp_pdu_create(Push);
/*
* Both push headers and push body are optional
*/
if (e->u.S_Push_Req.push_headers == NULL) {
headers = http_create_empty_headers();
pdu->u.Push.headers = wsp_headers_pack(headers, 1, WSP_1_2);
http_destroy_headers(headers);
} else
pdu->u.Push.headers =
wsp_headers_pack(e->u.S_Push_Req.push_headers, 1, WSP_1_2);
if (e->u.S_Push_Req.push_body == NULL)
pdu->u.Push.data = octstr_create("");
else
pdu->u.Push.data =
octstr_duplicate(e->u.S_Push_Req.push_body);
return pdu;
}
static void shell_logger(enum mbuni_event_type_t type, const char *subtype, int err, const char *file,
int line, const char *function,
const char *interface, Octstr *id,
Octstr *msg)
{
char *xtype;
Octstr *cmd, *xid = octstr_duplicate(id);
gw_assert(shell_cmd);
switch(type) {
case MBUNI_INFO:
xtype = "INFO";
break;
case MBUNI_WARNING:
xtype = "WARNING";
break;
default: /* including error. */
xtype = "ERROR";
break;
}
escape_shell_chars(msg);
escape_shell_chars(id);
cmd = octstr_format("%S '%s' '%s' %d '%s' '%s' %d '%S' '%S'",
shell_cmd, xtype, subtype ? subtype : "", err, interface ? interface : "", file, line, xid ? xid : octstr_imm(""), msg);
system(octstr_get_cstr(cmd));
octstr_destroy(cmd);
octstr_destroy(xid);
}
/*
* Checks if body_part contains a Content-Type header. Tranfers this header to
* a list content_headers. (Only part before 'boundary').
* Return 1, when Content-Type headers was found, 0 otherwise
*/
static int check_data_content_type_header(Octstr **body_part, List **content_headers,
Octstr *boundary)
{
long header_pos,
next_header_pos;
Octstr *content_header;
long message_start_pos;
header_pos = next_header_pos = -1;
content_header = octstr_create("Content-Type");
message_start_pos = octstr_search(*body_part, boundary, 0);
if ((header_pos = octstr_case_nsearch(*body_part, content_header, 0,
message_start_pos)) < 0) {
goto error;
}
if ((next_header_pos = pass_field_value(body_part, &content_header,
header_pos + octstr_len(content_header))) < 0) {
goto error;
}
if ((next_header_pos = parse_terminator(*body_part, next_header_pos)) < 0) {
goto error;
}
octstr_delete(*body_part, header_pos, next_header_pos - header_pos);
gwlist_append(*content_headers, octstr_duplicate(content_header));
octstr_destroy(content_header);
return 1;
error:
octstr_destroy(content_header);
return 0;
}