GOSTSec/sgminer
1
0
Fork 0
mirror of https://github.com/GOSTSec/sgminer synced 2025-01-14 16:58:05 +00:00
Code Issues Releases Wiki Activity

cgminer - size check all sprintf

Browse Source
This commit is contained in:
Kano 2013-07-06 20:47:49 +10:00
parent ad1572f77f
commit 74d71cce2c
1 changed files with 63 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
cgminer.c
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 */