static bool opencl_thread_prepare(struct thr_info *thr) { char name[256]; struct timeval now; struct cgpu_info *cgpu = thr->cgpu; int gpu = cgpu->device_id; int virtual_gpu = cgpu->virtual_gpu; int i = thr->id; static bool failmessage = false; int buffersize = BUFFERSIZE; if (!blank_res) blank_res = (uint32_t *)calloc(buffersize, 1); if (!blank_res) { applog(LOG_ERR, "Failed to calloc in opencl_thread_init"); return false; } strcpy(name, ""); applog(LOG_INFO, "Init GPU thread %i GPU %i virtual GPU %i", i, gpu, virtual_gpu); clStates[i] = initCl(virtual_gpu, name, sizeof(name), &cgpu->algorithm); if (!clStates[i]) { #ifdef HAVE_CURSES if (use_curses) enable_curses(); #endif applog(LOG_ERR, "Failed to init GPU thread %d, disabling device %d", i, gpu); if (!failmessage) { applog(LOG_ERR, "Restarting the GPU from the menu will not fix this."); applog(LOG_ERR, "Re-check your configuration and try restarting."); failmessage = true; #ifdef HAVE_CURSES char *buf; if (use_curses) { buf = curses_input("Press enter to continue"); if (buf) free(buf); } #endif } cgpu->deven = DEV_DISABLED; cgpu->status = LIFE_NOSTART; dev_error(cgpu, REASON_DEV_NOSTART); return false; } if (!cgpu->name) cgpu->name = strdup(name); if (!cgpu->kernelname) cgpu->kernelname = strdup("ckolivas"); applog(LOG_INFO, "initCl() finished. Found %s", name); cgtime(&now); get_datestamp(cgpu->init, sizeof(cgpu->init), &now); have_opencl = true; return true; }
static void curses_arp_poisoning(void) { DEBUG_MSG("curses_arp_poisoning"); sprintf(params, "arp:"); curses_input("Parameters :", params + strlen("arp:"), PARAMS_LEN - strlen("arp:"), curses_start_mitm); }
static void curses_port_stealing(void) { DEBUG_MSG("curses_port_stealing"); sprintf(params, "port:"); curses_input("Parameters :", params + strlen("port:"), PARAMS_LEN - strlen("port:"), curses_start_mitm); }
static void curses_dhcp_spoofing(void) { DEBUG_MSG("curses_dhcp_spoofing"); sprintf(params, "dhcp:"); curses_input("Parameters :", params + strlen("dhcp:"), PARAMS_LEN - strlen("dhcp:"), curses_start_mitm); }
static void curses_icmp_redir(void) { DEBUG_MSG("curses_icmp_redir"); sprintf(params, "icmp:"); curses_input("Parameters :", params + strlen("icmp:"), PARAMS_LEN - strlen("icmp:"), curses_start_mitm); }
static float curses_float(const char *query) { float ret; char *cvar; cvar = curses_input(query); ret = atof(cvar); free(cvar); return ret; }
/* * display the write file menu */ static void curses_file_write(void) { #define FILE_LEN 40 DEBUG_MSG("curses_file_write"); SAFE_CALLOC(GBL_OPTIONS->pcapfile_out, FILE_LEN, sizeof(char)); curses_input("Output file :", GBL_OPTIONS->pcapfile_out, FILE_LEN, write_pcapfile); }
/* * display the log dialog */ static void curses_log_info(void) { DEBUG_MSG("curses_log_info"); /* make sure to free if already set */ SAFE_FREE(logfile); SAFE_CALLOC(logfile, FILE_LEN, sizeof(char)); curses_input("Log File :", logfile, FILE_LEN, log_info); }
/* * display the pcap filter dialog */ static void curses_pcap_filter(void) { #define PCAP_FILTER_LEN 50 DEBUG_MSG("curses_pcap_filter"); SAFE_CALLOC(GBL_PCAP->filter, PCAP_FILTER_LEN, sizeof(char)); /* * no callback, the filter is set but we have to return to * the interface for other user input */ curses_input("Pcap filter :", GBL_PCAP->filter, PCAP_FILTER_LEN, NULL); }
void command_loop(int server_socket) { char* next_cmd = NULL; while (true) { next_cmd = curses_input(basic_input); if (next_cmd) { send_outgoing_command(next_cmd, server_socket); free(next_cmd); } } endwin(); printf("Error: %s\n", strerror(errno)); pthread_cancel(receive_thread); exit(EXIT_FAILURE); }
/* * display the interface selection dialog */ static void curses_unified_sniff(void) { char err[PCAP_ERRBUF_SIZE]; #define IFACE_LEN 50 DEBUG_MSG("curses_unified_sniff"); /* if the user has not specified an interface, get the first one */ if (GBL_OPTIONS->iface == NULL) { char *iface; SAFE_CALLOC(GBL_OPTIONS->iface, IFACE_LEN, sizeof(char)); iface = pcap_lookupdev(err); ON_ERROR(iface, NULL, "pcap_lookupdev: %s", err); strncpy(GBL_OPTIONS->iface, iface, IFACE_LEN - 1); } /* calling wdg_exit will go to the next interface :) */ curses_input("Network interface :", GBL_OPTIONS->iface, IFACE_LEN, wdg_exit); }
/* * set a different netmask than the system one */ static void curses_set_netmask(void) { struct in_addr net; DEBUG_MSG("curses_set_netmask"); if (GBL_OPTIONS->netmask == NULL) SAFE_CALLOC(GBL_OPTIONS->netmask, IP_ASCII_ADDR_LEN, sizeof(char)); /* * no callback, the filter is set but we have to return to * the interface for other user input */ curses_input("Netmask :", GBL_OPTIONS->netmask, IP_ASCII_ADDR_LEN, NULL); /* sanity check */ if (strcmp(GBL_OPTIONS->netmask, "") && inet_aton(GBL_OPTIONS->netmask, &net) == 0) ui_error("Invalid netmask %s", GBL_OPTIONS->netmask); /* if no netmask was specified, free it */ if (!strcmp(GBL_OPTIONS->netmask, "")) SAFE_FREE(GBL_OPTIONS->netmask); }
void manage_gpu(void) { struct thr_info *thr; int selected, gpu, i; char checkin[40]; char input; if (!opt_g_threads) return; opt_loginput = true; immedok(logwin, true); clear_logwin(); retry: for (gpu = 0; gpu < nDevs; gpu++) { struct cgpu_info *cgpu = &gpus[gpu]; double displayed_rolling, displayed_total; bool mhash_base = true; displayed_rolling = cgpu->rolling; displayed_total = cgpu->total_mhashes / total_secs; if (displayed_rolling < 1) { displayed_rolling *= 1000; displayed_total *= 1000; mhash_base = false; } wlog("GPU %d: %.1f / %.1f %sh/s | A:%d R:%d HW:%d U:%.2f/m I:%d\n", gpu, displayed_rolling, displayed_total, mhash_base ? "M" : "K", cgpu->accepted, cgpu->rejected, cgpu->hw_errors, cgpu->utility, cgpu->intensity); #ifdef HAVE_ADL if (gpus[gpu].has_adl) { int engineclock = 0, memclock = 0, activity = 0, fanspeed = 0, fanpercent = 0, powertune = 0; float temp = 0, vddc = 0; if (gpu_stats(gpu, &temp, &engineclock, &memclock, &vddc, &activity, &fanspeed, &fanpercent, &powertune)) { char logline[255]; strcpy(logline, ""); // In case it has no data if (temp != -1) sprintf(logline, "%.1f C ", temp); if (fanspeed != -1 || fanpercent != -1) { tailsprintf(logline, "F: "); if (fanpercent != -1) tailsprintf(logline, "%d%% ", fanpercent); if (fanspeed != -1) tailsprintf(logline, "(%d RPM) ", fanspeed); tailsprintf(logline, " "); } if (engineclock != -1) tailsprintf(logline, "E: %d MHz ", engineclock); if (memclock != -1) tailsprintf(logline, "M: %d Mhz ", memclock); if (vddc != -1) tailsprintf(logline, "V: %.3fV ", vddc); if (activity != -1) tailsprintf(logline, "A: %d%% ", activity); if (powertune != -1) tailsprintf(logline, "P: %d%%", powertune); tailsprintf(logline, "\n"); wlog(logline); } } #endif wlog("Last initialised: %s\n", cgpu->init); wlog("Intensity: "); if (gpus[gpu].dynamic) wlog("Dynamic (only one thread in use)\n"); else wlog("%d\n", gpus[gpu].intensity); for (i = 0; i < mining_threads; i++) { thr = &thr_info[i]; if (thr->cgpu != cgpu) continue; get_datestamp(checkin, &thr->last); displayed_rolling = thr->rolling; if (!mhash_base) displayed_rolling *= 1000; wlog("Thread %d: %.1f %sh/s %s ", i, displayed_rolling, mhash_base ? "M" : "K" , cgpu->deven != DEV_DISABLED ? "Enabled" : "Disabled"); switch (cgpu->status) { default: case LIFE_WELL: wlog("ALIVE"); break; case LIFE_SICK: wlog("SICK reported in %s", checkin); break; case LIFE_DEAD: wlog("DEAD reported in %s", checkin); break; case LIFE_INIT: case LIFE_NOSTART: wlog("Never started"); break; } if (thr->pause) wlog(" paused"); wlog("\n"); } wlog("\n"); } wlogprint("[E]nable [D]isable [I]ntensity [R]estart GPU %s\n",adl_active ? "[C]hange settings" : ""); wlogprint("Or press any other key to continue\n"); input = getch(); if (nDevs == 1) selected = 0; else selected = -1; if (!strncasecmp(&input, "e", 1)) { struct cgpu_info *cgpu; if (selected) selected = curses_int("Select GPU to enable"); if (selected < 0 || selected >= nDevs) { wlogprint("Invalid selection\n"); goto retry; } if (gpus[selected].deven != DEV_DISABLED) { wlogprint("Device already enabled\n"); goto retry; } gpus[selected].deven = DEV_ENABLED; for (i = 0; i < mining_threads; ++i) { thr = &thr_info[i]; cgpu = thr->cgpu; if (cgpu->api != &opencl_api) continue; if (dev_from_id(i) != selected) continue; if (cgpu->status != LIFE_WELL) { wlogprint("Must restart device before enabling it"); goto retry; } applog(LOG_DEBUG, "Pushing ping to thread %d", thr->id); tq_push(thr->q, &ping); } goto retry; } if (!strncasecmp(&input, "d", 1)) { if (selected) selected = curses_int("Select GPU to disable"); if (selected < 0 || selected >= nDevs) { wlogprint("Invalid selection\n"); goto retry; } if (gpus[selected].deven == DEV_DISABLED) { wlogprint("Device already disabled\n"); goto retry; } gpus[selected].deven = DEV_DISABLED; goto retry; } else if (!strncasecmp(&input, "i", 1)) { int intensity; char *intvar; if (selected) selected = curses_int("Select GPU to change intensity on"); if (selected < 0 || selected >= nDevs) { wlogprint("Invalid selection\n"); goto retry; } intvar = curses_input("Set GPU scan intensity (d or " _MIN_INTENSITY_STR " -> " _MAX_INTENSITY_STR ")"); if (!intvar) { wlogprint("Invalid input\n"); goto retry; } if (!strncasecmp(intvar, "d", 1)) { wlogprint("Dynamic mode enabled on gpu %d\n", selected); gpus[selected].dynamic = true; pause_dynamic_threads(selected); free(intvar); goto retry; } intensity = atoi(intvar); free(intvar); if (intensity < MIN_INTENSITY || intensity > MAX_INTENSITY) { wlogprint("Invalid selection\n"); goto retry; } gpus[selected].dynamic = false; gpus[selected].intensity = intensity; wlogprint("Intensity on gpu %d set to %d\n", selected, intensity); pause_dynamic_threads(selected); goto retry; } else if (!strncasecmp(&input, "r", 1)) { if (selected) selected = curses_int("Select GPU to attempt to restart"); if (selected < 0 || selected >= nDevs) { wlogprint("Invalid selection\n"); goto retry; } wlogprint("Attempting to restart threads of GPU %d\n", selected); reinit_device(&gpus[selected]); goto retry; } else if (adl_active && (!strncasecmp(&input, "c", 1))) { if (selected) selected = curses_int("Select GPU to change settings on"); if (selected < 0 || selected >= nDevs) { wlogprint("Invalid selection\n"); goto retry; } change_gpusettings(selected); goto retry; } else clear_logwin(); immedok(logwin, false); opt_loginput = false; }
static bool opencl_thread_prepare(struct thr_info *thr) { char name[256]; struct timeval now; struct cgpu_info *cgpu = thr->cgpu; int gpu = cgpu->device_id; int virtual_gpu = cgpu->virtual_gpu; int i = thr->id; static bool failmessage = false; if (!blank_res) blank_res = calloc(BUFFERSIZE, 1); if (!blank_res) { applog(LOG_ERR, "Failed to calloc in opencl_thread_init"); return false; } strcpy(name, ""); applog(LOG_INFO, "Init GPU thread %i GPU %i virtual GPU %i", i, gpu, virtual_gpu); clStates[i] = initCl(virtual_gpu, name, sizeof(name)); if (!clStates[i]) { #ifdef HAVE_CURSES if (use_curses) enable_curses(); #endif applog(LOG_ERR, "Failed to init GPU thread %d, disabling device %d", i, gpu); if (!failmessage) { applog(LOG_ERR, "Restarting the GPU from the menu will not fix this."); applog(LOG_ERR, "Try restarting cgminer."); failmessage = true; #ifdef HAVE_CURSES char *buf; if (use_curses) { buf = curses_input("Press enter to continue"); if (buf) free(buf); } #endif } cgpu->deven = DEV_DISABLED; cgpu->status = LIFE_NOSTART; dev_error(cgpu, REASON_DEV_NOSTART); return false; } if (!cgpu->name) cgpu->name = strdup(name); if (!cgpu->kname) { switch (clStates[i]->chosen_kernel) { case KL_DIABLO: cgpu->kname = "diablo"; break; case KL_DIAKGCN: cgpu->kname = "diakgcn"; break; case KL_PHATK: cgpu->kname = "phatk"; break; #ifdef USE_SCRYPT case KL_SCRYPT: cgpu->kname = "scrypt"; break; #endif case KL_POCLBM: cgpu->kname = "poclbm"; break; default: break; } } applog(LOG_INFO, "initCl() finished. Found %s", name); gettimeofday(&now, NULL); get_datestamp(cgpu->init, &now); have_opencl = true; return true; }
static bool opencl_thread_prepare(struct thr_info *thr) { char name[256]; struct timeval now; struct cgpu_info *cgpu = thr->cgpu; int gpu = cgpu->device_id; int virtual_gpu = cgpu->virtual_gpu; int i = thr->id; static bool failmessage = false; int buffersize = BUFFERSIZE; if (!blank_res) blank_res = calloc(buffersize, 1); if (!blank_res) { applog(LOG_ERR, "Failed to calloc in opencl_thread_init"); return false; } strcpy(name, ""); applog(LOG_INFO, "Init GPU thread %i GPU %i virtual GPU %i", i, gpu, virtual_gpu); clStates[i] = initCl(virtual_gpu, name, sizeof(name)); if (!clStates[i]) { #ifdef HAVE_CURSES if (use_curses) enable_curses(); #endif applog(LOG_ERR, "Failed to init GPU thread %d, disabling device %d", i, gpu); if (!failmessage) { applog(LOG_ERR, "Restarting the GPU from the menu will not fix this."); applog(LOG_ERR, "Try restarting sgminer."); failmessage = true; #ifdef HAVE_CURSES char *buf; if (use_curses) { buf = curses_input("Press enter to continue"); if (buf) free(buf); } #endif } cgpu->deven = DEV_DISABLED; cgpu->status = LIFE_NOSTART; dev_error(cgpu, REASON_DEV_NOSTART); return false; } if (!cgpu->name) cgpu->name = strdup(name); if (!cgpu->kname) { switch (clStates[i]->chosen_kernel) { case KL_ALEXKARNEW: cgpu->kname = ALEXKARNEW_KERNNAME; break; case KL_ALEXKAROLD: cgpu->kname = ALEXKAROLD_KERNNAME; break; case KL_CKOLIVAS: cgpu->kname = CKOLIVAS_KERNNAME; break; case KL_ZUIKKIS: cgpu->kname = ZUIKKIS_KERNNAME; break; case KL_PSW: cgpu->kname = PSW_KERNNAME; break; case KL_DARKCOIN: cgpu->kname = DARKCOIN_KERNNAME; break; case KL_QUBITCOIN: cgpu->kname = QUBITCOIN_KERNNAME; break; case KL_QUARKCOIN: cgpu->kname = QUARKCOIN_KERNNAME; break; default: break; } } applog(LOG_INFO, "initCl() finished. Found %s", name); cgtime(&now); get_datestamp(cgpu->init, sizeof(cgpu->init), &now); return true; }
/* * change the WEP key for wifi */ static void curses_wep_key(void) { DEBUG_MSG("curses_wep_key"); curses_input("WEP key :", wkey, WLEN, curses_set_wepkey); }
/* * change the visualization regex */ static void curses_vis_regex(void) { DEBUG_MSG("curses_vis_regex"); curses_input("Visualization regex :", vregex, RLEN, curses_set_regex); }
/* * change the visualization method */ static void curses_vis_method(void) { DEBUG_MSG("curses_vis_method"); curses_input("Visualization method :", vmethod, VLEN, curses_set_method); }
/* * change the WiFi key for wifi */ static void curses_wifi_key(void) { DEBUG_MSG("curses_wifi_key"); curses_input("WiFi key :", wkey, WLEN, curses_set_wifikey); }