mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

Change sprintf to SNPRINTF for kenwood files

pull/928/head
Mike Black W9MDB 2022-01-10 23:03:54 -06:00
rodzic b0ae08f7b7
commit 18f69356c9
22 zmienionych plików z 242 dodań i 285 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

12
rigs/kenwood/flex6xxx.c
Wyświetl plik

@ -441,7 +441,7 @@ static int flex6k_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(buf, "MD%c", '0' + kmode); SNPRINTF(buf, sizeof(buf), "MD%c", '0' + kmode);
err = kenwood_transaction(rig, buf, NULL, 0); err = kenwood_transaction(rig, buf, NULL, 0);
if (err != RIG_OK) if (err != RIG_OK)
@ -471,11 +471,11 @@ static int flex6k_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
switch (vfo) switch (vfo)
{ {
case RIG_VFO_A: case RIG_VFO_A:
sprintf(buf, "ZZFI%02d;", idx); SNPRINTF(buf, sizeof(buf), "ZZFI%02d;", idx);
break; break;
case RIG_VFO_B: case RIG_VFO_B:
sprintf(buf, "ZZFJ%02d;", idx); SNPRINTF(buf, sizeof(buf), "ZZFJ%02d;", idx);
break; break;
default: default:
@ -513,7 +513,7 @@ static int powersdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(buf, "ZZMD%02d", kmode); SNPRINTF(buf, sizeof(buf), "ZZMD%02d", kmode);
err = kenwood_transaction(rig, buf, NULL, 0); err = kenwood_transaction(rig, buf, NULL, 0);
if (err != RIG_OK) if (err != RIG_OK)
@ -548,11 +548,11 @@ static int powersdr_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{ {
// 150Hz on the low end should be enough // 150Hz on the low end should be enough
// Set high to the width requested // Set high to the width requested
sprintf(buf, "ZZFL00150;ZZFH%05d;", (int)width); SNPRINTF(buf, sizeof(buf), "ZZFL00150;ZZFH%05d;", (int)width);
} }
else else
{ {
sprintf(buf, "ZZFI%02d;", idx); SNPRINTF(buf, sizeof(buf), "ZZFI%02d;", idx);
} }
break; break;

98
rigs/kenwood/ic10.c
Wyświetl plik

@ -186,7 +186,7 @@ static int get_ic10_if(RIG *rig, char *data)
int ic10_set_vfo(RIG *rig, vfo_t vfo) int ic10_set_vfo(RIG *rig, vfo_t vfo)
{ {
char cmdbuf[6]; char cmdbuf[6];
int cmd_len, retval; int retval;
char vfo_function; char vfo_function;
switch (vfo) switch (vfo)
@ -208,9 +208,9 @@ int ic10_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
cmd_len = sprintf(cmdbuf, "FN%c;", vfo_function); SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c;", vfo_function);
retval = ic10_transaction(rig, cmdbuf, cmd_len, NULL, 0); retval = ic10_transaction(rig, cmdbuf, strlen(cmdbuf), NULL, 0);
return retval; return retval;
} }
@ -373,7 +373,7 @@ int ic10_get_mode(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
int ic10_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width) int ic10_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{ {
char modebuf[6]; char modebuf[6];
int mode_len, retval; int retval;
char mode_letter; char mode_letter;
switch (mode) switch (mode)
@ -396,8 +396,8 @@ int ic10_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
mode_len = sprintf(modebuf, "MD%c;", mode_letter); SNPRINTF(modebuf, sizeof(modebuf), "MD%c;", mode_letter);
retval = ic10_transaction(rig, modebuf, mode_len, NULL, 0); retval = ic10_transaction(rig, modebuf, strlen(modebuf), NULL, 0);
return retval; return retval;
} }
@ -442,7 +442,7 @@ int ic10_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
int ic10_set_freq(RIG *rig, vfo_t vfo, freq_t freq) int ic10_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{ {
char freqbuf[64]; char freqbuf[64];
int freq_len, retval; int retval;
unsigned char vfo_letter; unsigned char vfo_letter;
vfo_t tvfo; vfo_t tvfo;
@ -470,8 +470,8 @@ int ic10_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
} }
// cppcheck-suppress * // cppcheck-suppress *
freq_len = sprintf(freqbuf, "F%c%011"PRIll";", vfo_letter, (int64_t)freq); SNPRINTF(freqbuf, sizeof(freqbuf), "F%c%011"PRIll";", vfo_letter, (int64_t)freq);
retval = ic10_transaction(rig, freqbuf, freq_len, NULL, 0); retval = ic10_transaction(rig, freqbuf, strlen(freqbuf), NULL, 0);
return retval; return retval;
} }
@ -484,11 +484,11 @@ int ic10_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
int ic10_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option) int ic10_set_ant(RIG *rig, vfo_t vfo, ant_t ant, value_t option)
{ {
char buf[6], ackbuf[64]; char buf[6], ackbuf[64];
int len, ack_len, retval; int ack_len, retval;
len = sprintf(buf, "AN%c;", ant == RIG_ANT_1 ? '1' : '2'); SNPRINTF(buf, sizeof(buf), "AN%c;", ant == RIG_ANT_1 ? '1' : '2');
retval = ic10_transaction(rig, buf, len, ackbuf, &ack_len); retval = ic10_transaction(rig, buf, strlen(buf), ackbuf, &ack_len);
return retval; return retval;
} }
@ -562,7 +562,7 @@ int ic10_get_ptt(RIG *rig, vfo_t vfo, ptt_t *ptt)
int ic10_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt) int ic10_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
{ {
char pttbuf[4]; char pttbuf[4];
int ptt_len, retval; int retval;
unsigned char ptt_letter; unsigned char ptt_letter;
rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__); rig_debug(RIG_DEBUG_VERBOSE, "%s: called\n", __func__);
@ -579,8 +579,8 @@ int ic10_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
ptt_len = sprintf(pttbuf, "%cX;", ptt_letter); SNPRINTF(pttbuf, sizeof(pttbuf), "%cX;", ptt_letter);
retval = ic10_transaction(rig, pttbuf, ptt_len, NULL, 0); retval = ic10_transaction(rig, pttbuf, strlen(pttbuf), NULL, 0);
return retval; return retval;
} }
@ -622,11 +622,11 @@ int ic10_get_mem(RIG *rig, vfo_t vfo, int *ch)
int ic10_set_mem(RIG *rig, vfo_t vfo, int ch) int ic10_set_mem(RIG *rig, vfo_t vfo, int ch)
{ {
char membuf[8], ackbuf[64]; char membuf[8], ackbuf[64];
int mem_len, ack_len, retval; int ack_len, retval;
mem_len = sprintf(membuf, "MC%02d;", ch); SNPRINTF(membuf, sizeof(membuf), "MC%02d;", ch);
retval = ic10_transaction(rig, membuf, mem_len, ackbuf, &ack_len); retval = ic10_transaction(rig, membuf, strlen(membuf), ackbuf, &ack_len);
return retval; return retval;
} }
@ -635,11 +635,11 @@ int ic10_set_mem(RIG *rig, vfo_t vfo, int ch)
int ic10_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only) int ic10_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
{ {
char membuf[16], infobuf[32]; char membuf[16], infobuf[32];
int retval, info_len, len; int retval, info_len;
len = sprintf(membuf, "MR00%02d;", chan->channel_num); SNPRINTF(membuf, sizeof(membuf), "MR00%02d;", chan->channel_num);
info_len = 24; info_len = 24;
retval = ic10_transaction(rig, membuf, len, infobuf, &info_len); retval = ic10_transaction(rig, membuf, strlen(membuf), infobuf, &info_len);
if (retval != RIG_OK) if (retval != RIG_OK)
{ {
@ -679,9 +679,9 @@ int ic10_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
{ {
chan->split = 1; chan->split = 1;
/* TX VFO (Split channel only) */ /* TX VFO (Split channel only) */
len = sprintf(membuf, "MR10%02d;", chan->channel_num); SNPRINTF(membuf, sizeof(membuf), "MR10%02d;", chan->channel_num);
info_len = 24; info_len = 24;
retval = ic10_transaction(rig, membuf, len, infobuf, &info_len); retval = ic10_transaction(rig, membuf, strlen(membuf), infobuf, &info_len);
if (retval == RIG_OK && info_len > 17) if (retval == RIG_OK && info_len > 17)
{ {
@ -732,7 +732,7 @@ int ic10_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
int ic10_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) int ic10_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{ {
char membuf[64]; char membuf[64];
int retval, len, md; int retval, md;
int64_t freq; int64_t freq;
freq = (int64_t) chan->freq; freq = (int64_t) chan->freq;
@ -767,12 +767,12 @@ int ic10_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
} }
/* MWnxrrggmmmkkkhhhdzxxxx; */ /* MWnxrrggmmmkkkhhhdzxxxx; */
len = sprintf(membuf, "MW0 %02d%011"PRIll"%c0 ;", SNPRINTF(membuf, sizeof(membuf), "MW0 %02d%011"PRIll"%c0 ;",
chan->channel_num, chan->channel_num,
freq, freq,
md md
); );
retval = ic10_transaction(rig, membuf, len, NULL, 0); retval = ic10_transaction(rig, membuf, strlen(membuf), NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
{ {
@ -807,12 +807,12 @@ int ic10_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan->channel_num >= 90) if (chan->channel_num >= 90)
{ {
/* MWnxrrggmmmkkkhhhdzxxxx; */ /* MWnxrrggmmmkkkhhhdzxxxx; */
len = sprintf(membuf, "MW1 %02d%011"PRIll"%c0 ;", SNPRINTF(membuf, sizeof(membuf), "MW1 %02d%011"PRIll"%c0 ;",
chan->channel_num, chan->channel_num,
freq, freq,
md md
); );
retval = ic10_transaction(rig, membuf, len, NULL, 0); retval = ic10_transaction(rig, membuf, strlen(membuf), NULL, 0);
// I assume we need to check the retval here -- W9MDB // I assume we need to check the retval here -- W9MDB
// This was found from cppcheck // This was found from cppcheck
@ -835,13 +835,13 @@ int ic10_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
int ic10_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status) int ic10_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
{ {
char cmdbuf[6], fctbuf[50]; char cmdbuf[6], fctbuf[50];
int cmdlen, fct_len, retval; int fct_len, retval;
fct_len = 4; fct_len = 4;
switch (func) switch (func)
{ {
case RIG_FUNC_LOCK: cmdlen = sprintf(cmdbuf, "LK;"); break; case RIG_FUNC_LOCK: SNPRINTF(cmdbuf, sizeof(cmdbuf), "LK;"); break;
default: default:
rig_debug(RIG_DEBUG_ERR, "%s: unsupported get_func %s", rig_debug(RIG_DEBUG_ERR, "%s: unsupported get_func %s",
@ -849,7 +849,7 @@ int ic10_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
retval = ic10_transaction(rig, cmdbuf, cmdlen, fctbuf, &fct_len); retval = ic10_transaction(rig, cmdbuf, strlen(cmdbuf), fctbuf, &fct_len);
if (retval != RIG_OK) if (retval != RIG_OK)
{ {
@ -876,18 +876,12 @@ int ic10_get_func(RIG *rig, vfo_t vfo, setting_t func, int *status)
int ic10_set_func(RIG *rig, vfo_t vfo, setting_t func, int status) int ic10_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
{ {
char cmdbuf[4], fctbuf[16], ackbuf[64]; char cmdbuf[4], fctbuf[16], ackbuf[64];
int cmdlen, fct_len, ack_len; int ack_len;
switch (func) switch (func)
{ {
case RIG_FUNC_LOCK: case RIG_FUNC_LOCK:
cmdlen = sprintf(cmdbuf, "LK"); SNPRINTF(cmdbuf, sizeof(cmdbuf), "LK");
if (cmdlen < 0)
{
return -RIG_ETRUNC;
}
break; break;
default: default:
@ -896,14 +890,9 @@ int ic10_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
fct_len = sprintf(fctbuf, "%s%c;", cmdbuf, status == 0 ? '0' : '1'); SNPRINTF(fctbuf, sizeof(fctbuf), "%s%c;", cmdbuf, status == 0 ? '0' : '1');
if (fct_len < 0) return ic10_transaction(rig, fctbuf, strlen(fctbuf), ackbuf, &ack_len);
{
return -RIG_ETRUNC;
}
return ic10_transaction(rig, fctbuf, fct_len, ackbuf, &ack_len);
} }
@ -914,7 +903,6 @@ int ic10_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
int ic10_set_parm(RIG *rig, setting_t parm, value_t val) int ic10_set_parm(RIG *rig, setting_t parm, value_t val)
{ {
char cmdbuf[50]; char cmdbuf[50];
int cmd_len;
int hours; int hours;
int minutes; int minutes;
int seconds; int seconds;
@ -926,8 +914,8 @@ int ic10_set_parm(RIG *rig, setting_t parm, value_t val)
hours = minutes / 60; hours = minutes / 60;
seconds = val.i - (minutes * 60); seconds = val.i - (minutes * 60);
minutes = minutes % 60; minutes = minutes % 60;
cmd_len = sprintf(cmdbuf, "CK1%02d%02d%02d;", hours, minutes, seconds); SNPRINTF(cmdbuf, sizeof(cmdbuf), "CK1%02d%02d%02d;", hours, minutes, seconds);
return ic10_transaction(rig, cmdbuf, cmd_len, NULL, NULL); return ic10_transaction(rig, cmdbuf, strlen(cmdbuf), NULL, NULL);
break; break;
default: default:
@ -996,11 +984,11 @@ int ic10_get_parm(RIG *rig, setting_t parm, value_t *val)
int ic10_set_powerstat(RIG *rig, powerstat_t status) int ic10_set_powerstat(RIG *rig, powerstat_t status)
{ {
char pwrbuf[16], ackbuf[64]; char pwrbuf[16], ackbuf[64];
int pwr_len, ack_len; int ack_len;
pwr_len = sprintf(pwrbuf, "PS%c;", status == RIG_POWER_ON ? '1' : '0'); SNPRINTF(pwrbuf, sizeof(pwrbuf), "PS%c;", status == RIG_POWER_ON ? '1' : '0');
return ic10_transaction(rig, pwrbuf, pwr_len, ackbuf, &ack_len); return ic10_transaction(rig, pwrbuf, strlen(pwrbuf), ackbuf, &ack_len);
} }
@ -1041,11 +1029,11 @@ int ic10_get_powerstat(RIG *rig, powerstat_t *status)
int ic10_set_trn(RIG *rig, int trn) int ic10_set_trn(RIG *rig, int trn)
{ {
char trnbuf[16], ackbuf[64]; char trnbuf[16], ackbuf[64];
int trn_len, ack_len; int ack_len;
trn_len = sprintf(trnbuf, "AI%c;", trn == RIG_TRN_RIG ? '1' : '0'); SNPRINTF(trnbuf, sizeof(trnbuf), "AI%c;", trn == RIG_TRN_RIG ? '1' : '0');
return ic10_transaction(rig, trnbuf, trn_len, ackbuf, &ack_len); return ic10_transaction(rig, trnbuf, strlen(trnbuf), ackbuf, &ack_len);
} }

2
rigs/kenwood/k3.c
Wyświetl plik

@ -1609,7 +1609,7 @@ int k3_set_split_mode(RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(buf, "MD$%c", '0' + kmode); snprintf(buf, sizeof(buf), "MD$%c", '0' + kmode);
err = kenwood_transaction(rig, buf, NULL, 0); err = kenwood_transaction(rig, buf, NULL, 0);
if (err != RIG_OK) if (err != RIG_OK)

30
rigs/kenwood/pihpsdr.c
Wyświetl plik

@ -361,7 +361,7 @@ int pihspdr_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
} }
/* put channel num in the command string */ /* put channel num in the command string */
sprintf(cmd, "MR0%03d;", chan->channel_num); SNPRINTF(cmd, sizeof(cmd), "MR0%03d;", chan->channel_num);
err = kenwood_transaction(rig, cmd, buf, sizeof(buf)); err = kenwood_transaction(rig, cmd, buf, sizeof(buf));
@ -735,7 +735,7 @@ int pihspdr_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
} }
/* P-number 2-3 4 5 6 7 8 9 101112 13 141516 */ /* P-number 2-3 4 5 6 7 8 9 101112 13 141516 */
sprintf(buf, "MW0%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;", SNPRINTF(buf, sizeof(buf), "MW0%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;",
chan->channel_num, chan->channel_num,
(unsigned) chan->freq, /* 4 - frequency */ (unsigned) chan->freq, /* 4 - frequency */
'0' + mode, /* 5 - mode */ '0' + mode, /* 5 - mode */
@ -807,20 +807,20 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
case RIG_LEVEL_RFPOWER: case RIG_LEVEL_RFPOWER:
/* level is float between 0.0 and 1.0, maps to 0 ... 100 */ /* level is float between 0.0 and 1.0, maps to 0 ... 100 */
kenwood_val = val.f * 100; kenwood_val = val.f * 100;
sprintf(levelbuf, "PC%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "PC%03d", kenwood_val);
break; break;
case RIG_LEVEL_AF: case RIG_LEVEL_AF:
sprintf(levelbuf, "AG%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "AG%03d", kenwood_val);
break; break;
case RIG_LEVEL_RF: case RIG_LEVEL_RF:
/* XXX check level range */ /* XXX check level range */
sprintf(levelbuf, "RG%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "RG%03d", kenwood_val);
break; break;
case RIG_LEVEL_SQL: case RIG_LEVEL_SQL:
sprintf(levelbuf, "SQ%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "SQ%03d", kenwood_val);
break; break;
case RIG_LEVEL_AGC: case RIG_LEVEL_AGC:
@ -830,7 +830,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
else if (kenwood_val == RIG_AGC_MEDIUM) { kenwood_val = 15; } else if (kenwood_val == RIG_AGC_MEDIUM) { kenwood_val = 15; }
else if (kenwood_val == RIG_AGC_SLOW) { kenwood_val = 20; } else if (kenwood_val == RIG_AGC_SLOW) { kenwood_val = 20; }
sprintf(levelbuf, "GT%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "GT%03d", kenwood_val);
break; break;
case RIG_LEVEL_ATT: case RIG_LEVEL_ATT:
@ -838,7 +838,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
/* set the attenuator if a correct value is entered */ /* set the attenuator if a correct value is entered */
if (val.i == 0) if (val.i == 0)
{ {
sprintf(levelbuf, "RA00"); SNPRINTF(levelbuf, sizeof(levelbuf), "RA00");
} }
else else
{ {
@ -848,7 +848,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{ {
if (val.i == rig->state.attenuator[i]) if (val.i == rig->state.attenuator[i])
{ {
sprintf(levelbuf, "RA%02d", i + 1); SNPRINTF(levelbuf, sizeof(levelbuf), "RA%02d", i + 1);
foundit = 1; foundit = 1;
break; break;
} }
@ -867,7 +867,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
/* set the preamp if a correct value is entered */ /* set the preamp if a correct value is entered */
if (val.i == 0) if (val.i == 0)
{ {
sprintf(levelbuf, "PA0"); SNPRINTF(levelbuf, sizeof(levelbuf), "PA0");
} }
else else
{ {
@ -877,7 +877,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{ {
if (val.i == rig->state.preamp[i]) if (val.i == rig->state.preamp[i])
{ {
sprintf(levelbuf, "PA%01d", i + 1); SNPRINTF(levelbuf, sizeof(levelbuf), "PA%01d", i + 1);
foundit = 1; foundit = 1;
break; break;
} }
@ -897,7 +897,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(levelbuf, "SH%02d", (val.i)); SNPRINTF(levelbuf, sizeof(levelbuf), "SH%02d", (val.i));
break; break;
case RIG_LEVEL_SLOPE_LOW: case RIG_LEVEL_SLOPE_LOW:
@ -906,7 +906,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(levelbuf, "SL%02d", (val.i)); SNPRINTF(levelbuf, sizeof(levelbuf), "SL%02d", (val.i));
break; break;
case RIG_LEVEL_CWPITCH: case RIG_LEVEL_CWPITCH:
@ -915,7 +915,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(levelbuf, "PT%02d", (val.i / 50) - 8); SNPRINTF(levelbuf, sizeof(levelbuf), "PT%02d", (val.i / 50) - 8);
break; break;
case RIG_LEVEL_KEYSPD: case RIG_LEVEL_KEYSPD:
@ -924,7 +924,7 @@ int pihpsdr_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(levelbuf, "KS%03d", val.i); SNPRINTF(levelbuf, sizeof(levelbuf), "KS%03d", val.i);
break; break;
default: default:

84
rigs/kenwood/th.c
Wyświetl plik

@ -243,7 +243,7 @@ th_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
freq_sent = freq_sent >= MHz(470) ? (round(freq_sent / 10000) * 10000) : freq_sent = freq_sent >= MHz(470) ? (round(freq_sent / 10000) * 10000) :
freq_sent; freq_sent;
// cppcheck-suppress * // cppcheck-suppress *
sprintf(buf, "FQ %011"PRIll",%X", (int64_t) freq_sent, step); SNPRINTF(buf, sizeof(buf), "FQ %011"PRIll",%X", (int64_t) freq_sent, step);
return kenwood_transaction(rig, buf, buf, sizeof buf); return kenwood_transaction(rig, buf, buf, sizeof buf);
} }
@ -335,7 +335,7 @@ th_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
} }
} }
sprintf(mdbuf, "MD %c", kmode); SNPRINTF(mdbuf, sizeof(mdbuf), "MD %c", kmode);
return kenwood_transaction(rig, mdbuf, mdbuf, sizeof mdbuf); return kenwood_transaction(rig, mdbuf, mdbuf, sizeof mdbuf);
} }
@ -570,7 +570,7 @@ th_get_vfo_char(RIG *rig, vfo_t *vfo, char *vfoch)
/* Get mode of the VFO band */ /* Get mode of the VFO band */
sprintf(cmdbuf, "VMC %c", vfoc); SNPRINTF(cmdbuf, sizeof(cmdbuf), "VMC %c", vfoc);
retval = kenwood_safe_transaction(rig, cmdbuf, buf, 10, 7); retval = kenwood_safe_transaction(rig, cmdbuf, buf, 10, 7);
@ -1154,7 +1154,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level) switch (level)
{ {
case RIG_LEVEL_RAWSTR: case RIG_LEVEL_RAWSTR:
sprintf(buf, "SM %c", vch); SNPRINTF(buf, sizeof(buf), "SM %c", vch);
// XXX use kenwood_safe_transaction // XXX use kenwood_safe_transaction
retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf)); retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf));
@ -1177,7 +1177,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break; break;
case RIG_LEVEL_SQL: case RIG_LEVEL_SQL:
sprintf(buf, "SQ %c", vch); SNPRINTF(buf, sizeof(buf), "SQ %c", vch);
retval = kenwood_safe_transaction(rig, buf, ackbuf, 10, 7); retval = kenwood_safe_transaction(rig, buf, ackbuf, 10, 7);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1201,7 +1201,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break; break;
case RIG_LEVEL_AF: case RIG_LEVEL_AF:
sprintf(buf, "AG %c", vch); SNPRINTF(buf, sizeof(buf), "AG %c", vch);
retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf)); retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1225,7 +1225,7 @@ th_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break; break;
case RIG_LEVEL_RFPOWER: case RIG_LEVEL_RFPOWER:
sprintf(buf, "PC %c", vch); SNPRINTF(buf, sizeof(buf), "PC %c", vch);
retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf)); retval = kenwood_transaction(rig, buf, ackbuf, sizeof(ackbuf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1345,7 +1345,7 @@ int th_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{ {
case RIG_LEVEL_RFPOWER : case RIG_LEVEL_RFPOWER :
sprintf(buf, "PC %c,%01d", vch, SNPRINTF(buf, sizeof(buf), "PC %c,%01d", vch,
(int)(val.f * (rig->caps->level_gran[LVL_RFPOWER].max.i - (int)(val.f * (rig->caps->level_gran[LVL_RFPOWER].max.i -
rig->caps->level_gran[LVL_RFPOWER].min.i)) rig->caps->level_gran[LVL_RFPOWER].min.i))
+ rig->caps->level_gran[LVL_RFPOWER].min.i); + rig->caps->level_gran[LVL_RFPOWER].min.i);
@ -1353,26 +1353,26 @@ int th_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return kenwood_transaction(rig, buf, NULL, 0); return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_SQL : case RIG_LEVEL_SQL :
sprintf(buf, "SQ %c,%02x", vch, SNPRINTF(buf, sizeof(buf), "SQ %c,%02x", vch,
(int)(val.f * (rig->caps->level_gran[LVL_SQL].max.i - (int)(val.f * (rig->caps->level_gran[LVL_SQL].max.i -
rig->caps->level_gran[LVL_SQL].min.i)) rig->caps->level_gran[LVL_SQL].min.i))
+ rig->caps->level_gran[LVL_SQL].min.i); + rig->caps->level_gran[LVL_SQL].min.i);
return kenwood_transaction(rig, buf, NULL, 0); return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_AF : case RIG_LEVEL_AF :
sprintf(buf, "AG %c,%02x", vch, (int)(val.f * 32.0)); SNPRINTF(buf, sizeof(buf), "AG %c,%02x", vch, (int)(val.f * 32.0));
return kenwood_transaction(rig, buf, NULL, 0); return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_ATT : case RIG_LEVEL_ATT :
sprintf(buf, "ATT %c", val.i ? '1' : '0'); SNPRINTF(buf, sizeof(buf), "ATT %c", val.i ? '1' : '0');
return kenwood_transaction(rig, buf, NULL, 0); return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_BALANCE : case RIG_LEVEL_BALANCE :
sprintf(buf, "BAL %c", '4' - (int)(val.f * ('4' - '0'))); SNPRINTF(buf, sizeof(buf), "BAL %c", '4' - (int)(val.f * ('4' - '0')));
return kenwood_transaction(rig, buf, NULL, 0); return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_VOXGAIN: case RIG_LEVEL_VOXGAIN:
sprintf(buf, "VXG %d", (int)(val.f * 9)); SNPRINTF(buf, sizeof(buf), "VXG %d", (int)(val.f * 9));
return kenwood_transaction(rig, buf, NULL, 0); return kenwood_transaction(rig, buf, NULL, 0);
case RIG_LEVEL_VOXDELAY: /* "VXD" */ case RIG_LEVEL_VOXDELAY: /* "VXD" */
@ -1949,11 +1949,11 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan_caps[1].type == RIG_MTYPE_PRIO) if (chan_caps[1].type == RIG_MTYPE_PRIO)
{ {
/* Info */ /* Info */
sprintf(req, "MR %s0,I-%01d", mr_extra, channel_num); SNPRINTF(req, sizeof(req), "MR %s0,I-%01d", mr_extra, channel_num);
} }
else else
{ {
sprintf(req, "MR %s0,%03d", mr_extra, channel_num); SNPRINTF(req, sizeof(req), "MR %s0,%03d", mr_extra, channel_num);
} }
break; break;
@ -1962,12 +1962,12 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan_caps[1].type == RIG_MTYPE_EDGE) if (chan_caps[1].type == RIG_MTYPE_EDGE)
{ {
snprintf(req, sizeof(req), "MR %s0,L%01d", mr_extra, channel_num); snprintf(req, sizeof(req), "MR %s0,L%01d", mr_extra, channel_num);
sprintf(chan->channel_desc, "L%01d", channel_num); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "L%01d", channel_num);
} }
else else
{ {
snprintf(req, sizeof(req), "MR %s0,U%01d", mr_extra, channel_num); snprintf(req, sizeof(req), "MR %s0,U%01d", mr_extra, channel_num);
sprintf(chan->channel_desc, "U%01d", channel_num); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "U%01d", channel_num);
} }
break; break;
@ -1976,35 +1976,35 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan_caps->startc == chan_caps->endc) if (chan_caps->startc == chan_caps->endc)
{ {
snprintf(req, sizeof(req), "MR %s0,PR", mr_extra); snprintf(req, sizeof(req), "MR %s0,PR", mr_extra);
sprintf(chan->channel_desc, "Pr"); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Pr");
} }
else else
{ {
snprintf(req, sizeof(req), "MR %s0,PR%01d", mr_extra, channel_num + 1); snprintf(req, sizeof(req), "MR %s0,PR%01d", mr_extra, channel_num + 1);
sprintf(chan->channel_desc, "Pr%01d", channel_num + 1); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Pr%01d", channel_num + 1);
} }
break; break;
case RIG_MTYPE_CALL: case RIG_MTYPE_CALL:
sprintf(req, "CR 0,%01d", channel_num); SNPRINTF(req, sizeof(req), "CR 0,%01d", channel_num);
if (chan->channel_num == chan_caps->startc) { sprintf(chan->channel_desc, "Call V"); } if (chan->channel_num == chan_caps->startc) { SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call V"); }
else if (chan->channel_num == chan_caps->endc) { sprintf(chan->channel_desc, "Call U"); } else if (chan->channel_num == chan_caps->endc) { SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call U"); }
else { sprintf(chan->channel_desc, "Call"); } else { SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call"); }
break; break;
case RIG_MTYPE_BAND: case RIG_MTYPE_BAND:
sprintf(req, "VR %01X", channel_num); SNPRINTF(req, sizeof(req), "VR %01X", channel_num);
sprintf(chan->channel_desc, "BAND %01X", channel_num); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "BAND %01X", channel_num);
break; break;
default: default:
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(membuf, "%s", req); SNPRINTF(membuf, sizeof(membuf), "%s", req);
retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf)); retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf));
@ -2140,7 +2140,7 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
{ {
/* split ? */ /* split ? */
req[3 + strlen(mr_extra)] = '1'; req[3 + strlen(mr_extra)] = '1';
sprintf(membuf, "%s", req); SNPRINTF(membuf, sizeof(membuf), "%s", req);
retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf)); retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf));
if (retval == RIG_OK) if (retval == RIG_OK)
@ -2160,11 +2160,11 @@ int th_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan_caps[1].type == RIG_MTYPE_PRIO) if (chan_caps[1].type == RIG_MTYPE_PRIO)
{ {
sprintf(membuf, "MNA %sI-%01d", mr_extra, channel_num); SNPRINTF(membuf, sizeof(membuf), "MNA %sI-%01d", mr_extra, channel_num);
} }
else else
{ {
sprintf(membuf, "MNA %s%03d", mr_extra, channel_num); SNPRINTF(membuf, sizeof(membuf), "MNA %s%03d", mr_extra, channel_num);
} }
/* Get memory name */ /* Get memory name */
@ -2343,13 +2343,13 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan_caps[1].type == RIG_MTYPE_PRIO) if (chan_caps[1].type == RIG_MTYPE_PRIO)
{ {
/* Info */ /* Info */
sprintf(req, "MW %s0,I-%01d", mr_extra, channel_num); SNPRINTF(req, sizeof(req), "MW %s0,I-%01d", mr_extra, channel_num);
channel_desc = chan->channel_desc; channel_desc = chan->channel_desc;
} }
else else
{ {
/* Regular */ /* Regular */
sprintf(req, "MW %s0,%03d", mr_extra, channel_num); SNPRINTF(req, sizeof(req), "MW %s0,%03d", mr_extra, channel_num);
channel_desc = chan->channel_desc; channel_desc = chan->channel_desc;
} }
@ -2358,11 +2358,11 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
case RIG_MTYPE_EDGE: case RIG_MTYPE_EDGE:
if (chan_caps[1].type == RIG_MTYPE_EDGE) if (chan_caps[1].type == RIG_MTYPE_EDGE)
{ {
sprintf(req, "MW %s0,L%01d", mr_extra, channel_num); SNPRINTF(req, sizeof(req), "MW %s0,L%01d", mr_extra, channel_num);
} }
else else
{ {
sprintf(req, "MW %s0,U%01d", mr_extra, channel_num); SNPRINTF(req, sizeof(req), "MW %s0,U%01d", mr_extra, channel_num);
} }
break; break;
@ -2370,21 +2370,21 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
case RIG_MTYPE_PRIO: case RIG_MTYPE_PRIO:
if (chan_caps->startc == chan_caps->endc) if (chan_caps->startc == chan_caps->endc)
{ {
sprintf(req, "MW %s0,PR", mr_extra); SNPRINTF(req, sizeof(req), "MW %s0,PR", mr_extra);
} }
else else
{ {
sprintf(req, "MW %s0,PR%01d", mr_extra, channel_num + 1); SNPRINTF(req, sizeof(req), "MW %s0,PR%01d", mr_extra, channel_num + 1);
} }
break; break;
case RIG_MTYPE_CALL: case RIG_MTYPE_CALL:
sprintf(req, "CW 0,%01d", channel_num); SNPRINTF(req, sizeof(req), "CW 0,%01d", channel_num);
break; break;
case RIG_MTYPE_BAND: case RIG_MTYPE_BAND:
sprintf(req, "VW %01X", channel_num); SNPRINTF(req, sizeof(req), "VW %01X", channel_num);
break; break;
default: default:
@ -2396,7 +2396,7 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan_caps->mem_caps.flags) if (chan_caps->mem_caps.flags)
{ {
sprintf(lockoutstr, ",%d", lockout); SNPRINTF(lockoutstr, sizeof(lockoutstr), ",%d", lockout);
} }
else else
{ {
@ -2435,7 +2435,7 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{ {
/* Without DCS,mode */ /* Without DCS,mode */
sprintf(membuf, "%s,%011"PRIll",%X,%d,%d,%d,%d,,%02d,,%02d,%09"PRIll"%s", SNPRINTF(membuf, sizeof(membuf), "%s,%011"PRIll",%X,%d,%d,%d,%d,,%02d,,%02d,%09"PRIll"%s",
req, (int64_t)chan->freq, step, shift, rev, tone, req, (int64_t)chan->freq, step, shift, rev, tone,
ctcss, tonefq, ctcssfq, ctcss, tonefq, ctcssfq,
(int64_t)labs((long)(chan->rptr_offs)), lockoutstr (int64_t)labs((long)(chan->rptr_offs)), lockoutstr
@ -2457,7 +2457,7 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
req[3 + strlen(mr_extra)] = '1'; req[3 + strlen(mr_extra)] = '1';
sprintf(membuf, "%s,%011"PRIll",%X", req, (int64_t)chan->tx_freq, step); SNPRINTF(membuf, sizeof(membuf), "%s,%011"PRIll",%X", req, (int64_t)chan->tx_freq, step);
retval = kenwood_transaction(rig, membuf, membuf, sizeof membuf); retval = kenwood_transaction(rig, membuf, membuf, sizeof membuf);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -2472,11 +2472,11 @@ int th_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
/* TODO: check strlen(channel_desc) < rig->caps->chan_desc_sz */ /* TODO: check strlen(channel_desc) < rig->caps->chan_desc_sz */
if (chan_caps[1].type == RIG_MTYPE_PRIO) if (chan_caps[1].type == RIG_MTYPE_PRIO)
{ {
sprintf(membuf, "MNA %sI-%01d,%s", mr_extra, channel_num, channel_desc); SNPRINTF(membuf, sizeof(membuf), "MNA %sI-%01d,%s", mr_extra, channel_num, channel_desc);
} }
else else
{ {
sprintf(membuf, "MNA %s%03d,%s", mr_extra, channel_num, channel_desc); SNPRINTF(membuf, sizeof(membuf), "MNA %s%03d,%s", mr_extra, channel_num, channel_desc);
} }
retval = kenwood_transaction(rig, membuf, membuf, sizeof membuf); retval = kenwood_transaction(rig, membuf, membuf, sizeof membuf);

34
rigs/kenwood/thd72.c
Wyświetl plik

@ -208,7 +208,7 @@ static int thd72_set_ptt(RIG *rig, vfo_t vfo, ptt_t ptt)
vfonum = '1'; vfonum = '1';
} }
sprintf(vfobuf, "BC %c", vfonum); SNPRINTF(vfobuf, sizeof(vfobuf), "BC %c", vfonum);
retval = kenwood_transaction(rig, vfobuf, NULL, 0); retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -275,7 +275,7 @@ static int thd72_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
} }
/* Set VFO mode */ /* Set VFO mode */
sprintf(vfobuf, "VMC 0,0"); SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 0,0");
retval = kenwood_transaction(rig, vfobuf, NULL, 0); retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -283,7 +283,7 @@ static int thd72_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
return retval; return retval;
} }
sprintf(vfobuf, "VMC 1,0"); SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 1,0");
retval = kenwood_transaction(rig, vfobuf, NULL, 0); retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -291,7 +291,7 @@ static int thd72_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
return retval; return retval;
} }
sprintf(vfobuf, "BC 1"); // leave VFOB as selected VFO SNPRINTF(vfobuf, sizeof(vfobuf), "BC 1"); // leave VFOB as selected VFO
retval = kenwood_transaction(rig, vfobuf, NULL, 0); retval = kenwood_transaction(rig, vfobuf, NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -378,7 +378,7 @@ static int thd72_get_freq_info(RIG *rig, vfo_t vfo, char *buf)
return retval; return retval;
} }
sprintf(cmd, "FO %c", c); SNPRINTF(cmd, sizeof(cmd), "FO %c", c);
retval = kenwood_transaction(rig, cmd, buf, 53); retval = kenwood_transaction(rig, cmd, buf, 53);
return retval; return retval;
} }
@ -457,7 +457,7 @@ static int thd72_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
(int)ts); (int)ts);
freq = roundl(freq / ts) * ts; freq = roundl(freq / ts) * ts;
// cppcheck-suppress * // cppcheck-suppress *
sprintf(fbuf, "%010"PRIll, (int64_t)freq); SNPRINTF(fbuf, sizeof(fbuf), "%010"PRIll, (int64_t)freq);
memcpy(buf + 5, fbuf, 10); memcpy(buf + 5, fbuf, 10);
retval = kenwood_simple_transaction(rig, buf, 52); retval = kenwood_simple_transaction(rig, buf, 52);
return retval; return retval;
@ -580,7 +580,7 @@ static int thd72_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs)
return retval; return retval;
} }
sprintf(boff, "%08ld", offs); SNPRINTF(boff, sizeof(boff), "%08ld", offs);
memcpy(buf + 42, boff, 8); memcpy(buf + 42, boff, 8);
retval = kenwood_simple_transaction(rig, buf, 52); retval = kenwood_simple_transaction(rig, buf, 52);
return retval; return retval;
@ -672,7 +672,7 @@ static int thd72_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
} }
buf[22] = (tone == 0) ? '0' : '1'; buf[22] = (tone == 0) ? '0' : '1';
sprintf(tmp, "%02d", tinx); SNPRINTF(tmp, sizeof(tmp), "%02d", tinx);
memcpy(buf + 30, tmp, 2); memcpy(buf + 30, tmp, 2);
return kenwood_simple_transaction(rig, buf, 52); return kenwood_simple_transaction(rig, buf, 52);
} }
@ -745,7 +745,7 @@ static int thd72_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
} }
buf[26] = (code == 0) ? '0' : '1'; buf[26] = (code == 0) ? '0' : '1';
sprintf(tmp, "%03d", cinx); SNPRINTF(tmp, sizeof(tmp), "%03d", cinx);
memcpy(buf + 36, tmp, 3); memcpy(buf + 36, tmp, 3);
return kenwood_simple_transaction(rig, buf, 52); return kenwood_simple_transaction(rig, buf, 52);
} }
@ -810,7 +810,7 @@ static int thd72_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
} }
buf[24] = (tone == 0) ? '0' : '1'; buf[24] = (tone == 0) ? '0' : '1';
sprintf(tmp, "%02d", tinx); SNPRINTF(tmp, sizeof(tmp), "%02d", tinx);
memcpy(buf + 33, tmp, 2); memcpy(buf + 33, tmp, 2);
return kenwood_simple_transaction(rig, buf, 52); return kenwood_simple_transaction(rig, buf, 52);
} }
@ -943,7 +943,7 @@ static int thd72_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
else if (val.f <= 0.10) { lvlc = '1'; } else if (val.f <= 0.10) { lvlc = '1'; }
else { lvlc = '0'; } else { lvlc = '0'; }
sprintf(cmd, "PC %c,%c", c, lvlc); SNPRINTF(cmd, sizeof(cmd), "PC %c,%c", c, lvlc);
return kenwood_simple_transaction(rig, cmd, 6); return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_VOXGAIN: case RIG_LEVEL_VOXGAIN:
@ -958,7 +958,7 @@ static int thd72_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
case RIG_LEVEL_SQL: case RIG_LEVEL_SQL:
lvlc = '0' + (int)(val.f * 5); lvlc = '0' + (int)(val.f * 5);
sprintf(cmd, "PC %c,%c", c, lvlc); SNPRINTF(cmd, sizeof(cmd), "PC %c,%c", c, lvlc);
return kenwood_simple_transaction(rig, cmd, 6); return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_BALANCE: case RIG_LEVEL_BALANCE:
@ -992,7 +992,7 @@ static int thd72_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level) switch (level)
{ {
case RIG_LEVEL_RFPOWER: case RIG_LEVEL_RFPOWER:
sprintf(cmd, "PC %c", c); SNPRINTF(cmd, sizeof(cmd), "PC %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1044,7 +1044,7 @@ static int thd72_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break; break;
case RIG_LEVEL_SQL: case RIG_LEVEL_SQL:
sprintf(cmd, "SQ %c", c); SNPRINTF(cmd, sizeof(cmd), "SQ %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1241,7 +1241,7 @@ static int thd72_set_mem(RIG *rig, vfo_t vfo, int ch)
return retval; return retval;
} }
sprintf(cmd, "MR %c,%03d", c, ch); SNPRINTF(cmd, sizeof(cmd), "MR %c,%03d", c, ch);
return kenwood_simple_transaction(rig, cmd, 10); return kenwood_simple_transaction(rig, cmd, 10);
} }
@ -1259,7 +1259,7 @@ static int thd72_get_mem(RIG *rig, vfo_t vfo, int *ch)
return retval; return retval;
} }
sprintf(cmd, "MR %c", c); SNPRINTF(cmd, sizeof(cmd), "MR %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1370,7 +1370,7 @@ static int thd72_get_channel(RIG *rig, vfo_t vfo, channel_t *chan,
{ {
int len; int len;
char cmd[16]; char cmd[16];
sprintf(cmd, "ME %03d", chan->channel_num); SNPRINTF(cmd, sizeof(cmd), "ME %03d", chan->channel_num);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)

42
rigs/kenwood/thd74.c
Wyświetl plik

@ -275,7 +275,7 @@ static int thd74_get_freq_info(RIG *rig, vfo_t vfo, char *buf)
return retval; return retval;
} }
sprintf(cmd, "FO %c", c); SNPRINTF(cmd, sizeof(cmd), "FO %c", c);
retval = kenwood_transaction(rig, cmd, buf, 73); retval = kenwood_transaction(rig, cmd, buf, 73);
return retval; return retval;
} }
@ -420,7 +420,7 @@ static int thd74_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
} }
freq = thd74_round_freq(rig, vfo, freq); freq = thd74_round_freq(rig, vfo, freq);
sprintf(fbuf, "%010"PRIll, (int64_t)freq); SNPRINTF(fbuf, sizeof(fbuf), "%010"PRIll, (int64_t)freq);
memcpy(buf + 5, fbuf, 10); memcpy(buf + 5, fbuf, 10);
retval = kenwood_simple_transaction(rig, buf, 72); retval = kenwood_simple_transaction(rig, buf, 72);
return retval; return retval;
@ -511,7 +511,7 @@ int thd74_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
} }
} }
sprintf(mdbuf, "MD %c,%c", v, kmode); SNPRINTF(mdbuf, sizeof(mdbuf), "MD %c,%c", v, kmode);
rig_debug(RIG_DEBUG_ERR, "%s: mdbuf: %s\n", __func__, mdbuf); rig_debug(RIG_DEBUG_ERR, "%s: mdbuf: %s\n", __func__, mdbuf);
retval = kenwood_transaction(rig, mdbuf, replybuf, 7); retval = kenwood_transaction(rig, mdbuf, replybuf, 7);
@ -608,7 +608,7 @@ static int thd74_set_rptr_offs(RIG *rig, vfo_t vfo, shortfreq_t offs)
return retval; return retval;
} }
sprintf(boff, "%010ld", offs); SNPRINTF(boff, sizeof(boff), "%010ld", offs);
memcpy(buf + 16, boff, 10); memcpy(buf + 16, boff, 10);
retval = kenwood_simple_transaction(rig, buf, 72); retval = kenwood_simple_transaction(rig, buf, 72);
return retval; return retval;
@ -683,7 +683,7 @@ static int thd74_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
} }
buf[22] = (tone == 0) ? '0' : '1'; buf[22] = (tone == 0) ? '0' : '1';
sprintf(tmp, "%02d", tinx); SNPRINTF(tmp, sizeof(tmp), "%02d", tinx);
memcpy(buf + 30, tmp, 2); memcpy(buf + 30, tmp, 2);
return kenwood_simple_transaction(rig, buf, 52); return kenwood_simple_transaction(rig, buf, 52);
} }
@ -756,7 +756,7 @@ static int thd74_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
} }
buf[26] = (code == 0) ? '0' : '1'; buf[26] = (code == 0) ? '0' : '1';
sprintf(tmp, "%03d", cinx); SNPRINTF(tmp, sizeof(tmp), "%03d", cinx);
memcpy(buf + 36, tmp, 3); memcpy(buf + 36, tmp, 3);
return kenwood_simple_transaction(rig, buf, 52); return kenwood_simple_transaction(rig, buf, 52);
} }
@ -821,7 +821,7 @@ static int thd74_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
} }
buf[24] = (tone == 0) ? '0' : '1'; buf[24] = (tone == 0) ? '0' : '1';
sprintf(tmp, "%02d", tinx); SNPRINTF(tmp, sizeof(tmp), "%02d", tinx);
memcpy(buf + 33, tmp, 2); memcpy(buf + 33, tmp, 2);
return kenwood_simple_transaction(rig, buf, 52); return kenwood_simple_transaction(rig, buf, 52);
} }
@ -908,11 +908,11 @@ static int thd74_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
else if (val.f <= 0.4) { lvlc = '1'; } else if (val.f <= 0.4) { lvlc = '1'; }
else { lvlc = '0'; } else { lvlc = '0'; }
sprintf(cmd, "PC %c,%c", c, lvlc); SNPRINTF(cmd, sizeof(cmd), "PC %c,%c", c, lvlc);
return kenwood_simple_transaction(rig, cmd, 6); return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_VOXGAIN: case RIG_LEVEL_VOXGAIN:
sprintf(cmd, "VG %d", (int)(val.f * 10.0 - 0.5)); SNPRINTF(cmd, sizeof(cmd), "VG %d", (int)(val.f * 10.0 - 0.5));
return kenwood_simple_transaction(rig, cmd, 4); return kenwood_simple_transaction(rig, cmd, 4);
case RIG_LEVEL_VOXDELAY: case RIG_LEVEL_VOXDELAY:
@ -920,15 +920,15 @@ static int thd74_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
else if (val.i > 10000) { lvl = val.i / 10000 + 3; } else if (val.i > 10000) { lvl = val.i / 10000 + 3; }
else { lvl = val.i / 2500; } else { lvl = val.i / 2500; }
sprintf(cmd, "VD %d", lvl); SNPRINTF(cmd, sizeof(cmd), "VD %d", lvl);
return kenwood_simple_transaction(rig, cmd, 4); return kenwood_simple_transaction(rig, cmd, 4);
case RIG_LEVEL_SQL: case RIG_LEVEL_SQL:
sprintf(cmd, "SQ %c,%d", c, (int)val.f); SNPRINTF(cmd, sizeof(cmd), "SQ %c,%d", c, (int)val.f);
return kenwood_simple_transaction(rig, cmd, 6); return kenwood_simple_transaction(rig, cmd, 6);
case RIG_LEVEL_ATT: // no value provided to distinguish between on/off?? case RIG_LEVEL_ATT: // no value provided to distinguish between on/off??
sprintf(cmd, "RA %c,%d", c, (int)val.f); SNPRINTF(cmd, sizeof(cmd), "RA %c,%d", c, (int)val.f);
return kenwood_simple_transaction(rig, cmd, 6); return kenwood_simple_transaction(rig, cmd, 6);
default: default:
@ -957,7 +957,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level) switch (level)
{ {
case RIG_LEVEL_RFPOWER: case RIG_LEVEL_RFPOWER:
sprintf(cmd, "PC %c", c); SNPRINTF(cmd, sizeof(cmd), "PC %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -987,7 +987,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break; break;
case RIG_LEVEL_VOXGAIN: case RIG_LEVEL_VOXGAIN:
sprintf(cmd, "VG"); SNPRINTF(cmd, sizeof(cmd), "VG");
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1001,7 +1001,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break; break;
case RIG_LEVEL_VOXDELAY: case RIG_LEVEL_VOXDELAY:
sprintf(cmd, "VD"); SNPRINTF(cmd, sizeof(cmd), "VD");
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1015,7 +1015,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break; break;
case RIG_LEVEL_SQL: case RIG_LEVEL_SQL:
sprintf(cmd, "SQ %c", c); SNPRINTF(cmd, sizeof(cmd), "SQ %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1035,7 +1035,7 @@ static int thd74_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
break; break;
case RIG_LEVEL_ATT: case RIG_LEVEL_ATT:
sprintf(cmd, "RA %c", c); SNPRINTF(cmd, sizeof(cmd), "RA %c", c);
retval = kenwood_transaction(rig, cmd, buf, 7); retval = kenwood_transaction(rig, cmd, buf, 7);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1159,7 +1159,7 @@ static int thd74_set_mem(RIG *rig, vfo_t vfo, int ch)
return retval; return retval;
} }
sprintf(cmd, "MR %c,%03d", c, ch); SNPRINTF(cmd, sizeof(cmd), "MR %c,%03d", c, ch);
return kenwood_simple_transaction(rig, cmd, 8); return kenwood_simple_transaction(rig, cmd, 8);
} }
@ -1177,7 +1177,7 @@ static int thd74_get_mem(RIG *rig, vfo_t vfo, int *ch)
return retval; return retval;
} }
sprintf(cmd, "MR %c", c); SNPRINTF(cmd, sizeof(cmd), "MR %c", c);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1288,7 +1288,7 @@ static int thd74_get_channel(RIG *rig, vfo_t vfo, channel_t *chan,
{ {
int len; int len;
char cmd[16]; char cmd[16];
sprintf(cmd, "ME %03d", chan->channel_num); SNPRINTF(cmd, sizeof(cmd), "ME %03d", chan->channel_num);
retval = kenwood_transaction(rig, cmd, buf, sizeof(buf)); retval = kenwood_transaction(rig, cmd, buf, sizeof(buf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -1426,7 +1426,7 @@ int thd74_set_split_freq(RIG *rig, vfo_t vfo, freq_t tx_freq)
} }
tx_freq = thd74_round_freq(rig, RIG_VFO_A, tx_freq); tx_freq = thd74_round_freq(rig, RIG_VFO_A, tx_freq);
sprintf(fbuf, "%010"PRIll, (int64_t)tx_freq); SNPRINTF(fbuf, sizeof(fbuf), "%010"PRIll, (int64_t)tx_freq);
memcpy(buf + 5, fbuf, 10); memcpy(buf + 5, fbuf, 10);
return kenwood_simple_transaction(rig, buf, 72); return kenwood_simple_transaction(rig, buf, 72);
} }

4
rigs/kenwood/thg71.c
Wyświetl plik

@ -412,11 +412,11 @@ int thg71_set_vfo(RIG *rig, vfo_t vfo)
{ {
case RIG_VFO_A: case RIG_VFO_A:
case RIG_VFO_VFO: case RIG_VFO_VFO:
sprintf(vfobuf, "VMC 0,0"); SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 0,0");
break; break;
case RIG_VFO_MEM: case RIG_VFO_MEM:
sprintf(vfobuf, "VMC 0,2"); SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 0,2");
break; break;
default: default:

60
rigs/kenwood/tmv7.c
Wyświetl plik

@ -382,20 +382,20 @@ int tmv7_set_vfo(RIG *rig, vfo_t vfo)
{ {
case RIG_VFO_A: case RIG_VFO_A:
case RIG_VFO_VFO: case RIG_VFO_VFO:
sprintf(vfobuf, "VMC 0,0"); SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 0,0");
break; break;
case RIG_VFO_B: case RIG_VFO_B:
sprintf(vfobuf, "VMC 1,0"); SNPRINTF(vfobuf, sizeof(vfobuf), "VMC 1,0");
break; break;
case RIG_VFO_MEM: case RIG_VFO_MEM:
sprintf(vfobuf, "BC"); SNPRINTF(vfobuf, sizeof(vfobuf), "BC");
retval = kenwood_transaction(rig, vfobuf, ackbuf, sizeof(ackbuf)); retval = kenwood_transaction(rig, vfobuf, ackbuf, sizeof(ackbuf));
if (retval != RIG_OK) { return retval; } if (retval != RIG_OK) { return retval; }
sprintf(vfobuf, "VMC %c,2", ackbuf[3]); SNPRINTF(vfobuf, sizeof(vfobuf), "VMC %c,2", ackbuf[3]);
break; break;
default: default:
@ -418,11 +418,11 @@ int tmv7_set_vfo(RIG *rig, vfo_t vfo)
{ {
case RIG_VFO_A: case RIG_VFO_A:
case RIG_VFO_VFO: case RIG_VFO_VFO:
sprintf(vfobuf, "BC 0,0"); SNPRINTF(vfobuf, sizeof(vfobuf), "BC 0,0");
break; break;
case RIG_VFO_B: case RIG_VFO_B:
sprintf(vfobuf, "BC 1,1"); SNPRINTF(vfobuf, sizeof(vfobuf),"BC 1,1");
break; break;
case RIG_VFO_MEM: case RIG_VFO_MEM:
@ -517,35 +517,35 @@ int tmv7_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
else if (chan->channel_num < 204) else if (chan->channel_num < 204)
{ {
snprintf(req, sizeof(req), "MR 0,0,L%01d", chan->channel_num - 200); snprintf(req, sizeof(req), "MR 0,0,L%01d", chan->channel_num - 200);
sprintf(chan->channel_desc, "L%01d/V", chan->channel_num - 200); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "L%01d/V", chan->channel_num - 200);
} }
else if (chan->channel_num < 211) else if (chan->channel_num < 211)
{ {
snprintf(req, sizeof(req), "MR 1,0,L%01d", chan->channel_num - 203); snprintf(req, sizeof(req), "MR 1,0,L%01d", chan->channel_num - 203);
sprintf(chan->channel_desc, "L%01d/U", chan->channel_num - 203); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "L%01d/U", chan->channel_num - 203);
} }
else if (chan->channel_num < 214) else if (chan->channel_num < 214)
{ {
snprintf(req, sizeof(req), "MR 0,0,U%01d", chan->channel_num - 210); snprintf(req, sizeof(req), "MR 0,0,U%01d", chan->channel_num - 210);
sprintf(chan->channel_desc, "U%01d/V", chan->channel_num - 210); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "U%01d/V", chan->channel_num - 210);
} }
else if (chan->channel_num < 220) else if (chan->channel_num < 220)
{ {
snprintf(req, sizeof(req), "MR 1,0,U%01d", chan->channel_num - 213); snprintf(req, sizeof(req), "MR 1,0,U%01d", chan->channel_num - 213);
sprintf(chan->channel_desc, "U%01d/U", chan->channel_num - 213); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "U%01d/U", chan->channel_num - 213);
} }
else if (chan->channel_num < 223) else if (chan->channel_num < 223)
{ {
if (chan->channel_num == 221) if (chan->channel_num == 221)
{ {
snprintf(req, sizeof(req), "CR 0,0"); snprintf(req, sizeof(req), "CR 0,0");
sprintf(chan->channel_desc, "Call V"); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call V");
} }
if (chan->channel_num == 222) if (chan->channel_num == 222)
{ {
snprintf(req, sizeof(req), "CR 1,0"); snprintf(req, sizeof(req), "CR 1,0");
sprintf(chan->channel_desc, "Call U"); SNPRINTF(chan->channel_desc, sizeof(chan->channel_desc), "Call U");
} }
} }
else else
@ -618,7 +618,7 @@ int tmv7_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
if (chan->channel_num < 223 && shift == 0) if (chan->channel_num < 223 && shift == 0)
{ {
req[5] = '1'; req[5] = '1';
sprintf(membuf, "%s", req); SNPRINTF(membuf, sizeof(membuf), "%s", req);
retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf)); retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf));
if (retval == RIG_OK) if (retval == RIG_OK)
@ -634,11 +634,11 @@ int tmv7_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
{ {
if (chan->channel_num < 100) if (chan->channel_num < 100)
{ {
sprintf(membuf, "MNA 0,%03d", chan->channel_num); SNPRINTF(membuf, sizeof(membuf), "MNA 0,%03d", chan->channel_num);
} }
else else
{ {
sprintf(membuf, "MNA 1,%03d", chan->channel_num - 100); SNPRINTF(membuf, sizeof(membuf), "MNA 1,%03d", chan->channel_num - 100);
} }
retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf)); retval = kenwood_transaction(rig, membuf, ackbuf, sizeof(ackbuf));
@ -736,38 +736,38 @@ int tmv7_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan->channel_num < 100) if (chan->channel_num < 100)
{ {
sprintf(req, "MW 0,0,%03d", chan->channel_num); SNPRINTF(req, sizeof(req), "MW 0,0,%03d", chan->channel_num);
} }
else if (chan->channel_num < 200) else if (chan->channel_num < 200)
{ {
sprintf(req, "MW 1,0,%03d", chan->channel_num - 100); SNPRINTF(req, sizeof(req), "MW 1,0,%03d", chan->channel_num - 100);
} }
else if (chan->channel_num < 204) else if (chan->channel_num < 204)
{ {
sprintf(req, "MW 0,0,L%01d", chan->channel_num - 200); SNPRINTF(req, sizeof(req), "MW 0,0,L%01d", chan->channel_num - 200);
} }
else if (chan->channel_num < 211) else if (chan->channel_num < 211)
{ {
sprintf(req, "MW 1,0,L%01d", chan->channel_num - 203); SNPRINTF(req, sizeof(req), "MW 1,0,L%01d", chan->channel_num - 203);
} }
else if (chan->channel_num < 214) else if (chan->channel_num < 214)
{ {
sprintf(req, "MW 0,0,U%01d", chan->channel_num - 210); SNPRINTF(req, sizeof(req), "MW 0,0,U%01d", chan->channel_num - 210);
} }
else if (chan->channel_num < 220) else if (chan->channel_num < 220)
{ {
sprintf(req, "MW 1,0,U%01d", chan->channel_num - 213); SNPRINTF(req, sizeof(req), "MW 1,0,U%01d", chan->channel_num - 213);
} }
else if (chan->channel_num < 223) else if (chan->channel_num < 223)
{ {
if (chan->channel_num == 221) if (chan->channel_num == 221)
{ {
sprintf(req, "CW 0,0"); SNPRINTF(req, sizeof(req), "CW 0,0");
} }
if (chan->channel_num == 222) if (chan->channel_num == 222)
{ {
sprintf(req, "CW 1,0"); SNPRINTF(req, sizeof(req), "CW 1,0");
} }
} }
else else
@ -776,13 +776,17 @@ int tmv7_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
} }
if (chan->channel_num < 221) if (chan->channel_num < 221)
sprintf(membuf, "%s,%011ld,%01d,%01d,0,%01d,%01d,0,%02d,000,%02d,0,0", {
SNPRINTF(membuf, sizeof(membuf), "%s,%011ld,%01d,%01d,0,%01d,%01d,0,%02d,000,%02d,0,0",
req, (long)freq, step, shift, tone, req, (long)freq, step, shift, tone,
ctcss, tonefq, ctcssfq); ctcss, tonefq, ctcssfq);
}
else else
sprintf(membuf, "%s,%011ld,%01d,%01d,0,%01d,%01d,0,%02d,000,%02d,", {
SNPRINTF(membuf, sizeof(membuf), "%s,%011ld,%01d,%01d,0,%01d,%01d,0,%02d,000,%02d,",
req, (long)freq, step, shift, tone, req, (long)freq, step, shift, tone,
ctcss, tonefq, ctcssfq); ctcss, tonefq, ctcssfq);
}
retval = kenwood_transaction(rig, membuf, NULL, 0); retval = kenwood_transaction(rig, membuf, NULL, 0);
@ -795,7 +799,7 @@ int tmv7_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{ {
req[5] = '1'; req[5] = '1';
// cppcheck-suppress * // cppcheck-suppress *
sprintf(membuf, "%s,%011"PRIll",%01d", req, (int64_t)chan->tx_freq, step); SNPRINTF(membuf, sizeof(membuf), "%s,%011"PRIll",%01d", req, (int64_t)chan->tx_freq, step);
retval = kenwood_transaction(rig, membuf, NULL, 0); retval = kenwood_transaction(rig, membuf, NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -808,11 +812,11 @@ int tmv7_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{ {
if (chan->channel_num < 100) if (chan->channel_num < 100)
{ {
sprintf(membuf, "MNA 0,%03d,%s", chan->channel_num, chan->channel_desc); SNPRINTF(membuf, sizeof(membuf), "MNA 0,%03d,%s", chan->channel_num, chan->channel_desc);
} }
else else
{ {
sprintf(membuf, "MNA 1,%03d,%s", chan->channel_num - 100, chan->channel_desc); SNPRINTF(membuf, sizeof(membuf), "MNA 1,%03d,%s", chan->channel_num - 100, chan->channel_desc);
} }
retval = kenwood_transaction(rig, membuf, NULL, 0); retval = kenwood_transaction(rig, membuf, NULL, 0);

2
rigs/kenwood/ts140.c
Wyświetl plik

@ -71,7 +71,7 @@ static int ts140_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmdbuf, "FN%c", SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c",
vfo_function); /* The 680 and 140 need this to set the VFO on the radio */ vfo_function); /* The 680 and 140 need this to set the VFO on the radio */
return kenwood_transaction(rig, cmdbuf, NULL, 0); return kenwood_transaction(rig, cmdbuf, NULL, 0);
} }

4
rigs/kenwood/ts2000.c
Wyświetl plik

@ -388,7 +388,7 @@ int ts2000_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
} }
/* put channel num in the command string */ /* put channel num in the command string */
sprintf(cmd, "MR0%03d;", chan->channel_num); SNPRINTF(cmd, sizeof(cmd), "MR0%03d;", chan->channel_num);
err = kenwood_transaction(rig, cmd, buf, sizeof(buf)); err = kenwood_transaction(rig, cmd, buf, sizeof(buf));
@ -789,7 +789,7 @@ int ts2000_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan->split == RIG_SPLIT_ON) if (chan->split == RIG_SPLIT_ON)
{ {
sprintf(buf, "MW1%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;\n", SNPRINTF(buf, sizeof(buf), "MW1%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;\n",
chan->channel_num, chan->channel_num,
(unsigned) chan->tx_freq, /* 4 - frequency */ (unsigned) chan->tx_freq, /* 4 - frequency */
'0' + tx_mode, /* 5 - mode */ '0' + tx_mode, /* 5 - mode */

18
rigs/kenwood/ts480.c
Wyświetl plik

@ -313,7 +313,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{ {
case RIG_LEVEL_RF: case RIG_LEVEL_RF:
kenwood_val = val.f * 100; kenwood_val = val.f * 100;
sprintf(levelbuf, "RG%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "RG%03d", kenwood_val);
break; break;
case RIG_LEVEL_AF: case RIG_LEVEL_AF:
@ -321,7 +321,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
case RIG_LEVEL_SQL: case RIG_LEVEL_SQL:
kenwood_val = val.f * 255; kenwood_val = val.f * 255;
sprintf(levelbuf, "SQ0%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "SQ0%03d", kenwood_val);
break; break;
case RIG_LEVEL_AGC: case RIG_LEVEL_AGC:
@ -348,22 +348,22 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(levelbuf, "GT%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "GT%03d", kenwood_val);
break; break;
case RIG_LEVEL_MONITOR_GAIN: case RIG_LEVEL_MONITOR_GAIN:
kenwood_val = val.f * 9.0; kenwood_val = val.f * 9.0;
sprintf(levelbuf, "ML%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "ML%03d", kenwood_val);
break; break;
case RIG_LEVEL_NB: case RIG_LEVEL_NB:
kenwood_val = val.f * 10.0; kenwood_val = val.f * 10.0;
sprintf(levelbuf, "NL%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "NL%03d", kenwood_val);
break; break;
case RIG_LEVEL_NR: case RIG_LEVEL_NR:
kenwood_val = val.f * 9.0; kenwood_val = val.f * 9.0;
sprintf(levelbuf, "RL%02d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "RL%02d", kenwood_val);
break; break;
case RIG_LEVEL_PREAMP: case RIG_LEVEL_PREAMP:
@ -372,7 +372,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
RETURNFUNC(-RIG_EINVAL); RETURNFUNC(-RIG_EINVAL);
} }
sprintf(levelbuf, "PA%c", (val.i == 12) ? '1' : '0'); SNPRINTF(levelbuf, sizeof(levelbuf), "PA%c", (val.i == 12) ? '1' : '0');
break; break;
case RIG_LEVEL_ATT: case RIG_LEVEL_ATT:
@ -381,7 +381,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
RETURNFUNC(-RIG_EINVAL); RETURNFUNC(-RIG_EINVAL);
} }
sprintf(levelbuf, "RA%02d", (val.i == 12) ? 1 : 0); SNPRINTF(levelbuf, sizeof(levelbuf), "RA%02d", (val.i == 12) ? 1 : 0);
break; break;
case RIG_LEVEL_METER: case RIG_LEVEL_METER:
@ -403,7 +403,7 @@ int kenwood_ts480_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
RETURNFUNC(-RIG_EINVAL); RETURNFUNC(-RIG_EINVAL);
} }
sprintf(levelbuf, "RM%d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "RM%d", kenwood_val);
break; break;
case RIG_LEVEL_CWPITCH: case RIG_LEVEL_CWPITCH:

75
rigs/kenwood/ts570.c
Wyświetl plik

@ -190,7 +190,7 @@ static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(buf, "MD%c", kmode); SNPRINTF(buf, sizeof(buf), "MD%c", kmode);
retval = kenwood_transaction(rig, buf, NULL, 0); retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) { return retval; } if (retval != RIG_OK) { return retval; }
@ -203,7 +203,7 @@ static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
case RIG_MODE_CWR: case RIG_MODE_CWR:
case RIG_MODE_RTTY: case RIG_MODE_RTTY:
case RIG_MODE_RTTYR: case RIG_MODE_RTTYR:
sprintf(buf, "FW%04d", (int)width); SNPRINTF(buf, sizeof(buf), "FW%04d", (int)width);
retval = kenwood_transaction(rig, buf, NULL, 0); retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) { return retval; } if (retval != RIG_OK) { return retval; }
@ -214,7 +214,7 @@ static int ts570_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
case RIG_MODE_LSB: case RIG_MODE_LSB:
case RIG_MODE_FM: case RIG_MODE_FM:
case RIG_MODE_AM: case RIG_MODE_AM:
sprintf(buf, "SL%02d", (int)width / 50); SNPRINTF(buf, sizeof(buf), "SL%02d", (int)width / 50);
retval = kenwood_transaction(rig, buf, NULL, 0); retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) { return retval; } if (retval != RIG_OK) { return retval; }
@ -249,11 +249,11 @@ int ts570_set_func(RIG *rig, vfo_t vfo, setting_t func, int status)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(fctbuf, "NR%01d", status); SNPRINTF(fctbuf, sizeof(fctbuf), "NR%01d", status);
return kenwood_transaction(rig, fctbuf, NULL, 0); return kenwood_transaction(rig, fctbuf, NULL, 0);
case RIG_FUNC_TUNER: case RIG_FUNC_TUNER:
sprintf(fctbuf, "AC %c0", (0 == status) ? '0' : '1'); SNPRINTF(fctbuf, sizeof(fctbuf), "AC %c0", (0 == status) ? '0' : '1');
return kenwood_transaction(rig, fctbuf, NULL, 0); return kenwood_transaction(rig, fctbuf, NULL, 0);
default: default:
@ -346,7 +346,7 @@ ts570_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
/* set the preamplifier if a correct value is entered */ /* set the preamplifier if a correct value is entered */
if (kenwood_val == 0) if (kenwood_val == 0)
{ {
sprintf(levelbuf, "PA0"); SNPRINTF(levelbuf, sizeof(levelbuf), "PA0");
} }
else else
{ {
@ -355,7 +355,7 @@ ts570_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
for (i = 0; i < HAMLIB_MAXDBLSTSIZ; i++) for (i = 0; i < HAMLIB_MAXDBLSTSIZ; i++)
if (kenwood_val == rig->state.preamp[i]) if (kenwood_val == rig->state.preamp[i])
{ {
sprintf(levelbuf, "PA%01d", i + 1); SNPRINTF(levelbuf, sizeof(levelbuf), "PA%01d", i + 1);
break; /* found - stop searching */ break; /* found - stop searching */
} }
else else
@ -369,13 +369,13 @@ ts570_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
case RIG_LEVEL_RFPOWER: case RIG_LEVEL_RFPOWER:
/* level for TS570D is from 0.. 100W in SSB and CW */ /* level for TS570D is from 0.. 100W in SSB and CW */
kenwood_val = val.f * 100; kenwood_val = val.f * 100;
sprintf(levelbuf, "PC%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "PC%03d", kenwood_val);
return kenwood_transaction(rig, levelbuf, NULL, 0); return kenwood_transaction(rig, levelbuf, NULL, 0);
case RIG_LEVEL_MICGAIN: case RIG_LEVEL_MICGAIN:
/* level is from 0..100 */ /* level is from 0..100 */
kenwood_val = val.f * 100; kenwood_val = val.f * 100;
sprintf(levelbuf, "MG%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "MG%03d", kenwood_val);
return kenwood_transaction(rig, levelbuf, NULL, 0); return kenwood_transaction(rig, levelbuf, NULL, 0);
default: default:
@ -561,7 +561,7 @@ int ts570_get_split_vfo(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo)
int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo) int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
{ {
char cmdbuf[16], ackbuf[20]; char cmdbuf[16], ackbuf[20];
int cmd_len, retval; int retval;
unsigned char vfo_function; unsigned char vfo_function;
if (vfo != RIG_VFO_CURR) if (vfo != RIG_VFO_CURR)
@ -582,12 +582,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
} }
/* set RX VFO */ /* set RX VFO */
cmd_len = sprintf(cmdbuf, "FR%c%c", vfo_function, cmd_trm(rig)); SNPRINTF(cmdbuf, sizeof(cmdbuf), "FR%c%c", vfo_function, cmd_trm(rig));
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
retval = kenwood_transaction(rig, cmdbuf, NULL, 0); retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -629,12 +624,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
} }
/* set TX VFO */ /* set TX VFO */
cmd_len = sprintf(cmdbuf, "FT%c%c", vfo_function, cmd_trm(rig)); SNPRINTF(cmdbuf, sizeof(cmdbuf), "FT%c%c", vfo_function, cmd_trm(rig));
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
retval = kenwood_transaction(rig, cmdbuf, NULL, 0); retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -658,12 +648,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
/* and then set it to both vfo's */ /* and then set it to both vfo's */
vfo_function = ackbuf[2]; vfo_function = ackbuf[2];
cmd_len = sprintf(cmdbuf, "FT%c%c", vfo_function, cmd_trm(rig)); SNPRINTF(cmdbuf, sizeof(cmdbuf), "FT%c%c", vfo_function, cmd_trm(rig));
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
retval = kenwood_transaction(rig, cmdbuf, NULL, 0); retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -691,7 +676,7 @@ int ts570_set_split_vfo(RIG *rig, vfo_t vfo, split_t split, vfo_t txvfo)
int ts570_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan) int ts570_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
{ {
char cmdbuf[30]; char cmdbuf[30];
int retval, cmd_len; int retval;
int num, freq, tx_freq, tone; int num, freq, tx_freq, tone;
char mode, tx_mode, tones; char mode, tx_mode, tones;
@ -728,14 +713,9 @@ int ts570_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
tone = 0; tone = 0;
} }
cmd_len = sprintf(cmdbuf, "MW0 %02d%011d%c0%c%02d ", SNPRINTF(cmdbuf, sizeof(cmdbuf), "MW0 %02d%011d%c0%c%02d ",
num, freq, mode, tones, tone); num, freq, mode, tones, tone);
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
retval = kenwood_transaction(rig, cmdbuf, NULL, 0); retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -743,14 +723,9 @@ int ts570_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
return retval; return retval;
} }
cmd_len = sprintf(cmdbuf, "MW1 %02d%011d%c0%c%02d ", SNPRINTF(cmdbuf, sizeof(cmdbuf), "MW1 %02d%011d%c0%c%02d ",
num, tx_freq, tx_mode, tones, tone); num, tx_freq, tx_mode, tones, tone);
if (cmd_len < 0)
{
return -RIG_ETRUNC;
}
retval = kenwood_transaction(rig, cmdbuf, NULL, 0); retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -799,7 +774,7 @@ int ts570_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
{ {
char buf[50]; char buf[50];
unsigned char c; unsigned char c;
int retval, len, i; int retval, i;
if (rit == 0) if (rit == 0)
{ {
@ -833,12 +808,7 @@ int ts570_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
c = 'D'; c = 'D';
} }
len = sprintf(buf, "R%c", c); SNPRINTF(buf, sizeof(buf), "R%c", c);
if (len < 0)
{
return -RIG_ETRUNC;
}
retval = kenwood_transaction(rig, "RC", NULL, 0); retval = kenwood_transaction(rig, "RC", NULL, 0);
@ -864,7 +834,7 @@ int ts570_set_xit(RIG *rig, vfo_t vfo, shortfreq_t rit)
{ {
char buf[50]; char buf[50];
unsigned char c; unsigned char c;
int retval, len, i; int retval, i;
if (rit == 0) if (rit == 0)
{ {
@ -898,12 +868,7 @@ int ts570_set_xit(RIG *rig, vfo_t vfo, shortfreq_t rit)
c = 'D'; c = 'D';
} }
len = sprintf(buf, "R%c", c); SNPRINTF(buf, sizeof(buf), "R%c", c);
if (len < 0)
{
return -RIG_ETRUNC;
}
retval = kenwood_transaction(rig, "RC", NULL, 0); retval = kenwood_transaction(rig, "RC", NULL, 0);

2
rigs/kenwood/ts680.c
Wyświetl plik

@ -71,7 +71,7 @@ static int ts680_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmdbuf, "FN%c", SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c",
vfo_function); /* The 680 and 140 need this to set the VFO on the radio */ vfo_function); /* The 680 and 140 need this to set the VFO on the radio */
return kenwood_transaction(rig, cmdbuf, NULL, 0); return kenwood_transaction(rig, cmdbuf, NULL, 0);
} }

2
rigs/kenwood/ts711.c
Wyświetl plik

@ -90,7 +90,7 @@ ts711_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmdbuf, "FN%c", vfo_function); SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c", vfo_function);
return kenwood_transaction(rig, cmdbuf, NULL, 0); return kenwood_transaction(rig, cmdbuf, NULL, 0);
} }

2
rigs/kenwood/ts811.c
Wyświetl plik

@ -76,7 +76,7 @@ ts811_set_vfo(RIG *rig, vfo_t vfo)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmdbuf, "FN%c", vfo_function); SNPRINTF(cmdbuf, sizeof(cmdbuf), "FN%c", vfo_function);
return kenwood_transaction(rig, cmdbuf, NULL, 0); return kenwood_transaction(rig, cmdbuf, NULL, 0);
} }

8
rigs/kenwood/ts850.c
Wyświetl plik

@ -287,7 +287,7 @@ int ts850_set_rit(RIG *rig, vfo_t vfo, shortfreq_t rit)
c = 'D'; c = 'D';
} }
sprintf(buf, "R%c", c); SNPRINTF(buf, sizeof(buf), "R%c", c);
retval = kenwood_transaction(rig, "RC", NULL, 0); retval = kenwood_transaction(rig, "RC", NULL, 0);
@ -350,7 +350,7 @@ int ts850_set_xit(RIG *rig, vfo_t vfo, shortfreq_t xit)
c = 'D'; c = 'D';
} }
sprintf(buf, "R%c", c); SNPRINTF(buf, sizeof(buf), "R%c", c);
for (i = 0; i < labs(lrint(xit / 20)); i++) for (i = 0; i < labs(lrint(xit / 20)); i++)
{ {
@ -553,7 +553,7 @@ int ts850_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
tone = 0; tone = 0;
} }
sprintf(cmdbuf, "MW0 %02d%011d%c0%c%02d ", SNPRINTF(cmdbuf, sizeof(cmdbuf), "MW0 %02d%011d%c0%c%02d ",
num, freq, mode, tones, tone); num, freq, mode, tones, tone);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0); retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -562,7 +562,7 @@ int ts850_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
return retval; return retval;
} }
sprintf(cmdbuf, "MW1 %02d%011d%c0%c%02d ", SNPRINTF(cmdbuf, sizeof(cmdbuf), "MW1 %02d%011d%c0%c%02d ",
num, tx_freq, tx_mode, tones, tone); num, tx_freq, tx_mode, tones, tone);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0); retval = kenwood_transaction(rig, cmdbuf, NULL, 0);

8
rigs/kenwood/ts870s.c
Wyświetl plik

@ -223,7 +223,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(buf, "MD%c", kmode); SNPRINTF(buf, sizeof(buf), "MD%c", kmode);
retval = kenwood_transaction(rig, buf, NULL, 0); retval = kenwood_transaction(rig, buf, NULL, 0);
if (retval != RIG_OK) { return retval; } if (retval != RIG_OK) { return retval; }
@ -248,7 +248,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
mode_default_hpf = 100; mode_default_hpf = 100;
} }
sprintf(buf, "IS %04d", (int)(width + mode_default_hpf)); SNPRINTF(buf, sizeof(buf), "IS %04d", (int)(width + mode_default_hpf));
retval = kenwood_transaction(rig, buf, NULL, 0); retval = kenwood_transaction(rig, buf, NULL, 0);
} }
else else
@ -257,7 +257,7 @@ static int ts870s_set_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
* This rig will simply use an IF bandpass which is closest to width, * This rig will simply use an IF bandpass which is closest to width,
* so we don't need to check the value... * so we don't need to check the value...
*/ */
sprintf(buf, "FW%04d", (int)width / 10); SNPRINTF(buf, sizeof(buf), "FW%04d", (int)width / 10);
retval = kenwood_transaction(rig, buf, NULL, 0); retval = kenwood_transaction(rig, buf, NULL, 0);
} }
} }
@ -275,7 +275,7 @@ int ts870s_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{ {
case RIG_LEVEL_RFPOWER: case RIG_LEVEL_RFPOWER:
intval = val.f * 100; intval = val.f * 100;
sprintf(levelbuf, "PC%03d", intval); SNPRINTF(levelbuf, sizeof(levelbuf), "PC%03d", intval);
return kenwood_transaction(rig, levelbuf, NULL, 0); return kenwood_transaction(rig, levelbuf, NULL, 0);
break; break;

6
rigs/kenwood/ts890s.c
Wyświetl plik

@ -54,12 +54,12 @@ int kenwood_ts890_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
{ {
case RIG_LEVEL_RF: case RIG_LEVEL_RF:
kenwood_val = val.f * 255; kenwood_val = val.f * 255;
sprintf(levelbuf, "RG%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "RG%03d", kenwood_val);
break; break;
case RIG_LEVEL_SQL: case RIG_LEVEL_SQL:
kenwood_val = val.f * 255; kenwood_val = val.f * 255;
sprintf(levelbuf, "SQ%03d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "SQ%03d", kenwood_val);
break; break;
case RIG_LEVEL_AGC: case RIG_LEVEL_AGC:
@ -94,7 +94,7 @@ int kenwood_ts890_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(levelbuf, "GC%d", kenwood_val); SNPRINTF(levelbuf, sizeof(levelbuf), "GC%d", kenwood_val);
break; break;
default: default:

12
rigs/kenwood/ts990s.c
Wyświetl plik

@ -418,7 +418,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmd, "RA%c", v); SNPRINTF(cmd, sizeof(cmd), "RA%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 4); retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 4);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -465,7 +465,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmd, "AG%c", v); SNPRINTF(cmd, sizeof(cmd), "AG%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 6); retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 6);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -494,7 +494,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmd, "RG%c", v); SNPRINTF(cmd, sizeof(cmd), "RG%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 6); retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 6);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -523,7 +523,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmd, "SQ%c", v); SNPRINTF(cmd, sizeof(cmd), "SQ%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 6); retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 6);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -605,7 +605,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmd, "GC%c", v); SNPRINTF(cmd, sizeof(cmd), "GC%c", v);
if (RIG_OK != (retval = kenwood_safe_transaction(rig, cmd, lvlbuf, if (RIG_OK != (retval = kenwood_safe_transaction(rig, cmd, lvlbuf,
sizeof(lvlbuf), 4))) sizeof(lvlbuf), 4)))
@ -701,7 +701,7 @@ int ts990s_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmd, "SM%c", v); SNPRINTF(cmd, sizeof(cmd), "SM%c", v);
retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 7); retval = kenwood_safe_transaction(rig, cmd, lvlbuf, sizeof(lvlbuf), 7);
if (retval != RIG_OK) if (retval != RIG_OK)

4
rigs/kenwood/tx500.c
Wyświetl plik

@ -387,7 +387,7 @@ int ts2000_get_channel(RIG *rig, vfo_t vfo, channel_t *chan, int read_only)
} }
/* put channel num in the command string */ /* put channel num in the command string */
sprintf(cmd, "MR0%03d;", chan->channel_num); SNPRINTF(cmd, sizeof(cmd), "MR0%03d;", chan->channel_num);
err = kenwood_transaction(rig, cmd, buf, sizeof(buf)); err = kenwood_transaction(rig, cmd, buf, sizeof(buf));
@ -788,7 +788,7 @@ int ts2000_set_channel(RIG *rig, vfo_t vfo, const channel_t *chan)
if (chan->split == RIG_SPLIT_ON) if (chan->split == RIG_SPLIT_ON)
{ {
sprintf(buf, "MW1%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;\n", SNPRINTF(buf, sizeof(buf), "MW1%03d%011u%c%c%c%02d%02d%03d%c%c%09d0%c%c%s;\n",
chan->channel_num, chan->channel_num,
(unsigned) chan->tx_freq, /* 4 - frequency */ (unsigned) chan->tx_freq, /* 4 - frequency */
'0' + tx_mode, /* 5 - mode */ '0' + tx_mode, /* 5 - mode */

18
rigs/kenwood/xg3.c
Wyświetl plik

@ -248,7 +248,7 @@ int xg3_set_level(RIG *rig, vfo_t vfo, setting_t level, value_t val)
} }
/* XXX check level range */ /* XXX check level range */
sprintf(levelbuf, "L,%02d", (int)val.f); SNPRINTF(levelbuf, sizeof(levelbuf), "L,%02d", (int)val.f);
break; break;
default: default:
@ -275,7 +275,7 @@ int xg3_get_level(RIG *rig, vfo_t vfo, setting_t level, value_t *val)
switch (level) switch (level)
{ {
case RIG_LEVEL_RFPOWER: case RIG_LEVEL_RFPOWER:
sprintf(cmdbuf, "L;"); SNPRINTF(cmdbuf, sizeof(cmdbuf), "L;");
retval = write_block(&rs->rigport, (unsigned char *) cmdbuf, strlen(cmdbuf)); retval = write_block(&rs->rigport, (unsigned char *) cmdbuf, strlen(cmdbuf));
if (retval != RIG_OK) if (retval != RIG_OK)
@ -395,11 +395,11 @@ int xg3_set_freq(RIG *rig, vfo_t vfo, freq_t freq)
{ {
int ch; int ch;
xg3_get_mem(rig, vfo, &ch); xg3_get_mem(rig, vfo, &ch);
sprintf(cmdbuf, "M,%02d,%011ld", ch, (long)freq); SNPRINTF(cmdbuf, sizeof(cmdbuf), "M,%02d,%011ld", ch, (long)freq);
} }
else else
{ {
sprintf(cmdbuf, "F,%011ld", (long)freq); SNPRINTF(cmdbuf, sizeof(cmdbuf), "F,%011ld", (long)freq);
} }
err = kenwood_transaction(rig, cmdbuf, NULL, 0); err = kenwood_transaction(rig, cmdbuf, NULL, 0);
@ -448,11 +448,11 @@ int xg3_get_freq(RIG *rig, vfo_t vfo, freq_t *freq)
{ {
int ch; int ch;
xg3_get_mem(rig, vfo, &ch); xg3_get_mem(rig, vfo, &ch);
sprintf(cmdbuf, "M,%02d;", ch); SNPRINTF(cmdbuf, sizeof(cmdbuf), "M,%02d;", ch);
} }
else else
{ {
sprintf(cmdbuf, "F;"); SNPRINTF(cmdbuf, sizeof(cmdbuf), "F;");
} }
retval = write_block(&rs->rigport, (unsigned char *) cmdbuf, strlen(cmdbuf)); retval = write_block(&rs->rigport, (unsigned char *) cmdbuf, strlen(cmdbuf));
@ -548,7 +548,7 @@ int xg3_set_mem(RIG *rig, vfo_t vfo, int ch)
return -RIG_EINVAL; return -RIG_EINVAL;
} }
sprintf(cmdbuf, "C,%02d;", ch); SNPRINTF(cmdbuf, sizeof(cmdbuf), "C,%02d;", ch);
retval = kenwood_transaction(rig, cmdbuf, NULL, 0); retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -573,7 +573,7 @@ int xg3_get_mem(RIG *rig, vfo_t vfo, int *ch)
rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__); rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
sprintf(cmdbuf, "C;"); SNPRINTF(cmdbuf, sizeof(cmdbuf), "C;");
retval = kenwood_transaction(rig, cmdbuf, NULL, 0); retval = kenwood_transaction(rig, cmdbuf, NULL, 0);
if (retval != RIG_OK) if (retval != RIG_OK)
@ -660,7 +660,7 @@ int xg3_set_parm(RIG *rig, setting_t parm, value_t val)
case RIG_PARM_BACKLIGHT: case RIG_PARM_BACKLIGHT:
ival = 3 - (int)(val.f * 3); // gives us 0-3 bright-to-dim ival = 3 - (int)(val.f * 3); // gives us 0-3 bright-to-dim
rig_debug(RIG_DEBUG_ERR, "%s: BACKLIGHT %d\n", __func__, ival); rig_debug(RIG_DEBUG_ERR, "%s: BACKLIGHT %d\n", __func__, ival);
sprintf(cmdbuf, "G,%02d", ival); SNPRINTF(cmdbuf, sizeof(cmdbuf), "G,%02d", ival);
retval = kenwood_simple_transaction(rig, cmdbuf, 0); retval = kenwood_simple_transaction(rig, cmdbuf, 0);
break; break;