char *daemon_render_node_to_json(struct razer_fx_render_node *render_node)
{
char *rn_json = str_CreateEmpty();
rn_json = str_CatFree(rn_json,"\n {\n");
rn_json = str_CatFree(rn_json," \"id\" : ");
char *id_string = str_FromLong(render_node->id);
rn_json = str_CatFree(rn_json,id_string);
rn_json = str_CatFree(rn_json," ,\n");
free(id_string);
rn_json = str_CatFree(rn_json," \"name\": \"");
rn_json = str_CatFree(rn_json,render_node->name);
rn_json = str_CatFree(rn_json,"\" ,\ndescription\": \"");
rn_json = str_CatFree(rn_json,render_node->description);
/*effect_json = str_CatFree(effect_json,"\" ,\n \"subs_num\" : ");
char *parameters_num_string = str_FromLong(effect->parameters->num);
effect_json = str_CatFree(effect_json,parameters_num_string);
effect_json = str_CatFree(effect_json," ,\n");
free(parameters_num_string);
effect_json = str_CatFree(effect_json," \"parameters\" : [\n");
for(int i = 0;i<effect->parameters->num;i++)
{
struct razer_parameter *parameter = effect->parameters->items[i];
char *parameter_json = daemon_parameter_to_json(parameter);
effect_json = str_CatFree(effect_json,parameter_json);
free(parameter_json);
}*/
rn_json = str_CatFree(rn_json,"\"\n },\n");
return(rn_json);
}
char *str_Copy(char *src)
{
if(src==NULL)
return(str_CreateEmpty());
char *a = (char*)malloc(strlen(src)+1);
memcpy(a, src, strlen(src)+1);
return(a);
}
struct razer_chroma *razer_open(void)
{
struct razer_chroma *chroma =(struct razer_chroma*)malloc(sizeof(struct razer_chroma));
#ifdef USE_DEBUGGING
printf("opening chroma lib\n");
#endif
chroma->sys_mouse_event_path = str_Copy(razer_sys_mouse_event_default_path);
chroma->sys_keyboard_event_path = str_Copy(razer_sys_keyboard_event_default_path);
chroma->custom_mode_file = NULL;
chroma->update_keys_file = NULL;
chroma->keyboard_input_file = 0;
chroma->mouse_input_file = 0;
chroma->device_path = razer_get_device_path();
if(!chroma->device_path)
{
#ifdef USE_DEBUGGING
printf("error no compatible device found\n");
#endif
return(NULL);
}
#ifdef USE_VERBOSE_DEBUGGING
printf("found device at path:%s\n",chroma->device_path);
#endif
chroma->keys = (struct razer_keys*)malloc(sizeof(struct razer_keys));
razer_init_keys(chroma->keys);
chroma->custom_mode_filename = str_CreateEmpty();
chroma->custom_mode_filename = str_CatFree(chroma->custom_mode_filename,chroma->device_path);
chroma->custom_mode_filename = str_CatFree(chroma->custom_mode_filename,razer_custom_mode_pathname);
chroma->update_keys_filename = str_CreateEmpty();
chroma->update_keys_filename = str_CatFree(chroma->update_keys_filename,chroma->device_path);
chroma->update_keys_filename = str_CatFree(chroma->update_keys_filename,razer_update_keys_pathname);
chroma->input_handler = NULL;
chroma->last_key_pos.x = -1;
chroma->last_key_pos.y = -1;
chroma->key_pos.x = -1;
chroma->key_pos.y = -1;
return(chroma);
}
char *str_FromDouble(double d)
{
char *ret=NULL;
long len = snprintf(NULL,0,"%f",d);
if(len)
{
ret = (char*)malloc(len+1);
snprintf(ret,len+1,"%f",d);
}
else
ret=str_CreateEmpty();
return(ret);
}
char *str_FromLong(long i)
{
char *ret=NULL;
long len = snprintf(NULL,0,"%ld",i);
if(len)
{
ret = (char*)malloc(len+1);
snprintf(ret,len+1,"%ld",i);
}
else
ret=str_CreateEmpty();
return(ret);
}
char *str_Cat(char *a,char *b)
{
if(a == NULL && b != NULL)
return(str_Copy(b));
else
if(a != NULL && b == NULL)
return(str_Copy(a));
else
if(a == NULL && b == NULL)
return(str_CreateEmpty());
char *tmp = (char*)malloc(strlen(a) + strlen(b) + 1);
memcpy(tmp, a, strlen(a));
memcpy(tmp + strlen(a), b, strlen(b)+1);
return(tmp);
}
char *str_Sub(char *a,long start,long len)
{
if(a==NULL || (long)strlen(a)<=start)
{
return(str_CreateEmpty());
}
long l=0;
if(len>0)
{
long e = start + len;
l=len;
if(e>(long)strlen(a))
l = strlen(a) - start;
}
else
{
l = strlen(a) - start;
}
char *tmp = (char*)malloc(l + 1);
memset(tmp+l, 0, 1);
memcpy(tmp, a+start, l);
return(tmp);
}
void dc_render_node_sub_add(struct razer_daemon_controller *controller,int render_node_uid,int sub_render_node_uid)
{
DBusMessage *msg;
DBusMessageIter args;
char *path = str_CreateEmpty();
path = str_CatFree(path,"/");
char *suid = str_FromLong(render_node_uid);
path = str_CatFree(path,suid);
free(suid);
msg = dbus_message_new_method_call("org.voyagerproject.razer.daemon",path,"org.voyagerproject.razer.daemon.render_node.sub","add");
if(!msg)
dc_error_close(controller,"Error creating Message\n");
dbus_message_iter_init_append(msg,&args);
if(!dbus_message_iter_append_basic(&args,DBUS_TYPE_INT32,&sub_render_node_uid))
dc_error_close(controller,"Out of memory!\n");
if(!dbus_connection_send_with_reply(controller->dbus,msg,&controller->pending,-1))
dc_error_close(controller,"Out of memory!\n");
if(!controller->pending)
dc_error_close(controller,"No pending call\n");
dbus_connection_flush(controller->dbus);
dbus_message_unref(msg);
free(path);
}
int dc_render_node_parent_get(struct razer_daemon_controller *controller,int render_node_uid)
{
DBusMessage *msg;
DBusMessageIter args;
char *path = str_CreateEmpty();
path = str_CatFree(path,"/");
char *suid = str_FromLong(render_node_uid);
path = str_CatFree(path,suid);
free(suid);
msg = dbus_message_new_method_call("org.voyagerproject.razer.daemon",path,"org.voyagerproject.razer.daemon.render_node.parent","get");
if(!msg)
dc_error_close(controller,"Error creating Message\n");
if(!dbus_connection_send_with_reply(controller->dbus,msg,&controller->pending,-1))
dc_error_close(controller,"Out of memory!\n");
if(!controller->pending)
dc_error_close(controller,"No pending call\n");
dbus_connection_flush(controller->dbus);
dbus_message_unref(msg);
int parent_uid = -1;
dbus_pending_call_block(controller->pending);
msg = dbus_pending_call_steal_reply(controller->pending);
if(!msg)
dc_error_close(controller,"Empty reply\n");
dbus_pending_call_unref(controller->pending);
if(!dbus_message_iter_init(msg,&args))
dc_error_close(controller,"Message has no arguments!\n");
else if(dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_INT32)
dc_error_close(controller,"Argument is not an int!\n");
else
dbus_message_iter_get_basic(&args,&parent_uid);
dbus_message_unref(msg);
free(path);//TODO gets not freed on error
return(parent_uid);
}
void dc_render_node_opacity_set(struct razer_daemon_controller *controller,int render_node_uid,float opacity)
{
DBusMessage *msg;
DBusMessageIter args;
char *path = str_CreateEmpty();
path = str_CatFree(path,"/");
char *suid = str_FromLong(render_node_uid);
path = str_CatFree(path,suid);
free(suid);
double opc = (double)opacity;
msg = dbus_message_new_method_call("org.voyagerproject.razer.daemon",path,"org.voyagerproject.razer.daemon.render_node.opacity","set");
if(!msg)
dc_error_close(controller,"Error creating Message\n");
dbus_message_iter_init_append(msg,&args);
if(!dbus_message_iter_append_basic(&args,DBUS_TYPE_DOUBLE,&opc))
dc_error_close(controller,"Out of memory!\n");
if(!dbus_connection_send_with_reply(controller->dbus,msg,&controller->pending,-1))
dc_error_close(controller,"Out of memory!\n");
if(!controller->pending)
dc_error_close(controller,"No pending call\n");
dbus_connection_flush(controller->dbus);
dbus_message_unref(msg);
free(path);//TODO gets not freed on error
}
return("Float Array");
case RAZER_PARAMETER_TYPE_RGB_ARRAY:
return("RGB Array");
case RAZER_PARAMETER_TYPE_POS_ARRAY:
return("Position Array");
default:
return("Unknown Type");
}
}
char *daemon_parameter_to_json(struct razer_parameter *parameter, int final)
{
char *parameter_json = str_CreateEmpty();
parameter_json = str_CatFree(parameter_json,"{\n \"key\": \"");
parameter_json = str_CatFree(parameter_json,parameter->key);
parameter_json = str_CatFree(parameter_json,"\",\n");
parameter_json = str_CatFree(parameter_json," \"id\" : ");
char *id_string = str_FromLong(parameter->id);
parameter_json = str_CatFree(parameter_json,id_string);
parameter_json = str_CatFree(parameter_json," ,\n");
free(id_string);
parameter_json = str_CatFree(parameter_json," \"type\" : \"");
//char *type_string = str_FromLong(parameter->type);
//parameter_json = str_CatFree(parameter_json,type_string);
parameter_json = str_CatFree(parameter_json,daemon_parameter_type_to_string(parameter));
parameter_json = str_CatFree(parameter_json,"\" ,\n");
//free(type_string);
parameter_json = str_CatFree(parameter_json," \"private\" : ");
static int callback_nyx_websockets(struct libwebsocket_context *context,struct libwebsocket *wsi,enum libwebsocket_callback_reasons reason, void *user,void *in,size_t len)
{
struct per_session_data_nyx *pss =(struct per_session_data_nyx*)user;
int n;
node *wsd_state = (node*)libwebsocket_context_user(context);
//node *daemon = (node*)libwebsocket_context_user(context);
//node *wsd_state = node_GetNode(get_value(daemon));
node *found_prot = NULL;
node *state = NULL;
node *block = NULL;
//node *daemon = NULL;
node *daemon_obj = NULL;
node *session_uid = NULL;
long lsession_uid = 0;
node *sessions_num = NULL;
node *sessions = NULL;
long lsessions_num = 0;
if(wsd_state)
{
state = node_GetItem(wsd_state,0);
block = node_GetItem(wsd_state,1);
//daemon = node_GetItem(wsd_state,2);
node *protocols = node_GetItem(wsd_state,3);
session_uid = node_GetItem(wsd_state,4);
node *session_uid_value = node_GetItemByKey(session_uid,"value");
lsession_uid = node_GetSint32(session_uid_value);
sessions_num = node_GetItem(wsd_state,5);
sessions = node_GetItem(wsd_state,6);
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
lsessions_num = node_GetSint32(sessions_num_value);
daemon_obj = node_GetItem(wsd_state,9);
if(wsi)
{
node *protocols_items = node_GetItemByKey(protocols,"items");
const struct libwebsocket_protocols *prot = libwebsockets_get_protocol(wsi);
if(prot && prot->name)
{
node_ItemIterationReset(protocols_items);
while(node_ItemIterationUnfinished(protocols_items))
{
node *proto = node_ItemIterate(protocols_items);
if(!strcmp(get_obj_name(proto),prot->name))
{
found_prot = proto;
}
}
}
}
}
switch(reason)
{
//case LWS_CALLBACK_SERVER_NEW_CLIENT_INSTANTIATED:
case LWS_CALLBACK_CLIENT_ESTABLISHED:
printf("new session created:%d, num:%d\n",lsession_uid,lsessions_num);
pss->session = NULL;
break;
case LWS_CALLBACK_HTTP:
if(len < 1)
{
libwebsockets_return_http_status(context,wsi,HTTP_STATUS_BAD_REQUEST,NULL);
return(-1);
}
if(lws_hdr_total_length(wsi,WSI_TOKEN_POST_URI))
return(0);
if(found_prot)
{
//printf("found prot in http callback : uid:%d,num:%d (sess:%x)\n",lsession_uid+1,lsessions_num,pss->session);
if(!pss->session)
{
lsession_uid++;
node *session_uid_value = node_GetItemByKey(session_uid,"value");
node_SetSint32(session_uid_value,lsession_uid);
lsessions_num++;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
pss->session = create_session(state,sessions,lsession_uid,get_obj_name(found_prot));
node *session_privates = node_GetItemByKey(pss->session,"privates");
set_obj_int(session_privates,"is_http",1);
//printf("created new session :%d actual sessions num:%d\n",lsession_uid,lsessions_num);
}
node *parameters = create_obj("parameters");
node *base_class = get_base_class(state);
node *prot_value = create_class_instance(base_class);
set_obj_string(prot_value,"name","protocol");
set_obj_string(prot_value,"value",get_obj_name(found_prot));
node_AddItem(parameters,prot_value);
inc_obj_refcount(prot_value);
char *url = str_CreateEmpty();
url = str_AddChars(url,in,len);
node *url_value = create_class_instance(base_class);
set_obj_string(url_value,"name","url");
set_obj_string(url_value,"value",url);
node_AddItem(parameters,url_value);
inc_obj_refcount(url_value);
free(url);
node_AddItem(parameters,pss->session);
inc_obj_refcount(pss->session);
//node_AddItem(parameters,daemon_obj);
node_AddItem(parameters,sessions);
inc_obj_refcount(sessions);
node *tmp_parent = node_GetParent(found_prot);
node *bmembers = node_GetItemByKey(block,"members");
node_SetParent(found_prot,bmembers);
node *ret_obj = execute_obj(state,found_prot,block,parameters,True,False);//,True);resolve
node_SetParent(found_prot,tmp_parent);
//dec_obj_refcount(msg_value);
dec_obj_refcount(prot_value);
//add_garbage(state,msg_value);//TODO check if "just survives"
add_garbage(state,prot_value);
dec_obj_refcount(url_value);
add_garbage(state,url_value);
dec_obj_refcount(pss->session);
dec_obj_refcount(sessions);
node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
if( (node_GetType(ret_obj_value)==NODE_TYPE_STRING && strlen(node_GetString(ret_obj_value))) || (node_GetType(ret_obj_value)==NODE_TYPE_BINARY && node_GetBinaryLength(ret_obj_value)) )
{
//printf("returning http message: [%s] :%d\n",node_GetString(ret_obj_value),strlen(node_GetString(ret_obj_value)));
//node *ret_obj_copy = node_CopyTree(ret_obj,True,True);
node *ret_obj_copy = copy_class(ret_obj);
//reset_obj_refcount(ret_obj_copy);
set_obj_string(ret_obj_copy,"name","message");
add_member(pss->session,ret_obj_copy);
inc_obj_refcount(ret_obj_copy);
}
libwebsocket_callback_on_writable(context, wsi);
}
break;
case LWS_CALLBACK_HTTP_BODY_COMPLETION:
if(found_prot)
{
printf("found prot in http body complete : %d,num:%d\n",lsession_uid,lsessions_num);
if(daemon_obj)
{
printf("body: found daemon_obj\n");
}
}
else
printf("body closed: prot not found\n");
//lwsl_notice("LWS_CALLBACK_HTTP_BODY_COMPLETION\n");
libwebsockets_return_http_status(context,wsi,HTTP_STATUS_OK,NULL);
return(-1);
case LWS_CALLBACK_HTTP_FILE_COMPLETION:
if(found_prot)
{
//printf("found prot in http file complete : %d,num:%d\n",lsession_uid,lsessions_num);
lsessions_num--;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
delete_session(state,sessions,pss->session);
pss->session = NULL;
if(daemon_obj)
{
printf("http: found daemon_obj\n");
}
}
else
printf("file closed: prot not found\n");
return(-1);
case LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION:
if(found_prot)
{
int n;
static const char *token_names[] =
{
/*[WSI_TOKEN_GET_URI] =*/ "GET URI",
/*[WSI_TOKEN_POST_URI] =*/ "POST URI",
/*[WSI_TOKEN_OPTIONS] =*/ "Options",
/*[WSI_TOKEN_HOST] =*/ "Host",
/*[WSI_TOKEN_CONNECTION] =*/ "Connection",
/*[WSI_TOKEN_KEY1] =*/ "key 1",
/*[WSI_TOKEN_KEY2] =*/ "key 2",
/*[WSI_TOKEN_PROTOCOL] =*/ "Protocol",
/*[WSI_TOKEN_UPGRADE] =*/ "Upgrade",
/*[WSI_TOKEN_ORIGIN] =*/ "Origin",
/*[WSI_TOKEN_DRAFT] =*/ "Draft",
/*[WSI_TOKEN_CHALLENGE] =*/ "Challenge",
/* new for 04 */
/*[WSI_TOKEN_KEY] =*/ "Key",
/*[WSI_TOKEN_VERSION] =*/ "Version",
/*[WSI_TOKEN_SWORIGIN] =*/ "Sworigin",
/* new for 05 */
/*[WSI_TOKEN_EXTENSIONS] =*/ "Extensions",
/* client receives these */
/*[WSI_TOKEN_ACCEPT] =*/ "Accept",
/*[WSI_TOKEN_NONCE] =*/ "Nonce",
/*[WSI_TOKEN_HTTP] =*/ "Http",
"Accept:",
"Accept_Request_Headers:",
"If-None-Match:",
"If-Modified-Since:",
"Accept-Encoding:",
"Accept-Language:",
"Pragma:",
"Cache-Control:",
"Authorization:",
"Cookie:",
"Content-Length:",
"Content-Type:",
"Date:",
"Range:",
"Referer:",
"Uri-Args:",
/*[WSI_TOKEN_MUXURL] =*/ "MuxURL",
};
//printf("found prot in http filter callback : uid:%d,num:%d (sess:%x)\n",lsession_uid+1,lsessions_num,pss->session);
if(!pss->session)
{
lsession_uid++;
node *session_uid_value = node_GetItemByKey(session_uid,"value");
node_SetSint32(session_uid_value,lsession_uid);
lsessions_num++;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
pss->session = create_session(state,sessions,lsession_uid,get_obj_name(found_prot));
//node *session_privates = node_GetItemByKey(pss->session,"privates");
//set_obj_int(session_privates,"is_http",1);
}
//printf("filter sess:%x\n",pss->session);
for(n=0;n<(int)(sizeof(token_names)/sizeof(token_names[0]));n++)
{
if (!lws_hdr_total_length(wsi, n))
continue;
char *cookies = (char*)malloc(512);
memset(cookies,0,512);
lws_hdr_copy(wsi,cookies,511,n);
//printf("header:%s = [%s]\n",token_names[n],cookies);
//fflush(stdout);
if(pss->session && !strcmp("Cookie:",token_names[n]))
{
//printf("cookie found:%s = [%s]\n",token_names[n],cookies);
//fflush(stdout);
node *base_class = get_base_class(state);
node *cookie_value = create_class_instance(base_class);
set_obj_string(cookie_value,"name","cookie");
set_obj_string(cookie_value,"value",cookies);
add_member(pss->session,cookie_value);
inc_obj_refcount(cookie_value);
}
free(cookies);
}
}
break;
case LWS_CALLBACK_HTTP_WRITEABLE:
case LWS_CALLBACK_SERVER_WRITEABLE:
{
//node_PrintTree(pss->session);
node *message = get_member(pss->session,"message");
node *session_privates = node_GetItemByKey(pss->session,"privates");
node *http_only = node_GetItemByKey(session_privates,"is_http");
while(message)
{
//node *session_id = get_member(pss->session,"id");
//node *session_id_value = node_GetItemByKey(session_id,"value");
node *message_value = node_GetItemByKey(message,"value");
unsigned char *me = NULL;
unsigned long me_len = 0;
if(node_GetType(message_value)==NODE_TYPE_STRING)
{
me = (unsigned char*)node_GetString(message_value);
me_len = strlen((char*)me);
}
else if(node_GetType(message_value)==NODE_TYPE_BINARY)
{
me = (unsigned char*)node_GetBinary(message_value);
me_len = node_GetBinaryLength(message_value);
}
//printf("sending message now: [%s] to: %d\n",me,node_GetSint32(session_id_value));
//fflush(stdout);
unsigned char *buf = (unsigned char*)malloc(LWS_SEND_BUFFER_PRE_PADDING + me_len + LWS_SEND_BUFFER_POST_PADDING);
memcpy(buf+LWS_SEND_BUFFER_PRE_PADDING,me,me_len);
if(http_only)
//n = libwebsocket_write(wsi, me, me_len, LWS_WRITE_HTTP);
n = libwebsocket_write(wsi,buf+LWS_SEND_BUFFER_PRE_PADDING,me_len,LWS_WRITE_HTTP);
else
//n = libwebsocket_write(wsi, me, me_len, LWS_WRITE_TEXT);
n = libwebsocket_write(wsi,buf+LWS_SEND_BUFFER_PRE_PADDING,me_len,LWS_WRITE_TEXT);
free(buf);
if(n<0)
{
printf("ERROR %d writing to socket, hanging up\n", n);
return(1);
}
if(n<(long)me_len)
{
printf("Partial write\n");
return(-1);
}
//node_FreeTree(pss->message);
remove_member(pss->session,message);
dec_obj_refcount(message);
//printf("removing message from queue:%x (%d)\n",message,get_obj_refcount(message));
add_garbage(state,message);
message = get_member(pss->session,"message");
}
if(http_only)
{
//if(lws_http_transaction_completed(wsi))
//{
//printf("removing http session num:%d\n",lsessions_num);
lsessions_num--;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
delete_session(state,sessions,pss->session);
pss->session = NULL;
//printf("removed http\n");
return -1;
//return(-1);
//}
//else
// libwebsocket_callback_on_writable(context, wsi);
}
}
break;
case LWS_CALLBACK_ESTABLISHED:
if(found_prot)
{
//printf("found prot in establish callback : uid:%d,num:%d (sess:%x)\n",lsession_uid+1,lsessions_num,pss->session);
if(!pss->session)
{
lsession_uid++;
node *session_uid_value = node_GetItemByKey(session_uid,"value");
node_SetSint32(session_uid_value,lsession_uid);
lsessions_num++;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
pss->session = create_session(state,sessions,lsession_uid,get_obj_name(found_prot));
}
if(daemon_obj)
{
node *connect_handler = get_member(daemon_obj,"connect_handler");
if(connect_handler)
{
connect_handler = resolve_object(state,connect_handler);
node *parameters = create_obj("parameters");
node *base_class = get_base_class(state);
node *prot_value = create_class_instance(base_class);
set_obj_string(prot_value,"name","protocol");
set_obj_string(prot_value,"value",get_obj_name(found_prot));
node_AddItem(parameters,prot_value);
inc_obj_refcount(prot_value);
node_AddItem(parameters,pss->session);
inc_obj_refcount(pss->session);
node_AddItem(parameters,sessions);
inc_obj_refcount(sessions);
node *tmp_parent = node_GetParent(connect_handler);
node *bmembers = node_GetItemByKey(block,"members");
node_SetParent(connect_handler,bmembers);
node *ret_obj = execute_obj(state,connect_handler,block,parameters,True,False);//,True);resolve
node_SetParent(connect_handler,tmp_parent);
dec_obj_refcount(prot_value);
add_garbage(state,prot_value);
dec_obj_refcount(pss->session);
dec_obj_refcount(sessions);
node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
if(node_GetType(ret_obj_value)==NODE_TYPE_STRING && strlen(node_GetString(ret_obj_value)))
{
}
}
}
}
break;
case LWS_CALLBACK_CLOSED_HTTP:
break;
case LWS_CALLBACK_CLOSED:
case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
if(found_prot)
{
//printf("found prot in closed callback : uid:%d,num:%d (sess:%x)\n",lsession_uid,lsessions_num,pss->session);
if(daemon_obj)
{
//printf("closed: found daemon_obj\n");
node *disconnect_handler = get_member(daemon_obj,"disconnect_handler");
if(disconnect_handler)
{
//printf("disc found\n");
disconnect_handler = resolve_object(state,disconnect_handler);
node *parameters = create_obj("parameters");
node *base_class = get_base_class(state);
node *prot_value = create_class_instance(base_class);
set_obj_string(prot_value,"name","protocol");
set_obj_string(prot_value,"value",get_obj_name(found_prot));
node_AddItem(parameters,prot_value);
inc_obj_refcount(prot_value);
node_AddItem(parameters,pss->session);
inc_obj_refcount(pss->session);
node_AddItem(parameters,sessions);
inc_obj_refcount(sessions);
node *tmp_parent = node_GetParent(disconnect_handler);
node *bmembers = node_GetItemByKey(block,"members");
node_SetParent(disconnect_handler,bmembers);
node *ret_obj = execute_obj(state,disconnect_handler,block,parameters,True,False);//,True);resolve
node_SetParent(disconnect_handler,tmp_parent);
dec_obj_refcount(prot_value);
add_garbage(state,prot_value);
dec_obj_refcount(pss->session);
dec_obj_refcount(sessions);
node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
if(node_GetType(ret_obj_value)==NODE_TYPE_STRING && strlen(node_GetString(ret_obj_value)))
{
}
}
}
lsessions_num--;
node *sessions_num_value = node_GetItemByKey(sessions_num,"value");
node_SetSint32(sessions_num_value,lsessions_num);
delete_session(state,sessions,pss->session);
pss->session = NULL;
//printf("disconnected\n");
}
else
{
printf("closed connection without prot found\n");
if(pss->session)
printf("but a session was found\n");
}
break;
case LWS_CALLBACK_RECEIVE:
if(len>1024)
{ //TODO use some variable
lwsl_err("Server received packet bigger than %u, hanging up\n", 1024);
return(1);
}
if(found_prot)
{
node *parameters = create_obj("parameters");
node *base_class = get_base_class(state);
node *prot_value = create_class_instance(base_class);
set_obj_string(prot_value,"name","protocol");
set_obj_string(prot_value,"value",get_obj_name(found_prot));
node_AddItem(parameters,prot_value);
inc_obj_refcount(prot_value);
char *msg = str_CreateEmpty();
msg = str_AddChars(msg,in,len);
node *msg_value = create_class_instance(base_class);
set_obj_string(msg_value,"name","message");
set_obj_string(msg_value,"value",msg);
node_AddItem(parameters,msg_value);
inc_obj_refcount(msg_value);
free(msg);
/*node *session_value = create_class_instance(base_class);
reset_obj_refcount(session_value);
add_garbage(state,session_value);
set_obj_string(session_value,"name","session_id");
set_obj_int(session_value,"value",lsession_uid);
set_obj_int(session_value,"item_index",2);
node_AddItem(parameters,session_value);
*/
node_AddItem(parameters,pss->session);
inc_obj_refcount(pss->session);
//node_AddItem(parameters,daemon_obj);
//inc_obj_refcount(daemon_obj);
node_AddItem(parameters,sessions);
inc_obj_refcount(sessions);
//printf("recv callback\n");
//fflush(stdout);
node *tmp_parent = node_GetParent(found_prot);
node *bmembers = node_GetItemByKey(block,"members");
node_SetParent(found_prot,bmembers);
node *ret_obj = execute_obj(state,found_prot,block,parameters,True,False);//,True);resolve
node_SetParent(found_prot,tmp_parent);
//printf("recv callback finished\n");
//fflush(stdout);
dec_obj_refcount(msg_value);
dec_obj_refcount(prot_value);
add_garbage(state,msg_value);//TODO check if "just survives"
add_garbage(state,prot_value);
dec_obj_refcount(pss->session);
dec_obj_refcount(sessions);
//dec_obj_refcount(daemon_obj);
//printf("recv gc\n");
//fflush(stdout);
//node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
//char *me = node_GetString(ret_obj_value);
//printf("returned string:[%s]\n",me);
node *ret_obj_value = node_GetItemByKey(ret_obj,"value");
if(node_GetType(ret_obj_value)==NODE_TYPE_STRING && strlen(node_GetString(ret_obj_value)))
{
//printf("returning message: [%s] :%d\n",node_GetString(ret_obj_value),strlen(node_GetString(ret_obj_value)));
//node *ret_obj_copy = node_CopyTree(ret_obj,True,True);
node *ret_obj_copy = copy_class(ret_obj);
//reset_obj_refcount(ret_obj_copy);
set_obj_string(ret_obj_copy,"name","message");
add_member(pss->session,ret_obj_copy);
inc_obj_refcount(ret_obj_copy);
//set_obj_string(ret_obj,"name","message");
//add_member(pss->session,ret_obj);
//inc_obj_refcount(ret_obj);
}
libwebsocket_callback_on_writable(context, wsi);
}
break;
default:
break;
}
return(0);
}
char *daemon_parameter_to_json(struct razer_parameter *parameter)
{
char *parameter_json = str_CreateEmpty();
parameter_json = str_CatFree(parameter_json,"{\n \"key\": \"");
parameter_json = str_CatFree(parameter_json,parameter->key);
parameter_json = str_CatFree(parameter_json,"\",\n");
parameter_json = str_CatFree(parameter_json," \"id\" : ");
char *id_string = str_FromLong(parameter->id);
parameter_json = str_CatFree(parameter_json,id_string);
parameter_json = str_CatFree(parameter_json," ,\n");
free(id_string);
parameter_json = str_CatFree(parameter_json," \"type\" : ");
char *type_string = str_FromLong(parameter->type);
parameter_json = str_CatFree(parameter_json,type_string);
parameter_json = str_CatFree(parameter_json," ,\n");
free(type_string);
parameter_json = str_CatFree(parameter_json," \"value\" : ");
switch(parameter->type)
{
case RAZER_PARAMETER_TYPE_STRING:
{
parameter_json = str_CatFree(parameter_json,"\"");
parameter_json = str_CatFree(parameter_json,daemon_get_parameter_string(parameter));
parameter_json = str_CatFree(parameter_json,"\" ,\n");
}
break;
case RAZER_PARAMETER_TYPE_INT:
{
char *int_string = str_FromLong(daemon_get_parameter_int(parameter));
parameter_json = str_CatFree(parameter_json,int_string);
free(int_string);
parameter_json = str_CatFree(parameter_json," ,\n");
}
break;
case RAZER_PARAMETER_TYPE_UINT:
{
char *int_string = str_FromLong(daemon_get_parameter_int(parameter));
parameter_json = str_CatFree(parameter_json,int_string);
free(int_string);
parameter_json = str_CatFree(parameter_json," ,\n");
}
break;
case RAZER_PARAMETER_TYPE_FLOAT:
{
char *float_string = str_FromDouble(daemon_get_parameter_float(parameter));
parameter_json = str_CatFree(parameter_json,float_string);
free(float_string);
parameter_json = str_CatFree(parameter_json," ,\n");
}
break;
case RAZER_PARAMETER_TYPE_RGB:
{
parameter_json = str_CatFree(parameter_json,"[");
struct razer_rgb *color = daemon_get_parameter_rgb(parameter);
char *r_string = str_FromLong(color->r);
parameter_json = str_CatFree(parameter_json,r_string);
parameter_json = str_CatFree(parameter_json," ,");
free(r_string);
char *g_string = str_FromLong(color->g);
parameter_json = str_CatFree(parameter_json,g_string);
parameter_json = str_CatFree(parameter_json," ,");
free(g_string);
char *b_string = str_FromLong(color->b);
parameter_json = str_CatFree(parameter_json,b_string);
free(b_string);
parameter_json = str_CatFree(parameter_json,"] ,\n");
}
break;
case RAZER_PARAMETER_TYPE_POS:
{
parameter_json = str_CatFree(parameter_json,"[");
struct razer_pos *pos = daemon_get_parameter_pos(parameter);
char *x_string = str_FromLong(pos->x);
parameter_json = str_CatFree(parameter_json,x_string);
parameter_json = str_CatFree(parameter_json," ,");
free(x_string);
char *y_string = str_FromLong(pos->y);
parameter_json = str_CatFree(parameter_json,y_string);
free(y_string);
parameter_json = str_CatFree(parameter_json,"] ,\n");
}
break;
case RAZER_PARAMETER_TYPE_RENDER_NODE:
{
struct razer_fx_render_node *render_node = daemon_get_parameter_render_node(parameter);
char *render_node_string = str_FromLong(render_node->id);
parameter_json = str_CatFree(parameter_json,render_node_string);
free(render_node_string);
parameter_json = str_CatFree(parameter_json," ,\n");
}
break;
case RAZER_PARAMETER_TYPE_FLOAT_RANGE:
{
parameter_json = str_CatFree(parameter_json,"[");
struct razer_float_range *range = daemon_get_parameter_float_range(parameter);
char *min_string = str_FromDouble(range->min);
parameter_json = str_CatFree(parameter_json,min_string);
parameter_json = str_CatFree(parameter_json," ,");
free(min_string);
char *max_string = str_FromDouble(range->max);
parameter_json = str_CatFree(parameter_json,max_string);
free(max_string);
parameter_json = str_CatFree(parameter_json,"] ,\n");
}
break;
case RAZER_PARAMETER_TYPE_INT_RANGE:
{
parameter_json = str_CatFree(parameter_json,"[");
struct razer_int_range *range = daemon_get_parameter_int_range(parameter);
char *min_string = str_FromLong(range->min);
parameter_json = str_CatFree(parameter_json,min_string);
parameter_json = str_CatFree(parameter_json," ,");
free(min_string);
char *max_string = str_FromLong(range->max);
parameter_json = str_CatFree(parameter_json,max_string);
free(max_string);
parameter_json = str_CatFree(parameter_json,"] ,\n");
}
break;
case RAZER_PARAMETER_TYPE_UINT_RANGE:
{
parameter_json = str_CatFree(parameter_json,"[");
struct razer_uint_range *range = daemon_get_parameter_uint_range(parameter);
char *min_string = str_FromLong(range->min);
parameter_json = str_CatFree(parameter_json,min_string);
parameter_json = str_CatFree(parameter_json," ,");
free(min_string);
char *max_string = str_FromLong(range->max);
parameter_json = str_CatFree(parameter_json,max_string);
free(max_string);
parameter_json = str_CatFree(parameter_json,"] ,\n");
}
break;
case RAZER_PARAMETER_TYPE_RGB_RANGE:
{
parameter_json = str_CatFree(parameter_json,"[");
struct razer_rgb_range *range = daemon_get_parameter_rgb_range(parameter);
struct razer_rgb *min = range->min;
parameter_json = str_CatFree(parameter_json,"{\n\"R\" : ");
char *min_r_string = str_FromLong(min->r);
parameter_json = str_CatFree(parameter_json,min_r_string);
parameter_json = str_CatFree(parameter_json," ,\n\"G\" : ");
free(min_r_string);
char *min_g_string = str_FromLong(min->g);
parameter_json = str_CatFree(parameter_json,min_g_string);
parameter_json = str_CatFree(parameter_json," ,\n\"B\" : ");
free(min_g_string);
char *min_b_string = str_FromLong(min->b);
parameter_json = str_CatFree(parameter_json,min_b_string);
free(min_b_string);
parameter_json = str_CatFree(parameter_json,"} ,\n");
parameter_json = str_CatFree(parameter_json," ,");
parameter_json = str_CatFree(parameter_json,"{");
struct razer_rgb *max = range->max;
parameter_json = str_CatFree(parameter_json,"{\n\"R\" : ");
char *max_r_string = str_FromLong(max->r);
parameter_json = str_CatFree(parameter_json,max_r_string);
parameter_json = str_CatFree(parameter_json," ,\n\"G\" : ");
free(max_r_string);
char *max_g_string = str_FromLong(max->g);
parameter_json = str_CatFree(parameter_json,max_g_string);
parameter_json = str_CatFree(parameter_json," ,\n\"B\" : ");
free(max_g_string);
char *max_b_string = str_FromLong(max->b);
parameter_json = str_CatFree(parameter_json,max_b_string);
free(max_b_string);
parameter_json = str_CatFree(parameter_json,"} ,\n");
parameter_json = str_CatFree(parameter_json,"] ,\n");
}
break;
case RAZER_PARAMETER_TYPE_POS_RANGE:
{
parameter_json = str_CatFree(parameter_json,"[");
struct razer_pos_range *range = daemon_get_parameter_pos_range(parameter);
struct razer_pos *min = range->min;
parameter_json = str_CatFree(parameter_json,"{\n\"X\" : ");
char *min_x_string = str_FromLong(min->x);
parameter_json = str_CatFree(parameter_json,min_x_string);
parameter_json = str_CatFree(parameter_json," ,\n\"Y\" : ");
free(min_x_string);
char *min_y_string = str_FromLong(min->y);
parameter_json = str_CatFree(parameter_json,min_y_string);
free(min_y_string);
parameter_json = str_CatFree(parameter_json,"} ,\n");
parameter_json = str_CatFree(parameter_json," ,");
parameter_json = str_CatFree(parameter_json,"{");
struct razer_pos *max = range->max;
parameter_json = str_CatFree(parameter_json,"{\n\"X\" : ");
char *max_x_string = str_FromLong(max->x);
parameter_json = str_CatFree(parameter_json,max_x_string);
parameter_json = str_CatFree(parameter_json," ,\n\"Y\" : ");
free(max_x_string);
char *max_y_string = str_FromLong(max->y);
parameter_json = str_CatFree(parameter_json,max_y_string);
free(max_y_string);
parameter_json = str_CatFree(parameter_json,"} ,\n");
parameter_json = str_CatFree(parameter_json,"] ,\n");
}
break;
/*case RAZER_PARAMETER_TYPE_INT_ARRAY:
case RAZER_PARAMETER_TYPE_UINT_ARRAY:
case RAZER_PARAMETER_TYPE_FLOAT_ARRAY:
case RAZER_PARAMETER_TYPE_RGB_ARRAY:
case RAZER_PARAMETER_TYPE_POS_ARRAY:
*/
}
parameter_json = str_CatFree(parameter_json," \"description\": \"");
parameter_json = str_CatFree(parameter_json,parameter->description);
parameter_json = str_CatFree(parameter_json,"\" },\n");
return(parameter_json);
}
char *daemon_parameter_array_to_json(struct razer_parameter *parameter,int array_index)
{
char *parameter_json = str_CreateEmpty();
parameter_json = str_CatFree(parameter_json,"{\n \"item\": \"");
parameter_json = str_CatFree(parameter_json,parameter->key);
parameter_json = str_CatFree(parameter_json,"\",\n");
parameter_json = str_CatFree(parameter_json," \"id\" : ");
char *id_string = str_FromLong(array_index);
parameter_json = str_CatFree(parameter_json,id_string);
parameter_json = str_CatFree(parameter_json," ,\n");
free(id_string);
parameter_json = str_CatFree(parameter_json," \"value\" : ");
struct razer_array_header *header = (struct razer_array_header*)parameter->value;
if(array_index<0 || array_index >= header->size)
{
parameter_json = str_CatFree(parameter_json," null \n},\n");
return(parameter_json);
}
switch(parameter->type)
{
case RAZER_PARAMETER_TYPE_POS_ARRAY:
{
struct razer_pos *pos = ((struct razer_pos_array*)parameter->value)->values[array_index];
parameter_json = str_CatFree(parameter_json,"[");
char *x_string = str_FromLong(pos->x);
parameter_json = str_CatFree(parameter_json,x_string);
parameter_json = str_CatFree(parameter_json," ,");
free(x_string);
char *y_string = str_FromLong(pos->y);
parameter_json = str_CatFree(parameter_json,y_string);
parameter_json = str_CatFree(parameter_json," ,");
free(y_string);
parameter_json = str_CatFree(parameter_json,"] ,\n");
}
break;
case RAZER_PARAMETER_TYPE_UINT_ARRAY:
{
unsigned long value = ((struct razer_uint_array*)parameter->value)->values[array_index];
char *uint_string = str_FromLong(value);
parameter_json = str_CatFree(parameter_json,uint_string);
free(uint_string);
parameter_json = str_CatFree(parameter_json," ,\n");
}
break;
case RAZER_PARAMETER_TYPE_INT_ARRAY:
{
long value = ((struct razer_int_array*)parameter->value)->values[array_index];
char *int_string = str_FromLong(value);
parameter_json = str_CatFree(parameter_json,int_string);
free(int_string);
parameter_json = str_CatFree(parameter_json," ,\n");
}
break;
case RAZER_PARAMETER_TYPE_FLOAT_ARRAY:
{
float value = ((struct razer_float_array*)parameter->value)->values[array_index];
char *float_string = str_FromDouble((double)value);
parameter_json = str_CatFree(parameter_json,float_string);
parameter_json = str_CatFree(parameter_json," ,\n");
free(float_string);
}
break;
case RAZER_PARAMETER_TYPE_RGB_ARRAY:
{
parameter_json = str_CatFree(parameter_json,"[");
struct razer_rgb *color = ((struct razer_rgb_array*)parameter->value)->values[array_index];
char *r_string = str_FromLong(color->r);
parameter_json = str_CatFree(parameter_json,r_string);
parameter_json = str_CatFree(parameter_json," ,");
free(r_string);
char *g_string = str_FromLong(color->g);
parameter_json = str_CatFree(parameter_json,g_string);
parameter_json = str_CatFree(parameter_json," ,");
free(g_string);
char *b_string = str_FromLong(color->b);
parameter_json = str_CatFree(parameter_json,b_string);
free(b_string);
parameter_json = str_CatFree(parameter_json,"] ,\n");
}
break;
}
parameter_json = str_CatFree(parameter_json," },\n");
return(parameter_json);
}
