void RedClient::handle_init(RedPeer::InMessage* message)
{
SpiceMsgMainInit *init = (SpiceMsgMainInit *)message->data();
LOG_INFO("");
_connection_id = init->session_id;
set_mm_time(init->multi_media_time);
if (!_during_migration) {
calc_pixmap_cach_and_glz_window_size(init->display_channels_hint, init->ram_hint);
}
set_mouse_mode(init->supported_mouse_modes, init->current_mouse_mode);
_agent_tokens = init->agent_tokens;
_agent_connected = !!init->agent_connected;
if (_agent_connected) {
Message* msg = new Message(SPICE_MSGC_MAIN_AGENT_START);
SpiceMsgcMainAgentStart agent_start;
agent_start.num_tokens = ~0;
_marshallers->msgc_main_agent_start(msg->marshaller(), &agent_start);
post_message(msg);
send_agent_announce_capabilities(true);
}
if (!_during_migration) {
if (!init_guest_display()) {
send_main_attach_channels();
}
} else {
LOG_INFO("connecting all channels after migration");
Channels::iterator iter = _channels.begin();
for (; iter != _channels.end(); ++iter) {
(*iter)->connect_migration_target();
}
_during_migration = false;
}
}
void RedChannel::handle_ping(RedPeer::InMessage* message)
{
SpiceMsgPing *ping = (SpiceMsgPing *)message->data();
Message *pong = new Message(SPICE_MSGC_PONG);
_marshallers->msgc_pong(pong->marshaller(), ping);
post_message(pong);
}
void RedClient::set_mouse_mode(uint32_t supported_modes, uint32_t current_mode)
{
if (current_mode != _mouse_mode) {
_mouse_mode = current_mode;
Lock lock(_channels_lock);
Channels::iterator iter = _channels.begin();
for (; iter != _channels.end(); ++iter) {
if ((*iter)->get_type() == SPICE_CHANNEL_CURSOR) {
((CursorChannel *)(*iter))->on_mouse_mode_change();
}
}
AutoRef<MouseModeEvent> event(new MouseModeEvent(*this));
push_event(*event);
}
// FIXME: use configured mouse mode (currently, use client mouse mode if supported by server)
if ((supported_modes & SPICE_MOUSE_MODE_CLIENT) && (current_mode != SPICE_MOUSE_MODE_CLIENT)) {
Message* message = new Message(SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST);
SpiceMsgcMainMouseModeRequest mouse_mode_request;
mouse_mode_request.mode = SPICE_MOUSE_MODE_CLIENT;
_marshallers->msgc_main_mouse_mode_request(message->marshaller(),
&mouse_mode_request);
post_message(message);
}
}
void RedChannel::on_message_recived()
{
if (_message_ack_count && !--_message_ack_count) {
post_message(new Message(SPICE_MSGC_ACK));
_message_ack_count = _message_ack_window;
}
}
void RedClient::send_agent_announce_capabilities(bool request)
{
Message* message = new Message(SPICE_MSGC_MAIN_AGENT_DATA);
VDAgentMessage* msg = (VDAgentMessage*)
spice_marshaller_reserve_space(message->marshaller(),
sizeof(VDAgentMessage));
VDAgentAnnounceCapabilities* caps;
msg->protocol = VD_AGENT_PROTOCOL;
msg->type = VD_AGENT_ANNOUNCE_CAPABILITIES;
msg->opaque = 0;
msg->size = sizeof(VDAgentAnnounceCapabilities) + VD_AGENT_CAPS_BYTES;
caps = (VDAgentAnnounceCapabilities*)
spice_marshaller_reserve_space(message->marshaller(), msg->size);
caps->request = request;
memset(caps->caps, 0, VD_AGENT_CAPS_BYTES);
VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_MOUSE_STATE);
VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_MONITORS_CONFIG);
VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_REPLY);
VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_DISPLAY_CONFIG);
VD_AGENT_SET_CAPABILITY(caps->caps, VD_AGENT_CAP_CLIPBOARD_BY_DEMAND);
ASSERT(_agent_tokens)
_agent_tokens--;
post_message(message);
}
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);
}
/* wake anybody waiting on the socket event or send the associated message */
static void sock_wake_up( struct sock *sock )
{
unsigned int events = sock->pmask & sock->mask;
int i;
if ( !events ) return;
if (sock->event)
{
if (debug_level) fprintf(stderr, "signalling events %x ptr %p\n", events, sock->event );
set_event( sock->event );
}
if (sock->window)
{
if (debug_level) fprintf(stderr, "signalling events %x win %08x\n", events, sock->window );
for (i = 0; i < FD_MAX_EVENTS; i++)
{
int event = event_bitorder[i];
if (sock->pmask & (1 << event))
{
lparam_t lparam = (1 << event) | (sock_get_error(sock->errors[event]) << 16);
post_message( sock->window, sock->message, sock->wparam, lparam );
}
}
sock->pmask = 0;
sock_reselect( sock );
}
}
/*
poll_joystick()
Poll the current state of one given handset joystick.
num: number of the joystick to poll (0-3)
Returns true if the handset state has changed and a message was posted.
*/
bool ti99_handset_device::poll_joystick(int num)
{
uint8_t current_joy;
int current_joy_x, current_joy_y;
int message;
/* read joystick position */
current_joy_x = ioport(joynames[0][num])->read();
current_joy_y = ioport(joynames[1][num])->read();
/* compare with last saved position */
current_joy = current_joy_x | (current_joy_y << 4);
if (current_joy != previous_joy[num])
{
/* save position */
previous_joy[num] = current_joy;
/* transform position to signed quantity */
current_joy_x -= 7;
current_joy_y -= 7;
message = 0;
/* set sign */
// note that we set the sign if the joystick position is 0 to work
// around a bug in the ti99/4 ROMs
if (current_joy_x <= 0)
{
message |= 0x040;
current_joy_x = - current_joy_x;
}
if (current_joy_y <= 0)
{
message |= 0x400;
current_joy_y = - current_joy_y;
}
/* convert absolute values to Gray code and insert in message */
if (current_joy_x & 4)
current_joy_x ^= 3;
if (current_joy_x & 2)
current_joy_x ^= 1;
message |= current_joy_x << 3;
if (current_joy_y & 4)
current_joy_y ^= 3;
if (current_joy_y & 2)
current_joy_y ^= 1;
message |= current_joy_y << 7;
/* set joystick address */
message |= (num << 1) | 0x1;
/* post message */
post_message(message);
return true;
}
return false;
}
static ParseAction mpegts_demuxer_read_frame(MpegTSDemuxer *demuxer)
{
ParseAction result = PA_READ_FRAME;
GstFlowReturn flow_result = GST_FLOW_OK;
AVPacket packet;
int ret = av_read_frame(demuxer->context, &packet);
switch(ret)
{
case 0:
#ifdef ENABLE_VIDEO
if (packet.stream_index == demuxer->video.stream_index) // Video
flow_result = process_video_packet(demuxer, &packet);
else
#endif // ENABLE_VIDEO
if (packet.stream_index == demuxer->audio.stream_index) // Audio
flow_result = process_audio_packet(demuxer, &packet);
if (flow_result != GST_FLOW_OK)
{
if (flow_result != GST_FLOW_FLUSHING)
post_message(demuxer, "Send packet failed", GST_MESSAGE_ERROR, GST_STREAM_ERROR, GST_STREAM_ERROR_DEMUX);
result = PA_STOP;
}
#ifdef FAKE_ERROR
else if (demuxer->read_bytes > 1000000)
{
post_message(demuxer, "Fake error", GST_MESSAGE_ERROR, GST_STREAM_ERROR, GST_STREAM_ERROR_DEMUX);
result = PA_STOP;
}
#endif
break;
default:
if (demuxer->is_eos && demuxer->is_last_buffer_send) // Send EOS
mpegts_demuxer_push_to_sources(demuxer, gst_event_new_eos());
else
post_error(demuxer, "LibAV stream parse error", ret, GST_STREAM_ERROR_DEMUX); // Send Error
result = PA_STOP;
break;
}
av_free_packet(&packet);
return result;
}
void RecordChannel::send_start_mark()
{
Message* message = new Message(SPICE_MSGC_RECORD_START_MARK);
SpiceMsgcRecordStartMark start_mark;
start_mark.time = get_mm_time();
_marshallers->msgc_record_start_mark(message->marshaller(), &start_mark);
post_message(message);
}
void RedClient::send_main_attach_channels(void)
{
if (_msg_attach_channels_sent)
return;
post_message(new Message(SPICE_MSGC_MAIN_ATTACH_CHANNELS));
_msg_attach_channels_sent = true;
}
void RedChannel::handle_set_ack(RedPeer::InMessage* message)
{
SpiceMsgSetAck* ack = (SpiceMsgSetAck*)message->data();
_message_ack_window = _message_ack_count = ack->window;
Message *response = new Message(SPICE_MSGC_ACK_SYNC);
SpiceMsgcAckSync sync;
sync.generation = ack->generation;
_marshallers->msgc_ack_sync(response->marshaller(), &sync);
post_message(response);
}
void RedClient::send_agent_monitors_config()
{
AutoRef<MonitorsQuery > qury(new MonitorsQuery());
push_event(*qury);
(*qury)->wait();
if (!(*qury)->success()) {
THROW(" monitors query failed");
}
double min_distance = INFINITY;
int dx = 0;
int dy = 0;
int i;
std::vector<MonitorInfo>& monitors = (*qury)->get_monitors();
std::vector<MonitorInfo>::iterator iter = monitors.begin();
for (; iter != monitors.end(); iter++) {
double distance = sqrt(pow((double)(*iter).position.x, 2) + pow((double)(*iter).position.y,
2));
if (distance < min_distance) {
min_distance = distance;
dx = -(*iter).position.x;
dy = -(*iter).position.y;
}
}
Message* message = new Message(SPICE_MSGC_MAIN_AGENT_DATA);
VDAgentMessage* msg = (VDAgentMessage*)
spice_marshaller_reserve_space(message->marshaller(), sizeof(VDAgentMessage));
msg->protocol = VD_AGENT_PROTOCOL;
msg->type = VD_AGENT_MONITORS_CONFIG;
msg->opaque = 0;
msg->size = sizeof(VDAgentMonitorsConfig) + monitors.size() * sizeof(VDAgentMonConfig);
VDAgentMonitorsConfig* mon_config = (VDAgentMonitorsConfig*)
spice_marshaller_reserve_space(message->marshaller(),
sizeof(VDAgentMonitorsConfig) + monitors.size() * sizeof(VDAgentMonConfig));
mon_config->num_of_monitors = monitors.size();
mon_config->flags = 0;
if (Platform::is_monitors_pos_valid()) {
mon_config->flags = VD_AGENT_CONFIG_MONITORS_FLAG_USE_POS;
}
for (iter = monitors.begin(), i = 0; iter != monitors.end(); iter++, i++) {
mon_config->monitors[i].depth = (*iter).depth;
mon_config->monitors[i].width = (*iter).size.x;
mon_config->monitors[i].height = (*iter).size.y;
mon_config->monitors[i].x = (*iter).position.x + dx;
mon_config->monitors[i].y = (*iter).position.y + dy;
}
ASSERT(_agent_tokens)
_agent_tokens--;
post_message(message);
_agent_mon_config_sent = true;
_agent_reply_wait_type = VD_AGENT_MONITORS_CONFIG;
}
void RecordChannel::on_connect()
{
Message* message = new Message(SPICE_MSGC_RECORD_MODE);
SpiceMsgcRecordMode mode;
mode.time = get_mm_time();
mode.mode = _mode =
test_capability(SPICE_RECORD_CAP_CELT_0_5_1) ? RecordChannel::data_mode :
SPICE_AUDIO_DATA_MODE_RAW;
_marshallers->msgc_record_mode(message->marshaller(), &mode);
post_message(message);
}
void DisplayChannel::on_connect()
{
Message* message = new Message(SPICE_MSGC_DISPLAY_INIT);
SpiceMsgcDisplayInit init;
init.pixmap_cache_id = 1;
init.pixmap_cache_size = get_client().get_pixmap_cache_size();
init.glz_dictionary_id = 1;
init.glz_dictionary_window_size = get_client().get_glz_window_size();
_marshallers->msgc_display_init(message->marshaller(), &init);
post_message(message);
AutoRef<AttachChannelsEvent> attach_channels(new AttachChannelsEvent(*this));
get_client().push_event(*attach_channels);
}
void RedClient::handle_agent_connected(RedPeer::InMessage* message)
{
DBG(0, "");
_agent_connected = true;
Message* msg = new Message(SPICE_MSGC_MAIN_AGENT_START);
SpiceMsgcMainAgentStart agent_start;
agent_start.num_tokens = ~0;
_marshallers->msgc_main_agent_start(msg->marshaller(), &agent_start);
post_message(msg);
send_agent_announce_capabilities(false);
if (_auto_display_res && !_agent_mon_config_sent) {
send_agent_monitors_config();
}
}
entity_id world::create_entity(std::string debug_name) {
entity_id res = entities.allocate(std::ref(*this));
res->debug_name = debug_name;
#ifdef USE_NAMES_FOR_IDS
res.set_debug_name(debug_name);
assert(res.get_debug_name() != "");
#endif
messages::new_entity_message msg;
msg.subject = res;
post_message(msg);
return res;
}
void RedClient::send_agent_display_config()
{
Message* message = new Message(SPICE_MSGC_MAIN_AGENT_DATA);
VDAgentMessage* msg = (VDAgentMessage*)
spice_marshaller_reserve_space(message->marshaller(), sizeof(VDAgentMessage));
VDAgentDisplayConfig* disp_config;
DBG(0,"");
msg->protocol = VD_AGENT_PROTOCOL;
msg->type = VD_AGENT_DISPLAY_CONFIG;
msg->opaque = 0;
msg->size = sizeof(VDAgentDisplayConfig);
disp_config = (VDAgentDisplayConfig*)
spice_marshaller_reserve_space(message->marshaller(), sizeof(VDAgentDisplayConfig));
disp_config->flags = 0;
disp_config->depth = 0;
if (_display_setting._disable_wallpaper) {
disp_config->flags |= VD_AGENT_DISPLAY_CONFIG_FLAG_DISABLE_WALLPAPER;
}
if (_display_setting._disable_font_smooth) {
disp_config->flags |= VD_AGENT_DISPLAY_CONFIG_FLAG_DISABLE_FONT_SMOOTH;
}
if (_display_setting._disable_animation) {
disp_config->flags |= VD_AGENT_DISPLAY_CONFIG_FLAG_DISABLE_ANIMATION;
}
if (_display_setting._set_color_depth) {
disp_config->flags |= VD_AGENT_DISPLAY_CONFIG_FLAG_SET_COLOR_DEPTH;
disp_config->depth = _display_setting._color_depth;
}
ASSERT(_agent_tokens)
_agent_tokens--;
post_message(message);
_agent_disp_config_sent = true;
if (!_display_setting.is_empty()) {
_agent_reply_wait_type = VD_AGENT_DISPLAY_CONFIG;
}
}
void RedClient::do_send_agent_clipboard()
{
uint32_t size;
while (_agent_tokens &&
(size = MIN(VD_AGENT_MAX_DATA_SIZE,
_agent_out_msg_size - _agent_out_msg_pos))) {
Message* message = new Message(SPICE_MSGC_MAIN_AGENT_DATA);
void* data = spice_marshaller_reserve_space(message->marshaller(), size);
memcpy(data, (uint8_t*)_agent_out_msg + _agent_out_msg_pos, size);
_agent_tokens--;
post_message(message);
_agent_out_msg_pos += size;
if (_agent_out_msg_pos == _agent_out_msg_size) {
delete[] (uint8_t *)_agent_out_msg;
_agent_out_msg = NULL;
_agent_out_msg_size = 0;
_agent_out_msg_pos = 0;
}
}
}
PostListPage::PostListPage(QWidget* parent) :
QWidget(parent)
{
_ui = new Ui::PostListPage;
_ui->setupUi(this);
_ui->splitter->setStretchFactor(0, 1);
_ui->splitter->setStretchFactor(1, 0);
_ui->splitter->setSizes({10, 1});
static QList<QString> colors = { "FF9908", "FFBA00", "DD5F5F", "06A3CB", "8ABDB0", "9EC41C" };
_ui->colorWidget->set_colors(colors);
_layout = new QVBoxLayout(_ui->postsWidget);
_layout->setContentsMargins(0, 0, 0, 0);
_spacer = new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
_layout->addSpacerItem(_spacer);
connect(_ui->refreshListButton, SIGNAL(clicked()), this, SLOT(refresh_list()));
connect(_ui->postButton, SIGNAL(clicked()), this, SLOT(post_message()));
connect(_ui->setLocationButton, SIGNAL(clicked()), this, SIGNAL(show_location_dialog()));
}
static int lua_post_message(lua_State *L)
{
void *session;
const char *nch,*msg;
int result=LIBIRC_ERR_INVAL;
if(lua_gettop(L)==3){
session=lua_touserdata(L,1);
if(session!=NULL){
nch=lua_tostring(L,2);
msg=lua_tostring(L,3);
if((nch!=NULL) && (msg!=NULL)){
void *hwnd;
hwnd=get_hwnd_by_session(session,nch);
if(hwnd!=0){
result=post_message(hwnd,msg);
}
}
}
}
lua_pushinteger(L,result);
return 1;
}
void RedClient::send_agent_clipboard_message(uint32_t message_type, uint32_t size, void* data)
{
if (!_agent_connected)
return;
if (!VD_AGENT_HAS_CAPABILITY(_agent_caps, _agent_caps_size,
VD_AGENT_CAP_CLIPBOARD_BY_DEMAND))
return;
Message* message = new Message(SPICE_MSGC_MAIN_AGENT_DATA);
VDAgentMessage* msg = (VDAgentMessage*)
spice_marshaller_reserve_space(message->marshaller(), sizeof(VDAgentMessage) + size);
msg->protocol = VD_AGENT_PROTOCOL;
msg->type = message_type;
msg->opaque = 0;
msg->size = size;
if (size && data) {
memcpy(msg->data, data, size);
}
ASSERT(_agent_tokens)
_agent_tokens--;
post_message(message);
}
jint Java_pp_compiler_Compile_compiler(JNIEnv* env, jobject obj, jstring jname)
{
int e;
const char*path;
int i;
char*name; // index of the file name
initialize();
// error capture
e=0;
if ((e=setjmp(jmp_env))!=0)
{
terminate();
if (iStackPtr>0)
{
#ifdef DEBUG
return 12345; // for debug to stay in console
#else
return e;
#endif
// lauch editor on the error if e>0
// stay on the console on fatal error <0
}
return -1;
}
// Parameters are used in other functons such as emitChar
// so save them in globals
Env=env;
Obj=obj;
// compute the identifier of the Java Method used by the compiler
jclass cls = (*env)->GetObjectClass(env, obj);
emitcharID = (*env)->GetMethodID(env, cls, "emitChar", "(C)V");
if (emitcharID == NULL) ReportError(INTERNAL,"method not found"); // Humm, method not found
// get the path of the file to compile
path=(*env)->GetStringUTFChars(env,jname,NULL);
if (path==NULL) ReportError(OUTOFMEMORY); // out of memory
// copy the path in the Pool and split it
// split the path into the path and the name
// a terminal zero is included in place of the last '/'
// assign LoPoolMax to the end of the path
name=split(path);
(*env)->ReleaseStringUTFChars(env,jname,path);
prompt(name);
do_compile();
do_link();
build_exec();
terminate();
post_message();
return 0;
}
XCamReturn
DeviceManager::poll_buffer_failed (int64_t timestamp, const char *msg)
{
post_message (XCAM_MESSAGE_BUF_ERROR, timestamp, msg);
return XCAM_RETURN_NO_ERROR;
}
static int
callback_messageboard(struct lws *wsi, enum lws_callback_reasons reason,
void *user, void *in, size_t len)
{
struct per_session_data__gs_mb *pss = (struct per_session_data__gs_mb *)user;
const struct lws_protocol_vhost_options *pvo;
struct per_vhost_data__gs_mb *vhd = (struct per_vhost_data__gs_mb *)
lws_protocol_vh_priv_get(lws_get_vhost(wsi), lws_get_protocol(wsi));
unsigned char *p, *start, *end, buffer[LWS_PRE + 256];
char s[512];
int n;
switch (reason) {
case LWS_CALLBACK_PROTOCOL_INIT: /* per vhost */
vhd = lws_protocol_vh_priv_zalloc(lws_get_vhost(wsi),
lws_get_protocol(wsi), sizeof(struct per_vhost_data__gs_mb));
if (!vhd)
return 1;
vhd->vh = lws_get_vhost(wsi);
vhd->gsp = lws_vhost_name_to_protocol(vhd->vh,
"protocol-generic-sessions");
if (!vhd->gsp) {
lwsl_err("messageboard: requires generic-sessions\n");
return 1;
}
pvo = (const struct lws_protocol_vhost_options *)in;
while (pvo) {
if (!strcmp(pvo->name, "message-db"))
strncpy(vhd->message_db, pvo->value,
sizeof(vhd->message_db) - 1);
pvo = pvo->next;
}
if (!vhd->message_db[0]) {
lwsl_err("messageboard: \"message-db\" pvo missing\n");
return 1;
}
if (sqlite3_open_v2(vhd->message_db, &vhd->pdb,
SQLITE_OPEN_READWRITE |
SQLITE_OPEN_CREATE, NULL) != SQLITE_OK) {
lwsl_err("Unable to open message db %s: %s\n",
vhd->message_db, sqlite3_errmsg(vhd->pdb));
return 1;
}
if (sqlite3_exec(vhd->pdb, "create table if not exists msg ("
" idx integer primary key, time integer,"
" username varchar(32), email varchar(100),"
" ip varchar(80), content blob);",
NULL, NULL, NULL) != SQLITE_OK) {
lwsl_err("Unable to create msg table: %s\n",
sqlite3_errmsg(vhd->pdb));
return 1;
}
vhd->last_idx = get_last_idx(vhd);
break;
case LWS_CALLBACK_PROTOCOL_DESTROY:
if (vhd->pdb)
sqlite3_close(vhd->pdb);
goto passthru;
case LWS_CALLBACK_ESTABLISHED:
vhd->gsp->callback(wsi, LWS_CALLBACK_SESSION_INFO,
pss->pss_gs, &pss->sinfo, 0);
if (!pss->sinfo.username[0]) {
lwsl_notice("messageboard ws attempt with no session\n");
return -1;
}
lws_callback_on_writable(wsi);
break;
case LWS_CALLBACK_SERVER_WRITEABLE:
{
struct message m;
char j[MAX_MSG_LEN + 512], e[MAX_MSG_LEN + 512],
*p = j + LWS_PRE, *start = p,
*end = j + sizeof(j) - LWS_PRE;
if (pss->last_idx == vhd->last_idx)
break;
/* restrict to last 10 */
if (!pss->last_idx)
if (vhd->last_idx >= 10)
pss->last_idx = vhd->last_idx - 10;
sprintf(s, "select idx, time, username, email, ip, content "
"from msg where idx > %lu order by idx limit 1;",
pss->last_idx);
if (sqlite3_exec(vhd->pdb, s, lookup_cb, &m, NULL) != SQLITE_OK) {
lwsl_err("Unable to lookup msg: %s\n",
sqlite3_errmsg(vhd->pdb));
return 0;
}
/* format in JSON */
p += snprintf(p, end - p,
"{\"idx\":\"%lu\",\"time\":\"%lu\",",
m.idx, m.time);
p += snprintf(p, end - p, " \"username\":\"%s\",",
lws_json_purify(e, m.username, sizeof(e)));
p += snprintf(p, end - p, " \"email\":\"%s\",",
lws_json_purify(e, m.email, sizeof(e)));
p += snprintf(p, end - p, " \"ip\":\"%s\",",
lws_json_purify(e, m.ip, sizeof(e)));
p += snprintf(p, end - p, " \"content\":\"%s\"}",
lws_json_purify(e, m.content, sizeof(e)));
if (lws_write(wsi, (unsigned char *)start, p - start,
LWS_WRITE_TEXT) < 0)
return -1;
pss->last_idx = m.idx;
if (pss->last_idx == vhd->last_idx)
break;
lws_callback_on_writable(wsi); /* more to do */
}
break;
case LWS_CALLBACK_HTTP:
pss->our_form = 0;
/* ie, it's our messageboard new message form */
if (!strcmp((const char *)in, "/msg")) {
pss->our_form = 1;
break;
}
goto passthru;
case LWS_CALLBACK_HTTP_BODY:
if (!pss->our_form)
goto passthru;
if (len < 2)
break;
if (!pss->spa) {
pss->spa = lws_spa_create(wsi, param_names,
ARRAY_SIZE(param_names),
MAX_MSG_LEN + 1024, NULL, NULL);
if (!pss->spa)
return -1;
}
if (lws_spa_process(pss->spa, in, len)) {
lwsl_notice("spa process blew\n");
return -1;
}
break;
case LWS_CALLBACK_HTTP_BODY_COMPLETION:
if (!pss->our_form)
goto passthru;
if (post_message(wsi, vhd, pss))
return -1;
p = buffer + LWS_PRE;
start = p;
end = p + sizeof(buffer) - LWS_PRE;
if (lws_add_http_header_status(wsi, 200, &p, end))
return -1;
if (lws_add_http_header_by_token(wsi, WSI_TOKEN_HTTP_CONTENT_TYPE,
(unsigned char *)"text/plain", 10, &p, end))
return -1;
if (lws_add_http_header_content_length(wsi, 1, &p, end))
return -1;
if (lws_finalize_http_header(wsi, &p, end))
return -1;
n = lws_write(wsi, start, p - start, LWS_WRITE_HTTP_HEADERS);
if (n != (p - start)) {
lwsl_err("_write returned %d from %d\n", n, (p - start));
return -1;
}
s[0] = '0';
n = lws_write(wsi, (unsigned char *)s, 1, LWS_WRITE_HTTP);
if (n != 1)
return -1;
goto try_to_reuse;
case LWS_CALLBACK_HTTP_BIND_PROTOCOL:
if (!pss || pss->pss_gs)
break;
pss->pss_gs = malloc(vhd->gsp->per_session_data_size);
if (!pss->pss_gs)
return -1;
memset(pss->pss_gs, 0, vhd->gsp->per_session_data_size);
break;
case LWS_CALLBACK_HTTP_DROP_PROTOCOL:
if (vhd->gsp->callback(wsi, reason, pss ? pss->pss_gs : NULL, in, len))
return -1;
if (pss && pss->spa) {
lws_spa_destroy(pss->spa);
pss->spa = NULL;
}
if (pss && pss->pss_gs) {
free(pss->pss_gs);
pss->pss_gs = NULL;
}
break;
default:
passthru:
return vhd->gsp->callback(wsi, reason, pss ? pss->pss_gs : NULL, in, len);
}
return 0;
try_to_reuse:
if (lws_http_transaction_completed(wsi))
return -1;
return 0;
}
static inline void post_unsupported_warning(MpegTSDemuxer *demuxer)
{
post_message(demuxer, "Unsupported stream type", GST_MESSAGE_WARNING, GST_STREAM_ERROR, GST_STREAM_ERROR_NOT_IMPLEMENTED);
}
/*
poll_keyboard()
Poll the current state of one given handset keypad.
num: number of the keypad to poll (0-3)
Returns true if the handset state has changed and a message was posted.
*/
bool ti99_handset_device::poll_keyboard(int num)
{
uint32_t key_buf;
uint8_t current_key;
int i;
/* read current key state */
key_buf = (ioport(keynames[num])->read() | (ioport(keynames[num + 1])->read() << 16) ) >> (4*num);
// If a key was previously pressed, this key was not shift, and this key is
// still down, then don't change the current key press.
if (previous_key[num] !=0 && (previous_key[num] != 0x24)
&& (key_buf & (1 << (previous_key[num] & 0x1f))))
{
/* check the shift modifier state */
if (((previous_key[num] & 0x20) != 0) == ((key_buf & 0x0008) != 0))
/* the shift modifier state has not changed */
return false;
else
{
// The shift modifier state has changed: we need to update the
// keyboard state
if (key_buf & 0x0008)
{ /* shift has been pressed down */
previous_key[num] = current_key = previous_key[num] | 0x20;
}
else
{
previous_key[num] = current_key = previous_key[num] & ~0x20;
}
/* post message */
post_message((((unsigned)current_key) << 4) | (num << 1));
return true;
}
}
current_key = 0; /* default value if no key is down */
for (i=0; i<20; i++)
{
if (key_buf & (1 << i))
{
current_key = i + 1;
if (key_buf & 0x0008)
current_key |= 0x20; /* set shift flag */
if (current_key != 0x24)
// If this is the shift key, any other key we may find will
// have higher priority; otherwise, we may exit the loop and keep
// the key we have just found.
break;
}
}
if (current_key != previous_key[num])
{
previous_key[num] = current_key;
/* post message */
post_message((((unsigned) current_key) << 4) | (num << 1));
return true;
}
return false;
}
static gboolean mpegts_demuxer_sink_event(GstPad *pad, GstObject *parent, GstEvent *event)
{
MpegTSDemuxer *demuxer = MPEGTS_DEMUXER(parent);
gboolean result = TRUE;
switch (GST_EVENT_TYPE(event))
{
case GST_EVENT_EOS:
#ifdef DEBUG_OUTPUT
g_print("MpegTS sinkEvent: EOS\n");
#endif
g_mutex_lock(&demuxer->lock);
demuxer->is_eos = TRUE;
g_cond_signal(&demuxer->add_cond); // Signal read callback to read up remaining data.
g_mutex_unlock(&demuxer->lock);
gst_event_unref(event);
break;
case GST_EVENT_FLUSH_START:
#ifdef DEBUG_OUTPUT
g_print("MpegTS sinkEvent: FLUSH_START ...");
#endif
result = gst_pad_event_default(demuxer->sinkpad, parent, event);
g_mutex_lock(&demuxer->lock);
demuxer->is_flushing = TRUE;
g_cond_signal(&demuxer->del_cond); // Signal _chain() and read callback to wake them up and update state.
g_cond_signal(&demuxer->add_cond);
g_mutex_unlock(&demuxer->lock);
if (demuxer->reader_thread)
{
g_thread_join(demuxer->reader_thread);
demuxer->reader_thread = NULL;
}
#ifdef DEBUG_OUTPUT
g_print("done.\n");
#endif
break;
case GST_EVENT_FLUSH_STOP: // Stop flushing buffers.
g_mutex_lock(&demuxer->lock);
mpegts_demuxer_flush(demuxer);
demuxer->is_flushing = FALSE; // Unset flag so chain function accepts buffers.
g_mutex_unlock(&demuxer->lock);
result = gst_pad_event_default(demuxer->sinkpad, parent, event);
#ifdef DEBUG_OUTPUT
g_print("MpegTS sinkEvent: FLUSH_STOP\n");
#endif
break;
case GST_EVENT_SEGMENT:
{
GstSegment segment;
gst_event_copy_segment(event, &segment);
gst_event_unref(event);
g_mutex_lock(&demuxer->lock);
if (!demuxer->is_closing)
{
#ifdef DEBUG_OUTPUT
g_print("MpegTS sinkEvent: NEW_SEGMENT, time=%.2f\n",
time != GST_CLOCK_TIME_NONE ? (double)time/GST_SECOND : -1.0);
#endif
if (segment.format == GST_FORMAT_TIME)
{
gst_segment_copy_into(&segment, &demuxer->audio.segment);
gst_segment_copy_into(&segment, &demuxer->video.segment);
}
demuxer->audio.discont = demuxer->video.discont = TRUE;
demuxer->is_eos = FALSE;
demuxer->is_last_buffer_send = FALSE;
demuxer->is_reading = TRUE;
if (!demuxer->reader_thread)
{
demuxer->reader_thread = g_thread_new(NULL, mpegts_demuxer_process_input, demuxer);
#ifdef DEBUG_OUTPUT
g_print("MpegTS: Process_input thread created\n");
#endif
}
else
post_message(demuxer, "Demuxer thread is not null", GST_MESSAGE_ERROR, GST_CORE_ERROR, GST_CORE_ERROR_THREAD);
}
g_mutex_unlock(&demuxer->lock);
break;
}
default:
result = mpegts_demuxer_push_to_sources(demuxer, event);
break;
}
return result;
}
void RedClient::send_migrate_end()
{
Message* message = new Message(SPICE_MSGC_MAIN_MIGRATE_END);
post_message(message);
}