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

More pointerizations in src/*

pull/1573/head
George Baltz N3GB 2024-06-30 16:41:00 -04:00
rodzic 5b8cc94b01
commit 00bc700ec1
5 zmienionych plików z 134 dodań i 109 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

33
src/cache.c
Wyświetl plik

@ -24,7 +24,7 @@
#include "cache.h"
#include "misc.h"
#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state)
#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !STATE(r)->comm_state)
/**
* \file cache.c
@ -35,6 +35,7 @@
int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
{
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
ENTERFUNC;
@ -43,16 +44,16 @@ int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
if (vfo == RIG_VFO_CURR)
{
// if CURR then update this before we figure out the real VFO
vfo = rig->state.current_vfo;
vfo = rs->current_vfo;
}
else if (vfo == RIG_VFO_TX)
{
vfo = rig->state.tx_vfo;
vfo = rs->tx_vfo;
rig_debug(RIG_DEBUG_VERBOSE, "%s: TX VFO = %s\n", __func__, rig_strvfo(vfo));
}
else if (vfo == RIG_VFO_RX)
{
vfo = rig->state.rx_vfo;
vfo = rs->rx_vfo;
rig_debug(RIG_DEBUG_VERBOSE, "%s: RX VFO = %s\n", __func__, rig_strvfo(vfo));
}
@ -63,7 +64,7 @@ int rig_set_cache_mode(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
if (vfo == RIG_VFO_OTHER) { vfo = vfo_fixup(rig, vfo, cachep->split); }
if (vfo == rig->state.current_vfo)
if (vfo == rs->current_vfo)
{
cachep->modeCurr = mode;
if (width > 0)
@ -157,6 +158,7 @@ int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq)
{
int flag = HAMLIB_ELAPSED_SET;
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
if (rig_need_debug(RIG_DEBUG_CACHE))
{
@ -165,12 +167,12 @@ int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq)
rig_debug(RIG_DEBUG_CACHE, "%s(%d): vfo=%s, current_vfo=%s\n", __func__,
__LINE__,
rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo));
rig_strvfo(vfo), rig_strvfo(rs->current_vfo));
if (vfo == RIG_VFO_CURR)
{
// if CURR then update this before we figure out the real VFO
vfo = rig->state.current_vfo;
vfo = rs->current_vfo;
}
// if freq == 0 then we are asking to invalidate the cache
@ -188,7 +190,7 @@ int rig_set_cache_freq(RIG *rig, vfo_t vfo, freq_t freq)
rig_strvfo(vfo), freq);
}
if (vfo == rig->state.current_vfo)
if (vfo == rs->current_vfo)
{
cachep->freqCurr = freq;
elapsed_ms(&cachep->time_freqCurr, flag);
@ -307,6 +309,7 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
rmode_t *mode, int *cache_ms_mode, pbwidth_t *width, int *cache_ms_width)
{
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
if (CHECK_RIG_ARG(rig) || !freq || !cache_ms_freq ||
!mode || !cache_ms_mode || !width || !cache_ms_width)
@ -321,25 +324,25 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
rig_debug(RIG_DEBUG_CACHE, "%s(%d): vfo=%s, current_vfo=%s\n", __func__,
__LINE__,
rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo));
rig_strvfo(vfo), rig_strvfo(rs->current_vfo));
if (vfo == RIG_VFO_CURR)
{
vfo = rig->state.current_vfo;
vfo = rs->current_vfo;
}
else if (vfo == RIG_VFO_TX)
{
vfo = rig->state.tx_vfo;
vfo = rs->tx_vfo;
rig_debug(RIG_DEBUG_VERBOSE, "%s: TX VFO = %s\n", __func__, rig_strvfo(vfo));
}
else if (vfo == RIG_VFO_RX)
{
vfo = rig->state.rx_vfo;
vfo = rs->rx_vfo;
rig_debug(RIG_DEBUG_VERBOSE, "%s: RX VFO = %s\n", __func__, rig_strvfo(vfo));
}
else if (vfo == RIG_VFO_OTHER)
{
switch (rig->state.current_vfo)
switch (rs->current_vfo)
{
case RIG_VFO_CURR:
break; // no change
@ -384,7 +387,7 @@ int rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int *cache_ms_freq,
default:
rig_debug(RIG_DEBUG_WARN, "%s(%d): unknown vfo=%s, curr_vfo=%s\n", __func__,
__LINE__,
rig_strvfo(vfo), rig_strvfo(rig->state.current_vfo));
rig_strvfo(vfo), rig_strvfo(rs->current_vfo));
}
}
@ -574,7 +577,7 @@ void rig_cache_show(RIG *rig, const char *func, int line)
cachep->freqMainB, rig_strrmode(cachep->modeMainB),
(int)cachep->widthMainB);
if (rig->state.vfo_list & RIG_VFO_SUB_A)
if (STATE(rig)->vfo_list & RIG_VFO_SUB_A)
{
rig_debug(RIG_DEBUG_CACHE,
"%s(%d): freqSubA=%.0f, modeSubA=%s, widthSubA=%d\n", func, line,

30
src/misc.h
Wyświetl plik

@ -30,11 +30,11 @@
*/
#ifdef HAVE_PTHREAD
#include <pthread.h>
#define set_transaction_active(rig) {pthread_mutex_lock(&rig->state.mutex_set_transaction);(rig)->state.transaction_active = 1;}
#define set_transaction_inactive(rig) {(rig)->state.transaction_active = 0;pthread_mutex_unlock(&rig->state.mutex_set_transaction);}
#define set_transaction_active(rig) {pthread_mutex_lock(&STATE(rig)->mutex_set_transaction);STATE(rig)->transaction_active = 1;}
#define set_transaction_inactive(rig) {STATE(rig)->transaction_active = 0;pthread_mutex_unlock(&STATE(rig)->mutex_set_transaction);}
#else
#define set_transaction_active(rig) {(rig)->state.transaction_active = 1;}
#define set_transaction_inactive(rig) {(rig)->state.transaction_active = 0;}
#define set_transaction_active(rig) {STATE(rig)->transaction_active = 1;}
#define set_transaction_inactive(rig) {STATE(rig)->transaction_active = 0;}
#endif
__BEGIN_DECLS
@ -157,24 +157,24 @@ extern HAMLIB_EXPORT(char *)date_strget(char *buf, int buflen, int localtime);
#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
void errmsg(int err, char *s, const char *func, const char *file, int line);
#define ERRMSG(err, s) errmsg(err, s, __func__, __FILENAME__, __LINE__)
#define ENTERFUNC { ++rig->state.depth; \
rig_debug(RIG_DEBUG_VERBOSE, "%s%d:%s(%d):%s entered\n", spaces(rig->state.depth), rig->state.depth, __FILENAME__, __LINE__, __func__); \
#define ENTERFUNC { ++STATE(rig)->depth; \
rig_debug(RIG_DEBUG_VERBOSE, "%s%d:%s(%d):%s entered\n", spaces(STATE(rig)->depth), STATE(rig)->depth, __FILENAME__, __LINE__, __func__); \
}
#define ENTERFUNC2 { rig_debug(RIG_DEBUG_VERBOSE, "%s(%d):%s entered\n", __FILENAME__, __LINE__, __func__); \
}
// we need to refer to rc just once as it
// could be a function call
#define RETURNFUNC(rc) {do { \
int rctmp = rc; \
rig_debug(RIG_DEBUG_VERBOSE, "%s%d:%s(%d):%s returning(%ld) %s\n", spaces(rig->state.depth), rig->state.depth, __FILENAME__, __LINE__, __func__, (long int) (rctmp), rctmp<0?rigerror2(rctmp):""); \
--rig->state.depth; \
return (rctmp); \
} while(0);}
int rctmp = rc; \
rig_debug(RIG_DEBUG_VERBOSE, "%s%d:%s(%d):%s returning(%ld) %s\n", spaces(STATE(rig)->depth), STATE(rig)->depth, __FILENAME__, __LINE__, __func__, (long int) (rctmp), rctmp<0?rigerror2(rctmp):""); \
--STATE(rig)->depth; \
return (rctmp); \
} while(0);}
#define RETURNFUNC2(rc) {do { \
int rctmp = rc; \
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d):%s returning2(%ld) %s\n", __FILENAME__, __LINE__, __func__, (long int) (rctmp), rctmp<0?rigerror2(rctmp):""); \
return (rctmp); \
} while(0);}
int rctmp = rc; \
rig_debug(RIG_DEBUG_VERBOSE, "%s(%d):%s returning2(%ld) %s\n", __FILENAME__, __LINE__, __func__, (long int) (rctmp), rctmp<0?rigerror2(rctmp):""); \
return (rctmp); \
} while(0);}
#define CACHE_RESET {\
elapsed_ms(&CACHE(rig)->time_freqMainA, HAMLIB_ELAPSED_INVALIDATE);\

119
src/multicast.c
Wyświetl plik

@ -33,9 +33,10 @@ static struct sockaddr_in dest_addr = {0};
int multicast_stop(RIG *rig)
{
if (rig->state.multicast) { rig->state.multicast->runflag = 0; }
struct rig_state *rs = STATE(rig);
if (rs->multicast) { rs->multicast->runflag = 0; }
pthread_join(rig->state.multicast->threadid, NULL);
pthread_join(rs->multicast->threadid, NULL);
return RIG_OK;
}
@ -44,6 +45,7 @@ static int multicast_status_changed(RIG *rig)
{
int retval;
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
#if 0
freq_t freq, freqsave = cachep->freqMainA;
@ -63,7 +65,7 @@ static int multicast_status_changed(RIG *rig)
#if 0
if (rig->state.multicast->seqnumber % 2 == 0
if (rs->multicast->seqnumber % 2 == 0
&& (retval = rig_get_mode(rig, RIG_VFO_A, &modeA, &widthA)) != RIG_OK)
{
rig_debug(RIG_DEBUG_ERR, "%s: rig_get_modeA:%s\n", __func__, rigerror(retval));
@ -77,7 +79,7 @@ static int multicast_status_changed(RIG *rig)
#if 0
if (rig->state.multicast->seqnumber % 2 == 0
if (rs->multicast->seqnumber % 2 == 0
&& (rig->caps->targetable_vfo & RIG_TARGETABLE_MODE)
&& (retval = rig_get_mode(rig, RIG_VFO_B, &modeB, &widthB)) != RIG_OK)
{
@ -94,14 +96,14 @@ static int multicast_status_changed(RIG *rig)
#if 0
if (rig->state.multicast->seqnumber % 2 == 0
if (rs->multicast->seqnumber % 2 == 0
&& (retval = rig_get_ptt(rig, RIG_VFO_CURR, &ptt)) != RIG_OK)
if (ptt != pttsave) { return 1; }
split_t split, splitsave = cachep->split;
vfo_t txvfo;
if (rig->state.multicast->seqnumber % 2 == 0
if (rs->multicast->seqnumber % 2 == 0
&& (retval = rig_get_split_vfo(rig, RIG_VFO_CURR, &split, &txvfo)) != RIG_OK)
if (split != splitsave) { return 1; }
@ -192,6 +194,7 @@ void json_add_time(char *msg, int addComma)
void json_add_vfoA(RIG *rig, char *msg)
{
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
strcat(msg, "{\n");
json_add_string(msg, "Name", "VFOA", 1);
@ -211,15 +214,15 @@ void json_add_vfoA(RIG *rig, char *msg)
#if 0 // not working quite yet
// what about full duplex? rx_vfo would be in rx all the time?
rig_debug(RIG_DEBUG_ERR, "%s: rx_vfo=%s, tx_vfo=%s, split=%d\n", __func__,
rig_strvfo(rig->state.rx_vfo), rig_strvfo(rig->state.tx_vfo),
rig_strvfo(rs->rx_vfo), rig_strvfo(rs->tx_vfo),
cachep->split);
printf("%s: rx_vfo=%s, tx_vfo=%s, split=%d\n", __func__,
rig_strvfo(rig->state.rx_vfo), rig_strvfo(rig->state.tx_vfo),
rig_strvfo(rs->rx_vfo), rig_strvfo(rs->tx_vfo),
cachep->split);
if (cachep->split)
{
if (rig->state.tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B))
if (rs->tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B))
{
json_add_boolean(msg, "RX", !cachep->ptt, 1);
json_add_boolean(msg, "TX", 0, 0);
@ -230,7 +233,7 @@ void json_add_vfoA(RIG *rig, char *msg)
json_add_boolean(msg, "TX", cachep->ptt, 0);
}
}
else if (rig->state.current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A))
else if (rs->current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A))
{
json_add_boolean(msg, "RX", !cachep->ptt, 1);
json_add_boolean(msg, "TX", cachep->ptt, 0);
@ -248,6 +251,7 @@ void json_add_vfoA(RIG *rig, char *msg)
void json_add_vfoB(RIG *rig, char *msg)
{
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
strcat(msg, ",\n{\n");
json_add_string(msg, "Name", "VFOB", 1);
@ -266,9 +270,9 @@ void json_add_vfoB(RIG *rig, char *msg)
#if 0 // not working yet
if (rig->state.rx_vfo != rig->state.tx_vfo && cachep->split)
if (rs->rx_vfo != rs->tx_vfo && cachep->split)
{
if (rig->state.tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B))
if (rs->tx_vfo && (RIG_VFO_B | RIG_VFO_MAIN_B))
{
json_add_boolean(msg, "RX", 0, 1);
json_add_boolean(msg, "TX", cachep->ptt, 0);
@ -279,7 +283,7 @@ void json_add_vfoB(RIG *rig, char *msg)
json_add_boolean(msg, "TX", 0, 0);
}
}
else if (rig->state.current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A))
else if (rs->current_vfo && (RIG_VFO_A | RIG_VFO_MAIN_A))
{
json_add_boolean(msg, "RX", !cachep->ptt, 1);
json_add_boolean(msg, "TX", cachep->ptt, 0);
@ -300,7 +304,8 @@ static int multicast_send_json(RIG *rig)
char msg[8192]; // could be pretty big
char buf[4096];
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
// sprintf(msg,"%s:f=%.1f", date_strget(msg, (int)sizeof(msg), 0), f);
msg[0] = 0;
snprintf(buf, sizeof(buf), "%s:%s", rig->caps->model_name,
@ -308,11 +313,11 @@ static int multicast_send_json(RIG *rig)
strcat(msg, "{\n");
json_add_string(msg, "ID", buf, 1);
json_add_time(msg, 1);
json_add_int(msg, "Sequence", rig->state.multicast->seqnumber++, 1);
json_add_string(msg, "VFOCurr", rig_strvfo(rig->state.current_vfo), 1);
json_add_int(msg, "Sequence", rs->multicast->seqnumber++, 1);
json_add_string(msg, "VFOCurr", rig_strvfo(rs->current_vfo), 1);
json_add_int(msg, "PTT", cachep->ptt, 1);
json_add_int(msg, "Split", cachep->split, 1);
rig_sprintf_mode(buf, sizeof(buf), rig->state.mode_list);
rig_sprintf_mode(buf, sizeof(buf), rs->mode_list);
json_add_string(msg, "ModeList", buf, 1);
strcat(msg, "\"VFOs\": [\n");
json_add_vfoA(rig, msg);
@ -333,17 +338,18 @@ void *multicast_thread_rx(void *vrig)
// int ret = 0;
RIG *rig = (RIG *)vrig;
hamlib_port_t port;
rig->state.rig_type = RIG_TYPE_TRANSCEIVER;
rig->state.ptt_type = RIG_PTT_RIG;
rig->state.port_type = RIG_PORT_UDP_NETWORK;
struct rig_state *rs = STATE(rig);
rs->rig_type = RIG_TYPE_TRANSCEIVER;
rs->ptt_type = RIG_PTT_RIG;
rs->port_type = RIG_PORT_UDP_NETWORK;
strcpy(port.pathname, "127.0.0.1:4532");
//rig_debug(RIG_DEBUG_TRACE, "%s: started\n", __func__);
#if 0
network_open(&port, 4532);
#endif
//while (rig->state.multicast->runflag && ret >= 0)
while (rig->state.multicast->runflag)
//while (rs->multicast->runflag && ret >= 0)
while (rs->multicast->runflag)
{
#if 0
ret = read_string(RIGPORT(rig), (unsigned char *) buf, sizeof(buf), "\n",
@ -377,10 +383,11 @@ void *multicast_thread(void *vrig)
mode_t modeB, modeBsave = 0;
ptt_t ptt, pttsave = 0;
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
rig->state.multicast->runflag = 1;
rs->multicast->runflag = 1;
while (rig->state.multicast->runflag)
while (rs->multicast->runflag)
{
#if 0
@ -470,7 +477,9 @@ static char *GetWinsockLastError(char *errorBuffer, DWORD errorBufferSize)
int multicast_init(RIG *rig, char *addr, int port)
{
if (rig->state.multicast && rig->state.multicast->multicast_running) { return RIG_OK; }
struct rig_state *rs = STATE(rig);
if (rs->multicast && rs->multicast->multicast_running) { return RIG_OK; }
#ifdef _WIN32
WSADATA wsaData;
@ -485,22 +494,22 @@ int multicast_init(RIG *rig, char *addr, int port)
#endif
if (rig->state.multicast == NULL)
if (rs->multicast == NULL)
{
rig->state.multicast = calloc(1, sizeof(struct multicast_s));
rs->multicast = calloc(1, sizeof(struct multicast_s));
}
else if (rig->state.multicast->multicast_running) { return RIG_OK; } // we only need one port
else if (rs->multicast->multicast_running) { return RIG_OK; } // we only need one port
//rig->state.multicast->mreq = {0};
//rs->multicast->mreq = {0};
if (addr == NULL) { addr = RIG_MULTICAST_ADDR; }
if (port == 0) { port = RIG_MULTICAST_PORT; }
// Create a UDP socket
rig->state.multicast->sock = socket(AF_INET, SOCK_DGRAM, 0);
rs->multicast->sock = socket(AF_INET, SOCK_DGRAM, 0);
if (rig->state.multicast->sock < 0)
if (rs->multicast->sock < 0)
{
#ifdef _WIN32
int err = WSAGetLastError();
@ -515,7 +524,7 @@ int multicast_init(RIG *rig, char *addr, int port)
// Set the SO_REUSEADDR option to allow multiple processes to use the same address
int optval = 1;
if (setsockopt(rig->state.multicast->sock, SOL_SOCKET, SO_REUSEADDR,
if (setsockopt(rs->multicast->sock, SOL_SOCKET, SO_REUSEADDR,
(char *)&optval,
sizeof(optval)) < 0)
{
@ -533,7 +542,7 @@ int multicast_init(RIG *rig, char *addr, int port)
#if 0
if (bind(rig->state.multicast->sock, (struct sockaddr *)&saddr,
if (bind(rs->multicast->sock, (struct sockaddr *)&saddr,
sizeof(saddr)) < 0)
{
rig_debug(RIG_DEBUG_ERR, "%s: bind: %s\n", __func__, strerror(errno));
@ -544,13 +553,13 @@ int multicast_init(RIG *rig, char *addr, int port)
// Construct the multicast group address
// struct ip_mreq mreq = {0};
rig->state.multicast->mreq.imr_multiaddr.s_addr = inet_addr(addr);
rig->state.multicast->mreq.imr_interface.s_addr = htonl(INADDR_ANY);
rs->multicast->mreq.imr_multiaddr.s_addr = inet_addr(addr);
rs->multicast->mreq.imr_interface.s_addr = htonl(INADDR_ANY);
// Set the multicast TTL (time-to-live) to limit the scope of the packets
char ttl = 1;
if (setsockopt(rig->state.multicast->sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
if (setsockopt(rs->multicast->sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
sizeof(ttl)) < 0)
{
rig_debug(RIG_DEBUG_ERR, "%s: setsockopt: %s\n", __func__, strerror(errno));
@ -561,8 +570,8 @@ int multicast_init(RIG *rig, char *addr, int port)
// look like we need to implement the client in a separate thread?
// Join the multicast group
if (setsockopt(rig->state.multicast->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
(char *)&rig->state.multicast->mreq, sizeof(rig->state.multicast->mreq)) < 0)
if (setsockopt(rs->multicast->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
(char *)&rs->multicast->mreq, sizeof(rs->multicast->mreq)) < 0)
{
rig_debug(RIG_DEBUG_ERR, "%s: setsockopt: %s\n", __func__, strerror(errno));
//return -RIG_EIO;
@ -571,19 +580,19 @@ int multicast_init(RIG *rig, char *addr, int port)
#endif
// prime the dest_addr for the send routine
memset(&rig->state.multicast->dest_addr, 0,
sizeof(rig->state.multicast->dest_addr));
rig->state.multicast->dest_addr.sin_family = AF_INET;
rig->state.multicast->dest_addr.sin_addr.s_addr = inet_addr(addr);
rig->state.multicast->dest_addr.sin_port = htons(port);
memset(&rs->multicast->dest_addr, 0,
sizeof(rs->multicast->dest_addr));
rs->multicast->dest_addr.sin_family = AF_INET;
rs->multicast->dest_addr.sin_addr.s_addr = inet_addr(addr);
rs->multicast->dest_addr.sin_port = htons(port);
#if 0
rig->state.multicast->runflag = 1;
pthread_create(&rig->state.multicast->threadid, NULL, multicast_thread,
rs->multicast->runflag = 1;
pthread_create(&rs->multicast->threadid, NULL, multicast_thread,
(void *)rig);
//printf("threadid=%ld\n", rig->state.multicast->threadid);
rig->state.multicast->multicast_running = 1;
pthread_create(&rig->state.multicast->threadid, NULL, multicast_thread_rx,
//printf("threadid=%ld\n", rs->multicast->threadid);
rs->multicast->multicast_running = 1;
pthread_create(&rs->multicast->threadid, NULL, multicast_thread_rx,
(void *)rig);
#endif
return RIG_OK;
@ -592,17 +601,19 @@ int multicast_init(RIG *rig, char *addr, int port)
// cppcheck-suppress unusedFunction
void multicast_close(RIG *rig)
{
struct rig_state *rs = STATE(rig);
// Leave the multicast group
if (setsockopt(rig->state.multicast->sock, IPPROTO_IP,
IP_DROP_MEMBERSHIP, (char *)&rig->state.multicast->mreq,
sizeof(rig->state.multicast->mreq)) < 0)
if (setsockopt(rs->multicast->sock, IPPROTO_IP,
IP_DROP_MEMBERSHIP, (char *)&rs->multicast->mreq,
sizeof(rs->multicast->mreq)) < 0)
{
rig_debug(RIG_DEBUG_ERR, "%s: setsockopt: %s\n", __func__, strerror(errno));
return;
}
// Close the socket
if (close(rig->state.multicast->sock))
if (close(rs->multicast->sock))
{
rig_debug(RIG_DEBUG_ERR, "%s: close: %s\n", __func__, strerror(errno));
}
@ -626,7 +637,7 @@ int multicast_send(RIG *rig, const char *msg, int msglen)
// Send the message to the multicast group
ssize_t num_bytes = sendto(rig->state.multicast->sock, msg, msglen, 0,
ssize_t num_bytes = sendto(STATE(rig)->multicast->sock, msg, msglen, 0,
(struct sockaddr *)&addr,
sizeof(addr));
@ -665,7 +676,7 @@ int main(int argc, const char *argv[])
RIGPORT(rig)->parm.serial.rate = 38400;
rig_open(rig);
multicast_init(rig, "224.0.0.1", 4532);
pthread_join(rig->state.multicast->threadid, NULL);
pthread_join(STATE(rig)->multicast->threadid, NULL);
pthread_exit(NULL);
return 0;
}

19
src/snapshot_data.c
Wyświetl plik

@ -20,16 +20,17 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig)
cJSON *node;
char buf[1024];
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
cJSON *id_node = cJSON_CreateObject();
cJSON_AddStringToObject(id_node, "model", rig->caps->model_name);
cJSON_AddStringToObject(id_node, "endpoint", RIGPORT(rig)->pathname);
cJSON_AddStringToObject(id_node, "process", snapshot_data_pid);
cJSON_AddStringToObject(id_node, "deviceId", rig->state.device_id);
cJSON_AddStringToObject(id_node, "deviceId", rs->device_id);
cJSON_AddItemToObject(rig_node, "id", id_node);
node = cJSON_AddStringToObject(rig_node, "status",
rig_strcommstatus(rig->state.comm_status));
rig_strcommstatus(rs->comm_status));
if (node == NULL)
{
@ -75,7 +76,7 @@ static int snapshot_serialize_rig(cJSON *rig_node, RIG *rig)
goto error;
}
rig_sprintf_mode(buf, sizeof(buf), rig->state.mode_list);
rig_sprintf_mode(buf, sizeof(buf), rs->mode_list);
char *p;
cJSON *modes_array = cJSON_CreateArray();
@ -113,6 +114,7 @@ static int snapshot_serialize_vfo(cJSON *vfo_node, RIG *rig, vfo_t vfo)
int is_rx, is_tx;
cJSON *node;
struct rig_cache *cachep = CACHE(rig);
struct rig_state *rs = STATE(rig);
// TODO: This data should match rig_get_info command response
@ -153,9 +155,9 @@ static int snapshot_serialize_vfo(cJSON *vfo_node, RIG *rig, vfo_t vfo)
split = cachep->split;
split_vfo = cachep->split_vfo;
is_rx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo)
is_rx = (split == RIG_SPLIT_OFF && vfo == rs->current_vfo)
|| (split == RIG_SPLIT_ON && vfo != split_vfo);
is_tx = (split == RIG_SPLIT_OFF && vfo == rig->state.current_vfo)
is_tx = (split == RIG_SPLIT_OFF && vfo == rs->current_vfo)
|| (split == RIG_SPLIT_ON && vfo == split_vfo);
ptt = cachep->ptt && is_tx;
@ -336,6 +338,7 @@ int snapshot_serialize(size_t buffer_length, char *buffer, RIG *rig,
char buf[256];
int result;
int i;
struct rig_state *rs = STATE(rig);
root_node = cJSON_CreateObject();
@ -360,7 +363,7 @@ int snapshot_serialize(size_t buffer_length, char *buffer, RIG *rig,
}
node = cJSON_AddNumberToObject(root_node, "seq",
rig->state.snapshot_packet_sequence_number);
rs->snapshot_packet_sequence_number);
if (node == NULL)
{
@ -410,7 +413,7 @@ int snapshot_serialize(size_t buffer_length, char *buffer, RIG *rig,
for (i = 0; i < HAMLIB_MAX_VFOS; i++)
{
vfo_t vfo = rig->state.vfo_list & RIG_VFO_N(i);
vfo_t vfo = rs->vfo_list & RIG_VFO_N(i);
if (!vfo)
{
@ -464,7 +467,7 @@ int snapshot_serialize(size_t buffer_length, char *buffer, RIG *rig,
RETURNFUNC2(-RIG_EINVAL);
}
rig->state.snapshot_packet_sequence_number++;
rs->snapshot_packet_sequence_number++;
return RIG_OK;

42
src/tones.c
Wyświetl plik

@ -68,7 +68,7 @@ tone_t full_dcs_list[] = { FULL_DCS_LIST };
#ifndef DOC_HIDDEN
#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !(r)->state.comm_state)
#define CHECK_RIG_ARG(r) (!(r) || !(r)->caps || !STATE(r)->comm_state)
#endif /* !DOC_HIDDEN */
@ -98,6 +98,7 @@ tone_t full_dcs_list[] = { FULL_DCS_LIST };
int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
{
const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
int retcode;
vfo_t curr_vfo;
@ -117,7 +118,7 @@ int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
if ((caps->targetable_vfo & RIG_TARGETABLE_TONE)
|| vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rs->current_vfo)
{
return caps->set_ctcss_tone(rig, vfo, tone);
@ -128,7 +129,7 @@ int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
return -RIG_ENTARGET;
}
curr_vfo = rig->state.current_vfo;
curr_vfo = rs->current_vfo;
retcode = caps->set_vfo(rig, vfo);
if (retcode != RIG_OK)
@ -165,6 +166,7 @@ int HAMLIB_API rig_set_ctcss_tone(RIG *rig, vfo_t vfo, tone_t tone)
int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
{
const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
int retcode;
vfo_t curr_vfo;
@ -184,7 +186,7 @@ int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
if ((caps->targetable_vfo & RIG_TARGETABLE_TONE)
|| vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rs->current_vfo)
{
return caps->get_ctcss_tone(rig, vfo, tone);
@ -195,7 +197,7 @@ int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
return -RIG_ENTARGET;
}
curr_vfo = rig->state.current_vfo;
curr_vfo = rs->current_vfo;
retcode = caps->set_vfo(rig, vfo);
if (retcode != RIG_OK)
@ -228,6 +230,7 @@ int HAMLIB_API rig_get_ctcss_tone(RIG *rig, vfo_t vfo, tone_t *tone)
int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
{
const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
int retcode;
vfo_t curr_vfo;
@ -247,7 +250,7 @@ int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
if ((caps->targetable_vfo & RIG_TARGETABLE_TONE)
|| vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rs->current_vfo)
{
return caps->set_dcs_code(rig, vfo, code);
@ -258,7 +261,7 @@ int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
return -RIG_ENTARGET;
}
curr_vfo = rig->state.current_vfo;
curr_vfo = rs->current_vfo;
retcode = caps->set_vfo(rig, vfo);
if (retcode != RIG_OK)
@ -290,6 +293,7 @@ int HAMLIB_API rig_set_dcs_code(RIG *rig, vfo_t vfo, tone_t code)
int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code)
{
const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
int retcode;
vfo_t curr_vfo;
@ -309,7 +313,7 @@ int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code)
if ((caps->targetable_vfo & RIG_TARGETABLE_TONE)
|| vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rs->current_vfo)
{
return caps->get_dcs_code(rig, vfo, code);
@ -320,7 +324,7 @@ int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code)
return -RIG_ENTARGET;
}
curr_vfo = rig->state.current_vfo;
curr_vfo = rs->current_vfo;
retcode = caps->set_vfo(rig, vfo);
if (retcode != RIG_OK)
@ -360,6 +364,7 @@ int HAMLIB_API rig_get_dcs_code(RIG *rig, vfo_t vfo, tone_t *code)
int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
{
const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
int retcode;
vfo_t curr_vfo;
@ -379,7 +384,7 @@ int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
if ((caps->targetable_vfo & RIG_TARGETABLE_TONE)
|| vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rs->current_vfo)
{
return caps->set_ctcss_sql(rig, vfo, tone);
@ -390,7 +395,7 @@ int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
return -RIG_ENTARGET;
}
curr_vfo = rig->state.current_vfo;
curr_vfo = rs->current_vfo;
retcode = caps->set_vfo(rig, vfo);
if (retcode != RIG_OK)
@ -427,6 +432,7 @@ int HAMLIB_API rig_set_ctcss_sql(RIG *rig, vfo_t vfo, tone_t tone)
int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone)
{
const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
int retcode;
vfo_t curr_vfo;
@ -446,7 +452,7 @@ int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone)
if ((caps->targetable_vfo & RIG_TARGETABLE_TONE)
|| vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rs->current_vfo)
{
return caps->get_ctcss_sql(rig, vfo, tone);
@ -457,7 +463,7 @@ int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone)
return -RIG_ENTARGET;
}
curr_vfo = rig->state.current_vfo;
curr_vfo = rs->current_vfo;
retcode = caps->set_vfo(rig, vfo);
if (retcode != RIG_OK)
@ -489,6 +495,7 @@ int HAMLIB_API rig_get_ctcss_sql(RIG *rig, vfo_t vfo, tone_t *tone)
int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code)
{
const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
int retcode;
vfo_t curr_vfo;
@ -508,7 +515,7 @@ int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code)
if ((caps->targetable_vfo & RIG_TARGETABLE_TONE)
|| vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rs->current_vfo)
{
return caps->set_dcs_sql(rig, vfo, code);
@ -519,7 +526,7 @@ int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code)
return -RIG_ENTARGET;
}
curr_vfo = rig->state.current_vfo;
curr_vfo = rs->current_vfo;
retcode = caps->set_vfo(rig, vfo);
if (retcode != RIG_OK)
@ -551,6 +558,7 @@ int HAMLIB_API rig_set_dcs_sql(RIG *rig, vfo_t vfo, tone_t code)
int HAMLIB_API rig_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code)
{
const struct rig_caps *caps;
struct rig_state *rs = STATE(rig);
int retcode;
vfo_t curr_vfo;
@ -570,7 +578,7 @@ int HAMLIB_API rig_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code)
if ((caps->targetable_vfo & RIG_TARGETABLE_TONE)
|| vfo == RIG_VFO_CURR
|| vfo == rig->state.current_vfo)
|| vfo == rs->current_vfo)
{
return caps->get_dcs_sql(rig, vfo, code);
@ -581,7 +589,7 @@ int HAMLIB_API rig_get_dcs_sql(RIG *rig, vfo_t vfo, tone_t *code)
return -RIG_ENTARGET;
}
curr_vfo = rig->state.current_vfo;
curr_vfo = rs->current_vfo;
retcode = caps->set_vfo(rig, vfo);
if (retcode != RIG_OK)