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; }