CnxInfo::CnxInfo(IN const CnxInfo &x) { addr = x.addr; saddr = x.saddr; init_strings(); }
int sh_setenv(t_cmd *cmd, t_env *env) { t_var *temp; t_var *start; t_var *p_var; start = NULL; if (setenv_isvalid(cmd, env)) return (1); temp = init_strings(env->var, &p_var); while (p_var) { if (ft_strcmp(cmd->split[1], p_var->name) == 0) return (sh_setenv_var(p_var, cmd, env)); temp = p_var; p_var = p_var->next; } env_list_add(&temp, &start); temp->name = ft_strdup(cmd->split[1]); temp->value = (cmd->split[2]) ? ft_strdup(cmd->split[2]) : NULL; env->nb++; if (cmd->env) array2d_free(cmd->env); if (env->var == NULL) env->var = temp; cmd->env = env_list_to_array(env->var, env->nb); return (0); }
int get_next_line(int fd, char **line) { static char *s[1]; char *buff; char *tmp; int ret; init_strings(&buff, &tmp); fd > -1 && (read(fd, tmp, 0) >= 0) ? buff = malloc(BUFF_SIZE + 1) : NULL; if (fd > -1 && (read(fd, tmp, 0) >= 0)) !s[fd] ? (s[fd] = ft_strnew(0)) : (tmp = ft_strchr(s[fd], '\n')); if (!buff) return (-1); while (fd > -1 && line && !tmp && (ret = read(fd, buff, BUFF_SIZE)) > 0) { buff[ret] = '\0'; (tmp = ft_strjoin(s[fd], buff)) ? free(s[fd]) : NULL; s[fd] = tmp; tmp = ft_strchr(s[fd], '\n'); } fd > -1 && (read(fd, tmp, 0) >= 0) ? free(buff) : NULL; if ((fd < 0 || ret < 0 || !line) || (!tmp && s[fd][0] == '\0')) return (!tmp && s[fd][0] == '\0' ? 0 : -1); *line = (tmp ? ft_strsub(s[fd], 0, tmp - s[fd]) : ft_strdup(s[fd])); s[fd] = (tmp ? ft_strcpy(s[fd], ++tmp) : ft_strdup("\0")); return (ft_strlen(*line)); }
int main(void) { SetConsoleTitle(TITLE); mtx_init(&gmutex, mtx_plain); cnd_init(&gcond); init_timer(); init_path(); init_strings(); init_server(); initpackets(); //test_map(1); thrd_create(&t1, initsocket, (void*)0); thrd_create(&t2, commands, (void*)0); server_loop(); destroy_server(); mtx_destroy(&gmutex); cnd_destroy(&gcond); #if _DEBUG VLDReportLeaks(); #endif exit(TRUE);// Exit program }
token_initer::token_initer() { init_ascii(); init_latin1(); init_special_chars(); init_strings(); default_token_info.set(TOKEN_OTHER); }
CnxInfo::CnxInfo(IN in_addr p_in_addr, IN int p_port) { addr.sin_family = AF_INET;; addr.sin_addr = p_in_addr; addr.sin_port = ::htons(p_port); init_strings(); }
void CnxInfo::init_from_hostname(const char *host_name,int p_port) { unsigned long ia = inet_addr(host_name); addr.sin_addr.S_un.S_addr = ia; addr.sin_family = AF_INET; addr.sin_port = ::htons(p_port); init_strings(); }
int main(int argc, char** argv) { if (argc != 2) { // Ensure that the user supplies a image filename fprintf(stderr,"Usage: %s image.nsi\n",argv[0]); return 1; // Return error and usage message if no file supplied } init_memory(argv[1]); // create a new memory image of the suppied filename init_strings(); // setup of core system strings, and opcode tables init_lexicon(); // define a basic lexicon compile(); // compile the source listings from stdin fini_memory(); // save the memory image and close the file return 0; // return success }
void rocPrestart() { unsigned short iflag; int stat; /* Check ffile for changes (usrstrutils) Useful for items that may change without re-download (e.g. prescale factors) */ init_strings(); ps1 = getint("ps1"); printf("usrstrutils configuration:\n"); printf("\tps1 = %d\n",ps1); /* Program/Init Trigger Supervisor and VME Modules Here */ tsReset(0); tsCsr2Set(TS_CSR2_LOCK_ALL); /* ROC Lock mode on all BRANCHES */ tsEnableInput(0xfff,0); /* Enable all Trigger inputs in non-strobe mode */ tsRoc(0,0,0,0); /* Enable ACK 0,1 on BRANCH 1 and ACK 2 on Branch 2*/ /* Synchronization programming */ tsSync(100); /* schedule Sync every 100th physics trigger */ tsCsr2Set(TS_CSR2_ENABLE_SYNC); /* Enable Scheduled syncs */ /* Set nominal Level 2/3 timer values */ tsTimerWrite(TS_TIMER_L2A,0x05); /* Level 2 Timer 40ns/count */ tsTimerWrite(TS_TIMER_L3A,0x05); /* Level 3 Timer 40ns/count */ /* Front End Busy timer 40ns/count */ tsTimerWrite(TS_TIMER_FB,250); /* 250 = 10 microsec */ tsCsr2Set(TS_CSR2_ENABLE_FB_TIMER); /* Enable FEB Timer */ /* Construct TS memory data --- in the following model, all trigger patterns that form the memory address are assigned to trigger class 1. For those trigger patterns with a single hit, the ROC code is set to be the trigger input number. Otherwise, the ROC code is set to 0xE. All LEVEL 1 ACCEPT signals are asserted for every pattern. */ tsMemInit(); /* Fix special cases - both inputs 1 and 2 firing - type 13 (0xd) all L1 accept outputs firing 0xff03 */ tsMemWrite(3,0xdff03); /* Set specific input prescale factors */ tsPrescale(1,0); tsPrescale(2,0); printf("rocPrestart: User Prestart Executed\n"); }
STRING* ui_gettext(UI_LANG_ID lang, UI_STRING_ID string_id) { static STRING localized_strings[LANGS_MAX+1][STRS_MAX+1]; static int ready = 0; if(!ready) { init_strings(localized_strings); ready = 1; } if((lang > LANGS_MAX) || (string_id > STRS_MAX)) { return &canary; } return &localized_strings[lang][string_id]; }
STRING* ui_gettext(UI_LANG_ID lang, UI_STRING_ID string_id) { static STRING localized_strings[NUM_LANGS][NUM_STRS]; static int ready = 0; if(!ready) { init_strings(localized_strings); ready = 1; } if((lang >= NUM_LANGS) || (string_id >= NUM_STRS)) { return &canary; } return &localized_strings[lang][string_id]; }
void rocDownload() { int dmaMode; /* Initialize usrstrutils */ init_strings(); string1 = getflag("string"); string2 = getflag("string2"); printf("usrstrutils configuration:\n"); printf("\tstring1 = %d\n\tstring2 = %d\n",string1,string2); printf("rocDownload: User Download Executed\n"); }
/****************************************************************** * DllMain (jscript.@) */ BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) { TRACE("(%p %d %p)\n", hInstDLL, fdwReason, lpv); switch(fdwReason) { case DLL_PROCESS_ATTACH: DisableThreadLibraryCalls(hInstDLL); jscript_hinstance = hInstDLL; if(!init_strings()) return FALSE; break; case DLL_PROCESS_DETACH: if (lpv) break; free_strings(); } return TRUE; }
int main(int argc, const char * argv[]) { /* Name our little program */ strncpy(program_name, argv[0], short_strlen); /* Prepare ilu functions "database" */ init_strings(); /* initialize DevIL in order to get defined behavior of the app */ ilInit(); iluInit(); /* Prepare command line parsing */ Params * parameters = create_params(); /* Do the parsing */ parse_arguments(argc, argv, parameters); /* Finally do what we wanted */ do_stuff(parameters); /* Clean after the party */ destroy_params(parameters); return 0; }
/* slave information interface */ void init_sii(ecat_slave *esv) { int pdoe_idx = 0; memset(&esv->categories,0,sizeof(struct __sii_categories__)); init_si_info(&esv->categories.sii); init_strings(&esv->categories.strings, &esv->categories.strings_hdr); init_fmmu(&esv->categories.fmmu, &esv->categories.fmmu_hdr); init_syncm(esv, &esv->categories.syncm0, 0 ,&esv->categories.syncm_hdr0); init_syncm(esv, &esv->categories.syncm1, 1 ,&esv->categories.syncm_hdr1); init_general(esv, &esv->categories.general, &esv->categories.general_hdr); init_end_hdr(&esv->categories.endhdr); // pdos esv->categories.rxpdo_hdr.type = CAT_TYPE_RXPDO; esv->categories.rxpdo_hdr.size = sizeof(esv->categories.rxpdo)/2; esv->categories.rxpdo.entries = 2; esv->categories.rxpdo.flags = 0; esv->categories.rxpdo.name_idx = RXPDO_CAT_NAME_IDX + 1; esv->categories.rxpdo.synchronization = 0; esv->categories.rxpdo.syncm = 0; esv->categories.rxpdo.pdo_index = 0x1600; init_pdo(&esv->categories.rxpdo.pdo[0], 0x1600, 0X02, RX_PDO1_NAME_IDX + 1, 0, 8, 0); esv->pdoe_sizes[pdoe_idx++] = 8; init_pdo(&esv->categories.rxpdo.pdo[1], 0x1600, 0X01, RX_PDO2_NAME_IDX + 1, 0, 32, 0); esv->pdoe_sizes[pdoe_idx++] = 32; esv->categories.txpdo_hdr.type = CAT_TYPE_TXPDO; esv->categories.txpdo.entries = 2; esv->categories.txpdo.flags = 0; esv->categories.txpdo.name_idx = TXPDO_CAT_NAME_IDX +1; esv->categories.txpdo.synchronization = 0; esv->categories.txpdo.syncm = 1; esv->categories.txpdo.pdo_index = 0x1a00; esv->categories.txpdo_hdr.size = sizeof(esv->categories.txpdo)/2; init_pdo(&esv->categories.txpdo.pdo[0], 0x1a00, 0X02, TX_PDO1_NAME_IDX + 1, 0, 32, 0); esv->pdoe_sizes[pdoe_idx++] = 32; init_pdo(&esv->categories.txpdo.pdo[1], 0x1a00, 0X01, TX_PDO2_NAME_IDX + 1, 0, 16, 0); esv->pdoe_sizes[pdoe_idx++] = 16; }
int WWWLib_Init(Tcl_Interp *interp) { LibraryFunction *c; #ifdef CMDLINE HTProfile_newClient(APP_NAME, APP_VERSION); #else HTLibInit(APP_NAME, APP_VERSION); #endif Tcl_InitHashTable(&HTableAnchor, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableLink, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableList, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableReq, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableStream, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableVoid, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableAssoc, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableUser, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableCallback, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableHost, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableChunk, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableProt, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableConverter, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableCoder, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableAlertCallback, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableAlertPar, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableError, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableMIMEParseSet, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableCallback, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableNet, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableDNS, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableTrans, TCL_STRING_KEYS); Tcl_InitHashTable(&HTableChannel, TCL_STRING_KEYS); random_seed(); init_strings(); for(c = www_commands; c->name; c++){ Tcl_CreateCommand(interp, c->name, c->proc, c->data, NULL /* delete proc???*/); } return TCL_OK; }
int main P2(int, argc, char **, argv) { time_t tm; int i, new_mudlib = 0, got_defaults = 0; int no_ip_demon = 0; char *p; char version_buf[80]; #if 0 int dtablesize; #endif error_context_t econ; #if !defined(LATTICE) && !defined(OLD_ULTRIX) && !defined(sequent) && \ !defined(sgi) void tzset(); #endif struct lpc_predef_s predefs; #if !defined(__SASC) && (defined(AMITCP) || defined(AS225)) amiga_sockinit(); atexit(amiga_sockexit); #endif #ifdef WRAPPEDMALLOC wrappedmalloc_init(); #endif /* WRAPPEDMALLOC */ #ifdef DEBUGMALLOC MDinit(); #endif #if (defined(PROFILING) && !defined(PROFILE_ON) && defined(HAS_MONCONTROL)) moncontrol(0); #endif #if !defined(OLD_ULTRIX) && !defined(LATTICE) && !defined(sequent) tzset(); #endif boot_time = get_current_time(); const0.type = T_NUMBER; const0.u.number = 0; const1.type = T_NUMBER; const1.u.number = 1; /* const0u used by undefinedp() */ const0u.type = T_NUMBER; const0u.subtype = T_UNDEFINED; const0u.u.number = 0; /* const0n used by nullp() */ const0n.type = T_NUMBER; const0n.subtype = T_NULLVALUE; const0n.u.number = 0; fake_prog.program_size = 0; /* * Check that the definition of EXTRACT_UCHAR() is correct. */ p = (char *) &i; *p = -10; if (EXTRACT_UCHAR(p) != 0x100 - 10) { fprintf(stderr, "Bad definition of EXTRACT_UCHAR() in interpret.h.\n"); exit(-1); } /* * An added test: can we do EXTRACT_UCHAR(x++)? * (read_number, etc uses it) */ p = (char *) &i; (void) EXTRACT_UCHAR(p++); if ((p - (char *) &i) != 1) { fprintf(stderr, "EXTRACT_UCHAR() in interpret.h evaluates its argument more than once.\n"); exit(-1); } /* * Check the living hash table size */ if (CFG_LIVING_HASH_SIZE != 4 && CFG_LIVING_HASH_SIZE != 16 && CFG_LIVING_HASH_SIZE != 64 && CFG_LIVING_HASH_SIZE != 256 && CFG_LIVING_HASH_SIZE != 1024 && CFG_LIVING_HASH_SIZE != 4096) { fprintf(stderr, "CFG_LIVING_HASH_SIZE in options.h must be one of 4, 16, 64, 256, 1024, 4096, ...\n"); exit(-1); } #ifdef RAND srand(get_current_time()); #else # ifdef DRAND48 srand48(get_current_time()); # else # ifdef RANDOM srandom(get_current_time()); # else fprintf(stderr, "Warning: no random number generator specified!\n"); # endif # endif #endif current_time = get_current_time(); /* * Initialize the microsecond clock. */ init_usec_clock(); /* read in the configuration file */ got_defaults = 0; for (i = 1; (i < argc) && !got_defaults; i++) { if (argv[i][0] != '-') { set_defaults(argv[i]); got_defaults = 1; } } if (!got_defaults) { fprintf(stderr, "You must specify the configuration filename as an argument.\n"); exit(-1); } printf("Initializing internal tables....\n"); init_strings(); /* in stralloc.c */ init_otable(); /* in otable.c */ init_identifiers(); /* in lex.c */ init_locals(); /* in compiler.c */ /* disable this for now */ #if 0 /* * We estimate that we will need MAX_USERS + MAX_EFUN_SOCKS + 10 file * descriptors if the maximum number of users were to log in and all LPC * sockets were in use. This is a pretty close estimate. */ #ifndef LATTICE dtablesize = MAX_USERS + MAX_EFUN_SOCKS + 10; #else /* * Amiga sockets separate from file descriptors */ dtablesize = MAX_USERS + MAX_EFUN_SOCKS; #endif /* * If our estimate is larger than FD_SETSIZE, then we need more file * descriptors than the operating system can handle. This is a problem * that can be resolved by decreasing MAX_USERS, MAX_EFUN_SOCKS, or both. */ if (dtablesize > FD_SETSIZE) { fprintf(stderr, "Warning: File descriptor requirements exceed system capacity!\n"); fprintf(stderr, " Configuration exceeds system capacity by %d descriptor(s).\n", dtablesize - FD_SETSIZE); } #ifdef HAS_SETDTABLESIZE /* * If the operating system supports setdtablesize() then we can request * the number of file descriptors we really need. First check to see if * wee already have enough. If so dont bother the OS. If not, attempt to * allocate the number we estimated above. There are system imposed * limits on file descriptors, so we may not get as many as we asked for. * Check to make sure we get enough. */ if (getdtablesize() < dtablesize) if (setdtablesize(dtablesize) < dtablesize) { fprintf(stderr, "Warning: Could not allocate enough file descriptors!\n"); fprintf(stderr, " setdtablesize() could not allocate %d descriptor(s).\n", getdtablesize() - dtablesize); } /* * Just be polite and tell the administrator how many he has. */ fprintf(stderr, "%d file descriptors were allocated, (%d were requested).\n", getdtablesize(), dtablesize); #endif #endif time_to_clean_up = TIME_TO_CLEAN_UP; time_to_swap = TIME_TO_SWAP; max_cost = MAX_COST; reserved_size = RESERVED_SIZE; max_array_size = MAX_ARRAY_SIZE; max_buffer_size = MAX_BUFFER_SIZE; max_string_length = MAX_STRING_LENGTH; master_file_name = (char *) MASTER_FILE; /* fix the filename */ while (*master_file_name == '/') master_file_name++; p = master_file_name; while (*p++); if (p[-2]=='c' && p[-3]=='.') p[-3]=0; mud_lib = (char *) MUD_LIB; set_inc_list(INCLUDE_DIRS); if (reserved_size > 0) reserved_area = (char *) DMALLOC(reserved_size, TAG_RESERVED, "main.c: reserved_area"); for (i = 0; i < sizeof consts / sizeof consts[0]; i++) consts[i] = exp(-i / 900.0); init_num_args(); reset_machine(1); /* * The flags are parsed twice ! The first time, we only search for the -m * flag, which specifies another mudlib, and the D-flags, so that they * will be available when compiling master.c. */ for (i = 1; i < argc; i++) { if (argv[i][0] != '-') continue; switch (argv[i][1]) { case 'D': if (argv[i][2]) { /* Amylaar : allow flags to be passed down to * the LPC preprocessor */ struct lpc_predef_s *tmp; tmp = &predefs; tmp->flag = argv[i] + 2; tmp->next = lpc_predefs; lpc_predefs = tmp; continue; } fprintf(stderr, "Illegal flag syntax: %s\n", argv[i]); exit(-1); case 'N': no_ip_demon++; continue; #ifdef YYDEBUG case 'y': yydebug = 1; continue; #endif /* YYDEBUG */ case 'm': mud_lib = alloc_cstring(argv[i] + 2, "mudlib dir"); if (chdir(mud_lib) == -1) { fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib); exit(-1); } new_mudlib = 1; break; } } if (!new_mudlib && chdir(mud_lib) == -1) { fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib); exit(-1); } get_version(version_buf); time(&tm); debug_message("----------------------------------------------------------------------------\n%s (%s) starting up on %s - %s\n\n", MUD_NAME, version_buf, ARCH, ctime(&tm)); #ifdef BINARIES init_binaries(argc, argv); #endif #ifdef LPC_TO_C init_lpc_to_c(); #endif add_predefines(); #ifndef NO_IP_DEMON if (!no_ip_demon && ADDR_SERVER_IP) init_addr_server(ADDR_SERVER_IP, ADDR_SERVER_PORT); #endif /* NO_IP_DEMON */ eval_cost = max_cost; /* needed for create() functions */ save_context(&econ); if (SETJMP(econ.context)) { debug_message("The simul_efun (%s) and master (%s) objects must be loadable.\n", SIMUL_EFUN, MASTER_FILE); exit(-1); } else { init_simul_efun(SIMUL_EFUN); init_master(MASTER_FILE); } pop_context(&econ); for (i = 1; i < argc; i++) { if (argv[i][0] != '-') { continue; } else { /* * Look at flags. -m and -o has already been tested. */ switch (argv[i][1]) { case 'D': case 'N': case 'm': case 'y': continue; case 'f': save_context(&econ); if (SETJMP(econ.context)) { debug_message("Error while calling master::flag(\"%s\"), aborting ...", argv[i] + 2); exit(-1); } push_constant_string(argv[i] + 2); (void) apply_master_ob(APPLY_FLAG, 1); if (MudOS_is_being_shut_down) { debug_message("Shutdown by master object.\n"); exit(0); } pop_context(&econ); continue; case 'e': e_flag++; continue; case 'p': external_port[0].port = atoi(argv[i] + 2); continue; case 'd': #ifdef DEBUG d_flag++; #else debug_message("Driver must be compiled with DEBUG on to use -d.\n"); #endif case 'c': comp_flag++; continue; case 't': t_flag++; continue; default: debug_message("Unknown flag: %s\n", argv[i]); exit(-1); } } } if (MudOS_is_being_shut_down) exit(1); if (strlen(DEFAULT_FAIL_MESSAGE)) default_fail_message = DEFAULT_FAIL_MESSAGE; else default_fail_message = "What?"; #ifdef PACKAGE_MUDLIB_STATS restore_stat_files(); #endif #ifdef PACKAGE_SOCKETS init_sockets(); /* initialize efun sockets */ #endif preload_objects(e_flag); #ifdef SIGFPE signal(SIGFPE, sig_fpe); #endif #ifdef TRAP_CRASHES #ifdef SIGUSR1 signal(SIGUSR1, sig_usr1); #endif signal(SIGTERM, sig_term); signal(SIGINT, sig_int); #ifndef DEBUG #if defined(SIGABRT) && !defined(LATTICE) signal(SIGABRT, sig_abrt); #endif #ifdef SIGIOT signal(SIGIOT, sig_iot); #endif #ifdef SIGHUP signal(SIGHUP, sig_hup); #endif #ifdef SIGBUS signal(SIGBUS, sig_bus); #endif #ifndef LATTICE signal(SIGSEGV, sig_segv); signal(SIGILL, sig_ill); #endif #endif /* DEBUG */ #endif backend(); return 0; }
/** used in client thread */ void sdl_user::init() { main_config = new config("Lineage.ini"); if (!main_config->config_ok()) { delete main_config; main_config = 0; throw "ERROR Loading configuration file.\n"; } char *test; test = (char*)getfiles->load_file("Sprite00.idx", 0, FILE_REGULAR1, 0); if (test == 0) { throw "Lineage Data not found"; } delete [] test; lineage_font.init("Font/eng.fnt", this); //TODO : make a client specific version of the font unsigned char *sprite_data; int sprite_dlength; sprite_data = (unsigned char*)getfiles->load_file("sprite_table.txt", &sprite_dlength, FILE_REGULAR2, 0); if (sprite_data == 0) { printf("sprite_table.txt not found\n"); } else { int offset = 1; int sprnum = 0; printf("The first number is %d\n", atoi((char*)&sprite_data[offset])); while (isdigit(sprite_data[offset])) { offset++; } if (sprite_data[offset] == '=') { offset += 1; int alias = atoi((char*)&sprite_data[offset]); printf("Alias of %d found\n", alias); while (isdigit(sprite_data[offset])) { offset++; } while (!isdigit(sprite_data[offset])) { offset++; } } char value = atoi((char*)&sprite_data[offset]); while (isdigit(sprite_data[offset])) { offset++; } int temp; switch (value) { case 100: //switches //read a value, then read 4 times that many values temp = atoi((char*)&sprite_data[offset]); while (isdigit(sprite_data[offset])) { offset++; } for (int i = 0; i < temp; i++) { atoi((char*)&sprite_data[offset]); while (isdigit(sprite_data[offset])) { offset++; } atoi((char*)&sprite_data[offset]); while (isdigit(sprite_data[offset])) { offset++; } atoi((char*)&sprite_data[offset]); while (isdigit(sprite_data[offset])) { offset++; } atoi((char*)&sprite_data[offset]); while (isdigit(sprite_data[offset])) { offset++; } } break; case 101: //shadow //read one value break; case 102: //objType //read one value break; case 103: //altAttack //read one value break; case 104: //attr //read one value break; case 105: //clothing //read a value //read 0 or that value of numbers, whichever is higher break; case 106: //weapons //? break; case 107: //size //read 2 numbers break; case 108: //flyingType //read one number break; case 109: //immaterial //read two numbers break; case 110: //read a number and modify the stack with it break; case 111: //stride //read one number break; case 112: //furniture //read one number break; case 113: //morphEffect //read one number break; case 114: //furnitureSize //read one number break; default: printf("?(%d)\n", value); break; } while (offset < sprite_dlength) { offset++; } } DesKeyInit("~!@#%^$<"); //TODO : move this code to a class and use an object init_packs(); init_tiles(); change_drawmode(DRAWMODE_LOADING); while (!are_you_ready()) { check_requests(); } draw_loading *load; int what_server; load = (draw_loading*)get_drawmode(false); //wait for the user to pick a server do { what_server = load->get_server_pick(); check_requests(); } while (what_server == -1); server_name = new char[strlen(main_config->get_name(what_server)) + 1]; strcpy(server_name, main_config->get_name(what_server)); server = new connection(main_config, what_server); proc = new packet(server, this); if (get_updates(server, load) > 0) { } //check for custom opcodes unsigned char *copcodes; copcodes = (unsigned char*)getfiles->load_file("opcodes.txt", 0, FILE_REGULAR3, 0); if (copcodes != 0) { //there are custom opcodes for this server printf("This server has custom opcodes\n"); int offset; char *data = (char*)copcodes; for (int i = 0; i < 256; i++) { char *p; p = strtok(data, "\n"); if (data != NULL) data = NULL; int temp; sscanf(p, "%d", &temp); convert_client_packets[i] = (unsigned char)temp; } for (int i = 0; i < 256; i++) { char *p; p = strtok(data, "\n"); if (data != NULL) data = NULL; int temp; sscanf(p, "%d", &temp); convert_server_packets[i] = (unsigned char)temp; } delete [] copcodes; copcodes = 0; } //begin game portion of client // if (server->connection_ok() == 1) { if (server->change() != 1) { throw "Failed to connect to game server\n"; } } init_codepage(0); init_math_tables(); // printf("STUB Load player config\n"); // printf("STUB Initialize emblem cache\n"); init_strings(); load->load_done(); }
static PyObject* module_init(void) { PyObject *module, *ts_module, *capi; PyObject *copy_reg; if (init_strings() < 0) return NULL; #ifdef PY3K module = PyModule_Create(&moduledef); #else module = Py_InitModule3("cPersistence", cPersistence_methods, cPersistence_doc_string); #endif #ifdef PY3K ((PyObject*)&Pertype)->ob_type = &PyType_Type; #else Pertype.ob_type = &PyType_Type; #endif Pertype.tp_new = PyType_GenericNew; if (PyType_Ready(&Pertype) < 0) return NULL; if (PyModule_AddObject(module, "Persistent", (PyObject *)&Pertype) < 0) return NULL; cPersistenceCAPI = &truecPersistenceCAPI; #ifdef PY3K capi = PyCapsule_New(cPersistenceCAPI, CAPI_CAPSULE_NAME, NULL); #else capi = PyCObject_FromVoidPtr(cPersistenceCAPI, NULL); #endif if (!capi) return NULL; if (PyModule_AddObject(module, "CAPI", capi) < 0) return NULL; if (PyModule_AddIntConstant(module, "GHOST", cPersistent_GHOST_STATE) < 0) return NULL; if (PyModule_AddIntConstant(module, "UPTODATE", cPersistent_UPTODATE_STATE) < 0) return NULL; if (PyModule_AddIntConstant(module, "CHANGED", cPersistent_CHANGED_STATE) < 0) return NULL; if (PyModule_AddIntConstant(module, "STICKY", cPersistent_STICKY_STATE) < 0) return NULL; py_simple_new = PyObject_GetAttrString(module, "simple_new"); if (!py_simple_new) return NULL; #ifdef PY3K copy_reg = PyImport_ImportModule("copyreg"); #else copy_reg = PyImport_ImportModule("copy_reg"); #endif if (!copy_reg) return NULL; copy_reg_slotnames = PyObject_GetAttrString(copy_reg, "_slotnames"); if (!copy_reg_slotnames) { Py_DECREF(copy_reg); return NULL; } __newobj__ = PyObject_GetAttrString(copy_reg, "__newobj__"); if (!__newobj__) { Py_DECREF(copy_reg); return NULL; } if (!TimeStamp) { ts_module = PyImport_ImportModule("persistent.timestamp"); if (!ts_module) return NULL; TimeStamp = PyObject_GetAttrString(ts_module, "TimeStamp"); Py_DECREF(ts_module); /* fall through to immediate return on error */ } return module; }
bool main_menu::opening_screen() { // Play title music, whoo! play_music( "title" ); world_generator->set_active_world( NULL ); world_generator->init(); init_windows(); init_strings(); print_menu( w_open, 0, iMenuOffsetX, iMenuOffsetY ); if( !assure_dir_exist( FILENAMES["config_dir"] ) ) { popup( _( "Unable to make config directory. Check permissions." ) ); return false; } if( !assure_dir_exist( FILENAMES["savedir"] ) ) { popup( _( "Unable to make save directory. Check permissions." ) ); return false; } if( !assure_dir_exist( FILENAMES["templatedir"] ) ) { popup( _( "Unable to make templates directory. Check permissions." ) ); return false; } for( std::string path : get_files_from_path( ".template", FILENAMES["templatedir"], false, true ) ) { path = native_to_utf8( path ); path.erase( path.find( ".template" ), std::string::npos ); path.erase( 0, path.find_last_of( "\\//" ) + 1 ); templates.push_back( path ); } std::sort( templates.begin(), templates.end(), std::greater<std::string>() ); ctxt.register_cardinal(); ctxt.register_action( "QUIT" ); ctxt.register_action( "CONFIRM" ); ctxt.register_action( "DELETE_TEMPLATE" ); // for the menu shortcuts ctxt.register_action( "ANY_INPUT" ); bool start = false; g->u = player(); // Make [Load Game] the default cursor position if there's game save available if( !world_generator->all_worldnames().empty() ) { sel1 = 2; } while( !start ) { print_menu( w_open, sel1, iMenuOffsetX, iMenuOffsetY, ( sel1 != 0 ) ); if( layer == 1 ) { if( sel1 == 0 ) { // Print the MOTD. const int motdy = ( iMenuOffsetY - mmenu_motd.size() ) * 2 / 3; const int motdx = 8 + extra_w / 2; for( size_t i = 0; i < mmenu_motd.size(); i++ ) { mvwprintz( w_open, motdy + i, motdx, c_light_red, mmenu_motd[i].c_str() ); } wrefresh( w_open ); catacurses::refresh(); } std::string action = handle_input_timeout( ctxt ); std::string sInput = ctxt.get_raw_input().text; // check automatic menu shortcuts for( size_t i = 0; i < vMenuHotkeys.size(); ++i ) { for( auto hotkey : vMenuHotkeys[i] ) { if( sInput == hotkey ) { sel1 = i; action = "CONFIRM"; } } } // also check special keys if( action == "QUIT" ) { if( query_yn( _( "Really quit?" ) ) ) { sel1 = 8; action = "CONFIRM"; } } else if( action == "LEFT" ) { if( sel1 > 0 ) { sel1--; } else { sel1 = 8; } on_move(); } else if( action == "RIGHT" ) { if( sel1 < 8 ) { sel1++; } else { sel1 = 0; } on_move(); } if( ( action == "UP" || action == "CONFIRM" ) && sel1 > 0 ) { if( sel1 == 6 ) { display_help(); } else if( sel1 == 7 ) { display_credits(); } else if( sel1 == 8 ) { return false; } else { sel2 = 0; layer = 2; print_menu( w_open, sel1, iMenuOffsetX, iMenuOffsetY, ( sel1 != 0 ) ); switch( sel1 ) { case 1: start = new_character_tab(); break; case 2: start = load_character_tab(); break; case 3: world_tab(); break; default: break; } } } } else if( layer == 2 ) { if( sel1 == 4 ) { // Special game if( MAP_SHARING::isSharing() ) { // Thee can't save special games, therefore thee can't share them layer = 1; popup( _( "Special games don't work with shared maps." ) ); continue; } std::vector<std::string> special_names; int xoffset = 32 + iMenuOffsetX + extra_w / 2; int yoffset = iMenuOffsetY - 2; int xlen = 0; for( int i = 1; i < NUM_SPECIAL_GAMES; i++ ) { std::string spec_name = special_game_name( special_game_id( i ) ); special_names.push_back( spec_name ); xlen += spec_name.size() + 2; } xlen += special_names.size() - 1; print_menu_items( w_open, special_names, sel2, yoffset, xoffset - ( xlen / 4 ) ); wrefresh( w_open ); catacurses::refresh(); std::string action = handle_input_timeout( ctxt ); if( action == "LEFT" ) { if( sel2 > 0 ) { sel2--; } else { sel2 = NUM_SPECIAL_GAMES - 2; } on_move(); } else if( action == "RIGHT" ) { if( sel2 < NUM_SPECIAL_GAMES - 2 ) { sel2++; } else { sel2 = 0; } on_move(); } else if( action == "DOWN" || action == "QUIT" ) { layer = 1; } if( action == "UP" || action == "CONFIRM" ) { if( sel2 >= 0 && sel2 < NUM_SPECIAL_GAMES - 1 ) { g->gamemode = get_special_game( special_game_id( sel2 + 1 ) ); // check world WORLDPTR world = world_generator->make_new_world( special_game_id( sel2 + 1 ) ); if( world == NULL ) { continue; } world_generator->set_active_world( world ); try { g->setup(); } catch( const std::exception &err ) { debugmsg( "Error: %s", err.what() ); g->gamemode.reset(); g->u = player(); continue; } if( !g->gamemode->init() ) { g->gamemode.reset(); g->u = player(); continue; } start = true; } } } else if( sel1 == 5 ) { // Settings Menu int settings_subs_to_display = vSettingsSubItems.size(); std::vector<std::string> settings_subs; int xoffset = 46 + iMenuOffsetX + extra_w / 2; int yoffset = iMenuOffsetY - 2; int xlen = 0; for( int i = 0; i < settings_subs_to_display; ++i ) { settings_subs.push_back( vSettingsSubItems[i] ); xlen += vSettingsSubItems[i].size() + 2; // Open and close brackets added } xlen += settings_subs.size() - 1; if( settings_subs.size() > 1 ) { xoffset -= 6; } print_menu_items( w_open, settings_subs, sel2, yoffset, xoffset - ( xlen / 4 ) ); wrefresh( w_open ); catacurses::refresh(); std::string action = handle_input_timeout( ctxt ); std::string sInput = ctxt.get_raw_input().text; for( int i = 0; i < settings_subs_to_display; ++i ) { for( auto hotkey : vSettingsHotkeys[i] ) { if( sInput == hotkey ) { sel2 = i; action = "CONFIRM"; } } } if( action == "LEFT" ) { if( sel2 > 0 ) { --sel2; } else { sel2 = settings_subs_to_display - 1; } on_move(); } else if( action == "RIGHT" ) { if( sel2 < settings_subs_to_display - 1 ) { ++sel2; } else { sel2 = 0; } on_move(); } else if( action == "DOWN" || action == "QUIT" ) { layer = 1; } if( action == "UP" || action == "CONFIRM" ) { if( sel2 == 0 ) { get_options().show( true ); // The language may have changed- gracefully handle this. init_strings(); print_menu( w_open, sel1, iMenuOffsetX, iMenuOffsetY, ( sel1 != 0 ) ); } else if( sel2 == 1 ) { input_context ctxt_default = get_default_mode_input_context(); ctxt_default.display_menu(); } else if( sel2 == 2 ) { get_auto_pickup().show(); } else if( sel2 == 3 ) { get_safemode().show(); } else if( sel2 == 4 ) { all_colors.show_gui(); } } } } } if( start ) { g->refresh_all(); g->draw(); } return start; }
int main (int argc, char ** argv) { time_t tm; int i, new_mudlib = 0, got_defaults = 0; char *p; char version_buf[80]; #if 0 int dtablesize; #endif error_context_t econ; #ifdef PROTO_TZSET void tzset(); #endif #ifdef INCL_LOCALE_H setlocale(LC_ALL, "C"); #endif #if !defined(__SASC) && (defined(AMITCP) || defined(AS225)) amiga_sockinit(); atexit(amiga_sockexit); #endif #ifdef WRAPPEDMALLOC wrappedmalloc_init(); #endif /* WRAPPEDMALLOC */ #ifdef DEBUGMALLOC MDinit(); #endif #if (defined(PROFILING) && !defined(PROFILE_ON) && defined(HAS_MONCONTROL)) moncontrol(0); #endif #ifdef USE_TZSET tzset(); #endif boot_time = get_current_time(); const0.type = T_NUMBER; const0.u.number = 0; const1.type = T_NUMBER; const1.u.number = 1; /* const0u used by undefinedp() */ const0u.type = T_NUMBER; const0u.subtype = T_UNDEFINED; const0u.u.number = 0; //fake_prog.program_size = 0; //0 anyway /* * Check that the definition of EXTRACT_UCHAR() is correct. */ p = (char *) &i; *p = -10; if (EXTRACT_UCHAR(p) != 0x100 - 10) { fprintf(stderr, "Bad definition of EXTRACT_UCHAR() in interpret.h.\n"); exit(-1); } /* * An added test: can we do EXTRACT_UCHAR(x++)? * (read_number, etc uses it) */ p = (char *) &i; (void) EXTRACT_UCHAR(p++); if ((p - (char *) &i) != 1) { fprintf(stderr, "EXTRACT_UCHAR() in interpret.h evaluates its argument more than once.\n"); exit(-1); } /* * Check the living hash table size */ if (CFG_LIVING_HASH_SIZE != 4 && CFG_LIVING_HASH_SIZE != 16 && CFG_LIVING_HASH_SIZE != 64 && CFG_LIVING_HASH_SIZE != 256 && CFG_LIVING_HASH_SIZE != 1024 && CFG_LIVING_HASH_SIZE != 4096) { fprintf(stderr, "CFG_LIVING_HASH_SIZE in options.h must be one of 4, 16, 64, 256, 1024, 4096, ...\n"); exit(-1); } #ifdef RAND srand(get_current_time()); #else # ifdef DRAND48 srand48(get_current_time()); # else # ifdef RANDOM srandom(get_current_time()); # else fprintf(stderr, "Warning: no random number generator specified!\n"); # endif # endif #endif current_time = get_current_time(); /* * Initialize the microsecond clock. */ init_usec_clock(); /* read in the configuration file */ got_defaults = 0; for (i = 1; (i < argc) && !got_defaults; i++) { if (argv[i][0] != '-') { set_defaults(argv[i]); got_defaults = 1; } } get_version(version_buf); if (!got_defaults) { fprintf(stderr, "%s for %s.\n", version_buf, ARCH); fprintf(stderr, "You must specify the configuration filename as an argument.\n"); exit(-1); } printf("Initializing internal tables....\n"); init_strings(); /* in stralloc.c */ init_otable(); /* in otable.c */ init_identifiers(); /* in lex.c */ init_locals(); /* in compiler.c */ /* * If our estimate is larger than FD_SETSIZE, then we need more file * descriptors than the operating system can handle. This is a problem * that can be resolved by decreasing MAX_USERS, MAX_EFUN_SOCKS, or both. * * Unfortunately, since neither MAX_USERS or MAX_EFUN_SOCKS exist any more, * we have no clue how many we will need. This code really should be * moved to places where ENFILE/EMFILE is returned. */ #if 0 if (dtablesize > FD_SETSIZE) { fprintf(stderr, "Warning: File descriptor requirements exceed system capacity!\n"); fprintf(stderr, " Configuration exceeds system capacity by %d descriptor(s).\n", dtablesize - FD_SETSIZE); } #ifdef HAS_SETDTABLESIZE /* * If the operating system supports setdtablesize() then we can request * the number of file descriptors we really need. First check to see if * wee already have enough. If so dont bother the OS. If not, attempt to * allocate the number we estimated above. There are system imposed * limits on file descriptors, so we may not get as many as we asked for. * Check to make sure we get enough. */ if (getdtablesize() < dtablesize) if (setdtablesize(dtablesize) < dtablesize) { fprintf(stderr, "Warning: Could not allocate enough file descriptors!\n"); fprintf(stderr, " setdtablesize() could not allocate %d descriptor(s).\n", getdtablesize() - dtablesize); } /* * Just be polite and tell the administrator how many he has. */ fprintf(stderr, "%d file descriptors were allocated, (%d were requested).\n", getdtablesize(), dtablesize); #endif #endif time_to_clean_up = TIME_TO_CLEAN_UP; max_cost = MAX_COST; reserved_size = RESERVED_SIZE; max_array_size = MAX_ARRAY_SIZE; if(max_array_size > 65535){ fprintf(stderr, "Maximum array size can not exceed 65535"); max_array_size = 65535; } max_buffer_size = MAX_BUFFER_SIZE; max_string_length = MAX_STRING_LENGTH; mud_lib = (char *) MUD_LIB; set_inc_list(INCLUDE_DIRS); if (reserved_size > 0) reserved_area = (char *) DMALLOC(reserved_size, TAG_RESERVED, "main.c: reserved_area"); for (i = 0; i < sizeof consts / sizeof consts[0]; i++) consts[i] = exp(-i / 900.0); reset_machine(1); /* * The flags are parsed twice ! The first time, we only search for the -m * flag, which specifies another mudlib, and the D-flags, so that they * will be available when compiling master.c. */ for (i = 1; i < argc; i++) { if (argv[i][0] != '-') continue; switch (argv[i][1]) { case 'D': if (argv[i][2]) { lpc_predef_t *tmp = ALLOCATE(lpc_predef_t, TAG_PREDEFINES, "predef"); tmp->flag = argv[i] + 2; tmp->next = lpc_predefs; lpc_predefs = tmp; continue; } fprintf(stderr, "Illegal flag syntax: %s\n", argv[i]); exit(-1); case 'N': no_ip_demon++; continue; #ifdef HAS_CONSOLE case 'C': has_console = 1; continue; #endif #ifdef YYDEBUG case 'y': yydebug = 1; continue; #endif /* YYDEBUG */ case 'm': mud_lib = alloc_cstring(argv[i] + 2, "mudlib dir"); if (chdir(mud_lib) == -1) { fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib); exit(-1); } new_mudlib = 1; break; } } if (!new_mudlib && chdir(mud_lib) == -1) { fprintf(stderr, "Bad mudlib directory: %s\n", mud_lib); exit(-1); } time(&tm); debug_message("----------------------------------------------------------------------------\n%s (%s) starting up on %s - %s\n\n", MUD_NAME, version_buf, ARCH, ctime(&tm)); add_predefines(); #ifdef WIN32 _tzset(); #endif #ifndef NO_IP_DEMON if (!no_ip_demon && ADDR_SERVER_IP) init_addr_server(ADDR_SERVER_IP, ADDR_SERVER_PORT); #endif /* NO_IP_DEMON */ set_eval(max_cost); save_context(&econ); if (SETJMP(econ.context)) { debug_message("The simul_efun (%s) and master (%s) objects must be loadable.\n", SIMUL_EFUN, MASTER_FILE); exit(-1); } else { init_simul_efun(SIMUL_EFUN); init_master(); } pop_context(&econ); for (i = 1; i < argc; i++) { if (argv[i][0] != '-') { continue; } else { /* * Look at flags. -m and -o has already been tested. */ switch (argv[i][1]) { case 'D': case 'N': case 'm': case 'y': case 'C': continue; case 'f': save_context(&econ); if (SETJMP(econ.context)) { debug_message("Error while calling master::flag(\"%s\"), aborting ...\n", argv[i] + 2); exit(-1); } push_constant_string(argv[i] + 2); apply_master_ob(APPLY_FLAG, 1); if (MudOS_is_being_shut_down) { debug_message("Shutdown by master object.\n"); exit(0); } pop_context(&econ); continue; case 'e': e_flag++; continue; case 'p': external_port[0].port = atoi(argv[i] + 2); continue; case 'd': #ifdef DEBUG_MACRO if (argv[i][2]) debug_level_set(&argv[i][2]); else debug_level |= DBG_d_flag; #else debug_message("Driver must be compiled with DEBUG_MACRO on to use -d.\n"); #endif break; case 'c': comp_flag++; continue; case 't': t_flag++; continue; default: debug_message("Unknown flag: %s\n", argv[i]); exit(-1); } } } if (MudOS_is_being_shut_down) exit(1); if (*(DEFAULT_FAIL_MESSAGE)) { char buf[8192]; strcpy(buf, DEFAULT_FAIL_MESSAGE); strcat(buf, "\n"); default_fail_message = make_shared_string(buf); } else default_fail_message = "What?\n"; #ifdef PACKAGE_MUDLIB_STATS restore_stat_files(); #endif preload_objects(e_flag); #ifdef SIGFPE signal(SIGFPE, sig_fpe); #endif #ifdef TRAP_CRASHES #ifdef SIGUSR1 signal(SIGUSR1, sig_usr1); #endif #ifdef SIGUSR2 signal(SIGUSR2, sig_usr2); #endif signal(SIGTERM, sig_term); signal(SIGINT, sig_int); #ifndef DEBUG #if defined(SIGABRT) signal(SIGABRT, sig_abrt); #endif #ifdef SIGIOT signal(SIGIOT, sig_iot); #endif #ifdef SIGHUP signal(SIGHUP, sig_hup); #endif #ifdef SIGBUS signal(SIGBUS, sig_bus); #endif signal(SIGSEGV, sig_segv); signal(SIGILL, sig_ill); #endif /* DEBUG */ #endif #ifndef WIN32 #ifdef USE_BSD_SIGNALS signal(SIGCHLD, sig_cld); #else signal(SIGCLD, sig_cld); #endif #endif #ifdef HAS_CONSOLE if(has_console >= 0) signal(SIGTTIN, sig_ttin); signal(SIGTTOU, SIG_IGN); #endif backend(); return 0; }
int main() { int res, try, retries; char *query_string, *abf_api_url, *api_token; char *log_level = getenv("LOG_LEVEL"); if (init_logger(log_level == NULL ? "INFO" : log_level) < 0) { return 2; } register_thread("Main"); log_printf(LOG_INFO, "Starting DNS check...\n"); res = check_dns(); if (res < 0) { log_printf(LOG_FATAL, "Check DNS failed, can't resolve github.com. Exiting...\n"); return 6; } else { log_printf(LOG_INFO, "Successfuly resolved github. Continuing.\n"); } usergroup omv_mock = get_omv_uid_mock_gid(); if(omv_mock.omv_uid == 0) { log_printf(LOG_FATAL, "User omv doesn't exist. Exiting...\n"); return 7; } if(omv_mock.mock_gid == 0) { log_printf(LOG_FATAL, "Group mock doesn't exist. Exiting...\n"); return 8; } res = process_config(&abf_api_url, &api_token, &query_string); if (res < 0) { log_printf(LOG_FATAL, "Failed to process config, exiting.\n"); return 1; } init_strings(api_token); init_api(abf_api_url, api_token); if(start_statistics_thread(query_string)) { log_printf(LOG_FATAL, "Failed to initialize statistics thread. Exiting...\n"); return 5; } while(1) { char *job; if(api_jobs_shift(&job, query_string)) { sleep(10); continue; } char *build_id, *distrib_type; char **env; int ttl; res = parse_job_description(job, &build_id, &ttl, &distrib_type, &env); free(job); if(res < 0) { sleep(10); continue; } log_printf(LOG_INFO, "Starting build with build_id %s.\n", build_id); log_printf(LOG_INFO, "Sending build start notification to ABF.\n"); retries = 5; try = 0; set_busy_status(1, build_id); int build_start_success = 0; while(retries) { log_printf(LOG_INFO, "Try #%d: Sending data to ABF.\n", try + 1); if(!api_jobs_feedback(build_id, BUILD_STARTED, hostname_payload)) { log_printf(LOG_INFO, "Try #%d: Data sent.\n", try + 1); build_start_success = 1; break; } else { log_printf(LOG_ERROR, "Try #%d: Failed to send data to ABF. Sleeping for %d seconds and retrying...\n", try + 1, 1 << try); } retries--; sleep(1 << try); try++; } if (!build_start_success) { log_printf(LOG_ERROR, "Failed to send build start to ABF, aborting build.\n"); free(build_id); free(distrib_type); for(int i = 0; i < res; i++) { free(env[i]); } free(env); set_busy_status(0, NULL); continue; } child script = exec_build(distrib_type, (char * const *)env, omv_mock); int live_inspector_started = 1; log_printf(LOG_INFO, "Starting live inspector, build's time to live is %d seconds.\n", ttl); if(start_live_inspector(ttl, script.pid, build_id) < 0) { live_inspector_started = 0; log_printf(LOG_WARN, "Live inspector failed to start. Job canceling and timeout will be unavailable.\n"); } int live_logger_started = 1; log_printf(LOG_INFO, "Starting live logger.\n"); if(start_live_logger(build_id, script.read_fd) < 0) { live_logger_started = 0; log_printf(LOG_WARN, "Live logger failed to start. Live log will be unavailable.\n"); } int status, build_status = BUILD_COMPLETED; waitpid(script.pid, &status, 0); int canceled = 0; if (live_inspector_started) { canceled = stop_live_inspector(); } if (live_logger_started) { stop_live_logger(); } int exit_code = 0; if (canceled) { build_status = BUILD_CANCELED; } else if(WIFEXITED(status)) { exit_code = WEXITSTATUS(status); switch(exit_code) { case 0: build_status = BUILD_COMPLETED; break; case 5: build_status = TESTS_FAILED; break; default: build_status = BUILD_FAILED; } } else if(WIFSIGNALED(status)) { exit_code = 255; build_status = BUILD_FAILED; } for(int i = 0; i < res; i++) { free(env[i]); } free(env); free(distrib_type); log_printf(LOG_INFO, "Build is over with status %s.\n", build_statuses_str[build_status]); mkdir(home_output, 0666); system(move_output_cmd); system(upload_cmd); char *container_data = read_file(container_data_path); char *results = read_file("/tmp/results.json"); char *commit_hash = read_file(commit_hash_path); if(commit_hash != NULL) { commit_hash[40] = '\0'; } char *fail_reason = NULL; if (build_status == BUILD_FAILED) { fail_reason = read_file(fail_reason_path); if (fail_reason != NULL) { for (unsigned int i = 0; i < strlen(fail_reason); i++) { if (!isprint(fail_reason[i]) || fail_reason[i] == '"') { fail_reason[i] = ' '; } } } } char *args = xmalloc((container_data ? strlen(container_data) : 0) + (results ? strlen(results) : 0) + 2048); sprintf(args, build_completed_args_fmt, (results ? results : "[]"), \ (container_data ? container_data : "{}"), exit_code, (commit_hash ? commit_hash : ""), (fail_reason ? fail_reason : "")); retries = 5; try = 0; while(retries) { log_printf(LOG_INFO, "Try #%d: Sending data to ABF\n", try + 1); if(!api_jobs_feedback(build_id, build_status, args)) { log_printf(LOG_INFO, "Data sent.\n"); break; } else { log_printf(LOG_ERROR, "Failed to send data to ABF. Sleeping for %d seconds and retrying...\n", 1 << try); } retries--; sleep(1 << try); try++; } set_busy_status(0, NULL); free(args); free(build_id); if(commit_hash) { free(commit_hash); } if(results) { free(results); } if(container_data) { free(container_data); } if(fail_reason) { free(fail_reason); } } return 0; }