int init_socket() { struct sockaddr_un address; int socket_fd ; socket_fd = socket(PF_UNIX, SOCK_STREAM, 0); if(socket_fd < 0) { psyslog("socket() failed\n"); perror("Err:"); return 0; } /* start with a clean address structure */ memset(&address, 0, sizeof(struct sockaddr_un)); address.sun_family = AF_UNIX; sprintf(address.sun_path, MINERGATE_SOCKET_FILE); if(connect(socket_fd, (struct sockaddr *) &address, sizeof(struct sockaddr_un)) != 0) { psyslog("connect() failed\n"); perror("Err:"); return 0; } return socket_fd; }
void print_stack() { int j, nptrs; void *buffer[SIZE]; char **strings; psyslog("ERROR, ABORT, DYE!\n"); psyslog("MINERGATE ERROR: "); nptrs = backtrace(buffer, SIZE); strings = backtrace_symbols(buffer, nptrs); for (j = 0; j < nptrs; j++) { psyslog(" %s\n", strings[j]); } }
void end_stopper(struct timeval *tv, const char *name) { int usec; struct timeval end; gettimeofday(&end, NULL); usec = (end.tv_sec - tv->tv_sec) * 1000000; usec += (end.tv_usec - tv->tv_usec); psyslog("%s took %d\n", name, usec); }
void mg_event(const char *s) { FILE *f = fopen("/tmp/mg_event", "w"); if (!f) { psyslog("Failed to create watchdog file\n"); return; } fprintf(f, "%s\n", s); fclose(f); }
static int krb4_auth(pam_handle_t *pamh, int flags, const char *name, const char *inst, struct pam_conv *conv) { struct pam_response *resp; char prompt[128]; struct pam_message msg, *pmsg = &msg; int ret; if (ctrl_on(KRB4_TRY_FIRST_PASS) || ctrl_on(KRB4_USE_FIRST_PASS)) { char *pass = 0; ret = pam_get_item(pamh, PAM_AUTHTOK, (void **) &pass); if (ret != PAM_SUCCESS) { psyslog(LOG_ERR , "pam_get_item returned error to get-password"); return ret; } else if (pass != 0 && verify_pass(pamh, name, inst, pass) == PAM_SUCCESS) return PAM_SUCCESS; else if (ctrl_on(KRB4_USE_FIRST_PASS)) return PAM_AUTHTOK_RECOVERY_ERR; /* Wrong password! */ else /* We tried the first password but it didn't work, cont. */; } msg.msg_style = PAM_PROMPT_ECHO_OFF; if (*inst == 0) snprintf(prompt, sizeof(prompt), "%s's Password: "******"%s.%s's Password: ", name, inst); msg.msg = prompt; ret = conv->conv(1, &pmsg, &resp, conv->appdata_ptr); if (ret != PAM_SUCCESS) return ret; ret = verify_pass(pamh, name, inst, resp->resp); if (ret == PAM_SUCCESS) { memset(resp->resp, 0, strlen(resp->resp)); /* Erase password! */ free(resp->resp); free(resp); } else { pam_set_item(pamh, PAM_AUTHTOK, resp->resp); /* Save password. */ /* free(resp->resp); XXX */ /* free(resp); XXX */ } return ret; }
void kill_fan() { FILE *f; int val = 0; f = fopen("/sys/devices/ocp.3/pwm_test_P9_31.12/duty", "w"); if (f <= 0) { psyslog(RED "Fan PWM not found\n" RESET); } else { fprintf(f, "%d", val); fclose(f); } }
void _pabort(const char *s) { if (s) { //perror(orig_buf); psyslog("%s :STACK:", s); } print_stack(); #ifdef MINERGATE exit_nicely(0, "apAbort"); #else exit(0); #endif }
void set_fan_level(int fan_level) { FILE *f; if (vm.fan_level != fan_level) { passert(fan_level <= 100 && fan_level >=0); int val = PWM_VALUE(fan_level); f = fopen("/sys/devices/ocp.3/pwm_test_P9_31.12/duty", "w"); if (f <= 0) { psyslog(RED "Fan PWM not found\n" RESET); } else { fprintf(f, "%d", val); fclose(f); vm.fan_level = fan_level; } } }
static void parse_ctrl(int argc, const char **argv) { int i, j; ctrl_flags = KRB4_DEFAULTS; for (i = 0; i < argc; i++) { for (j = 0; j < KRB4_CTRLS; j++) if (strcmp(argv[i], krb4_args[j].token) == 0) break; if (j >= KRB4_CTRLS) psyslog(LOG_ALERT, "unrecognized option [%s]", *argv); else ctrl_flags |= krb4_args[j].flag; } }
int is_sp30() { int rc = 0; int r; char model [16]; FILE* file = fopen("/model_name", "r"); if (file < 0) { psyslog("file /model_name missing is it an SP miner at all??"); passert(0); } else{ r = fscanf (file, "%s",model); if (r > 0){ rc = (strcmp("SP30",model) == 0); } } fclose (file); return rc; }
static int verify_pass(pam_handle_t *pamh, const char *name, const char *inst, const char *pass) { char realm[REALM_SZ]; int ret, krb_verify, old_euid, old_ruid; krb_get_lrealm(realm, 1); if (ctrl_on(KRB4_NO_VERIFY)) krb_verify = KRB_VERIFY_SECURE_FAIL; else krb_verify = KRB_VERIFY_SECURE; old_ruid = getuid(); old_euid = geteuid(); setreuid(0, 0); ret = krb_verify_user(name, inst, realm, pass, krb_verify, NULL); pdeb("krb_verify_user(`%s', `%s', `%s', pw, %d, NULL) returns %s", name, inst, realm, krb_verify, krb_get_err_text(ret)); setreuid(old_ruid, old_euid); if (getuid() != old_ruid || geteuid() != old_euid) { psyslog(LOG_ALERT , "setreuid(%d, %d) failed at line %d", old_ruid, old_euid, __LINE__); exit(1); } switch(ret) { case KSUCCESS: return PAM_SUCCESS; case KDC_PR_UNKNOWN: return PAM_USER_UNKNOWN; case SKDC_CANT: case SKDC_RETRY: case RD_AP_TIME: return PAM_AUTHINFO_UNAVAIL; default: return PAM_AUTH_ERR; } }
int pam_sm_setcred(pam_handle_t *pamh, int flags, int argc, const char **argv) { parse_ctrl(argc, argv); ENTRY("pam_sm_setcred"); switch (flags & ~PAM_SILENT) { case 0: case PAM_ESTABLISH_CRED: if (k_hasafs()) k_setpag(); /* Fall through, fill PAG with credentials below. */ case PAM_REINITIALIZE_CRED: case PAM_REFRESH_CRED: if (k_hasafs()) { void *user = 0; if (pam_get_item(pamh, PAM_USER, &user) == PAM_SUCCESS) { struct passwd *pw = getpwnam((char *)user); if (pw != 0) krb_afslog_uid_home(/*cell*/ 0,/*realm_hint*/ 0, pw->pw_uid, pw->pw_dir); } } break; case PAM_DELETE_CRED: dest_tkt(); if (k_hasafs()) k_unlog(); break; default: psyslog(LOG_ALERT , "pam_sm_setcred: unknown flags 0x%x", flags); break; } return PAM_SUCCESS; }
int pam_sm_authenticate(pam_handle_t *pamh, int flags, int argc, const char **argv) { char *user; int ret; struct pam_conv *conv; struct passwd *pw; uid_t uid = -1; const char *name, *inst; char realm[REALM_SZ]; realm[0] = 0; parse_ctrl(argc, argv); ENTRY("pam_sm_authenticate"); ret = pam_get_user(pamh, &user, "login: "******"root") == 0) return PAM_AUTHINFO_UNAVAIL; ret = pam_get_item(pamh, PAM_CONV, (void*)&conv); if (ret != PAM_SUCCESS) return ret; pw = getpwnam(user); if (pw != 0) { uid = pw->pw_uid; set_tkt_string(uid); } if (strcmp(user, "root") == 0 && getuid() != 0) { pw = getpwuid(getuid()); if (pw != 0) { name = strdup(pw->pw_name); inst = "root"; } } else { name = user; inst = ""; } ret = krb4_auth(pamh, flags, name, inst, conv); /* * The realm was lost inside krb_verify_user() so we can't simply do * a krb_kuserok() when inst != "". */ if (ret == PAM_SUCCESS && inst[0] != 0) { uid_t old_euid = geteuid(); uid_t old_ruid = getuid(); setreuid(0, 0); /* To read ticket file. */ if (krb_get_tf_fullname(tkt_string(), 0, 0, realm) != KSUCCESS) ret = PAM_SERVICE_ERR; else if (krb_kuserok(name, inst, realm, user) != KSUCCESS) { setreuid(0, uid); /* To read ~/.klogin. */ if (krb_kuserok(name, inst, realm, user) != KSUCCESS) ret = PAM_PERM_DENIED; } if (ret != PAM_SUCCESS) { dest_tkt(); /* Passwd known, ok to kill ticket. */ psyslog(LOG_NOTICE, "%s.%s@%s is not allowed to log in as %s", name, inst, realm, user); } setreuid(old_ruid, old_euid); if (getuid() != old_ruid || geteuid() != old_euid) { psyslog(LOG_ALERT , "setreuid(%d, %d) failed at line %d", old_ruid, old_euid, __LINE__); exit(1); } } if (ret == PAM_SUCCESS) { psyslog(LOG_INFO, "%s.%s@%s authenticated as user %s", name, inst, realm, user); if (chown(tkt_string(), uid, -1) == -1) { dest_tkt(); psyslog(LOG_ALERT , "chown(%s, %d, -1) failed", tkt_string(), uid); exit(1); } } /* * Kludge alert!!! Sun dtlogin unlock screen fails to call * pam_setcred(3) with PAM_REFRESH_CRED after a successful * authentication attempt, sic. * * This hack is designed as a workaround to that problem. */ if (ctrl_on(KRB4_REAFSLOG)) if (ret == PAM_SUCCESS) pam_sm_setcred(pamh, PAM_REFRESH_CRED, argc, argv); return ret; }
void *read_sock(void *p) { if(p==NULL) return NULL; char szBuf[MAX_SIZE*5] = {0}; SOCKDATA *pdata = (SOCKDATA*)p; int nbytes; if((nbytes=recv(pdata->sock_fd, szBuf, MAX_SIZE, 0))==-1 || nbytes==0){ psyslog(LOG_NOTICE, "From client %d recv data is %s\n", pdata->sock_fd, nbytes?"not empty":"empty"); free(pdata); return NULL; } uint8_t *podata = (uint8_t*)malloc(nbytes-1); if(reverse_crc_data(szBuf, nbytes, (void*)podata)!=0){ psyslog(LOG_ERR, "The data from client crc error"); free(pdata); free(podata); return NULL; } //use JSON cJSON *root = cJSON_Parse((char*)podata); if (root == NULL){ psyslog(LOG_ERR, cJSON_GetErrorPtr()); free(pdata); free(podata); return NULL; } int needResponse = cJSON_GetObjectItem(root, "needResponse")->valueint; char *message = cJSON_GetObjectItem(root, "message")->valuestring; int msgLen = cJSON_GetObjectItem(root, "len")->valueint; bzero(szBuf, MAX_SIZE*5); strncpy(szBuf, message, msgLen); szBuf[msgLen] = '\n'; pthread_rwlock_wrlock(&rwlock); write(pdata->write_fd, szBuf, msgLen+1); if(needResponse) { //need respons bzero(szBuf, MAX_SIZE*5); //nbytes=read(pdata->read_fd, szBuf, MAX_SIZE*5); sleep(0.1); strcpy(szBuf, "Hello WoW!"); nbytes = strlen(szBuf); pdata->msg = szBuf; pdata->size = nbytes; write_sock(pdata); } pthread_rwlock_unlock(&rwlock); free(pdata); free(podata); cJSON_Delete(root); return NULL; }
int get_fet(int board_id ){ int err=0; int fet_type = 100; int fetflag = 0; int vpdrev ; pthread_mutex_lock(&i2c_mutex); err = setI2CSwitches(board_id); if (err){ fet_type = FET_ERROR_BOARD_NA; goto get_out; } vpdrev = (unsigned char)i2c_read_byte(MAIN_BOARD_I2C_EEPROM_DEV_ADDR, 0 , &err); if (err){ fet_type = FET_EEPROM_DEV_ERROR; goto get_out; } if (vpdrev == 0xFF) { fet_type = FET_ERROR_BLANK_VPD; if (is_sp30()){ psyslog("this is an SP30, with no VPD in main board.\nWe ASSUME it's an old ELA-2013 board, hence FET=0\n"); fet_type = 0; } goto get_out; } else if (vpdrev < FET_SUPPORT_VPD_REV){ fet_type = FET_ERROR_VPD_FET_NOT_SUPPORT; goto get_out; } fetflag = (unsigned char)i2c_read_byte(MAIN_BOARD_I2C_EEPROM_DEV_ADDR, MAIN_BOARD_VPD_FET_FLAG_ADDR_START , &err); if (err || fetflag != 1) { fet_type = FET_ERROR_VPD_FET_NOT_SET; goto get_out; } fet_type = (unsigned char)i2c_read_byte(MAIN_BOARD_I2C_EEPROM_DEV_ADDR, MAIN_BOARD_VPD_FET_CODE_ADDR_START, &err); if (err) { fet_type = FET_ERROR_VPD_READ_ERROR; goto get_out; } get_out: resetI2CSwitches(); pthread_mutex_unlock(&i2c_mutex); if (fet_type == FET_ERROR_VPD_FET_NOT_SET || fet_type == FET_ERROR_VPD_FET_NOT_SUPPORT ) { // read ela and stuff mainboard_vpd_info_t vpd = {}; // allocte, and initializero if (mainboard_get_vpd(board_id , &vpd) != 0) fet_type = FET_ERROR_VPD_READ_ERROR; else fet_type = get_fet_from_ela(&vpd); } return fet_type; }