gboolean ProcessTestKeyPress(KeySym keysym, u_int kev_state)
{
if (!current_CS)
return TRUE;
// dbg("hime_reset\n");
gboolean v;
test_mode= TRUE;
switch(current_method_type()) {
case method_type_PHO:
pho_save_gst();
v = ProcessKeyPress(keysym, kev_state);
pho_restore_gst();
break;
case method_type_TSIN:
tsin_save_gst();
v = ProcessKeyPress(keysym, kev_state);
tsin_restore_gst();
break;
case method_type_MODULE:
break;
default:
gtab_save_gst();
v = ProcessKeyPress(keysym, kev_state);
gtab_restore_gst();
}
test_mode= FALSE;
return v;
}
int xim_ForwardEventHandler(IMForwardEventStruct *call_data)
{
current_forward_eve = call_data;
if (call_data->event.type != KeyPress && call_data->event.type != KeyRelease) {
#if DEBUG || 1
dbg("bogus event type, ignored\n");
#endif
return True;
}
char strbuf[STRBUFLEN];
KeySym keysym;
bzero(strbuf, STRBUFLEN);
XKeyEvent *kev = (XKeyEvent*)¤t_forward_eve->event;
XLookupString(kev, strbuf, STRBUFLEN, &keysym, NULL);
int ret;
if (call_data->event.type == KeyPress)
ret = ProcessKeyPress(keysym, kev->state);
else
ret = ProcessKeyRelease(keysym, kev->state);
if (!ret)
bounce_back_key();
export_text_xim();
return False;
}
gboolean Process2KeyPress(KeySym keysym, u_int kev_state)
{
gboolean tv = ProcessTestKeyPress(keysym, kev_state);
gboolean v = ProcessKeyPress(keysym, kev_state);
if (tv != v)
dbg("ProcessKeyPress %x -> %d %d\n",keysym, tv, v);
return v;
}
void CMessageKeyProcessor::RunL()
{
// Handle completed request
ProcessKeyPress(TChar(iConsole->KeyCode()));
}
void CActiveConsole::RunL()
{
ProcessKeyPress(TChar(iConsole->KeyCode()));
}
int main(int argc, char **argv)
{
unsigned char Message[257];
int Bytes, ch;
uint32_t LoopCount[2];
pthread_t SSDVThread, FTPThread, NetworkThread, HabitatThread, ServerThread;
WINDOW * mainwin;
int LEDCounts[2];
if (prog_count("gateway") > 1)
{
printf("\nThe gateway program is already running!\n\n");
exit(1);
}
mainwin = InitDisplay();
// Settings for character input
noecho();
cbreak();
nodelay(stdscr, TRUE);
keypad(stdscr, TRUE);
Config.LoRaDevices[0].InUse = 0;
Config.LoRaDevices[1].InUse = 0;
LEDCounts[0] = 0;
LEDCounts[1] = 0;
// Remove any old SSDV files
// system("rm -f /tmp/*.bin");
// Default pin allocations
Config.LoRaDevices[0].DIO0 = 6;
Config.LoRaDevices[0].DIO5 = 5;
Config.LoRaDevices[1].DIO0 = 27;
Config.LoRaDevices[1].DIO5 = 26;
LoadConfigFile();
LoadPayloadFiles();
if (wiringPiSetup() < 0)
{
fprintf(stderr, "Failed to open wiringPi\n");
exit(1);
}
if (Config.LoRaDevices[0].ActivityLED >= 0) pinMode(Config.LoRaDevices[0].ActivityLED, OUTPUT);
if (Config.LoRaDevices[1].ActivityLED >= 0) pinMode(Config.LoRaDevices[1].ActivityLED, OUTPUT);
if (Config.InternetLED >= 0) pinMode(Config.InternetLED, OUTPUT);
if (Config.NetworkLED >= 0) pinMode(Config.NetworkLED, OUTPUT);
setupRFM98(0);
setupRFM98(1);
ShowPacketCounts(0);
ShowPacketCounts(1);
LoopCount[0] = 0;
LoopCount[1] = 0;
if (pthread_create(&SSDVThread, NULL, SSDVLoop, NULL))
{
fprintf(stderr, "Error creating SSDV thread\n");
return 1;
}
if (pthread_create(&FTPThread, NULL, FTPLoop, NULL))
{
fprintf(stderr, "Error creating FTP thread\n");
return 1;
}
if (pthread_create(&HabitatThread, NULL, HabitatLoop, NULL))
{
fprintf(stderr, "Error creating Habitat thread\n");
return 1;
}
if (Config.ServerPort > 0)
{
if (pthread_create(&ServerThread, NULL, ServerLoop, NULL))
{
fprintf(stderr, "Error creating server thread\n");
return 1;
}
}
if ((Config.NetworkLED >= 0) && (Config.InternetLED >= 0))
{
if (pthread_create(&NetworkThread, NULL, NetworkLoop, NULL))
{
fprintf(stderr, "Error creating Network thread\n");
return 1;
}
}
while (run)
{
int Channel;
for (Channel=0; Channel<=1; Channel++)
{
if (Config.LoRaDevices[Channel].InUse)
{
if (digitalRead(Config.LoRaDevices[Channel].DIO0))
{
Bytes = receiveMessage(Channel, Message+1);
if (Bytes > 0)
{
if (Config.LoRaDevices[Channel].ActivityLED >= 0)
{
digitalWrite(Config.LoRaDevices[Channel].ActivityLED, 1);
LEDCounts[Channel] = 5;
}
// LogMessage("Channel %d data available - %d bytes\n", Channel, Bytes);
// LogMessage("Line = '%s'\n", Message);
if (Message[1] == '!')
{
ProcessUploadMessage(Channel, (char *) Message+1);
}
else if (Message[1] == '^')
{
ProcessCallingMessage(Channel, (char *) Message+1);
}
else if (Message[1] == '$')
{
ProcessTelemetryMessage(Channel, (char *) Message+1);
}
else if (Message[1] == 0x66)
{
ProcessSSDVMessage(Channel, Message);
}
else
{
LogMessage("Unknown packet type is %02Xh, RSSI %d\n", Message[1], readRegister(Channel, REG_PACKET_RSSI) - 157);
ChannelPrintf(Channel, 4, 1, "Unknown Packet %d, %d bytes", Message[0], Bytes);
Config.LoRaDevices[Channel].UnknownCount++;
}
Config.LoRaDevices[Channel].LastPacketAt = time(NULL);
if (Config.LoRaDevices[Channel].InCallingMode && (Config.CallingTimeout > 0))
{
Config.LoRaDevices[Channel].ReturnToCallingModeAt = time(NULL) + Config.CallingTimeout;
}
ShowPacketCounts(Channel);
}
}
if (++LoopCount[Channel] > 1000000)
{
LoopCount[Channel] = 0;
ShowPacketCounts(Channel);
ChannelPrintf(Channel, 12, 1, "Current RSSI = %4d ", readRegister(Channel, REG_CURRENT_RSSI) - 157);
if (Config.LoRaDevices[Channel].LastPacketAt > 0)
{
ChannelPrintf(Channel, 6, 1, "%us since last packet ", (unsigned int)(time(NULL) - Config.LoRaDevices[Channel].LastPacketAt));
}
if (Config.LoRaDevices[Channel].InCallingMode && (Config.CallingTimeout > 0) && (Config.LoRaDevices[Channel].ReturnToCallingModeAt > 0) && (time(NULL) > Config.LoRaDevices[Channel].ReturnToCallingModeAt))
{
Config.LoRaDevices[Channel].InCallingMode = 0;
Config.LoRaDevices[Channel].ReturnToCallingModeAt = 0;
LogMessage("Return to calling mode\n");
// setMode(Channel, RF96_MODE_SLEEP);
// setFrequency(Channel, Frequency);
// SetLoRaParameters(Channel, ImplicitOrExplicit, ErrorCoding, Bandwidth, SpreadingFactor, LowDataRateOptimize);
// setMode(Channel, RF96_MODE_RX_CONTINUOUS);
setLoRaMode(Channel);
SetDefaultLoRaParameters(Channel);
setMode(Channel, RF96_MODE_RX_CONTINUOUS);
ChannelPrintf(Channel, 1, 1, "Channel %d %sMHz %s mode", Channel, Config.LoRaDevices[Channel].Frequency, Modes[Config.LoRaDevices[Channel].SpeedMode]);
}
if ((ch = getch()) != ERR)
{
ProcessKeyPress(ch);
}
if (LEDCounts[Channel] && (Config.LoRaDevices[Channel].ActivityLED >= 0))
{
if (--LEDCounts[Channel] == 0)
{
digitalWrite(Config.LoRaDevices[Channel].ActivityLED, 0);
}
}
}
}
}
// delay(5);
}
CloseDisplay(mainwin);
if (Config.NetworkLED >= 0) digitalWrite(Config.NetworkLED, 0);
if (Config.InternetLED >= 0) digitalWrite(Config.InternetLED, 0);
if (Config.LoRaDevices[0].ActivityLED >= 0) digitalWrite(Config.LoRaDevices[0].ActivityLED, 0);
if (Config.LoRaDevices[1].ActivityLED >= 0) digitalWrite(Config.LoRaDevices[1].ActivityLED, 0);
return 0;
}
void process_client_req(int fd)
{
HIME_req req;
#if DBG
dbg("svr--> process_client_req %d\n", fd);
#endif
int rn = myread(fd, &req, sizeof(req));
if (rn <= 0) {
shutdown_client(fd);
return;
}
if (hime_clients[fd].type == Connection_type_tcp) {
__hime_enc_mem((u_char *)&req, sizeof(req), &srv_ip_port.passwd, &hime_clients[fd].seed);
}
to_hime_endian_4(&req.req_no);
to_hime_endian_4(&req.client_win);
to_hime_endian_4(&req.flag);
to_hime_endian_2(&req.spot_location.x);
to_hime_endian_2(&req.spot_location.y);
// dbg("spot %d %d\n", req.spot_location.x, req.spot_location.y);
ClientState *cs = NULL;
if (current_CS && req.client_win == current_CS->client_win) {
cs = current_CS;
} else {
int idx = fd;
cs = hime_clients[fd].cs;
int new_cli = 0;
if (!cs) {
cs = hime_clients[idx].cs = tzmalloc(ClientState, 1);
new_cli = 1;
}
cs->client_win = req.client_win;
cs->b_hime_protocol = TRUE;
cs->input_style = InputStyleOverSpot;
if (hime_init_im_enabled && ((hime_single_state && !is_init_im_enabled) || (!hime_single_state && new_cli))) {
dbg("new_cli default_input_method:%d\n", default_input_method);
is_init_im_enabled = TRUE;
current_CS = cs;
save_CS_temp_to_current();
init_state_chinese(cs);
}
}
if (!cs)
p_err("bad cs\n");
if (req.req_no != HIME_req_message) {
cs->spot_location.x = req.spot_location.x;
cs->spot_location.y = req.spot_location.y;
}
gboolean status;
HIME_reply reply;
bzero(&reply, sizeof(reply));
switch (req.req_no) {
case HIME_req_key_press:
case HIME_req_key_release:
current_CS = cs;
save_CS_temp_to_current();
#if DBG && 0
{
char tt[128];
if (req.keyeve.key < 127) {
sprintf(tt,"'%c'", req.keyeve.key);
} else {
strcpy(tt, XKeysymToString(req.keyeve.key));
}
dbg_time("HIME_key_press %x %s\n", cs, tt);
}
#endif
to_hime_endian_4(&req.keyeve.key);
to_hime_endian_4(&req.keyeve.state);
// dbg("serv key eve %x %x predit:%d\n",req.keyeve.key, req.keyeve.state, cs->use_preedit);
#if DBG
char *typ;
typ="press";
#endif
#if 0
if (req.req_no==HIME_req_key_press)
status = Process2KeyPress(req.keyeve.key, req.keyeve.state);
else {
status = Process2KeyRelease(req.keyeve.key, req.keyeve.state);
#else
if (req.req_no==HIME_req_key_press)
status = ProcessKeyPress(req.keyeve.key, req.keyeve.state);
else {
status = ProcessKeyRelease(req.keyeve.key, req.keyeve.state);
#endif
#if DBG
typ="rele";
#endif
}
if (status)
reply.flag |= HIME_reply_key_processed;
#if DBG
dbg("%s srv flag:%x status:%d len:%d %x %c\n",typ, reply.flag, status, output_bufferN, req.keyeve.key,req.keyeve.key & 0x7f);
#endif
int datalen;
datalen = reply.datalen =
output_bufferN ? output_bufferN + 1 : 0; // include '\0'
to_hime_endian_4(&reply.flag);
to_hime_endian_4(&reply.datalen);
write_enc(fd, &reply, sizeof(reply));
// dbg("server reply.flag %x\n", reply.flag);
if (output_bufferN) {
write_enc(fd, output_buffer, datalen);
clear_output_buffer();
}
break;
case HIME_req_focus_in:
#if DBG
dbg_time("HIME_req_focus_in %x %d %d\n",cs, cs->spot_location.x, cs->spot_location.y);
#endif
// current_CS = cs;
hime_FocusIn(cs);
break;
case HIME_req_focus_out:
#if DBG
dbg_time("HIME_req_focus_out %x\n", cs);
#endif
hime_FocusOut(cs);
break;
case HIME_req_focus_out2:
{
#if DBG
dbg_time("HIME_req_focus_out2 %x\n", cs);
#endif
if (hime_FocusOut(cs))
flush_edit_buffer();
HIME_reply reply;
bzero(&reply, sizeof(reply));
int datalen = reply.datalen =
output_bufferN ? output_bufferN + 1 : 0; // include '\0'
to_hime_endian_4(&reply.flag);
to_hime_endian_4(&reply.datalen);
write_enc(fd, &reply, sizeof(reply));
// dbg("server reply.flag %x\n", reply.flag);
if (output_bufferN) {
write_enc(fd, output_buffer, datalen);
clear_output_buffer();
}
}
break;
case HIME_req_set_cursor_location:
#if DBG
dbg_time("set_cursor_location %x %d %d\n", cs,
cs->spot_location.x, cs->spot_location.y);
#endif
update_in_win_pos();
break;
case HIME_req_set_flags:
// dbg("HIME_req_set_flags\n");
if (BITON(req.flag, FLAG_HIME_client_handle_raise_window)) {
#if DBG
dbg("********* raise * window\n");
#endif
if (!hime_pop_up_win)
cs->b_raise_window = TRUE;
}
if (req.flag & FLAG_HIME_client_handle_use_preedit)
cs->use_preedit = TRUE;
int rflags;
rflags = 0;
if (hime_pop_up_win)
rflags = FLAG_HIME_srv_ret_status_use_pop_up;
write_enc(fd, &rflags, sizeof(rflags));
break;
case HIME_req_get_preedit:
{
#if DBG
dbg("svr HIME_req_get_preedit %x\n", cs);
#endif
char str[HIME_PREEDIT_MAX_STR];
HIME_PREEDIT_ATTR attr[HIME_PREEDIT_ATTR_MAX_N];
int cursor, sub_comp_len;
int attrN = hime_get_preedit(cs, str, attr, &cursor, &sub_comp_len);
if (hime_edit_display&(HIME_EDIT_DISPLAY_BOTH|HIME_EDIT_DISPLAY_OVER_THE_SPOT))
cursor=0;
if (hime_edit_display&HIME_EDIT_DISPLAY_OVER_THE_SPOT) {
attrN=0;
str[0]=0;
}
int len = strlen(str)+1; // including \0
write_enc(fd, &len, sizeof(len));
write_enc(fd, str, len);
// dbg("attrN:%d\n", attrN);
write_enc(fd, &attrN, sizeof(attrN));
if (attrN > 0)
write_enc(fd, attr, sizeof(HIME_PREEDIT_ATTR)*attrN);
write_enc(fd, &cursor, sizeof(cursor));
write_enc(fd, &sub_comp_len, sizeof(sub_comp_len));
// dbg("uuuuuuuuuuuuuuuuu len:%d %d cursor:%d\n", len, attrN, cursor);
}
break;
case HIME_req_reset:
hime_reset();
break;
case HIME_req_message:
{
// dbg("HIME_req_message\n");
short len=0;
int rn = myread(fd, &len, sizeof(len));
if (rn <= 0) {
cli_down:
shutdown_client(fd);
return;
}
// only unix socket, no decrypt
char buf[512];
// message should include '\0'
if (len > 0 && len < sizeof(buf)) {
if (myread(fd, buf, len)<=0)
goto cli_down;
message_cb(buf);
}
}
break;
default:
dbg_time("Invalid request %x from:", req.req_no);
struct sockaddr_in addr;
socklen_t len=sizeof(addr);
bzero(&addr, sizeof(addr));
if (!getpeername(fd, (struct sockaddr *)&addr, &len)) {
dbg("%s\n", inet_ntoa(addr.sin_addr));
} else {
perror("getpeername\n");
}
shutdown_client(fd);
break;
}
}
