void UserInputServer::onRequest(UINT8 reqCode, BlockingGate *backGate)
{
switch (reqCode) {
case POINTER_POS_CHANGED:
applyNewPointerPos(backGate);
break;
case CLIPBOARD_CHANGED:
applyNewClipboard(backGate);
break;
case KEYBOARD_EVENT:
applyKeyEvent(backGate);
break;
case USER_INFO_REQ:
ansUserInfo(backGate);
break;
case USER_INPUT_INIT:
serverInit(backGate);
break;
default:
StringStorage errMess;
errMess.format(_T("Unknown %d protocol code received")
_T(" from a UserInputClient"), reqCode);
throw Exception(errMess.getString());
break;
}
}
void user_init(void)
{
ETS_UART_INTR_DISABLE();
UART_SetBaudrate(UART0, BIT_RATE_9600);
UART_ResetFifo(UART0);
UART_SetBaudrate(UART1, BIT_RATE_115200);
UART_ResetFifo(UART1);
flash_param_init();
flash_param = flash_param_get();
emsRxBuf = allocateRcvMsgBuff();
uart_init(BIT_RATE_9600, BIT_RATE_115200);
rtc_clock_calibration = system_rtc_clock_cali_proc(); // get RTC clock period
os_printf("rtc_clock_calibration: %0x\n", rtc_clock_calibration >>12 );
os_printf("system_get_rtc_time: %d\n", system_get_rtc_time());
os_printf("system_get_time: %d\n", system_get_time());
serverInit(flash_param->port);
wifi_set_sleep_type(LIGHT_SLEEP_T);
system_os_task(recvTask, recvTaskPrio, recvTaskQueue, recvTaskQueueLen);
ETS_UART_INTR_ENABLE();
}
SnmpRouted::SnmpRouted(const IpAddress& sAddr, const IpAddress& dAddr, bool daemon)
:destAddr(dAddr)
{
memset(reqTable, 0, sizeof(reqTable));
if(daemon) serverInit();
listener.bind(sAddr);
}
void user_init(void)
{
uint8_t i;
//system_set_os_print(0);
os_timer_disarm(&some_timer);
//Setup timer
os_timer_setfn(&some_timer, (os_timer_func_t *)some_timer_func, NULL);
//Arm the timer
//&some_timer is the pointer
//1000 is the fire time in ms
//0 for once and 1 for repeating
os_timer_arm(&some_timer, 5000, 0);
UartDev.data_bits = EIGHT_BITS;
UartDev.parity = NONE_BITS;
UartDev.stop_bits = ONE_STOP_BIT;
uart_init(BIT_RATE_500000, BIT_RATE_500000);
os_printf("size flash_param_t %d\n", sizeof(flash_param_t));
#ifdef CONFIG_STATIC
// refresh wifi config
config_execute();
#endif
#ifdef CONFIG_DYNAMIC
serverInit(flash_param->port);
#else
serverInit(8876);
#endif
#ifdef CONFIG_GPIO
config_gpio();
#endif
for (i = 0; i < 16; ++i)
uart0_sendStr("\r\n");
system_os_task(recvTask, recvTaskPrio, recvTaskQueue, recvTaskQueueLen);
}
void ICACHE_FLASH_ATTR user_init(void)
{
uint8_t i;
//wifi_set_opmode(3); //STA+AP
#ifdef CONFIG_DYNAMIC
flash_param_t *flash_param;
flash_param_init();
flash_param = flash_param_get();
UartDev.data_bits = GETUART_DATABITS(flash_param->uartconf0);
UartDev.parity = GETUART_PARITYMODE(flash_param->uartconf0);
UartDev.stop_bits = GETUART_STOPBITS(flash_param->uartconf0);
uart_init(flash_param->baud, BIT_RATE_115200);
#else
UartDev.data_bits = EIGHT_BITS;
UartDev.parity = NONE_BITS;
UartDev.stop_bits = ONE_STOP_BIT;
uart_init(BIT_RATE_115200, BIT_RATE_115200);
#endif
os_printf("size flash_param_t %d\n", sizeof(flash_param_t));
#ifdef CONFIG_STATIC
// refresh wifi config
config_execute();
#endif
#ifdef CONFIG_DYNAMIC
serverInit(flash_param->port);
#else
serverInit(23);
#endif
config_gpio();
os_timer_disarm(&main_timer);
os_timer_setfn(&main_timer, (os_timer_func_t *)main_timer_callback, NULL);
os_timer_arm(&main_timer, TIMER_DURATION_MS, 1);
system_os_task(recvTask, recvTaskPrio, recvTaskQueue, recvTaskQueueLen);
}
void handleMessage(char * messageR){
msg_t* message = (msg_t*)messageR;
message->returnVal = -1;
int returnVal;
switch(message->msgType){
case INIT:
returnVal = serverInit(file);
message->returnVal = returnVal;
break;
case READ:
returnVal = serverRead(message->inum, message->buffer, message->block);
message->returnVal = returnVal;
break;
case LOOKUP:
returnVal = serverLookup(message->pinum, message->name);
message->returnVal = returnVal;
break;
case WRITE:
returnVal = serverWrite(message->inum, message->buffer, message->block);
message->returnVal = returnVal;
break;
case STAT:
returnVal = serverStat(message->inum, &(message->stat));
message->returnVal = returnVal;
break;
case CREATE:
returnVal = serverCreate(message->pinum, message->type, (message->name));
message->returnVal = returnVal;
break;
case UNLINK:
returnVal = serverUnlink(message->pinum, message->name);
message->returnVal = returnVal;
break;
case SHUTDOWN:
message->returnVal = 0;
memcpy(messageR, message, sizeof(*message));
UDP_Write(sd, &s, messageR, sizeof(msg_t));
//fsync(diskFD);
close(diskFD);
// printDisk();
exit(0);
break;
default:
message->returnVal = -1;
break;
}
memcpy(messageR, message, sizeof(*message));
}
int main(int argc, const char * argv[])
{
io_iterator_t serialPortIterator;
char bsdPath[MAXPATHLEN];
if(udpServerInit() != 0) {
consoleNotef("Simulator link input port open failed.\n");
return -1;
}
if(initConsoleInput() != 0) {
consoleNotef("Console input initialization failed.\n");
return -2;
}
Boolean looking = false;
while(1) {
if(!looking) {
consoleNotef("Looking for the serial port...\n");
looking = true;
}
if(findModems(&serialPortIterator) == KERN_SUCCESS) {
if(getModemPath(serialPortIterator, bsdPath, sizeof(bsdPath)) == KERN_SUCCESS) {
if(openSerialPort(bsdPath) != -1) {
serverInit();
consoleNotef("Entering server loop...\n");
serverLoop();
consoleNotef("Server loop exited.\n");
closeSerialPort(serialPort);
looking = false;
} else
consoleNotef("Serial port could not be opened.\n");
}
IOObjectRelease(serialPortIterator);
}
sleep(1);
}
return EX_OK;
}
Server *
serverNew (
ServerInfo *info
) {
Server *self;
if ((self = calloc(1, sizeof(Server))) == NULL) {
return NULL;
}
if (!serverInit (self, info)) {
serverDestroy(&self);
error("Server failed to initialize.");
return NULL;
}
return self;
}
void UserInputServer::onRequest(UINT8 reqCode, BlockingGate *backGate)
{
switch (reqCode) {
case POINTER_POS_CHANGED:
applyNewPointerPos(backGate);
break;
case CLIPBOARD_CHANGED:
applyNewClipboard(backGate);
break;
case KEYBOARD_EVENT:
applyKeyEvent(backGate);
break;
case USER_INFO_REQ:
ansUserInfo(backGate);
break;
case DESKTOP_COORDS_REQ:
ansDesktopCoords(backGate);
break;
case WINDOW_COORDS_REQ:
ansWindowCoords(backGate);
break;
case WINDOW_HANDLE_REQ:
ansWindowHandle(backGate);
break;
case DISPLAY_NUMBER_COORDS_REQ:
ansDisplayNumberCoords(backGate);
break;
case APPLICATION_REGION_REQ:
ansApplicationRegion(backGate);
break;
case NORMALIZE_RECT_REQ:
ansNormalizeRect(backGate);
break;
case USER_INPUT_INIT:
serverInit(backGate);
break;
default:
StringStorage errMess;
errMess.format(_T("Unknown %d protocol code received")
_T(" from a UserInputClient"), reqCode);
throw Exception(errMess.getString());
break;
}
}
int main(int argc, char *argv[]) {
int listenfd = 0, connfd = 0, n = 0, len = 0;
char sendBuff[1025] = {0};
struct sockaddr_in client_addr;
FILE *infile = 0;
if((listenfd = serverInit()) == -1) { //error setting up server
fprintf(stderr, "Error: unable to initialize server\n");
return 1;
}
if(!(infile = getConfigFile())) { //unable to open config file
fprintf(stderr, "Cannot open config file \"%s\", make s", CONFIG_FILE);
fprintf(stderr, "ure the file exists and you have read permissions.\n");
return 1;
}
while(1) { //loop continually to connect to client
len = sizeof(client_addr);
connfd = accept(listenfd, (struct sockaddr *)&client_addr, (socklen_t *)&len);
printf("Client connected from IP=%s on PORT=%d\n",
inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
while(1) { //processing loop
n = read(connfd, sendBuff, sizeof(sendBuff));
if(!n) { //client died
printf("Client died, waiting for new connection\n");
close(connfd);
break;
}
else if(n == -1) { //client hasn't sent anything yet
continue;
}
executeInput(sendBuff, connfd, infile);
}//end while
sleep(1); //sleep for a tiny bit to we don't use all CPU power, hehehe
}//end while
fclose(infile); //close config file
}//end main
int
main(int argc, char *argv[])
{
if(argc != 3){
fprintf(stderr,"usage: server <portnum> <filename>\n");
exit(0);
}
int port = atoi(argv[1]);
sprintf(file, argv[2]);
sd = UDP_Open(port);
assert(sd > -1);
serverInit(file);
memLoad();
printf("waiting in loop\n");
while (1) {
//use this to get the socket address
struct sockaddr_in y;
s = y;
char buffer[sizeof(msg_t)];
int rc = UDP_Read(sd, &s, buffer, sizeof(msg_t));
//figure out what kind of message this is - read, write, lookup etc
//when done go ahead and reply to it
if (rc > 0) {
// char reply[BUFFER_SIZE];
//sprintf(reply, "reply");
handleMessage (buffer);
//need a message struct casted as a char []
rc = UDP_Write(sd, &s, buffer, sizeof(msg_t));
}
}
return 0;
}
int main(int argc, char const *argv[])
{
if (argc != 2) {
fprintf(stderr, "usage: %s <port>\n", argv[0]);
exit(EXIT_FAILURE);
}
if (!isValidArguments(argc, argv)) {
fprintf(stderr, "Invalid Arguments\n");
exit(EXIT_FAILURE);
}
init();
// server initialize
int port;
sscanf(argv[1], "%d", &port);
int listenId = serverInit(port);
// signal
// signal(SIGCHLD, sigChld);
// wait for connection, then fork for per client
while (true) {
pid_t childPid;
socklen_t clientLen = sizeof(sockaddr_in);
sockaddr_in clientAddr;
int clientfd = accept(listenId, reinterpret_cast<sockaddr*>(&clientAddr), &clientLen);
if ((childPid = fork()) == 0) {
close(listenId);
char clientInfo[1024];
strcpy(clientInfo, inet_ntoa(clientAddr.sin_addr));
int clientPort = static_cast<int>(clientAddr.sin_port);
fprintf(stdout, "Connection from %s, port %d\n", clientInfo, clientPort);
TCPServer(clientfd);
close(clientfd);
fprintf(stdout, "Client %s:%d terminated\n", clientInfo, clientPort);
exit(EXIT_SUCCESS);
}
close(clientfd);
}
return 0;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
WNDCLASSEX wcex;
gEnv->Init();
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1));
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(2);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_ICON1));
if (!RegisterClassEx(&wcex))
{
MessageBox(NULL,_T("Call to RegisterClassEx failed!"),szWindowClass,NULL);
return 1;
}
hInst = hInstance;
HWND hWnd = CreateWindow(szWindowClass, szTitle, WS_VISIBLE| WS_SYSMENU | WS_MINIMIZEBOX, CW_USEDEFAULT, CW_USEDEFAULT,750, 465,NULL, NULL, hInstance, NULL);
if (!hWnd)
{
MessageBox(NULL, _T("Call to CreateWindow failed!"), szWindowClass, NULL);
return 1;
}
ShowWindow(hWnd,nCmdShow);
UpdateWindow(hWnd);
// Init server
std::thread serverInit(MasterServerInit);
serverInit.detach();
// Main message loop:
MSG msg;
while (GetMessage(&msg, NULL, 0, 0))
{
switch (msg.message)
{
case WM_KEYDOWN:
{
if(VK_RETURN == msg.wParam)
{
char buff[256];
GetWindowText(gEnv->consoleBox,buff,256);
gEnv->pConsole->Read(buff);
SetWindowText(gEnv->consoleBox, "");
}
break;
}
default:
break;
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return (int) msg.wParam;
}
void setup() {
Serial.begin(9600);
Serial.println();
Serial.print(SELF_NAME);
Serial.println(F(" started..."));
#ifdef ETHERNET_FEATURE
ethernetInit();
#endif
sdCardInit();
#ifdef RTC_FEATURE
rtcInit();
#endif
#ifdef SERVER_FEATURE
serverInit();
#endif
timersInit();
#ifdef MAJORDOMO_FEATURE
majordomoInit();
majordomoMegaLive();
#endif
#ifdef LAURENT_FEATURE
laurentInit();
#endif
#ifdef SD_INFO_FEATURE
sdInfoInit();
#endif
#ifdef SD_FILES_FEATURE
sdFilesInit();
#endif
#ifdef PING_FEATURE
pingInit();
#endif
#ifdef UPLOAD_FEATURE
uploadInit();
#endif
#ifdef PIRS_FEATURE
pirsInit();
#endif
#ifdef CONTACTS_FEATURE
contactsInit();
#endif
#ifdef TEMP_FEATURE
tempInit();
#endif
#ifdef ELECTRO_FEATURE
electroInit();
#endif
#ifdef KEYS_FEATURE
keysInit();
#endif
#ifdef LEDS_FEATURE
ledsInit();
#endif
#ifdef NOO_FEATURE
nooInit();
#endif
timeStamp();
Serialprint("GLOBAL Init DONE\n");
Serial.println();
timeStamp();
Serialprint("AMS WORK\n");
} // setup
void ICACHE_FLASH_ATTR wifi_check_ip(void *arg)
{
char IP[15];
char IP_temp[3];
uint8_t wifi_opmode;
system_soft_wdt_feed();
os_timer_disarm(&WiFiLinker);
wifi_opmode = wifi_get_opmode();
if(wifi_opmode==STATION_MODE){
switch(wifi_station_get_connect_status())
{
case STATION_GOT_IP:
wifi_get_ip_info(STATION_IF, &ipConfig);
if(ipConfig.ip.addr != 0 && connState !=WIFI_CONNECTED) {
connState = WIFI_CONNECTED;
ets_uart_printf("%d.%d.%d.%d",p[0],p[1],p[2],p[3]);
uart0_sendStr("\r");
itoa(p[0],IP_temp);
IP[0]=IP_temp[0];
IP[1]=IP_temp[1];
IP[2]=IP_temp[2];
IP[3]='.';
itoa(p[1],IP_temp);
IP[4]=IP_temp[0];
IP[5]=IP_temp[1];
IP[6]=IP_temp[2];
IP[7]='.';
itoa(p[2],IP_temp);
IP[8]=IP_temp[0];
IP[9]='.';
itoa(p[3],IP_temp);
IP[10]=IP_temp[0];
IP[11]=IP_temp[1];
IP[12]=IP_temp[2];
IP[13]=0;
IP[14]=0;
stringDraw(3, 1, "IP:");
stringDraw(3, 18, IP);
serverInit(23);
}
break;
case STATION_WRONG_PASSWORD:
connState = WIFI_CONNECTING_ERROR;
ets_uart_printf("WiFi connecting error, wrong password\n");
break;
case STATION_NO_AP_FOUND:
connState = WIFI_CONNECTING_ERROR;
ets_uart_printf("WiFi connecting error, ap not found\n");
setup_wifi_ap_mode();
break;
case STATION_CONNECT_FAIL:
connState = WIFI_CONNECTING_ERROR;
ets_uart_printf("WiFi connecting fail\n");
break;
default:
connState = WIFI_CONNECTING;
ets_uart_printf("WiFi connecting...\n");
stringDraw(3, 1, "WiFi connecting");
}
if(wifi_station_get_connect_status()!=STATION_GOT_IP){
os_timer_setfn(&WiFiLinker, (os_timer_func_t *)wifi_check_ip, NULL);
os_timer_arm(&WiFiLinker, 2000, 0);
}
}else{
ets_uart_printf("Conectar na rede SSID: %s\n",WIFI_CLIENTSSID_AP);
}
}
bool GameLabyrinth::init(Config& _conf, Input& _input)
{
if (!GameFreeScene::init(_conf, _input))
{
return false;
}
// resources
character_model = loadGraphObject(_conf, "character.model");
if (conf->getb("labyrinth.randomize", false))
{
srand((unsigned int)(globalTimer.timestamp()*1000));
}
else
{
srand((unsigned int)(conf->geti("labyrinth.rand_seed", 0)));
}
if (conf->gets("camera.mode", "fixed") == "fixed")
{
cameraMode = C_FIXED;
spectator.camera.setDirection(v3(1, 1, -0.3f));
}
else
{
cameraMode = C_FREE;
}
if (!initAgeia())
{
abort_init("PhysX", "Cannot init PhysX");
return false;
}
// network
std::string net_role_str = conf->gets("net.role", "server");
if (!loadScene(conf->find("scene")))
{
return false;
}
if (net_role_str == "server")
{
if (!serverInit())
{
return false;
}
game_state = GAME_PLAYING;
}
else if (net_role_str == "client")
{
if (!clientInit())
{
return false;
}
}
else
{
abort_init("net", "Unknown net role '" + net_role_str + "'");
}
createPhysicWorld();
netTimerSend.start();
netTimerReceive.start();
netTimerReconnect.start();
refresh_needed = true;
cell_visibility_set.clear();
injected_objects.clear();
return true;
}
int main(int argc, char *argv[])
{
int portno,map_id;
pthread_t receive_connection_thread;
int receive_t;
portno=atoi(argv[1]);
char usertext[10];
system("setterm -term linux -back green -fore white -bold on -clear");
//system("gnome-terminal ");
//gotoxy(50,50);
fflush(stdout);
clrScreen();
printCenter("Max No. of Players : ");
scanf("%d",&max_players);
clrScreen();
printCenter("No. Of Automatic Commandos : ");
scanf("%d",&auto_commando_count);
clrScreen();
printCenter("No.Of Automatic ALiens : ");
scanf("%d",&auto_alien_count);
printCenter(" Choose Arena\n");
printCenter("******************\n");
printCenter("1 : Forest_War\n");
printCenter("2 : Nuke_Alien\n");
printCenter("3 : Mountain_Comm\n");
printCenter("4 : Mission_Earth\n");
printCenter("5 : Collapse_CA\n");
printCenter("Your Choice : ");
scanf("%d",&map_id);
clrScreen();
initializeGame(map_id);
serverInit(portno);
printCenter(" *********The Game Begins Now*******\n");
printCenter(" Server Established \n");
printCenter("Waiting For Incomming Connections...\n");
//timer();
//change
pthread_create(&receive_connection_thread,NULL,receiveIncomingConnections,(void *)&receive_t);
//receiveIncomingConnections();
while(1)
{
printCenter("Press x to Shutdown Server : ");
scanf("%s",usertext);
if(strcmp(usertext,"q")==0)
{
system("setterm -default");
system("clear");
printf("All Connections Terminated\n");
printf("Server ShutDown\n");
showAllData(-1);
shutDownServer();
//exit(0);
}
else
{
printCenter("Please enter x to quit :\n");
}
}
}
void user_init(void)
{
uint8_t i;
UartDev.data_bits = EIGHT_BITS;
UartDev.parity = NONE_BITS;
UartDev.stop_bits = ONE_STOP_BIT;
uart_init(BIT_RATE_9600, BIT_RATE_9600);
i2c_init();
SSD1306Init();
clearScreen();
stringDraw(4, 1, "SDK ver:");
stringDraw(4, 48, (char*)system_get_sdk_version());
// ets_uart_printf("reset reason: %d\n", reset_info->reason);
// ets_uart_printf("Booting...\n");
// ets_uart_printf("SDK version:%s\n", system_get_sdk_version());
setup_wifi_st_mode();
if(wifi_get_phy_mode() != PHY_MODE_11N)
wifi_set_phy_mode(PHY_MODE_11N);
if(wifi_station_get_auto_connect() == 0)
wifi_station_set_auto_connect(1);
#ifdef CONFIG_DYNAMIC
flash_param_t *flash_param;
flash_param_init();
flash_param = flash_param_get();
UartDev.data_bits = GETUART_DATABITS(flash_param->uartconf0);
UartDev.parity = GETUART_PARITYMODE(flash_param->uartconf0);
UartDev.stop_bits = GETUART_STOPBITS(flash_param->uartconf0);
uart_init(flash_param->baud, BIT_RATE_115200);
#else
#endif
//ets_uart_printf("size flash_param_t %d\n", sizeof(flash_param_t));
serverInit(23);
#ifdef CONFIG_GPIO
config_gpio();
#endif
// os_timer_disarm(&timer_1);
// os_timer_setfn(&timer_1, (os_timer_func_t *)timer_1_int, NULL);
// os_timer_arm(&timer_1, 1000, 1);
// Wait for Wi-Fi connection
os_timer_disarm(&WiFiLinker);
os_timer_setfn(&WiFiLinker, (os_timer_func_t *)wifi_check_ip, NULL);
os_timer_arm(&WiFiLinker, 1000, 0);
system_os_task(recvTask, recvTaskPrio, recvTaskQueue, recvTaskQueueLen);
}
