int main(int argc, char **args){
if(argc != 3){
fprintf(stderr,"%s RECV SEND\n",args[0]);
exit(1);
}
signal(SIGINT,&call_for_stop);
bstring pull_addr = bfromcstr(args[1]);
bstring pub_addr = bfromcstr(args[2]);
mongrel2_ctx *ctx = mongrel2_init(1); // Yes for threads?
mongrel2_socket *pull_socket = mongrel2_pull_socket(ctx,bdata(&SENDER));
mongrel2_connect(pull_socket, bdata(pull_addr));
pub_socket = mongrel2_pub_socket(ctx);
mongrel2_connect(pub_socket, bdata(pub_addr));
mongrel2_request *request;
// Polling is done to show how to do a clean shutdown
int poll_response;
zmq_pollitem_t socket_tracker;
socket_tracker.socket = pull_socket->zmq_socket;
socket_tracker.events = ZMQ_POLLIN;
// Let's try out some ADT goodness
dict_t* dict = dict_create(DICTCOUNT_T_MAX, compare_session);
dict_set_allocator(dict, alloc_dict, free_dict, NULL);
dnode_t* tempnode = NULL;
m2_ws_session_data *counter = NULL;
int retval = 0;
while(shutdown != 1){
poll_response = zmq_poll(&socket_tracker,1,500*1000);
if(poll_response > 0){
request = mongrel2_recv(pull_socket);
fprintf(stdout,"got something...\n");
if(request != NULL && mongrel2_request_for_disconnect(request) != 1){
m2_ws_session_id* incoming = calloc(1,sizeof(m2_ws_session_id));
incoming->req = request;
printf("Looking at incoming->conn_id = %d\n",incoming->req->conn_id);
tempnode = dict_lookup(dict,incoming);
if(tempnode == NULL){
mongrel2_ws_reply_upgrade(request,pub_socket);
counter = calloc(1,sizeof(m2_ws_session_data));
counter->times_seen = 0;
retval = dict_alloc_insert(dict,incoming,counter);
assert(retval == 1);
} else {
free(incoming);
counter = dnode_get(tempnode);
counter->times_seen += 1;
}
if(blength(request->body) > 0){
// mongrel2_ws_frame_get_fin(blength(request->body),
// (uint8_t*)bdata(request->body))
if(tempnode && OP_CLOSE == mongrel2_ws_frame_get_opcode(blength(request->body),
(uint8_t*)bdata(request->body))){
dict_delete_free(dict,tempnode);
mongrel2_disconnect(pub_socket,request);
}
} else {
mongrel2_ws_reply(pub_socket,request,(const bstring)&HELLO);
}
printf("FYI: we've got %ld entries\n",dict_count(dict));
} else {
fprintf(stdout,"Connection %d disconnected\n", request->conn_id);
dict_delete_free(dict,tempnode);
mongrel2_disconnect(pub_socket,request);
}
} else if (poll_response < 0){
fprintf(stdout, "Error on poll!");
shutdown = 1;
}
}
// bstring msg = bformat("{\"msg\" : \"hi there %d\"}", request->conn_id);
// fprintf(stdout,"Sending new msg: '%*s'",blength(msg),bdata(msg));
// mongrel2_ws_reply(pub_socket,request,msg);
// bdestroy(msg);
// mongrel2_request_finalize(request);
// mongrel2_reply(pub_socket,request,bfromcstr(""));
bdestroy(pull_addr);
bdestroy(pub_addr);
mongrel2_close(pull_socket);
mongrel2_close(pub_socket);
mongrel2_deinit(ctx);
fprintf(stdout,"\nClean shutdown done! Thanks for playing!\n");
return 0;
}
int main(int argc, char** args){
uint8_t *frame;
size_t size;
// printf("==== NO MASK ====\n");
test_frame_small_no_mask(&size,&frame);
// mongrel2_ws_frame_debug(size,frame);
assert(mongrel2_ws_frame_get_fin(size,frame) == 1);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_mask_present(size,frame) == 0);
assert(mongrel2_ws_frame_get_opcode(size,frame) == OP_TEXT);
assert(mongrel2_ws_frame_get_payload_type(size,frame) == SMALL);
assert(mongrel2_ws_frame_get_payload_size(size,frame) == 111);
free(frame);
test_frame_medium_no_mask(&size,&frame);
// mongrel2_ws_frame_debug(size,frame);
assert(mongrel2_ws_frame_get_fin(size,frame) == 1);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_mask_present(size,frame) == 0);
assert(mongrel2_ws_frame_get_opcode(size,frame) == OP_BIN);
assert(mongrel2_ws_frame_get_payload_type(size,frame) == MEDIUM);
assert(mongrel2_ws_frame_get_payload_size(size,frame) == 2000);
free(frame);
test_frame_large_no_mask(&size,&frame);
// mongrel2_ws_frame_debug(size,frame);
assert(mongrel2_ws_frame_get_fin(size,frame) == 1);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_mask_present(size,frame) == 0);
assert(mongrel2_ws_frame_get_opcode(size,frame) == OP_TEXT);
// Since no mask present, getting mask would be undefined behavior
assert(mongrel2_ws_frame_get_payload_type(size,frame) == LARGE);
assert(mongrel2_ws_frame_get_payload_size(size,frame) == 66000);
free(frame);
// printf("======== W/ MASK ========\n");
test_frame_small_with_mask(&size,&frame);
// mongrel2_ws_frame_debug(size,frame);
assert(mongrel2_ws_frame_get_fin(size,frame) == 1);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_mask_present(size,frame) == 1);
assert(mongrel2_ws_frame_get_opcode(size,frame) == OP_TEXT);
assert(mongrel2_ws_frame_get_mask(size,frame) == 0xFFEEAADD);
assert(mongrel2_ws_frame_get_payload_type(size,frame) == SMALL);
assert(mongrel2_ws_frame_get_payload_size(size,frame) == 4);
free(frame);
test_frame_medium_with_mask(&size,&frame);
// mongrel2_ws_frame_debug(size,frame);
assert(mongrel2_ws_frame_get_fin(size,frame) == 1);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_rsrvd1(size,frame) == 0);
assert(mongrel2_ws_frame_get_mask_present(size,frame) == 1);
assert(mongrel2_ws_frame_get_opcode(size,frame) == OP_BIN);
assert(mongrel2_ws_frame_get_mask(size,frame) == 0xFFFFFFFF);
assert(mongrel2_ws_frame_get_payload_type(size,frame) == MEDIUM);
assert(mongrel2_ws_frame_get_payload_size(size,frame) == 2244);
free(frame);
return 0;
}
int main(int argc, char **args){
signal(SIGINT,&call_for_stop);
if(argc != 3){
fprintf(stderr,"%s RECV SEND\n",args[0]);
exit(1);
}
bstring pull_addr = bfromcstr(args[1]);
bstring pub_addr = bfromcstr(args[2]);
mongrel2_ctx *ctx = mongrel2_init(1);
mongrel2_socket *pull_socket = mongrel2_pull_socket(ctx);
mongrel2_connect(pull_socket, bdata(pull_addr));
mongrel2_socket *pub_socket = mongrel2_pub_socket(ctx);
mongrel2_connect(pub_socket, bdata(pub_addr));
mongrel2_set_identity(pub_socket, bdata(&SENDER) );
// Polling is done to show how to do a clean shutdown
int poll_response;
zmq_pollitem_t socket_tracker;
socket_tracker.socket = pull_socket->zmq_socket;
socket_tracker.events = ZMQ_POLLIN;
// Let's try out some C-style ADT goodness
m2_ws_sessions_state sessions;
mongrel2_ws_sessions_state_init(&sessions);
mongrel2_ws_sessions_state_unlock(&sessions);
mongrel2_request *request = NULL;
while(shutdown != 1){
poll_response = zmq_poll(&socket_tracker,1,500*1000);
if(poll_response > 0){
request = mongrel2_recv(pull_socket);
if(request != NULL && mongrel2_request_for_disconnect(request) != 1){
if(mongrel2_ws_sessions_state_contains(&sessions,request)){
printf("We had it already\n");
} else {
mongrel2_ws_reply_upgrade(request,pub_socket);
mongrel2_ws_sessions_state_add(&sessions,request);
}
if(blength(request->body) > 0){
// mongrel2_ws_frame_debug(blength(request->body),(uint8_t*)bdata(request->body));
if(OP_CLOSE == mongrel2_ws_frame_get_opcode(blength(request->body),
(uint8_t*)bdata(request->body))){
printf("Hey, it's a close\n");
} else {
printf("Not a OP_CLOSE. bstring length: '%d'\n",blength(request->body));
#ifndef NDEBUG
mongrel2_ws_frame_debug(blength(request->body), (uint8_t*)bdata(request->body));
#endif
}
} else {
// mongrel2_ws_reply(pub_socket,request,(const bstring)&HELLO);
mongrel2_ws_broadcast(pub_socket,&sessions,(const bstring)&HELLO);
}
} else {
fprintf(stdout,"Connection %d disconnected\n", request->conn_id);
mongrel2_ws_sessions_state_remove(&sessions,request);
mongrel2_disconnect(pub_socket,request);
}
} else if(poll_response < 0) {
printf("ZMQ poller had an error");
}
}
printf("\nThanks for playing\n");
return 0;
}
void mongrel2_ws_frame_debug(size_t len, uint8_t* header){
fprintf(stdout,"=========== BYTES ============\n");
printf("BYTES: %zd\n",len);
uint8_t fin = mongrel2_ws_frame_get_fin(len,header);
uint8_t rsrvd1 = mongrel2_ws_frame_get_rsrvd1(len,header);
uint8_t rsrvd2 = mongrel2_ws_frame_get_rsrvd2(len,header);
uint8_t rsrvd3 = mongrel2_ws_frame_get_rsrvd3(len,header);
printf("FIN: %d\n",fin);
printf("RSRVD1: %d\n",rsrvd1);
printf("RSRVD2: %d\n",rsrvd2);
printf("RSRVD3: %d\n",rsrvd3);
uint8_t opcode = mongrel2_ws_frame_get_opcode(len,header);
switch(opcode){
case OP_CONT:
printf("OPCODE: OP_CONT\n");
break;
case OP_TEXT:
printf("OPCODE: OP_TEXT\n");
break;
case OP_BIN:
printf("OPCODE: OP_BIN\n");
break;
case OP_CLOSE:
printf("OPCODE: OP_CLOSE\n");
break;
case OP_PING:
printf("OPCODE: OP_PING\n");
break;
case OP_PONG:
printf("OPCODE: OP_PONG\n");
break;
default:
printf("OPCODE: UNKNOWN: %d\n",opcode);
}
uint8_t maskp = mongrel2_ws_frame_get_mask_present(len,header);
ftype msg_type = mongrel2_ws_frame_get_payload_type(len,header);
uint32_t mask = 0;
printf("MASKP: %d\n",maskp);
if(maskp == 1){
mask = mongrel2_ws_frame_get_mask(len,header);
printf("MASK: 0x%8X\n",mask);
}
uint64_t msg_size = mongrel2_ws_frame_get_payload_size(len,header);
switch(msg_type){
case SMALL:
printf("SIZE: SMALL\n");
break;
case MEDIUM:
printf("SIZE: MEDIUM\n");
break;
case LARGE:
printf("SIZE: LARGE\n");
break;
default:
printf("SIZE: UNKNOWN!");
break;
}
printf("MSG_SIZE:%" PRIu64 "\n",msg_size);
uint8_t *payload = NULL;
size_t size = 0;
mongrel2_ws_frame_get_payload(len,header,&size,&payload);
if(size > 0 && size < 60 && payload != NULL){
printf("MSG: %*s\n",(int)size,payload);
if(maskp == 1){
uint8_t *unmasked = calloc(size,sizeof(uint8_t));
memcpy(unmasked,payload,size);
mongrel2_ws_frame_unmask(mask,size,unmasked);
printf("UNMASKED: %.*s\n",(int)size,unmasked);
free(unmasked);
}
} else if (size > 0){
printf("MSG: %*s\n",60,payload);
}
fprintf(stdout,"==============================\n");
}
