void EQEmu::ProfanityManager::RedactMessage(std::string &message) {
if (message.length() < REDACTION_LENGTH_MIN || message.length() >= 4096)
return;
std::string test_message(const_cast<const std::string&>(message));
std::transform(test_message.begin(), test_message.end(), test_message.begin(), [](unsigned char c) -> unsigned char { return tolower(c); });
for (const auto &iter : profanity_list) { // consider adding textlink checks if it becomes an issue
size_t pos = 0;
size_t start_pos = 0;
while (pos != std::string::npos) {
pos = test_message.find(iter, start_pos);
if (pos == std::string::npos)
continue;
if ((pos + iter.length()) == test_message.length() || !isalpha(test_message.at(pos + iter.length()))) {
if (pos == 0 || !isalpha(test_message.at(pos - 1)))
message.replace(pos, iter.length(), iter.length(), REDACTION_CHARACTER);
}
start_pos = (pos + iter.length());
}
}
}
void EQEmu::ProfanityManager::RedactMessage(char *message) {
if (!message)
return;
std::string test_message(message);
// hard-coded max length based on channel message buffer size (4096 bytes)..
// ..will need to change or remove if other sources are used for redaction
if (test_message.length() < REDACTION_LENGTH_MIN || test_message.length() >= 4096)
return;
std::transform(test_message.begin(), test_message.end(), test_message.begin(), [](unsigned char c) -> unsigned char { return tolower(c); });
for (const auto &iter : profanity_list) { // consider adding textlink checks if it becomes an issue
size_t pos = 0;
size_t start_pos = 0;
while (pos != std::string::npos) {
pos = test_message.find(iter, start_pos);
if (pos == std::string::npos)
continue;
if ((pos + iter.length()) == test_message.length() || !isalpha(test_message.at(pos + iter.length()))) {
if (pos == 0 || !isalpha(test_message.at(pos - 1)))
memset((message + pos), REDACTION_CHARACTER, iter.length());
}
start_pos = (pos + iter.length());
}
}
}
int main (void)
{
test_message ();
test_attribute ();
test_vectors ();
test_hash_creds ();
return 0;
}
int main()
{
sys::error_category const & cat = sys::system_category();
// message
for( int i = -2; i < 1024; ++i )
{
test_message( cat, i );
}
test_message( cat, 5810 );
for( int i = 10000; i < 11032; ++i )
{
test_message( cat, i );
}
return boost::report_errors();
}
bool EQEmu::ProfanityManager::ContainsCensoredLanguage(const std::string &message) {
if (message.length() < REDACTION_LENGTH_MIN || message.length() >= 4096)
return false;
std::string test_message(message);
std::transform(test_message.begin(), test_message.end(), test_message.begin(), [](unsigned char c) -> unsigned char { return tolower(c); });
for (const auto &iter : profanity_list) {
if (test_message.find(iter) != std::string::npos)
return true;
}
return false;
}
void binary_reader::bin_read_tests::generation_messages( std::string test_file_name )
{
std::ofstream test_file( BINARY_DIR + test_file_name, std::ios::binary );
BOOST_CHECK ( test_file.is_open() );
std::string str;
char c = '1';
for( uint32_t i = 1; i < 10; i++, c++)
{
str = "test_string";
str += c;
test_message msg( i, i, str.c_str() );
msg.write( test_file );
}
test_message( 10ul, 10ul, NULL ).write( test_file );
test_file.close();
}
static gboolean
test_stream (GMimeStream *stream)
{
GMimeParser *parser;
GMimeMessage *msg;
gboolean rv;
parser = NULL;
msg = NULL;
parser = g_mime_parser_new_with_stream (stream);
if (!parser) {
g_warning ("failed to create parser");
rv = FALSE;
goto leave;
}
msg = g_mime_parser_construct_message (parser);
if (!msg) {
g_warning ("failed to construct message");
rv = FALSE;
goto leave;
}
rv = test_message (msg);
leave:
if (parser)
g_object_unref (parser);
else
g_object_unref (stream);
if (msg)
g_object_unref (msg);
return rv;
}
int main(void) {
sd_rtnl *rtnl;
sd_rtnl_message *m;
sd_rtnl_message *r;
const char *string_data;
int if_loopback;
uint16_t type;
test_message();
test_match();
test_multiple();
test_route();
test_container();
assert_se(sd_rtnl_open(&rtnl, 0) >= 0);
assert_se(rtnl);
if_loopback = (int) if_nametoindex("lo");
assert_se(if_loopback > 0);
test_async(if_loopback);
test_pipe(if_loopback);
test_event_loop(if_loopback);
test_link_configure(rtnl, if_loopback);
test_get_addresses(rtnl);
test_message_link_bridge(rtnl);
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, if_loopback) >= 0);
assert_se(m);
assert_se(sd_rtnl_message_get_type(m, &type) >= 0);
assert_se(type == RTM_GETLINK);
assert_se(sd_rtnl_message_read_string(m, IFLA_IFNAME, &string_data) == -EPERM);
assert_se(sd_rtnl_call(rtnl, m, 0, &r) == 1);
assert_se(sd_rtnl_message_get_type(r, &type) >= 0);
assert_se(type == RTM_NEWLINK);
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
assert_se(sd_rtnl_call(rtnl, m, -1, &r) == -EPERM);
assert_se((m = sd_rtnl_message_unref(m)) == NULL);
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
test_link_get(rtnl, if_loopback);
test_address_get(rtnl, if_loopback);
assert_se(sd_rtnl_flush(rtnl) >= 0);
assert_se((m = sd_rtnl_message_unref(m)) == NULL);
assert_se((r = sd_rtnl_message_unref(r)) == NULL);
assert_se((rtnl = sd_rtnl_unref(rtnl)) == NULL);
return EXIT_SUCCESS;
}
int
main (void)
{
parser = NULL;
int i, j, k;
int request_count;
int response_count;
printf("sizeof(http_parser) = %d\n", sizeof(http_parser));
for (request_count = 0; requests[request_count].name; request_count++);
for (response_count = 0; responses[response_count].name; response_count++);
//// RESPONSES
for (i = 0; i < response_count; i++) {
test_message(&responses[i]);
}
for (i = 0; i < response_count; i++) {
if (!responses[i].should_keep_alive) continue;
for (j = 0; j < response_count; j++) {
if (!responses[j].should_keep_alive) continue;
for (k = 0; k < response_count; k++) {
test_multiple3(&responses[i], &responses[j], &responses[k]);
}
}
}
printf("response scan 1/1 ");
test_scan( &responses[TRAILING_SPACE_ON_CHUNKED_BODY]
, &responses[NO_HEADERS_NO_BODY_404]
, &responses[NO_REASON_PHRASE]
);
puts("responses okay");
/// REQUESTS
test_error("hello world");
test_error("GET / HTP/1.1\r\n\r\n");
const char *dumbfuck2 =
"GET / HTTP/1.1\r\n"
"X-SSL-Bullshit: -----BEGIN CERTIFICATE-----\r\n"
"\tMIIFbTCCBFWgAwIBAgICH4cwDQYJKoZIhvcNAQEFBQAwcDELMAkGA1UEBhMCVUsx\r\n"
"\tETAPBgNVBAoTCGVTY2llbmNlMRIwEAYDVQQLEwlBdXRob3JpdHkxCzAJBgNVBAMT\r\n"
"\tAkNBMS0wKwYJKoZIhvcNAQkBFh5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMu\r\n"
"\tdWswHhcNMDYwNzI3MTQxMzI4WhcNMDcwNzI3MTQxMzI4WjBbMQswCQYDVQQGEwJV\r\n"
"\tSzERMA8GA1UEChMIZVNjaWVuY2UxEzARBgNVBAsTCk1hbmNoZXN0ZXIxCzAJBgNV\r\n"
"\tBAcTmrsogriqMWLAk1DMRcwFQYDVQQDEw5taWNoYWVsIHBhcmQYJKoZIhvcNAQEB\r\n"
"\tBQADggEPADCCAQoCggEBANPEQBgl1IaKdSS1TbhF3hEXSl72G9J+WC/1R64fAcEF\r\n"
"\tW51rEyFYiIeZGx/BVzwXbeBoNUK41OK65sxGuflMo5gLflbwJtHBRIEKAfVVp3YR\r\n"
"\tgW7cMA/s/XKgL1GEC7rQw8lIZT8RApukCGqOVHSi/F1SiFlPDxuDfmdiNzL31+sL\r\n"
"\t0iwHDdNkGjy5pyBSB8Y79dsSJtCW/iaLB0/n8Sj7HgvvZJ7x0fr+RQjYOUUfrePP\r\n"
"\tu2MSpFyf+9BbC/aXgaZuiCvSR+8Snv3xApQY+fULK/xY8h8Ua51iXoQ5jrgu2SqR\r\n"
"\twgA7BUi3G8LFzMBl8FRCDYGUDy7M6QaHXx1ZWIPWNKsCAwEAAaOCAiQwggIgMAwG\r\n"
"\tA1UdEwEB/wQCMAAwEQYJYIZIAYb4QgHTTPAQDAgWgMA4GA1UdDwEB/wQEAwID6DAs\r\n"
"\tBglghkgBhvhCAQ0EHxYdVUsgZS1TY2llbmNlIFVzZXIgQ2VydGlmaWNhdGUwHQYD\r\n"
"\tVR0OBBYEFDTt/sf9PeMaZDHkUIldrDYMNTBZMIGaBgNVHSMEgZIwgY+AFAI4qxGj\r\n"
"\tloCLDdMVKwiljjDastqooXSkcjBwMQswCQYDVQQGEwJVSzERMA8GA1UEChMIZVNj\r\n"
"\taWVuY2UxEjAQBgNVBAsTCUF1dGhvcml0eTELMAkGA1UEAxMCQ0ExLTArBgkqhkiG\r\n"
"\t9w0BCQEWHmNhLW9wZXJhdG9yQGdyaWQtc3VwcG9ydC5hYy51a4IBADApBgNVHRIE\r\n"
"\tIjAggR5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMudWswGQYDVR0gBBIwEDAO\r\n"
"\tBgwrBgEEAdkvAQEBAQYwPQYJYIZIAYb4QgEEBDAWLmh0dHA6Ly9jYS5ncmlkLXN1\r\n"
"\tcHBvcnQuYWMudmT4sopwqlBWsvcHViL2NybC9jYWNybC5jcmwwPQYJYIZIAYb4QgEDBDAWLmh0\r\n"
"\tdHA6Ly9jYS5ncmlkLXN1cHBvcnQuYWMudWsvcHViL2NybC9jYWNybC5jcmwwPwYD\r\n"
"\tVR0fBDgwNjA0oDKgMIYuaHR0cDovL2NhLmdyaWQt5hYy51ay9wdWIv\r\n"
"\tY3JsL2NhY3JsLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAS/U4iiooBENGW/Hwmmd3\r\n"
"\tXCy6Zrt08YjKCzGNjorT98g8uGsqYjSxv/hmi0qlnlHs+k/3Iobc3LjS5AMYr5L8\r\n"
"\tUO7OSkgFFlLHQyC9JzPfmLCAugvzEbyv4Olnsr8hbxF1MbKZoQxUZtMVu29wjfXk\r\n"
"\thTeApBv7eaKCWpSp7MCbvgzm74izKhu3vlDk9w6qVrxePfGgpKPqfHiOoGhFnbTK\r\n"
"\twTC6o2xq5y0qZ03JonF7OJspEd3I5zKY3E+ov7/ZhW6DqT8UFvsAdjvQbXyhV8Eu\r\n"
"\tYhixw1aKEPzNjNowuIseVogKOLXxWI5vAi5HgXdS0/ES5gDGsABo4fqovUKlgop3\r\n"
"\tRA==\r\n"
"\t-----END CERTIFICATE-----\r\n"
"\r\n";
test_error(dumbfuck2);
#if 0
// NOTE(Wed Nov 18 11:57:27 CET 2009) this seems okay. we just read body
// until EOF.
//
// no content-length
// error if there is a body without content length
const char *bad_get_no_headers_no_body = "GET /bad_get_no_headers_no_body/world HTTP/1.1\r\n"
"Accept: */*\r\n"
"\r\n"
"HELLO";
test_error(bad_get_no_headers_no_body);
#endif
/* TODO sending junk and large headers gets rejected */
/* check to make sure our predefined requests are okay */
for (i = 0; requests[i].name; i++) {
test_message(&requests[i]);
}
for (i = 0; i < request_count; i++) {
if (!requests[i].should_keep_alive) continue;
for (j = 0; j < request_count; j++) {
if (!requests[j].should_keep_alive) continue;
for (k = 0; k < request_count; k++) {
test_multiple3(&requests[i], &requests[j], &requests[k]);
}
}
}
printf("request scan 1/3 ");
test_scan( &requests[GET_NO_HEADERS_NO_BODY]
, &requests[GET_ONE_HEADER_NO_BODY]
, &requests[GET_NO_HEADERS_NO_BODY]
);
printf("request scan 2/3 ");
test_scan( &requests[POST_CHUNKED_ALL_YOUR_BASE]
, &requests[POST_IDENTITY_BODY_WORLD]
, &requests[GET_FUNKY_CONTENT_LENGTH]
);
printf("request scan 3/3 ");
test_scan( &requests[TWO_CHUNKS_MULT_ZERO_END]
, &requests[CHUNKED_W_TRAILING_HEADERS]
, &requests[CHUNKED_W_BULLSHIT_AFTER_LENGTH]
);
puts("requests okay");
return 0;
}
static void test_transaction(void) {
_c_cleanup_(b1_peer_unrefp) B1Peer *src = NULL, *dst = NULL;
_c_cleanup_(b1_node_freep) B1Node *node = NULL;
_c_cleanup_(b1_handle_unrefp) B1Handle *handle = NULL;
_c_cleanup_(b1_message_unrefp) B1Message *message = NULL;
const char *payload = "WOOF";
struct iovec vec = {
.iov_base = (void*)payload,
.iov_len = strlen(payload) + 1,
};
struct iovec *vec_out;
size_t n_vec;
int r, fd;
r = b1_peer_new(&src);
assert(r >= 0);
r = b1_peer_new(&dst);
assert(r >= 0);
r = b1_node_new(dst, &node);
assert(r >= 0);
r = b1_handle_transfer(b1_node_get_handle(node), src, &handle);
assert(r >= 0);
r = b1_message_new(src, &message);
assert(r >= 0);
r = b1_message_set_payload(message, &vec, 1);
assert(r >= 0);
r = b1_message_set_handles(message, &handle, 1);
assert(r >= 0);
fd = eventfd(0, 0);
assert(fd >= 0);
r = b1_message_set_fds(message, &fd, 1);
assert(r >= 0);
assert(close(fd) >= 0);
r = b1_message_send(message, &handle, 1);
assert(r >= 0);
message = b1_message_unref(message);
assert(!message);
handle = b1_handle_unref(handle);
assert(!handle);
r = b1_peer_recv(dst, &message);
assert(r >= 0);
assert(message);
assert(b1_message_get_type(message) == BUS1_MSG_DATA);
assert(b1_message_get_destination_node(message) == node);
assert(b1_message_get_uid(message) == getuid());
assert(b1_message_get_gid(message) == getgid());
assert(b1_message_get_pid(message) == getpid());
assert(b1_message_get_tid(message) == c_syscall_gettid());
r = b1_message_get_payload(message, &vec_out, &n_vec);
assert(r >= 0);
assert(vec_out);
assert(n_vec == 1);
assert(vec_out->iov_len == strlen("WOOF") + 1);
assert(strcmp(vec_out->iov_base, "WOOF") == 0);
r = b1_message_get_handle(message, 0, &handle);
assert(r >= 0);
assert(handle == b1_node_get_handle(node));
handle = NULL;
r = b1_message_get_fd(message, 0, &fd);
assert(r >= 0);
assert(fd >= 0);
message = b1_message_unref(message);
r = b1_peer_recv(dst, &message);
assert(r >= 0);
assert(message);
assert(b1_message_get_type(message) == BUS1_MSG_NODE_RELEASE);
assert(b1_message_get_destination_node(message) == node);
assert(b1_message_get_uid(message) == (uid_t)-1);
assert(b1_message_get_gid(message) == (gid_t)-1);
assert(b1_message_get_pid(message) == 0);
assert(b1_message_get_tid(message) == 0);
message = b1_message_unref(message);
r = b1_node_destroy(node);
assert(r >= 0);
r = b1_peer_recv(dst, &message);
assert(r >= 0);
assert(message);
assert(b1_message_get_type(message) == BUS1_MSG_NODE_DESTROY);
assert(b1_message_get_destination_node(message));
assert(b1_message_get_destination_node(message) == node);
assert(b1_message_get_uid(message) == (uid_t)-1);
assert(b1_message_get_gid(message) == (gid_t)-1);
assert(b1_message_get_pid(message) == 0);
assert(b1_message_get_tid(message) == 0);
message = b1_message_unref(message);
r = b1_peer_recv(dst, &message);
assert(r == -EAGAIN);
r = b1_peer_recv(src, &message);
assert(r == -EAGAIN);
}
static void test_multicast(void) {
_c_cleanup_(b1_peer_unrefp) B1Peer *src = NULL, *dst1 = NULL, *dst2 = NULL;
_c_cleanup_(b1_node_freep) B1Node *node1 = NULL, *node2 = NULL;
_c_cleanup_(b1_message_unrefp) B1Message *message = NULL;
const char *payload = "WOOF";
struct iovec vec = {
.iov_base = (void*)payload,
.iov_len = strlen(payload) + 1,
};
struct iovec *vec_out;
size_t n_vec;
B1Handle *handles[2], *handle;
int r, fd;
r = b1_peer_new(&src);
assert(r >= 0);
r = b1_peer_new(&dst1);
assert(r >= 0);
r = b1_peer_new(&dst2);
assert(r >= 0);
r = b1_node_new(dst1, &node1);
assert(r >= 0);
r = b1_node_new(dst2, &node2);
assert(r >= 0);
r = b1_handle_transfer(b1_node_get_handle(node1), src, &handles[0]);
assert(r >= 0);
r = b1_handle_transfer(b1_node_get_handle(node2), src, &handles[1]);
assert(r >= 0);
r = b1_message_new(src, &message);
assert(r >= 0);
r = b1_message_set_payload(message, &vec, 1);
assert(r >= 0);
r = b1_message_set_handles(message, handles, 2);
assert(r >= 0);
fd = eventfd(0, 0);
assert(fd >= 0);
r = b1_message_set_fds(message, &fd, 1);
assert(r >= 0);
assert(close(fd) >= 0);
r = b1_message_send(message, handles, 2);
assert(r >= 0);
message = b1_message_unref(message);
assert(!message);
handles[0] = b1_handle_unref(handles[0]);
assert(!handles[0]);
handles[1] = b1_handle_unref(handles[1]);
assert(!handles[1]);
r = b1_peer_recv(dst1, &message);
assert(r >= 0);
assert(message);
assert(b1_message_get_type(message) == BUS1_MSG_DATA);
assert(b1_message_get_destination_node(message) == node1);
assert(b1_message_get_uid(message) == getuid());
assert(b1_message_get_gid(message) == getgid());
assert(b1_message_get_pid(message) == getpid());
assert(b1_message_get_tid(message) == c_syscall_gettid());
r = b1_message_get_payload(message, &vec_out, &n_vec);
assert(r >= 0);
assert(vec_out);
assert(n_vec == 1);
assert(vec_out->iov_len == strlen("WOOF") + 1);
assert(strcmp(vec_out->iov_base, "WOOF") == 0);
r = b1_message_get_handle(message, 0, &handle);
assert(r >= 0);
assert(handle == b1_node_get_handle(node1));
r = b1_message_get_handle(message, 1, &handle);
assert(r >= 0);
assert(handle);
assert(handle != b1_node_get_handle(node1));
r = b1_message_get_fd(message, 0, &fd);
assert(r >= 0);
assert(fd >= 0);
message = b1_message_unref(message);
r = b1_peer_recv(dst2, &message);
assert(r >= 0);
assert(message);
assert(b1_message_get_type(message) == BUS1_MSG_DATA);
assert(b1_message_get_destination_node(message) == node2);
assert(b1_message_get_uid(message) == getuid());
assert(b1_message_get_gid(message) == getgid());
assert(b1_message_get_pid(message) == getpid());
assert(b1_message_get_tid(message) == c_syscall_gettid());
r = b1_message_get_payload(message, &vec_out, &n_vec);
assert(r >= 0);
assert(vec_out);
assert(n_vec == 1);
assert(vec_out->iov_len == strlen("WOOF") + 1);
assert(strcmp(vec_out->iov_base, "WOOF") == 0);
r = b1_message_get_handle(message, 0, &handle);
assert(r >= 0);
assert(handle);
assert(handle != b1_node_get_handle(node2));
r = b1_message_get_handle(message, 1, &handle);
assert(r >= 0);
assert(handle);
assert(handle == b1_node_get_handle(node2));
r = b1_message_get_fd(message, 0, &fd);
assert(r >= 0);
assert(fd >= 0);
message = b1_message_unref(message);
r = b1_peer_recv(dst1, &message);
assert(r >= 0);
assert(message);
assert(b1_message_get_type(message) == BUS1_MSG_NODE_RELEASE);
assert(b1_message_get_destination_node(message) == node1);
assert(b1_message_get_uid(message) == (uid_t)-1);
assert(b1_message_get_gid(message) == (gid_t)-1);
assert(b1_message_get_pid(message) == 0);
assert(b1_message_get_tid(message) == 0);
message = b1_message_unref(message);
r = b1_peer_recv(dst2, &message);
assert(r >= 0);
assert(message);
assert(b1_message_get_type(message) == BUS1_MSG_NODE_RELEASE);
assert(b1_message_get_destination_node(message) == node2);
assert(b1_message_get_uid(message) == (uid_t)-1);
assert(b1_message_get_gid(message) == (gid_t)-1);
assert(b1_message_get_pid(message) == 0);
assert(b1_message_get_tid(message) == 0);
message = b1_message_unref(message);
r = b1_node_destroy(node1);
assert(r >= 0);
r = b1_peer_recv(dst1, &message);
assert(r >= 0);
assert(message);
assert(b1_message_get_type(message) == BUS1_MSG_NODE_DESTROY);
assert(b1_message_get_destination_node(message) == node1);
assert(b1_message_get_uid(message) == (uid_t)-1);
assert(b1_message_get_gid(message) == (gid_t)-1);
assert(b1_message_get_pid(message) == 0);
assert(b1_message_get_tid(message) == 0);
message = b1_message_unref(message);
r = b1_node_destroy(node2);
assert(r >= 0);
r = b1_peer_recv(dst2, &message);
assert(r >= 0);
assert(message);
assert(b1_message_get_type(message) == BUS1_MSG_NODE_DESTROY);
assert(b1_message_get_destination_node(message) == node2);
assert(b1_message_get_uid(message) == (uid_t)-1);
assert(b1_message_get_gid(message) == (gid_t)-1);
assert(b1_message_get_pid(message) == 0);
assert(b1_message_get_tid(message) == 0);
message = b1_message_unref(message);
r = b1_peer_recv(dst1, &message);
assert(r == -EAGAIN);
r = b1_peer_recv(dst2, &message);
assert(r == -EAGAIN);
r = b1_peer_recv(src, &message);
assert(r == -EAGAIN);
}
int main(int argc, char **argv) {
if (access("/dev/bus1", F_OK) < 0 && errno == ENOENT)
return 77;
test_peer();
test_node();
test_handle();
test_message();
test_transaction();
test_multicast();
return 0;
}
int
main (int argc, char **argv)
{
int success = 1;
int verbose = 0; /* 1: verbose, 0 (or nothing: not verbose) */
int clone = 0; /* 1: verbose, 0 (or nothing: not verbose) */
int binary = 0;
FILE *torture_file;
char *msg;
int pos;
int len;
for (pos = 3; pos < argc; pos++) {
if (0 == strncmp (argv[pos], "-v", 2))
verbose = 1;
else if (0 == strncmp (argv[pos], "-c", 2))
clone = 1;
else if (0 == strncmp (argv[pos], "-b", 2))
binary = 1;
else
usage ();
}
if (argc < 3) {
usage ();
}
torture_file = fopen (argv[1], "r");
if (torture_file == NULL) {
usage ();
}
/* initialize parser */
parser_init ();
if (binary) {
if (read_binary (&msg, &len, torture_file) < 0)
return -1;
}
else {
msg = read_text (atoi (argv[2]), torture_file);
if (!msg)
return -1;
len = strlen (msg);
}
success = test_message (msg, len, verbose, clone);
if (verbose) {
fprintf (stdout, "test %s : ============================ \n", argv[2]);
fwrite (msg, 1, len, stdout);
if (0 == success)
fprintf (stdout, "test %s : ============================ OK\n", argv[2]);
else
fprintf (stdout, "test %s : ============================ FAILED\n", argv[2]);
}
osip_free (msg);
fclose (torture_file);
#ifdef __linux
if (success)
exit (EXIT_FAILURE);
else
exit (EXIT_SUCCESS);
#endif
return success;
}
/** Program start */
int
main (int argc, char *argv[])
{
/* MPI stuff */
int rank = 0;
int np = 0;
char hostname[MPI_MAX_PROCESSOR_NAME+1];
int namelen = 0;
/* Output file */
const char* outfile = "async.dat";
FILE *fp = NULL; /* output file, only valid on rank 0 */
/* Message buffer */
int* msgbuf = NULL;
const int msglen = (1 << 21); /* 2^21 words */
double t_delay = 0; /* Current delay (seconds) */
const double delay_step = 1e-4; /* Delay step */
const double max_delay = 100*delay_step; /* Maximum delay */
/* Start MPI */
#if defined(_OPENMP)
int mpi_omp_support_level;
MPI_Init_thread (&argc, &argv, MPI_THREAD_MULTIPLE, &mpi_omp_support_level);
#else
MPI_Init (&argc, &argv);
#endif
MPI_Comm_rank (MPI_COMM_WORLD, &rank); /* Get process id */
MPI_Comm_size (MPI_COMM_WORLD, &np); /* Get number of processes */
MPI_Get_processor_name (hostname, &namelen); /* Get hostname of node */
fprintf (stderr, "[%s:rank %d of %d] Hello, world!\n", hostname, rank, np);
/* This benchmark must be run between only two processes */
assert (np == 2);
if (rank == 0) {
fprintf (stderr, "\n");
fprintf (stderr, "Experimental parameters:\n");
fprintf (stderr, " Delay step: %g seconds\n", delay_step);
fprintf (stderr, " Maximum delay: %g seconds\n", max_delay);
#if defined (_OPENMP)
fprintf (stderr, " OpenMP enabled; support level: ");
switch (mpi_omp_support_level) {
case MPI_THREAD_SINGLE: fprintf (stderr, "MPI_THREAD_SINGLE"); break;
case MPI_THREAD_FUNNELED: fprintf (stderr, "MPI_THREAD_FUNNELED"); break;
case MPI_THREAD_SERIALIZED: fprintf (stderr, "MPI_THREAD_SERIALIZED"); break;
case MPI_THREAD_MULTIPLE: fprintf (stderr, "MPI_THREAD_MULTIPLE"); break;
default: fprintf (stderr, "(unknown)");
}
fprintf (stderr, "\n");
#else
fprintf (stderr, " OpenMP disabled.\n");
#endif
fprintf (stderr, " Output file: %s\n", outfile);
fprintf (stderr, "\n");
}
/* Open a file for writing results */
fprintf (stderr, "[%s:rank %d of %d] Opening output file, %s...\n",
hostname, rank, np, outfile);
if (rank == 0) {
fp = fopen (outfile, "w");
assert (fp != NULL);
}
/* Create a message buffer */
fprintf (stderr, "[%s:rank %d of %d] Creating message buffer of size %d ints (%d bytes)...\n",
hostname, rank, np, msglen, msglen * sizeof (int));
msgbuf = (int *)malloc (msglen * sizeof (int));
assert (msgbuf);
/* Runs the asynchronous test-delay protocol */
while (t_delay < max_delay) {
double t_elapsed = -1;
init_message (rank, msgbuf, msglen); /* reset the message */
test_message (rank, msgbuf, msglen); /* redundant check */
MPI_Barrier (MPI_COMM_WORLD);
#pragma omp parallel
#pragma omp single nowait
t_elapsed = async_comm_test (t_delay, rank, msgbuf, msglen);
/* Check that the msgbufs match initial values on rank 0 */
test_message (0, msgbuf, msglen);
/* Write out the timing result */
if (rank == 0) {
printf ("%g\t%g\n", t_delay, t_elapsed); fflush (stdout);
fprintf (fp, "%g\t%g\n", t_delay, t_elapsed); fflush (fp);
}
t_delay += delay_step;
} while (t_delay <= max_delay);
fprintf (stderr, "[%s:rank %d of %d] Done! Cleaning up...\n", hostname, rank, np);
free (msgbuf);
if (rank == 0) {
fclose (fp); /* Close output file */
}
fprintf (stderr, "[%s:rank %d of %d] Shutting down MPI...\n", hostname, rank, np);
MPI_Finalize ();
fprintf (stderr, "[%s:rank %d of %d] Bye bye.\n", hostname, rank, np);
return 0;
}
