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;
}
