Octstr *parse_get_seperated_block(ParseContext *context, Octstr *seperator)
{
Octstr *result;
long spos, epos;
gw_assert(context != NULL);
gw_assert(seperator != NULL);
spos = octstr_search(context->data, seperator, context->pos);
if (spos < 0 || spos >= context->limit) {
context->error = 1;
return NULL;
}
epos = octstr_search(context->data, seperator, spos + octstr_len(seperator));
if (epos < 0 || epos >= context->limit) {
context->error = 1;
return NULL;
}
spos = spos + octstr_len(seperator);
result = octstr_copy(context->data, spos, epos - spos);
context->pos = epos;
return result;
}
/*
* Splits the first body part away from the multipart message. A body part end with
* either with another body or with a close delimiter. We first split the body and
* then remove the separating stuff from the remainder. If we have the last body
* part, we must parse all closing stuff.
* Returns 1, there is still another body part in the multipart message
* 0, if there is none
* -1, when parsing error.
*/
static int parse_body_part (Octstr **multipart, Octstr *boundary,
Octstr **body_part)
{
Octstr *part_delimiter,
*close_delimiter;
long boundary_pos, /* start of the boundary */
close_delimiter_pos, /* start of the close delimiter */
next_part_pos, /* start of the next part */
epilogue_pos; /* start of the epilogue */
part_delimiter = make_part_delimiter(boundary);
close_delimiter = make_close_delimiter(boundary);
if ((close_delimiter_pos = octstr_search(*multipart,
close_delimiter, 0)) < 0)
goto error;
boundary_pos = octstr_search(*multipart, part_delimiter, 0);
if (boundary_pos == close_delimiter_pos) {
octstr_split_by_pos(multipart, body_part, close_delimiter_pos);
if ((epilogue_pos =
parse_close_delimiter(close_delimiter, *multipart, 0)) < 0)
goto error;
epilogue_pos = parse_transport_padding(*multipart, epilogue_pos);
octstr_delete(*multipart, 0, epilogue_pos);
goto last_part;
}
octstr_split_by_pos(multipart, body_part, boundary_pos);
if (parse_tail(multipart, part_delimiter, 0, &next_part_pos) < 0) {
goto error;
}
octstr_delete(*multipart, 0, next_part_pos);
octstr_destroy(part_delimiter);
octstr_destroy(close_delimiter);
return 1;
error:
octstr_destroy(part_delimiter);
octstr_destroy(close_delimiter);
return -1;
last_part:
octstr_destroy(part_delimiter);
octstr_destroy(close_delimiter);
return 0;
}
static int auth_check(Octstr *user, Octstr *pass, List *headers, int *has_auth_hdr)
{
int i, res = -1;
Octstr *v = http_header_value(headers, octstr_imm("Authorization"));
Octstr *p = NULL, *q = NULL;
*has_auth_hdr = (v != NULL);
if (octstr_len(user) == 0) {
res = 0;
goto done;
}
if (!v ||
octstr_search(v, octstr_imm("Basic "), 0) != 0)
goto done;
p = octstr_copy(v, sizeof "Basic", octstr_len(v));
octstr_base64_to_binary(p);
i = octstr_search_char(p, ':', 0);
q = octstr_copy(p, i+1, octstr_len(p));
octstr_delete(p, i, octstr_len(p));
/* p = user, q = pass. */
if (octstr_compare(user, p) != 0 ||
octstr_compare(pass, q) != 0)
res = -1;
else
res = 0;
done:
octstr_destroy(v);
octstr_destroy(p);
octstr_destroy(q);
return res;
}
void set_charset(Octstr *document, Octstr *charset)
{
long gt = 0, enc = 0;
Octstr *encoding = NULL, *text = NULL, *temp = NULL;
if (octstr_len(charset) == 0)
return;
encoding = octstr_create(" encoding");
enc = octstr_search(document, encoding, 0);
gt = octstr_search_char(document, '>', 0);
if (enc < 0 || enc > gt) {
gt++;
text = octstr_copy(document, gt, octstr_len(document) - gt);
if (charset_to_utf8(text, &temp, charset) >= 0) {
octstr_delete(document, gt, octstr_len(document) - gt);
octstr_append_data(document, octstr_get_cstr(temp),
octstr_len(temp));
}
octstr_destroy(temp);
octstr_destroy(text);
}
octstr_destroy(encoding);
}
/*
* 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;
}
/*
* Boundary misses crlf here. This is intentional: Kannel header parsing pro-
* cess drops this terminator.
*/
static int parse_preamble(Octstr **mime_content, Octstr *boundary)
{
long boundary_pos,
next_part_pos;
Octstr *dash_boundary;
boundary_pos = next_part_pos = -1;
dash_boundary = make_start_delimiter(boundary);
if ((boundary_pos = octstr_search(*mime_content, dash_boundary, 0)) < 0)
goto error;
if (parse_tail(mime_content, dash_boundary, boundary_pos,
&next_part_pos) < 0)
goto error;
octstr_delete(*mime_content, 0, next_part_pos);
octstr_destroy(dash_boundary);
return 0;
error:
octstr_destroy(dash_boundary);
return -1;
}
Octstr *find_charset_encoding(Octstr *document)
{
long gt = 0, enc = 0;
Octstr *encoding = NULL, *temp = NULL;
enc = octstr_search(document, octstr_imm(" encoding="), 0);
gt = octstr_search(document, octstr_imm("?>"), 0);
/* in case there is no encoding argument, assume always UTF-8 */
if (enc < 0 || enc + 10 > gt)
return NULL;
temp = octstr_copy(document, enc + 10, gt - (enc + 10));
octstr_strip_blanks(temp);
encoding = octstr_copy(temp, 1, octstr_len(temp) - 2);
octstr_destroy(temp);
return encoding;
}
/* Skip a comment in HTML. */
static void skip_html_comment(Octstr *html, long *pos)
{
long i;
*pos += 4; /* Skip "<!--" at beginning of comment. */
i = octstr_search(html, octstr_imm("-->"), *pos);
if (i == -1)
*pos = octstr_len(html);
else
*pos = i;
}
static Octstr *cgw_decode_msg(Octstr* str)
{
int i;
/* make \n -> linefeed */
while ((i = octstr_search(str, octstr_imm("\\n"), 0)) != -1) {
octstr_delete(str, i, 2); /* delete "\n" str */
octstr_insert(str, octstr_imm("\n"), i);
}
/* make \r -> carriage return */
while ((i = octstr_search(str, octstr_imm("\\r"), 0)) != -1) {
octstr_delete(str, i, 2); /* delete EOL char */
octstr_insert(str, octstr_imm("\r"), i);
}
/* remove double backslashes */
while ((i = octstr_search(str, octstr_imm("\\\\"), 0)) != -1) {
octstr_delete(str, i, 1);
}
return str;
}
static Octstr *get_msg_filename(const Octstr *dir_s, const Octstr *hash, const Octstr *dst)
{
Octstr *ret;
DIR *dir;
struct dirent *ent;
char *hash_cstr;
if ((dir = opendir(octstr_get_cstr(dir_s))) == NULL) {
error(errno, "Could not open directory `%s'", octstr_get_cstr(dir_s));
return NULL;
}
hash_cstr = octstr_get_cstr(hash);
while ((ent = readdir(dir)) != NULL) {
Octstr *fname = octstr_create((char*)ent->d_name);
if (octstr_ncompare(fname, hash, OUR_DIGEST_LEN) == 0) {
Octstr *addr;
long addr_len, pos;
/* this is a candidate */
if (dst == NULL)
goto found;
/* check for the destination address suffix part */
if ((addr_len = (octstr_len(fname) - OUR_DIGEST_LEN)) < 0 ||
(pos = (addr_len - octstr_len(dst))) < 0) {
octstr_destroy(fname);
continue;
}
addr = octstr_copy(fname, OUR_DIGEST_LEN, addr_len);
/* if not found, then bail out*/
if (octstr_search(addr, dst, pos) == -1) {
octstr_destroy(addr);
octstr_destroy(fname);
continue;
}
octstr_destroy(addr);
found:
/* found it */
closedir(dir);
ret = octstr_format("%S/%S", dir_s, fname);
octstr_destroy(fname);
return ret;
}
octstr_destroy(fname);
}
closedir(dir);
return NULL;
}
/*
* Count the number of times `pat' occurs in `str'.
*/
static long count_occurences(Octstr *str, Octstr *pat)
{
long count;
long pos;
long len;
count = 0;
pos = 0;
len = octstr_len(pat);
while ((pos = octstr_search(str, pat, pos)) != -1) {
++count;
pos += len;
}
return count;
}
/*
* Extension headers are optional, see Push Message, chapter 6.2. Field struc-
* ture is defined in rfc 822, chapter 3.2. Extension headers are defined in
* rfc 2045, chapter 9, grammar in appendix A. (Only to the next null line).
* Return 0 when error, 1 otherwise.
*/
static int pass_extension_headers(Octstr **body_part, List **content_headers, Octstr *boundary)
{
long next_field_part_pos,
count;
Octstr *header_name,
*header_value;
long next_content_part_pos;
header_name = octstr_create("");
header_value = octstr_create("");
count = 0;
next_field_part_pos = 0;
next_content_part_pos = octstr_search(*body_part, boundary, 0);
do {
if ((octstr_case_nsearch(*body_part, octstr_imm("Content"), 0,
next_content_part_pos)) < 0)
goto end;
if ((next_field_part_pos = pass_field_name(body_part, &header_name,
next_field_part_pos)) < 0)
goto error;
if ((next_field_part_pos = pass_field_value(body_part, &header_value,
next_field_part_pos)) < 0)
goto error;
if ((next_field_part_pos = parse_terminator(*body_part,
next_field_part_pos)) == 0)
goto error;
drop_separator(&header_value, &next_field_part_pos);
http_header_add(*content_headers, octstr_get_cstr(header_name),
octstr_get_cstr(header_value));
} while (islwspchar(octstr_get_char(*body_part, next_field_part_pos)));
octstr_delete(*body_part, 0, next_field_part_pos);
/*
* An intentional fall-through. We must eventually use a function for memory
* cleaning.
*/
end:
octstr_destroy(header_name);
octstr_destroy(header_value);
return 1;
error:
octstr_destroy(header_name);
octstr_destroy(header_value);
return 0;
}
static int drop_optional_header(Octstr **body_part, char *name, Octstr *boundary)
{
long content_pos;
long message_start_pos;
content_pos = -1;
message_start_pos = octstr_search(*body_part, boundary, 0);
if ((content_pos = octstr_case_nsearch(*body_part, octstr_imm(name), 0, message_start_pos)) < 0)
return 1;
if (drop_header_true(body_part, content_pos) < 0)
return 0;
return 1;
}
void smpp_listener_auth_failed(SMPPServer *smpp_server, Octstr *ip) {
if (octstr_len(smpp_server->ip_blocklist_exempt_ips) && (octstr_search(smpp_server->ip_blocklist_exempt_ips, ip, 0) > -1)) {
debug("smpp.listener.auth.failed", 0, "IP address %s is exempt from the IP block list", octstr_get_cstr(ip));
return;
}
gw_rwlock_wrlock(smpp_server->ip_blocklist_lock);
SMPPBlockedIp *smpp_blocked_ip = dict_get(smpp_server->ip_blocklist, ip);
if(smpp_blocked_ip == NULL) {
smpp_blocked_ip = smpp_blocked_ip_create();
dict_put(smpp_server->ip_blocklist, ip, smpp_blocked_ip);
}
smpp_blocked_ip->attempts++;
smpp_blocked_ip->time_blocked = time(NULL);
debug("smpp.listener.auth.failed", 0, "IP address %s, attempts %ld have failed", octstr_get_cstr(ip), smpp_blocked_ip->attempts);
gw_rwlock_unlock(smpp_server->ip_blocklist_lock);
}
static int check_control_content_type_header(Octstr **body_part, Octstr *boundary)
{
long content_pos;
long message_start_pos;
message_start_pos = octstr_search(*body_part, boundary, 0);
if ((content_pos = octstr_case_nsearch(*body_part, octstr_imm("Content-Type:"), 0,
message_start_pos)) < 0 ||
octstr_case_search(*body_part, octstr_imm("application/xml"), 0) < 0) {
return 0;
}
if (drop_header_true(body_part, content_pos) < 0)
return 0;
return 1;
}
static Octstr *get_dlr_notify_url(Octstr *msgid, char *report_type, Octstr *mmc_gid, Octstr *mmc_id,
Octstr *status,
Octstr **transid)
{
Octstr *xtransid = NULL, *url = NULL;
mms_dlr_url_get(msgid, report_type, mmc_gid, &url, &xtransid);
if (transid)
*transid = xtransid;
else
octstr_destroy(xtransid);
if (octstr_len(url) == 0) {
if (url)
mms_info(0, "MM7", NULL,
"Sending delivery-report skipped: `url' is empty, `group_id'=[%s], `msgid'=[%s]",
octstr_get_cstr(mmc_gid), octstr_get_cstr(msgid));
octstr_destroy(url);
url = NULL;
goto done;
} else if (octstr_search(url, octstr_imm("msgid:"), 0) == 0) { /* a fake one, skip it. */
octstr_destroy(url);
url = NULL;
goto done;
}
#if 0
/* At what point do we delete it? For now, when we get a read report,
* and also when we get a delivery report that is not 'deferred' or sent or forwarded
*/
if (strcmp(report_type, "read-report") == 0 ||
(octstr_case_compare(status, octstr_imm("Deferred")) != 0 &&
octstr_case_compare(status, octstr_imm("Forwarded")) != 0))
mms_dlr_url_remove(msgid, report_type, mmc_gid);
#endif
done:
return url;
}
/*
* We try to find an optional header, so a failure to find one is not an
* error. Return -1 when error, 0 when header name not found, 1 otherwise.
* Search only until 'boundary'.
*/
static int pass_optional_header(Octstr **body_part, char *name, List **content_headers,
Octstr *boundary)
{
long content_pos,
next_header_pos;
Octstr *osname,
*osvalue;
long message_start_pos;
content_pos = next_header_pos = -1;
osname = octstr_create(name);
osvalue = octstr_create("");
message_start_pos = octstr_search(*body_part, boundary, 0);
if ((content_pos = octstr_case_nsearch(*body_part, osname, 0, message_start_pos)) < 0)
goto noheader;
if ((next_header_pos = pass_field_value(body_part, &osvalue,
content_pos + octstr_len(osname))) < 0)
goto error;
if ((next_header_pos =
parse_terminator(*body_part, next_header_pos)) == 0)
goto error;
drop_separator(&osvalue, &next_header_pos);
http_header_add(*content_headers, name, octstr_get_cstr(osvalue));
octstr_delete(*body_part, content_pos, next_header_pos - content_pos);
octstr_destroy(osname);
octstr_destroy(osvalue);
return 1;
error:
octstr_destroy(osvalue);
octstr_destroy(osname);
return -1;
noheader:
octstr_destroy(osvalue);
octstr_destroy(osname);
return 0;
}
/*
* In the case of SI documents, only attribute values to be tokenized are
* parts of urls (see si, chapter 9.3.3). The caller romoves the start of an
* url. Check whether we can find parts in the value. If not, parse value a an
* inline string, otherwise parse parts before and after tokenizable parts as
* inline strings.
*/
void parse_url_value(Octstr *value, simple_binary_t **sibxml)
{
size_t i;
long pos;
Octstr *urlos,
*first_part,
*last_part;
size_t first_part_len;
i = 0;
first_part_len = 0;
first_part = NULL;
last_part = NULL;
while (i < NUMBER_OF_URL_VALUES) {
pos = octstr_search(value,
urlos = octstr_imm(si_URL_values[i].name), 0);
if (pos >= 0) {
first_part = octstr_duplicate(value);
octstr_delete(first_part, pos, octstr_len(first_part) - pos);
first_part_len = octstr_len(first_part);
parse_inline_string(first_part, sibxml);
output_char(si_URL_values[i].token, sibxml);
last_part = octstr_duplicate(value);
octstr_delete(last_part, 0, first_part_len + octstr_len(urlos));
parse_inline_string(last_part, sibxml);
octstr_destroy(first_part);
octstr_destroy(last_part);
break;
}
octstr_destroy(urlos);
++i;
}
if (pos < 0)
parse_inline_string(value, sibxml);
}
static Octstr *eat_string_parm(Octstr *packet, int parm, int maxlen) {
long start, datastart;
long tab;
Octstr *result;
Octstr *parmheader;
parmheader = octstr_format("%c%03d:", TAB, parm);
start = octstr_search(packet, parmheader, 0);
if (start < 0) {
octstr_destroy(parmheader);
return NULL;
}
datastart = start + octstr_len(parmheader);
tab = octstr_search_char(packet, TAB, datastart + 1);
if (tab < 0) {
tab = octstr_len(packet);
}
result = octstr_copy(packet, datastart, tab - datastart);
octstr_delete(packet, start, tab - start);
octstr_destroy(parmheader);
return result;
}
struct dlr_storage *dlr_init_sdb(Cfg* cfg)
{
CfgGroup *grp;
List *grplist;
Octstr *sdb_url, *sdb_id;
Octstr *p = NULL;
long pool_size;
DBConf *db_conf = NULL;
/*
* check for all mandatory directives that specify the field names
* of the used table
*/
if (!(grp = cfg_get_single_group(cfg, octstr_imm("dlr-db"))))
panic(0, "DLR: SDB: group 'dlr-db' is not specified!");
if (!(sdb_id = cfg_get(grp, octstr_imm("id"))))
panic(0, "DLR: SDB: directive 'id' is not specified!");
fields = dlr_db_fields_create(grp);
gw_assert(fields != NULL);
/*
* now grap the required information from the 'mysql-connection' group
* with the sdb-id we just obtained
*
* we have to loop through all available SDB connection definitions
* and search for the one we are looking for
*/
grplist = cfg_get_multi_group(cfg, octstr_imm("sdb-connection"));
while (grplist && (grp = gwlist_extract_first(grplist)) != NULL) {
p = cfg_get(grp, octstr_imm("id"));
if (p != NULL && octstr_compare(p, sdb_id) == 0) {
goto found;
}
if (p != NULL) octstr_destroy(p);
}
panic(0, "DLR: SDB: connection settings for id '%s' are not specified!",
octstr_get_cstr(sdb_id));
found:
octstr_destroy(p);
gwlist_destroy(grplist, NULL);
if (cfg_get_integer(&pool_size, grp, octstr_imm("max-connections")) == -1 || pool_size == 0)
pool_size = 1;
if (!(sdb_url = cfg_get(grp, octstr_imm("url"))))
panic(0, "DLR: SDB: directive 'url' is not specified!");
if (octstr_search(sdb_url, octstr_imm("oracle:"), 0) == 0)
sdb_conn_type = SDB_ORACLE;
else if (octstr_search(sdb_url, octstr_imm("mysql:"), 0) == 0) {
warning(0, "DLR[sdb]: Please use native MySQL support, instead of libsdb.");
sdb_conn_type = SDB_MYSQL;
}
else if (octstr_search(sdb_url, octstr_imm("postgres:"), 0) == 0) {
sdb_conn_type = SDB_POSTGRES;
}
else
sdb_conn_type = SDB_OTHER;
/*
* ok, ready to connect
*/
info(0,"Connecting to sdb resource <%s>.", octstr_get_cstr(sdb_url));
db_conf = gw_malloc(sizeof(DBConf));
gw_assert(db_conf != NULL);
db_conf->sdb = gw_malloc(sizeof(SDBConf));
gw_assert(db_conf->sdb != NULL);
db_conf->sdb->url = sdb_url;
pool = dbpool_create(DBPOOL_SDB, db_conf, pool_size);
gw_assert(pool != NULL);
/*
* XXX should a failing connect throw panic?!
*/
if (dbpool_conn_count(pool) == 0)
panic(0,"DLR: SDB: database pool has no connections!");
return &handles;
}
static void httpd_serve(HTTPClient *client, Octstr *ourl, List *headers,
Octstr *body, List *cgivars)
{
Octstr *reply, *final_reply, *url;
char *content_type;
char *header, *footer;
int status_type;
int i;
long pos;
reply = final_reply = NULL; /* for compiler please */
url = octstr_duplicate(ourl);
/* Set default reply format according to client
* Accept: header */
if (http_type_accepted(headers, "text/vnd.wap.wml")) {
status_type = BBSTATUS_WML;
content_type = "text/vnd.wap.wml";
}
else if (http_type_accepted(headers, "text/html")) {
status_type = BBSTATUS_HTML;
content_type = "text/html";
}
else if (http_type_accepted(headers, "text/xml")) {
status_type = BBSTATUS_XML;
content_type = "text/xml";
} else {
status_type = BBSTATUS_TEXT;
content_type = "text/plain";
}
/* kill '/cgi-bin' prefix */
pos = octstr_search(url, octstr_imm("/cgi-bin/"), 0);
if (pos != -1)
octstr_delete(url, pos, 9);
else if (octstr_get_char(url, 0) == '/')
octstr_delete(url, 0, 1);
/* look for type and kill it */
pos = octstr_search_char(url, '.', 0);
if (pos != -1) {
Octstr *tmp = octstr_copy(url, pos+1, octstr_len(url) - pos - 1);
octstr_delete(url, pos, octstr_len(url) - pos);
if (octstr_str_compare(tmp, "txt") == 0)
status_type = BBSTATUS_TEXT;
else if (octstr_str_compare(tmp, "html") == 0)
status_type = BBSTATUS_HTML;
else if (octstr_str_compare(tmp, "xml") == 0)
status_type = BBSTATUS_XML;
else if (octstr_str_compare(tmp, "wml") == 0)
status_type = BBSTATUS_WML;
octstr_destroy(tmp);
}
for (i=0; httpd_commands[i].command != NULL; i++) {
if (octstr_str_compare(url, httpd_commands[i].command) == 0) {
reply = httpd_commands[i].function(cgivars, status_type);
break;
}
}
/* check if command found */
if (httpd_commands[i].command == NULL) {
char *lb = bb_status_linebreak(status_type);
reply = octstr_format("Unknown command `%S'.%sPossible commands are:%s",
ourl, lb, lb);
for (i=0; httpd_commands[i].command != NULL; i++)
octstr_format_append(reply, "%s%s", httpd_commands[i].command, lb);
}
gw_assert(reply != NULL);
if (status_type == BBSTATUS_HTML) {
header = "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2//EN\">\n"
"<html>\n<title>" GW_NAME "</title>\n<body>\n<p>";
footer = "</p>\n</body></html>\n";
content_type = "text/html";
} else if (status_type == BBSTATUS_WML) {
header = "<?xml version=\"1.0\"?>\n"
"<!DOCTYPE wml PUBLIC \"-//WAPFORUM//DTD WML 1.1//EN\" "
"\"http://www.wapforum.org/DTD/wml_1.1.xml\">\n"
"\n<wml>\n <card>\n <p>";
footer = " </p>\n </card>\n</wml>\n";
content_type = "text/vnd.wap.wml";
} else if (status_type == BBSTATUS_XML) {
header = "<?xml version=\"1.0\"?>\n"
"<gateway>\n";
footer = "</gateway>\n";
} else {
header = "";
footer = "";
content_type = "text/plain";
}
final_reply = octstr_create(header);
octstr_append(final_reply, reply);
octstr_append_cstr(final_reply, footer);
/* debug("bb.http", 0, "Result: '%s'", octstr_get_cstr(final_reply));
*/
http_destroy_headers(headers);
headers = list_create();
http_header_add(headers, "Content-Type", content_type);
http_send_reply(client, HTTP_OK, headers, final_reply);
octstr_destroy(url);
octstr_destroy(ourl);
octstr_destroy(body);
octstr_destroy(reply);
octstr_destroy(final_reply);
http_destroy_headers(headers);
http_destroy_cgiargs(cgivars);
}
/* MT related function */
static int brunet_send_sms(SMSCConn *conn, Msg *sms)
{
ConnData *conndata = conn->data;
Octstr *url, *tid, *xser;
List *headers;
char id[UUID_STR_LEN + 1];
int dcs;
/*
* Construct TransactionId.
* Beware that brunet needs an "clean" octstr representation,
* without the dashes in the string. So remove them.
*/
uuid_unparse(sms->sms.id, id);
tid = octstr_create(id);
octstr_replace(tid, octstr_imm("-"), octstr_imm(""));
/* form the basic URL */
url = octstr_format("%S?MsIsdn=%E&Originator=%E",
conndata->send_url, sms->sms.receiver, sms->sms.sender);
/*
* We use &binfo=<foobar> from sendsms interface to encode
* additional paramters. If a mandatory value is not set,
* a default value is applied
*/
if (octstr_len(sms->sms.binfo)) {
octstr_url_decode(sms->sms.binfo);
octstr_format_append(url, "&%S", sms->sms.binfo);
}
/* CustomerId */
if (octstr_search(url, octstr_create("CustomerId="), 0) == -1) {
octstr_format_append(url, "&CustomerId=%S", conndata->username);
}
/* TransactionId */
if (octstr_search(url, octstr_create("TransactionId="), 0) == -1) {
octstr_format_append(url, "&TransactionId=%S", tid);
}
/* SMSCount */
if (octstr_search(url, octstr_create("SMSCount="), 0) == -1) {
octstr_format_append(url, "&%s", "SMSCount=1");
}
/* ActionType */
if (octstr_search(url, octstr_create("ActionType="), 0) == -1) {
octstr_format_append(url, "&%s", "ActionType=A");
}
/* ServiceDeliveryType */
if (octstr_search(url, octstr_create("ServiceDeliveryType="), 0) == -1) {
octstr_format_append(url, "&%s", "ServiceDeliveryType=P");
}
/* if coding is not set and UDH exists, assume DC_8BIT
* else default to DC_7BIT */
if (sms->sms.coding == DC_UNDEF)
sms->sms.coding = octstr_len(sms->sms.udhdata) > 0 ? DC_8BIT : DC_7BIT;
if (sms->sms.coding == DC_8BIT)
octstr_format_append(url, "&MessageType=B&Text=%H", sms->sms.msgdata);
else
octstr_format_append(url, "&MessageType=S&Text=%E", sms->sms.msgdata);
dcs = fields_to_dcs(sms,
(sms->sms.alt_dcs != SMS_PARAM_UNDEFINED ? sms->sms.alt_dcs : 0));
/* XSer processing */
xser = octstr_create("");
/* XSer DCS values */
if (dcs != 0 && dcs != 4)
octstr_format_append(xser, "0201%02x", dcs & 0xff);
/* add UDH header */
if (octstr_len(sms->sms.udhdata)) {
octstr_format_append(xser, "01%02x%H", octstr_len(sms->sms.udhdata),
sms->sms.udhdata);
}
if (octstr_len(xser) > 0)
octstr_format_append(url, "&XSer=%S", xser);
octstr_destroy(xser);
headers = http_create_empty_headers();
debug("smsc.http.brunet", 0, "HTTP[%s]: Sending request <%s>",
octstr_get_cstr(conn->id), octstr_get_cstr(url));
/*
* Brunet requires an SSL-enabled HTTP client call, this is handled
* transparently by the Kannel HTTP layer module.
*/
http_start_request(conndata->http_ref, HTTP_METHOD_GET, url, headers,
NULL, 0, sms, NULL);
octstr_destroy(url);
octstr_destroy(tid);
http_destroy_headers(headers);
return 0;
}
int cfg_read(Cfg *cfg)
{
CfgLoc *loc;
CfgLoc *loc_inc;
List *lines;
List *expand;
List *stack;
Octstr *name;
Octstr *value;
Octstr *filename;
CfgGroup *grp;
long equals;
long lineno;
long error_lineno;
loc = loc_inc = NULL;
/*
* expand initial main config file and add it to the recursion
* stack to protect against cycling
*/
if ((lines = expand_file(cfg->filename, 1)) == NULL) {
panic(0, "Failed to load main configuration file `%s'. Aborting!",
octstr_get_cstr(cfg->filename));
}
stack = gwlist_create();
gwlist_insert(stack, 0, octstr_duplicate(cfg->filename));
grp = NULL;
lineno = 0;
error_lineno = 0;
while (error_lineno == 0 && (loc = gwlist_extract_first(lines)) != NULL) {
octstr_strip_blanks(loc->line);
if (octstr_len(loc->line) == 0) {
if (grp != NULL && add_group(cfg, grp) == -1) {
error_lineno = loc->line_no;
destroy_group(grp);
}
grp = NULL;
} else if (octstr_get_char(loc->line, 0) != '#') {
equals = octstr_search_char(loc->line, '=', 0);
if (equals == -1) {
error(0, "An equals sign ('=') is missing on line %ld of file %s.",
loc->line_no, octstr_get_cstr(loc->filename));
error_lineno = loc->line_no;
} else
/*
* check for special config directives, like include or conditional
* directives here
*/
if (octstr_search(loc->line, octstr_imm("include"), 0) != -1) {
filename = octstr_copy(loc->line, equals + 1, octstr_len(loc->line));
parse_value(filename);
/* check if we are cycling */
if (gwlist_search(stack, filename, octstr_item_match) != NULL) {
panic(0, "Recursive include for config file `%s' detected "
"(on line %ld of file %s).",
octstr_get_cstr(filename), loc->line_no,
octstr_get_cstr(loc->filename));
} else {
List *files = gwlist_create();
Octstr *file;
struct stat filestat;
/* check if included file is a directory */
if (lstat(octstr_get_cstr(filename), &filestat) != 0) {
error(errno, "lstat failed: couldn't stat `%s'",
octstr_get_cstr(filename));
panic(0, "Failed to include `%s' "
"(on line %ld of file %s). Aborting!",
octstr_get_cstr(filename), loc->line_no,
octstr_get_cstr(loc->filename));
}
/*
* is a directory, create a list with files of
* this directory and load all as part of the
* whole configuration.
*/
if (S_ISDIR(filestat.st_mode)) {
DIR *dh;
struct dirent *diritem;
debug("gwlib.cfg", 0, "Loading include dir `%s' "
"(on line %ld of file %s).",
octstr_get_cstr(filename), loc->line_no,
octstr_get_cstr(loc->filename));
dh = opendir(octstr_get_cstr(filename));
while ((diritem = readdir(dh))) {
Octstr *fileitem;
fileitem = octstr_duplicate(filename);
octstr_append_cstr(fileitem, "/");
octstr_append_cstr(fileitem, diritem->d_name);
lstat(octstr_get_cstr(fileitem), &filestat);
if (!S_ISDIR(filestat.st_mode)) {
gwlist_insert(files, 0, fileitem);
} else {
octstr_destroy(fileitem);
}
}
closedir(dh);
}
/* is a file, create a list with it */
else {
gwlist_insert(files, 0, octstr_duplicate(filename));
}
/* include files */
while ((file = gwlist_extract_first(files)) != NULL) {
gwlist_insert(stack, 0, octstr_duplicate(file));
debug("gwlib.cfg", 0, "Loading include file `%s' (on line %ld of file %s).",
octstr_get_cstr(file), loc->line_no,
octstr_get_cstr(loc->filename));
/*
* expand the given include file and add it to the current
* processed main while loop
*/
if ((expand = expand_file(file, 0)) != NULL) {
while ((loc_inc = gwlist_extract_first(expand)) != NULL)
gwlist_insert(lines, 0, loc_inc);
} else {
panic(0, "Failed to load whole configuration. Aborting!");
}
gwlist_destroy(expand, NULL);
cfgloc_destroy(loc_inc);
octstr_destroy(file);
}
gwlist_destroy(files, octstr_destroy_item);
}
octstr_destroy(filename);
}
/*
* this is a "normal" line, so process it accodingly
*/
else {
name = octstr_copy(loc->line, 0, equals);
octstr_strip_blanks(name);
value = octstr_copy(loc->line, equals + 1, octstr_len(loc->line));
parse_value(value);
if (grp == NULL)
grp = create_group();
if (grp->configfile != NULL) {
octstr_destroy(grp->configfile);
grp->configfile = NULL;
}
grp->configfile = octstr_duplicate(cfg->filename);
cfg_set(grp, name, value);
octstr_destroy(name);
octstr_destroy(value);
}
}
cfgloc_destroy(loc);
}
if (grp != NULL && add_group(cfg, grp) == -1) {
error_lineno = 1;
destroy_group(grp);
}
gwlist_destroy(lines, NULL);
gwlist_destroy(stack, octstr_destroy_item);
if (error_lineno != 0) {
error(0, "Error found on line %ld of file `%s'.",
error_lineno, octstr_get_cstr(cfg->filename));
return -1;
}
return 0;
}