GOSTSec
/
sgminer
mirror of https://github.com/GOSTSec/sgminer
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

cgminer - size check all sprintf

nfactor-troky
Kano 12 years ago
parent
ad1572f77f
commit
74d71cce2c
1 changed files with 63 additions and 47 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 110
      cgminer.c

110
cgminer.c
Unescape View File

@ -1311,7 +1311,7 @@ static char *parse_config(json_t *config, bool fileconf)
applog(LOG_ERR, "Invalid config option %s: %s", p, err); applog(LOG_ERR, "Invalid config option %s: %s", p, err);
fileconf_load = -1; fileconf_load = -1;
} else { } else {
sprintf(err_buf, "Parsing JSON option %s: %s", snprintf(err_buf, sizeof(err_buf), "Parsing JSON option %s: %s",
p, err); p, err);
return err_buf; return err_buf;
} }
@ -1334,6 +1334,7 @@ static char *load_config(const char *arg, void __maybe_unused *unused)
json_error_t err; json_error_t err;
json_t *config; json_t *config;
char *json_error; char *json_error;
size_t siz;
if (!cnfbuf) if (!cnfbuf)
cnfbuf = strdup(arg); cnfbuf = strdup(arg);
@ -1347,11 +1348,12 @@ static char *load_config(const char *arg, void __maybe_unused *unused)
config = json_load_file(arg, &err); config = json_load_file(arg, &err);
#endif #endif
if (!json_is_object(config)) { if (!json_is_object(config)) {
json_error = malloc(JSON_LOAD_ERROR_LEN + strlen(arg) + strlen(err.text)); siz = JSON_LOAD_ERROR_LEN + strlen(arg) + strlen(err.text);
json_error = malloc(siz);
if (!json_error) if (!json_error)
quit(1, "Malloc failure in json error"); quit(1, "Malloc failure in json error");
sprintf(json_error, JSON_LOAD_ERROR, arg, err.text); snprintf(json_error, siz, JSON_LOAD_ERROR, arg, err.text);
return json_error; return json_error;
} }
@ -1946,7 +1948,7 @@ static bool curses_active_locked(void)
/* Convert a uint64_t value into a truncated string for displaying with its /* Convert a uint64_t value into a truncated string for displaying with its
* associated suitable for Mega, Giga etc. Buf array needs to be long enough */ * associated suitable for Mega, Giga etc. Buf array needs to be long enough */
static void suffix_string(uint64_t val, char *buf, int sigdigits) static void suffix_string(uint64_t val, char *buf, size_t bufsiz, int sigdigits)
{ {
const double dkilo = 1000.0; const double dkilo = 1000.0;
const uint64_t kilo = 1000ull; const uint64_t kilo = 1000ull;
@ -1962,26 +1964,26 @@ static void suffix_string(uint64_t val, char *buf, int sigdigits)
if (val >= exa) { if (val >= exa) {
val /= peta; val /= peta;
dval = (double)val / dkilo; dval = (double)val / dkilo;
sprintf(suffix, "E"); strcpy(suffix, "E");
} else if (val >= peta) { } else if (val >= peta) {
val /= tera; val /= tera;
dval = (double)val / dkilo; dval = (double)val / dkilo;
sprintf(suffix, "P"); strcpy(suffix, "P");
} else if (val >= tera) { } else if (val >= tera) {
val /= giga; val /= giga;
dval = (double)val / dkilo; dval = (double)val / dkilo;
sprintf(suffix, "T"); strcpy(suffix, "T");
} else if (val >= giga) { } else if (val >= giga) {
val /= mega; val /= mega;
dval = (double)val / dkilo; dval = (double)val / dkilo;
sprintf(suffix, "G"); strcpy(suffix, "G");
} else if (val >= mega) { } else if (val >= mega) {
val /= kilo; val /= kilo;
dval = (double)val / dkilo; dval = (double)val / dkilo;
sprintf(suffix, "M"); strcpy(suffix, "M");
} else if (val >= kilo) { } else if (val >= kilo) {
dval = (double)val / dkilo; dval = (double)val / dkilo;
sprintf(suffix, "K"); strcpy(suffix, "K");
} else { } else {
dval = val; dval = val;
decimal = false; decimal = false;
@ -1989,15 +1991,15 @@ static void suffix_string(uint64_t val, char *buf, int sigdigits)
if (!sigdigits) { if (!sigdigits) {
if (decimal) if (decimal)
sprintf(buf, "%.3g%s", dval, suffix); snprintf(buf, bufsiz, "%.3g%s", dval, suffix);
else else
sprintf(buf, "%d%s", (unsigned int)dval, suffix); snprintf(buf, bufsiz, "%d%s", (unsigned int)dval, suffix);
} else { } else {
/* Always show sigdigits + 1, padded on right with zeroes /* Always show sigdigits + 1, padded on right with zeroes
* followed by suffix */ * followed by suffix */
int ndigits = sigdigits - 1 - (dval > 0.0 ? floor(log10(dval)) : 0); int ndigits = sigdigits - 1 - (dval > 0.0 ? floor(log10(dval)) : 0);
sprintf(buf, "%*.*f%s", sigdigits + 1, ndigits, dval, suffix); snprintf(buf, bufsiz, "%*.*f%s", sigdigits + 1, ndigits, dval, suffix);
} }
} }
@ -2022,10 +2024,10 @@ static void get_statline(char *buf, size_t bufsiz, struct cgpu_info *cgpu)
dh64 = (double)cgpu->total_mhashes / dev_runtime * 1000000ull; dh64 = (double)cgpu->total_mhashes / dev_runtime * 1000000ull;
dr64 = (double)cgpu->rolling * 1000000ull; dr64 = (double)cgpu->rolling * 1000000ull;
suffix_string(dh64, displayed_hashes, 4); suffix_string(dh64, displayed_hashes, sizeof(displayed_hashes), 4);
suffix_string(dr64, displayed_rolling, 4); suffix_string(dr64, displayed_rolling, sizeof(displayed_rolling), 4);
sprintf(buf, "%s%d ", cgpu->drv->name, cgpu->device_id); snprintf(buf, bufsiz, "%s%d ", cgpu->drv->name, cgpu->device_id);
cgpu->drv->get_statline_before(buf, bufsiz, cgpu); cgpu->drv->get_statline_before(buf, bufsiz, cgpu);
tailsprintf(buf, bufsiz, "(%ds):%s (avg):%sh/s | A:%.0f R:%.0f HW:%d WU:%.1f/m", tailsprintf(buf, bufsiz, "(%ds):%s (avg):%sh/s | A:%.0f R:%.0f HW:%d WU:%.1f/m",
opt_log_interval, opt_log_interval,
@ -2139,8 +2141,8 @@ static void curses_print_devstatus(struct cgpu_info *cgpu, int count)
dh64 = (double)cgpu->total_mhashes / dev_runtime * 1000000ull; dh64 = (double)cgpu->total_mhashes / dev_runtime * 1000000ull;
dr64 = (double)cgpu->rolling * 1000000ull; dr64 = (double)cgpu->rolling * 1000000ull;
suffix_string(dh64, displayed_hashes, 4); suffix_string(dh64, displayed_hashes, sizeof(displayed_hashes), 4);
suffix_string(dr64, displayed_rolling, 4); suffix_string(dr64, displayed_rolling, sizeof(displayed_rolling), 4);
#ifdef USE_USBUTILS #ifdef USE_USBUTILS
if (cgpu->usbinfo.nodev) if (cgpu->usbinfo.nodev)
@ -2410,7 +2412,7 @@ share_result(json_t *val, json_t *res, json_t *err, const struct work *work,
strcpy(reason, ""); strcpy(reason, "");
if (total_pools > 1) if (total_pools > 1)
sprintf(where, "pool %d", work->pool->pool_no); snprintf(where, sizeof(where), "pool %d", work->pool->pool_no);
else else
strcpy(where, ""); strcpy(where, "");
@ -2565,9 +2567,10 @@ static bool submit_upstream_work(struct work *work, CURL *curl, bool resubmit)
outhash = bin2hex(rhash + 2, 4); outhash = bin2hex(rhash + 2, 4);
else else
outhash = bin2hex(rhash + 4, 4); outhash = bin2hex(rhash + 4, 4);
suffix_string(work->share_diff, diffdisp, 0); suffix_string(work->share_diff, diffdisp, sizeof(diffdisp), 0);
sprintf(hashshow, "%s Diff %s/%d%s", outhash, diffdisp, intdiff, snprintf(hashshow, sizeof(hashshow), "%s Diff %s/%d%s",
work->block? " BLOCK!" : ""); outhash, diffdisp, intdiff,
work->block? " BLOCK!" : "");
free(outhash); free(outhash);
if (opt_worktime) { if (opt_worktime) {
@ -2592,8 +2595,8 @@ static bool submit_upstream_work(struct work *work, CURL *curl, bool resubmit)
memcpy(&tm_submit_reply, tm, sizeof(struct tm)); memcpy(&tm_submit_reply, tm, sizeof(struct tm));
if (work->clone) { if (work->clone) {
sprintf(workclone, "C:%1.3f", snprintf(workclone, sizeof(workclone), "C:%1.3f",
tdiff((struct timeval *)&(work->tv_cloned), tdiff((struct timeval *)&(work->tv_cloned),
(struct timeval *)&(work->tv_getwork_reply))); (struct timeval *)&(work->tv_getwork_reply)));
} }
else else
@ -2602,7 +2605,8 @@ static bool submit_upstream_work(struct work *work, CURL *curl, bool resubmit)
if (work->work_difficulty < 1) if (work->work_difficulty < 1)
diffplaces = 6; diffplaces = 6;
sprintf(worktime, " <-%08lx.%08lx M:%c D:%1.*f G:%02d:%02d:%02d:%1.3f %s (%1.3f) W:%1.3f (%1.3f) S:%1.3f R:%02d:%02d:%02d", snprintf(worktime, sizeof(worktime),
" <-%08lx.%08lx M:%c D:%1.*f G:%02d:%02d:%02d:%1.3f %s (%1.3f) W:%1.3f (%1.3f) S:%1.3f R:%02d:%02d:%02d",
(unsigned long)swab32(*(uint32_t *)&(work->data[opt_scrypt ? 32 : 28])), (unsigned long)swab32(*(uint32_t *)&(work->data[opt_scrypt ? 32 : 28])),
(unsigned long)swab32(*(uint32_t *)&(work->data[opt_scrypt ? 28 : 24])), (unsigned long)swab32(*(uint32_t *)&(work->data[opt_scrypt ? 28 : 24])),
work->getwork_mode, diffplaces, work->work_difficulty, work->getwork_mode, diffplaces, work->work_difficulty,
@ -2752,7 +2756,7 @@ static void calc_diff(struct work *work, int known)
difficulty = work->work_difficulty; difficulty = work->work_difficulty;
pool_stats->last_diff = difficulty; pool_stats->last_diff = difficulty;
suffix_string((uint64_t)difficulty, work->pool->diff, 0); suffix_string((uint64_t)difficulty, work->pool->diff, sizeof(work->pool->diff), 0);
if (difficulty == pool_stats->min_diff) if (difficulty == pool_stats->min_diff)
pool_stats->min_diff_count++; pool_stats->min_diff_count++;
@ -3296,7 +3300,7 @@ static uint64_t share_diff(const struct work *work)
if (unlikely(ret > best_diff)) { if (unlikely(ret > best_diff)) {
new_best = true; new_best = true;
best_diff = ret; best_diff = ret;
suffix_string(best_diff, best_share, 0); suffix_string(best_diff, best_share, sizeof(best_share), 0);
} }
if (unlikely(ret > work->pool->best_diff)) if (unlikely(ret > work->pool->best_diff))
work->pool->best_diff = ret; work->pool->best_diff = ret;
@ -3674,7 +3678,7 @@ static void set_blockdiff(const struct work *work)
previous_diff = current_diff; previous_diff = current_diff;
diff64 = diffone / d64; diff64 = diffone / d64;
suffix_string(diff64, block_diff, 0); suffix_string(diff64, block_diff, sizeof(block_diff), 0);
current_diff = (double)diffone / (double)d64; current_diff = (double)diffone / (double)d64;
if (unlikely(current_diff != previous_diff)) if (unlikely(current_diff != previous_diff))
applog(LOG_NOTICE, "Network diff set to %s", block_diff); applog(LOG_NOTICE, "Network diff set to %s", block_diff);
@ -4144,7 +4148,7 @@ void zero_bestshare(void)
best_diff = 0; best_diff = 0;
memset(best_share, 0, 8); memset(best_share, 0, 8);
suffix_string(best_diff, best_share, 0); suffix_string(best_diff, best_share, sizeof(best_share), 0);
for (i = 0; i < total_pools; i++) { for (i = 0; i < total_pools; i++) {
struct pool *pool = pools[i]; struct pool *pool = pools[i];
@ -4521,7 +4525,7 @@ retry:
char *str, filename[PATH_MAX], prompt[PATH_MAX + 50]; char *str, filename[PATH_MAX], prompt[PATH_MAX + 50];
default_save_file(filename); default_save_file(filename);
sprintf(prompt, "Config filename to write (Enter for default) [%s]", filename); snprintf(prompt, sizeof(prompt), "Config filename to write (Enter for default) [%s]", filename);
str = curses_input(prompt); str = curses_input(prompt);
if (strcmp(str, "-1")) { if (strcmp(str, "-1")) {
struct stat statbuf; struct stat statbuf;
@ -4717,10 +4721,11 @@ static void hashmeter(int thr_id, struct timeval *diff,
dh64 = (double)total_mhashes_done / total_secs * 1000000ull; dh64 = (double)total_mhashes_done / total_secs * 1000000ull;
dr64 = (double)rolling * 1000000ull; dr64 = (double)rolling * 1000000ull;
suffix_string(dh64, displayed_hashes, 4); suffix_string(dh64, displayed_hashes, sizeof(displayed_hashes), 4);
suffix_string(dr64, displayed_rolling, 4); suffix_string(dr64, displayed_rolling, sizeof(displayed_rolling), 4);
sprintf(statusline, "%s(%ds):%s (avg):%sh/s | A:%.0f R:%.0f HW:%d WU:%.1f/m", snprintf(statusline, sizeof(statusline),
"%s(%ds):%s (avg):%sh/s | A:%.0f R:%.0f HW:%d WU:%.1f/m",
want_per_device_stats ? "ALL " : "", want_per_device_stats ? "ALL " : "",
opt_log_interval, displayed_rolling, displayed_hashes, opt_log_interval, displayed_rolling, displayed_hashes,
total_diff_accepted, total_diff_rejected, hw_errors, total_diff_accepted, total_diff_rejected, hw_errors,
@ -4743,15 +4748,16 @@ static void stratum_share_result(json_t *val, json_t *res_val, json_t *err_val,
struct stratum_share *sshare) struct stratum_share *sshare)
{ {
struct work *work = sshare->work; struct work *work = sshare->work;
char hashshow[65]; char hashshow[64];
uint32_t *hash32; uint32_t *hash32;
char diffdisp[16]; char diffdisp[16];
int intdiff; int intdiff;
hash32 = (uint32_t *)(work->hash); hash32 = (uint32_t *)(work->hash);
intdiff = floor(work->work_difficulty); intdiff = floor(work->work_difficulty);
suffix_string(work->share_diff, diffdisp, 0); suffix_string(work->share_diff, diffdisp, sizeof (diffdisp), 0);
sprintf(hashshow, "%08lx Diff %s/%d%s", (unsigned long)htole32(hash32[6]), diffdisp, intdiff, snprintf(hashshow, sizeof(hashshow),
"%08lx Diff %s/%d%s", (unsigned long)htole32(hash32[6]), diffdisp, intdiff,
work->block? " BLOCK!" : ""); work->block? " BLOCK!" : "");
share_result(val, res_val, err_val, work, hashshow, false, ""); share_result(val, res_val, err_val, work, hashshow, false, "");
} }
@ -5127,7 +5133,8 @@ static void *stratum_sthread(void *userdata)
sshare->id = swork_id++; sshare->id = swork_id++;
mutex_unlock(&sshare_lock); mutex_unlock(&sshare_lock);
sprintf(s, "{\"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\": %d, \"method\": \"mining.submit\"}", snprintf(s, sizeof(s),
"{\"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\": %d, \"method\": \"mining.submit\"}",
pool->rpc_user, work->job_id, work->nonce2, work->ntime, noncehex, sshare->id); pool->rpc_user, work->job_id, work->nonce2, work->ntime, noncehex, sshare->id);
free(noncehex); free(noncehex);
@ -5353,6 +5360,7 @@ retry_stratum:
if (pool->hdr_path) { if (pool->hdr_path) {
char *copy_start, *hdr_path; char *copy_start, *hdr_path;
bool need_slash = false; bool need_slash = false;
size_t siz;
hdr_path = pool->hdr_path; hdr_path = pool->hdr_path;
if (strstr(hdr_path, "://")) { if (strstr(hdr_path, "://")) {
@ -5364,13 +5372,14 @@ retry_stratum:
if (pool->rpc_url[strlen(pool->rpc_url) - 1] != '/') if (pool->rpc_url[strlen(pool->rpc_url) - 1] != '/')
need_slash = true; need_slash = true;
pool->lp_url = malloc(strlen(pool->rpc_url) + strlen(copy_start) + 2); siz = strlen(pool->rpc_url) + strlen(copy_start) + 2;
pool->lp_url = malloc(siz);
if (!pool->lp_url) { if (!pool->lp_url) {
applog(LOG_ERR, "Malloc failure in pool_active"); applog(LOG_ERR, "Malloc failure in pool_active");
return false; return false;
} }
sprintf(pool->lp_url, "%s%s%s", pool->rpc_url, need_slash ? "/" : "", copy_start); snprintf(pool->lp_url, siz, "%s%s%s", pool->rpc_url, need_slash ? "/" : "", copy_start);
} }
} else } else
pool->lp_url = NULL; pool->lp_url = NULL;
@ -5573,7 +5582,8 @@ static void gen_stratum_work(struct pool *pool, struct work *work)
header = calloc(pool->swork.header_len, 1); header = calloc(pool->swork.header_len, 1);
if (unlikely(!header)) if (unlikely(!header))
quit(1, "Failed to calloc header in gen_stratum_work"); quit(1, "Failed to calloc header in gen_stratum_work");
sprintf(header, "%s%s%s%s%s%s%s", snprintf(header, pool->swork.header_len,
"%s%s%s%s%s%s%s",
pool->swork.bbversion, pool->swork.bbversion,
pool->swork.prev_hash, pool->swork.prev_hash,
merkle_hash, merkle_hash,
@ -6298,7 +6308,8 @@ retry_pool:
* avoid races */ * avoid races */
if (pool->has_gbt) { if (pool->has_gbt) {
cg_rlock(&pool->gbt_lock); cg_rlock(&pool->gbt_lock);
sprintf(lpreq, "{\"id\": 0, \"method\": \"getblocktemplate\", \"params\": " snprintf(lpreq, sizeof(lpreq),
"{\"id\": 0, \"method\": \"getblocktemplate\", \"params\": "
"[{\"capabilities\": [\"coinbasetxn\", \"workid\", \"coinbase/append\"], " "[{\"capabilities\": [\"coinbasetxn\", \"workid\", \"coinbase/append\"], "
"\"longpollid\": \"%s\"}]}\n", pool->longpollid); "\"longpollid\": \"%s\"}]}\n", pool->longpollid);
cg_runlock(&pool->gbt_lock); cg_runlock(&pool->gbt_lock);
@ -6565,7 +6576,7 @@ static void *watchdog_thread(void __maybe_unused *userdata)
gpu = cgpu->device_id; gpu = cgpu->device_id;
denable = &cgpu->deven; denable = &cgpu->deven;
sprintf(dev_str, "%s%d", cgpu->drv->name, gpu); snprintf(dev_str, sizeof(dev_str), "%s%d", cgpu->drv->name, gpu);
#ifdef HAVE_ADL #ifdef HAVE_ADL
if (adl_active && cgpu->has_adl) if (adl_active && cgpu->has_adl)
@ -6811,15 +6822,18 @@ static void *test_pool_thread(void *arg)
* active it returns false. */ * active it returns false. */
bool add_pool_details(struct pool *pool, bool live, char *url, char *user, char *pass) bool add_pool_details(struct pool *pool, bool live, char *url, char *user, char *pass)
{ {
size_t siz;
url = get_proxy(url, pool); url = get_proxy(url, pool);
pool->rpc_url = url; pool->rpc_url = url;
pool->rpc_user = user; pool->rpc_user = user;
pool->rpc_pass = pass; pool->rpc_pass = pass;
pool->rpc_userpass = malloc(strlen(pool->rpc_user) + strlen(pool->rpc_pass) + 2); siz = strlen(pool->rpc_user) + strlen(pool->rpc_pass) + 2;
pool->rpc_userpass = malloc(siz);
if (!pool->rpc_userpass) if (!pool->rpc_userpass)
quit(1, "Failed to malloc userpass"); quit(1, "Failed to malloc userpass");
sprintf(pool->rpc_userpass, "%s:%s", pool->rpc_user, pool->rpc_pass); snprintf(pool->rpc_userpass, siz, "%s:%s", pool->rpc_user, pool->rpc_pass);
pool->testing = true; pool->testing = true;
pool->idle = true; pool->idle = true;
@ -7379,7 +7393,7 @@ int main(int argc, char *argv[])
if (unlikely(pthread_cond_init(&gws_cond, NULL))) if (unlikely(pthread_cond_init(&gws_cond, NULL)))
quit(1, "Failed to pthread_cond_init gws_cond"); quit(1, "Failed to pthread_cond_init gws_cond");
sprintf(packagename, "%s %s", PACKAGE, VERSION); snprintf(packagename, sizeof(packagename), "%s %s", PACKAGE, VERSION);
handler.sa_handler = &sighandler; handler.sa_handler = &sighandler;
handler.sa_flags = 0; handler.sa_flags = 0;
@ -7610,6 +7624,7 @@ int main(int argc, char *argv[])
for (i = 0; i < total_pools; i++) { for (i = 0; i < total_pools; i++) {
struct pool *pool = pools[i]; struct pool *pool = pools[i];
size_t siz;
pool->cgminer_stats.getwork_wait_min.tv_sec = MIN_SEC_UNSET; pool->cgminer_stats.getwork_wait_min.tv_sec = MIN_SEC_UNSET;
pool->cgminer_pool_stats.getwork_wait_min.tv_sec = MIN_SEC_UNSET; pool->cgminer_pool_stats.getwork_wait_min.tv_sec = MIN_SEC_UNSET;
@ -7617,10 +7632,11 @@ int main(int argc, char *argv[])
if (!pool->rpc_userpass) { if (!pool->rpc_userpass) {
if (!pool->rpc_user || !pool->rpc_pass) if (!pool->rpc_user || !pool->rpc_pass)
quit(1, "No login credentials supplied for pool %u %s", i, pool->rpc_url); quit(1, "No login credentials supplied for pool %u %s", i, pool->rpc_url);
pool->rpc_userpass = malloc(strlen(pool->rpc_user) + strlen(pool->rpc_pass) + 2); siz = strlen(pool->rpc_user) + strlen(pool->rpc_pass) + 2;
pool->rpc_userpass = malloc(siz);
if (!pool->rpc_userpass) if (!pool->rpc_userpass)
quit(1, "Failed to malloc userpass"); quit(1, "Failed to malloc userpass");
sprintf(pool->rpc_userpass, "%s:%s", pool->rpc_user, pool->rpc_pass); snprintf(pool->rpc_userpass, siz, "%s:%s", pool->rpc_user, pool->rpc_pass);
} }
} }
/* Set the currentpool to pool 0 */ /* Set the currentpool to pool 0 */

Write Preview
Loading…
Cancel
Save