/* Destroy test session */
static void destroy_sess(struct test_sess *sess, unsigned wait_msec)
{
if (sess->caller.ice) {
pj_ice_strans_destroy(sess->caller.ice);
sess->caller.ice = NULL;
}
if (sess->callee.ice) {
pj_ice_strans_destroy(sess->callee.ice);
sess->callee.ice = NULL;
}
poll_events(sess->stun_cfg, wait_msec, PJ_FALSE);
if (sess->resolver) {
pj_dns_resolver_destroy(sess->resolver, PJ_FALSE);
sess->resolver = NULL;
}
if (sess->server) {
destroy_test_server(sess->server);
sess->server = NULL;
}
if (sess->pool) {
pj_pool_t *pool = sess->pool;
sess->pool = NULL;
pj_pool_release(pool);
}
}
int button_pressed()
{
if ( !button_pressed_ )
poll_events();
int result = button_pressed_;
button_pressed_ = 0;
return result;
}
void GDNetHost::thread_loop() {
while (_running) {
acquireMutex();
send_messages();
poll_events();
releaseMutex();
}
}
int main(void)
{
static const double tstep = 1.0/TICKRATE;
double tlast, tnow, tsec, dt, ddt=0.0;
int ticks=0, tps=0, frames=0;
#if 0
{
int i;
for (i=0; i<100; ++i) {
gx_init("demo", XRES, YRES);
gx_delay(0.01);
gx_exit();
}
}
#endif
gx_init("demo", XRES, YRES);
tlast = gx_time();
while (1) {
tnow = gx_time();
dt = tnow - tlast;
tlast = tnow;
if (dt > 0.25) dt = 0.25;
if (poll_events())
break;
ddt += dt;
while (ddt >= tstep) {
ddt -= tstep;
++ticks;
++tps;
}
draw(tnow, ddt/dt);
gx_paint(buf, XRES, YRES);
++frames;
print_time(ticks, &tps, tnow, dt);
if (limitfps && maxfps) {
double tmax = 1.0 / maxfps;
while (gx_time() - tnow < tmax-0.002) gx_delay(0.001);
while (gx_time() - tnow < tmax);
}
}
tsec = gx_time();
printf("--- timing report ---\n"
"ticks : %d\n"
"frames : %d\n"
"time : %.2f\n"
"tickrate : %.2f\n"
"fps : %.2f\n",
ticks, frames, tsec, ticks/tsec, frames/tsec);
return 0;
}
int main(int argc, char *argv[]) {
pid_t ruid, euid, suid;
gid_t rgid, egid, sgid;
openlog("echoserver", LOG_NDELAY | LOG_PID, LOG_DAEMON);
if (getresuid(&ruid, &euid, &suid) == -1) {
syslog(LOG_ERR, "Failed to run getresuid\n");
}
syslog(LOG_INFO, "Running as real UID=%d, EUID=%d, SUID=%d\n",ruid, euid, suid);
syslog(LOG_INFO, "Running as real GID=%d, EGID=%d, SGID=%d\n",rgid, egid, sgid);
poll_events();
}
static inline void do_server (void)
{
while (!done) {
poll_ctl_events();
if (endpoint != NULL)
poll_events();
}
sleep (1);
return;
}
void Engine::go() {
states.push(std::make_shared<TitleScreen>());
music.loadJson("music.json");
music.setNextSong("intro");
music.setNextSong("partA");
clock.restart();
while (window.isOpen() && !states.empty()) {
++current_tick;
poll_events();
update();
draw();
}
}
int JoyDevice::get_event (JoyEvent *event)
{
poll_events ();
if (queue.empty ())
return 0;
event->parameter = queue.front ().parameter;
event->state = queue.front ().state;
queue.pop ();
return 1;
}
int main()
{
std::cout << "Enet Server" << std::endl;
setup_network();
setup_as_server();
while(true)
{
poll_events();
}
destroy_network();
return 0;
}
/* Destroy test session */
static void destroy_sess(struct test_sess *sess, unsigned wait_msec)
{
unsigned i;
if (sess->caller.ice) {
pj_ice_strans_destroy(sess->caller.ice);
sess->caller.ice = NULL;
}
if (sess->callee.ice) {
pj_ice_strans_destroy(sess->callee.ice);
sess->callee.ice = NULL;
}
sess->param->worker_quit = PJ_TRUE;
for (i=0; i<sess->param->worker_cnt; ++i) {
if (sess->worker_threads[i])
pj_thread_join(sess->worker_threads[i]);
}
poll_events(sess->stun_cfg, wait_msec, PJ_FALSE);
if (sess->resolver) {
pj_dns_resolver_destroy(sess->resolver, PJ_FALSE);
sess->resolver = NULL;
}
if (sess->server) {
destroy_test_server(sess->server);
sess->server = NULL;
}
if (sess->pool) {
pj_pool_t *pool = sess->pool;
sess->pool = NULL;
pj_pool_release(pool);
}
}
static inline void do_client (void)
{
int ret;
ret = cci_connect (ctl_ep, server_uri, &ctl_opts, sizeof (ctl_opts), attr,
NULL, 0, NULL);
check_return (ctl_ep, "cci_connect", ret, 1);
while (!done) {
poll_ctl_events ();
if (endpoint != NULL)
poll_events();
}
if (connection == NULL) {
fprintf (stderr, "Connection Rejected -- Test Successful\n");
} else {
fprintf (stderr, "Connection Accepted -- Test fails\n");
}
sleep (1);
return;
}
static int destroy_test(pj_stun_config *stun_cfg,
pj_bool_t with_dns_srv,
pj_bool_t in_callback)
{
struct test_session_cfg test_cfg =
{
{ /* Client cfg */
/* DNS SRV */ /* Destroy on state */
PJ_TRUE, 0xFFFF
},
{ /* Server cfg */
0xFFFFFFFF, /* flags */
PJ_TRUE, /* respond to allocate */
PJ_TRUE /* respond to refresh */
}
};
struct test_session *sess;
int target_state;
int rc;
PJ_LOG(3,("", " destroy test %s %s",
(in_callback? "in callback" : ""),
(with_dns_srv? "with DNS srv" : "")
));
test_cfg.client.enable_dns_srv = with_dns_srv;
for (target_state=PJ_TURN_STATE_RESOLVING; target_state<=PJ_TURN_STATE_READY; ++target_state) {
enum { TIMEOUT = 60 };
pjlib_state pjlib_state;
pj_turn_session_info info;
pj_time_val tstart;
capture_pjlib_state(stun_cfg, &pjlib_state);
PJ_LOG(3,("", " %s", pj_turn_state_name((pj_turn_state_t)target_state)));
if (in_callback)
test_cfg.client.destroy_on_state = target_state;
rc = create_test_session(stun_cfg, &test_cfg, &sess);
if (rc != 0)
return rc;
if (in_callback) {
pj_gettimeofday(&tstart);
rc = 0;
while (sess->turn_sock) {
pj_time_val now;
poll_events(stun_cfg, 100, PJ_FALSE);
pj_gettimeofday(&now);
if (now.sec - tstart.sec > TIMEOUT) {
rc = -7;
break;
}
}
} else {
pj_gettimeofday(&tstart);
rc = 0;
while (sess->turn_sock) {
pj_time_val now;
poll_events(stun_cfg, 1, PJ_FALSE);
pj_turn_sock_get_info(sess->turn_sock, &info);
if (info.state >= target_state) {
pj_turn_sock_destroy(sess->turn_sock);
break;
}
pj_gettimeofday(&now);
if (now.sec - tstart.sec > TIMEOUT) {
rc = -8;
break;
}
}
}
if (rc != 0) {
PJ_LOG(3,("", " error: timeout"));
return rc;
}
poll_events(stun_cfg, 1000, PJ_FALSE);
destroy_session(sess);
rc = check_pjlib_state(stun_cfg, &pjlib_state);
if (rc != 0) {
PJ_LOG(3,("", " error: memory/timer-heap leak detected"));
return rc;
}
}
return 0;
}
void client(char *server_uri)
{
int num_connect = 0, ret, i = 0, c;
uint32_t caps = 0;
cci_os_handle_t *fd = NULL;
cci_endpoint_t *endpoint = NULL;
cci_connection_t *connection = NULL;
uint32_t timeout = 10 * 1000000;
int context[3] = {0, 1, 2};
struct timeval wait;
ret = cci_init(CCI_ABI_VERSION, 0, &caps);
if (ret) {
fprintf(stderr, "cci_init() failed with %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
/* create an endpoint */
ret = cci_create_endpoint(NULL, 0, &endpoint, fd);
if (ret) {
fprintf(stderr, "cci_create_endpoint() failed with %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
/* set conn tx timeout */
cci_set_opt(endpoint, CCI_OPT_ENDPT_SEND_TIMEOUT,
&timeout);
if (ret) {
fprintf(stderr, "cci_set_opt() failed with %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
ret = cci_connect(endpoint, server_uri, "Happy", 5,
CCI_CONN_ATTR_UU, (int *) &context[0], 0, NULL);
if (ret) {
fprintf(stderr, "cci_connect(0) failed with %s\n",
cci_strerror(endpoint, ret));
}
ret = cci_connect(endpoint, server_uri, "New", 3,
CCI_CONN_ATTR_UU, (int *) &context[1], 0, NULL);
if (ret) {
fprintf(stderr, "cci_connect(1) failed with %s\n",
cci_strerror(endpoint, ret));
}
wait.tv_sec = 2;
wait.tv_usec = 0;
ret = cci_connect(endpoint, server_uri, "Year", 4,
CCI_CONN_ATTR_UU, (int *) &context[2], 0, &wait);
if (ret) {
fprintf(stderr, "cci_connect(2) failed with %s\n",
cci_strerror(endpoint, ret));
}
/* poll for connect completion */
//while (num_connect < 3)
while (num_connect < 1) /* connect timeouts are not registering */
poll_events(endpoint, &connection, &num_connect);
printf("test passed\n");
fflush(stdout);
/* server has to close first to avoid hang */
sleep(5);
client_cleanup:
ret = cci_destroy_endpoint(endpoint);
if (ret) {
fprintf(stderr, "cci_destroy_endpoint() failed with %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
ret = cci_finalize();
if (ret) {
fprintf(stderr, "cci_finalize() failed with %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
}
static void do_server(void)
{
int ret;
while (!ready) {
cci_event_t *event;
if (blocking) {
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
ret = select(nfds, &rfds, NULL, NULL, NULL);
if (!ret)
return;
}
ret = cci_get_event(endpoint, &event);
if (ret == CCI_SUCCESS) {
switch (event->type) {
case CCI_EVENT_CONNECT_REQUEST:
if (accept) {
opts =
*((options_t *) event->request.
data_ptr);
ret = cci_accept(event, NULL);
check_return(endpoint, "cci_accept", ret, 1);
} else {
ret = cci_reject(event);
check_return(endpoint, "cci_reject", ret, 1);
}
break;
case CCI_EVENT_ACCEPT:
{
int len;
ready = 1;
connection = event->accept.connection;
if (opts.method == MSGS)
len = connection->max_send_size;
else
len = opts.max_rma_size;
ret =
posix_memalign((void **)&buffer,
4096, len);
check_return(endpoint, "memalign buffer", ret, 1);
memset(buffer, 'a', len);
if (opts.method != MSGS) {
ret =
cci_rma_register(endpoint,
buffer,
opts.
max_rma_size,
opts.method == RMA_WRITE ? CCI_FLAG_WRITE : CCI_FLAG_READ,
&server_rma_handle);
check_return(endpoint, "cci_rma_register",
ret, 1);
memcpy(&opts.rma_handle,
server_rma_handle,
sizeof(*server_rma_handle));
}
ret =
cci_send(connection, &opts,
sizeof(opts), NULL, 0);
check_return(endpoint, "cci_send", ret, 1);
break;
}
default:
fprintf(stderr,
"%s: ignoring unexpected event %d\n",
__func__, event->type);
break;
}
ret = cci_return_event(event);
if (ret)
fprintf(stderr, "cci_return_event() failed with %s\n",
cci_strerror(endpoint, ret));
}
}
while (!done)
poll_events();
if (opts.method != MSGS) {
ret = cci_rma_deregister(endpoint, server_rma_handle);
check_return(endpoint, "cci_rma_deregister", ret, 1);
}
printf("server done\n");
sleep(1);
return;
}
static int state_progression_test(pj_stun_config *stun_cfg)
{
struct test_session_cfg test_cfg =
{
{ /* Client cfg */
/* DNS SRV */ /* Destroy on state */
PJ_TRUE, 0xFFFF
},
{ /* Server cfg */
0xFFFFFFFF, /* flags */
PJ_TRUE, /* respond to allocate */
PJ_TRUE /* respond to refresh */
}
};
struct test_session *sess;
unsigned i;
int rc;
PJ_LOG(3,("", " state progression tests"));
for (i=0; i<=1; ++i) {
enum { TIMEOUT = 60 };
pjlib_state pjlib_state;
pj_turn_session_info info;
struct test_result result;
pj_time_val tstart;
PJ_LOG(3,("", " %s DNS SRV resolution",
(i==0? "without" : "with")));
capture_pjlib_state(stun_cfg, &pjlib_state);
test_cfg.client.enable_dns_srv = i;
rc = create_test_session(stun_cfg, &test_cfg, &sess);
if (rc != 0)
return rc;
pj_bzero(&info, sizeof(info));
/* Wait until state is READY */
pj_gettimeofday(&tstart);
while (sess->turn_sock) {
pj_time_val now;
poll_events(stun_cfg, 10, PJ_FALSE);
rc = pj_turn_sock_get_info(sess->turn_sock, &info);
if (rc!=PJ_SUCCESS)
break;
if (info.state >= PJ_TURN_STATE_READY)
break;
pj_gettimeofday(&now);
if (now.sec - tstart.sec > TIMEOUT) {
PJ_LOG(3,("", " timed-out"));
break;
}
}
if (info.state != PJ_TURN_STATE_READY) {
PJ_LOG(3,("", " error: state is not READY"));
destroy_session(sess);
return -130;
}
/* Deallocate */
pj_turn_sock_destroy(sess->turn_sock);
/* Wait for couple of seconds.
* We can't poll the session info since the session may have
* been destroyed
*/
poll_events(stun_cfg, 2000, PJ_FALSE);
sess->turn_sock = NULL;
pj_memcpy(&result, &sess->result, sizeof(result));
destroy_session(sess);
/* Check the result */
if ((result.state_called & (1<<PJ_TURN_STATE_RESOLVING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_RESOLVING is not called"));
return -140;
}
if ((result.state_called & (1<<PJ_TURN_STATE_RESOLVED)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_RESOLVED is not called"));
return -150;
}
if ((result.state_called & (1<<PJ_TURN_STATE_ALLOCATING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_ALLOCATING is not called"));
return -155;
}
if ((result.state_called & (1<<PJ_TURN_STATE_READY)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_READY is not called"));
return -160;
}
if ((result.state_called & (1<<PJ_TURN_STATE_DEALLOCATING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_DEALLOCATING is not called"));
return -170;
}
if ((result.state_called & (1<<PJ_TURN_STATE_DEALLOCATED)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_DEALLOCATED is not called"));
return -180;
}
if ((result.state_called & (1<<PJ_TURN_STATE_DESTROYING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_DESTROYING is not called"));
return -190;
}
poll_events(stun_cfg, 500, PJ_FALSE);
rc = check_pjlib_state(stun_cfg, &pjlib_state);
if (rc != 0) {
PJ_LOG(3,("", " error: memory/timer-heap leak detected"));
return rc;
}
}
return 0;
}
static int perform_test(const char *title,
pj_stun_config *stun_cfg,
unsigned server_flag,
struct test_cfg *caller_cfg,
struct test_cfg *callee_cfg)
{
pjlib_state pjlib_state;
struct test_sess *sess;
int rc;
PJ_LOG(3,("", INDENT "%s", title));
capture_pjlib_state(stun_cfg, &pjlib_state);
rc = create_sess(stun_cfg, server_flag, caller_cfg, callee_cfg, &sess);
if (rc != 0)
return rc;
#define ALL_READY (sess->caller.result.init_status!=PJ_EPENDING && \
sess->callee.result.init_status!=PJ_EPENDING)
/* Wait until both ICE transports are initialized */
WAIT_UNTIL(30, ALL_READY, rc);
if (!ALL_READY) {
PJ_LOG(3,("", INDENT "err: init timed-out"));
destroy_sess(sess, 500);
return -100;
}
if (sess->caller.result.init_status != sess->caller.cfg.expected.init_status) {
app_perror(INDENT "err: caller init", sess->caller.result.init_status);
destroy_sess(sess, 500);
return -102;
}
if (sess->callee.result.init_status != sess->callee.cfg.expected.init_status) {
app_perror(INDENT "err: callee init", sess->callee.result.init_status);
destroy_sess(sess, 500);
return -104;
}
/* Failure condition */
if (sess->caller.result.init_status != PJ_SUCCESS ||
sess->callee.result.init_status != PJ_SUCCESS)
{
rc = 0;
goto on_return;
}
/* Init ICE on caller */
rc = pj_ice_strans_init_ice(sess->caller.ice, sess->caller.cfg.role,
&sess->caller.ufrag, &sess->caller.pass);
if (rc != PJ_SUCCESS) {
app_perror(INDENT "err: caller pj_ice_strans_init_ice()", rc);
destroy_sess(sess, 500);
return -100;
}
/* Init ICE on callee */
rc = pj_ice_strans_init_ice(sess->callee.ice, sess->callee.cfg.role,
&sess->callee.ufrag, &sess->callee.pass);
if (rc != PJ_SUCCESS) {
app_perror(INDENT "err: callee pj_ice_strans_init_ice()", rc);
destroy_sess(sess, 500);
return -110;
}
/* Start ICE on callee */
rc = start_ice(&sess->callee, &sess->caller);
if (rc != PJ_SUCCESS) {
destroy_sess(sess, 500);
return -120;
}
/* Wait for callee's answer_delay */
poll_events(stun_cfg, sess->callee.cfg.answer_delay, PJ_FALSE);
/* Start ICE on caller */
rc = start_ice(&sess->caller, &sess->callee);
if (rc != PJ_SUCCESS) {
destroy_sess(sess, 500);
return -130;
}
/* Wait until negotiation is complete on both endpoints */
#define ALL_DONE (sess->caller.result.nego_status!=PJ_EPENDING && \
sess->callee.result.nego_status!=PJ_EPENDING)
WAIT_UNTIL(30, ALL_DONE, rc);
if (!ALL_DONE) {
PJ_LOG(3,("", INDENT "err: negotiation timed-out"));
destroy_sess(sess, 500);
return -140;
}
if (sess->caller.result.nego_status != sess->caller.cfg.expected.nego_status) {
app_perror(INDENT "err: caller negotiation failed", sess->caller.result.nego_status);
destroy_sess(sess, 500);
return -150;
}
if (sess->callee.result.nego_status != sess->callee.cfg.expected.nego_status) {
app_perror(INDENT "err: callee negotiation failed", sess->callee.result.nego_status);
destroy_sess(sess, 500);
return -160;
}
/* Verify that both agents have agreed on the same pair */
rc = check_pair(&sess->caller, &sess->callee, -170);
if (rc != 0) {
destroy_sess(sess, 500);
return rc;
}
rc = check_pair(&sess->callee, &sess->caller, -180);
if (rc != 0) {
destroy_sess(sess, 500);
return rc;
}
/* Looks like everything is okay */
/* Destroy ICE stream transports first to let it de-allocate
* TURN relay (otherwise there'll be timer/memory leak, unless
* we wait for long time in the last poll_events() below).
*/
if (sess->caller.ice) {
pj_ice_strans_destroy(sess->caller.ice);
sess->caller.ice = NULL;
}
if (sess->callee.ice) {
pj_ice_strans_destroy(sess->callee.ice);
sess->callee.ice = NULL;
}
on_return:
/* Wait.. */
poll_events(stun_cfg, 500, PJ_FALSE);
/* Now destroy everything */
destroy_sess(sess, 500);
/* Flush events */
poll_events(stun_cfg, 100, PJ_FALSE);
rc = check_pjlib_state(stun_cfg, &pjlib_state);
if (rc != 0) {
return rc;
}
return 0;
}
static void do_client(void)
{
int ret;
uint32_t min = 0, max;
struct timeval start, end;
char *func;
char *header = "Done";
/* initiate connect */
ret =
cci_connect(endpoint, server_uri, &opts, sizeof(opts), attr, NULL,
0, NULL);
check_return(endpoint, "cci_connect", ret, 1);
/* poll for connect completion */
while (!connect_done)
poll_events();
if (!connection) {
fprintf(stderr, "no connection\n");
return;
}
while (!ready)
poll_events();
if (opts.method == MSGS) {
func = "cci_send";
max = connection->max_send_size;
} else {
func = "cci_rma";
max = opts.max_rma_size;
}
ret = posix_memalign((void **)&buffer, 4096, max);
check_return(endpoint, "memalign buffer", ret, 1);
memset(buffer, 'b', max);
if (opts.method != MSGS) {
int flags = 0;
/* for the client, we want the opposite of the opts.method.
* when testing RMA WRITE, we only need READ access.
* when testing RMA READ, we need WRITE access.
*/
if (opts.method == RMA_WRITE)
flags = CCI_FLAG_READ;
else if (opts.method == RMA_READ)
flags = CCI_FLAG_WRITE;
ret = cci_rma_register(endpoint, buffer, max, flags,
&local_rma_handle);
check_return(endpoint, "cci_rma_register", ret, 1);
fprintf(stderr, "local_rma_handle is %p\n",
(void*)local_rma_handle);
min = 1;
if (opts.method == RMA_WRITE)
opts.flags |= CCI_FLAG_WRITE;
else
opts.flags |= CCI_FLAG_READ;
}
if (remote_completion) {
rmt_comp_msg = header;
rmt_comp_len = 4;
}
if (opts.method == MSGS)
printf("Bytes\t\tLatency (one-way)\tThroughput\n");
else
printf("Bytes\t\tLatency (round-trip)\tThroughput\n");
/* begin communication with server */
for (current_size = min; current_size <= max;) {
double lat = 0.0;
double bw = 0.0;
if (opts.method == MSGS)
ret =
cci_send(connection, buffer, current_size, NULL,
opts.flags);
else
ret = cci_rma(connection, rmt_comp_msg, rmt_comp_len,
local_rma_handle, 0,
&opts.rma_handle, 0,
current_size, (void *)1, opts.flags);
check_return(endpoint, func, ret, 1);
while (count < warmup)
poll_events();
gettimeofday(&start, NULL);
while (count < warmup + iters)
poll_events();
gettimeofday(&end, NULL);
if (opts.method == MSGS)
lat = usecs(start, end) / (double)iters / 2.0;
else
lat = usecs(start, end) / (double)iters;
bw = (double)current_size / lat;
printf("%8d\t%8.2f us\t\t%8.2f MB/s\n", current_size, lat,
bw);
count = 0;
if (current_size == 0)
current_size++;
else
current_size *= 2;
if (current_size >= 64 * 1024) {
if (iters >= 32)
iters /= 2;
if (warmup >= 4)
warmup /= 2;
}
}
ret = cci_send(connection, "bye", 3, (void *)0xdeadbeef, opts.flags);
check_return(endpoint, "cci_send", ret, 0);
while (!done)
poll_events();
if (opts.method != MSGS) {
ret = cci_rma_deregister(endpoint, local_rma_handle);
check_return(endpoint, "cci_rma_deregister", ret, 1);
}
printf("client done\n");
sleep(1);
return;
}
int main(int argc, char *argv[])
{
int done = 0, ret, i = 0, c;
uint32_t caps = 0;
char *server_uri = NULL;
cci_os_handle_t *fd = NULL;
cci_endpoint_t *endpoint = NULL;
cci_connection_t *connection = NULL;
uint32_t timeout = 30 * 1000000;
while ((c = getopt(argc, argv, "h:c:b")) != -1) {
switch (c) {
case 'h':
server_uri = strdup(optarg);
break;
case 'c':
if (strncasecmp ("ru", optarg, 2) == 0)
attr = CCI_CONN_ATTR_RU;
else if (strncasecmp ("ro", optarg, 2) == 0)
attr = CCI_CONN_ATTR_RO;
else if (strncasecmp ("uu", optarg, 2) == 0)
attr = CCI_CONN_ATTR_UU;
break;
case 'b':
flags |= CCI_FLAG_BLOCKING;
break;
default:
fprintf(stderr, "usage: %s -h <server_uri> [-c <type>]\n",
argv[0]);
fprintf(stderr, "\t-c\tConnection type (UU, RU, or RO) "
"set by client; RO by default\n");
exit(EXIT_FAILURE);
}
}
if (!server_uri) {
fprintf(stderr, "usage: %s -h <server_uri> [-c <type>]\n", argv[0]);
fprintf(stderr, "\t-c\tConnection type (UU, RU, or RO) "
"set by client; RO by default\n");
exit(EXIT_FAILURE);
}
ret = cci_init(CCI_ABI_VERSION, 0, &caps);
if (ret) {
fprintf(stderr, "cci_init() failed with %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
/* create an endpoint */
ret = cci_create_endpoint(NULL, 0, &endpoint, fd);
if (ret) {
fprintf(stderr, "cci_create_endpoint() failed with %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
/* set conn tx timeout */
cci_set_opt(endpoint, CCI_OPT_ENDPT_SEND_TIMEOUT,
&timeout);
if (ret) {
fprintf(stderr, "cci_set_opt() failed with %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
/* initiate connect */
ret =
cci_connect(endpoint, server_uri, "Hello World!", 12,
attr, CONNECT_CONTEXT, 0, NULL);
if (ret) {
fprintf(stderr, "cci_connect() failed with %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
/* poll for connect completion */
while (!done)
poll_events(endpoint, &connection, &done);
if (!connection)
exit(0);
done = 0;
/* begin communication with server */
for (i = 0; i < iters; i++) {
char data[128];
memset(data, 0, sizeof(data));
sprintf(data, "%4d", i);
sprintf(data + 4, "Hello World!");
ret = cci_send(connection, data, (uint32_t) strlen(data) + 4,
(void *)(uintptr_t) i, flags);
if (ret)
fprintf(stderr, "send %d failed with %s\n", i,
cci_strerror(endpoint, ret));
if (flags & CCI_FLAG_BLOCKING)
fprintf(stderr, "send %d completed with %d\n", i, ret);
}
if (flags == CCI_FLAG_BLOCKING)
send_done = iters;
while (!done)
poll_events(endpoint, &connection, &done);
ret = cci_send(connection, "bye", 3, (void *)(uintptr_t) iters, flags);
if (ret)
fprintf(stderr, "sending \"bye\" failed with %s\n",
cci_strerror(endpoint, ret));
if (flags & CCI_FLAG_BLOCKING)
done = 2;
while (done != 2)
poll_events(endpoint, &connection, &done);
/* clean up */
ret = cci_destroy_endpoint(endpoint);
if (ret) {
fprintf(stderr, "cci_destroy_endpoint() failed with %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
ret = cci_finalize();
if (ret) {
fprintf(stderr, "cci_finalize() failed with %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
return 0;
}
static int perform_test2(const char *title,
pj_stun_config *stun_cfg,
unsigned server_flag,
struct test_cfg *caller_cfg,
struct test_cfg *callee_cfg,
struct sess_param *test_param)
{
pjlib_state pjlib_state;
struct test_sess *sess;
unsigned i;
int rc;
PJ_LOG(3,(THIS_FILE, INDENT "%s", title));
capture_pjlib_state(stun_cfg, &pjlib_state);
rc = create_sess(stun_cfg, server_flag, caller_cfg, callee_cfg, test_param, &sess);
if (rc != 0)
return rc;
#define ALL_READY (sess->caller.result.init_status!=PJ_EPENDING && \
sess->callee.result.init_status!=PJ_EPENDING)
/* Wait until both ICE transports are initialized */
WAIT_UNTIL(30000, ALL_READY, rc);
if (!ALL_READY) {
PJ_LOG(3,(THIS_FILE, INDENT "err: init timed-out"));
destroy_sess(sess, 500);
return -100;
}
if (sess->caller.result.init_status != sess->caller.cfg.expected.init_status) {
app_perror(INDENT "err: caller init", sess->caller.result.init_status);
destroy_sess(sess, 500);
return -102;
}
if (sess->callee.result.init_status != sess->callee.cfg.expected.init_status) {
app_perror(INDENT "err: callee init", sess->callee.result.init_status);
destroy_sess(sess, 500);
return -104;
}
/* Failure condition */
if (sess->caller.result.init_status != PJ_SUCCESS ||
sess->callee.result.init_status != PJ_SUCCESS)
{
rc = 0;
goto on_return;
}
/* Init ICE on caller */
rc = pj_ice_strans_init_ice(sess->caller.ice, sess->caller.cfg.role,
&sess->caller.ufrag, &sess->caller.pass);
if (rc != PJ_SUCCESS) {
app_perror(INDENT "err: caller pj_ice_strans_init_ice()", rc);
destroy_sess(sess, 500);
return -100;
}
/* Init ICE on callee */
rc = pj_ice_strans_init_ice(sess->callee.ice, sess->callee.cfg.role,
&sess->callee.ufrag, &sess->callee.pass);
if (rc != PJ_SUCCESS) {
app_perror(INDENT "err: callee pj_ice_strans_init_ice()", rc);
destroy_sess(sess, 500);
return -110;
}
/* Start ICE on callee */
rc = start_ice(&sess->callee, &sess->caller);
if (rc != PJ_SUCCESS) {
destroy_sess(sess, 500);
return -120;
}
/* Wait for callee's answer_delay */
poll_events(stun_cfg, sess->callee.cfg.answer_delay, PJ_FALSE);
/* Start ICE on caller */
rc = start_ice(&sess->caller, &sess->callee);
if (rc != PJ_SUCCESS) {
destroy_sess(sess, 500);
return -130;
}
for (i=0; i<sess->param->worker_cnt; ++i) {
pj_status_t status;
status = pj_thread_create(sess->pool, "worker_thread",
worker_thread_proc, sess, 0, 0,
&sess->worker_threads[i]);
if (status != PJ_SUCCESS) {
PJ_LOG(3,(THIS_FILE, INDENT "err: create thread"));
destroy_sess(sess, 500);
return -135;
}
}
if (sess->param->destroy_after_create)
goto on_destroy;
if (sess->param->destroy_after_one_done) {
while (sess->caller.result.init_status==PJ_EPENDING &&
sess->callee.result.init_status==PJ_EPENDING)
{
if (sess->param->worker_cnt)
pj_thread_sleep(0);
else
poll_events(stun_cfg, 0, PJ_FALSE);
}
goto on_destroy;
}
WAIT_UNTIL(30000, ALL_DONE, rc);
if (!ALL_DONE) {
PJ_LOG(3,(THIS_FILE, INDENT "err: negotiation timed-out"));
destroy_sess(sess, 500);
return -140;
}
if (sess->caller.result.nego_status != sess->caller.cfg.expected.nego_status) {
app_perror(INDENT "err: caller negotiation failed", sess->caller.result.nego_status);
destroy_sess(sess, 500);
return -150;
}
if (sess->callee.result.nego_status != sess->callee.cfg.expected.nego_status) {
app_perror(INDENT "err: callee negotiation failed", sess->callee.result.nego_status);
destroy_sess(sess, 500);
return -160;
}
/* Verify that both agents have agreed on the same pair */
rc = check_pair(&sess->caller, &sess->callee, -170);
if (rc != 0) {
destroy_sess(sess, 500);
return rc;
}
rc = check_pair(&sess->callee, &sess->caller, -180);
if (rc != 0) {
destroy_sess(sess, 500);
return rc;
}
/* Looks like everything is okay */
on_destroy:
/* Destroy ICE stream transports first to let it de-allocate
* TURN relay (otherwise there'll be timer/memory leak, unless
* we wait for long time in the last poll_events() below).
*/
if (sess->caller.ice) {
pj_ice_strans_destroy(sess->caller.ice);
sess->caller.ice = NULL;
}
if (sess->callee.ice) {
pj_ice_strans_destroy(sess->callee.ice);
sess->callee.ice = NULL;
}
on_return:
/* Wait.. */
poll_events(stun_cfg, 200, PJ_FALSE);
/* Now destroy everything */
destroy_sess(sess, 500);
/* Flush events */
poll_events(stun_cfg, 100, PJ_FALSE);
rc = check_pjlib_state(stun_cfg, &pjlib_state);
if (rc != 0) {
return rc;
}
return rc;
}
int main(int argc, char *argv[])
{
int done = 0, ret, i = 0, c;
uint32_t caps = 0;
char *server_uri = NULL; /* ip://1.2.3.4 */
char *uri = NULL;
cci_os_handle_t fd;
cci_endpoint_t *endpoint = NULL;
cci_connection_t *connection = NULL;
uint32_t timeout_us = 30 * 1000000; /* microseconds */
proc_name = argv[0];
while ((c = getopt(argc, argv, "h:")) != -1) {
switch (c) {
case 'h':
server_uri = strdup(optarg);
break;
default:
usage();
}
}
/* init */
ret = cci_init(CCI_ABI_VERSION, 0, &caps);
if (ret) {
fprintf(stderr, "cci_init() returned %s\n", cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
/* create an endpoint */
ret = cci_create_endpoint(NULL, 0, &endpoint, &fd);
if (ret) {
fprintf(stderr, "cci_create_endpoint() returned %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
ret = cci_get_opt(endpoint,
CCI_OPT_ENDPT_URI, &uri);
if (ret) {
fprintf(stderr, "cci_get_opt() failed with %s\n", cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
printf("Opened %s\n", uri);
/* set endpoint tx timeout */
cci_set_opt(endpoint, CCI_OPT_ENDPT_SEND_TIMEOUT,
&timeout_us);
if (ret) {
fprintf(stderr, "cci_set_opt() returned %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
/* initiate connect */
ret = cci_connect(endpoint, server_uri, "Hello World!", 12,
CCI_CONN_ATTR_UU, NULL, 0, NULL);
if (ret) {
fprintf(stderr, "cci_connect() returned %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
/* poll for connect completion */
while (!done)
poll_events(endpoint, &connection, &done);
if (!connection) {
fprintf(stderr, "no connection\n");
exit(EXIT_FAILURE);
}
/* begin communication with server */
char *data;
int max = connection->max_send_size;
data = (char*)malloc(max);
memset(data, 1, sizeof(data));
int len = 128;
int repeat = 1000;
while (len <= max) {
s = cci_get_time();
for (i = 0; i < repeat; i++) {
/* ret = cci_send(connection, data, (uint32_t) strlen(data), */
/* (void *)(uintptr_t) i, 0); */
ret = cci_send(connection, data, len,
(void *)(uintptr_t) i, 0);
if (ret > 0) {
fprintf(stderr, "send %d returned %s\n", i,
cci_strerror(endpoint, ret));
exit(1);
}
done = 0;
while (!done)
poll_events(endpoint, &connection, &done);
}
e = cci_get_time();
fprintf(stderr, "%d %f %f\n", len, (e - s) / repeat, (len / (e - s)) * repeat);
len = len << 1;
sleep(1);
}
/* clean up */
ret = cci_disconnect(connection);
if (ret) {
fprintf(stderr, "cci_disconnect() returned %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
ret = cci_destroy_endpoint(endpoint);
if (ret) {
fprintf(stderr, "cci_destroy_endpoint() returned %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
/* add cci_finalize() here */
return 0;
}
static void do_server(void)
{
int ret = 0;
hdr_t *h = NULL;
while (!ready) {
cci_event_t *event;
if (blocking) {
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
ret = select(nfds, &rfds, NULL, NULL, NULL);
if (!ret)
return;
}
ret = cci_get_event(endpoint, &event);
if (ret == CCI_SUCCESS) {
switch (event->type) {
case CCI_EVENT_CONNECT_REQUEST:
{
int which = 0;
h = (void*)event->request.data_ptr;
if (h->generic.type == MSG_CONN_REQ) {
opts = h->request.opts;
which = TEST;
} else {
which = CONTROL;
}
ret = cci_accept(event, (void*)((uintptr_t)which));
check_return(endpoint, "cci_accept", ret, 1);
break;
}
case CCI_EVENT_ACCEPT:
{
if ((uintptr_t)event->accept.context == (uintptr_t)CONTROL) {
control = event->accept.connection;
} else {
int len;
test = event->accept.connection;
len = opts.reg_len;
ret =
posix_memalign((void **)&buffer,
4096, len);
check_return(endpoint, "memalign buffer", ret, 1);
init_buffer(0);
print_buffer(buffer, opts.reg_len);
ret = cci_rma_register(endpoint,
buffer,
opts.reg_len,
opts.method == RMA_WRITE ? CCI_FLAG_WRITE : CCI_FLAG_READ,
&local_rma_handle);
check_return(endpoint, "cci_rma_register",
ret, 1);
}
if (test && control) {
hdr_t msg;
ready = 1;
msg.reply.type = MSG_CONN_REPLY;
msg.reply.handle = *local_rma_handle;
ret = cci_send(test, &msg,
sizeof(msg.reply), NULL, 0);
check_return(endpoint, "cci_send", ret, 1);
}
break;
}
default:
fprintf(stderr,
"%s: ignoring unexpected event %s\n",
__func__, cci_event_type_str(event->type));
break;
}
ret = cci_return_event(event);
if (ret)
fprintf(stderr, "cci_return_event() failed with %s\n",
cci_strerror(endpoint, ret));
}
}
while (!done)
poll_events();
ret = cci_rma_deregister(endpoint, local_rma_handle);
check_return(endpoint, "cci_rma_deregister", ret, 1);
printf("server done\n");
sleep(1);
return;
}
static void do_client(void)
{
int ret;
uint32_t min = 1;
/* initiate connect */
msg.request.type = MSG_CONTROL;
ret =
cci_connect(endpoint, server_uri, &msg, sizeof(msg.generic), attr,
(void*)(uintptr_t)CONTROL, 0, NULL);
check_return(endpoint, "cci_connect", ret, 1);
msg.request.type = MSG_CONN_REQ;
msg.request.opts = opts;
ret =
cci_connect(endpoint, server_uri, &msg, sizeof(msg.request), attr,
(void*)(uintptr_t)TEST, 0, NULL);
check_return(endpoint, "cci_connect", ret, 1);
/* poll for connect completion */
while (!connect_done)
poll_events();
if (!test) {
fprintf(stderr, "no connection\n");
return;
}
while (!ready)
poll_events();
ret = posix_memalign((void **)&buffer, 4096, opts.reg_len);
check_return(endpoint, "memalign buffer", ret, 1);
memset(buffer, 0xaa, opts.reg_len);
init_buffer(1);
print_buffer(buffer, (int) opts.reg_len);
/* for the client, we do not need remote access flags */
ret = cci_rma_register(endpoint, buffer, opts.reg_len, 0, &local_rma_handle);
check_return(endpoint, "cci_rma_register", ret, 1);
if (opts.method == RMA_WRITE)
opts.flags = CCI_FLAG_WRITE;
else
opts.flags = CCI_FLAG_READ;
/* begin communication with server */
for (current_size = min; current_size <= length;) {
void *ptr = (void*)((uintptr_t)buffer + local_offset);
msg.check.type = MSG_RMA_CHK;
msg.check.offset = remote_offset;
msg.check.len = current_size;
/* Compute the CRC only on a valid buffer */
if (current_size + local_offset <= opts.reg_len)
msg.check.crc = crc32(0, ptr, current_size);
else
msg.check.crc = 0;
msg_len = sizeof(msg.check);
print_buffer(ptr, current_size);
fprintf(stderr, "Testing length %9u ... ", current_size);
ret = cci_rma(test, &msg, msg_len,
local_rma_handle, local_offset,
&remote_rma_handle, remote_offset,
current_size, NULL, opts.flags);
check_return(endpoint, "cci_rma", ret, 1);
while (count < iters)
poll_events();
if (test)
fprintf(stderr, "success.\n");
else
goto out;
count = 0;
current_size *= 2;
if (current_size >= 64 * 1024) {
if (iters >= 32)
iters /= 2;
}
}
out:
ret = cci_send(control, "bye", 3, (void *)0xdeadbeef, 0);
check_return(endpoint, "cci_send", ret, 0);
while (!done)
poll_events();
ret = cci_rma_deregister(endpoint, local_rma_handle);
check_return(endpoint, "cci_rma_deregister", ret, 1);
printf("client done\n");
sleep(1);
return;
}
int main(int argc, char *argv[])
{
cci_os_handle_t *fd = NULL; //endpoint 생성시, process를 block하는데 사용
cci_endpoint_t *endpoint = NULL;
cci_connection_t *connection = NULL;
int ret, c, ft_start = 0 , done = 0, i = 0, connect = 0;
pthread_t send;
uint32_t caps = 0;//??
char *server_uri = NULL;
char id[16]="";
t_data thread_data;
while ((c = getopt(argc, argv, "h:c:b")) != -1) { //client 실행시 option check
switch (c) {
case 'h':
server_uri = strdup(optarg);//-h에 대한 인자를 가리키는 optarg 포인터가 생김 http://weed2758.tistory.com/entry/Linux-C-getopt-%ED%95%A8%EC%88%98
break;
case 'c':
if (strncasecmp ("ru", optarg, 2) == 0)
attr = CCI_CONN_ATTR_RU;
else if (strncasecmp ("ro", optarg, 2) == 0)
attr = CCI_CONN_ATTR_RO;
else if (strncasecmp ("uu", optarg, 2) == 0)
attr = CCI_CONN_ATTR_UU;
break;
case 'b':
flags |= CCI_FLAG_BLOCKING;
break;
default:
fprintf(stderr, "usage: %s -h <server_uri> [-c <type>]\n",
argv[0]);
fprintf(stderr, "\t-c\tConnection type (UU, RU, or RO) "
"set by client; RO by default\n");
exit(EXIT_FAILURE);
}
}
if (!server_uri) {
fprintf(stderr, "usage: %s -h <server_uri> [-c <type>]\n", argv[0]);
fprintf(stderr, "\t-c\tConnection type (UU, RU, or RO) "
"set by client; RO by default\n");
exit(EXIT_FAILURE);
}
ret = cci_init(CCI_ABI_VERSION, 0, &caps);
if (ret) {
fprintf(stderr, "cci_init() failed with %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
/* create an endpoint */
ret = cci_create_endpoint(NULL, 0, &endpoint, fd);
if (ret) {
fprintf(stderr, "cci_create_endpoint() failed with %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
if (ret) {
fprintf(stderr, "cci_set_opt() failed with %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
/* initiate connect */
ret = cci_connect(endpoint, server_uri, "Connect request", 15, attr, CONNECT_CONTEXT, 0, NULL);
if (ret) {
fprintf(stderr, "cci_connect() failed with %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
while (!done)
poll_events(endpoint, &connection, &done, id);
if (!connection)
exit(0);
done = 0;
thread_data.connection=connection;
thread_data.flag=flags;
thread_data.id=id;
pthread_create(&send,NULL,send_msg,&thread_data);
while(!done)
poll_events(endpoint, &connection, &done, id);
pthread_join(send,NULL);
/* clean up */
ret = cci_destroy_endpoint(endpoint);
if (ret) {
fprintf(stderr, "cci_destroy_endpoint() failed with %s\n",
cci_strerror(endpoint, ret));
exit(EXIT_FAILURE);
}
ret = cci_finalize();
if (ret) {
fprintf(stderr, "cci_finalize() failed with %s\n",
cci_strerror(NULL, ret));
exit(EXIT_FAILURE);
}
return 0;
}
void
run()
{
poll_events(client.kq, client_poll);
}
