/* Parse the data stream for packets, and send out replies. */
static void parse_data(Octstr *in, Octstr *out) {
int stx, etx;
Octstr *packet;
for (;;) {
/* Look for start of packet. Delete everything up to the start
* marker. (CIMD2 section 3.1 says we can ignore any data
* transmitted between packets.) */
stx = octstr_search_char(in, STX, 0);
if (stx < 0)
octstr_delete(in, 0, octstr_len(in));
else if (stx > 0)
octstr_delete(in, 0, stx);
etx = octstr_search_char(in, ETX, 0);
if (etx < 0)
return; /* Incomplete packet; wait for more data. */
/* Copy the data between stx and etx */
packet = octstr_copy(in, 1, etx - 1);
/* Then cut the packet (including stx and etx) from inbuffer */
octstr_delete(in, 0, etx + 1);
parse_packet(packet, out);
octstr_destroy(packet);
}
}
void wap_map_url(Octstr **osp, Octstr **send_msisdn_query,
Octstr **send_msisdn_header,
Octstr **send_msisdn_format, int *accept_cookies)
{
long i;
Octstr *newurl, *tmp1, *tmp2;
newurl = tmp1 = tmp2 = NULL;
*send_msisdn_query = *send_msisdn_header = *send_msisdn_format = NULL;
*accept_cookies = -1;
debug("wsp",0,"WSP: Mapping url <%s>", octstr_get_cstr(*osp));
for (i = 0; url_map && i < gwlist_len(url_map); i++) {
struct url_map_struct *entry;
entry = gwlist_get(url_map, i);
/*
debug("wsp",0,"WSP: matching <%s> with <%s>",
octstr_get_cstr(entry->url), octstr_get_cstr(entry->map_url));
*/
/* DAVI: I only have '*' terminated entry->url implementation for now */
tmp1 = octstr_duplicate(entry->url);
octstr_delete(tmp1, octstr_len(tmp1)-1, 1); /* remove last '*' */
tmp2 = octstr_copy(*osp, 0, octstr_len(tmp1));
debug("wsp",0,"WSP: Matching <%s> with <%s>",
octstr_get_cstr(tmp1), octstr_get_cstr(tmp2));
if (octstr_case_compare(tmp2, tmp1) == 0) {
/* rewrite url if configured to do so */
if (entry->map_url != NULL) {
if (octstr_get_char(entry->map_url,
octstr_len(entry->map_url)-1) == '*') {
newurl = octstr_duplicate(entry->map_url);
octstr_delete(newurl, octstr_len(newurl)-1, 1);
octstr_append(newurl, octstr_copy(*osp,
octstr_len(entry->url)-1,
octstr_len(*osp)-octstr_len(entry->url)+1));
} else {
newurl = octstr_duplicate(entry->map_url);
}
debug("wsp",0,"WSP: URL Rewriten from <%s> to <%s>",
octstr_get_cstr(*osp), octstr_get_cstr(newurl));
octstr_destroy(*osp);
*osp = newurl;
}
*accept_cookies = entry->accept_cookies;
*send_msisdn_query = octstr_duplicate(entry->send_msisdn_query);
*send_msisdn_header = octstr_duplicate(entry->send_msisdn_header);
*send_msisdn_format = octstr_duplicate(entry->send_msisdn_format);
octstr_destroy(tmp1);
octstr_destroy(tmp2);
break;
}
octstr_destroy(tmp1);
octstr_destroy(tmp2);
}
}
/*
* 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;
}
/******************************************************************************
*
* EXTERNAL FUNCTIONS:
*
* Handles a possible concatenated message. Creates a list of wap events.
*/
List *wtp_unpack_wdp_datagram(WAPEvent *datagram)
{
List *events = NULL;
WAPEvent *event = NULL;
WAPEvent *subdgram = NULL;
Octstr *data = NULL;
long pdu_len;
gw_assert(datagram->type == T_DUnitdata_Ind);
events = gwlist_create();
if (concatenated_message(datagram->u.T_DUnitdata_Ind.user_data)) {
data = octstr_duplicate(datagram->u.T_DUnitdata_Ind.user_data);
octstr_delete(data, 0, 1);
while (octstr_len(data) != 0) {
if (octstr_get_bits(data, 0, 1) == 0) {
pdu_len = octstr_get_char(data, 0);
octstr_delete(data, 0, 1);
} else {
pdu_len = octstr_get_bits(data, 1, 15);
octstr_delete(data, 0, 2);
}
subdgram = wap_event_duplicate(datagram);
octstr_destroy(subdgram->u.T_DUnitdata_Ind.user_data);
subdgram->u.T_DUnitdata_Ind.user_data = octstr_copy(data, 0, pdu_len);
wap_event_assert(subdgram);
if ((event = unpack_wdp_datagram_real(subdgram)) != NULL) {
wap_event_assert(event);
gwlist_append(events, event);
}
octstr_delete(data, 0, pdu_len);
wap_event_destroy(subdgram);
}
octstr_destroy(data);
} else if ((event = unpack_wdp_datagram_real(datagram)) != NULL) {
wap_event_assert(event);
gwlist_append(events, event);
} else {
warning(0, "WTP: Dropping unhandled datagram data:");
octstr_dump(datagram->u.T_DUnitdata_Ind.user_data, 0, GW_WARNING);
}
return events;
}
/*
* Transfer entity headers of a body part (it is, from the content entity)
* to a header list. Push Message, chapter 6.2.1.10 states that Content-Type
* header is mandatory.
* Message proper starts after first empty line. We search only to it, and
* remove the line here.
* Return 0 when error, 1 otherwise. In addition, return the modified body
* part and content headers.
*/
static int pass_data_headers(Octstr **body_part, List **data_headers)
{
*data_headers = http_create_empty_headers();
if (check_data_content_type_header(body_part, data_headers, octstr_imm("\r\n\r\n")) == 0) {
warning(0, "MIME: pass_data_headers: Content-Type header missing");
return 0;
}
if (pass_optional_header(body_part, "Content-Transfer-Encoding", data_headers,
octstr_imm("\r\n\r\n")) < 0)
goto operror;
if (pass_optional_header(body_part, "Content-ID", data_headers, octstr_imm("\r\n\r\n")) < 0)
goto operror;
if (pass_optional_header(body_part, "Content-Description", data_headers,
octstr_imm("\r\n\r\n")) < 0)
goto operror;
if (pass_extension_headers(body_part, data_headers, octstr_imm("\r\n\r\n")) == 0)
goto operror;
octstr_delete(*body_part, 0, octstr_len(octstr_imm("\r\n")));
return 1;
operror:
warning(0, "MIME: pass_data_headers: an unparsable optional header");
return 0;
}
/*
* Extension headers are defined in rfc 822, Appendix D, as fields. We must
* parse all rfc 822 headers containing a string "Content". These headers
* are optional, too. For general definition of message parts see chapter 4.1.
* Specifically: "everything after first null line is message body".
*/
static int drop_extension_headers(Octstr **body_part, Octstr *boundary)
{
long content_pos,
next_header_pos;
long next_content_part_pos;
next_content_part_pos = octstr_case_search(*body_part, boundary, 0);
do {
if ((content_pos = octstr_case_nsearch(*body_part, octstr_imm("Content"), 0,
next_content_part_pos)) < 0)
return 1;
if ((next_header_pos = parse_field_name(*body_part, content_pos)) < 0)
return 0;
if ((next_header_pos = parse_field_value(*body_part,
next_header_pos)) < 0)
return 0;
if ((next_header_pos = parse_terminator(*body_part,
next_header_pos)) == 0)
return 0;
} while (islwspchar(octstr_get_char(*body_part, next_header_pos)));
octstr_delete(*body_part, content_pos, next_header_pos - content_pos);
return 1;
}
/*
* 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 *conn_read_line(Connection *conn)
{
Octstr *result = NULL;
long pos;
lock_in(conn);
/* 10 is the code for linefeed. We don't rely on \n because that
* might be a different value on some (strange) systems, and
* we are reading from a network connection. */
pos = octstr_search_char(conn->inbuf, 10, conn->inbufpos);
if (pos < 0) {
unlocked_read(conn);
pos = octstr_search_char(conn->inbuf, 10, conn->inbufpos);
if (pos < 0) {
unlock_in(conn);
return NULL;
}
}
result = unlocked_get(conn, pos - conn->inbufpos);
gw_claim_area(result);
/* Skip the LF, which we left in the buffer */
conn->inbufpos++;
/* If the line was terminated with CR LF, we have to remove
* the CR from the result. */
if (octstr_len(result) > 0 &&
octstr_get_char(result, octstr_len(result) - 1) == 13)
octstr_delete(result, octstr_len(result) - 1, 1);
unlock_in(conn);
return result;
}
/*
* Re-escape SMASI ASCII representation of binary data with the
* original binary data octet string.
* XXX this may be done by the internal parser routines too.
*/
static void decode_binary_data(Octstr *data)
{
long pos = 0;
while (pos < octstr_len(data)) {
int check = octstr_get_char(data, pos);
if (check == ':') {
Octstr *byte;
int msb = octstr_get_char(data, pos + 1);
int lsb = octstr_get_char(data, pos + 2);
if (msb != -1 && lsb != -1) {
byte = octstr_create("");
octstr_append_char(byte, msb);
octstr_append_char(byte, lsb);
if (octstr_hex_to_binary(byte) != -1) {
/* Do inplace unescaping. */
octstr_delete(data, pos, 3);
octstr_insert(data, byte, pos);
} else {
error(0, "Malformed binary encoded data.");
}
octstr_destroy(byte);
}
}
pos++;
}
}
/*
* Will replace a binary data octet string (inplace) with a SMASI conform
* ASCII representation of the data.
*/
static void encode_binary_data(Octstr *data)
{
Octstr *result = octstr_create("");
long pos = 0;
while (pos < octstr_len(data)) {
int encode = octstr_get_char(data, pos);
int msb = (encode & 0xf0) >> 4;
int lsb = (encode & 0x0f) >> 0;
if (msb == 0) msb = '0';
else if (msb < 10) msb = '1' + msb - 1;
else msb = 'a' + msb - 10;
if (lsb == 0) lsb = '0';
else if (lsb < 10) lsb = '1' + lsb - 1;
else lsb = 'a' + lsb - 10;
octstr_append_char(result, ':');
octstr_append_char(result, msb);
octstr_append_char(result, lsb);
pos++;
}
/* Replace binary data octet string with ASCII representation. */
octstr_delete(data, 0, octstr_len(data));
octstr_append(data, result);
octstr_destroy(result);
}
/*
* 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;
}
/*
* Escapes outgoing message body data by replacing occurrences of "special"
* chars inside the octet string.
*/
static void escape_data(Octstr *data)
{
long pos = 0;
/* This one uses a different approach than the encode and decode
* functions. Because it is assumed, that only a fraction of the
* contained chars have to be escaped.
*/
while (pos < octstr_len(data)) {
Octstr * escaped = NULL;
int check = octstr_get_char(data, pos);
if (check == ':') escaped = colon;
else if (check == '=') escaped = assign;
else if (check == ',') escaped = comma;
else if (check == '\n') escaped = cr;
else if (check == '\r') escaped = lf;
if (escaped != NULL) {
/* If the current char has to be escaped, delete the char from
* the source string, replace it with the escape sequence, and
* advance position until after the inserted sequence.
*/
octstr_delete(data, pos, 1);
octstr_insert(data, escaped, pos);
pos += octstr_len(escaped);
} else {
/* If not escaped, simply skip the current char. */
pos++;
}
}
}
static int eat_char(Octstr *packet, int ch) {
if (octstr_get_char(packet, 0) == ch) {
octstr_delete(packet, 0, 1);
return 0;
}
return -1;
}
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);
}
static void write_data(Octstr *out, int fd) {
unsigned char buf[EVIL_BUFSIZE];
int len;
ssize_t ret;
len = sizeof(buf);
if (len > octstr_len(out))
len = octstr_len(out);
if (len == 0)
return;
octstr_get_many_chars(buf, out, 0, len);
ret = write(fd, buf, len);
if (ret > 0) {
if (logging == LOG_data)
pretty_print(buf, ret);
octstr_delete(out, 0, ret);
} else if (ret == 0) {
warning(0, "empty write");
} else {
if (errno == EINTR || errno == EAGAIN)
return;
error(errno, "write_data");
exit(1);
}
}
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;
}
static int remove_prefix(Octstr *os, Octstr *prefix)
{
if (octstr_ncompare(os, prefix, octstr_len(prefix)) != 0)
return -1;
octstr_delete(os, 0, octstr_len(prefix));
return 0;
}
/*
* Unescapes incoming message body data by replacing occurrences of escaped
* chars with their original character representation.
*/
static void unescape_data(Octstr *data)
{
long pos = 0;
/* Again, an inplace transformation is used. Because, again, it is
* assumed that only a fraction of chars has to be unescaped.
*/
while (pos < octstr_len(data)) {
int check = octstr_get_char(data, pos);
if (check == ':') {
char byte = 0;
int msb = octstr_get_char(data, pos + 1);
int lsb = octstr_get_char(data, pos + 2);
if (msb == '0') msb = 0;
else if (msb >= '1' && msb <= '9') msb -= '1' + 1;
else msb -= 'a' + 10;
if (lsb == '0') lsb = 0;
else if (lsb >= '1' && lsb <= '9') lsb -= '1' + 1;
else lsb -= 'a' + 10;
byte = msb << 4 | lsb;
/* Do inplace unescaping. */
octstr_delete(data, pos, 3);
octstr_insert_data(data, pos, &byte, 1);
}
pos++;
}
}
static void fixup_relayed_report(MmsMsg *m, MmscGrp *mmc, char *rtype, Octstr *status)
{
Octstr *value = mms_get_header_value(m, octstr_imm("Message-ID"));
Octstr *newmsgid = NULL, *transid = NULL;
/* Firstly, take care to look for the record we saved, and re-write the MessageID. */
if (value &&
mms_dlr_url_get(value, rtype, mmc->group_id, &newmsgid, &transid) == 0) {
int x = octstr_search_char(newmsgid, ':', 0);
if (x>=0)
octstr_delete(newmsgid, 0, x+1);
mms_replace_header_value(m, "Message-ID", octstr_get_cstr(newmsgid));
/* Add it back as original. */
mms_replace_header_value(m, "X-Mbuni-Orig-Message-ID", octstr_get_cstr(value));
#if 0
if (strcmp(rtype, "read-report") == 0 ||
(octstr_case_compare(status, octstr_imm("Deferred")) != 0 &&
octstr_case_compare(status, octstr_imm("Forwarded")) != 0))
mms_dlr_url_remove(value, rtype, mmc->group_id); /* only remove if not
* interim status
*/
#endif
}
octstr_destroy(newmsgid);
octstr_destroy(transid);
octstr_destroy(value);
}
/* This function checks that there is a boundary parameter in the headers
* for a multipart MIME object. If not, it is inserted and passed back to caller
* in the variable boundary_elem.
*/
static void fix_boundary_element(List *headers, Octstr **boundary_elem)
{
Octstr *value, *boundary;
long len;
/*
* Check if we have an boundary parameter already in the
* Content-Type header. If no, add one, otherwise parse which one
* we should use.
* XXX this can be abstracted as function in gwlib/http.[ch].
*/
value = http_header_value(headers, octstr_imm("Content-Type"));
boundary = value ? http_get_header_parameter(value, octstr_imm("boundary")) : NULL;
if (value == NULL) {
/* we got here because it is multi-part, so... */
value = octstr_create("multipart/mixed");
http_header_add(headers, "Content-Type", "multipart/mixed");
}
if (boundary == NULL) {
Octstr *v;
boundary = octstr_format("_boundary_%d_%ld_%c_%c_bd%d",
random(), (long) time(NULL), 'A' + (random() % 26),
'a' + (random() % 26), random());
octstr_format_append(value, "; boundary=%S", boundary);
http_header_remove_all(headers, "Content-Type");
http_header_add(headers, "Content-Type", octstr_get_cstr(value));
if ((v = http_header_value(headers, octstr_imm("MIME-Version"))) == NULL)
http_header_add(headers, "MIME-Version", "1.0");
else
octstr_destroy(v);
}
else if ((len = octstr_len(boundary)) > 0 &&
octstr_get_char(boundary, 0) == '"' &&
octstr_get_char(boundary, len - 1) == '"') {
octstr_delete(boundary, 0, 1);
octstr_delete(boundary, len - 2, 1);
}
octstr_destroy(value);
if (boundary_elem)
*boundary_elem = boundary;
else
octstr_destroy(boundary);
}
static Octstr *get_start_param(Octstr *content_type)
{
Octstr *start;
int len;
if (!content_type)
return NULL;
start = http_get_header_parameter(content_type, octstr_imm("start"));
if (start && (len = octstr_len(start)) > 0 &&
octstr_get_char(start, 0) == '"' && octstr_get_char(start, len-1) == '"') {
octstr_delete(start, 0, 1);
octstr_delete(start, len-2, 1);
}
return start;
}
/*
* Remove ':' plus spaces from the header value
*/
static void drop_separator(Octstr **header_value, long *pos)
{
long count;
octstr_delete(*header_value, 0, 1); /* remove :*/
count = octstr_drop_leading_blanks(header_value);
pos = pos - 1 - count;
}
static void fixup_value(Octstr *value, int lineno)
{
Octstr *tmp;
int i,n;
octstr_strip_blanks(value);
if (octstr_get_char(value, 0) != '"')
return;
if (octstr_get_char(value, octstr_len(value) - 1) != '"')
mms_error(0, "mms_cfg", NULL, "Missing enclosing '\"' at line %d in conf file", lineno);
octstr_delete(value, 0,1); /* strip quotes. */
octstr_delete(value, octstr_len(value) - 1, 1);
tmp = octstr_duplicate(value);
octstr_delete(value, 0, octstr_len(value));
for (i = 0, n = octstr_len(tmp); i < n; i++) {
int ch = octstr_get_char(tmp, i);
if (ch != '\\') {
octstr_append_char(value, ch);
continue;
}
i++; /* skip forward. */
ch = octstr_get_char(tmp,i);
switch(ch) {
case '"':
case '\\':
default:
octstr_append_char(value, ch);
break;
case 'n':
octstr_append_char(value, '\n');
break;
case 't':
octstr_append_char(value, '\t');
break;
}
}
octstr_destroy(tmp);
}
static void parse_value(Octstr *value)
{
Octstr *temp;
long len;
int c;
octstr_strip_blanks(value);
len = octstr_len(value);
if (octstr_get_char(value, 0) != '"' ||
octstr_get_char(value, len - 1) != '"')
return;
octstr_delete(value, len - 1, 1);
octstr_delete(value, 0, 1);
temp = octstr_duplicate(value);
octstr_truncate(value, 0);
while (octstr_len(temp) > 0) {
c = octstr_get_char(temp, 0);
octstr_delete(temp, 0, 1);
if (c != '\\' || octstr_len(temp) == 0)
octstr_append_char(value, c);
else {
c = octstr_get_char(temp, 0);
octstr_delete(temp, 0, 1);
switch (c) {
case '\\':
case '"':
octstr_append_char(value, c);
break;
default:
octstr_append_char(value, '\\');
octstr_append_char(value, c);
break;
}
}
}
octstr_destroy(temp);
}
static void octstr_drop_trailing_zeros(Octstr **date_token)
{
while (1) {
if (octstr_get_char(*date_token, octstr_len(*date_token) - 1) == '\0')
octstr_delete(*date_token, octstr_len(*date_token) - 1, 1);
else
return;
}
}
Octstr *copy_and_clean_address(Octstr *addr)
{
Octstr *s;
int k, i;
if (addr == NULL) return NULL;
s = octstr_duplicate(addr);
octstr_strip_blanks(s);
/* Only clean up email addresses for now. */
if ((k = octstr_search_char(s, '@',0)) < 0)
goto done;
/* Find '<' if any, then find last one and remove everything else. */
i = octstr_search_char(s, '<',0);
if (i >= 0) {
int j;
octstr_delete(s, 0, i+1); /* strip first part off. */
j = octstr_search_char(s, '>',0);
if (j >= 0)
octstr_delete(s, j, octstr_len(s));
} else {
/* remove everything after the domain. */
int n = octstr_len(s);
char *p = octstr_get_cstr(s);
for (i = k+1; i < n; i++)
if (isspace(p[i])) { /* there can't be space in domain, so this marks end of address. */
octstr_delete(s, i, n);
break;
}
}
done:
if (octstr_len(s) == 0) {
octstr_destroy(s);
s = NULL;
}
return s;
}
static int remove_long(long *p, Octstr *os)
{
long pos;
pos = octstr_parse_long(p, os, 0, 10);
if (pos == -1)
return -1;
octstr_delete(os, 0, pos);
return 0;
}
static int skip_tail(Octstr **os, int delimiter)
{
long delimiter_pos;
if ((delimiter_pos = octstr_search_char(*os, delimiter, 0)) == -1)
return 0;
octstr_delete(*os, delimiter_pos, octstr_len(*os) - delimiter_pos);
return 1;
}
Octstr *parse_get_rest(ParseContext *context)
{
Octstr *rest;
gw_assert(context != NULL);
octstr_delete(context->data, 0, context->pos);
rest = octstr_duplicate(context->data);
return rest;
}
static long eat_number(Octstr *ostr) {
long result;
long pos;
pos = octstr_parse_long(&result, ostr, 0, 10);
if (pos < 0)
return INT_MIN;
octstr_delete(ostr, 0, pos);
return result;
}
