void ajout_info_liste(int fd) {
while (lecture("entete_ref") == 1) write(fd,get_message(),size_message());
while (liste_fichiers(".")) {
write(fd,get_message(),size_message());
}
close(fd);
}
static MuMsg*
get_message (MuMsgIter *iter, time_t after)
{
MuMsg *msg;
if (mu_msg_iter_is_done (iter))
return NULL;
msg = mu_msg_iter_get_msg_floating (iter);
if (!msg)
return NULL; /* error */
if (!mu_msg_is_readable (msg)) {
mu_msg_iter_next (iter);
return get_message (iter, after);
}
if (after != 0 && after > mu_msg_get_timestamp (msg)) {
mu_msg_iter_next (iter);
return get_message (iter, after);
}
return msg;
}
creation_message_erreur(char nom[]) {
int fd = creation_fichier_liste("erreur.txt");
set_message("le fichier suivant n'existe pas : "******"\n\n");
write(fd,get_message(),size_message());
ajout_info_liste(fd);
}
static void compute_rseed()
{
int16_t seed = 0;
seed = (get_ambient_light() + measure_voltage()) * get_ambient_light();
srand(seed);
message_out(rand(), rand(), rand());
get_message();
seed += message_rx[0] + message_rx[1] * message_rx[2] + (message_rx[3] << 2);
srand(seed);
message_out(rand(), rand(), rand());
get_message();
seed += message_rx[0] - message_rx[1] * message_rx[2] + (message_rx[3] << 2);
srand(seed);
}
static int
queue_ram_envelope_update(uint64_t evpid, const char *buf, size_t len)
{
struct qr_envelope *evp;
struct qr_message *msg;
void *tmp;
if ((msg = get_message(evpid_to_msgid(evpid))) == NULL)
return (0);
if ((evp = tree_get(&msg->envelopes, evpid)) == NULL) {
log_warn("warn: queue-ram: not found");
return (0);
}
tmp = malloc(len);
if (tmp == NULL) {
log_warn("warn: queue-ram: malloc");
return (0);
}
memmove(tmp, buf, len);
free(evp->buf);
evp->len = len;
evp->buf = tmp;
stat_decrement("queue.ram.envelope.size", evp->len);
stat_increment("queue.ram.envelope.size", len);
return (1);
}
file_dialog::file_dialog(display &disp, const std::string& file_path,
const std::string& title, bool show_directory_buttons) :
gui::dialog(disp, title, file_path, gui::OK_CANCEL),
show_directory_buttons_(show_directory_buttons),
files_list_(NULL),
last_selection_(-1),
last_textbox_text_(),
chosen_file_(".."),
autocomplete_(true)
{
files_list_ = new gui::file_menu(disp.video(), file_path);
const unsigned file_list_height = (disp.h() / 2);
const unsigned file_list_width = std::min<unsigned>(files_list_->width(), (disp.w() / 4));
files_list_->set_measurements(file_list_width, file_list_height);
files_list_->set_max_height(file_list_height);
set_menu(files_list_);
get_message().set_text(format_dirname(files_list_->get_directory()));
set_textbox(_("File: "), format_filename(file_path), 100);
if (show_directory_buttons_)
{
add_button( new gui::dialog_button(disp.video(), _("Delete File"),
gui::button::TYPE_PRESS, gui::DELETE_ITEM), dialog::BUTTON_EXTRA);
add_button( new gui::dialog_button(disp.video(), _("New Folder"),
gui::button::TYPE_PRESS, gui::CREATE_ITEM), dialog::BUTTON_EXTRA_LEFT);
}
}
void py_msg_list_cb (struct tgl_state *TLSR, void *cb_extra, int success, int num, struct tgl_message *M[]) {
assert (TLSR == TLS);
PyObject *callable = cb_extra;
PyObject *arglist = NULL;
PyObject *msgs = NULL;
PyObject *result = NULL;
if(PyCallable_Check(callable)) {
msgs = PyList_New(0);
if (success) {
int i;
for (i = 0; i < num; i++) {
PyList_Append(msgs, get_message (M[i]));
}
}
arglist = Py_BuildValue("(OO)", success ? Py_True : Py_False, msgs);
result = PyEval_CallObject(callable, arglist);
Py_DECREF(arglist);
if(result == NULL)
PyErr_Print();
Py_XDECREF(result);
}
Py_XDECREF(callable);
}
void py_new_msg (struct tgl_message *M) {
if (!python_loaded) {
return;
}
PyObject *msg;
PyObject *arglist, *result;
if(_py_new_msg == NULL) {
logprintf("Callback not set for on_new_msg");
return;
}
msg = get_message (M);
arglist = Py_BuildValue("(O)", msg);
result = PyEval_CallObject(_py_new_msg, arglist);
Py_DECREF(arglist);
if(result == NULL)
PyErr_Print();
else if(PyUnicode_Check(result))
logprintf ("python: %s\n", PyBytes_AsString(PyUnicode_AsASCIIString(result)));
Py_XDECREF(result);
}
static PyObject* python_get_message(PyObject* self, PyObject* args) {
int arg_message_index;
if(PyArg_ParseTuple(args, "i", &arg_message_index) == 0) return NULL;
struct message* retval = get_message(arg_message_index);
return Py_BuildValue("O", py_mapper_message(retval));
}
/* Process an abort from no longer being in 3270 mode. */
static void
ft_in3270(bool ignored _is_unused)
{
if (!IN_3270 && ft_state != FT_NONE) {
ft_complete(get_message("ftNot3270"));
}
}
/* Process a disconnect abort. */
static void
ft_connected(bool ignored _is_unused)
{
if (!CONNECTED && ft_state != FT_NONE) {
ft_complete(get_message("ftDisconnected"));
}
}
void
test_1(UNSIGNED argc, VOID *argv)
{
STATUS status;
int ch;
unsigned char lbuf[2048];
/* Access argc and argv just to avoid compilation warnings. */
status = (STATUS) argc + (STATUS) argv;
for(;;){
if ( ttyE_poll() == 0) {
ch = ttyE_in();
switch(ch){
case 'R':
get_message();
break;
}
}
NU_Sleep(10);
#if 0
status = nflash_read_page(lbuf, 0);
#endif
}
}
static void on_receive (int socket_fd)
{
printf ("enter on receive...\n");
struct message msg;
while (1)
{
ssize_t len = get_message (socket_fd, &msg);
if (len < 0)
{
break;
}
/* 用户掉线或者主动退出游戏 */
else if (len == 0)
{
user_offline (socket_fd);
break;
}
else
{
services[msg.type] (socket_fd, &msg);
}
}
printf ("exit on receive...\n");
}
/*!
* Send socket port that matches dpi_id to client
*/
void send_sockport(int sock_fd, char *dpi_tag, struct dp *dpi_attr_list)
{
int i;
char *dpi_id, *d_cmd, port_str[16];
struct service *serv;
dReturn_if_fail((dpi_id = get_message(sock_fd, dpi_tag)) != NULL);
serv = dList_find_custom(services_list,dpi_id,(dCompareFunc)service_match);
if (serv == NULL || (i = serv->dp_index) == -1)
for (i = 0; i < numdpis; i++)
if (!strncmp(dpi_attr_list[i].id, dpi_id,
dpi_attr_list[i].id - strchr(dpi_attr_list[i].id, '.')))
break;
if (i < numdpis) {
/* found */
snprintf(port_str, 8, "%d", dpi_attr_list[i].port);
d_cmd = a_Dpip_build_cmd("cmd=%s msg=%s", "send_data", port_str);
(void) CKD_WRITE(sock_fd, d_cmd);
dFree(d_cmd);
}
dFree(dpi_id);
}
void make_udp_action(int sock_fd, struct sockaddr_in from, int fromlen){
printf("UDP request received\n");
char* message = get_message();
n = sendto(sock_fd, message, strlen(message), 0, (struct sockaddr *)&from, fromlen);
if (n < 0)
error("ERROR sendto");
}
void clear_all_message(play_para_t *para)
{
player_cmd_t *cmd;
while ((cmd = get_message(para)) != NULL) {
message_free(cmd);
}
}
Monitor::DisplayType PowerBookMonitor::poll() {
Monitor::DisplayType rc = None;
struct pbb_message msg;
if (_serverPort < 0 || _clientPort < 0)
return Error;
// Drain the queue, send the last message
while (0 == get_message(_clientPort, 0, &msg)) {
switch (msg.code) {
case DISPLAYVOLUME:
rc = Monitor::Volume;
_progress = msg.value;
break;
case DISPLAYMUTE:
rc = Monitor::Mute;
_progress = msg.value;
break;
case DISPLAYBRIGHTNESS:
rc = Monitor::Brightness;
_progress = msg.value*100/15;
break;
case REGFAILED:
case CLIENTEXIT:
rc = Monitor::Error;
break;
default:
break;
}
}
return rc;
}
void be_client(char *ip, int port)
{
t_socket sock;
fd_set rdfs;
char *ask;
char *prompt;
sock = init_connection(ip, port);
while (1)
{
init_socks(sock, &rdfs);
if (FD_ISSET(STDIN_FILENO, &rdfs))
client_in(sock);
else if (FD_ISSET(sock, &rdfs))
{
client_out(sock);
ask = ft_strdup("/gp\n");
ft_send(sock, ask);
free(ask);
prompt = get_message(sock);
ft_putstr("\n");
ft_putstr(prompt);
free(prompt);
}
}
}
void parser_exception::to_stream(std::ostream& out) const {
out << "Parse error: ";
if (d_line != -1) {
out << get_filename() << ":" << get_line() << ":" << get_position() << ": ";
}
out << get_message();
}
void py_msg_cb (struct tgl_state *TLSR, void *cb_extra, int success, struct tgl_message *M) {
assert (TLSR == TLS);
PyObject *callable = cb_extra;
PyObject *arglist = NULL;
PyObject *msg = NULL;
PyObject *result = NULL;
if(PyCallable_Check(callable)) {
if (success && M && (M->flags & TGLMF_CREATED)) {
msg = get_message(M);
} else {
Py_INCREF(Py_None);
msg = Py_None;
}
arglist = Py_BuildValue("(OO)", success ? Py_True : Py_False, msg);
result = PyEval_CallObject(callable, arglist);
Py_DECREF(arglist);
if(result == NULL)
PyErr_Print();
Py_XDECREF(result);
}
Py_XDECREF(callable);
}
void RecordChannel::push_frame(uint8_t *frame)
{
RecordSamplesMessage *message;
ASSERT(_frame_bytes == FRAME_SIZE * 4);
if (!(message = get_message())) {
DBG(0, "blocked");
return;
}
uint8_t celt_buf[CELT_COMPRESSED_FRAME_BYTES];
int n;
if (_mode == SPICE_AUDIO_DATA_MODE_CELT_0_5_1) {
n = celt051_encode(_celt_encoder, (celt_int16_t *)frame, NULL, celt_buf,
CELT_COMPRESSED_FRAME_BYTES);
if (n < 0) {
THROW("celt encode failed");
}
frame = celt_buf;
} else {
n = _frame_bytes;
}
RedPeer::OutMessage& peer_message = message->peer_message();
peer_message.reset(SPICE_MSGC_RECORD_DATA);
SpiceMsgcRecordPacket packet;
packet.time = get_mm_time();
_marshallers->msgc_record_data(peer_message.marshaller(), &packet);
spice_marshaller_add(peer_message.marshaller(), frame, n);
post_message(message);
}
int list_properties(DBusConnection *connection, char *function,
char *service_name)
{
DBusMessage *message;
message = get_message(connection, function);
if (message == NULL)
return -ENOMEM;
if (strcmp(function, "GetProperties") == 0)
extract_manager_properties(message);
else if (strcmp(function, "GetServices") == 0 && service_name != NULL)
extract_services(message, service_name);
else if (strcmp(function, "GetServices") == 0 && service_name == NULL)
get_services(message);
else if (strcmp(function, "GetTechnologies") == 0)
extract_tech(message);
dbus_message_unref(message);
return 0;
}
//c'est le vrai main. le coeur du service
void lancement_service(int ta_socket) {
int n;
int choix;
choix = 1;
char mMessage[TLIM] = "";
char reponse[TLIM] = "";
char nom[TLIM] = "";
if ((n=read(ta_socket, nom, TLIM-1))>0);
else strcpy(nom,"sombre inconnu");
liste_referentiel(ta_socket);
while (choix) {
n = lecture_s(ta_socket);
if (sscanf(get_message(),"%s",mMessage)>0) {
while ((n=lecture(mMessage))==1) {
ecriture_s(ta_socket);
}
if (n<0) {
creation_message_erreur(mMessage);
diffusion_erreur(ta_socket);
//while (lecture("erreur.txt") == 1) ecriture_s(ta_socket);
}
}
if (!strcmp(mMessage,"q") || !strcmp(mMessage,"Q")) {
choix = 0;
quitter(ta_socket);
}
}
}
static int
queue_ram_envelope_create(uint32_t msgid, const char *buf, size_t len,
uint64_t *evpid)
{
struct qr_envelope *evp;
struct qr_message *msg;
if ((msg = get_message(msgid)) == NULL)
return (0);
do {
*evpid = queue_generate_evpid(msgid);
} while (tree_check(&msg->envelopes, *evpid));
evp = calloc(1, sizeof *evp);
if (evp == NULL) {
log_warn("warn: queue-ram: calloc");
return (0);
}
evp->len = len;
evp->buf = malloc(len);
if (evp->buf == NULL) {
log_warn("warn: queue-ram: malloc");
free(evp);
return (0);
}
memmove(evp->buf, buf, len);
tree_xset(&msg->envelopes, *evpid, evp);
stat_increment("queue.ram.envelope.size", len);
return (1);
}
void on_receive (int fd)
{
struct message msg;
while (1)
{
ssize_t len = get_message (&msg);
if (len < 0)
{
break;
}
else if (len == 0)
{
show_message_dialog (GTK_MESSAGE_ERROR, "服务器掉线了\n");
exit (-1);
}
else
{
g_print ("on_recive: msgtype = %d\n",msg.type);
gdk_threads_enter ();
services[msg.type] (fd, &msg);
gdk_threads_leave ();
}
}
}
/**************************************************************************
...
**************************************************************************/
static void meswin_row_activated_callback(GtkTreeView *view,
GtkTreePath *path,
GtkTreeViewColumn *col,
gpointer data)
{
struct message *pmsg;
GtkTreeModel *model;
GtkTreeIter iter;
gint row;
model = gtk_tree_view_get_model(view);
if (!gtk_tree_model_get_iter(model, &iter, path)) {
return;
}
gtk_tree_model_get(model, &iter, 2, &row, -1);
pmsg = get_message(row);
meswin_double_click(row);
meswin_set_visited(&iter, TRUE);
gui_dialog_set_response_sensitive(meswin_shell, CMD_GOTO,
pmsg->location_ok);
gui_dialog_set_response_sensitive(meswin_shell, CMD_POPCITY,
pmsg->city_ok);
}
DLL_EXPORT int Iterate(void *client, int max_messages) {
CConceptClient *CC = (CConceptClient *)client;
if (CC) {
int messages = 0;
TParameters PARAM;
CC->SendPending();
while ((max_messages) && (!CC->IsEOF())) {
PARAM.Owner = CC;
PARAM.UserData = 0;
PARAM.Flags = 0;
int res = get_message(CC, &PARAM, (PROGRESS_API)CC->notify);
if (res == -2)
return messages;
if (res <= 0)
return -1;
if (CC->NON_OPAQUE_CONCEPT_CALLBACK)
CC->NON_OPAQUE_CONCEPT_CALLBACK(&PARAM);
else
if (CC->CONCEPT_CALLBACK)
CC->CONCEPT_CALLBACK(client, PARAM.Sender.c_str(), PARAM.Sender.Length(), PARAM.ID, PARAM.Target.c_str(), PARAM.Target.Length(), PARAM.Value.c_str(), PARAM.Value.Length());
CC->SendPending();
messages++;
max_messages--;
}
return messages;
}
return -1;
}
int main(int argc, char *argv[])
{
char *msg;
size_t msglen;
int operation;
switch (argc) {
case 1:
operation = OP_COMPRESS;
break;
case 2:
if (strcmp(argv[1], "-d") == 0) {
operation = OP_DECOMPRESS;
break;
}
default:
err_use(argv[0]);
}
msglen = get_message(&msg);
if (operation == OP_COMPRESS)
b64pack_compress(msg, &msglen);
else
b64pack_decompress(msg, &msglen);
put_message(msg, msglen);
exit(EXIT_SUCCESS);
}
cat >main.cpp <<EOF
#include "message.h"
#include <iostream>
int main()
{
std::cout << get_message() << std::endl;
}
void dy_despatch_thread(jd_var *arg) {
dy_info("Starting despatcher");
for (;;) scope {
JD_VAR(msg);
get_message(msg);
dy_despatch_message(msg);
}
}