void message_ignore_unknown(struct stream_s *stream,const char *from, const char *to,
const char *args, xmlnode msg){
Session *session;
User *user;
gboolean on;
session=session_get_by_jid(from,stream,0);
if (session!=NULL)
user=session->user;
else
user=user_get_by_jid(from);
if (args && g_strcasecmp(args,"on")==0) on=TRUE;
else if (args && g_strcasecmp(args,"off")==0) on=FALSE;
else on=!user->ignore_unknown;
if (user->ignore_unknown==on){
message_send(stream,to,from,1,_("No change."),0);
return;
}
user->ignore_unknown=on;
if (on)
message_send(stream,to,from,1,_("ignore unknown: on"),0);
else
message_send(stream,to,from,1,_("ignore unknown: off"),0);
if (session!=NULL) session_send_status(session);
user_save(user);
}
int parse_request(client * c, cmd_table * table)
{
unsigned char buffer[MAX_PACKET_SIZE] = {0};
int nb_read;
int ok;
nb_read = packet_read(c->socket_tcp, buffer, MAX_PACKET_SIZE);
if (nb_read <= 0)
{
trace(DBG_CONN, "Connection closed: read error.\n");
return 0;
}
ok = parse_table(table, c, buffer);
switch (ok)
{
case 3: return 0;
case 2: break;
case 1: message_send(c->socket_tcp, PACKET_MSG_ACK, 1); break;
case 0: message_send(c->socket_tcp, PACKET_MSG_NACK, 1); break;
case -1: message_send(c->socket_tcp, PACKET_MSG_ERROR, 1); break;
}
trace(DBG_RQST, "Request status: %d (read %d bytes).\n", ok, nb_read);
return 1;
}
/**
* @brief Terminate server
*
* At first all logged users are logged out (commands to quit clients are included). Then frees all used memory, deletes all used files and terminates server.
*/
void server_quit(){
for(int i=0; i<SERVER_CAPACITY; i++){
// is here is logged user
if(users_logged[i]){
//send message to him
message_send(users_logged[i],"Server terminated\n");
message_send(users_logged[i],"Logged out.");
//free used memory for him
free(users_logged[i]->username);
free(users_logged[i]->password);
free(users_logged[i]);
users_logged[i]=NULL;
}
}
//wait for deliver all messages
sleep(1);
//destroy named pipe
if(in)
fclose(in);
unlink(inPipe);
remove(serverLock);
//exit program
exit(0);
}
void message_invisible(struct stream_s *stream,const char *from, const char *to,
const char *args, xmlnode msg){
Session *session;
User *user;
Resource *r;
gboolean on;
session=session_get_by_jid(from,stream,0);
if (session!=NULL)
user=session->user;
else
user=user_get_by_jid(from);
if (args && g_strcasecmp(args,"on")==0) on=TRUE;
else if (args && g_strcasecmp(args,"off")==0) on=FALSE;
else on=!user->invisible;
if (user->invisible==on){
message_send(stream,to,from,1,_("No change."),0);
return;
}
user->invisible=on;
if (on)
message_send(stream,to,from,1,_("invisible: on"),0);
else
message_send(stream,to,from,1,_("invisible: off"),0);
if (session!=NULL) session_send_status(session);
r=session_get_cur_resource(session);
if ( r )
presence_send(stream,NULL,user->jid,user->invisible?-1:r->available,r->show,session->gg_status_descr,0);
user_save(user);
}
void message_get_roster(struct stream_s *stream,const char *from, const char *to,
const char *args, xmlnode msg){
Session *s;
s=session_get_by_jid(from,stream,0);
if(!s || !s->ggs){
message_send(stream,to,from,1,_("Log in first..."),0);
return;
}
message_send(stream,to,from,1,_("Receiving roster..."),0);
gg_userlist_request(s->ggs, GG_USERLIST_GET, NULL);
}
/*******************************************************************************
Name : STDVMi_EventTerm()
Description : Terminates STDVM event notification task
Parameters : BOOL ForceTerminate
Return Value :
*******************************************************************************/
ST_ErrorCode_t STDVMi_EventTerm(ST_DeviceName_t DVMDeviceName,
ST_DeviceName_t PRMDeviceName,
ST_DeviceName_t MP3PBDeviceName,
BOOL ForceTerminate)
{
ST_ErrorCode_t ErrorCode;
STDVMi_Event_t *Event_p;
ErrorCode = STDVMi_UnRegisterAndUnSubscribeEvents(DVMDeviceName, PRMDeviceName, MP3PBDeviceName);
if(ErrorCode != ST_NO_ERROR)
{
STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "STDVMi_UnRegisterAndUnSubscribeEvents()=%08X\n", ErrorCode));
return ErrorCode;
}
Event_p = (STDVMi_Event_t *)message_claim(STDVMi_EventTaskMQ_p);
STDVMi_EventTaskState = TASK_STOPPED;
message_send(STDVMi_EventTaskMQ_p, Event_p);
task_wait(&STDVMi_EventTask_p, 1, TIMEOUT_INFINITY);
if(task_delete(STDVMi_EventTask_p) != 0 )
{
STTBX_Report((STTBX_REPORT_LEVEL_ERROR, "task_delete failed\n"));
return ST_ERROR_BAD_PARAMETER;
}
message_delete_queue(STDVMi_EventTaskMQ_p);
return ST_NO_ERROR;
}
static void *
juggling_thread(void *arg)
{
int fd2, i, j;
fd2 = *(int *)arg;
if (pthread_mutex_lock(&threaded_mtx) != 0)
err(-1, "juggling_thread: pthread_mutex_lock");
threaded_child_ready = 1;
if (pthread_cond_signal(&threaded_cond) != 0)
err(-1, "juggling_thread: pthread_cond_signal");
if (pthread_mutex_unlock(&threaded_mtx) != 0)
err(-1, "juggling_thread: pthread_mutex_unlock");
for (i = 0; i < NUMCYCLES; i++) {
for (j = 0; j < threaded_pipeline; j++) {
if (message_recv(fd2) < 0)
err(-1, "message_recv fd2");
if (message_send(fd2) < 0)
err(-1, "message_send fd2");
}
}
return (NULL);
}
/** Analyse user requests from stdin
* @return 0 if no request is done, 1 otherwise
*/
int user_request(lsocket**sockets){
char message[SIZE_BUFFER];
lpacket*pck;
/* Read user imput */
printf("Awaiting request > ");
fgets(message,SIZE_BUFFER,stdin);
/* Process request */
if (strlen(message)<2) {printf("No requests sent, shutting down...\n"); return 0;}
/* Exchange message with the server */
message_send(sockets[1],msg_text,message);
pck=packet_receive(sockets[0]);
if (pck->type>msg_errors) {
printf("[Server] Error (%d): %s\n",pck->type,pck->message);
self_terminate();
}
if (pck->type>msg_errors) {
printf("[Server] Warning (%d): %s\n",pck->type,pck->message);
return -1;
}
/* Display it */
printf("The server answered: %s\n",pck->message);
return 1;
}
static void person_process(int id) {
init_random();
char buf[4096];
struct lift_msg * reply;
struct lift_msg m;
m.person_id = id;
int len;
//printf("Created person with id %d\n", m.person_id);
while(1) {
// TODO:
// Generate a to and from floor
// Send a LIFT_TRAVEL message to the lift process
// Wait for a LIFT_TRAVEL_DONE message
// Wait a little while
//printf("Morning! This is number %d speaking.\n", id);
m.from_floor = get_random_value(id, N_FLOORS - 1);
do {
m.to_floor = get_random_value(id, N_FLOORS - 1);
} while(m.from_floor == m.to_floor);
//printf("Person %d wants to go to floor %d\n", m.person_id, m.to_floor);
m.type = LIFT_TRAVEL;
message_send((char *) &m, sizeof(m), QUEUE_LIFT, 0);
do {
len = message_receive(buf, 4096, QUEUE_FIRSTPERSON + id); // Wait for a message
if(len < sizeof(struct lift_msg)) {
fprintf(stderr, "Message too short\n");
continue;
}
reply = ((struct lift_msg*) buf);
} while(reply->type != LIFT_TRAVEL_DONE);
//printf("Going to sleep. Number %d\n", id);
usleep(1000000);
}
}
void message_unignore(struct stream_s *stream,const char *from, const char *to,
const char *args, xmlnode msg){
Session *session;
User *user;
uin_t uin;
Contact *c;
gchar *m;
session=session_get_by_jid(from,stream,0);
if (session!=NULL)
user=session->user;
else
user=user_get_by_jid(from);
if (args && *args) uin=atoi(args);
else uin=0;
if (uin<=0) {
message_ignore(stream,from,to,NULL,msg);
return;
}
c=user_get_contact(user,uin,FALSE);
if (c) {
c->ignored=FALSE;
user_check_contact(user,c);
if (session) session_update_contact(session,c);
}
m=g_strdup_printf(_("\nMessages from GG number %li will NOT be ignored."),(long)uin);
message_send(stream,to,from,1,m,0);
g_free(m);
user_save(user);
}
int cdfs_getinfo_request(unsigned short seq,unsigned short devid)
{
int rc;
union cdfs_msg msg;
if(cdfs_queid==0) {
rc=cdfs_init();
if(rc<0)
return rc;
}
msg.h.size=sizeof(struct cdfs_req_getinfo);
msg.h.service=CDFS_SRV_CDFS;
msg.h.command=CDFS_CMD_GETINFO;
msg.h.arg=environment_getqueid();
msg.getinfo.req.seq=seq;
msg.getinfo.req.devid=devid;
/*
int2dec(msg.req.queid,s);
display_puts(s);
*/
rc=message_send(cdfs_queid, &msg);
if(rc<0) {
display_puts("getcode sndcmd=");
int2dec(-rc,s);
display_puts(s);
display_puts("\n");
return rc;
}
return 0;
}
int cdfs_stat_request(unsigned short seq,int handle)
{
int rc;
union cdfs_msg msg;
if(cdfs_queid==0) {
rc=cdfs_init();
if(rc<0)
return rc;
}
msg.h.size=sizeof(struct cdfs_req_readdir);
msg.h.service=CDFS_SRV_CDFS;
msg.h.command=CDFS_CMD_STAT;
msg.h.arg=environment_getqueid();
msg.stat.req.seq=seq;
msg.stat.req.handle=handle;
/*
int2dec(msg.req.queid,s);
display_puts(s);
*/
rc=message_send(cdfs_queid, &msg);
if(rc<0) {
display_puts("cdfs_stat sndcmd=");
int2dec(-rc,s);
display_puts(s);
display_puts("\n");
return rc;
}
return 0;
}
void dolines(PGresult *pgr, char format)
{
int i, j, ncol = 0, nrow = 0;
string *str;
char *s;
nrow = PQntuples(pgr);
ncol = PQnfields(pgr);
str = new_string();
for(i=0;i<nrow;i++)
{
for(j=0;j<ncol;j++)
{
s = PQgetvalue(pgr, i, j);
dolitem(str, s, (j == ncol - 1), format);
}
string_cat_c(str, '\n');
if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;
string_clear(str);
}
string_delete(str);
return;
}
void dolines(MYSQL_RES *res, char format)
{
int j;
unsigned int ncol = 0;
string *str;
char *s;
MYSQL_ROW row;
ncol = mysql_num_fields(res);
str = new_string();
while((row = mysql_fetch_row(res)) != NULL)
{
for(j=0;j<ncol;j++)
{
s = row[j];
dolitem(str, s, (j == ncol - 1), format);
}
string_cat_c(str, '\n');
if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;
string_clear(str);
}
string_delete(str);
return;
}
void message_status(struct stream_s *stream,const char *from, const char *to,
const char *args, xmlnode msg){
Session *session;
User *user;
char *m;
session=session_get_by_jid(from,stream,0);
if (session!=NULL)
user=session->user;
else
user=user_get_by_jid(from);
g_free(user->status);
if (args) {
if (!g_strcasecmp(args,"off")) user->status=NULL;
else user->status=g_strndup(string_to_gg(args),GG_STATUS_DESCR_MAXSIZE);
}
else user->status=NULL;
m=g_strdup_printf(_("status: %s%s%s"),
(user->status?"`":""),
(user->status?string_from_gg(user->status):_("not set")),
(user->status?"'":""));
message_send(stream,to,from,1,m,0);
g_free(m);
if (session!=NULL) session_send_status(session);
user_save(user);
}
int main( void ) {
Status status;
Pid pid;
char *message = "This is the test message.";
status = fork( &pid );
if ( status == SUCCESS ) {
if ( pid > 0) { //in parent
sleep(2); //sleep for two seconds
status = message_send( pid, message, 26 );
if ( status == SUCCESS ) {
writef( "User messages_test(Parent) message_send status SUCCESS\n", status);
} else {
writef( "User messages_test(Parent) message_send status FAILED(%d)\n", status);
exit();
}
} else { //in child
char *receivedMessage;
Uint32 size;
Pid fromPid;
//sleep(2);
writef( "User messages_test(Child) waiting for message\n");
status = message_receive( &fromPid, (void**) &receivedMessage, &size );
if ( status == SUCCESS ) {
writef( "User messages_test(Child) received from %d of size %d: %s\n", fromPid, size, receivedMessage );
} else {
writef( "User messages_test(Child) message_receive status FAILED(%d)\n", status);
exit();
}
}
} else {
writef( "User messages_test fork status FAILED(%d)\n", status);
}
}
int display_putc(int chr)
{
struct msg_head msg;
int r;
if(display_queid==0) {
r=display_init();
if(r<0)
return r;
}
msg.size=sizeof(struct msg_head);
msg.service=DISPLAY_SRV_DISPLAY;
msg.command=DISPLAY_CMD_PUTC;
msg.arg=chr;
for(;;) {
r=message_send(display_queid, &msg);
if(r!=ERRNO_OVER)
break;
syscall_wait(10);
}
if(r<0) {
syscall_puts("putc sndcmd=");
long2hex(-r,s);
syscall_puts(s);
syscall_puts("\n");
return r;
}
return 0;
}
int main(void)
{
tid_t tid;
size_t i, n;
if (!metal_init(0))
return 1;
if (!metal_task_new(&tid, "hello", 0, hellofn))
die("Could not create task.\n");
if (!metal_task_start(tid))
die("Could not start task\n");
usleep(1500);
n = 100;
for (i = 0; i < n; i++) {
if (!message_send(0, tid, MM_MY_MESSAGE, 0, 0))
die("Could not send message to task\n");
usleep(1000);
}
usleep(1000);
// Stop the task in a civilized way
if (!metal_task_stop(tid))
die("Could not stop task");
if (!metal_exit())
return 1;
return 0;
}
void dolines(SQLHSTMT *stmt, SQLSMALLINT ncol, char format)
{
int j;
long ans;
string *str, *tstr;
char istr[256];
long sb = 0;
SQLLEN si;
str = new_string();
tstr = new_string();
for(;;)
{
ans = SQLFetch(*stmt);
/*
* I assume error here is EOF...
*/
if((ans != SQL_SUCCESS) && ( ans != SQL_SUCCESS_WITH_INFO))
break;
for(j=0;j<ncol;j++)
{
si = 0;
for(;;)
{
ans = SQLGetData(stmt, j+1, SQL_C_CHAR, istr, 256, &si);
if(ans == SQL_NO_DATA) break;
if(si == SQL_NO_TOTAL)
{
sb += 255;
}
else
{
sb += si;
}
string_cat(tstr, istr);
if(si != SQL_NO_TOTAL) break;
}
dolitem(str, string_s(tstr), (j == ncol - 1), format);
string_clear(tstr);
}
string_cat_c(str, '\n');
if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;
string_clear(str);
}
string_delete(str);
string_delete(tstr);
return;
}
static void liftmove_process(void) {
struct lift_msg m;
m.type = LIFT_MOVE;
while(1) {
usleep(1000000);
message_send((char *) &m, sizeof(m), QUEUE_LIFT, 0);
}
}
/** Send a message through a socket specifiying a different destination for one connection.
* @param dest The socket to send through
* @param sender_socket The sender's socket
* @param type_message The type of the message (msg_type definitions are pretty clear)
* @param msg The message itself
* Note that this function only makes sense on SOCK_DGRAM mode.
*/
int message_send_to(lsocket*sender_socket,msg_type type_message,char*msg,lsocket*dest){
lsocket*old_d;
switch (sender_socket->mode){
case SOCK_DGRAM:
old_d=sender_socket->sendto;
connect_lsocket(sender_socket,dest);
message_send(sender_socket,type_message,msg);
connect_lsocket(sender_socket,old_d);
return lpacket_snd_bytes;
case SOCK_STREAM:
message_send(sender_socket,type_message,msg);
return lpacket_snd_bytes;
default:
OUT("Unhandled mode");
break;
}
}
bool ICACHE_FLASH_ATTR
handle_observe_notify(lwm2m_context_t * contextP,
void * fromSessionH,
coap_packet_t * message,
coap_packet_t * response)
{
uint8_t * tokenP;
int token_len;
uint16_t clientID;
uint16_t obsID;
lwm2m_client_t * clientP;
lwm2m_observation_t * observationP;
uint32_t count;
token_len = coap_get_header_token(message, (const uint8_t **)&tokenP);
if (token_len != sizeof(uint32_t)) return false;
if (1 != coap_get_header_observe(message, &count)) return false;
clientID = (tokenP[0] << 8) | tokenP[1];
obsID = (tokenP[2] << 8) | tokenP[3];
clientP = (lwm2m_client_t *)lwm2m_list_find((lwm2m_list_t *)contextP->clientList, clientID);
if (clientP == NULL) return false;
observationP = (lwm2m_observation_t *)lwm2m_list_find((lwm2m_list_t *)clientP->observationList, obsID);
if (observationP == NULL)
{
coap_init_message(response, COAP_TYPE_RST, 0, message->mid);
message_send(contextP, response, fromSessionH);
}
else
{
if (message->type == COAP_TYPE_CON ) {
coap_init_message(response, COAP_TYPE_ACK, 0, message->mid);
message_send(contextP, response, fromSessionH);
}
observationP->callback(clientID,
&observationP->uri,
(int)count,
message->content_type, message->payload, message->payload_len,
observationP->userData);
}
return true;
}
static void liftmove_process(void) {
struct lift_msg m;
m.type = LIFT_MOVE;
while(1) {
//usleep(200000);
//printf("Move msg sent\n");
message_send((char *) &m, sizeof(m), QUEUE_LIFT, 0);
}
}
/*
* Envia uma mensagem (ja convertida para JSON) para
* todos os contatos da lista de amigos
*/
void broadcast_send(char *message)
{
contact * current; // Utilizado para iterar pela lista de contatos
// Itera pela lista de contatos
for(current = contactList; current!=NULL; current = current->next){
if(current->status == STATUS_ALIVE) // Se o contato estiver online
message_send(current, message); // Envia a mensagem
}
}
static GLOBAL_FUNC(cmd_notice)
{
struct globalMessage *message = NULL;
const char *recipient = NULL, *text;
char *sender;
long target = 0;
assert(argc >= 3);
sender = user->handle_info->handle;
if(!irccasecmp(argv[1], "all")) {
target = MESSAGE_RECIPIENT_ALL;
} else if(!irccasecmp(argv[1], "users")) {
target = MESSAGE_RECIPIENT_LUSERS;
} else if(!irccasecmp(argv[1], "authed")) {
target = MESSAGE_RECIPIENT_AUTHED;
} else if(!irccasecmp(argv[1], "helpers")) {
target = MESSAGE_RECIPIENT_HELPERS;
} else if(!irccasecmp(argv[1], "opers")) {
target = MESSAGE_RECIPIENT_OPERS;
} else if(!irccasecmp(argv[1], "staff") || !irccasecmp(argv[1], "privileged")) {
target |= MESSAGE_RECIPIENT_HELPERS | MESSAGE_RECIPIENT_OPERS;
} else if(!irccasecmp(argv[1], "announcement") || !irccasecmp(argv[1], "announce")) {
target |= MESSAGE_RECIPIENT_ANNOUNCE;
} else if(!irccasecmp(argv[1], "channels")) {
target = MESSAGE_RECIPIENT_CHANNELS;
} else if(!irccasecmp(argv[1], "rchannels")) {
target = MESSAGE_RECIPIENT_RCHANNELS;
} else {
global_notice(user, "GMSG_INVALID_TARGET", argv[1]);
return 0;
}
if(!irccasecmp(argv[2], "from")) {
if (argc < 5) {
reply("MSG_MISSING_PARAMS", argv[0]);
GLOBAL_SYNTAX();
return 0;
}
sender = argv[3];
text = unsplit_string(argv + 4, argc - 4, NULL);
} else {
text = unsplit_string(argv + 2, argc - 2, NULL);
}
message = message_add(target | MESSAGE_OPTION_IMMEDIATE, now, 0, sender, text);
if(!message)
return 0;
recipient = messageType(message);
message_send(message);
message_del(message);
global_notice(user, "GMSG_MESSAGE_SENT", recipient);
return 1;
}
/* dispatch new events */
void message_dispatch() {
message_t *m;
/* no messages? */
if (message_first==NULL) return;
m = yx->lremfirst((void **)&message_first);
if (m!=NULL) {
message_send(m->window,m->id,m->param1,m->param2);
message_destroy(m);
}
}
static void liftmove_process(void)
{
struct lift_msg m;
while(1){
// TODO:
// Sleep 2 seconds
// Send a message to the lift process to move the lift.
//usleep(200000);
m.type = LIFT_MOVE;
message_send(&m, sizeof(struct lift_msg), QUEUE_LIFT, 0);
}
}
void MyWarningHandler(String errmsg)
{
message_t reply = message_new(next_serial++);
message_add_packet(reply);
fprintf(stderr,"Warning: %s\n",errmsg);
fflush(stderr);
message_put_dblword(reply,WARNING_REPLY);
message_write_string(reply,errmsg,string_tag);
message_send(client_socket,reply);
message_free(reply);
}
void message_ignore(struct stream_s *stream,const char *from, const char *to,
const char *args, xmlnode msg){
Session *session;
User *user;
uin_t uin;
Contact *c;
gchar *m;
session=session_get_by_jid(from,stream,0);
if (session!=NULL)
user=session->user;
else
user=user_get_by_jid(from);
if (args && *args) uin=atoi(args);
else uin=0;
if (uin<=0) {
GList *it;
m=g_strdup(_("\nMessages from the following GG numbers will be ignored:"));
for(it=user->contacts;it;it=it->next){
c=(Contact *)it->data;
if (!c->ignored) continue;
m=g_strdup_printf(_("%s\n %li"),m,(long)c->uin);
}
message_send(stream,to,from,1,m,0);
g_free(m);
return;
}
c=user_get_contact(user,uin,TRUE);
c->ignored=TRUE;
if (session) session_update_contact(session,c);
m=g_strdup_printf(_("\nMessages from GG number %li will be ignored."),(long)uin);
message_send(stream,to,from,1,m,0);
g_free(m);
user_save(user);
}
void zmq_positive(long long tracking_ID,int positive_point){
zmq::context_t context(1);
zmq::socket_t sender(context,ZMQ_PUSH);
sender.connect("tcp://133.19.23.205:5733");
req.trackingID = tracking_ID;
req.positive_point = positive_point;
msgpack::sbuffer sbuf;
msgpack::pack(&sbuf,req);
zmq::message_t message_send(sbuf.size());
memcpy(message_send.data(),sbuf.data(),sbuf.size());
sender.send(message_send);
cout << "okzmq_pos" << endl;
}
