int main(int argc, char** argv) { if (argc > 1) { respondToPipe(argv[1]); return 0; } struct Allocator* alloc = MallocAllocator_new(1<<20); char* path = Process_getPath(alloc); Assert_true(path != NULL); Assert_true(strstr(path, "/Process_test")); Assert_true(path[0] == '/'); int fds[2]; Assert_true(!Pipe_createUniPipe(fds)); char fdName[32]; snprintf(fdName, 32, "%d", fds[1]); char* args[] = { fdName, NULL }; Assert_true(!Process_spawn(path, args)); char output[32] = {0}; ssize_t len = read(fds[0], output, 31); Assert_true(len == strlen(MESSAGE)); Assert_true(!strcmp(MESSAGE, output)); }
static void spawnAngel(char* testName, char* asClientPipeName, struct EventBase* base, struct Allocator* alloc) { char* args[] = { testName, "angel", asClientPipeName, NULL }; struct Allocator* tempAlloc = Allocator_child(alloc); char* path = Process_getPath(tempAlloc); Assert_true(path); Process_spawn(path, args, base, alloc); Allocator_free(tempAlloc); }
static void test_c64_vice_connect(void**) { int count = 0; PluginData* pluginData; pluginData = PluginHandler_getBackendPlugins(&count)[0]; // Lanuch C64 VICE // TODO: Fix hardcoded path #ifdef PRODBG_MAC //const char* viceLaunchPath = "../../vice/x64.app/Contents/MacOS/x64"; const char* viceLaunchPath = "/Applications/VICE/x64.app/Contents/MacOS/x64"; #elif PRODBG_WIN const char* viceLaunchPath = "..\\..\\vice\\x64.exe"; #else // Not supported on Linux yet const char* viceLaunchPath = 0; #endif assert_non_null(viceLaunchPath); //const char* argv[] = { viceLaunchPath, "-remotemonitor", "-console", "examples/c64_vice/test.prg", 0 }; const char* argv[] = { viceLaunchPath, "-remotemonitor", "-console", 0 }; s_viceHandle = Process_spawn(viceLaunchPath, argv); assert_non_null(s_viceHandle); // Wait 3 sec for VICE to launch Time_sleepMs(3000); // TODO: Non hard-coded path s_session = Session_createLocal((PDBackendPlugin*)pluginData->plugin, 0); // make sure we attach to VICE PDWriter* writer = s_session->currentWriter; PDWrite_eventBegin(writer, PDEventType_menuEvent); PDWrite_u32(writer, "menu_id", 0); PDWrite_eventEnd(writer); Session_update(s_session); // We haven't setup vice at this point so no connect assert_int_not_equal(s_session->state, PDDebugState_noTarget); }
static void initCore(char* coreBinaryPath, String* corePipeName, struct EventBase* base, struct Allocator* alloc, struct Except* eh) { char* args[] = { "core", corePipeName->bytes, NULL }; FILE* file; if ((file = fopen(coreBinaryPath, "r")) != NULL) { fclose(file); } else { Except_raise(eh, -1, "Can't open core executable [%s] for reading.", coreBinaryPath); } if (Process_spawn(coreBinaryPath, args, base, alloc)) { Except_raise(eh, -1, "Failed to spawn core process."); } }
static void spawnAngel(int* fromAngelOut, int* toAngelOut) { int pipeToAngel[2]; int pipeFromAngel[2]; Assert_true(!Pipe_createUniPipe(pipeToAngel) && !Pipe_createUniPipe(pipeFromAngel)); char pipeToAngelStr[8]; snprintf(pipeToAngelStr, 8, "%d", pipeToAngel[0]); char pipeFromAngelStr[8]; snprintf(pipeFromAngelStr, 8, "%d", pipeFromAngel[1]); char* args[] = { "angel", pipeToAngelStr, pipeFromAngelStr, NULL }; uint8_t allocBuff[256]; struct Allocator* tempAlloc = BufferAllocator_new(allocBuff, 256); char* path = Process_getPath(tempAlloc); Assert_true(path); Process_spawn(path, args); *fromAngelOut = pipeFromAngel[0]; *toAngelOut = pipeToAngel[1]; }
/** * Initialize the core. * * @param coreBinaryPath the path to the core binary. * @param toCore a pointer to an int which will be set to the * file descriptor for writing to the core. * @param fromCore a pointer to an int which will be set to the * file descriptor for reading from the core. * @param eh an exception handler in case something goes wrong. */ static void initCore(char* coreBinaryPath, int* toCore, int* fromCore, struct Except* eh) { int pipes[2][2]; if (Pipe_createUniPipe(pipes[0]) || Pipe_createUniPipe(pipes[1])) { Except_raise(eh, -1, "Failed to create pipes [%s]", Errno_getString()); } // Pipes used in the core process. #define TO_ANGEL (pipes[1][1]) #define FROM_ANGEL (pipes[0][0]) // Pipes used in the angel process (here). #define TO_CORE (pipes[0][1]) #define FROM_CORE (pipes[1][0]) char toAngel[32]; char fromAngel[32]; snprintf(toAngel, 32, "%u", TO_ANGEL); snprintf(fromAngel, 32, "%u", FROM_ANGEL); char* args[] = { "core", toAngel, fromAngel, NULL }; FILE* file; if ((file = fopen(coreBinaryPath, "r")) != NULL) { fclose(file); } else { Except_raise(eh, -1, "Can't open core executable [%s] for reading.", coreBinaryPath); } if (Process_spawn(coreBinaryPath, args)) { Except_raise(eh, -1, "Failed to spawn core process."); } *toCore = TO_CORE; *fromCore = FROM_CORE; }
int main(int argc, char** argv) { #ifdef Log_KEYS fprintf(stderr, "Log_LEVEL = KEYS, EXPECT TO SEE PRIVATE KEYS IN YOUR LOGS!\n"); #endif Assert_true(argc > 0); struct Except* eh = NULL; // Allow it to allocate 4MB struct Allocator* allocator = MallocAllocator_new(1<<22); struct Random* rand = Random_new(allocator, NULL, eh); struct EventBase* eventBase = EventBase_new(allocator); if (argc == 2) { // one argument if (strcmp(argv[1], "--help") == 0) { return usage(argv[0]); } else if (strcmp(argv[1], "--genconf") == 0) { return genconf(rand); } else if (strcmp(argv[1], "--pidfile") == 0) { // Performed after reading the configuration } else if (strcmp(argv[1], "--reconf") == 0) { // Performed after reading the configuration } else if (strcmp(argv[1], "--bench") == 0) { return benchmark(); } else if (strcmp(argv[1], "--version") == 0) { //printf("Version ID: %s\n", RouterModule_gitVersion()); return 0; } else { fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], argv[1]); fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]); return -1; } } else if (argc > 2) { // more than one argument? fprintf(stderr, "%s: too many arguments\n", argv[0]); fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]); return -1; } if (isatty(STDIN_FILENO)) { // We were started from a terminal // The chances an user wants to type in a configuration // bij hand are pretty slim so we show him the usage return usage(argv[0]); } else { // We assume stdin is a configuration file and that we should // start routing } struct Reader* stdinReader = FileReader_new(stdin, allocator); Dict config; if (JsonBencSerializer_get()->parseDictionary(stdinReader, allocator, &config)) { fprintf(stderr, "Failed to parse configuration.\n"); return -1; } struct Writer* logWriter = FileWriter_new(stdout, allocator); struct Log* logger = WriterLog_new(logWriter, allocator); // --------------------- Setup Pipes to Angel --------------------- // int pipeToAngel[2]; int pipeFromAngel[2]; if (Pipe_createUniPipe(pipeToAngel) || Pipe_createUniPipe(pipeFromAngel)) { Except_raise(eh, -1, "Failed to create pipes to angel [%s]", Errno_getString()); } char pipeToAngelStr[8]; snprintf(pipeToAngelStr, 8, "%d", pipeToAngel[0]); char pipeFromAngelStr[8]; snprintf(pipeFromAngelStr, 8, "%d", pipeFromAngel[1]); char* args[] = { "angel", pipeToAngelStr, pipeFromAngelStr, NULL }; // --------------------- Spawn Angel --------------------- // String* privateKey = Dict_getString(&config, String_CONST("privateKey")); String* corePath = getCorePath(allocator); if (!corePath) { Except_raise(eh, -1, "Can't find a usable cjdns core executable, " "make sure it is in the same directory as cjdroute"); } if (!privateKey) { Except_raise(eh, -1, "Need to specify privateKey."); } Log_info(logger, "Forking angel to background."); Process_spawn(corePath->bytes, args); // --------------------- Get Admin --------------------- // Dict* configAdmin = Dict_getDict(&config, String_CONST("admin")); String* adminPass = Dict_getString(configAdmin, String_CONST("password")); String* adminBind = Dict_getString(configAdmin, String_CONST("bind")); if (!adminPass) { adminPass = String_newBinary(NULL, 32, allocator); Random_base32(rand, (uint8_t*) adminPass->bytes, 32); adminPass->len = strlen(adminPass->bytes); } if (!adminBind) { adminBind = String_new("127.0.0.1:0", allocator); } // --------------------- Get user for angel to setuid() ---------------------- // String* securityUser = NULL; List* securityConf = Dict_getList(&config, String_CONST("security")); for (int i = 0; i < List_size(securityConf); i++) { securityUser = Dict_getString(List_getDict(securityConf, i), String_CONST("setuser")); if (securityUser) { int64_t* ea = Dict_getInt(List_getDict(securityConf, i), String_CONST("exemptAngel")); if (ea && *ea) { securityUser = NULL; } break; } } // --------------------- Pre-Configure Angel ------------------------- // Dict* preConf = Dict_new(allocator); Dict* adminPreConf = Dict_new(allocator); Dict_putDict(preConf, String_CONST("admin"), adminPreConf, allocator); Dict_putString(adminPreConf, String_CONST("core"), corePath, allocator); Dict_putString(preConf, String_CONST("privateKey"), privateKey, allocator); Dict_putString(adminPreConf, String_CONST("bind"), adminBind, allocator); Dict_putString(adminPreConf, String_CONST("pass"), adminPass, allocator); if (securityUser) { Dict_putString(adminPreConf, String_CONST("user"), securityUser, allocator); } #define CONFIG_BUFF_SIZE 1024 uint8_t buff[CONFIG_BUFF_SIZE] = {0}; struct Writer* toAngelWriter = ArrayWriter_new(buff, CONFIG_BUFF_SIZE - 1, allocator); if (StandardBencSerializer_get()->serializeDictionary(toAngelWriter, preConf)) { Except_raise(eh, -1, "Failed to serialize pre-configuration"); } write(pipeToAngel[1], buff, toAngelWriter->bytesWritten(toAngelWriter)); Log_keys(logger, "Sent [%s] to angel process.", buff); // --------------------- Get Response from Angel --------------------- // uint32_t amount = Waiter_getData(buff, CONFIG_BUFF_SIZE, pipeFromAngel[0], eventBase, eh); Dict responseFromAngel; struct Reader* responseFromAngelReader = ArrayReader_new(buff, amount, allocator); if (StandardBencSerializer_get()->parseDictionary(responseFromAngelReader, allocator, &responseFromAngel)) { Except_raise(eh, -1, "Failed to parse pre-configuration response [%s]", buff); } // --------------------- Get Admin Addr/Port/Passwd --------------------- // Dict* responseFromAngelAdmin = Dict_getDict(&responseFromAngel, String_CONST("admin")); adminBind = Dict_getString(responseFromAngelAdmin, String_CONST("bind")); if (!adminBind) { Except_raise(eh, -1, "didn't get address and port back from angel"); } struct Sockaddr_storage adminAddr; if (Sockaddr_parse(adminBind->bytes, &adminAddr)) { Except_raise(eh, -1, "Unable to parse [%s] as an ip address port, eg: 127.0.0.1:11234", adminBind->bytes); } // sanity check Assert_true(EventBase_eventCount(eventBase) == 0); // --------------------- Configuration ------------------------- // Configurator_config(&config, &adminAddr.addr, adminPass, eventBase, logger, allocator); return 0; }
int main(int argc, char** argv) { #ifdef Log_KEYS fprintf(stderr, "Log_LEVEL = KEYS, EXPECT TO SEE PRIVATE KEYS IN YOUR LOGS!\n"); #endif if (argc < 2) { // Fall through. } else if (!CString_strcmp("angel", argv[1])) { return AngelInit_main(argc, argv); } else if (!CString_strcmp("core", argv[1])) { return Core_main(argc, argv); } Assert_ifParanoid(argc > 0); struct Except* eh = NULL; // Allow it to allocate 8MB struct Allocator* allocator = MallocAllocator_new(1<<23); struct Random* rand = Random_new(allocator, NULL, eh); struct EventBase* eventBase = EventBase_new(allocator); if (argc == 2) { // one argument if ((CString_strcmp(argv[1], "--help") == 0) || (CString_strcmp(argv[1], "-h") == 0)) { return usage(allocator, argv[0]); } else if (CString_strcmp(argv[1], "--genconf") == 0) { return genconf(rand); } else if (CString_strcmp(argv[1], "--pidfile") == 0) { // deprecated fprintf(stderr, "'--pidfile' option is deprecated.\n"); return 0; } else if (CString_strcmp(argv[1], "--reconf") == 0) { // Performed after reading the configuration } else if (CString_strcmp(argv[1], "--bench") == 0) { return benchmark(); } else if ((CString_strcmp(argv[1], "--version") == 0) || (CString_strcmp(argv[1], "-v") == 0)) { printf("Cjdns protocol version: %d\n", Version_CURRENT_PROTOCOL); return 0; } else if (CString_strcmp(argv[1], "--cleanconf") == 0) { // Performed after reading configuration } else if (CString_strcmp(argv[1], "--nobg") == 0) { // Performed while reading configuration } else { fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], argv[1]); fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]); return -1; } } else if (argc > 2) { // more than one argument? fprintf(stderr, "%s: too many arguments [%s]\n", argv[0], argv[1]); fprintf(stderr, "Try `%s --help' for more information.\n", argv[0]); // because of '--pidfile $filename'? if (CString_strcmp(argv[1], "--pidfile") == 0) { fprintf(stderr, "\n'--pidfile' option is deprecated.\n"); } return -1; } if (isatty(STDIN_FILENO)) { // We were started from a terminal // The chances an user wants to type in a configuration // bij hand are pretty slim so we show him the usage return usage(allocator, argv[0]); } else { // We assume stdin is a configuration file and that we should // start routing } struct Reader* stdinReader = FileReader_new(stdin, allocator); Dict config; if (JsonBencSerializer_get()->parseDictionary(stdinReader, allocator, &config)) { fprintf(stderr, "Failed to parse configuration.\n"); return -1; } if (argc == 2 && CString_strcmp(argv[1], "--cleanconf") == 0) { struct Writer* stdoutWriter = FileWriter_new(stdout, allocator); JsonBencSerializer_get()->serializeDictionary(stdoutWriter, &config); printf("\n"); return 0; } int forceNoBackground = 0; if (argc == 2 && CString_strcmp(argv[1], "--nobg") == 0) { forceNoBackground = 1; } struct Writer* logWriter = FileWriter_new(stdout, allocator); struct Log* logger = WriterLog_new(logWriter, allocator); // --------------------- Get Admin --------------------- // Dict* configAdmin = Dict_getDict(&config, String_CONST("admin")); String* adminPass = Dict_getString(configAdmin, String_CONST("password")); String* adminBind = Dict_getString(configAdmin, String_CONST("bind")); if (!adminPass) { adminPass = String_newBinary(NULL, 32, allocator); Random_base32(rand, (uint8_t*) adminPass->bytes, 32); adminPass->len = CString_strlen(adminPass->bytes); } if (!adminBind) { Except_throw(eh, "You must specify admin.bind in the cjdroute.conf file."); } // --------------------- Welcome to cjdns ---------------------- // char* archInfo = ArchInfo_describe(ArchInfo_detect(), allocator); char* sysInfo = SysInfo_describe(SysInfo_detect(), allocator); Log_info(logger, "Cjdns %s %s", archInfo, sysInfo); // --------------------- Check for running instance --------------------- // Log_info(logger, "Checking for running instance..."); checkRunningInstance(allocator, eventBase, adminBind, adminPass, logger, eh); // --------------------- Setup Pipes to Angel --------------------- // char angelPipeName[64] = "client-angel-"; Random_base32(rand, (uint8_t*)angelPipeName+13, 31); Assert_ifParanoid(EventBase_eventCount(eventBase) == 0); struct Pipe* angelPipe = Pipe_named(angelPipeName, eventBase, eh, allocator); Assert_ifParanoid(EventBase_eventCount(eventBase) == 2); angelPipe->logger = logger; char* args[] = { "angel", angelPipeName, NULL }; // --------------------- Spawn Angel --------------------- // String* privateKey = Dict_getString(&config, String_CONST("privateKey")); char* corePath = Process_getPath(allocator); if (!corePath) { Except_throw(eh, "Can't find a usable cjdns core executable, " "make sure it is in the same directory as cjdroute"); } if (!privateKey) { Except_throw(eh, "Need to specify privateKey."); } Log_info(logger, "Forking angel to background."); Process_spawn(corePath, args, eventBase, allocator); // --------------------- Get user for angel to setuid() ---------------------- // String* securityUser = NULL; List* securityConf = Dict_getList(&config, String_CONST("security")); for (int i = 0; securityConf && i < List_size(securityConf); i++) { securityUser = Dict_getString(List_getDict(securityConf, i), String_CONST("setuser")); if (securityUser) { int64_t* ea = Dict_getInt(List_getDict(securityConf, i), String_CONST("exemptAngel")); if (ea && *ea) { securityUser = NULL; } break; } } // --------------------- Pre-Configure Angel ------------------------- // Dict* preConf = Dict_new(allocator); Dict* adminPreConf = Dict_new(allocator); Dict_putDict(preConf, String_CONST("admin"), adminPreConf, allocator); Dict_putString(adminPreConf, String_CONST("core"), String_new(corePath, allocator), allocator); Dict_putString(preConf, String_CONST("privateKey"), privateKey, allocator); Dict_putString(adminPreConf, String_CONST("bind"), adminBind, allocator); Dict_putString(adminPreConf, String_CONST("pass"), adminPass, allocator); if (securityUser) { Dict_putString(adminPreConf, String_CONST("user"), securityUser, allocator); } Dict* logging = Dict_getDict(&config, String_CONST("logging")); if (logging) { Dict_putDict(preConf, String_CONST("logging"), logging, allocator); } struct Message* toAngelMsg = Message_new(0, 1024, allocator); BencMessageWriter_write(preConf, toAngelMsg, eh); Interface_sendMessage(&angelPipe->iface, toAngelMsg); Log_debug(logger, "Sent [%d] bytes to angel process", toAngelMsg->length); // --------------------- Get Response from Angel --------------------- // struct Message* fromAngelMsg = InterfaceWaiter_waitForData(&angelPipe->iface, eventBase, allocator, eh); Dict* responseFromAngel = BencMessageReader_read(fromAngelMsg, allocator, eh); // --------------------- Get Admin Addr/Port/Passwd --------------------- // Dict* responseFromAngelAdmin = Dict_getDict(responseFromAngel, String_CONST("admin")); adminBind = Dict_getString(responseFromAngelAdmin, String_CONST("bind")); if (!adminBind) { Except_throw(eh, "didn't get address and port back from angel"); } struct Sockaddr_storage adminAddr; if (Sockaddr_parse(adminBind->bytes, &adminAddr)) { Except_throw(eh, "Unable to parse [%s] as an ip address port, eg: 127.0.0.1:11234", adminBind->bytes); } // sanity check, Pipe_named() creates 2 events, see above. Assert_ifParanoid(EventBase_eventCount(eventBase) == 2); // --------------------- Configuration ------------------------- // Configurator_config(&config, &adminAddr.addr, adminPass, eventBase, logger, allocator); // --------------------- noBackground ------------------------ // int64_t* noBackground = Dict_getInt(&config, String_CONST("noBackground")); if (forceNoBackground || (noBackground && *noBackground)) { EventBase_beginLoop(eventBase); } //Allocator_free(allocator); return 0; }
void xrServer::SLS_Default () { if (game->custom_sls_default()) { game->sls_default (); return; } #ifdef USE_DESIGNER_KEY bool _designer = !!strstr(Core.Params,"-designer"); CSE_ALifeCreatureActor *_actor = 0; #endif string256 fn_spawn; if (FS.exist(fn_spawn, "$level$", "level.spawn")) { IReader* SP = FS.r_open(fn_spawn); NET_Packet P; u32 S_id; for (IReader *S = SP->open_chunk_iterator(S_id); S; S = SP->open_chunk_iterator(S_id,S)) { P.B.count = S->length(); S->r (P.B.data,P.B.count); u16 ID; P.r_begin (ID); R_ASSERT (M_SPAWN==ID); ClientID clientID;clientID.set(0); #ifdef USE_DESIGNER_KEY CSE_Abstract *entity = #endif Process_spawn(P,clientID); #ifdef USE_DESIGNER_KEY if (_designer) { CSE_ALifeCreatureActor *actor = smart_cast<CSE_ALifeCreatureActor*>(entity); if (actor) _actor = actor; } #endif } FS.r_close (SP); } #ifdef USE_DESIGNER_KEY if (!_designer) return; if (_actor) return; _actor = smart_cast<CSE_ALifeCreatureActor*>(entity_Create("actor")); _actor->o_Position = Fvector().set(0.f,0.f,0.f); _actor->set_name_replace("designer"); _actor->s_flags.flags |= M_SPAWN_OBJECT_ASPLAYER; NET_Packet packet; packet.w_begin (M_SPAWN); _actor->Spawn_Write (packet,TRUE); u16 id; packet.r_begin (id); R_ASSERT (id == M_SPAWN); ClientID clientID; clientID.set (0); Process_spawn (packet,clientID); #endif }
u32 xrServer::OnMessage (NET_Packet& P, ClientID sender) // Non-Zero means broadcasting with "flags" as returned { if (g_pGameLevel && Level().IsDemoSave()) Level().Demo_StoreServerData(P.B.data, P.B.count); u16 type; P.r_begin (type); csPlayers.Enter (); VERIFY (verify_entities()); xrClientData* CL = ID_to_client(sender); switch (type) { case M_UPDATE: { Process_update (P,sender); // No broadcast VERIFY (verify_entities()); }break; case M_SPAWN: { // R_ASSERT(CL->flags.bLocal); if (CL->flags.bLocal) Process_spawn (P,sender); VERIFY (verify_entities()); }break; case M_EVENT: { Process_event (P,sender); VERIFY (verify_entities()); }break; case M_EVENT_PACK: { NET_Packet tmpP; while (!P.r_eof()) { tmpP.B.count = P.r_u8(); P.r (&tmpP.B.data, tmpP.B.count); OnMessage (tmpP, sender); }; }break; case M_CL_UPDATE: { xrClientData* CL = ID_to_client (sender); if (!CL) break; CL->net_Ready = TRUE; if (!CL->net_PassUpdates) break; //------------------------------------------------------------------- u32 ClientPing = CL->stats.getPing(); P.w_seek(P.r_tell()+2, &ClientPing, 4); //------------------------------------------------------------------- if (SV_Client) SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE)); VERIFY (verify_entities()); }break; case M_MOVE_PLAYERS_RESPOND: { xrClientData* CL = ID_to_client (sender); if (!CL) break; CL->net_Ready = TRUE; CL->net_PassUpdates = TRUE; }break; //------------------------------------------------------------------- case M_CL_PING_CHALLENGE: { P.r_u32(); u32 id = sender.value(); P.w_seek( P.r_tell(), &(id), 4); if (SV_Client) SendTo (SV_Client->ID, P, net_flags(FALSE)); }break; case M_CL_PING_CHALLENGE_RESPOND: { P.r_u32(); u32 id = P.r_u32(); ClientID clientID; clientID.set(id); u32 clLastPing = P.r_u32(); xrClientData* pCL = ID_to_client(clientID); pCL->ps->Rping = u16(clLastPing); SendTo (clientID, P, net_flags(FALSE)); }break; //------------------------------------------------------------------- case M_CL_INPUT: { xrClientData* CL = ID_to_client (sender); if (CL) CL->net_Ready = TRUE; if (SV_Client) SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE)); VERIFY (verify_entities()); }break; case M_GAMEMESSAGE: { ClientID clientID;clientID.setBroadcast(); SendBroadcast (clientID,P,net_flags(TRUE,TRUE)); VERIFY (verify_entities()); }break; case M_CLIENTREADY: { xrClientData* CL = ID_to_client(sender); if (CL) { CL->net_Ready = TRUE; CL->ps->DeathTime = Device.dwTimeGlobal; game->OnPlayerConnectFinished(sender); }; game->signal_Syncronize (); VERIFY (verify_entities()); }break; case M_SWITCH_DISTANCE: { game->switch_distance (P,sender); VERIFY (verify_entities()); }break; case M_CHANGE_LEVEL: { if (game->change_level(P,sender)){ ClientID clientID;clientID.setBroadcast(); SendBroadcast (clientID,P,net_flags(TRUE,TRUE)); } VERIFY (verify_entities()); }break; case M_SAVE_GAME: { game->save_game (P,sender); VERIFY (verify_entities()); }break; case M_LOAD_GAME: { game->load_game (P,sender); ClientID clientID;clientID.setBroadcast(); SendBroadcast (clientID,P,net_flags(TRUE,TRUE)); VERIFY (verify_entities()); }break; case M_RELOAD_GAME: { ClientID clientID;clientID.setBroadcast(); SendBroadcast (clientID,P,net_flags(TRUE,TRUE)); VERIFY (verify_entities()); }break; case M_SAVE_PACKET: { Process_save (P,sender); VERIFY (verify_entities()); }break; case M_CLIENT_REQUEST_CONNECTION_DATA: { xrClientData* CL = ID_to_client (sender); OnCL_Connected (CL); }break; case M_CHAT_MESSAGE: { xrClientData *l_pC = ID_to_client(sender); OnChatMessage (&P, l_pC); }break; case M_CHANGE_LEVEL_GAME: { ClientID CID; CID.set (0xffffffff); SendBroadcast (CID,P,net_flags(TRUE,TRUE)); }break; case M_CL_AUTH: { game->AddDelayedEvent (P,GAME_EVENT_PLAYER_AUTH, 0, sender); }break; case M_PAUSE_GAME: { ClientID clientID;clientID.setBroadcast(); SendBroadcast (clientID,P,net_flags(TRUE,TRUE)); }break; case M_STATISTIC_UPDATE: { ClientID clientID;clientID.setBroadcast(); if (SV_Client) SendBroadcast (SV_Client->ID,P,net_flags(TRUE,TRUE)); else SendBroadcast (clientID,P,net_flags(TRUE,TRUE)); }break; case M_STATISTIC_UPDATE_RESPOND: { if (SV_Client) SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE)); }break; case M_PLAYER_FIRE: { if (game) game->OnPlayerFire(sender, P); }break; } VERIFY (verify_entities()); csPlayers.Leave (); return IPureServer::OnMessage(P, sender); }
void xrServer::Update () { NET_Packet Packet; u32 position; csPlayers.Enter (); VERIFY (verify_entities()); // game update game->ProcessDelayedEvent(); game->Update (); // spawn queue u32 svT = Device.TimerAsync(); while (!(q_respawn.empty() || (svT<q_respawn.begin()->timestamp))) { // get svs_respawn R = *q_respawn.begin(); q_respawn.erase (q_respawn.begin()); // CSE_Abstract* E = ID_to_entity(R.phantom); E->Spawn_Write (Packet,FALSE); u16 ID; Packet.r_begin (ID); R_ASSERT(M_SPAWN==ID); ClientID clientID; clientID.set(0xffff); Process_spawn (Packet,clientID); } // for (u32 client=0; client<net_Players.size(); ++client) { // Initialize process and check for available bandwidth xrClientData* Client = (xrClientData*) net_Players [client]; if (!Client->net_Ready) continue; if (!HasBandwidth(Client) #ifdef DEBUG && !g_sv_SendUpdate #endif ) continue; // Send relevant entities to client // CSE_Abstract* Base = Client->owner; u16 PacketType = M_UPDATE; Packet.w_begin (PacketType); // GameUpdate ++(Client->game_replicate_id); u32 g_it = (Client->game_replicate_id % client_Count()); // u32 g_id = net_Players[g_it]->ID; ClientID g_id = net_Players[g_it]->ID; game->net_Export_Update (Packet,Client->ID,g_id); // if (!Client->flags.bLocal) game->net_Export_GameTime(Packet); if (!Client->flags.bLocal || client_Count() == 1) { #ifdef DEBUG if (g_Dump_Update_Write) Msg("---- UPDATE_Write to %s --- ", *(Client->Name)); #endif // Entities NET_Packet tmpPacket; xrS_entities::iterator I=entities.begin(),E=entities.end(); for (; I!=E; ++I) { CSE_Abstract& Test = *(I->second); if (0==Test.owner) continue; // Phantom(?) if (!Test.net_Ready) continue; if (Test.owner == Client && Client->flags.bLocal) continue; // Can't be relevant if (Test.s_flags.is(M_SPAWN_OBJECT_PHANTOM)) continue; // Surely: phantom tmpPacket.B.count = 0; // write specific data { tmpPacket.w_u16 (Test.ID ); tmpPacket.w_chunk_open8 (position ); Test.UPDATE_Write (tmpPacket ); #ifdef DEBUG if (g_Dump_Update_Write) Msg("* %s : %d", Test.name(), u32(tmpPacket.w_tell()-position)-sizeof(u8)); #endif tmpPacket.w_chunk_close8 (position ); if (Packet.B.count + tmpPacket.B.count < NET_PacketSizeLimit) { Packet.w(tmpPacket.B.data, tmpPacket.B.count); } else { if (Packet.B.count > 2) { // if (!Client->flags.bLocal) // Msg ("- Server Update[%d] to Client : %d", PacketType, Packet.B.count); SendTo (Client->ID,Packet,net_flags(FALSE,TRUE)); } PacketType = M_UPDATE_OBJECTS; Packet.w_begin(PacketType); } } } #ifdef DEBUG if (g_Dump_Update_Write) Msg("----------------------- "); #endif }; if (Packet.B.count > 2) { // if (!Client->flags.bLocal) // Msg ("- Server Update[%d] to Client : %d", PacketType, Packet.B.count); SendTo (Client->ID,Packet,net_flags(FALSE,TRUE)); } } #ifdef DEBUG g_sv_SendUpdate = 0; #endif if (game->sv_force_sync) Perform_game_export(); VERIFY (verify_entities()); //----------------------------------------------------- //Remove any of long time disconnected players for (u32 DI = 0; DI<net_Players_disconnected.size(); DI++) { IClient* CL = net_Players_disconnected[DI]; if (CL->dwTime_LastUpdate+g_sv_Client_Reconnect_Time*60000<Device.dwTimeGlobal) client_Destroy(CL); } //----------------------------------------------------- csPlayers.Leave (); }