int dispatch_imsg(struct ntpd_conf *lconf) { struct imsg imsg; int n, cnt; double d; char *name; struct ntp_addr *h, *hn; struct ibuf *buf; if ((n = imsg_read(ibuf)) == -1) return (-1); if (n == 0) { /* connection closed */ log_warnx("dispatch_imsg in main: pipe closed"); return (-1); } for (;;) { if ((n = imsg_get(ibuf, &imsg)) == -1) return (-1); if (n == 0) break; switch (imsg.hdr.type) { case IMSG_ADJTIME: if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(d)) fatalx("invalid IMSG_ADJTIME received"); memcpy(&d, imsg.data, sizeof(d)); n = ntpd_adjtime(d); imsg_compose(ibuf, IMSG_ADJTIME, 0, 0, -1, &n, sizeof(n)); break; case IMSG_ADJFREQ: if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(d)) fatalx("invalid IMSG_ADJFREQ received"); memcpy(&d, imsg.data, sizeof(d)); ntpd_adjfreq(d, 1); break; case IMSG_SETTIME: if (imsg.hdr.len != IMSG_HEADER_SIZE + sizeof(d)) fatalx("invalid IMSG_SETTIME received"); if (!lconf->settime) break; log_init(lconf->debug); memcpy(&d, imsg.data, sizeof(d)); ntpd_settime(d); /* daemonize now */ if (!lconf->debug) if (daemon(1, 0)) fatal("daemon"); lconf->settime = 0; timeout = INFTIM; break; case IMSG_HOST_DNS: name = imsg.data; if (imsg.hdr.len < 1 + IMSG_HEADER_SIZE) fatalx("invalid IMSG_HOST_DNS received"); imsg.hdr.len -= 1 + IMSG_HEADER_SIZE; if (name[imsg.hdr.len] != '\0' || strlen(name) != imsg.hdr.len) fatalx("invalid IMSG_HOST_DNS received"); cnt = host_dns(name, &hn); buf = imsg_create(ibuf, IMSG_HOST_DNS, imsg.hdr.peerid, 0, cnt * sizeof(struct sockaddr_storage)); if (buf == NULL) break; if (cnt > 0) for (h = hn; h != NULL; h = h->next) imsg_add(buf, &h->ss, sizeof(h->ss)); imsg_close(ibuf, buf); break; default: break; } imsg_free(&imsg); } return (0); }
void mm_get_keystate(struct monitor *pmonitor) { Buffer m; u_char *blob, *p; u_int bloblen, plen; u_int32_t seqnr, packets; u_int64_t blocks; debug3("%s: Waiting for new keys", __func__); buffer_init(&m); mm_request_receive_expect(pmonitor->m_sendfd, MONITOR_REQ_KEYEXPORT, &m); if (!compat20) { child_state.ssh1protoflags = buffer_get_int(&m); child_state.ssh1cipher = buffer_get_int(&m); child_state.ssh1key = buffer_get_string(&m, &child_state.ssh1keylen); child_state.ivout = buffer_get_string(&m, &child_state.ivoutlen); child_state.ivin = buffer_get_string(&m, &child_state.ivinlen); goto skip; } else { /* Get the Kex for rekeying */ *pmonitor->m_pkex = mm_get_kex(&m); } blob = buffer_get_string(&m, &bloblen); current_keys[MODE_OUT] = mm_newkeys_from_blob(blob, bloblen); xfree(blob); debug3("%s: Waiting for second key", __func__); blob = buffer_get_string(&m, &bloblen); current_keys[MODE_IN] = mm_newkeys_from_blob(blob, bloblen); xfree(blob); /* Now get sequence numbers for the packets */ seqnr = buffer_get_int(&m); blocks = buffer_get_int64(&m); packets = buffer_get_int(&m); packet_set_state(MODE_OUT, seqnr, blocks, packets); seqnr = buffer_get_int(&m); blocks = buffer_get_int64(&m); packets = buffer_get_int(&m); packet_set_state(MODE_IN, seqnr, blocks, packets); skip: /* Get the key context */ child_state.keyout = buffer_get_string(&m, &child_state.keyoutlen); child_state.keyin = buffer_get_string(&m, &child_state.keyinlen); debug3("%s: Getting compression state", __func__); /* Get compression state */ p = buffer_get_string(&m, &plen); if (plen != sizeof(child_state.outgoing)) fatal("%s: bad request size", __func__); memcpy(&child_state.outgoing, p, sizeof(child_state.outgoing)); xfree(p); p = buffer_get_string(&m, &plen); if (plen != sizeof(child_state.incoming)) fatal("%s: bad request size", __func__); memcpy(&child_state.incoming, p, sizeof(child_state.incoming)); xfree(p); /* Network I/O buffers */ debug3("%s: Getting Network I/O buffers", __func__); child_state.input = buffer_get_string(&m, &child_state.ilen); child_state.output = buffer_get_string(&m, &child_state.olen); buffer_free(&m); }
int mm_answer_pwnamallow(int sock, Buffer *m) { char *username; struct passwd *pwent; int allowed = 0; debug3("%s", __func__); if (authctxt->attempt++ != 0) fatal("%s: multiple attempts for getpwnam", __func__); username = buffer_get_string(m, NULL); pwent = getpwnamallow(username); authctxt->user = xstrdup(username); setproctitle("%s [priv]", pwent ? username : "******"); xfree(username); buffer_clear(m); if (pwent == NULL) { buffer_put_char(m, 0); authctxt->pw = fakepw(); goto out; } allowed = 1; authctxt->pw = pwent; authctxt->valid = 1; buffer_put_char(m, 1); buffer_put_string(m, pwent, sizeof(struct passwd)); buffer_put_cstring(m, pwent->pw_name); buffer_put_cstring(m, "*"); buffer_put_cstring(m, pwent->pw_gecos); #ifdef HAVE_PW_CLASS_IN_PASSWD buffer_put_cstring(m, pwent->pw_class); #endif buffer_put_cstring(m, pwent->pw_dir); buffer_put_cstring(m, pwent->pw_shell); buffer_put_string(m, &options, sizeof(options)); if (options.banner != NULL) buffer_put_cstring(m, options.banner); out: debug3("%s: sending MONITOR_ANS_PWNAM: %d", __func__, allowed); mm_request_send(sock, MONITOR_ANS_PWNAM, m); /* For SSHv1 allow authentication now */ if (!compat20) monitor_permit_authentications(1); else { /* Allow service/style information on the auth context */ monitor_permit(mon_dispatch, MONITOR_REQ_AUTHSERV, 1); monitor_permit(mon_dispatch, MONITOR_REQ_AUTH2_READ_BANNER, 1); } #ifdef USE_PAM if (options.use_pam) monitor_permit(mon_dispatch, MONITOR_REQ_PAM_START, 1); #endif return (0); }
extern int _ext_sensors_read_conf(void) { s_p_options_t options[] = { {"JobData", S_P_STRING}, {"NodeData", S_P_STRING}, {"SwitchData", S_P_STRING}, {"ColdDoorData", S_P_STRING}, {"MinWatt", S_P_UINT32}, {"MaxWatt", S_P_UINT32}, {"MinTemp", S_P_UINT32}, {"MaxTemp", S_P_UINT32}, {"EnergyRRA", S_P_STRING}, {"TempRRA", S_P_STRING}, {"EnergyPathRRD", S_P_STRING}, {"TempPathRRD", S_P_STRING}, {NULL} }; s_p_hashtbl_t *tbl = NULL; char *conf_path = NULL; struct stat buf; char *temp_str = NULL; /* Set initial values */ if (ext_sensors_cnf == NULL) { return SLURM_ERROR; } _ext_sensors_clear_free_conf(); /* Get the ext_sensors.conf path and validate the file */ conf_path = get_extra_conf_path("ext_sensors.conf"); if ((conf_path == NULL) || (stat(conf_path, &buf) == -1)) { fatal("ext_sensors: No ext_sensors file (%s)", conf_path); } else { debug2("ext_sensors: Reading ext_sensors file %s", conf_path); tbl = s_p_hashtbl_create(options); if (s_p_parse_file(tbl, NULL, conf_path, false) == SLURM_ERROR) { fatal("ext_sensors: Could not open/read/parse " "ext_sensors file %s", conf_path); } /* ext_sensors initialization parameters */ if (s_p_get_string(&temp_str, "JobData", tbl)) { if (strstr(temp_str, "energy")) ext_sensors_cnf->dataopts |= EXT_SENSORS_OPT_JOB_ENERGY; } xfree(temp_str); if (s_p_get_string(&temp_str, "NodeData", tbl)) { if (strstr(temp_str, "energy")) ext_sensors_cnf->dataopts |= EXT_SENSORS_OPT_NODE_ENERGY; if (strstr(temp_str, "temp")) ext_sensors_cnf->dataopts |= EXT_SENSORS_OPT_NODE_TEMP; } xfree(temp_str); if (s_p_get_string(&temp_str, "SwitchData", tbl)) { if (strstr(temp_str, "energy")) ext_sensors_cnf->dataopts |= EXT_SENSORS_OPT_SWITCH_ENERGY; if (strstr(temp_str, "temp")) ext_sensors_cnf->dataopts |= EXT_SENSORS_OPT_SWITCH_TEMP; } xfree(temp_str); if (s_p_get_string(&temp_str, "ColdDoorData", tbl)) { if (strstr(temp_str, "temp")) ext_sensors_cnf->dataopts |= EXT_SENSORS_OPT_COLDDOOR_TEMP; } xfree(temp_str); s_p_get_uint32(&ext_sensors_cnf->min_watt,"MinWatt", tbl); s_p_get_uint32(&ext_sensors_cnf->max_watt,"MaxWatt", tbl); s_p_get_uint32(&ext_sensors_cnf->min_temp,"MinTemp", tbl); s_p_get_uint32(&ext_sensors_cnf->max_temp,"MaxTemp", tbl); if (!s_p_get_string(&ext_sensors_cnf->energy_rra_name, "EnergyRRA", tbl)) { if (ext_sensors_cnf->dataopts & EXT_SENSORS_OPT_JOB_ENERGY) fatal("ext_sensors/rrd: EnergyRRA " "must be set to gather JobData=energy. " "Please set this value in your " "ext_sensors.conf file."); } if (!s_p_get_string(&ext_sensors_cnf->temp_rra_name, "TempRRA", tbl)) { if (ext_sensors_cnf->dataopts & EXT_SENSORS_OPT_NODE_TEMP) fatal("ext_sensors/rrd: TempRRA " "must be set to gather NodeData=temp. " "Please set this value in your " "ext_sensors.conf file."); } s_p_get_string(&ext_sensors_cnf->energy_rrd_file, "EnergyPathRRD", tbl); s_p_get_string(&ext_sensors_cnf->temp_rrd_file, "TempPathRRD", tbl); s_p_hashtbl_destroy(tbl); } xfree(conf_path); return SLURM_SUCCESS; }
static void decode(VMPM *vmpm) { Arithcoder *ac; Arithmodel *am; Arithmodel *bin_am; unsigned int *index_to_symbol; int i, n; unsigned int j; //debug_message_fn("()\n"); fatal(255, "DECODING IS INVALID. NEED REIMPLEMENTATION.\n"); ac = arithcoder_arith_create(); arithcoder_decode_init(ac, vmpm->infile); am = arithmodel_order_zero_create(); arithmodel_decode_init(am, ac); bin_am = arithmodel_order_zero_create(); arithmodel_decode_init(bin_am, ac); arithmodel_install_symbol(bin_am, 1); arithmodel_install_symbol(bin_am, 1); vmpm->token_index[vmpm->I] = vmpm->blocksize / ipow(vmpm->r, vmpm->I); for (i = vmpm->I; i >= 1; i--) { stat_message(vmpm, "Level %d: %d\n", i, vmpm->token_index[i]); vmpm->token_index[i - 1] = 0; if ((vmpm->tokens[i] = calloc(vmpm->token_index[i], sizeof(Token))) == NULL) memory_error(NULL, MEMORY_ERROR); // DECODING IS INVALID //arithmodel_order_zero_reset(am, 0, vmpm->newtoken[i]); for (j = 0; j < vmpm->token_index[i]; j++) { Index idx; arithmodel_decode(am, &idx); vmpm->tokens[i][j].value++; if (vmpm->tokens[i][j].value > vmpm->token_index[i - 1]) { if (vmpm->tokens[i][j].value == vmpm->token_index[i - 1] + 1) vmpm->token_index[i - 1]++; else generic_error((char *)"Invalid token value.\n", INVALID_TOKEN_VALUE_ERROR); } } vmpm->token_index[i - 1] *= vmpm->r; } if ((index_to_symbol = calloc(vmpm->alphabetsize, sizeof(unsigned int))) == NULL) memory_error(NULL, MEMORY_ERROR); n = 0; stat_message(vmpm, "Level 0: %d\n", vmpm->token_index[0]); for (j = 0; j < vmpm->token_index[0]; j++) { Index v; if (arithmodel_decode(am, &v) == 2) { arithmodel_decode_bits(bin_am, &vmpm->tokens[0][j].value, vmpm->bits_per_symbol, 0, 1); index_to_symbol[n++] = vmpm->tokens[0][j].value; } else { vmpm->tokens[0][j].value = index_to_symbol[v]; } } free(index_to_symbol); arithcoder_decode_final(ac); arithmodel_destroy(am); arithcoder_destroy(ac); }
/* Attempt to schedule a specific job on specific available nodes * IN job_ptr - job to schedule * IN/OUT avail_bitmap - nodes available/selected to use * RET SLURM_SUCCESS on success, otherwise an error code */ static int _try_sched(struct job_record *job_ptr, bitstr_t **avail_bitmap, uint32_t min_nodes, uint32_t max_nodes, uint32_t req_nodes) { bitstr_t *tmp_bitmap; int rc = SLURM_SUCCESS; int feat_cnt = _num_feature_count(job_ptr); List preemptee_candidates = NULL; if (feat_cnt) { /* Ideally schedule the job feature by feature, * but I don't want to add that complexity here * right now, so clear the feature counts and try * to schedule. This will work if there is only * one feature count. It should work fairly well * in cases where there are multiple feature * counts. */ struct job_details *detail_ptr = job_ptr->details; ListIterator feat_iter; struct feature_record *feat_ptr; int i = 0, list_size; uint16_t *feat_cnt_orig = NULL, high_cnt = 0; /* Clear the feature counts */ list_size = list_count(detail_ptr->feature_list); feat_cnt_orig = xmalloc(sizeof(uint16_t) * list_size); feat_iter = list_iterator_create(detail_ptr->feature_list); if (feat_iter == NULL) fatal("list_iterator_create: malloc failure"); while ((feat_ptr = (struct feature_record *) list_next(feat_iter))) { high_cnt = MAX(high_cnt, feat_ptr->count); feat_cnt_orig[i++] = feat_ptr->count; feat_ptr->count = 0; } list_iterator_destroy(feat_iter); if ((job_req_node_filter(job_ptr, *avail_bitmap) != SLURM_SUCCESS) || (bit_set_count(*avail_bitmap) < high_cnt)) { rc = ESLURM_NODES_BUSY; } else { preemptee_candidates = slurm_find_preemptable_jobs(job_ptr); rc = select_g_job_test(job_ptr, *avail_bitmap, high_cnt, max_nodes, req_nodes, SELECT_MODE_WILL_RUN, preemptee_candidates, NULL); } /* Restore the feature counts */ i = 0; feat_iter = list_iterator_create(detail_ptr->feature_list); while ((feat_ptr = (struct feature_record *) list_next(feat_iter))) { feat_ptr->count = feat_cnt_orig[i++]; } list_iterator_destroy(feat_iter); xfree(feat_cnt_orig); } else { /* Try to schedule the job. First on dedicated nodes * then on shared nodes (if so configured). */ uint16_t orig_shared; time_t now = time(NULL); preemptee_candidates = slurm_find_preemptable_jobs(job_ptr); orig_shared = job_ptr->details->shared; job_ptr->details->shared = 0; tmp_bitmap = bit_copy(*avail_bitmap); rc = select_g_job_test(job_ptr, *avail_bitmap, min_nodes, max_nodes, req_nodes, SELECT_MODE_WILL_RUN, preemptee_candidates, NULL); job_ptr->details->shared = orig_shared; if (((rc != SLURM_SUCCESS) || (job_ptr->start_time > now)) && (orig_shared != 0)) { FREE_NULL_BITMAP(*avail_bitmap); *avail_bitmap= tmp_bitmap; rc = select_g_job_test(job_ptr, *avail_bitmap, min_nodes, max_nodes, req_nodes, SELECT_MODE_WILL_RUN, preemptee_candidates, NULL); } else FREE_NULL_BITMAP(tmp_bitmap); } if (preemptee_candidates) list_destroy(preemptee_candidates); return rc; }
// Implementation of NativeTest void NativeTest::verify() { // make sure code pattern is actually a test eax, imm32 instruction if (*(u_char*)instruction_address() != instruction_code) fatal("not a test eax, imm32"); }
/* Sync up the core_bitmap with the CPU array using cyclic distribution * * The CPU array contains the distribution of CPUs, which can include * virtual CPUs (hyperthreads) */ static int _cyclic_sync_core_bitmap(struct job_record *job_ptr, const uint16_t cr_type, bool preempt_mode) { uint32_t c, i, j, s, n, *sock_start, *sock_end, size, csize, core_cnt; uint16_t cps = 0, cpus, vpus, sockets, sock_size; job_resources_t *job_res = job_ptr->job_resrcs; bitstr_t *core_map; bool *sock_used, *sock_avoid; bool alloc_cores = false, alloc_sockets = false; uint16_t ntasks_per_socket = 0xffff; uint16_t ntasks_per_core = 0xffff; int error_code = SLURM_SUCCESS; int tmp_cpt = 0; /* cpus_per_task */ if ((job_res == NULL) || (job_res->core_bitmap == NULL) || (job_ptr->details == NULL)) return error_code; if (cr_type & CR_SOCKET) alloc_sockets = true; else if (cr_type & CR_CORE) alloc_cores = true; core_map = job_res->core_bitmap; if (job_ptr->details->mc_ptr) { multi_core_data_t *mc_ptr = job_ptr->details->mc_ptr; if ((mc_ptr->ntasks_per_core != (uint16_t) INFINITE) && (mc_ptr->ntasks_per_core)) { ntasks_per_core = mc_ptr->ntasks_per_core; } if (mc_ptr->ntasks_per_socket) ntasks_per_socket = mc_ptr->ntasks_per_socket; } sock_size = select_node_record[0].sockets; sock_avoid = xmalloc(sock_size * sizeof(bool)); sock_start = xmalloc(sock_size * sizeof(uint32_t)); sock_end = xmalloc(sock_size * sizeof(uint32_t)); sock_used = xmalloc(sock_size * sizeof(bool)); size = bit_size(job_res->node_bitmap); csize = bit_size(core_map); for (c = 0, i = 0, n = 0; n < size; n++) { if (bit_test(job_res->node_bitmap, n) == 0) continue; sockets = select_node_record[n].sockets; cps = select_node_record[n].cores; vpus = cr_cpus_per_core(job_ptr->details, n); if (select_debug_flags & DEBUG_FLAG_SELECT_TYPE) { info("DEBUG: job %u node %s vpus %u cpus %u", job_ptr->job_id, select_node_record[n].node_ptr->name, vpus, job_res->cpus[i]); } if ((c + (sockets * cps)) > csize) fatal("cons_res: _cyclic_sync_core_bitmap index error"); if (sockets > sock_size) { sock_size = sockets; xrealloc(sock_avoid, sock_size * sizeof(bool)); xrealloc(sock_start, sock_size * sizeof(uint32_t)); xrealloc(sock_end, sock_size * sizeof(uint32_t)); xrealloc(sock_used, sock_size * sizeof(bool)); } for (s = 0; s < sockets; s++) { sock_start[s] = c + (s * cps); sock_end[s] = sock_start[s] + cps; sock_avoid[s] = false; sock_used[s] = false; } core_cnt = 0; cpus = job_res->cpus[i]; if (ntasks_per_socket != 0xffff) { int x_cpus, cpus_per_socket; uint32_t total_cpus = 0; uint32_t *cpus_cnt; cpus_per_socket = ntasks_per_socket * job_ptr->details->cpus_per_task; cpus_cnt = xmalloc(sizeof(uint32_t) * sockets); for (s = 0; s < sockets; s++) { for (j = sock_start[s]; j < sock_end[s]; j++) { if (bit_test(core_map, j)) cpus_cnt[s] += vpus; } total_cpus += cpus_cnt[s]; } for (s = 0; s < sockets && total_cpus > cpus; s++) { if (cpus_cnt[s] > cpus_per_socket) { x_cpus = cpus_cnt[s] - cpus_per_socket; cpus_cnt[s] = cpus_per_socket; total_cpus -= x_cpus; } } for (s = 0; s < sockets && total_cpus > cpus; s++) { if ((cpus_cnt[s] <= cpus_per_socket) && (total_cpus - cpus_cnt[s] >= cpus)) { sock_avoid[s] = true; total_cpus -= cpus_cnt[s]; } } xfree(cpus_cnt); } else if (job_ptr->details->cpus_per_task > 1) { /* CLANG false positive */ /* Try to pack all CPUs of each tasks on one socket. */ uint32_t *cpus_cnt, cpus_per_task; cpus_per_task = job_ptr->details->cpus_per_task; cpus_cnt = xmalloc(sizeof(uint32_t) * sockets); for (s = 0; s < sockets; s++) { for (j = sock_start[s]; j < sock_end[s]; j++) { if (bit_test(core_map, j)) cpus_cnt[s] += vpus; } cpus_cnt[s] -= (cpus_cnt[s] % cpus_per_task); } tmp_cpt = cpus_per_task; for (s = 0; ((s < sockets) && (cpus > 0)); s++) { while ((sock_start[s] < sock_end[s]) && (cpus_cnt[s] > 0) && (cpus > 0)) { if (bit_test(core_map, sock_start[s])) { int used; sock_used[s] = true; core_cnt++; if ((ntasks_per_core == 1) && (cpus_per_task > vpus)) { used = MIN(tmp_cpt, vpus); if (tmp_cpt <= used) tmp_cpt = cpus_per_task; else tmp_cpt -= used; } else used = vpus; if (cpus_cnt[s] < vpus) cpus_cnt[s] = 0; else cpus_cnt[s] -= used; if (cpus < vpus) cpus = 0; else cpus -= used; } sock_start[s]++; } } xfree(cpus_cnt); } while (cpus > 0) { uint16_t prev_cpus = cpus; for (s = 0; s < sockets && cpus > 0; s++) { if (sock_avoid[s]) continue; while (sock_start[s] < sock_end[s]) { if (bit_test(core_map, sock_start[s])) { sock_used[s] = true; core_cnt++; break; } else sock_start[s]++; } if (sock_start[s] == sock_end[s]) /* this socket is unusable */ continue; if (cpus < vpus) cpus = 0; else cpus -= vpus; sock_start[s]++; } if (prev_cpus != cpus) continue; if (!preempt_mode) { /* we're stuck! */ job_ptr->priority = 0; job_ptr->state_reason = WAIT_HELD; error("%s: sync loop not progressing on node %s, holding job %u", __func__, select_node_record[n].node_ptr->name, job_ptr->job_id); } error_code = SLURM_ERROR; goto fini; } /* clear the rest of the cores in each socket * FIXME: do we need min_core/min_socket checks here? */ for (s = 0; s < sockets; s++) { if (sock_start[s] == sock_end[s]) continue; if (!alloc_sockets || !sock_used[s]) { bit_nclear(core_map, sock_start[s], sock_end[s]-1); } if ((select_node_record[n].vpus >= 1) && (alloc_sockets || alloc_cores) && sock_used[s]) { for (j=sock_start[s]; j<sock_end[s]; j++) { /* Mark all cores as used */ if (alloc_sockets) bit_set(core_map, j); if (bit_test(core_map, j)) core_cnt++; } } } if ((alloc_cores || alloc_sockets) && (select_node_record[n].vpus >= 1)) { job_res->cpus[i] = core_cnt * select_node_record[n].vpus; } i++; /* advance 'c' to the beginning of the next node */ c += sockets * cps; } fini: xfree(sock_avoid); xfree(sock_start); xfree(sock_end); xfree(sock_used); return error_code; }
DValue *DtoCastComplex(Loc &loc, DValue *val, Type *_to) { Type *to = _to->toBasetype(); Type *vty = val->type->toBasetype(); if (to->iscomplex()) { if (vty->size() == to->size()) { return val; } llvm::Value *re, *im; DtoGetComplexParts(loc, val->type, val, re, im); LLType *toty = DtoComplexBaseType(to); if (to->size() < vty->size()) { re = gIR->ir->CreateFPTrunc(re, toty); im = gIR->ir->CreateFPTrunc(im, toty); } else { re = gIR->ir->CreateFPExt(re, toty); im = gIR->ir->CreateFPExt(im, toty); } LLValue *pair = DtoAggrPair(DtoType(_to), re, im); return new DImValue(_to, pair); } if (to->isimaginary()) { // FIXME: this loads both values, even when we only need one LLValue *v = DtoRVal(val); LLValue *impart = gIR->ir->CreateExtractValue(v, 1, ".im_part"); Type *extractty; switch (vty->ty) { default: llvm_unreachable("Unexpected complex floating point type"); case Tcomplex32: extractty = Type::timaginary32; break; case Tcomplex64: extractty = Type::timaginary64; break; case Tcomplex80: extractty = Type::timaginary80; break; } auto im = new DImValue(extractty, impart); return DtoCastFloat(loc, im, to); } if (to->ty == Tbool) { return new DImValue( _to, DtoComplexEquals(loc, TOKnotequal, val, DtoNullValue(vty))); } if (to->isfloating() || to->isintegral()) { // FIXME: this loads both values, even when we only need one LLValue *v = DtoRVal(val); LLValue *repart = gIR->ir->CreateExtractValue(v, 0, ".re_part"); Type *extractty; switch (vty->ty) { default: llvm_unreachable("Unexpected complex floating point type"); case Tcomplex32: extractty = Type::tfloat32; break; case Tcomplex64: extractty = Type::tfloat64; break; case Tcomplex80: extractty = Type::tfloat80; break; } auto re = new DImValue(extractty, repart); return DtoCastFloat(loc, re, to); } error(loc, "Don't know how to cast `%s` to `%s`", vty->toChars(), to->toChars()); fatal(); }
static void setupTerminal(void) { int _stdin, _stdout, _stderr; boolean_t ctty = B_FALSE; char *data; boolean_t open_stdin = getStdinStatus(); if ((data = mdataGet("docker:tty")) != NULL) { if (strcmp("true", data) == 0) { ctty = B_TRUE; } free(data); } dlog("SWITCHING TO /dev/zfd/*\n"); /* * If 'OpenStdin' is set on the container we reopen stdin as connected to * the zfd. Otherwise we leave it opened as /dev/null. */ if (open_stdin) { if (close(0) == -1) { fatal(ERR_CLOSE, "failed to close(0): %s\n", strerror(errno)); } _stdin = open("/dev/zfd/0", O_RDWR); if (_stdin == -1) { if (errno == ENOENT) { _stdin = open("/dev/null", O_RDONLY); if (_stdin == -1) { fatal(ERR_OPEN_CONSOLE, "failed to open /dev/null: %s\n", strerror(errno)); } } else { fatal(ERR_OPEN_CONSOLE, "failed to open /dev/zfd/0: %s\n", strerror(errno)); } } } if (close(1) == -1) { fatal(ERR_CLOSE, "failed to close(1): %s\n", strerror(errno)); } if (close(2) == -1) { fatal(ERR_CLOSE, "failed to close(2): %s\n", strerror(errno)); } if (ctty) { /* Configure output as a controlling terminal */ _stdout = open("/dev/zfd/0", O_WRONLY); if (_stdout == -1) { fatal(ERR_OPEN_CONSOLE, "failed to open /dev/zfd/0: %s\n", strerror(errno)); } _stderr = open("/dev/zfd/0", O_WRONLY); if (_stderr == -1) { fatal(ERR_OPEN_CONSOLE, "failed to open /dev/zfd/0: %s\n", strerror(errno)); } if (setsid() < 0) { fatal(ERR_OPEN_CONSOLE, "failed to create process session: %s\n", strerror(errno)); } if (ioctl(_stdout, TIOCSCTTY, NULL) < 0) { fatal(ERR_OPEN_CONSOLE, "failed set controlling tty: %s\n", strerror(errno)); } } else { /* Configure individual pipe style output */ _stdout = open("/dev/zfd/1", O_WRONLY); if (_stdout == -1) { fatal(ERR_OPEN_CONSOLE, "failed to open /dev/zfd/1: %s\n", strerror(errno)); } _stderr = open("/dev/zfd/2", O_WRONLY); if (_stderr == -1) { fatal(ERR_OPEN_CONSOLE, "failed to open /dev/zfd/2: %s\n", strerror(errno)); } } }
/* sync up core bitmap with new CPU count using a best-fit approach * on the available resources on each node * * "Best-fit" means: * 1st priority: Use smallest number of boards with sufficient * available CPUs * 2nd priority: Use smallest number of sockets with sufficient * available CPUs * 3rd priority: Use board combination with the smallest number * of available CPUs * 4th priority: Use higher-numbered boards/sockets/cores first * * The CPU array contains the distribution of CPUs, which can include * virtual CPUs (hyperthreads) */ static void _block_sync_core_bitmap(struct job_record *job_ptr, const uint16_t cr_type) { uint32_t c, s, i, j, n, b, z, size, csize, core_cnt; uint16_t cpus, num_bits, vpus = 1; uint16_t cpus_per_task = job_ptr->details->cpus_per_task; job_resources_t *job_res = job_ptr->job_resrcs; bool alloc_cores = false, alloc_sockets = false; uint16_t ntasks_per_core = 0xffff; int tmp_cpt = 0; int count, cpu_min, b_min, elig, s_min, comb_idx, sock_idx; int elig_idx, comb_brd_idx, sock_list_idx, comb_min, board_num; int* boards_core_cnt; int* sort_brds_core_cnt; int* board_combs; int* socket_list; int* elig_brd_combs; int* elig_core_cnt; bool* sockets_used; uint16_t boards_nb; uint16_t nboards_nb; uint16_t sockets_nb; uint16_t ncores_nb; uint16_t nsockets_nb; uint16_t sock_per_brd; uint16_t sock_per_comb; uint16_t req_cores,best_fit_cores = 0; uint32_t best_fit_location = 0; uint64_t ncomb_brd; bool sufficient, best_fit_sufficient; if (!job_res) return; if (!job_res->core_bitmap) { error("%s: core_bitmap for job %u is NULL", __func__, job_ptr->job_id); return; } if (bit_ffs(job_res->core_bitmap) == -1) { error("%s: core_bitmap for job %u has no bits set", __func__, job_ptr->job_id); return; } if (cr_type & CR_SOCKET) alloc_sockets = true; else if (cr_type & CR_CORE) alloc_cores = true; if (job_ptr->details && job_ptr->details->mc_ptr) { multi_core_data_t *mc_ptr = job_ptr->details->mc_ptr; if ((mc_ptr->ntasks_per_core != (uint16_t) INFINITE) && (mc_ptr->ntasks_per_core)) { ntasks_per_core = mc_ptr->ntasks_per_core; } } size = bit_size(job_res->node_bitmap); csize = bit_size(job_res->core_bitmap); sockets_nb = select_node_record[0].sockets; sockets_core_cnt = xmalloc(sockets_nb * sizeof(int)); sockets_used = xmalloc(sockets_nb * sizeof(bool)); boards_nb = select_node_record[0].boards; boards_core_cnt = xmalloc(boards_nb * sizeof(int)); sort_brds_core_cnt = xmalloc(boards_nb * sizeof(int)); for (c = 0, i = 0, n = 0; n < size; n++) { if (bit_test(job_res->node_bitmap, n) == 0) continue; core_cnt = 0; ncores_nb = select_node_record[n].cores; nsockets_nb = select_node_record[n].sockets; nboards_nb = select_node_record[n].boards; num_bits = nsockets_nb * ncores_nb; if ((c + num_bits) > csize) fatal("cons_res: _block_sync_core_bitmap index error"); cpus = job_res->cpus[i]; vpus = cr_cpus_per_core(job_ptr->details, n); /* compute still required cores on the node */ req_cores = cpus / vpus; if ( cpus % vpus ) req_cores++; /* figure out core cnt if task requires more than one core and * tasks_per_core is 1 */ if ((ntasks_per_core == 1) && (cpus_per_task > vpus)) { /* how many cores a task will consume */ int cores_per_task = (cpus_per_task + vpus - 1) / vpus; int tasks = cpus / cpus_per_task; req_cores = tasks * cores_per_task; } if (nboards_nb > MAX_BOARDS) { debug3("cons_res: node[%u]: exceeds max boards; " "doing best-fit across sockets only", n); nboards_nb = 1; } if ( nsockets_nb > sockets_nb) { sockets_nb = nsockets_nb; xrealloc(sockets_core_cnt, sockets_nb * sizeof(int)); xrealloc(sockets_used,sockets_nb * sizeof(bool)); } if ( nboards_nb > boards_nb) { boards_nb = nboards_nb; xrealloc(boards_core_cnt, boards_nb * sizeof(int)); xrealloc(sort_brds_core_cnt, boards_nb * sizeof(int)); } /* Count available cores on each socket and board */ if (nsockets_nb >= nboards_nb) { sock_per_brd = nsockets_nb / nboards_nb; } else { error("Node socket count lower than board count " "(%u < %u), job %u node %s", nsockets_nb, nboards_nb, job_ptr->job_id, node_record_table_ptr[n].name); sock_per_brd = 1; } for (b = 0; b < nboards_nb; b++) { boards_core_cnt[b] = 0; sort_brds_core_cnt[b] = 0; } for (s = 0; s < nsockets_nb; s++) { sockets_core_cnt[s]=0; sockets_used[s]=false; b = s/sock_per_brd; for ( j = c + (s * ncores_nb) ; j < c + ((s+1) * ncores_nb) ; j++ ) { if ( bit_test(job_res->core_bitmap,j) ) { sockets_core_cnt[s]++; boards_core_cnt[b]++; sort_brds_core_cnt[b]++; } } } /* Sort boards in descending order of available core count */ qsort(sort_brds_core_cnt, nboards_nb, sizeof (int), _cmp_int_descend); /* Determine minimum number of boards required for the * allocation (b_min) */ count = 0; for (b = 0; b < nboards_nb; b++) { count+=sort_brds_core_cnt[b]; if (count >= req_cores) break; } b_min = b+1; sock_per_comb = b_min * sock_per_brd; /* Allocate space for list of board combinations */ ncomb_brd = comb_counts[nboards_nb-1][b_min-1]; board_combs = xmalloc(ncomb_brd * b_min * sizeof(int)); /* Generate all combinations of b_min boards on the node */ _gen_combs(board_combs, nboards_nb, b_min); /* Determine which combinations have enough available cores * for the allocation (eligible board combinations) */ elig_brd_combs = xmalloc(ncomb_brd * sizeof(int)); elig_core_cnt = xmalloc(ncomb_brd * sizeof(int)); elig = 0; for (comb_idx = 0; comb_idx < ncomb_brd; comb_idx++) { count = 0; for (comb_brd_idx = 0; comb_brd_idx < b_min; comb_brd_idx++) { board_num = board_combs[(comb_idx * b_min) + comb_brd_idx]; count += boards_core_cnt[board_num]; } if (count >= req_cores) { elig_brd_combs[elig] = comb_idx; elig_core_cnt[elig] = count; elig++; } } /* Allocate space for list of sockets for each eligible board * combination */ socket_list = xmalloc(elig * sock_per_comb * sizeof(int)); /* Generate sorted list of sockets for each eligible board * combination, and find combination with minimum number * of sockets and minimum number of cpus required for the * allocation */ s_min = sock_per_comb; comb_min = 0; cpu_min = sock_per_comb * ncores_nb; for (elig_idx = 0; elig_idx < elig; elig_idx++) { comb_idx = elig_brd_combs[elig_idx]; for (comb_brd_idx = 0; comb_brd_idx < b_min; comb_brd_idx++) { board_num = board_combs[(comb_idx * b_min) + comb_brd_idx]; sock_list_idx = (elig_idx * sock_per_comb) + (comb_brd_idx * sock_per_brd); for (sock_idx = 0; sock_idx < sock_per_brd; sock_idx++) { socket_list[sock_list_idx + sock_idx] = (board_num * sock_per_brd) + sock_idx; } } /* Sort this socket list in descending order of * available core count */ qsort(&socket_list[elig_idx*sock_per_comb], sock_per_comb, sizeof (int), _cmp_sock); /* Determine minimum number of sockets required for * the allocation from this socket list */ count = 0; for (b = 0; b < sock_per_comb; b++) { sock_idx = socket_list[(int)((elig_idx*sock_per_comb)+b)]; count+=sockets_core_cnt[sock_idx]; if (count >= req_cores) break; } b++; /* Use board combination with minimum number * of required sockets and minimum number of CPUs */ if ((b < s_min) || (b == s_min && elig_core_cnt[elig_idx] <= cpu_min)) { s_min = b; comb_min = elig_idx; cpu_min = elig_core_cnt[elig_idx]; } } if (select_debug_flags & DEBUG_FLAG_SELECT_TYPE) { info("cons_res: best_fit: node[%u]: " "required cpus: %u, min req boards: %u,", n, cpus, b_min); info("cons_res: best_fit: node[%u]: " "min req sockets: %u, min avail cores: %u", n, s_min, cpu_min); } /* Re-sort socket list for best-fit board combination in * ascending order of socket number */ qsort(&socket_list[comb_min * sock_per_comb], sock_per_comb, sizeof (int), _cmp_int_ascend); xfree(board_combs); xfree(elig_brd_combs); xfree(elig_core_cnt); /* select cores from the sockets of the best-fit board * combination using a best-fit approach */ tmp_cpt = cpus_per_task; while ( cpus > 0 ) { best_fit_cores = 0; best_fit_sufficient = false; /* search for the socket with best fit */ for ( z = 0; z < sock_per_comb; z++ ) { s = socket_list[(comb_min*sock_per_comb)+z]; sufficient = sockets_core_cnt[s] >= req_cores; if ( (best_fit_cores == 0) || (sufficient && !best_fit_sufficient ) || (sufficient && (sockets_core_cnt[s] < best_fit_cores)) || (!sufficient && (sockets_core_cnt[s] > best_fit_cores)) ) { best_fit_cores = sockets_core_cnt[s]; best_fit_location = s; best_fit_sufficient = sufficient; } } /* check that we have found a usable socket */ if ( best_fit_cores == 0 ) break; j = best_fit_location; if (sock_per_brd) j /= sock_per_brd; if (select_debug_flags & DEBUG_FLAG_SELECT_TYPE) { info("cons_res: best_fit: using node[%u]: " "board[%u]: socket[%u]: %u cores " "available", n, j, best_fit_location, sockets_core_cnt[best_fit_location]); } sockets_used[best_fit_location] = true; for ( j = (c + (best_fit_location * ncores_nb)); j < (c + ((best_fit_location + 1) * ncores_nb)); j++ ) { /* * if no more cpus to select * release remaining cores unless * we are allocating whole sockets */ if (cpus == 0) { if (alloc_sockets) { bit_set(job_res->core_bitmap,j); core_cnt++; } else { bit_clear(job_res->core_bitmap,j); } continue; } /* * remove cores from socket count and * cpus count using hyperthreading requirement */ if ( bit_test(job_res->core_bitmap, j) ) { sockets_core_cnt[best_fit_location]--; core_cnt++; if (cpus < vpus) cpus = 0; else if ((ntasks_per_core == 1) && (cpus_per_task > vpus)) { int used = MIN(tmp_cpt, vpus); cpus -= used; if (tmp_cpt <= used) tmp_cpt = cpus_per_task; else tmp_cpt -= used; } else { cpus -= vpus; } } else if (alloc_sockets) { /* If the core is not used, add it * anyway if allocating whole sockets */ bit_set(job_res->core_bitmap, j); core_cnt++; } } /* loop again if more cpus required */ if ( cpus > 0 ) continue; /* release remaining cores of the unused sockets */ for (s = 0; s < nsockets_nb; s++) { if ( sockets_used[s] ) continue; bit_nclear(job_res->core_bitmap, c+(s*ncores_nb), c+((s+1)*ncores_nb)-1); } } xfree(socket_list); if (cpus > 0) { /* cpu count should NEVER be greater than the number * of set bits in the core bitmap for a given node */ fatal("cons_res: cpus computation error"); } /* adjust cpus count of the current node */ if ((alloc_cores || alloc_sockets) && (select_node_record[n].vpus >= 1)) { job_res->cpus[i] = core_cnt * select_node_record[n].vpus; } i++; /* move c to the next node in core_bitmap */ c += num_bits; } xfree(boards_core_cnt); xfree(sort_brds_core_cnt); xfree(sockets_core_cnt); xfree(sockets_used); }
void kexgex_server(Kex *kex) { BIGNUM *shared_secret = NULL, *dh_client_pub = NULL; Key *server_host_public, *server_host_private; DH *dh; u_char *kbuf, *hash, *signature = NULL, *server_host_key_blob = NULL; u_int sbloblen, klen, slen, hashlen; int omin = -1, min = -1, omax = -1, max = -1, onbits = -1, nbits = -1; int type, kout; if (kex->load_host_public_key == NULL || kex->load_host_private_key == NULL) fatal("Cannot load hostkey"); server_host_public = kex->load_host_public_key(kex->hostkey_type); if (server_host_public == NULL) fatal("Unsupported hostkey type %d", kex->hostkey_type); server_host_private = kex->load_host_private_key(kex->hostkey_type); type = packet_read(); switch (type) { case SSH2_MSG_KEX_DH_GEX_REQUEST: debug("SSH2_MSG_KEX_DH_GEX_REQUEST received"); omin = min = packet_get_int(); onbits = nbits = packet_get_int(); omax = max = packet_get_int(); min = MAX(DH_GRP_MIN, min); max = MIN(DH_GRP_MAX, max); nbits = MAX(DH_GRP_MIN, nbits); nbits = MIN(DH_GRP_MAX, nbits); break; case SSH2_MSG_KEX_DH_GEX_REQUEST_OLD: debug("SSH2_MSG_KEX_DH_GEX_REQUEST_OLD received"); onbits = nbits = packet_get_int(); /* unused for old GEX */ omin = min = DH_GRP_MIN; omax = max = DH_GRP_MAX; break; default: fatal("protocol error during kex, no DH_GEX_REQUEST: %d", type); } packet_check_eom(); if (omax < omin || onbits < omin || omax < onbits) fatal("DH_GEX_REQUEST, bad parameters: %d !< %d !< %d", omin, onbits, omax); /* Contact privileged parent */ dh = PRIVSEP(choose_dh(min, nbits, max)); if (dh == NULL) packet_disconnect("Protocol error: no matching DH grp found"); debug("SSH2_MSG_KEX_DH_GEX_GROUP sent"); packet_start(SSH2_MSG_KEX_DH_GEX_GROUP); packet_put_bignum2(dh->p); packet_put_bignum2(dh->g); packet_send(); /* flush */ packet_write_wait(); /* Compute our exchange value in parallel with the client */ dh_gen_key(dh, kex->we_need * 8); debug("expecting SSH2_MSG_KEX_DH_GEX_INIT"); packet_read_expect(SSH2_MSG_KEX_DH_GEX_INIT); /* key, cert */ if ((dh_client_pub = BN_new()) == NULL) fatal("dh_client_pub == NULL"); packet_get_bignum2(dh_client_pub); packet_check_eom(); #ifdef DEBUG_KEXDH fprintf(stderr, "dh_client_pub= "); BN_print_fp(stderr, dh_client_pub); fprintf(stderr, "\n"); debug("bits %d", BN_num_bits(dh_client_pub)); #endif #ifdef DEBUG_KEXDH DHparams_print_fp(stderr, dh); fprintf(stderr, "pub= "); BN_print_fp(stderr, dh->pub_key); fprintf(stderr, "\n"); #endif if (!dh_pub_is_valid(dh, dh_client_pub)) packet_disconnect("bad client public DH value"); klen = DH_size(dh); kbuf = xmalloc(klen); if ((kout = DH_compute_key(kbuf, dh_client_pub, dh)) < 0) fatal("DH_compute_key: failed"); #ifdef DEBUG_KEXDH dump_digest("shared secret", kbuf, kout); #endif if ((shared_secret = BN_new()) == NULL) fatal("kexgex_server: BN_new failed"); if (BN_bin2bn(kbuf, kout, shared_secret) == NULL) fatal("kexgex_server: BN_bin2bn failed"); memset(kbuf, 0, klen); free(kbuf); key_to_blob(server_host_public, &server_host_key_blob, &sbloblen); if (type == SSH2_MSG_KEX_DH_GEX_REQUEST_OLD) omin = min = omax = max = -1; /* calc H */ kexgex_hash( kex->evp_md, kex->client_version_string, kex->server_version_string, buffer_ptr(&kex->peer), buffer_len(&kex->peer), buffer_ptr(&kex->my), buffer_len(&kex->my), server_host_key_blob, sbloblen, omin, onbits, omax, dh->p, dh->g, dh_client_pub, dh->pub_key, shared_secret, &hash, &hashlen ); BN_clear_free(dh_client_pub); /* save session id := H */ if (kex->session_id == NULL) { kex->session_id_len = hashlen; kex->session_id = xmalloc(kex->session_id_len); memcpy(kex->session_id, hash, kex->session_id_len); } /* sign H */ kex->sign(server_host_private, server_host_public, &signature, &slen, hash, hashlen); /* destroy_sensitive_data(); */ /* send server hostkey, DH pubkey 'f' and singed H */ debug("SSH2_MSG_KEX_DH_GEX_REPLY sent"); packet_start(SSH2_MSG_KEX_DH_GEX_REPLY); packet_put_string(server_host_key_blob, sbloblen); packet_put_bignum2(dh->pub_key); /* f */ packet_put_string(signature, slen); packet_send(); free(signature); free(server_host_key_blob); /* have keys, free DH */ DH_free(dh); kex_derive_keys(kex, hash, hashlen, shared_secret); BN_clear_free(shared_secret); kex_finish(kex); }
void cipher_init(CipherContext *cc, Cipher *cipher, const u_char *key, u_int keylen, const u_char *iv, u_int ivlen, int do_encrypt) { static int dowarn = 1; #ifdef SSH_OLD_EVP EVP_CIPHER *type; #else const EVP_CIPHER *type; int klen; #endif u_char *junk, *discard; if (cipher->number == SSH_CIPHER_DES) { if (dowarn) { error("Warning: use of DES is strongly discouraged " "due to cryptographic weaknesses"); dowarn = 0; } if (keylen > 8) keylen = 8; } cc->plaintext = (cipher->number == SSH_CIPHER_NONE); if (keylen < cipher->key_len) fatal("cipher_init: key length %d is insufficient for %s.", keylen, cipher->name); if (iv != NULL && ivlen < cipher->block_size) fatal("cipher_init: iv length %d is insufficient for %s.", ivlen, cipher->name); cc->cipher = cipher; type = (*cipher->evptype)(); EVP_CIPHER_CTX_init(&cc->evp); #ifdef SSH_OLD_EVP if (type->key_len > 0 && type->key_len != keylen) { debug("cipher_init: set keylen (%d -> %d)", type->key_len, keylen); type->key_len = keylen; } EVP_CipherInit(&cc->evp, type, (u_char *)key, (u_char *)iv, (do_encrypt == CIPHER_ENCRYPT)); #else if (EVP_CipherInit(&cc->evp, type, NULL, (u_char *)iv, (do_encrypt == CIPHER_ENCRYPT)) == 0) fatal("cipher_init: EVP_CipherInit failed for %s", cipher->name); klen = EVP_CIPHER_CTX_key_length(&cc->evp); if (klen > 0 && keylen != (u_int)klen) { debug2("cipher_init: set keylen (%d -> %d)", klen, keylen); if (EVP_CIPHER_CTX_set_key_length(&cc->evp, keylen) == 0) fatal("cipher_init: set keylen failed (%d -> %d)", klen, keylen); } if (EVP_CipherInit(&cc->evp, NULL, (u_char *)key, NULL, -1) == 0) fatal("cipher_init: EVP_CipherInit: set key failed for %s", cipher->name); #endif if (cipher->discard_len > 0) { junk = xmalloc(cipher->discard_len); discard = xmalloc(cipher->discard_len); if (EVP_Cipher(&cc->evp, discard, junk, cipher->discard_len) == 0) fatal("evp_crypt: EVP_Cipher failed during discard"); memset(discard, 0, cipher->discard_len); xfree(junk); xfree(discard); } }
template<typename C> void registerClass(const std::string& name) { if (creators.find(name) != creators.end()) fatal("Two classes registered with name \"%s\"", name.c_str()); creators[name] = new ConcreteCreator<C, T, P>(); }
static void idOverflowError(int delta) { Unused(delta); // fix this - maybe eliminate nmethod IDs altogether? fatal("zone: nmethod ID table overflowed"); }
static void read_error(void) { fatal("Module index: unexpected error: %s\n" "Try re-running depmod\n", errno ? strerror(errno) : "EOF"); }
int main(int argc, char *argv[]) { char *arg; const char *printer; struct passwd *p; static char root[] = "root"; printer = NULL; uid = getuid(); euid = geteuid(); PRIV_END /* be safe */ progname = argv[0]; gethostname(local_host, sizeof(local_host)); openlog("lpd", 0, LOG_LPR); /* * Bogus code later checks for string equality between * `person' and "root", so if we are root, better make sure * that code will succeed. */ if (getuid() == 0) { person = root; } else if ((person = getlogin()) == NULL) { if ((p = getpwuid(getuid())) == NULL) fatal(0, "Who are you?"); if (strlen(p->pw_name) >= sizeof(luser)) fatal(0, "Your name is too long"); strcpy(luser, p->pw_name); person = luser; } while (--argc) { if ((arg = *++argv)[0] == '-') switch (arg[1]) { case 'P': if (arg[2]) printer = &arg[2]; else if (argc > 1) { argc--; printer = *++argv; } break; case '\0': if (!users) { users = -1; break; } default: usage(); } else { if (users < 0) usage(); if (isdigit(arg[0])) { if (requests >= MAXREQUESTS) fatal(0, "Too many requests"); requ[requests++] = atoi(arg); } else { if (users >= MAXUSERS) fatal(0, "Too many users"); user[users++] = arg; } } } if (printer == NULL && (printer = getenv("PRINTER")) == NULL) printer = DEFLP; rmjob(printer); exit(0); }
int main (int argc, char **argv) { int ch; setprogname (argv[0]); bool skip_sigs = false; while ((ch = getopt (argc, argv, "s")) != -1) { switch (ch) { case 's': skip_sigs = true; break; default: usage (); break; } } argc -= optind; argv += optind; if (argc != 3 || !convertint (argv[0], &shmfd) || !convertint (argv[1], &rfd) || !convertint (argv[2], &rwfd)) usage (); #ifdef MAINTAINER if (getenv ("AIOD_PAUSE")) { struct sigaction sa; bzero (&sa, sizeof (sa)); sa.sa_handler = nop; #ifdef SA_RESETHAND sa.sa_flags = SA_RESETHAND; #endif /* SA_RESETHAND */ sigaction (SIGCONT, &sa, NULL); warn ("pid %d, pausing\n", int (getpid ())); timeval tv; tv.tv_sec = 60; tv.tv_usec = 0; select (0, NULL, NULL, NULL, &tv); } #endif /* MAINTAINER */ umask (0); ptr<shmbuf> b = shmbuf::alloc (shmfd); if (!b) fatal ("could not map shared memory buffer\n"); srv = New aiosrv (rwfd, b); if (!skip_sigs) { (void) sigemptyset (&sigio_mask); sigaddset (&sigio_mask, SIGIO); sigprocmask (SIG_BLOCK, &sigio_mask, NULL); struct sigaction sa; bzero (&sa, sizeof (sa)); sa.sa_handler = sigio_handler; if (sigaction (SIGIO, &sa, NULL) < 0) fatal ("sigaction: %m\n"); /* Since the client code might not necessarily tolerate the death of * an aiod process, put ourselves in a new process group. That way * if the parent process catches terminal signals like SIGINT, the * aiods will not die. This allows the parent still to issue aio * requests while handling the signal. Additionally, if sigio_set * uses SIOCSPGRP, starting a new process group avoids hitting other * processes with our SIGIO signals. */ setpgid (0, 0); if (sigio_set (rwfd) < 0) fatal ("could not enable SIGIO\n"); msg_loop (); } else { msg_loop_simple (); } return 1; }
// Implementation of NativeMov void NativeMov::verify() { // make sure code pattern is actually a mov reg, imm32 instruction if ((*(u_char*)instruction_address() & !register_mask) != instruction_code) fatal("not a mov reg, imm32"); }
int main(int argc, char **argv) { int debug_flag = 0, log_level = SYSLOG_LEVEL_INFO; int opt, fopt_count = 0, j; char *tname, *cp, line[NI_MAXHOST]; FILE *fp; u_long linenum; extern int optind; extern char *optarg; __progname = ssh_get_progname(argv[0]); init_rng(); seed_rng(); TAILQ_INIT(&tq); /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */ sanitise_stdfd(); if (argc <= 1) usage(); while ((opt = getopt(argc, argv, "Hv46p:T:t:f:")) != -1) { switch (opt) { case 'H': hash_hosts = 1; break; case 'p': ssh_port = a2port(optarg); if (ssh_port <= 0) { fprintf(stderr, "Bad port '%s'\n", optarg); exit(1); } break; case 'T': timeout = convtime(optarg); if (timeout == -1 || timeout == 0) { fprintf(stderr, "Bad timeout '%s'\n", optarg); usage(); } break; case 'v': if (!debug_flag) { debug_flag = 1; log_level = SYSLOG_LEVEL_DEBUG1; } else if (log_level < SYSLOG_LEVEL_DEBUG3) log_level++; else fatal("Too high debugging level."); break; case 'f': if (strcmp(optarg, "-") == 0) optarg = NULL; argv[fopt_count++] = optarg; break; case 't': get_keytypes = 0; tname = strtok(optarg, ","); while (tname) { int type = key_type_from_name(tname); switch (type) { case KEY_RSA1: get_keytypes |= KT_RSA1; break; case KEY_DSA: get_keytypes |= KT_DSA; break; case KEY_ECDSA: get_keytypes |= KT_ECDSA; break; case KEY_RSA: get_keytypes |= KT_RSA; break; case KEY_UNSPEC: fatal("unknown key type %s", tname); } tname = strtok(NULL, ","); } break; case '4': IPv4or6 = AF_INET; break; case '6': IPv4or6 = AF_INET6; break; case '?': default: usage(); } } if (optind == argc && !fopt_count) usage(); log_init("ssh-keyscan", log_level, SYSLOG_FACILITY_USER, 1); maxfd = fdlim_get(1); if (maxfd < 0) fatal("%s: fdlim_get: bad value", __progname); if (maxfd > MAXMAXFD) maxfd = MAXMAXFD; if (MAXCON <= 0) fatal("%s: not enough file descriptors", __progname); if (maxfd > fdlim_get(0)) fdlim_set(maxfd); fdcon = xcalloc(maxfd, sizeof(con)); read_wait_nfdset = howmany(maxfd, NFDBITS); read_wait = xcalloc(read_wait_nfdset, sizeof(fd_mask)); for (j = 0; j < fopt_count; j++) { if (argv[j] == NULL) fp = stdin; else if ((fp = fopen(argv[j], "r")) == NULL) fatal("%s: %s: %s", __progname, argv[j], strerror(errno)); linenum = 0; while (read_keyfile_line(fp, argv[j] == NULL ? "(stdin)" : argv[j], line, sizeof(line), &linenum) != -1) { /* Chomp off trailing whitespace and comments */ if ((cp = strchr(line, '#')) == NULL) cp = line + strlen(line) - 1; while (cp >= line) { if (*cp == ' ' || *cp == '\t' || *cp == '\n' || *cp == '#') *cp-- = '\0'; else break; } /* Skip empty lines */ if (*line == '\0') continue; do_host(line); } if (ferror(fp)) fatal("%s: %s: %s", __progname, argv[j], strerror(errno)); fclose(fp); } while (optind < argc) do_host(argv[optind++]); while (ncon > 0) conloop(); return (0); }
int main(int argc, char *argv[]) { FILE *f; char buf[10000], type[100]; // int sum = 0; struct n_pair *gnames1, *gnames2; int num_gnames1 = 0, num_gnames2 = 0; int i = 0, j = 0, cur_id = 0; bool is_in = false; bool is_first = false; if( argc == 4 ) { is_first = true; } else if( argc != 3 ) { fatal("common_gene_list two_columns_list single_column_list (or FIRST)\n"); } strcpy(buf, ""); strcpy(type, ""); if((f = ckopen(argv[1], "r")) == NULL ) { fatalf("Cannot open file %s\n", argv[1]); } else { while(fgets(buf, 10000, f)) { num_gnames1++; } } if( num_gnames1 > 0 ) { gnames1 = (struct n_pair *) ckalloc(num_gnames1 * sizeof(struct n_pair)); for( i = 0; i < num_gnames1; i++ ) { strcpy(gnames1[i].name1, ""); strcpy(gnames1[i].name2, ""); strcpy(gnames1[i].name2, ""); gnames1[i].id = 0; gnames1[i].len = 0; } } fseek(f, 0, SEEK_SET); i = 0; while(fgets(buf, 10000, f)) { if( sscanf(buf, "%s %s %*s", gnames1[i].name1, gnames1[i].name2) != 2 ) { fatalf("wrong format in the gene list: %s", buf); } i++; } fclose(f); if((f = ckopen(argv[2], "r")) == NULL ) { fatalf("Cannot open file %s\n", argv[2]); } else { while(fgets(buf, 10000, f)) { num_gnames2++; } } if( num_gnames2 > 0 ) { gnames2 = (struct n_pair *) ckalloc(num_gnames2 * sizeof(struct n_pair)); for( i = 0; i < num_gnames2; i++ ) { strcpy(gnames2[i].name1, ""); strcpy(gnames2[i].name2, ""); strcpy(gnames2[i].name2, ""); gnames2[i].id = 0; gnames2[i].len = 0; } } fseek(f, 0, SEEK_SET); i = 0; while(fgets(buf, 10000, f)) { if( sscanf(buf, "%s %*s", gnames2[i].name1) != 1 ) { fatalf("wrong format in the gene list: %s", buf); } i++; } fclose(f); for( i = 0; i < num_gnames1; i++ ) { j = 0; is_in = false; cur_id = -1; while( (j < num_gnames2) && (is_in == false ) ) { if(strcmp(gnames1[i].name1, gnames2[j].name1) == 0) { is_in = true; cur_id = j; } j++; } if( is_in == true ) { if( cur_id == -1 ) { fatalf("unexpected case: %s\n", gnames1[i].name1); } if( is_first == false ) { printf("%s %s\n", gnames1[i].name1, gnames1[i].name2); } else { printf("%s\n", gnames1[i].name1); } } } if( num_gnames1 > 0 ) { free(gnames1); } if( num_gnames2 > 0 ) { free(gnames2); } return EXIT_SUCCESS; }
/* == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == */ int main(int argc, char *argv[]) { CDLL list; int i,direction,k; CDLL_NODE *currNode; if (argc < 4) { printf("You must supply 3 values on the cmd line after %s:\n", argv[0]); printf("1: name of an input file contaning n names/labels of the members of the circle\n"); printf("2: an integer: m < n , indicating that every m'th member gets deleted until all the members are deleted\n"); printf("3: a string \"CW\" or \"CCW\" for clockwise counter-clockwise. This is the direction\n"); printf(" you will move as you advance around the ring deleting members\n"); exit( EXIT_FAILURE ); } k = atoi(argv[2]); /* assume valid int < n */ if (strcmp(argv[3],"CW")==0) direction = CLOCKWISE; /* follow the NEXT ptr */ else direction = COUNTERCLOCKWISE; /* follow the PREV ptr */ /* Initialize CDLL (set head ptr NULL and set the cmp function */ initList(&list, compareStudent,printStudent,freeStudent); loadList(&list,argv[1]); printf("\nLIST: ");printList(list, CLOCKWISE, BRIEF ); /* we follow the NEXT ptr around the ring, not the PREV ptr */ do /* prompt user for a member to start the counting with */ { char *andrewID; STUDENT *s = malloc(sizeof(STUDENT)); if (!s) fatal("malloc( sizeof(STUDENT)) failed in main"); currNode=NULL; printf("\nchoose an ID as the starting point in the circle: "); fflush(stdout); if (!mygetline(&andrewID,stdin)) fatal("mygetline failed on stdin."); s->andrewID = andrewID; currNode = searchList( list, s); /* Can't call freeStudent() because it will free the name and major string but we didnt put any in this one - this student only has the id field initilaized. so manually just free the andereID string then node*/ free( s->andrewID ); free( s ); } while (!currNode); while (list.head) /* WHILE THERE ARE ANY MEMBERS STILL ALIVE */ { printf("\nDELETING: "); printStudent( currNode->data, BRIEF); fflush(stdout); currNode = deleteNode( &list, currNode, direction ); if (!currNode) { printf(" <-- was the last man standing!\n"); break; } printf("\nLIST: ");printList(list, CLOCKWISE, BRIEF ); printf("RESUMING AT: "); printStudent( currNode->data, BRIEF ); printf(" and skipping %d elements \n", k ); for ( i=1 ; i<=k ; ++i ) if (direction==CLOCKWISE) currNode = currNode->next; else currNode=currNode->prev; } /* END WHILE - END OF GAME */ return EXIT_SUCCESS; }
int main(int argc, char **argv) { Buffer b; Options options; Key *keys[2], *key; struct passwd *pw; int key_fd[2], i, found, version = 2, fd; u_char *signature, *data; char *host; u_int slen, dlen; u_int32_t rnd[256]; key_fd[0] = open(_PATH_HOST_RSA_KEY_FILE, O_RDONLY); key_fd[1] = open(_PATH_HOST_DSA_KEY_FILE, O_RDONLY); seteuid(getuid()); setuid(getuid()); init_rng(); seed_rng(); arc4random_stir(); #ifdef DEBUG_SSH_KEYSIGN log_init("ssh-keysign", SYSLOG_LEVEL_DEBUG3, SYSLOG_FACILITY_AUTH, 0); #endif /* verify that ssh-keysign is enabled by the admin */ original_real_uid = getuid(); /* XXX readconf.c needs this */ initialize_options(&options); (void)read_config_file(_PATH_HOST_CONFIG_FILE, "", &options); fill_default_options(&options); if (options.enable_ssh_keysign != 1) fatal("ssh-keysign not enabled in %s", _PATH_HOST_CONFIG_FILE); if (key_fd[0] == -1 && key_fd[1] == -1) fatal("could not open any host key"); if ((pw = getpwuid(getuid())) == NULL) fatal("getpwuid failed"); pw = pwcopy(pw); SSLeay_add_all_algorithms(); for (i = 0; i < 256; i++) rnd[i] = arc4random(); RAND_seed(rnd, sizeof(rnd)); found = 0; for (i = 0; i < 2; i++) { keys[i] = NULL; if (key_fd[i] == -1) continue; keys[i] = key_load_private_pem(key_fd[i], KEY_UNSPEC, NULL, NULL); close(key_fd[i]); if (keys[i] != NULL) found = 1; } if (!found) fatal("no hostkey found"); buffer_init(&b); if (ssh_msg_recv(STDIN_FILENO, &b) < 0) fatal("ssh_msg_recv failed"); if (buffer_get_char(&b) != version) fatal("bad version"); fd = buffer_get_int(&b); if ((fd == STDIN_FILENO) || (fd == STDOUT_FILENO)) fatal("bad fd"); if ((host = get_local_name(fd)) == NULL) fatal("cannot get sockname for fd"); data = buffer_get_string(&b, &dlen); if (valid_request(pw, host, &key, data, dlen) < 0) fatal("not a valid request"); xfree(host); found = 0; for (i = 0; i < 2; i++) { if (keys[i] != NULL && key_equal(key, keys[i])) { found = 1; break; } } if (!found) fatal("no matching hostkey found"); if (key_sign(keys[i], &signature, &slen, data, dlen) != 0) fatal("key_sign failed"); xfree(data); /* send reply */ buffer_clear(&b); buffer_put_string(&b, signature, slen); if (ssh_msg_send(STDOUT_FILENO, version, &b) == -1) fatal("ssh_msg_send failed"); return (0); }
int main(int argc, const char **argv) { char *p; unsigned int i; int rc; unsigned long network_prefix = 32; unsigned int suffix; int opt_version = 0, opt_help = 0, opt_error = 0; progname = strrchr(argv[0], '/'); if (progname) progname++; else progname = argv[0]; openlog(progname, LOG_PID, LOG_MAIL); for (i = 1; i < argc; i++) { if (optp(argv[i], "-d", "--debug")) debug_me = 1; else if (optp(argv[i], "-v", "--verbose")) opt_verbose++; else if (optp(argv[i], "-V", "--version")) opt_version = 1; else if (loptp(argv[i], "--help")) opt_help = 1; else if (optp(argv[i], "-b", "--bloc-max-idle")) { if (++i >= argc) fatal("Missing argument to --bloc-max-idle"); bloc_max_idle = strtoul(argv[i], &p, 10); if (*p) fatal("Invalid argument to --bloc-max-idle. " "Integer value expected"); } else if (optp(argv[i], "-g", "--greylist-delay")) { if (++i >= argc) fatal("Missing argument to --greylist-delay"); greylist_delay = strtoul(argv[i], &p, 10); if (*p) fatal("Invalid argument to --greylist-delay. " "Integer value expected"); } else if (optp(argv[i], "-c", "--cryptlist-delay")) { if (++i >= argc) fatal("Missing argument to --cryptlist-delay"); cryptlist_delay = strtoul(argv[i], &p, 10); if (*p) fatal("Invalid argument to --cryptlist-delay. " "Integer value expected"); } else if (optp(argv[i], "-h", "--home")) { if (++i >= argc) fatal("Missing argument to --home"); db_home = argv[i]; } else if (optp(argv[i], "-/", "--network-prefix")) { if (++i >= argc) fatal("Missing argument to --network-prefix"); network_prefix = strtoul(argv[i], &p, 10); if (*p || network_prefix > 32U) fatal("Invalid argument to --network-prefix. " "Integer value between 0 and 32 expected"); } else if (optp(argv[i], "-p", "--pass-max-idle")) { if (++i >= argc) fatal("Missing argument to --pass-max-idle"); pass_max_idle = strtoul(argv[i], &p, 10); if (*p) fatal("Invalid argument to --pass-max-idle. " "Integer value expected"); } else if (optp(argv[i], "-r", "--reject-action")) { if (++i >= argc) fatal("Missing argument to --reject-action"); reject_action_fmt = argv[i]; } else if (optp(argv[i], "-R", "--reject-unencrypted-action")) { if (++i >= argc) fatal("Missing argument to --reject-unencrypted-action"); reject_unencrypted_action_fmt = argv[i]; } else if (optp(argv[i], "-G", "--greylisted-action")) { if (++i >= argc) fatal("Missing argument to --greylisted-action"); greylisted_action_fmt = argv[i]; } else if (optp(argv[i], "-C", "--cryptlisted-action")) { if (++i >= argc) fatal("Missing argument to --greylisted-action"); cryptlisted_action_fmt = argv[i]; } else if (loptp(argv[i], "--dump-triplets")) { dump_triplets = 1; } else if (optp(argv[i],"-B","--block-unencrypted")) { block_unencrypted = 1; } else { fprintf(stderr, "Unknown option \"%s\"\n", argv[i]); opt_error = 1; } } if (opt_error) { print_usage(stderr, progname); exit(EXIT_FAILURE); } if (opt_version) puts(PACKAGE_STRING); if (opt_help) { print_usage(stdout, progname); exit(EXIT_SUCCESS); } suffix = 32 - network_prefix; ipv4_network_strip_bytes = suffix >> 3; ipv4_network_mask = 0xffU & ~0U << (suffix & 0x7U); #ifdef SIGHUP signal(SIGHUP, signal_handler); #endif #ifdef SIGINT signal(SIGINT, signal_handler); #endif #ifdef SIGQUIT signal(SIGQUIT, signal_handler); #endif #ifdef SIGILL signal(SIGILL, signal_handler); #endif #ifdef SIGABRT signal(SIGABRT, signal_handler); #endif #ifdef SIGSEGV signal(SIGSEGV, signal_handler); #endif #ifdef SIGALRM signal(SIGALRM, signal_handler); #endif #ifdef SIGTERM signal(SIGTERM, signal_handler); #endif rc = initialize(); if (rc) { cleanup(); syslog(LOG_ERR, "error: initialization failure: %s", db_strerror(rc)); } if (dump_triplets) do_dump_triplets(); else while (read_policy_request(0)) { const char *protocol = 0, *state = 0, *ip, *from, *to, *encryption_protocol = 0, *ccert_fingerprint = 0; int crypted = 0; if ((protocol = find_attribute("protocol_name")) && (state = find_attribute("protocol_state")) && (prefixp(protocol, STR_SMTP) || prefixp(protocol, STR_ESMTP)) && prefixp(state, STR_RCPT) && (ip = find_attribute("client_address")) && (from = find_attribute("sender")) && (to = find_attribute("recipient"))) { encryption_protocol = find_attribute("encryption_protocol"); ccert_fingerprint = find_attribute("ccert_fingerprint"); if (encryption_protocol) { // grumble - find_attribute returns a \n terminated string, not null int i; char actual_crypt[255]; char actual_fingerprint[255]; // FIXME actual_crypt[0] = '\0'; actual_fingerprint[0] = '\0'; if(encryption_protocol[0] != '\n') { crypted = triplet_data.crypted = TRANSPORT_ENCRYPTED; // FIXME, figure out what it is for(i = 0; i < 255 && encryption_protocol[i] != '\n'; i++) ; if(i > 0) { strncpy(actual_crypt,encryption_protocol,i); actual_crypt[i] = '\0'; } for(i = 0; i < 255 && ccert_fingerprint[i] != '\n'; i++) ; if(i > 0) { strncpy(actual_fingerprint,ccert_fingerprint,i); actual_fingerprint[i] = '\0'; } syslog(LOG_DEBUG,"Encryption: %s Fingerprint: %s", actual_crypt ? actual_crypt : "NA", actual_fingerprint ? actual_fingerprint : "NA"); } } build_triplet_key(ip, from, to); if (process_smtp_rcpt(crypted)) { syslog(LOG_ERR, "error: cleaning up"); cleanup(); syslog(LOG_ERR, "error: exiting after cleanup"); return 1; } } else { puts(STR_ACTION "DUNNO"); if (debug_me) { char *p = 0, *s = 0; if (protocol) { p = strchr(protocol, '\n'); *p = 0; } if (state) { s = strchr(state, '\n'); *s = 0; } syslog(LOG_DEBUG, "Ignoring protocol %s state %s", protocol ? protocol : "(not defined)", state ? state : "(not defined)"); if (p) *p = '\n'; if (s) *s = '\n'; } } putchar('\n'); fflush(stdout); } run_expiry(); cleanup(); if (opt_verbose) syslog(LOG_NOTICE, "daemon stopped"); closelog(); return 0; }
int mm_answer_pty(int sock, Buffer *m) { extern struct monitor *pmonitor; Session *s; int res, fd0; debug3("%s entering", __func__); buffer_clear(m); s = session_new(); if (s == NULL) goto error; s->authctxt = authctxt; s->pw = authctxt->pw; s->pid = pmonitor->m_pid; res = pty_allocate(&s->ptyfd, &s->ttyfd, s->tty, sizeof(s->tty)); if (res == 0) goto error; pty_setowner(authctxt->pw, s->tty); buffer_put_int(m, 1); buffer_put_cstring(m, s->tty); /* We need to trick ttyslot */ if (dup2(s->ttyfd, 0) == -1) fatal("%s: dup2", __func__); mm_record_login(s, authctxt->pw); /* Now we can close the file descriptor again */ close(0); /* send messages generated by record_login */ buffer_put_string(m, buffer_ptr(&loginmsg), buffer_len(&loginmsg)); buffer_clear(&loginmsg); mm_request_send(sock, MONITOR_ANS_PTY, m); mm_send_fd(sock, s->ptyfd); mm_send_fd(sock, s->ttyfd); /* make sure nothing uses fd 0 */ if ((fd0 = open(_PATH_DEVNULL, O_RDONLY)) < 0) fatal("%s: open(/dev/null): %s", __func__, strerror(errno)); if (fd0 != 0) error("%s: fd0 %d != 0", __func__, fd0); /* slave is not needed */ close(s->ttyfd); s->ttyfd = s->ptyfd; /* no need to dup() because nobody closes ptyfd */ s->ptymaster = s->ptyfd; debug3("%s: tty %s ptyfd %d", __func__, s->tty, s->ttyfd); return (0); error: if (s != NULL) mm_session_close(s); buffer_put_int(m, 0); mm_request_send(sock, MONITOR_ANS_PTY, m); return (0); }
int main(int argc, char *argv[]) { struct utmpx ut; char *devName; if (argc < 2 || strcmp(argv[1], "--help") == 0) usageErr("%s username [sleep-time]\n", argv[0]); /* Initialize login record for utmp and wtmp files */ memset(&ut, 0, sizeof(struct utmpx)); ut.ut_type = USER_PROCESS; /* This is a user login */ strncpy(ut.ut_user, argv[1], sizeof(ut.ut_user)); if (time((time_t *) &ut.ut_tv.tv_sec) == -1) errExit("time"); /* Stamp with current time */ ut.ut_pid = getpid(); /* Set ut_line and ut_id based on the terminal associated with 'stdin'. This code assumes terminals named "/dev/[pt]t[sy]*". The "/dev/" dirname is 5 characters; the "[pt]t[sy]" filename prefix is 3 characters (making 8 characters in all). */ devName = ttyname(STDIN_FILENO); if (devName == NULL) errExit("ttyname"); if (strlen(devName) <= 8) /* Should never happen */ fatal("Terminal name is too short: %s", devName); strncpy(ut.ut_line, devName + 5, sizeof(ut.ut_line)); strncpy(ut.ut_id, devName + 8, sizeof(ut.ut_id)); printf("Creating login entries in utmp and wtmp\n"); printf(" using pid %ld, line %.*s, id %.*s\n", (long) ut.ut_pid, (int) sizeof(ut.ut_line), ut.ut_line, (int) sizeof(ut.ut_id), ut.ut_id); setutxent(); /* Rewind to start of utmp file */ if (pututxline(&ut) == NULL) /* Write login record to utmp */ errExit("pututxline"); updwtmpx(_PATH_WTMP, &ut); /* Append login record to wtmp */ /* Sleep a while, so we can examine utmp and wtmp files */ sleep((argc > 2) ? getInt(argv[2], GN_NONNEG, "sleep-time") : 15); /* Now do a "logout"; use values from previously initialized 'ut', except for changes below */ ut.ut_type = DEAD_PROCESS; /* Required for logout record */ time((time_t *) &ut.ut_tv.tv_sec); /* Stamp with logout time */ memset(&ut.ut_user, 0, sizeof(ut.ut_user)); /* Logout record has null username */ printf("Creating logout entries in utmp and wtmp\n"); setutxent(); /* Rewind to start of utmp file */ if (pututxline(&ut) == NULL) /* Overwrite previous utmp record */ errExit("pututxline"); updwtmpx(_PATH_WTMP, &ut); /* Append logout record to wtmp */ endutxent(); exit(EXIT_SUCCESS); }
void monitor_child_preauth(Authctxt *_authctxt, struct monitor *pmonitor) { struct mon_table *ent; int authenticated = 0; debug3("preauth child monitor started"); authctxt = _authctxt; memset(authctxt, 0, sizeof(*authctxt)); authctxt->loginmsg = &loginmsg; if (compat20) { mon_dispatch = mon_dispatch_proto20; /* Permit requests for moduli and signatures */ monitor_permit(mon_dispatch, MONITOR_REQ_MODULI, 1); monitor_permit(mon_dispatch, MONITOR_REQ_SIGN, 1); } else { mon_dispatch = mon_dispatch_proto15; monitor_permit(mon_dispatch, MONITOR_REQ_SESSKEY, 1); } /* The first few requests do not require asynchronous access */ while (!authenticated) { auth_method = "unknown"; authenticated = (monitor_read(pmonitor, mon_dispatch, &ent) == 1); if (authenticated) { if (!(ent->flags & MON_AUTHDECIDE)) fatal("%s: unexpected authentication from %d", __func__, ent->type); if (authctxt->pw->pw_uid == 0 && !auth_root_allowed(auth_method)) authenticated = 0; #ifdef USE_PAM /* PAM needs to perform account checks after auth */ if (options.use_pam && authenticated) { Buffer m; buffer_init(&m); mm_request_receive_expect(pmonitor->m_sendfd, MONITOR_REQ_PAM_ACCOUNT, &m); authenticated = mm_answer_pam_account(pmonitor->m_sendfd, &m); buffer_free(&m); } #endif } if (ent->flags & (MON_AUTHDECIDE|MON_ALOG)) { auth_log(authctxt, authenticated, auth_method, compat20 ? " ssh2" : ""); if (!authenticated) authctxt->failures++; } } if (!authctxt->valid) fatal("%s: authenticated invalid user", __func__); if (strcmp(auth_method, "unknown") == 0) fatal("%s: authentication method name unknown", __func__); debug("%s: %s has been authenticated by privileged process", __func__, authctxt->user); mm_get_keystate(pmonitor); }
int main(int argc, char *argv[]) { bool inhibit_loadfade = false; bool error = false; bool freshstart; SetLogFilename("debug.txt"); if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) { staterr("ack, sdl_init failed: %s.", SDL_GetError()); return 1; } atexit(SDL_Quit); // start up inputs first thing because settings_load may remap them input_init(); // load settings, or at least get the defaults, // so we know the initial screen resolution. settings_load(); if (Graphics::init(settings->resolution)) { staterr("Failed to initialize graphics."); return 1; } if (font_init()) { staterr("Failed to load font."); return 1; } //speed_test(); //return 1; #ifdef CONFIG_DATA_EXTRACTOR if (!settings->files_extracted) { if (extract_main()) { Graphics::close(); font_close(); return 0; } else { settings->files_extracted = true; settings_save(); } } #endif if (check_data_exists()) { return 1; } //Graphics::ShowLoadingScreen(); if (sound_init()) { fatal("Failed to initialize sound."); return 1; } if (trig_init()) { fatal("Failed trig module init."); return 1; } if (tsc_init()) { fatal("Failed to initialize script engine."); return 1; } if (textbox.Init()) { fatal("Failed to initialize textboxes."); return 1; } if (Carets::init()) { fatal("Failed to initialize carets."); return 1; } if (game.init()) return 1; game.setmode(GM_NORMAL); // set null stage just to have something to do while we go to intro game.switchstage.mapno = 0; //#define REPLAY #ifdef REPLAY game.switchstage.mapno = START_REPLAY; //Replay::set_ffwd(6000); //Replay::set_stopat(3500); game.switchstage.param = 1; #else //game.switchstage.mapno = LOAD_GAME; //game.pause(GP_OPTIONS); if (settings->skip_intro && file_exists(GetProfileName(settings->last_save_slot))) game.switchstage.mapno = LOAD_GAME; else game.setmode(GM_INTRO); #endif // for debug if (game.paused) { game.switchstage.mapno = 0; game.switchstage.eventonentry = 0; } if (game.switchstage.mapno == LOAD_GAME) inhibit_loadfade = true; game.running = true; freshstart = true; stat("Entering main loop..."); #ifdef __SDLSHIM__ set_console_visible(false); #endif //speed_test(); //return 1; while(game.running) { // SSS/SPS persists across stage transitions until explicitly // stopped, or you die & reload. It seems a bit risky to me, // but that's the spec. if (game.switchstage.mapno >= MAPNO_SPECIALS) { StopLoopSounds(); } // enter next stage, whatever it may be if (game.switchstage.mapno == LOAD_GAME || \ game.switchstage.mapno == LOAD_GAME_FROM_MENU) { if (game.switchstage.mapno == LOAD_GAME_FROM_MENU) freshstart = true; stat("= Loading game ="); if (game_load(settings->last_save_slot)) { fatal("savefile error"); goto ingame_error; } Replay::OnGameStarting(); if (!inhibit_loadfade) fade.Start(FADE_IN, FADE_CENTER); else inhibit_loadfade = false; } else if (game.switchstage.mapno == START_REPLAY) { stat(">> beginning replay '%s'", GetReplayName(game.switchstage.param)); StopScripts(); if (Replay::begin_playback(GetReplayName(game.switchstage.param))) { fatal("error starting playback"); goto ingame_error; } } else { if (game.switchstage.mapno == NEW_GAME || \ game.switchstage.mapno == NEW_GAME_FROM_MENU) { bool show_intro = (game.switchstage.mapno == NEW_GAME_FROM_MENU); InitNewGame(show_intro); } // slide weapon bar on first intro to Start Point if (game.switchstage.mapno == STAGE_START_POINT && \ game.switchstage.eventonentry == 91) { freshstart = true; } // switch maps if (load_stage(game.switchstage.mapno)) goto ingame_error; player->x = (game.switchstage.playerx * TILE_W) << CSF; player->y = (game.switchstage.playery * TILE_H) << CSF; } // start the level if (game.initlevel()) return 1; if (freshstart) weapon_introslide(); gameloop(); game.stageboss.OnMapExit(); freshstart = false; } shutdown: ; Replay::close(); game.close(); Carets::close(); Graphics::close(); input_close(); font_close(); sound_close(); tsc_close(); textbox.Deinit(); return error; ingame_error: ; stat(""); stat(" ************************************************"); stat(" * An in-game error occurred. Game shutting down."); stat(" ************************************************"); error = true; goto shutdown; }
int mm_answer_keyallowed(int sock, Buffer *m) { Key *key; char *cuser, *chost; u_char *blob; u_int bloblen; enum mm_keytype type = 0; int allowed = 0; debug3("%s entering", __func__); type = buffer_get_int(m); cuser = buffer_get_string(m, NULL); chost = buffer_get_string(m, NULL); blob = buffer_get_string(m, &bloblen); key = key_from_blob(blob, bloblen); if ((compat20 && type == MM_RSAHOSTKEY) || (!compat20 && type != MM_RSAHOSTKEY)) fatal("%s: key type and protocol mismatch", __func__); debug3("%s: key_from_blob: %p", __func__, key); if (key != NULL && authctxt->valid) { switch (type) { case MM_USERKEY: allowed = options.pubkey_authentication && user_key_allowed(authctxt->pw, key); auth_method = "publickey"; break; case MM_HOSTKEY: allowed = options.hostbased_authentication && hostbased_key_allowed(authctxt->pw, cuser, chost, key); auth_method = "hostbased"; break; case MM_RSAHOSTKEY: key->type = KEY_RSA1; /* XXX */ allowed = options.rhosts_rsa_authentication && auth_rhosts_rsa_key_allowed(authctxt->pw, cuser, chost, key); auth_method = "rsa"; break; default: fatal("%s: unknown key type %d", __func__, type); break; } } if (key != NULL) key_free(key); /* clear temporarily storage (used by verify) */ monitor_reset_key_state(); if (allowed) { /* Save temporarily for comparison in verify */ key_blob = blob; key_bloblen = bloblen; key_blobtype = type; hostbased_cuser = cuser; hostbased_chost = chost; } else { /* Log failed attempt */ auth_log(authctxt, 0, auth_method, compat20 ? " ssh2" : ""); xfree(blob); xfree(cuser); xfree(chost); } debug3("%s: key %p is %s", __func__, key, allowed ? "allowed" : "disallowed"); buffer_clear(m); buffer_put_int(m, allowed); buffer_put_int(m, forced_command != NULL); mm_append_debug(m); mm_request_send(sock, MONITOR_ANS_KEYALLOWED, m); if (type == MM_RSAHOSTKEY) monitor_permit(mon_dispatch, MONITOR_REQ_RSACHALLENGE, allowed); return (0); }
int main(int argc, char *argv[]) { struct ntpd_conf lconf; struct pollfd pfd[POLL_MAX]; pid_t chld_pid = 0, pid; const char *conffile; int fd_ctl, ch, nfds; int pipe_chld[2]; struct passwd *pw; extern char *__progname; __progname = _compat_get_progname(argv[0]); if (strcmp(__progname, "ntpctl") == 0) { ctl_main (argc, argv); /* NOTREACHED */ } conffile = CONFFILE; bzero(&lconf, sizeof(lconf)); log_init(1); /* log to stderr until daemonized */ while ((ch = getopt(argc, argv, "df:nsSv")) != -1) { switch (ch) { case 'd': lconf.debug = 1; break; case 'f': conffile = optarg; break; case 'n': lconf.noaction = 1; break; case 's': lconf.settime = 1; break; case 'S': lconf.settime = 0; break; case 'v': debugsyslog = 1; break; default: usage(); /* NOTREACHED */ } } argc -= optind; argv += optind; if (argc > 0) usage(); if (parse_config(conffile, &lconf)) exit(1); if (lconf.noaction) { fprintf(stderr, "configuration OK\n"); exit(0); } if (geteuid()) errx(1, "need root privileges"); if ((pw = getpwnam(NTPD_USER)) == NULL) errx(1, "unknown user %s", NTPD_USER); #ifndef HAVE_ARC4RANDOM seed_rng(); #endif if (setpriority(PRIO_PROCESS, 0, -20) == -1) warn("can't set priority"); reset_adjtime(); if (!lconf.settime) { log_init(lconf.debug); if (!lconf.debug) if (daemon(1, 0)) fatal("daemon"); } else timeout = SETTIME_TIMEOUT * 1000; if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_chld) == -1) fatal("socketpair"); if ((fd_ctl = control_init(CTLSOCKET)) == -1) fatalx("control socket init failed"); if (control_listen(fd_ctl) == -1) fatalx("control socket listen failed"); signal(SIGCHLD, sighdlr); /* fork child process */ chld_pid = ntp_main(pipe_chld, fd_ctl, &lconf, pw); setproctitle("[priv]"); readfreq(); signal(SIGTERM, sighdlr); signal(SIGINT, sighdlr); signal(SIGHUP, sighdlr); close(pipe_chld[1]); if ((ibuf = malloc(sizeof(struct imsgbuf))) == NULL) fatal(NULL); imsg_init(ibuf, pipe_chld[0]); while (quit == 0) { pfd[PFD_PIPE].fd = ibuf->fd; pfd[PFD_PIPE].events = POLLIN; if (ibuf->w.queued) pfd[PFD_PIPE].events |= POLLOUT; if ((nfds = poll(pfd, 1, timeout)) == -1) if (errno != EINTR) { log_warn("poll error"); quit = 1; } if (nfds == 0 && lconf.settime) { lconf.settime = 0; timeout = INFTIM; log_init(lconf.debug); log_debug("no reply received in time, skipping initial " "time setting"); if (!lconf.debug) if (daemon(1, 0)) fatal("daemon"); } if (nfds > 0 && (pfd[PFD_PIPE].revents & POLLOUT)) if (msgbuf_write(&ibuf->w) <= 0 && errno != EAGAIN) { log_warn("pipe write error (to child)"); quit = 1; } if (nfds > 0 && pfd[PFD_PIPE].revents & POLLIN) { nfds--; if (dispatch_imsg(&lconf) == -1) quit = 1; } if (sigchld) { if (check_child(chld_pid, "child")) { quit = 1; chld_pid = 0; } sigchld = 0; } } signal(SIGCHLD, SIG_DFL); if (chld_pid) kill(chld_pid, SIGTERM); do { if ((pid = wait(NULL)) == -1 && errno != EINTR && errno != ECHILD) fatal("wait"); } while (pid != -1 || (pid == -1 && errno == EINTR)); msgbuf_clear(&ibuf->w); free(ibuf); log_info("Terminating"); return (0); }