int32_t
client_connect(bthid_server_p srv, int32_t fd)
{
bthid_session_p s;
hid_device_p d;
int32_t error;
socklen_t len;
assert(srv != NULL);
assert(fd >= 0);
s = session_by_fd(srv, fd);
assert(s != NULL);
d = get_hid_device(&s->bdaddr);
assert(d != NULL);
error = 0;
len = sizeof(error);
if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
syslog(LOG_ERR, "Could not get socket error for %s. %s (%d)",
bt_ntoa(&s->bdaddr, NULL), strerror(errno), errno);
session_close(s);
connect_in_progress = 0;
return (-1);
}
if (error != 0) {
syslog(LOG_ERR, "Could not connect to %s. %s (%d)",
bt_ntoa(&s->bdaddr, NULL), strerror(error), error);
session_close(s);
connect_in_progress = 0;
return (0);
}
switch (s->state) {
case W4CTRL: /* Control channel is open */
assert(s->ctrl == fd);
assert(s->intr == -1);
/* Open interrupt channel */
s->intr = client_socket(&s->bdaddr, d->interrupt_psm);
if (s->intr < 0) {
syslog(LOG_ERR, "Could not open interrupt channel " \
"to %s. %s (%d)", bt_ntoa(&s->bdaddr, NULL),
strerror(errno), errno);
session_close(s);
connect_in_progress = 0;
return (-1);
}
s->state = W4INTR;
FD_SET(s->intr, &srv->wfdset);
if (s->intr > srv->maxfd)
srv->maxfd = s->intr;
d->new_device = 0; /* reset new device flag */
write_hids_file();
break;
case W4INTR: /* Interrupt channel is open */
assert(s->ctrl != -1);
assert(s->intr == fd);
s->state = OPEN;
connect_in_progress = 0;
/* Register session's vkbd descriptor (if any) for read */
if (s->state == OPEN && d->keyboard) {
assert(s->vkbd != -1);
FD_SET(s->vkbd, &srv->rfdset);
if (s->vkbd > srv->maxfd)
srv->maxfd = s->vkbd;
}
break;
default:
assert(0);
break;
}
/* Move fd to from the write fd set into read fd set */
FD_CLR(fd, &srv->wfdset);
FD_SET(fd, &srv->rfdset);
return (0);
}
int
main(int argc, char **argv)
{
// Standard command line parsing.
HASH_T *options = parse_cmdline(argc, argv, arg_opts);
if(options == NULL || hash_get(options, "help") != NULL) {
show_usage(argc, argv, arg_opts);
return 1;
}
char *url = hash_get(options, "url");
const char *principal = hash_get(options, "principal");
CREDENTIALS_T *credentials = NULL;
const char *password = hash_get(options, "credentials");
if(password != NULL) {
credentials = credentials_create_password(password);
}
char *topic = hash_get(options, "topic");
char *session_id_str = hash_get(options, "session_id");
// Setup for condition variable.
apr_initialize();
apr_pool_create(&pool, NULL);
apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_UNNESTED, pool);
apr_thread_cond_create(&cond, pool);
// Create a session with Diffusion.
SESSION_T *session = NULL;
DIFFUSION_ERROR_T error;
session = session_create(url, principal, credentials, NULL, NULL, &error);
if(session == NULL) {
fprintf(stderr, "TEST: Failed to create session\n");
fprintf(stderr, "ERR : %s\n", error.message);
return 1;
}
// Create a payload.
char *data = hash_get(options, "data");
BUF_T *payload = buf_create();
buf_write_bytes(payload, data, strlen(data));
CONTENT_T *content = content_create(CONTENT_ENCODING_NONE, payload);
buf_free(payload);
// Build up some headers to send with the message.
LIST_T *headers = list_create();
list_append_last(headers, "apple");
list_append_last(headers, "train");
// Parameters for send_msg_to_session() call.
SESSION_ID_T *session_id = session_id_create_from_string(session_id_str);
SEND_MSG_TO_SESSION_PARAMS_T params = {
.topic_path = topic,
.session_id = *session_id,
.content = *content,
.options.headers = headers,
.options.priority = CLIENT_SEND_PRIORITY_NORMAL,
.on_send = on_send,
.context = "FOO"
};
// Send the message and wait for the callback to acknowledge delivery.
apr_thread_mutex_lock(mutex);
send_msg_to_session(session, params);
apr_thread_cond_wait(cond, mutex);
apr_thread_mutex_unlock(mutex);
// Politely close the client connection.
session_id_free(session_id);
session_close(session, &error);
return 0;
}
static int
do_client()
{
int rc = -1;
grn_obj text;
grn_thread thread;
struct timeval tvb, tve;
grn_com_header sheader;
grn_ctx ctx_, *ctx = &ctx_;
grn_ctx_init(ctx, 0);
GRN_COM_QUEUE_INIT(&fsessions);
sessions = grn_hash_create(ctx, NULL, sizeof(grn_sock), sizeof(session), 0);
sheader.proto = GRN_COM_PROTO_GQTP;
sheader.qtype = 0;
sheader.keylen = 0;
sheader.level = 0;
sheader.flags = 0;
sheader.status = 0;
sheader.opaque = 0;
sheader.cas = 0;
GRN_TEXT_INIT(&text, 0);
rc = grn_bulk_reserve(ctx, &text, BUFSIZE);
if (!rc) {
char *buf = GRN_TEXT_VALUE(&text);
if (!grn_com_event_init(ctx, &ev, 1000, sizeof(grn_com))) {
ev.msg_handler = msg_handler;
if (!THREAD_CREATE(thread, receiver, NULL)) {
int cnt = 0;
gettimeofday(&tvb, NULL);
lprint(ctx, "begin: procotol=%c max_concurrency=%d max_tp=%d", proto, max_con, max_tp);
while (fgets(buf, BUFSIZE, stdin)) {
uint32_t size = strlen(buf) - 1;
session *s = session_alloc(ctx, dests + (cnt++ % dest_cnt));
if (s) {
gettimeofday(&s->tv, NULL);
s->n_query++;
s->query_id = ++nsent;
s->n_sessions = (nsent - nrecv);
switch (proto) {
case 'H' :
case 'h' :
if (grn_com_send_http(ctx, s->com, buf, size, 0)) {
fprintf(stderr, "grn_com_send_http failed\n");
}
s->stat = 2;
/*
lprint(ctx, "sent %04d %04d %d",
s->n_query, s->query_id, s->com->fd);
*/
break;
default :
if (grn_com_send(ctx, s->com, &sheader, buf, size, 0)) {
fprintf(stderr, "grn_com_send failed\n");
}
break;
}
} else {
fprintf(stderr, "grn_com_copen failed\n");
}
for (;;) {
gettimeofday(&tve, NULL);
if ((nrecv < max_tp * (tve.tv_sec - tvb.tv_sec)) &&
(nsent - nrecv) < max_con) { break; }
/* lprint(ctx, "s:%d r:%d", nsent, nrecv); */
usleep(1000);
}
if (!(nsent % 1000)) { lprint(ctx, " : %d", nsent); }
}
done = 1;
if (THREAD_JOIN(thread)) {
fprintf(stderr, "THREAD_JOIN failed\n");
}
gettimeofday(&tve, NULL);
{
double qps;
uint64_t etime = (tve.tv_sec - tvb.tv_sec);
etime *= 1000000;
etime += (tve.tv_usec - tvb.tv_usec);
qps = (double)nsent * 1000000 / etime;
lprint(ctx, "end : n=%d min=%d max=%d avg=%d qps=%f etime=%d.%06d", nsent, etime_min, etime_max, (int)(etime_amount / nsent), qps, etime / 1000000, etime % 1000000);
}
{
session *s;
GRN_HASH_EACH(ctx, sessions, id, NULL, NULL, &s, {
session_close(ctx, s);
});
}
