int
main()
{
octstr_t a, b, c;
octstr_initv(&a, &b, &c, NULL);
octstr_append(&a, "hello \n");
octstr_append(&b, "from the\n");
octstr_append(&c, "side");
octstr_append_octstr(&a, &b);
octstr_append_octstr(&a, &c);
printf("result string is = \n");
octstr_print(&a);
printf("expected\n"
"\\x68\\x65\\x6C\\x6F\\x20"
"\\x0A\\x66\\x72\\x6F\\x6D"
"\\x20\\x74\\x68\\x65\\x0A"
"\\x73\\x69\\x64\\x65");
printf("====\n"
"bitwise tests:\n");
octstr_reset(&a);
octstr_reset(&b);
octstr_append_n(&a, "\xA5\x5A", 2);
octstr_append_n(&b, "\x5A\xA5", 2);
octstr_or(&c, &a, &b);
printf("octstr_or 0xA55A | 0x5AA5 = ");
octstr_print(&c);
octstr_and(&c, &a, &b);
printf("0xA55A & 0x5AA5 = ");
octstr_print(&c);
octstr_xor(&c, &a, &b);
printf("0xA55A ^ 0x5AA5 = ");
octstr_print(&c);
octstr_clearv(&a, &b, &c, NULL);
return 0;
}
static void write_msg(Msg *msg)
{
Octstr *pack;
unsigned char buf[4];
pack = store_msg_pack(msg);
encode_network_long(buf, octstr_len(pack));
octstr_insert_data(pack, 0, (char*)buf, 4);
octstr_print(file, pack);
fflush(file);
octstr_destroy(pack);
}
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;
}
int main(int argc, char **argv)
{
Octstr *mime_content,
*pap_content,
*push_data,
*rdf_content,
*boundary,
*push_content_file = NULL,
*this_header,
*pap_osname,
*data_osname;
List *content_headers,
*source_parts;
char *pap_content_file,
*push_data_file,
*rdf_content_file;
int ret,
std_out,
opt,
d_file,
c_file;
FILE *fp1,
*fp2,
*fp3;
gwlib_init();
std_out = 0;
d_file = 0;
c_file = 0;
data_osname = NULL;
pap_osname = NULL;
while ((opt = getopt(argc, argv, "hd:sc:")) != EOF) {
switch(opt) {
case 'h':
help();
exit(1);
break;
case 'd':
d_file = 1;
data_osname = octstr_create(optarg);
break;
case 'c':
c_file = 1;
pap_osname = octstr_create(optarg);
break;
case 's':
std_out = 1;
break;
case '?':
default:
error(0, "Invalid option %c", opt);
help();
panic(0, "Stopping");
break;
}
}
if (optind >= argc) {
help();
panic(0, "missing arguments, stopping");
}
if (!c_file)
pap_content_file = "test/pap.txt";
else
pap_content_file = octstr_get_cstr(pap_osname);
if (!d_file)
push_data_file = "test/data.txt";
else
push_data_file = octstr_get_cstr(data_osname);
rdf_content_file = "test/rdf.txt";
mime_content = octstr_read_file(argv[optind]);
if (mime_content == NULL) {
octstr_destroy(mime_content);
error(0, "No MIME source");
panic(0, "Stopping");
}
source_parts = octstr_split(mime_content, octstr_imm("content="));
if (gwlist_len(source_parts) == 1) { /* a hack to circumvent a bug */
error(0, "Badly formatted source:");
octstr_destroy(mime_content);
gwlist_destroy(source_parts, octstr_destroy_item);
panic(0, "Stopping");
}
boundary = gwlist_extract_first(source_parts);
octstr_delete(boundary, 0, octstr_len(octstr_imm("boundary=")));
if (skip_tail(&boundary, ';') == 0) {
error(0, "Cannot determine boundary, no delimiter; possible");
octstr_dump(boundary, 0);
goto no_parse;
}
octstr_destroy(mime_content);
mime_content = gwlist_extract_first(source_parts);
if (skip_tail(&mime_content, ';') == 0){
error(0, "Cannot determine mime content, no delimiter");
octstr_dump(mime_content, 0);
goto no_parse;
}
prepend_crlf(&mime_content);
add_crs(mime_content);
append_crlf(mime_content);
ret = mime_parse(boundary, mime_content, &pap_content, &push_data,
&content_headers, &rdf_content);
if (ret == 0) {
error(0, "Mime_parse returned 0, cannot continue");
goto error;
}
remove_crs(pap_content);
if (!std_out) {
fp1 = fopen(pap_content_file, "a");
if (fp1 == NULL) {
error(0, "Cannot open the file for pap control message");
goto error;
}
octstr_print(fp1, pap_content);
debug("test.mime", 0, "pap control message appended to the file");
fclose(fp1);
} else {
debug("test.mime", 0, "pap control message was");
octstr_dump(pap_content, 0);
}
remove_crs(push_data);
if (!std_out) {
fp2 = fopen(push_data_file, "a");
if (fp2 == NULL) {
error(0, "Cannot open the push data file");
goto error;
}
push_content_file = octstr_create("");
octstr_append(push_content_file, octstr_imm("headers="));
while (gwlist_len(content_headers) > 0) {
octstr_append(push_content_file,
this_header = gwlist_extract_first(content_headers));
octstr_format_append(push_content_file, "%c", ' ');
octstr_destroy(this_header);
}
octstr_append(push_content_file, octstr_imm(";\n"));
octstr_append(push_content_file, octstr_imm("content="));
octstr_append(push_content_file, push_data);
octstr_append(push_content_file, octstr_imm(";\n"));
octstr_print(fp2, push_content_file);
debug("test.mime", 0, "push content appended to the file");
fclose(fp2);
} else {
debug("test.mime", 0, "Content headers were");
http_header_dump(content_headers);
debug("test.mime", 0, "And push content itself");
octstr_dump(push_data, 0);
}
if (rdf_content != NULL)
remove_crs(rdf_content);
if (!std_out && rdf_content != NULL) {
fp3 = NULL;
if (rdf_content != NULL) {
fp3 = fopen(rdf_content_file, "a");
if (fp3 == NULL) {
error(0, "Cannot open the rdf file");
goto cerror;
}
octstr_print(fp3, rdf_content);
debug("test.mime", 0, "push caps message appended to the file");
fclose(fp3);
}
} else {
if (rdf_content != NULL) {
debug("test.mime", 0, "push caps message was");
octstr_dump(rdf_content, 0);
}
}
octstr_destroy(boundary);
octstr_destroy(mime_content);
octstr_destroy(pap_content);
octstr_destroy(push_data);
octstr_destroy(rdf_content);
octstr_destroy(pap_osname);
octstr_destroy(data_osname);
http_destroy_headers(content_headers);
gwlist_destroy(source_parts, octstr_destroy_item);
octstr_destroy(push_content_file);
gwlib_shutdown();
info(0, "MIME data parsed successfully");
return 0;
no_parse:
octstr_destroy(mime_content);
octstr_destroy(pap_osname);
octstr_destroy(data_osname);
gwlist_destroy(source_parts, octstr_destroy_item);
octstr_destroy(boundary);
gwlib_shutdown();
panic(0, "Stopping");
error:
octstr_destroy(mime_content);
gwlist_destroy(source_parts, octstr_destroy_item);
octstr_destroy(boundary);
octstr_destroy(pap_content);
octstr_destroy(push_data);
octstr_destroy(pap_osname);
octstr_destroy(data_osname);
http_destroy_headers(content_headers);
octstr_destroy(rdf_content);
gwlib_shutdown();
panic(0, "Stopping");
cerror:
octstr_destroy(mime_content);
gwlist_destroy(source_parts, octstr_destroy_item);
octstr_destroy(boundary);
octstr_destroy(pap_content);
octstr_destroy(push_data);
octstr_destroy(push_content_file);
octstr_destroy(pap_osname);
octstr_destroy(data_osname);
http_destroy_headers(content_headers);
octstr_destroy(rdf_content);
gwlib_shutdown();
panic(0, "Stopping");
/* return after panic always required by gcc */
return 1;
}
int main(int argc, char **argv)
{
output_t outputti = NORMAL_OUT;
FILE *fp = NULL;
Octstr *output = NULL;
Octstr *filename = NULL;
Octstr *wml_text = NULL;
Octstr *charset = NULL;
Octstr *wml_binary = NULL;
int i, ret = 0, opt, file = 0, zero = 0, numstatus = 0, wml_strict = 1;
long num = 0;
/* You can give an wml text file as an argument './wml_tester main.wml' */
gwlib_init();
while ((opt = getopt(argc, argv, "hsbzrn:f:c:")) != EOF) {
switch (opt) {
case 'h':
help();
exit(0);
case 's':
if (outputti == NORMAL_OUT)
outputti = SOURCE_OUT;
else {
help();
exit(0);
}
break;
case 'b':
if (outputti == NORMAL_OUT)
outputti = BINARY_OUT;
else {
help();
exit(0);
}
break;
case 'z':
zero = 1;
break;
case 'r':
wml_strict = 0;
break;
case 'n':
numstatus = octstr_parse_long(&num, octstr_imm(optarg), 0, 0);
if (numstatus == -1) {
/* Error in the octstr_parse_long */
error(num, "Error in the handling of argument to option n");
help();
panic(0, "Stopping.");
}
break;
case 'f':
file = 1;
filename = octstr_create(optarg);
fp = fopen(optarg, "a");
if (fp == NULL)
panic(0, "Couldn't open output file.");
break;
case 'c':
charset = octstr_create(optarg);
break;
case '?':
default:
error(0, "Invalid option %c", opt);
help();
panic(0, "Stopping.");
}
}
if (optind >= argc) {
error(0, "Missing arguments.");
help();
panic(0, "Stopping.");
}
if (outputti == BINARY_OUT)
log_set_output_level(GW_PANIC);
wml_init(wml_strict);
while (optind < argc) {
wml_text = octstr_read_file(argv[optind]);
if (wml_text == NULL)
panic(0, "Couldn't read WML source file.");
if (zero)
set_zero(wml_text);
for (i = 0; i <= num; i++) {
ret = wml_compile(wml_text, charset, &wml_binary, NULL);
if (i < num)
octstr_destroy(wml_binary);
}
optind++;
output = octstr_format("wml_compile returned: %d\n\n", ret);
if (ret == 0) {
if (fp == NULL)
fp = stdout;
if (outputti != BINARY_OUT) {
if (outputti == SOURCE_OUT) {
octstr_insert(output, wml_text, octstr_len(output));
octstr_append_char(output, '\n');
}
octstr_append(output, octstr_imm(
"Here's the binary output: \n\n"));
octstr_print(fp, output);
}
if (file && outputti != BINARY_OUT) {
fclose(fp);
log_open(octstr_get_cstr(filename), 0, GW_NON_EXCL);
octstr_dump(wml_binary, 0);
log_close_all();
fp = fopen(octstr_get_cstr(filename), "a");
} else if (outputti != BINARY_OUT)
octstr_dump(wml_binary, 0);
else
octstr_print(fp, wml_binary);
if (outputti != BINARY_OUT) {
octstr_destroy(output);
output = octstr_format("\n And as a text: \n\n");
octstr_print(fp, output);
octstr_pretty_print(fp, wml_binary);
octstr_destroy(output);
output = octstr_format("\n\n");
octstr_print(fp, output);
}
}
octstr_destroy(wml_text);
octstr_destroy(output);
octstr_destroy(wml_binary);
}
if (file) {
fclose(fp);
octstr_destroy(filename);
}
if (charset != NULL)
octstr_destroy(charset);
wml_shutdown();
gwlib_shutdown();
return ret;
}
static void client_thread(void *arg)
{
HTTPClient *client;
Octstr *body, *url, *ip;
List *headers, *resph, *cgivars;
HTTPCGIVar *v;
Octstr *reply_body, *reply_type;
unsigned long n = 0;
int status, i;
while (run) {
client = http_accept_request(port, &ip, &url, &headers, &body, &cgivars);
n++;
if (client == NULL)
break;
info(0, "Request for <%s> from <%s>",
octstr_get_cstr(url), octstr_get_cstr(ip));
if (verbose)
debug("test.http", 0, "CGI vars were");
/*
* Don't use gwlist_extract() here, otherwise we don't have a chance
* to re-use the cgivars later on.
*/
for (i = 0; i < gwlist_len(cgivars); i++) {
if ((v = gwlist_get(cgivars, i)) != NULL && verbose) {
octstr_dump(v->name, 0);
octstr_dump(v->value, 0);
}
}
if (arg == NULL) {
reply_body = octstr_duplicate(reply_text);
reply_type = octstr_create("Content-Type: text/plain; "
"charset=\"UTF-8\"");
} else {
reply_body = octstr_duplicate(arg);
reply_type = octstr_create("Content-Type: text/vnd.wap.wml");
}
resph = gwlist_create();
gwlist_append(resph, reply_type);
status = HTTP_OK;
/* check for special URIs and handle those */
if (octstr_compare(url, octstr_imm("/quit")) == 0) {
run = 0;
} else if (octstr_compare(url, octstr_imm("/whitelist")) == 0) {
octstr_destroy(reply_body);
if (whitelist != NULL) {
if (verbose) {
debug("test.http.server", 0, "we send a white list");
octstr_dump(whitelist, 0);
}
reply_body = octstr_duplicate(whitelist);
} else {
reply_body = octstr_imm("");
}
} else if (octstr_compare(url, octstr_imm("/blacklist")) == 0) {
octstr_destroy(reply_body);
if (blacklist != NULL) {
if (verbose) {
debug("test.http.server", 0, "we send a blacklist");
octstr_dump(blacklist, 0);
}
reply_body = octstr_duplicate(blacklist);
} else {
reply_body = octstr_imm("");
}
} else if (octstr_compare(url, octstr_imm("/save")) == 0) {
/* safe the body into a temporary file */
pid_t pid = getpid();
FILE *f = fopen(octstr_get_cstr(octstr_format("/tmp/body.%ld.%ld", pid, n)), "w");
octstr_print(f, body);
fclose(f);
} else if (octstr_compare(url, octstr_imm("/redirect/")) == 0) {
/* provide us with a HTTP 302 redirection response
* will return /redirect/<pid> for the location header
* and will return /redirect/ if cgivar loop is set to allow looping
*/
Octstr *redirect_header, *scheme, *uri, *l;
pid_t pid = getpid();
uri = ((l = http_cgi_variable(cgivars, "loop")) != NULL) ?
octstr_format("%s?loop=%s", octstr_get_cstr(url),
octstr_get_cstr(l)) :
octstr_format("%s%ld", octstr_get_cstr(url), pid);
octstr_destroy(reply_body);
reply_body = octstr_imm("Here you got a redirection URL that you should follow.");
scheme = ssl ? octstr_imm("https://") : octstr_imm("http://");
redirect_header = octstr_format("Location: %s%s%s",
octstr_get_cstr(scheme),
octstr_get_cstr(http_header_value(headers, octstr_imm("Host"))),
octstr_get_cstr(uri));
gwlist_append(resph, redirect_header);
status = HTTP_FOUND; /* will provide 302 */
octstr_destroy(uri);
} else if (octstr_compare(url, octstr_imm("/mmsc")) == 0) {
/* fake a M-Send.conf PDU which is using MMSEncapsulation as body */
pid_t pid = getpid();
FILE *f;
gwlist_destroy(resph, octstr_destroy_item);
octstr_destroy(reply_body);
reply_type = octstr_create("Content-Type: application/vnd.wap.mms-message");
reply_body = octstr_create("");
octstr_append_from_hex(reply_body,
"8c81" /* X-Mms-Message-Type: m-send-conf */
"98632d3862343300" /* X-Mms-Transaction-ID: c-8b43 */
"8d90" /* X-Mms-MMS-Version: 1.0 */
"9280" /* Response-status: Ok */
"8b313331373939353434393639383434313731323400"
); /* Message-Id: 13179954496984417124 */
resph = gwlist_create();
gwlist_append(resph, reply_type);
/* safe the M-Send.req body into a temporary file */
f = fopen(octstr_get_cstr(octstr_format("/tmp/mms-body.%ld.%ld", pid, n)), "w");
octstr_print(f, body);
fclose(f);
}
if (verbose) {
debug("test.http", 0, "request headers were");
http_header_dump(headers);
if (body != NULL) {
debug("test.http", 0, "request body was");
octstr_dump(body, 0);
}
}
if (extra_headers != NULL)
http_header_combine(resph, extra_headers);
/* return response to client */
http_send_reply(client, status, resph, reply_body);
octstr_destroy(ip);
octstr_destroy(url);
octstr_destroy(body);
octstr_destroy(reply_body);
http_destroy_cgiargs(cgivars);
gwlist_destroy(headers, octstr_destroy_item);
gwlist_destroy(resph, octstr_destroy_item);
}
octstr_destroy(whitelist);
octstr_destroy(blacklist);
debug("test.http", 0, "Working thread 'client_thread' terminates");
http_close_all_ports();
}
int main(int argc, char **argv)
{
char id[UUID_STR_LEN + 1];
int cf_index, ret, type;
Octstr *os, *store_type, *store_location, *status;
Msg *msg;
CfgGroup *grp;
conf_file = NULL;
gwlib_init();
//This can be overwritten with the -v flag at runtime
log_set_output_level(DEFAULT_LOG_LEVEL);
cf_index = get_and_set_debugs(argc, argv, check_args);
if (argv[cf_index] == NULL) {
print_usage(argv[0]);
goto error;
}
if (conf_file == NULL)
conf_file = octstr_create("kannel.conf");
cfg = cfg_create(conf_file);
if (cfg_read(cfg) == -1)
panic(0, "Couldn't read configuration from `%s'.", octstr_get_cstr(conf_file));
info(0, "1");
grp = cfg_get_single_group(cfg, octstr_imm("core"));
if (grp == NULL) {
printf("FATAL: Could not load Kannel's core group. Exiting.\n");
return 2;
}
store_location = cfg_get(grp, octstr_imm("store-location"));
store_type = cfg_get(grp, octstr_imm("store-type"));
store_init(store_type, store_location, -1, msg_pack, msg_unpack_wrapper);
switch (command) {
case COMMAND_LIST:
printf("Listing records %d -> %d\n", list_from+1, list_limit);
print_header();
store_load(print_msg);
if (counter == 0) {
printf("|%60s%14s%60s|\n", "", "Store is Empty", "");
}
print_sep();
break;
case COMMAND_DELETE:
store_load(msg_count);
msg = msg_create(ack);
msg->ack.nack = ack_failed;
msg->ack.time = time(NULL);
uuid_parse(octstr_get_cstr(param_1), msg->ack.id);
ret = store_save(msg);
if (ret == 0) {
printf("Deleted message %s\n", octstr_get_cstr(param_1));
counter--;
} else {
printf("Could not delete message %s\n", octstr_get_cstr(param_1));
}
msg_destroy(msg);
break;
case COMMAND_EXPORT:
counter = 0;
type = 0;
list = gwlist_create();
store_load(msg_push);
printf("Exporting %ld messages...\n", gwlist_len(list));
if ((octstr_compare(param_1, octstr_imm("file")) == 0) ||
(octstr_compare(param_1, octstr_imm("spool")) == 0)) {
store_shutdown();
store_init(param_1, param_2, -1, msg_pack, msg_unpack_wrapper);
store_load(msg_count);
while ((os = gwlist_extract_first(list)) != NULL) {
msg = msg_unpack_wrapper(os);
if (msg != NULL) {
ret = store_save(msg);
if (ret == 0) {
counter++;
} else {
printf("Error saving message\n");
}
} else {
printf("Error extracting message\n");
}
msg_destroy(msg);
}
status = NULL;
} else if (octstr_compare(param_1, octstr_imm("text")) == 0) {
status = store_status(BBSTATUS_TEXT);
} else if (octstr_compare(param_1, octstr_imm("html")) == 0) {
status = store_status(BBSTATUS_HTML);
} else if (octstr_compare(param_1, octstr_imm("xml")) == 0) {
status = store_status(BBSTATUS_XML);
} else {
status = NULL;
}
if (status != NULL) {
file = fopen(octstr_get_cstr(param_2), "w");
if (file == NULL) {
error(errno, "Failed to open '%s' for writing, cannot create output file",
octstr_get_cstr(param_2));
return -1;
}
octstr_print(file, status);
fflush(file);
if (file != NULL)
fclose(file);
//printf("%s", octstr_get_cstr(status));
}
gwlist_destroy(list, octstr_destroy_item);
break;
default:
break;
}
octstr_destroy(store_type);
octstr_destroy(store_location);
cfg_destroy(cfg);
store_shutdown();
error:
gwlib_shutdown();
return 1;
}