int handle_request(void *skt, sqlite3 *db){
char sql[512];
char rowstr[512];
const int len = 512;
char *errstr, *mdata_inline = NULL;
uint8_t cmd, *data = NULL;
uint32_t uid = 0;
int err = 0;
int64_t more;
size_t msg_size, more_size = sizeof(int64_t);
recieve_msg(skt, &msg_size, &more, &more_size, (void**)&data);
if (msg_size != sizeof(uint8_t) || !more){
if (more) flushall_msg_parts(skt);
free(data);
send_empty_msg(skt);
return -1;
}
memcpy(&cmd, data, sizeof(uint8_t));
free(data);
switch (cmd){
case 1: /* insert new entry */
recieve_msg(skt, &msg_size, &more, &more_size, (void**)&mdata_inline);
if (mdata_inline){
uid = insert_db(db, mdata_inline);
free(mdata_inline);
}
syslog(LOG_DEBUG, "assigned uid = %u", uid);
uid = hosttonet32(uid);
send_msg_vsm(skt, &uid, sizeof(uint32_t));
break;
case 2: /* look up id */
rowstr[0] = '\0';
recieve_msg(skt, &msg_size, &more, &more_size, (void**)&data);
if (msg_size != sizeof(uint32_t)){
free(data);
send_empty_msg(skt);
err = -2;
break;
}
memcpy(&uid, data, sizeof(uint32_t));
uid = nettohost32(uid);
char *result = lookup_db(db, uid);
send_msg_data(skt, result, strlen(result)+1, free_fn, NULL);
break;
default:
syslog(LOG_DEBUG, "unrecognized cmd, %u", cmd);
send_empty_msg(skt);
}
if (more)flushall_msg_parts(skt);
return err;
}
int init_server(void *ctx){
char addr[32];
/* send out init signal to main server and get the table number */
snprintf(addr, 32, "tcp://%s:%d", GlobalArgs.server_address, GlobalArgs.port+1);
void *skt = socket_connect(ctx, ZMQ_REQ, addr);
if (!skt){
syslog(LOG_CRIT,"INITSERVER: unable to get req skt");
exit(1);
}
char *str = strdup(init_str);
send_msg_data(skt, str, strlen(str)+1, free_fn, NULL);
/* wait for response */
zmq_msg_t msg;
zmq_msg_init(&msg);
time_t curr_time;
time(&curr_time);
int err = 0;
/* wait until error is recieved or until time alloted is up */
do {
err = zmq_recv(skt, &msg, ZMQ_NOBLOCK);
sleep(1);
} while (err && time(NULL) <= curr_time + 10);
if (err){
syslog(LOG_CRIT,"INITSERVER: no response from main server - timed out");
err = -1;
}
uint8_t tn= 0;
if (err == 0){
memcpy(&tn, zmq_msg_data(&msg), sizeof(uint8_t));
}
zmq_msg_close(&msg);
/* set static global variable */
table_number = tn;
zmq_close(skt);
syslog(LOG_DEBUG, "INITSERVER: recived table number %u, init complete", tn);
return err;
}
int register_table(void *ctx, const char *address){
void *skt = zmq_socket(ctx, ZMQ_REQ);
assert(skt);
assert(zmq_connect(skt, address) == 0);
char *str = strdup(init_str);
send_msg_data(skt, str, strlen(str)+1, free_fn, NULL);
int64_t more;
size_t msg_size, more_size = sizeof(int64_t);
void *data;
recieve_msg(skt, &msg_size, &more, &more_size, &data);
if (msg_size != sizeof(uint8_t)){
return -1;
}
memcpy(&table_number, data, sizeof(uint8_t));
free(data);
if (more) flushall_msg_parts(skt);
assert(zmq_close(skt) == 0);
return 0;
}
static bool cmd_x_apple_push_service(struct client_command_context *cmd)
{
const struct imap_arg *args;
struct mail_user *user = cmd->client->user;
const char *aps_topic = mail_user_plugin_getenv(user, "push_notify_aps_topic");
if (!client_read_args(cmd, 0, 0, &args))
return FALSE;
const char *aps_ver=NULL;
const char *aps_acct_id=NULL;
const char *aps_dev_token=NULL;
const char *aps_sub_topic=NULL;
const struct imap_arg *mailbox_list=NULL;
unsigned int mailbox_count=NULL;
bool mailbox_subscriptions=FALSE;
const char *key, *value;
/* must have a topic */
if (aps_topic == NULL || *aps_topic == '\0')
return FALSE;
/* scarf off the aps keys/values */
while (imap_arg_get_astring(&args[0], &key)) {
if (imap_arg_get_astring(&args[1], &value)) {
if (strcasecmp(key, "aps-version") == 0)
aps_ver = t_strdup(value);
else if (strcasecmp(key, "aps-account-id") == 0)
aps_acct_id = t_strdup(value);
else if (strcasecmp(key, "aps-device-token") == 0)
aps_dev_token = t_strdup(value);
else if (strcasecmp(key, "aps-subtopic") == 0)
aps_sub_topic = t_strdup(value);
else
return FALSE;
}
else if (strcasecmp(key, "mailboxes") == 0) {
mailbox_subscriptions = imap_arg_get_list_full(&args[1], &mailbox_list, &mailbox_count);
}
args += 2;
}
/* save notification settings */
if ( aps_ver && aps_acct_id && aps_dev_token && aps_sub_topic ) {
msg_data_t msg_data;
/* subscribe to notification node */
memset(&msg_data, 0, sizeof(struct msg_data_s));
msg_data.msg = 2;
i_strocpy(msg_data.d1, user->username, sizeof(msg_data.d1));
i_strocpy(msg_data.d2, aps_acct_id, sizeof(msg_data.d2));
i_strocpy(msg_data.d3, aps_dev_token, sizeof(msg_data.d3));
i_strocpy(msg_data.d4, aps_sub_topic, sizeof(msg_data.d4));
send_msg_data(&msg_data);
if(mailbox_subscriptions) {
const char *mailbox;
while (imap_arg_get_astring(&mailbox_list[0], &mailbox)) {
T_BEGIN;
string_t *mailbox_str = t_str_new(256);
imap_append_quoted( mailbox_str, "mailbox");
str_append_c( mailbox_str, ' ');
imap_append_quoted( mailbox_str, mailbox);
send_response(cmd->client, mailbox_str);
msg_data.msg = 4;
i_strocpy(msg_data.d4, mailbox, sizeof(msg_data.d4));
send_msg_data(&msg_data);
T_END;
mailbox_list += 1;
}
}
/* generate aps response */
string_t *str = t_str_new(256);
imap_append_quoted( str, "aps-version" );
str_append_c(str, ' ');
imap_append_quoted( str, APS_VERSION );
str_append_c(str, ' ');
imap_append_quoted( str, "aps-topic" );
str_append_c(str, ' ');
imap_append_quoted( str, aps_topic );
send_response(cmd->client, str);
}
client_send_tagline(cmd, "OK Provisioned");
return TRUE;
}
void* query_thread(void *arg){
ThrParam *thrparam = (ThrParam*)arg;
void *ctx = thrparam->ctx;
char *mdatastr = thrparam->mdatastr;
uint32_t **hashes = thrparam->hashes;
uint32_t *pnbframes = thrparam->nbframes;
unsigned int nbfiles = thrparam->nbfiles;
uint8_t thrn = thrparam->thrn;
uint8_t cmd = thrparam->cmd;
void *skt = zmq_socket(ctx, ZMQ_REQ);
assert(skt);
fprintf(stdout,"thrn%d: connect to %s\n", thrn, thrparam->address);
assert(zmq_connect(skt, thrparam->address)==0);
unsigned int i,j;
void *data;
int64_t more;
size_t msg_size, more_size=sizeof(int64_t);
struct timespec t1_ts, t2_ts, diff_ts;
unsigned long long latency, sum_ull = 0ULL;
if (cmd == 1){ /* queries */
for (i=0;i<nbfiles;i++){
clock_gettime(CLOCK_MONOTONIC, &t1_ts);
sendmore_msg_vsm(skt, &cmd, sizeof(uint8_t));
uint32_t snbframes = hosttonet32(pnbframes[i]);
sendmore_msg_vsm(skt, &snbframes, sizeof(uint32_t));
send_msg_data(skt, hashes[i], pnbframes[i]*sizeof(uint32_t), free_fn, NULL);
recieve_msg(skt, &msg_size, &more, &more_size, &data);
clock_gettime(CLOCK_MONOTONIC, &t2_ts);
diff_ts = diff_timespec(t1_ts, t2_ts);
latency = 1000000000*diff_ts.tv_sec + diff_ts.tv_nsec;
sum_ull += latency;
fprintf(stdout,"thrd%d: query %u frames, recv:\"%s\" in %llu nsecs\n",\
thrn,pnbframes[i],(char*)data, latency);
free(data);
/* simulate interarrival */
unsigned int pause = Arr; /* = next_arrival(Arr);*/
usleep(1000*pause);
}
} else if (cmd == 2){ /* submissions */
for (i=0;i<nbfiles;i++){
clock_gettime(CLOCK_MONOTONIC, &t1_ts);
sendmore_msg_vsm(skt, &cmd, sizeof(uint8_t));
uint32_t snbframes = hosttonet32(pnbframes[i]);
sendmore_msg_vsm(skt, &snbframes, sizeof(uint32_t));
sendmore_msg_data(skt, hashes[i], pnbframes[i]*sizeof(uint32_t), free_fn, NULL);
send_msg_data(skt, mdatastr, strlen(mdatastr)+1, NULL, NULL);
recieve_msg(skt, &msg_size, &more, &more_size, &data);
assert(msg_size == sizeof(uint32_t));
uint32_t uid;
memcpy(&uid, data, sizeof(uint32_t));
uid = nettohost32(uid);
clock_gettime(CLOCK_MONOTONIC, &t2_ts);
diff_ts = diff_timespec(t1_ts, t2_ts);
latency = 1000000000*diff_ts.tv_sec + diff_ts.tv_nsec;
sum_ull += latency;
fprintf(stdout,"thr%d: submit %u frames, recv %u=uid in %llu nsecs\n",\
thrn, pnbframes[i], uid, latency);
/* simulate interarrival */
unsigned int pause = Arr; /*next_arrival(Arr);*/
usleep(1000*pause);
free(data);
}
}
free(thrparam);
zmq_close(skt);
/* return the sum of latency's */
void *ptr = malloc(sizeof(unsigned long long));
assert(ptr);
memcpy(ptr, &sum_ull, sizeof(unsigned long long));
pthread_exit(ptr);
}
