mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-04-20 02:40:03 +02:00
Dev/fix port size (#805)
* port datatype changing from int to uint16_t * throwing for -1 given for uint16_t ports
This commit is contained in:
parent
77d13f0794
commit
9834b07b47
Binary file not shown.
@ -1789,8 +1789,8 @@ int configureMAC() {
|
||||
uint32_t dstip = udpDetails[0].dstip;
|
||||
uint64_t srcmac = udpDetails[0].srcmac;
|
||||
uint64_t dstmac = udpDetails[0].dstmac;
|
||||
int srcport = udpDetails[0].srcport;
|
||||
int dstport = udpDetails[0].dstport;
|
||||
uint16_t srcport = udpDetails[0].srcport;
|
||||
uint16_t dstport = udpDetails[0].dstport;
|
||||
|
||||
LOG(logINFOBLUE, ("Configuring MAC\n"));
|
||||
char src_mac[MAC_ADDRESS_SIZE], src_ip[INET_ADDRSTRLEN],
|
||||
@ -1802,10 +1802,10 @@ int configureMAC() {
|
||||
|
||||
LOG(logINFO, ("\tSource IP : %s\n"
|
||||
"\tSource MAC : %s\n"
|
||||
"\tSource Port : %d\n"
|
||||
"\tSource Port : %hu\n"
|
||||
"\tDest IP : %s\n"
|
||||
"\tDest MAC : %s\n"
|
||||
"\tDest Port : %d\n",
|
||||
"\tDest Port : %hu\n",
|
||||
src_ip, src_mac, srcport, dst_ip, dst_mac, dstport));
|
||||
|
||||
// 1 giga udp
|
||||
|
Binary file not shown.
@ -1808,9 +1808,9 @@ int configureMAC() {
|
||||
uint32_t dstip = udpDetails[iRxEntry].dstip;
|
||||
uint64_t srcmac = udpDetails[iRxEntry].srcmac;
|
||||
uint64_t dstmac = udpDetails[iRxEntry].dstmac;
|
||||
int srcport = udpDetails[iRxEntry].srcport;
|
||||
int dstport = udpDetails[iRxEntry].dstport;
|
||||
int dstport2 = udpDetails[iRxEntry].dstport2;
|
||||
uint16_t srcport = udpDetails[iRxEntry].srcport;
|
||||
uint16_t dstport = udpDetails[iRxEntry].dstport;
|
||||
uint16_t dstport2 = udpDetails[iRxEntry].dstport2;
|
||||
|
||||
char src_mac[MAC_ADDRESS_SIZE], src_ip[INET_ADDRSTRLEN],
|
||||
dst_mac[MAC_ADDRESS_SIZE], dst_ip[INET_ADDRSTRLEN];
|
||||
@ -1824,11 +1824,11 @@ int configureMAC() {
|
||||
LOG(logINFO,
|
||||
("\tSource IP : %s\n"
|
||||
"\tSource MAC : %s\n"
|
||||
"\tSource Port : %d\n"
|
||||
"\tSource Port : %hu\n"
|
||||
"\tDest IP : %s\n"
|
||||
"\tDest MAC : %s\n"
|
||||
"\tDest Port : %d\n"
|
||||
"\tDest Port2 : %d\n",
|
||||
"\tDest Port : %hu\n"
|
||||
"\tDest Port2 : %hu\n",
|
||||
src_ip, src_mac, srcport, dst_ip, dst_mac, dstport, dstport2));
|
||||
}
|
||||
|
||||
|
Binary file not shown.
@ -1902,8 +1902,8 @@ void setFirstUDPDestination(int value) {
|
||||
}
|
||||
|
||||
void setupHeader(int iRxEntry, int vetoInterface, uint32_t destip,
|
||||
uint64_t destmac, uint32_t destport, uint64_t sourcemac,
|
||||
uint32_t sourceip, uint32_t sourceport) {
|
||||
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
|
||||
uint32_t sourceip, uint16_t sourceport) {
|
||||
|
||||
// start addr
|
||||
uint32_t addr = BASE_UDP_RAM;
|
||||
@ -1995,10 +1995,10 @@ int configureMAC() {
|
||||
uint64_t srcmac2 = udpDetails[iRxEntry].srcmac2;
|
||||
uint64_t dstmac = udpDetails[iRxEntry].dstmac;
|
||||
uint64_t dstmac2 = udpDetails[iRxEntry].dstmac2;
|
||||
int srcport = udpDetails[iRxEntry].srcport;
|
||||
int srcport2 = udpDetails[iRxEntry].srcport2;
|
||||
int dstport = udpDetails[iRxEntry].dstport;
|
||||
int dstport2 = udpDetails[iRxEntry].dstport2;
|
||||
uint16_t srcport = udpDetails[iRxEntry].srcport;
|
||||
uint16_t srcport2 = udpDetails[iRxEntry].srcport2;
|
||||
uint16_t dstport = udpDetails[iRxEntry].dstport;
|
||||
uint16_t dstport2 = udpDetails[iRxEntry].dstport2;
|
||||
|
||||
char src_mac[MAC_ADDRESS_SIZE], src_ip[INET_ADDRSTRLEN],
|
||||
dst_mac[MAC_ADDRESS_SIZE], dst_ip[INET_ADDRSTRLEN];
|
||||
@ -2020,10 +2020,10 @@ int configureMAC() {
|
||||
LOG(logINFO, ("\tData Interface \n"));
|
||||
LOG(logINFO, ("\tSource IP : %s\n"
|
||||
"\tSource MAC : %s\n"
|
||||
"\tSource Port : %d\n"
|
||||
"\tSource Port : %hu\n"
|
||||
"\tDest IP : %s\n"
|
||||
"\tDest MAC : %s\n"
|
||||
"\tDest Port : %d\n\n",
|
||||
"\tDest Port : %hu\n\n",
|
||||
src_ip, src_mac, srcport, dst_ip, dst_mac, dstport));
|
||||
|
||||
if (getVetoStream()) {
|
||||
@ -2039,10 +2039,10 @@ int configureMAC() {
|
||||
LOG(logINFO,
|
||||
("\tSource IP2 : %s\n"
|
||||
"\tSource MAC2 : %s\n"
|
||||
"\tSource Port2: %d\n"
|
||||
"\tSource Port2: %hu\n"
|
||||
"\tDest IP2 : %s\n"
|
||||
"\tDest MAC2 : %s\n"
|
||||
"\tDest Port2 : %d\n\n",
|
||||
"\tDest Port2 : %hu\n\n",
|
||||
src_ip2, src_mac2, srcport2, dst_ip2, dst_mac2, dstport2));
|
||||
}
|
||||
#ifdef VIRTUAL
|
||||
|
Binary file not shown.
@ -1425,8 +1425,8 @@ int configureMAC() {
|
||||
uint32_t dstip = udpDetails[0].dstip;
|
||||
uint64_t srcmac = udpDetails[0].srcmac;
|
||||
uint64_t dstmac = udpDetails[0].dstmac;
|
||||
int srcport = udpDetails[0].srcport;
|
||||
int dstport = udpDetails[0].dstport;
|
||||
uint16_t srcport = udpDetails[0].srcport;
|
||||
uint16_t dstport = udpDetails[0].dstport;
|
||||
|
||||
LOG(logINFOBLUE, ("Configuring MAC\n"));
|
||||
char src_mac[MAC_ADDRESS_SIZE], src_ip[INET_ADDRSTRLEN],
|
||||
@ -1438,10 +1438,10 @@ int configureMAC() {
|
||||
|
||||
LOG(logINFO, ("\tSource IP : %s\n"
|
||||
"\tSource MAC : %s\n"
|
||||
"\tSource Port : %d\n"
|
||||
"\tSource Port : %hu\n"
|
||||
"\tDest IP : %s\n"
|
||||
"\tDest MAC : %s\n"
|
||||
"\tDest Port : %d\n",
|
||||
"\tDest Port : %hu\n",
|
||||
src_ip, src_mac, srcport, dst_ip, dst_mac, dstport));
|
||||
|
||||
#ifdef VIRTUAL
|
||||
|
Binary file not shown.
@ -1532,8 +1532,8 @@ int getPrimaryInterface() {
|
||||
}
|
||||
|
||||
void setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
|
||||
uint64_t destmac, uint32_t destport, uint64_t sourcemac,
|
||||
uint32_t sourceip, uint32_t sourceport) {
|
||||
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
|
||||
uint32_t sourceip, uint16_t sourceport) {
|
||||
|
||||
// start addr
|
||||
uint32_t addr = (type == INNER ? RXR_ENDPOINT_INNER_START_REG
|
||||
@ -1628,10 +1628,10 @@ int configureMAC() {
|
||||
uint64_t srcmac2 = udpDetails[iRxEntry].srcmac2;
|
||||
uint64_t dstmac = udpDetails[iRxEntry].dstmac;
|
||||
uint64_t dstmac2 = udpDetails[iRxEntry].dstmac2;
|
||||
int srcport = udpDetails[iRxEntry].srcport;
|
||||
int srcport2 = udpDetails[iRxEntry].srcport2;
|
||||
int dstport = udpDetails[iRxEntry].dstport;
|
||||
int dstport2 = udpDetails[iRxEntry].dstport2;
|
||||
uint16_t srcport = udpDetails[iRxEntry].srcport;
|
||||
uint16_t srcport2 = udpDetails[iRxEntry].srcport2;
|
||||
uint16_t dstport = udpDetails[iRxEntry].dstport;
|
||||
uint16_t dstport2 = udpDetails[iRxEntry].dstport2;
|
||||
|
||||
char src_mac[MAC_ADDRESS_SIZE], src_ip[INET_ADDRSTRLEN],
|
||||
dst_mac[MAC_ADDRESS_SIZE], dst_ip[INET_ADDRSTRLEN];
|
||||
@ -1655,10 +1655,10 @@ int configureMAC() {
|
||||
: (selInterface ? "Not Used" : "Used")));
|
||||
LOG(logINFO, ("\tSource IP : %s\n"
|
||||
"\tSource MAC : %s\n"
|
||||
"\tSource Port : %d\n"
|
||||
"\tSource Port : %hu\n"
|
||||
"\tDest IP : %s\n"
|
||||
"\tDest MAC : %s\n"
|
||||
"\tDest Port : %d\n\n",
|
||||
"\tDest Port : %hu\n\n",
|
||||
src_ip, src_mac, srcport, dst_ip, dst_mac, dstport));
|
||||
|
||||
LOG(logINFO,
|
||||
@ -1668,10 +1668,10 @@ int configureMAC() {
|
||||
LOG(logINFO,
|
||||
("\tSource IP2 : %s\n"
|
||||
"\tSource MAC2 : %s\n"
|
||||
"\tSource Port2: %d\n"
|
||||
"\tSource Port2: %hu\n"
|
||||
"\tDest IP2 : %s\n"
|
||||
"\tDest MAC2 : %s\n"
|
||||
"\tDest Port2 : %d\n\n",
|
||||
"\tDest Port2 : %hu\n\n",
|
||||
src_ip2, src_mac2, srcport2, dst_ip2, dst_mac2, dstport2));
|
||||
}
|
||||
#ifdef VIRTUAL
|
||||
|
Binary file not shown.
@ -1120,8 +1120,8 @@ int getPrimaryInterface() {
|
||||
}
|
||||
|
||||
void setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
|
||||
uint64_t destmac, uint32_t destport, uint64_t sourcemac,
|
||||
uint32_t sourceip, uint32_t sourceport) {
|
||||
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
|
||||
uint32_t sourceip, uint16_t sourceport) {
|
||||
|
||||
// start addr
|
||||
uint32_t addr = (type == INNER ? RXR_ENDPOINT_INNER_START_REG
|
||||
@ -1216,10 +1216,10 @@ int configureMAC() {
|
||||
uint64_t srcmac2 = udpDetails[iRxEntry].srcmac2;
|
||||
uint64_t dstmac = udpDetails[iRxEntry].dstmac;
|
||||
uint64_t dstmac2 = udpDetails[iRxEntry].dstmac2;
|
||||
int srcport = udpDetails[iRxEntry].srcport;
|
||||
int srcport2 = udpDetails[iRxEntry].srcport2;
|
||||
int dstport = udpDetails[iRxEntry].dstport;
|
||||
int dstport2 = udpDetails[iRxEntry].dstport2;
|
||||
uint16_t srcport = udpDetails[iRxEntry].srcport;
|
||||
uint16_t srcport2 = udpDetails[iRxEntry].srcport2;
|
||||
uint16_t dstport = udpDetails[iRxEntry].dstport;
|
||||
uint16_t dstport2 = udpDetails[iRxEntry].dstport2;
|
||||
|
||||
char src_mac[MAC_ADDRESS_SIZE], src_ip[INET_ADDRSTRLEN],
|
||||
dst_mac[MAC_ADDRESS_SIZE], dst_ip[INET_ADDRSTRLEN];
|
||||
@ -1243,10 +1243,10 @@ int configureMAC() {
|
||||
: (selInterface ? "Not Used" : "Used")));
|
||||
LOG(logINFO, ("\tSource IP : %s\n"
|
||||
"\tSource MAC : %s\n"
|
||||
"\tSource Port : %d\n"
|
||||
"\tSource Port : %hu\n"
|
||||
"\tDest IP : %s\n"
|
||||
"\tDest MAC : %s\n"
|
||||
"\tDest Port : %d\n\n",
|
||||
"\tDest Port : %hu\n\n",
|
||||
src_ip, src_mac, srcport, dst_ip, dst_mac, dstport));
|
||||
|
||||
LOG(logINFO,
|
||||
@ -1256,10 +1256,10 @@ int configureMAC() {
|
||||
LOG(logINFO,
|
||||
("\tSource IP2 : %s\n"
|
||||
"\tSource MAC2 : %s\n"
|
||||
"\tSource Port2: %d\n"
|
||||
"\tSource Port2: %hu\n"
|
||||
"\tDest IP2 : %s\n"
|
||||
"\tDest MAC2 : %s\n"
|
||||
"\tDest Port2 : %d\n\n",
|
||||
"\tDest Port2 : %hu\n\n",
|
||||
src_ip2, src_mac2, srcport2, dst_ip2, dst_mac2, dstport2));
|
||||
}
|
||||
#ifdef VIRTUAL
|
||||
|
Binary file not shown.
@ -1963,8 +1963,8 @@ int configureMAC() {
|
||||
uint32_t dstip = udpDetails[iRxEntry].dstip;
|
||||
uint64_t srcmac = udpDetails[iRxEntry].srcmac;
|
||||
uint64_t dstmac = udpDetails[iRxEntry].dstmac;
|
||||
int srcport = udpDetails[iRxEntry].srcport;
|
||||
int dstport = udpDetails[iRxEntry].dstport;
|
||||
uint16_t srcport = udpDetails[iRxEntry].srcport;
|
||||
uint16_t dstport = udpDetails[iRxEntry].dstport;
|
||||
|
||||
char src_mac[MAC_ADDRESS_SIZE], src_ip[INET_ADDRSTRLEN],
|
||||
dst_mac[MAC_ADDRESS_SIZE], dst_ip[INET_ADDRSTRLEN];
|
||||
@ -1976,10 +1976,10 @@ int configureMAC() {
|
||||
LOG(logINFOBLUE, ("\tEntry %d\n", iRxEntry));
|
||||
LOG(logINFO, ("\tSource IP : %s\n"
|
||||
"\tSource MAC : %s\n"
|
||||
"\tSource Port : %d\n"
|
||||
"\tSource Port : %hu\n"
|
||||
"\tDest IP : %s\n"
|
||||
"\tDest MAC : %s\n"
|
||||
"\tDest Port : %d\n",
|
||||
"\tDest Port : %hu\n",
|
||||
src_ip, src_mac, srcport, dst_ip, dst_mac, dstport));
|
||||
}
|
||||
#ifdef VIRTUAL
|
||||
|
@ -42,10 +42,10 @@ single detector.
|
||||
|
||||
enum interfaceType { OUTER, INNER };
|
||||
typedef struct udpStruct_s {
|
||||
int srcport;
|
||||
int srcport2;
|
||||
int dstport;
|
||||
int dstport2;
|
||||
uint16_t srcport;
|
||||
uint16_t srcport2;
|
||||
uint16_t dstport;
|
||||
uint16_t dstport2;
|
||||
uint64_t srcmac;
|
||||
uint64_t srcmac2;
|
||||
uint64_t dstmac;
|
||||
@ -467,8 +467,8 @@ void setFirstUDPDestination(int value);
|
||||
void selectPrimaryInterface(int val);
|
||||
int getPrimaryInterface();
|
||||
void setupHeader(int iRxEntry, enum interfaceType type, uint32_t destip,
|
||||
uint64_t destmac, uint32_t destport, uint64_t sourcemac,
|
||||
uint32_t sourceip, uint32_t sourceport);
|
||||
uint64_t destmac, uint16_t destport, uint64_t sourcemac,
|
||||
uint32_t sourceip, uint16_t sourceport);
|
||||
#endif
|
||||
#if defined(JUNGFRAUD) || defined(MOENCHD) || defined(GOTTHARD2D) || \
|
||||
defined(MYTHEN3D) || defined(CHIPTESTBOARDD)
|
||||
@ -516,7 +516,7 @@ void setDigitalIODelay(uint64_t pinMask, int delay);
|
||||
|
||||
// jungfrau/moench specific - powerchip, autocompdisable, clockdiv, asictimer,
|
||||
// clock, pll, flashing firmware
|
||||
#if defined(MOENCHED)
|
||||
#if defined(MOENCHD)
|
||||
void setADCPipeline(int val);
|
||||
int getADCPipeline();
|
||||
#endif
|
||||
|
@ -13,6 +13,7 @@
|
||||
#include "slsDetectorServer_funcs.h"
|
||||
|
||||
#include <getopt.h>
|
||||
#include <limits.h>
|
||||
#include <signal.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
@ -276,6 +277,15 @@ int main(int argc, char *argv[]) {
|
||||
LOG(logERROR, ("Could not set handler function for SIGINT"));
|
||||
}
|
||||
|
||||
// validate control and stop port number
|
||||
if (0 >= portno || portno > USHRT_MAX || 0 >= (portno + 1) ||
|
||||
(portno + 1) > USHRT_MAX) {
|
||||
LOG(logERROR, ("Invalid control server or stop server port "
|
||||
"numbers (%d, %d). It must be in range 1 - %d",
|
||||
portno, portno + 1, USHRT_MAX));
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (sharedMemory_create(portno) == FAIL) {
|
||||
return -1;
|
||||
}
|
||||
|
@ -5366,11 +5366,11 @@ int get_dest_udp_mac2(int file_des) {
|
||||
int set_dest_udp_port(int file_des) {
|
||||
ret = OK;
|
||||
memset(mess, 0, sizeof(mess));
|
||||
int arg = 0;
|
||||
uint16_t arg = 0;
|
||||
|
||||
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
|
||||
if (receiveData(file_des, &arg, sizeof(arg), INT16) < 0)
|
||||
return printSocketReadError();
|
||||
LOG(logINFO, ("Setting udp destination port: %u\n", arg));
|
||||
LOG(logINFO, ("Setting udp destination port: %hu\n", arg));
|
||||
|
||||
// only set
|
||||
if (Server_VerifyLock() == OK) {
|
||||
@ -5381,30 +5381,30 @@ int set_dest_udp_port(int file_des) {
|
||||
}
|
||||
}
|
||||
}
|
||||
return Server_SendResult(file_des, INT32, NULL, 0);
|
||||
return Server_SendResult(file_des, INT16, NULL, 0);
|
||||
}
|
||||
|
||||
int get_dest_udp_port(int file_des) {
|
||||
ret = OK;
|
||||
memset(mess, 0, sizeof(mess));
|
||||
int retval = -1;
|
||||
uint16_t retval = -1;
|
||||
LOG(logDEBUG1, ("Getting destination port"));
|
||||
|
||||
// get only
|
||||
retval = udpDetails[0].dstport;
|
||||
LOG(logDEBUG, ("udp destination port retval: %u\n", retval));
|
||||
LOG(logDEBUG, ("udp destination port retval: %hu\n", retval));
|
||||
|
||||
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
|
||||
return Server_SendResult(file_des, INT16, &retval, sizeof(retval));
|
||||
}
|
||||
|
||||
int set_dest_udp_port2(int file_des) {
|
||||
ret = OK;
|
||||
memset(mess, 0, sizeof(mess));
|
||||
int arg = 0;
|
||||
uint16_t arg = 0;
|
||||
|
||||
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
|
||||
if (receiveData(file_des, &arg, sizeof(arg), INT16) < 0)
|
||||
return printSocketReadError();
|
||||
LOG(logINFO, ("Setting udp destination port2: %u\n", arg));
|
||||
LOG(logINFO, ("Setting udp destination port2: %hu\n", arg));
|
||||
|
||||
#if !defined(JUNGFRAUD) && !defined(MOENCHD) && !defined(EIGERD) && \
|
||||
!defined(GOTTHARD2D)
|
||||
@ -5420,13 +5420,13 @@ int set_dest_udp_port2(int file_des) {
|
||||
}
|
||||
}
|
||||
#endif
|
||||
return Server_SendResult(file_des, INT32, NULL, 0);
|
||||
return Server_SendResult(file_des, INT16, NULL, 0);
|
||||
}
|
||||
|
||||
int get_dest_udp_port2(int file_des) {
|
||||
ret = OK;
|
||||
memset(mess, 0, sizeof(mess));
|
||||
int retval = -1;
|
||||
uint16_t retval = -1;
|
||||
LOG(logDEBUG1, ("Getting destination port2\n"));
|
||||
|
||||
#if !defined(JUNGFRAUD) && !defined(MOENCHD) && !defined(EIGERD) && \
|
||||
@ -5435,9 +5435,9 @@ int get_dest_udp_port2(int file_des) {
|
||||
#else
|
||||
// get only
|
||||
retval = udpDetails[0].dstport2;
|
||||
LOG(logDEBUG1, ("udp destination port2 retval: %u\n", retval));
|
||||
LOG(logDEBUG1, ("udp destination port2 retval: %hu\n", retval));
|
||||
#endif
|
||||
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
|
||||
return Server_SendResult(file_des, INT16, &retval, sizeof(retval));
|
||||
}
|
||||
|
||||
int set_num_interfaces(int file_des) {
|
||||
@ -6990,6 +6990,7 @@ int get_receiver_parameters(int file_des) {
|
||||
int n = 0;
|
||||
int i32 = 0;
|
||||
int64_t i64 = 0;
|
||||
uint16_t u16 = 0;
|
||||
uint32_t u32 = 0;
|
||||
uint64_t u64 = 0;
|
||||
|
||||
@ -7032,8 +7033,8 @@ int get_receiver_parameters(int file_des) {
|
||||
return printSocketReadError();
|
||||
|
||||
// udp dst port
|
||||
i32 = udpDetails[0].dstport;
|
||||
n += sendData(file_des, &i32, sizeof(i32), INT32);
|
||||
u16 = udpDetails[0].dstport;
|
||||
n += sendData(file_des, &u16, sizeof(u16), INT16);
|
||||
if (n < 0)
|
||||
return printSocketReadError();
|
||||
|
||||
@ -7051,8 +7052,8 @@ int get_receiver_parameters(int file_des) {
|
||||
return printSocketReadError();
|
||||
|
||||
// udp dst port2
|
||||
i32 = udpDetails[0].dstport2;
|
||||
n += sendData(file_des, &i32, sizeof(i32), INT32);
|
||||
u16 = udpDetails[0].dstport2;
|
||||
n += sendData(file_des, &u16, sizeof(u16), INT16);
|
||||
if (n < 0)
|
||||
return printSocketReadError();
|
||||
|
||||
@ -9170,7 +9171,8 @@ int get_dest_udp_list(int file_des) {
|
||||
ret = OK;
|
||||
memset(mess, 0, sizeof(mess));
|
||||
uint32_t arg = 0;
|
||||
uint32_t retvals[5] = {};
|
||||
uint16_t retvals16[2] = {};
|
||||
uint32_t retvals32[3] = {};
|
||||
uint64_t retvals64[2] = {};
|
||||
|
||||
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
|
||||
@ -9189,34 +9191,36 @@ int get_dest_udp_list(int file_des) {
|
||||
MAX_UDP_DESTINATION - 1);
|
||||
LOG(logERROR, (mess));
|
||||
} else {
|
||||
retvals[0] = arg;
|
||||
retvals[1] = udpDetails[arg].dstport;
|
||||
retvals[2] = udpDetails[arg].dstport2;
|
||||
retvals[3] = udpDetails[arg].dstip;
|
||||
retvals[4] = udpDetails[arg].dstip2;
|
||||
// arg;
|
||||
retvals16[0] = udpDetails[arg].dstport;
|
||||
retvals16[1] = udpDetails[arg].dstport2;
|
||||
retvals32[0] = udpDetails[arg].dstip;
|
||||
retvals32[1] = udpDetails[arg].dstip2;
|
||||
retvals64[0] = udpDetails[arg].dstmac;
|
||||
retvals64[1] = udpDetails[arg].dstmac2;
|
||||
|
||||
// swap ip
|
||||
retvals[3] = __builtin_bswap32(retvals[3]);
|
||||
retvals[4] = __builtin_bswap32(retvals[4]);
|
||||
retvals32[0] = __builtin_bswap32(retvals32[0]);
|
||||
retvals32[1] = __builtin_bswap32(retvals32[1]);
|
||||
|
||||
// convert to string
|
||||
char ip[INET_ADDRSTRLEN], ip2[INET_ADDRSTRLEN];
|
||||
getIpAddressinString(ip, retvals[3]);
|
||||
getIpAddressinString(ip2, retvals[4]);
|
||||
getIpAddressinString(ip, retvals32[0]);
|
||||
getIpAddressinString(ip2, retvals32[1]);
|
||||
char mac[MAC_ADDRESS_SIZE], mac2[MAC_ADDRESS_SIZE];
|
||||
getMacAddressinString(mac, MAC_ADDRESS_SIZE, retvals64[0]);
|
||||
getMacAddressinString(mac2, MAC_ADDRESS_SIZE, retvals64[1]);
|
||||
LOG(logDEBUG1,
|
||||
("Udp Dest. retval [%d]: [port %d, port2 %d, ip %s, ip2 %s, "
|
||||
("Udp Dest. retval [%d]: [port %hu, port2 %hu, ip %s, ip2 %s, "
|
||||
"mac %s, mac2 %s]\n",
|
||||
retvals[0], retvals[1], retvals[2], ip, ip2, mac, mac2));
|
||||
arg, retvals16[0], retvals16[1], ip, ip2, mac, mac2));
|
||||
}
|
||||
#endif
|
||||
Server_SendResult(file_des, INT32, NULL, 0);
|
||||
if (ret != FAIL) {
|
||||
sendData(file_des, retvals, sizeof(retvals), INT32);
|
||||
sendData(file_des, &arg, sizeof(arg), INT32);
|
||||
sendData(file_des, retvals16, sizeof(retvals16), INT16);
|
||||
sendData(file_des, retvals32, sizeof(retvals32), INT32);
|
||||
sendData(file_des, retvals64, sizeof(retvals64), INT64);
|
||||
}
|
||||
return ret;
|
||||
@ -9225,22 +9229,28 @@ int get_dest_udp_list(int file_des) {
|
||||
int set_dest_udp_list(int file_des) {
|
||||
ret = OK;
|
||||
memset(mess, 0, sizeof(mess));
|
||||
uint32_t args[5] = {};
|
||||
uint32_t arg = 0;
|
||||
uint16_t args16[2] = {};
|
||||
uint32_t args32[2] = {};
|
||||
uint64_t args64[2] = {};
|
||||
|
||||
if (receiveData(file_des, args, sizeof(args), INT32) < 0)
|
||||
if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
|
||||
return printSocketReadError();
|
||||
if (receiveData(file_des, args16, sizeof(args16), INT16) < 0)
|
||||
return printSocketReadError();
|
||||
if (receiveData(file_des, args32, sizeof(args32), INT32) < 0)
|
||||
return printSocketReadError();
|
||||
if (receiveData(file_des, args64, sizeof(args64), INT64) < 0)
|
||||
return printSocketReadError();
|
||||
|
||||
// swap ip
|
||||
args[3] = __builtin_bswap32(args[3]);
|
||||
args[4] = __builtin_bswap32(args[4]);
|
||||
args32[0] = __builtin_bswap32(args32[0]);
|
||||
args32[1] = __builtin_bswap32(args32[1]);
|
||||
|
||||
// convert to string
|
||||
char ip[INET_ADDRSTRLEN], ip2[INET_ADDRSTRLEN];
|
||||
getIpAddressinString(ip, args[3]);
|
||||
getIpAddressinString(ip2, args[4]);
|
||||
getIpAddressinString(ip, args32[0]);
|
||||
getIpAddressinString(ip2, args32[1]);
|
||||
char mac[MAC_ADDRESS_SIZE], mac2[MAC_ADDRESS_SIZE];
|
||||
getMacAddressinString(mac, MAC_ADDRESS_SIZE, args64[0]);
|
||||
getMacAddressinString(mac2, MAC_ADDRESS_SIZE, args64[1]);
|
||||
@ -9251,11 +9261,11 @@ int set_dest_udp_list(int file_des) {
|
||||
#else
|
||||
// only set
|
||||
if (Server_VerifyLock() == OK) {
|
||||
int entry = args[0];
|
||||
int entry = arg;
|
||||
LOG(logINFOBLUE,
|
||||
("Setting udp dest. [%d]: [port %d, port2 %d, ip %s, ip2 %s, "
|
||||
("Setting udp dest. [%d]: [port %hu, port2 %hu, ip %s, ip2 %s, "
|
||||
"mac %s, mac2 %s]\n",
|
||||
entry, args[1], args[2], ip, ip2, mac, mac2));
|
||||
entry, args16[0], args16[1], ip, ip2, mac, mac2));
|
||||
|
||||
if (entry < 1 || entry >= MAX_UDP_DESTINATION) {
|
||||
ret = FAIL;
|
||||
@ -9266,7 +9276,7 @@ int set_dest_udp_list(int file_des) {
|
||||
LOG(logERROR, (mess));
|
||||
}
|
||||
#if defined(EIGERD) || defined(MYTHEN3D)
|
||||
else if (args[4] != 0 || args64[1] != 0) {
|
||||
else if (args32[1] != 0 || args64[1] != 0) {
|
||||
ret = FAIL;
|
||||
strcpy(mess, "Could not set udp destination. ip2 and mac2 not "
|
||||
"implemented for this detector.\n");
|
||||
@ -9275,17 +9285,17 @@ int set_dest_udp_list(int file_des) {
|
||||
#endif
|
||||
else {
|
||||
if (check_detector_idle("set udp destination list entries") == OK) {
|
||||
if (args[1] != 0) {
|
||||
udpDetails[entry].dstport = args[1];
|
||||
if (args16[0] != 0) {
|
||||
udpDetails[entry].dstport = args16[0];
|
||||
}
|
||||
if (args[2] != 0) {
|
||||
udpDetails[entry].dstport2 = args[2];
|
||||
if (args16[1] != 0) {
|
||||
udpDetails[entry].dstport2 = args16[1];
|
||||
}
|
||||
if (args[3] != 0) {
|
||||
udpDetails[entry].dstip = args[3];
|
||||
if (args32[0] != 0) {
|
||||
udpDetails[entry].dstip = args32[0];
|
||||
}
|
||||
if (args[4] != 0) {
|
||||
udpDetails[entry].dstip2 = args[4];
|
||||
if (args32[1] != 0) {
|
||||
udpDetails[entry].dstip2 = args32[1];
|
||||
}
|
||||
if (args64[0] != 0) {
|
||||
udpDetails[entry].dstmac = args64[0];
|
||||
|
@ -66,7 +66,7 @@ class Detector {
|
||||
|
||||
/** connects to n servers at local host starting at specific control port.
|
||||
* Every virtual server will have a stop port (control port + 1) */
|
||||
void setVirtualDetectorServers(int numServers, int startingPort);
|
||||
void setVirtualDetectorServers(int numServers, uint16_t startingPort);
|
||||
|
||||
/** Gets shared memory ID */
|
||||
int getShmId() const;
|
||||
@ -791,20 +791,20 @@ class Detector {
|
||||
*/
|
||||
void setDestinationUDPMAC2(const MacAddr mac, Positions pos = {});
|
||||
|
||||
Result<int> getDestinationUDPPort(Positions pos = {}) const;
|
||||
Result<uint16_t> getDestinationUDPPort(Positions pos = {}) const;
|
||||
|
||||
/** Default is 50001. \n If module_id is -1, ports for each module is
|
||||
* calculated (incremented by 1 if no 2nd interface) */
|
||||
void setDestinationUDPPort(int port, int module_id = -1);
|
||||
void setDestinationUDPPort(uint16_t port, int module_id = -1);
|
||||
|
||||
/** [Eiger] right port[Jungfrau][Moench] bottom half [Gotthard2] veto
|
||||
* debugging */
|
||||
Result<int> getDestinationUDPPort2(Positions pos = {}) const;
|
||||
Result<uint16_t> getDestinationUDPPort2(Positions pos = {}) const;
|
||||
|
||||
/** [Eiger] right port[Jungfrau][Moench] bottom half [Gotthard2] veto
|
||||
* debugging \n Default is 50002. \n If module_id is -1, ports for each
|
||||
* module is calculated (incremented by 1 if no 2nd interface)*/
|
||||
void setDestinationUDPPort2(int port, int module_id = -1);
|
||||
void setDestinationUDPPort2(uint16_t port, int module_id = -1);
|
||||
|
||||
/** Reconfigures Detector with UDP destination. More for debugging as the
|
||||
* configuration is done automatically when the detector has sufficient UDP
|
||||
@ -904,14 +904,14 @@ class Detector {
|
||||
/** multiple rx hostnames. Single element will set it for all */
|
||||
void setRxHostname(const std::vector<std::string> &name);
|
||||
|
||||
Result<int> getRxPort(Positions pos = {}) const;
|
||||
Result<uint16_t> getRxPort(Positions pos = {}) const;
|
||||
|
||||
/** TCP port for client-receiver communication. \n
|
||||
* Default is 1954. \n Must be different if multiple receivers on same pc.
|
||||
* \n Must be first command to set a receiver parameter to be able to
|
||||
* communicate. \n Multi command will automatically increment port for
|
||||
* individual modules.*/
|
||||
void setRxPort(int port, int module_id = -1);
|
||||
void setRxPort(uint16_t port, int module_id = -1);
|
||||
|
||||
Result<int> getRxFifoDepth(Positions pos = {}) const;
|
||||
|
||||
@ -1089,7 +1089,7 @@ class Detector {
|
||||
*/
|
||||
void setRxZmqStartingFrame(int fnum, Positions pos = {});
|
||||
|
||||
Result<int> getRxZmqPort(Positions pos = {}) const;
|
||||
Result<uint16_t> getRxZmqPort(Positions pos = {}) const;
|
||||
|
||||
/** Zmq port for data to be streamed out of the receiver. \n
|
||||
* Also restarts receiver zmq streaming if enabled. \n Default is 30001. \n
|
||||
@ -1098,7 +1098,7 @@ class Detector {
|
||||
* no 2nd interface). \n Restarts receiver zmq sockets only if it was
|
||||
* already enabled
|
||||
*/
|
||||
void setRxZmqPort(int port, int module_id = -1);
|
||||
void setRxZmqPort(uint16_t port, int module_id = -1);
|
||||
|
||||
Result<IpAddr> getRxZmqIP(Positions pos = {}) const;
|
||||
|
||||
@ -1108,7 +1108,7 @@ class Detector {
|
||||
* receiver. */
|
||||
void setRxZmqIP(const IpAddr ip, Positions pos = {});
|
||||
|
||||
Result<int> getClientZmqPort(Positions pos = {}) const;
|
||||
Result<uint16_t> getClientZmqPort(Positions pos = {}) const;
|
||||
|
||||
/** Port number to listen to zmq data streamed out from receiver or
|
||||
* intermediate process. \n Must be different for every detector (and udp
|
||||
@ -1117,7 +1117,7 @@ class Detector {
|
||||
* sockets only if it was already enabled \n Default connects to receiver
|
||||
* zmq streaming out port (30001).
|
||||
*/
|
||||
void setClientZmqPort(int port, int module_id = -1);
|
||||
void setClientZmqPort(uint16_t port, int module_id = -1);
|
||||
|
||||
Result<IpAddr> getClientZmqIp(Positions pos = {}) const;
|
||||
|
||||
@ -2068,18 +2068,18 @@ class Detector {
|
||||
* *
|
||||
* ************************************************/
|
||||
|
||||
Result<int> getControlPort(Positions pos = {}) const;
|
||||
Result<uint16_t> getControlPort(Positions pos = {}) const;
|
||||
|
||||
/** Detector Control TCP port (for client communication with Detector
|
||||
* control server) Default is 1952. Normally unchanged. Set different ports
|
||||
* for virtual servers on same pc */
|
||||
void setControlPort(int value, Positions pos = {});
|
||||
void setControlPort(uint16_t value, Positions pos = {});
|
||||
|
||||
Result<int> getStopPort(Positions pos = {}) const;
|
||||
Result<uint16_t> getStopPort(Positions pos = {}) const;
|
||||
|
||||
/** Port number of the stop server on detector for detector-client tcp
|
||||
* interface. Default is 1953. Normally unchanged. */
|
||||
void setStopPort(int value, Positions pos = {});
|
||||
void setStopPort(uint16_t value, Positions pos = {});
|
||||
|
||||
Result<bool> getDetectorLock(Positions pos = {}) const;
|
||||
|
||||
@ -2112,7 +2112,7 @@ class Detector {
|
||||
///@}
|
||||
|
||||
private:
|
||||
std::vector<int> getPortNumbers(int start_port);
|
||||
std::vector<uint16_t> getValidPortNumbers(uint16_t start_port);
|
||||
void updateRxRateCorrections();
|
||||
void setNumberofUDPInterfaces_(int n, Positions pos);
|
||||
};
|
||||
|
@ -197,7 +197,7 @@ std::string CmdProxy::VirtualServer(int action) {
|
||||
throw RuntimeError("Cannot execute this at module level");
|
||||
}
|
||||
det->setVirtualDetectorServers(StringTo<int>(args[0]),
|
||||
StringTo<int>(args[1]));
|
||||
StringTo<uint16_t>(args[1]));
|
||||
os << ToString(args);
|
||||
} else {
|
||||
throw RuntimeError("Unknown action");
|
||||
|
@ -187,7 +187,6 @@ namespace sls {
|
||||
return os.str(); \
|
||||
}
|
||||
|
||||
/** int or enum */
|
||||
#define INTEGER_COMMAND_VEC_ID_GET(CMDNAME, GETFCN, SETFCN, CONV, HLPSTR) \
|
||||
std::string CMDNAME(const int action) { \
|
||||
std::ostringstream os; \
|
||||
@ -1976,14 +1975,14 @@ class CmdProxy {
|
||||
|
||||
INTEGER_COMMAND_VEC_ID_GET(
|
||||
udp_dstport, getDestinationUDPPort, setDestinationUDPPort,
|
||||
StringTo<int>,
|
||||
StringTo<uint16_t>,
|
||||
"[n]\n\tPort number of the receiver (destination) udp "
|
||||
"interface. Default is 50001. \n\tIf multi command, ports for each "
|
||||
"module is calculated (incremented by 1 if no 2nd interface)");
|
||||
|
||||
INTEGER_COMMAND_VEC_ID_GET(
|
||||
udp_dstport2, getDestinationUDPPort2, setDestinationUDPPort2,
|
||||
StringTo<int>,
|
||||
StringTo<uint16_t>,
|
||||
"[n]\n\t[Jungfrau][Moench][Eiger][Gotthard2] Port number of the "
|
||||
"receiver (destination) udp interface 2. Default is 50002. "
|
||||
"\n\tIf multi command, ports for each module is calculated "
|
||||
@ -2041,7 +2040,7 @@ class CmdProxy {
|
||||
/* Receiver Config */
|
||||
|
||||
INTEGER_COMMAND_VEC_ID_GET(
|
||||
rx_tcpport, getRxPort, setRxPort, StringTo<int>,
|
||||
rx_tcpport, getRxPort, setRxPort, StringTo<uint16_t>,
|
||||
"[port]\n\tTCP port for client-receiver communication. Default is "
|
||||
"1954. Must be different if multiple receivers on same pc. Must be "
|
||||
"first command to set a receiver parameter. Multi command will "
|
||||
@ -2172,7 +2171,7 @@ class CmdProxy {
|
||||
"and then depending on the rx zmq frequency/ timer");
|
||||
|
||||
INTEGER_COMMAND_VEC_ID_GET(
|
||||
rx_zmqport, getRxZmqPort, setRxZmqPort, StringTo<int>,
|
||||
rx_zmqport, getRxZmqPort, setRxZmqPort, StringTo<uint16_t>,
|
||||
"[port]\n\tZmq port for data to be streamed out of the receiver. "
|
||||
"Also restarts receiver zmq streaming if enabled. Default is 30001. "
|
||||
"Modified only when using an intermediate process between receiver and "
|
||||
@ -2180,7 +2179,7 @@ class CmdProxy {
|
||||
"Multi command will automatically increment for individual modules.");
|
||||
|
||||
INTEGER_COMMAND_VEC_ID_GET(
|
||||
zmqport, getClientZmqPort, setClientZmqPort, StringTo<int>,
|
||||
zmqport, getClientZmqPort, setClientZmqPort, StringTo<uint16_t>,
|
||||
"[port]\n\tZmq port in client(gui) or intermediate process for "
|
||||
"data to be streamed to from receiver. Default connects to receiver "
|
||||
"zmq streaming out port (30001). Modified only when using an "
|
||||
@ -2619,13 +2618,13 @@ class CmdProxy {
|
||||
/* Insignificant */
|
||||
|
||||
INTEGER_COMMAND_VEC_ID(
|
||||
port, getControlPort, setControlPort, StringTo<int>,
|
||||
port, getControlPort, setControlPort, StringTo<uint16_t>,
|
||||
"[n]\n\tPort number of the control server on detector for "
|
||||
"detector-client tcp interface. Default is 1952. Normally unchanged. "
|
||||
"Set different ports for virtual servers on same pc.");
|
||||
|
||||
INTEGER_COMMAND_VEC_ID(
|
||||
stopport, getStopPort, setStopPort, StringTo<int>,
|
||||
stopport, getStopPort, setStopPort, StringTo<uint16_t>,
|
||||
"[n]\n\tPort number of the stop server on detector for detector-client "
|
||||
"tcp interface. Default is 1953. Normally unchanged.");
|
||||
|
||||
|
@ -107,7 +107,9 @@ void Detector::setHostname(const std::vector<std::string> &hostname) {
|
||||
pimpl->setHostname(hostname);
|
||||
}
|
||||
|
||||
void Detector::setVirtualDetectorServers(int numServers, int startingPort) {
|
||||
void Detector::setVirtualDetectorServers(int numServers,
|
||||
uint16_t startingPort) {
|
||||
validatePortRange(startingPort, numServers * 2);
|
||||
pimpl->setVirtualDetectorServers(numServers, startingPort);
|
||||
}
|
||||
|
||||
@ -982,10 +984,10 @@ void Detector::setNumberofUDPInterfaces_(int n, Positions pos) {
|
||||
throw RuntimeError("No modules added.");
|
||||
}
|
||||
bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
|
||||
int clientStartingPort = getClientZmqPort({0}).squash(0);
|
||||
uint16_t clientStartingPort = getClientZmqPort({0}).squash(0);
|
||||
bool useReceiver = getUseReceiverFlag().squash(false);
|
||||
bool previouslyReceiverStreaming = false;
|
||||
int rxStartingPort = 0;
|
||||
uint16_t rxStartingPort = 0;
|
||||
if (useReceiver) {
|
||||
previouslyReceiverStreaming = getRxZmqDataStream(pos).squash(true);
|
||||
rxStartingPort = getRxZmqPort({0}).squash(0);
|
||||
@ -1108,34 +1110,36 @@ void Detector::setDestinationUDPMAC2(const MacAddr mac, Positions pos) {
|
||||
pimpl->Parallel(&Module::setDestinationUDPMAC2, pos, mac);
|
||||
}
|
||||
|
||||
Result<int> Detector::getDestinationUDPPort(Positions pos) const {
|
||||
Result<uint16_t> Detector::getDestinationUDPPort(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getDestinationUDPPort, pos);
|
||||
}
|
||||
|
||||
void Detector::setDestinationUDPPort(int port, int module_id) {
|
||||
void Detector::setDestinationUDPPort(uint16_t port, int module_id) {
|
||||
if (module_id == -1) {
|
||||
std::vector<int> port_list = getPortNumbers(port);
|
||||
std::vector<uint16_t> port_list = getValidPortNumbers(port);
|
||||
for (int idet = 0; idet < size(); ++idet) {
|
||||
pimpl->Parallel(&Module::setDestinationUDPPort, {idet},
|
||||
port_list[idet]);
|
||||
}
|
||||
} else {
|
||||
validatePortNumber(port);
|
||||
pimpl->Parallel(&Module::setDestinationUDPPort, {module_id}, port);
|
||||
}
|
||||
}
|
||||
|
||||
Result<int> Detector::getDestinationUDPPort2(Positions pos) const {
|
||||
Result<uint16_t> Detector::getDestinationUDPPort2(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getDestinationUDPPort2, pos);
|
||||
}
|
||||
|
||||
void Detector::setDestinationUDPPort2(int port, int module_id) {
|
||||
void Detector::setDestinationUDPPort2(uint16_t port, int module_id) {
|
||||
if (module_id == -1) {
|
||||
std::vector<int> port_list = getPortNumbers(port);
|
||||
std::vector<uint16_t> port_list = getValidPortNumbers(port);
|
||||
for (int idet = 0; idet < size(); ++idet) {
|
||||
pimpl->Parallel(&Module::setDestinationUDPPort2, {idet},
|
||||
port_list[idet]);
|
||||
}
|
||||
} else {
|
||||
validatePortNumber(port);
|
||||
pimpl->Parallel(&Module::setDestinationUDPPort2, {module_id}, port);
|
||||
}
|
||||
}
|
||||
@ -1235,21 +1239,23 @@ void Detector::setRxHostname(const std::vector<std::string> &name) {
|
||||
updateRxRateCorrections();
|
||||
}
|
||||
|
||||
Result<int> Detector::getRxPort(Positions pos) const {
|
||||
Result<uint16_t> Detector::getRxPort(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getReceiverPort, pos);
|
||||
}
|
||||
|
||||
void Detector::setRxPort(int port, int module_id) {
|
||||
void Detector::setRxPort(uint16_t port, int module_id) {
|
||||
if (module_id == -1) {
|
||||
std::vector<int> port_list(size());
|
||||
for (auto &it : port_list) {
|
||||
it = port++;
|
||||
}
|
||||
validatePortRange(port, size() - 1);
|
||||
|
||||
std::vector<uint16_t> port_list(size());
|
||||
std::iota(std::begin(port_list), std::end(port_list), port);
|
||||
|
||||
// no need to verify hostname-port combo as unique port(incremented)
|
||||
for (int idet = 0; idet < size(); ++idet) {
|
||||
pimpl->Parallel(&Module::setReceiverPort, {idet}, port_list[idet]);
|
||||
}
|
||||
} else {
|
||||
validatePortNumber(port);
|
||||
pimpl->verifyUniqueRxHost(port, module_id);
|
||||
pimpl->Parallel(&Module::setReceiverPort, {module_id}, port);
|
||||
}
|
||||
@ -1440,20 +1446,21 @@ void Detector::setRxZmqStartingFrame(int fnum, Positions pos) {
|
||||
pimpl->Parallel(&Module::setReceiverStreamingStartingFrame, pos, fnum);
|
||||
}
|
||||
|
||||
Result<int> Detector::getRxZmqPort(Positions pos) const {
|
||||
Result<uint16_t> Detector::getRxZmqPort(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getReceiverStreamingPort, pos);
|
||||
}
|
||||
|
||||
void Detector::setRxZmqPort(int port, int module_id) {
|
||||
void Detector::setRxZmqPort(uint16_t port, int module_id) {
|
||||
bool previouslyReceiverStreaming =
|
||||
getRxZmqDataStream(std::vector<int>{module_id}).squash(false);
|
||||
if (module_id == -1) {
|
||||
std::vector<int> port_list = getPortNumbers(port);
|
||||
std::vector<uint16_t> port_list = getValidPortNumbers(port);
|
||||
for (int idet = 0; idet < size(); ++idet) {
|
||||
pimpl->Parallel(&Module::setReceiverStreamingPort, {idet},
|
||||
port_list[idet]);
|
||||
}
|
||||
} else {
|
||||
validatePortNumber(port);
|
||||
pimpl->Parallel(&Module::setReceiverStreamingPort, {module_id}, port);
|
||||
}
|
||||
if (previouslyReceiverStreaming) {
|
||||
@ -1475,19 +1482,20 @@ void Detector::setRxZmqIP(const IpAddr ip, Positions pos) {
|
||||
}
|
||||
}
|
||||
|
||||
Result<int> Detector::getClientZmqPort(Positions pos) const {
|
||||
Result<uint16_t> Detector::getClientZmqPort(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getClientStreamingPort, pos);
|
||||
}
|
||||
|
||||
void Detector::setClientZmqPort(int port, int module_id) {
|
||||
void Detector::setClientZmqPort(uint16_t port, int module_id) {
|
||||
bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
|
||||
if (module_id == -1) {
|
||||
std::vector<int> port_list = getPortNumbers(port);
|
||||
std::vector<uint16_t> port_list = getValidPortNumbers(port);
|
||||
for (int idet = 0; idet < size(); ++idet) {
|
||||
pimpl->Parallel(&Module::setClientStreamingPort, {idet},
|
||||
port_list[idet]);
|
||||
}
|
||||
} else {
|
||||
validatePortNumber(port);
|
||||
pimpl->Parallel(&Module::setClientStreamingPort, {module_id}, port);
|
||||
}
|
||||
if (previouslyClientStreaming) {
|
||||
@ -2665,21 +2673,23 @@ void Detector::setADCInvert(uint32_t value, Positions pos) {
|
||||
|
||||
// Insignificant
|
||||
|
||||
Result<int> Detector::getControlPort(Positions pos) const {
|
||||
Result<uint16_t> Detector::getControlPort(Positions pos) const {
|
||||
return pimpl->Parallel(&Module::getControlPort, pos);
|
||||
}
|
||||
|
||||
void Detector::setControlPort(int value, Positions pos) {
|
||||
void Detector::setControlPort(uint16_t value, Positions pos) {
|
||||
validatePortNumber(value);
|
||||
pimpl->verifyUniqueDetHost(value, pos);
|
||||
pimpl->Parallel(&Module::setControlPort, pos, value);
|
||||
}
|
||||
|
||||
Result<int> Detector::getStopPort(Positions pos) const {
|
||||
Result<uint16_t> Detector::getStopPort(Positions pos) const {
|
||||
// not verifying unique stop port (control port is sufficient)
|
||||
return pimpl->Parallel(&Module::getStopPort, pos);
|
||||
}
|
||||
|
||||
void Detector::setStopPort(int value, Positions pos) {
|
||||
void Detector::setStopPort(uint16_t value, Positions pos) {
|
||||
validatePortNumber(value);
|
||||
pimpl->Parallel(&Module::setStopPort, pos, value);
|
||||
}
|
||||
|
||||
@ -2714,13 +2724,17 @@ Result<ns> Detector::getMeasurementTime(Positions pos) const {
|
||||
|
||||
std::string Detector::getUserDetails() const { return pimpl->getUserDetails(); }
|
||||
|
||||
std::vector<int> Detector::getPortNumbers(int start_port) {
|
||||
std::vector<uint16_t> Detector::getValidPortNumbers(uint16_t start_port) {
|
||||
int num_sockets_per_detector = getNumberofUDPInterfaces({}).tsquash(
|
||||
"Number of UDP Interfaces is not consistent among modules");
|
||||
std::vector<int> res;
|
||||
|
||||
validatePortRange(start_port, (size() - 1) * num_sockets_per_detector);
|
||||
|
||||
std::vector<uint16_t> res;
|
||||
res.reserve(size());
|
||||
for (int idet = 0; idet < size(); ++idet) {
|
||||
res.push_back(start_port + (idet * num_sockets_per_detector));
|
||||
uint16_t port = start_port + (idet * num_sockets_per_detector);
|
||||
res.push_back(port);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
@ -242,7 +242,8 @@ std::string DetectorImpl::exec(const char *cmd) {
|
||||
return result;
|
||||
}
|
||||
|
||||
void DetectorImpl::setVirtualDetectorServers(const int numdet, const int port) {
|
||||
void DetectorImpl::setVirtualDetectorServers(const int numdet,
|
||||
const uint16_t port) {
|
||||
std::vector<std::string> hostnames;
|
||||
for (int i = 0; i < numdet; ++i) {
|
||||
// * 2 is for control and stop port
|
||||
@ -283,7 +284,7 @@ void DetectorImpl::addModule(const std::string &name) {
|
||||
LOG(logINFO) << "Adding module " << name;
|
||||
auto host = verifyUniqueDetHost(name);
|
||||
std::string hostname = host.first;
|
||||
int port = host.second;
|
||||
uint16_t port = host.second;
|
||||
|
||||
// get type by connecting
|
||||
detectorType type = Module::getTypeFromDetector(hostname, port);
|
||||
@ -1583,41 +1584,41 @@ defs::xy DetectorImpl::calculatePosition(int moduleIndex,
|
||||
return pos;
|
||||
}
|
||||
|
||||
void DetectorImpl::verifyUniqueDetHost(const int port,
|
||||
void DetectorImpl::verifyUniqueDetHost(const uint16_t port,
|
||||
std::vector<int> positions) const {
|
||||
// port for given positions
|
||||
if (positions.empty() || (positions.size() == 1 && positions[0] == -1)) {
|
||||
positions.resize(modules.size());
|
||||
std::iota(begin(positions), end(positions), 0);
|
||||
}
|
||||
std::vector<std::pair<std::string, int>> hosts(size());
|
||||
std::vector<std::pair<std::string, uint16_t>> hosts(size());
|
||||
for (auto it : positions) {
|
||||
hosts[it].second = port;
|
||||
}
|
||||
verifyUniqueHost(true, hosts);
|
||||
}
|
||||
|
||||
void DetectorImpl::verifyUniqueRxHost(const int port,
|
||||
void DetectorImpl::verifyUniqueRxHost(const uint16_t port,
|
||||
const int moduleId) const {
|
||||
std::vector<std::pair<std::string, int>> hosts(size());
|
||||
std::vector<std::pair<std::string, uint16_t>> hosts(size());
|
||||
hosts[moduleId].second = port;
|
||||
verifyUniqueHost(false, hosts);
|
||||
}
|
||||
|
||||
std::pair<std::string, int>
|
||||
std::pair<std::string, uint16_t>
|
||||
DetectorImpl::verifyUniqueDetHost(const std::string &name) {
|
||||
// extract port
|
||||
// C++17 could be auto [hostname, port] = ParseHostPort(name);
|
||||
auto res = ParseHostPort(name);
|
||||
std::string hostname = res.first;
|
||||
int port = res.second;
|
||||
uint16_t port = res.second;
|
||||
if (port == 0) {
|
||||
port = DEFAULT_TCP_CNTRL_PORTNO;
|
||||
}
|
||||
|
||||
int detSize = size();
|
||||
// mod not yet added
|
||||
std::vector<std::pair<std::string, int>> hosts(detSize + 1);
|
||||
std::vector<std::pair<std::string, uint16_t>> hosts(detSize + 1);
|
||||
hosts[detSize].first = hostname;
|
||||
hosts[detSize].second = port;
|
||||
|
||||
@ -1625,7 +1626,7 @@ DetectorImpl::verifyUniqueDetHost(const std::string &name) {
|
||||
return std::make_pair(hostname, port);
|
||||
}
|
||||
|
||||
std::pair<std::string, int>
|
||||
std::pair<std::string, uint16_t>
|
||||
DetectorImpl::verifyUniqueRxHost(const std::string &name,
|
||||
std::vector<int> positions) const {
|
||||
// no checks if setting to none
|
||||
@ -1636,7 +1637,7 @@ DetectorImpl::verifyUniqueRxHost(const std::string &name,
|
||||
// C++17 could be auto [hostname, port] = ParseHostPort(name);
|
||||
auto res = ParseHostPort(name);
|
||||
std::string hostname = res.first;
|
||||
int port = res.second;
|
||||
uint16_t port = res.second;
|
||||
|
||||
// hostname and port for given positions
|
||||
if (positions.empty() || (positions.size() == 1 && positions[0] == -1)) {
|
||||
@ -1644,7 +1645,7 @@ DetectorImpl::verifyUniqueRxHost(const std::string &name,
|
||||
std::iota(begin(positions), end(positions), 0);
|
||||
}
|
||||
|
||||
std::vector<std::pair<std::string, int>> hosts(size());
|
||||
std::vector<std::pair<std::string, uint16_t>> hosts(size());
|
||||
for (auto it : positions) {
|
||||
hosts[it].first = hostname;
|
||||
hosts[it].second = port;
|
||||
@ -1654,7 +1655,7 @@ DetectorImpl::verifyUniqueRxHost(const std::string &name,
|
||||
return std::make_pair(hostname, port);
|
||||
}
|
||||
|
||||
std::vector<std::pair<std::string, int>>
|
||||
std::vector<std::pair<std::string, uint16_t>>
|
||||
DetectorImpl::verifyUniqueRxHost(const std::vector<std::string> &names) const {
|
||||
if ((int)names.size() != size()) {
|
||||
throw RuntimeError(
|
||||
@ -1663,7 +1664,7 @@ DetectorImpl::verifyUniqueRxHost(const std::vector<std::string> &names) const {
|
||||
}
|
||||
|
||||
// extract ports
|
||||
std::vector<std::pair<std::string, int>> hosts;
|
||||
std::vector<std::pair<std::string, uint16_t>> hosts;
|
||||
for (const auto &name : names) {
|
||||
hosts.push_back(ParseHostPort(name));
|
||||
}
|
||||
@ -1673,7 +1674,7 @@ DetectorImpl::verifyUniqueRxHost(const std::vector<std::string> &names) const {
|
||||
}
|
||||
|
||||
void DetectorImpl::verifyUniqueHost(
|
||||
bool isDet, std::vector<std::pair<std::string, int>> &hosts) const {
|
||||
bool isDet, std::vector<std::pair<std::string, uint16_t>> &hosts) const {
|
||||
|
||||
// fill from shm if not provided
|
||||
for (int i = 0; i != size(); ++i) {
|
||||
@ -1689,7 +1690,7 @@ void DetectorImpl::verifyUniqueHost(
|
||||
|
||||
// remove the ones without a hostname
|
||||
hosts.erase(std::remove_if(hosts.begin(), hosts.end(),
|
||||
[](const std::pair<std::string, int> &x) {
|
||||
[](const std::pair<std::string, uint16_t> &x) {
|
||||
return (x.first == "none" ||
|
||||
x.first.empty());
|
||||
}),
|
||||
|
@ -220,7 +220,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
|
||||
* @param numdet number of modules
|
||||
* @param port starting port number
|
||||
*/
|
||||
void setVirtualDetectorServers(const int numdet, const int port);
|
||||
void setVirtualDetectorServers(const int numdet, const uint16_t port);
|
||||
|
||||
/** Sets the hostname of all sls modules in shared memory and updates
|
||||
* local cache */
|
||||
@ -307,14 +307,16 @@ class DetectorImpl : public virtual slsDetectorDefs {
|
||||
void setDefaultDac(defs::dacIndex index, int defaultValue,
|
||||
defs::detectorSettings sett, Positions pos);
|
||||
|
||||
void verifyUniqueDetHost(const int port, std::vector<int> positions) const;
|
||||
void verifyUniqueRxHost(const int port, const int moduleId) const;
|
||||
void verifyUniqueDetHost(const uint16_t port,
|
||||
std::vector<int> positions) const;
|
||||
void verifyUniqueRxHost(const uint16_t port, const int moduleId) const;
|
||||
|
||||
std::pair<std::string, int> verifyUniqueDetHost(const std::string &name);
|
||||
std::pair<std::string, int>
|
||||
std::pair<std::string, uint16_t>
|
||||
verifyUniqueDetHost(const std::string &name);
|
||||
std::pair<std::string, uint16_t>
|
||||
verifyUniqueRxHost(const std::string &name,
|
||||
std::vector<int> positions) const;
|
||||
std::vector<std::pair<std::string, int>>
|
||||
std::vector<std::pair<std::string, uint16_t>>
|
||||
verifyUniqueRxHost(const std::vector<std::string> &names) const;
|
||||
|
||||
defs::ROI getRxROI() const;
|
||||
@ -439,9 +441,8 @@ class DetectorImpl : public virtual slsDetectorDefs {
|
||||
defs::xy getPortGeometry() const;
|
||||
defs::xy calculatePosition(int moduleIndex, defs::xy geometry) const;
|
||||
|
||||
void
|
||||
verifyUniqueHost(bool isDet,
|
||||
std::vector<std::pair<std::string, int>> &hosts) const;
|
||||
void verifyUniqueHost(
|
||||
bool isDet, std::vector<std::pair<std::string, uint16_t>> &hosts) const;
|
||||
|
||||
const int detectorIndex{0};
|
||||
SharedMemory<sharedDetector> shm{0, -1};
|
||||
|
@ -165,11 +165,15 @@ std::string Module::getReceiverSoftwareVersion() const {
|
||||
|
||||
// static function
|
||||
slsDetectorDefs::detectorType
|
||||
Module::getTypeFromDetector(const std::string &hostname, int cport) {
|
||||
Module::getTypeFromDetector(const std::string &hostname, uint16_t cport) {
|
||||
LOG(logDEBUG1) << "Getting Module type ";
|
||||
ClientSocket socket("Detector", hostname, cport);
|
||||
socket.Send(F_GET_DETECTOR_TYPE);
|
||||
socket.Receive<int>(); // TODO! Should we look at this OK/FAIL?
|
||||
if (socket.Receive<int>() == FAIL) {
|
||||
throw RuntimeError("Detector (" + hostname + ", " +
|
||||
std::to_string(cport) +
|
||||
") returned error at getting detector type");
|
||||
}
|
||||
auto retval = socket.Receive<detectorType>();
|
||||
LOG(logDEBUG1) << "Module type is " << retval;
|
||||
return retval;
|
||||
@ -1241,22 +1245,22 @@ void Module::setDestinationUDPMAC2(const MacAddr mac) {
|
||||
sendToDetector(F_SET_DEST_UDP_MAC2, mac, nullptr);
|
||||
}
|
||||
|
||||
int Module::getDestinationUDPPort() const {
|
||||
return sendToDetector<int>(F_GET_DEST_UDP_PORT);
|
||||
uint16_t Module::getDestinationUDPPort() const {
|
||||
return sendToDetector<uint16_t>(F_GET_DEST_UDP_PORT);
|
||||
}
|
||||
|
||||
void Module::setDestinationUDPPort(const int port) {
|
||||
void Module::setDestinationUDPPort(const uint16_t port) {
|
||||
sendToDetector(F_SET_DEST_UDP_PORT, port, nullptr);
|
||||
if (shm()->useReceiverFlag) {
|
||||
sendToReceiver(F_SET_RECEIVER_UDP_PORT, port, nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
int Module::getDestinationUDPPort2() const {
|
||||
return sendToDetector<int>(F_GET_DEST_UDP_PORT2);
|
||||
uint16_t Module::getDestinationUDPPort2() const {
|
||||
return sendToDetector<uint16_t>(F_GET_DEST_UDP_PORT2);
|
||||
}
|
||||
|
||||
void Module::setDestinationUDPPort2(const int port) {
|
||||
void Module::setDestinationUDPPort2(const uint16_t port) {
|
||||
sendToDetector(F_SET_DEST_UDP_PORT2, port, nullptr);
|
||||
if (shm()->useReceiverFlag) {
|
||||
sendToReceiver(F_SET_RECEIVER_UDP_PORT2, port, nullptr);
|
||||
@ -1354,7 +1358,8 @@ std::string Module::getReceiverHostname() const {
|
||||
return std::string(shm()->rxHostname);
|
||||
}
|
||||
|
||||
void Module::setReceiverHostname(const std::string &hostname, const int port,
|
||||
void Module::setReceiverHostname(const std::string &hostname,
|
||||
const uint16_t port,
|
||||
const bool initialChecks) {
|
||||
{
|
||||
std::ostringstream oss;
|
||||
@ -1427,13 +1432,10 @@ void Module::setReceiverHostname(const std::string &hostname, const int port,
|
||||
updateReceiverStreamingIP();
|
||||
}
|
||||
|
||||
int Module::getReceiverPort() const { return shm()->rxTCPPort; }
|
||||
uint16_t Module::getReceiverPort() const { return shm()->rxTCPPort; }
|
||||
|
||||
int Module::setReceiverPort(int port_number) {
|
||||
if (port_number >= 0 && port_number != shm()->rxTCPPort) {
|
||||
shm()->rxTCPPort = port_number;
|
||||
}
|
||||
return shm()->rxTCPPort;
|
||||
void Module::setReceiverPort(uint16_t port_number) {
|
||||
shm()->rxTCPPort = port_number;
|
||||
}
|
||||
|
||||
int Module::getReceiverFifoDepth() const {
|
||||
@ -1645,11 +1647,11 @@ void Module::setReceiverStreamingStartingFrame(int fnum) {
|
||||
sendToReceiver(F_SET_RECEIVER_STREAMING_START_FNUM, fnum, nullptr);
|
||||
}
|
||||
|
||||
int Module::getReceiverStreamingPort() const {
|
||||
return sendToReceiver<int>(F_GET_RECEIVER_STREAMING_PORT);
|
||||
uint16_t Module::getReceiverStreamingPort() const {
|
||||
return sendToReceiver<uint16_t>(F_GET_RECEIVER_STREAMING_PORT);
|
||||
}
|
||||
|
||||
void Module::setReceiverStreamingPort(int port) {
|
||||
void Module::setReceiverStreamingPort(uint16_t port) {
|
||||
sendToReceiver(F_SET_RECEIVER_STREAMING_PORT, port, nullptr);
|
||||
}
|
||||
|
||||
@ -1668,9 +1670,9 @@ void Module::setReceiverStreamingIP(const IpAddr ip) {
|
||||
sendToReceiver(F_SET_RECEIVER_STREAMING_SRC_IP, ip, nullptr);
|
||||
}
|
||||
|
||||
int Module::getClientStreamingPort() const { return shm()->zmqport; }
|
||||
uint16_t Module::getClientStreamingPort() const { return shm()->zmqport; }
|
||||
|
||||
void Module::setClientStreamingPort(int port) { shm()->zmqport = port; }
|
||||
void Module::setClientStreamingPort(uint16_t port) { shm()->zmqport = port; }
|
||||
|
||||
IpAddr Module::getClientStreamingIP() const { return shm()->zmqip; }
|
||||
|
||||
@ -2839,15 +2841,17 @@ void Module::setADCInvert(uint32_t value) {
|
||||
}
|
||||
|
||||
// Insignificant
|
||||
int Module::getControlPort() const { return shm()->controlPort; }
|
||||
uint16_t Module::getControlPort() const { return shm()->controlPort; }
|
||||
|
||||
void Module::setControlPort(int port_number) {
|
||||
void Module::setControlPort(uint16_t port_number) {
|
||||
shm()->controlPort = port_number;
|
||||
}
|
||||
|
||||
int Module::getStopPort() const { return shm()->stopPort; }
|
||||
uint16_t Module::getStopPort() const { return shm()->stopPort; }
|
||||
|
||||
void Module::setStopPort(int port_number) { shm()->stopPort = port_number; }
|
||||
void Module::setStopPort(uint16_t port_number) {
|
||||
shm()->stopPort = port_number;
|
||||
}
|
||||
|
||||
bool Module::getLockDetector() const {
|
||||
return sendToDetector<int>(F_LOCK_SERVER, GET_FLAG);
|
||||
|
@ -19,7 +19,7 @@ namespace sls {
|
||||
class ServerInterface;
|
||||
|
||||
#define MODULE_SHMAPIVERSION 0x190726
|
||||
#define MODULE_SHMVERSION 0x200402
|
||||
#define MODULE_SHMVERSION 0x230913
|
||||
|
||||
/**
|
||||
* @short structure allocated in shared memory to store Module settings for
|
||||
@ -36,8 +36,8 @@ struct sharedModule {
|
||||
/** END OF FIXED PATTERN -----------------------------------------------*/
|
||||
|
||||
slsDetectorDefs::xy numberOfModule;
|
||||
int controlPort;
|
||||
int stopPort;
|
||||
uint16_t controlPort;
|
||||
uint16_t stopPort;
|
||||
char settingsDir[MAX_STR_LENGTH];
|
||||
/** list of the energies at which the Module has been trimmed */
|
||||
StaticVector<int, MAX_TRIMEN> trimEnergies;
|
||||
@ -46,11 +46,11 @@ struct sharedModule {
|
||||
slsDetectorDefs::xy nChip;
|
||||
int nDacs;
|
||||
char rxHostname[MAX_STR_LENGTH];
|
||||
int rxTCPPort;
|
||||
uint16_t rxTCPPort;
|
||||
/** if rxHostname and rxTCPPort can be connected to */
|
||||
bool useReceiverFlag;
|
||||
/** Listening tcp port from gui (only data) */
|
||||
int zmqport;
|
||||
uint16_t zmqport;
|
||||
/** Listening tcp ip address from gui (only data) **/
|
||||
IpAddr zmqip;
|
||||
int numUDPInterfaces;
|
||||
@ -102,7 +102,7 @@ class Module : public virtual slsDetectorDefs {
|
||||
std::string getReceiverSoftwareVersion() const;
|
||||
static detectorType
|
||||
getTypeFromDetector(const std::string &hostname,
|
||||
int cport = DEFAULT_TCP_CNTRL_PORTNO);
|
||||
uint16_t cport = DEFAULT_TCP_CNTRL_PORTNO);
|
||||
|
||||
/** Get Detector type from shared memory */
|
||||
detectorType getDetectorType() const;
|
||||
@ -261,10 +261,10 @@ class Module : public virtual slsDetectorDefs {
|
||||
void setDestinationUDPMAC(const MacAddr mac);
|
||||
MacAddr getDestinationUDPMAC2() const;
|
||||
void setDestinationUDPMAC2(const MacAddr mac);
|
||||
int getDestinationUDPPort() const;
|
||||
void setDestinationUDPPort(int udpport);
|
||||
int getDestinationUDPPort2() const;
|
||||
void setDestinationUDPPort2(int udpport);
|
||||
uint16_t getDestinationUDPPort() const;
|
||||
void setDestinationUDPPort(uint16_t udpport);
|
||||
uint16_t getDestinationUDPPort2() const;
|
||||
void setDestinationUDPPort2(uint16_t udpport);
|
||||
void reconfigureUDPDestination();
|
||||
void validateUDPConfiguration();
|
||||
std::string printReceiverConfiguration();
|
||||
@ -286,10 +286,10 @@ class Module : public virtual slsDetectorDefs {
|
||||
* ************************************************/
|
||||
bool getUseReceiverFlag() const;
|
||||
std::string getReceiverHostname() const;
|
||||
void setReceiverHostname(const std::string &hostname, const int port,
|
||||
void setReceiverHostname(const std::string &hostname, const uint16_t port,
|
||||
const bool initialChecks);
|
||||
int getReceiverPort() const;
|
||||
int setReceiverPort(int port_number);
|
||||
uint16_t getReceiverPort() const;
|
||||
void setReceiverPort(uint16_t port_number);
|
||||
int getReceiverFifoDepth() const;
|
||||
void setReceiverFifoDepth(int n_frames);
|
||||
bool getReceiverSilentMode() const;
|
||||
@ -349,12 +349,12 @@ class Module : public virtual slsDetectorDefs {
|
||||
void setReceiverStreamingTimer(int time_in_ms = 200);
|
||||
int getReceiverStreamingStartingFrame() const;
|
||||
void setReceiverStreamingStartingFrame(int fnum);
|
||||
int getReceiverStreamingPort() const;
|
||||
void setReceiverStreamingPort(int port);
|
||||
uint16_t getReceiverStreamingPort() const;
|
||||
void setReceiverStreamingPort(uint16_t port);
|
||||
IpAddr getReceiverStreamingIP() const;
|
||||
void setReceiverStreamingIP(const IpAddr ip);
|
||||
int getClientStreamingPort() const;
|
||||
void setClientStreamingPort(int port);
|
||||
uint16_t getClientStreamingPort() const;
|
||||
void setClientStreamingPort(uint16_t port);
|
||||
IpAddr getClientStreamingIP() const;
|
||||
void setClientStreamingIP(const IpAddr ip);
|
||||
int getReceiverStreamingHwm() const;
|
||||
@ -597,10 +597,10 @@ class Module : public virtual slsDetectorDefs {
|
||||
* Insignificant *
|
||||
* *
|
||||
* ************************************************/
|
||||
int getControlPort() const;
|
||||
void setControlPort(int port_number);
|
||||
int getStopPort() const;
|
||||
void setStopPort(int port_number);
|
||||
uint16_t getControlPort() const;
|
||||
void setControlPort(uint16_t port_number);
|
||||
uint16_t getStopPort() const;
|
||||
void setStopPort(uint16_t port_number);
|
||||
bool getLockDetector() const;
|
||||
void setLockDetector(bool lock);
|
||||
IpAddr getLastClientIP() const;
|
||||
|
@ -11,6 +11,26 @@ namespace sls {
|
||||
using test::GET;
|
||||
using test::PUT;
|
||||
|
||||
void test_valid_port(const std::string &command,
|
||||
const std::vector<std::string> &arguments, int detector_id,
|
||||
int action) {
|
||||
Detector det;
|
||||
CmdProxy proxy(&det);
|
||||
|
||||
std::vector<std::string> arg(arguments);
|
||||
if (arg.empty())
|
||||
arg.push_back("0");
|
||||
|
||||
int test_values[3] = {77797, -1, 0};
|
||||
for (int i = 0; i != 3; ++i) {
|
||||
int port_number = test_values[i];
|
||||
arg[arg.size() - 1] = std::to_string(port_number);
|
||||
REQUIRE_THROWS(proxy.Call(command, arg, detector_id, action));
|
||||
/*REQUIRE_THROWS_WITH(proxy.Call(command, arguments, detector_id,
|
||||
action), "Invalid port range. Must be between 1 - 65535.");*/
|
||||
}
|
||||
}
|
||||
|
||||
void test_dac(defs::dacIndex index, const std::string &dacname, int dacvalue) {
|
||||
Detector det;
|
||||
CmdProxy proxy(&det);
|
||||
|
@ -5,6 +5,10 @@
|
||||
|
||||
namespace sls {
|
||||
|
||||
void test_valid_port(const std::string &command,
|
||||
const std::vector<std::string> &arguments, int detector_id,
|
||||
int action);
|
||||
|
||||
void test_dac(slsDetectorDefs::dacIndex index, const std::string &dacname,
|
||||
int dacvalue);
|
||||
void test_onchip_dac(slsDetectorDefs::dacIndex index,
|
||||
|
@ -5,6 +5,7 @@
|
||||
#include "sls/Detector.h"
|
||||
#include "sls/Version.h"
|
||||
#include "sls/sls_detector_defs.h"
|
||||
#include "test-CmdProxy-global.h"
|
||||
#include <sstream>
|
||||
|
||||
#include "sls/versionAPI.h"
|
||||
@ -223,7 +224,7 @@ TEST_CASE("rx_tcpport", "[.cmd][.rx]") {
|
||||
CmdProxy proxy(&det);
|
||||
auto prev_val = det.getRxPort();
|
||||
|
||||
int port = 3500;
|
||||
uint16_t port = 3500;
|
||||
proxy.Call("rx_tcpport", {std::to_string(port)}, -1, PUT);
|
||||
for (int i = 0; i != det.size(); ++i) {
|
||||
std::ostringstream oss;
|
||||
@ -237,6 +238,22 @@ TEST_CASE("rx_tcpport", "[.cmd][.rx]") {
|
||||
proxy.Call("rx_tcpport", {}, i, GET, oss);
|
||||
REQUIRE(oss.str() == "rx_tcpport " + std::to_string(port + i) + '\n');
|
||||
}
|
||||
|
||||
test_valid_port("rx_tcpport", {}, -1, PUT);
|
||||
test_valid_port("rx_tcpport", {}, 0, PUT);
|
||||
// should fail for the second module
|
||||
if (det.size() > 1) {
|
||||
REQUIRE_THROWS(proxy.Call("rx_tcpport", {"65535"}, -1, PUT));
|
||||
auto rxHostname = det.getRxHostname().squash("none");
|
||||
if (rxHostname != "none") {
|
||||
std::ostringstream oss;
|
||||
for (int i = 0; i != det.size(); ++i) {
|
||||
oss << rxHostname << ":" << 65536 + i << "+";
|
||||
}
|
||||
REQUIRE_THROWS(proxy.Call("rx_hostname", {oss.str()}, -1, PUT));
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i != det.size(); ++i) {
|
||||
det.setRxPort(prev_val[i], i);
|
||||
}
|
||||
@ -810,7 +827,7 @@ TEST_CASE("rx_zmqport", "[.cmd][.rx]") {
|
||||
proxy.Call("numinterfaces", {"2"}, -1, PUT);
|
||||
socketsperdetector *= 2;
|
||||
}
|
||||
int port = 3500;
|
||||
uint16_t port = 3500;
|
||||
proxy.Call("rx_zmqport", {std::to_string(port)}, -1, PUT);
|
||||
for (int i = 0; i != det.size(); ++i) {
|
||||
std::ostringstream oss;
|
||||
@ -828,6 +845,14 @@ TEST_CASE("rx_zmqport", "[.cmd][.rx]") {
|
||||
std::to_string(port + i * socketsperdetector) +
|
||||
'\n');
|
||||
}
|
||||
|
||||
test_valid_port("rx_zmqport", {}, -1, PUT);
|
||||
test_valid_port("rx_zmqport", {}, 0, PUT);
|
||||
// should fail for the second module
|
||||
if (det.size() > 1) {
|
||||
REQUIRE_THROWS(proxy.Call("rx_zmqport", {"65535"}, -1, PUT));
|
||||
}
|
||||
|
||||
for (int i = 0; i != det.size(); ++i) {
|
||||
det.setRxZmqPort(prev_val_zmqport[i], i);
|
||||
}
|
||||
|
@ -5,6 +5,7 @@
|
||||
#include "sls/Detector.h"
|
||||
#include "sls/file_utils.h"
|
||||
#include "sls/sls_detector_defs.h"
|
||||
#include "test-CmdProxy-global.h"
|
||||
|
||||
#include <chrono>
|
||||
#include <sstream>
|
||||
@ -76,7 +77,13 @@ TEST_CASE("hostname", "[.cmd]") {
|
||||
REQUIRE_NOTHROW(proxy.Call("hostname", {}, -1, GET));
|
||||
}
|
||||
|
||||
// virtual: not testing
|
||||
TEST_CASE("virtual", "[.cmd]") {
|
||||
Detector det;
|
||||
CmdProxy proxy(&det);
|
||||
REQUIRE_THROWS(proxy.Call("virtual", {}, -1, GET));
|
||||
test_valid_port("virtual", {"1"}, -1, PUT);
|
||||
REQUIRE_THROWS(proxy.Call("virtual", {"3", "65534"}, -1, PUT));
|
||||
}
|
||||
|
||||
TEST_CASE("versions", "[.cmd]") {
|
||||
Detector det;
|
||||
@ -2693,6 +2700,12 @@ TEST_CASE("udp_dstport", "[.cmd]") {
|
||||
proxy.Call("udp_dstport", {"50084"}, -1, PUT, oss);
|
||||
REQUIRE(oss.str() == "udp_dstport 50084\n");
|
||||
}
|
||||
test_valid_port("udp_dstport", {}, -1, PUT);
|
||||
test_valid_port("udp_dstport", {}, 0, PUT);
|
||||
// should fail for the second module
|
||||
if (det.size() > 1) {
|
||||
REQUIRE_THROWS(proxy.Call("udp_dstport", {"65535"}, -1, PUT));
|
||||
}
|
||||
for (int i = 0; i != det.size(); ++i) {
|
||||
det.setDestinationUDPPort(prev_val[i], {i});
|
||||
}
|
||||
@ -2781,8 +2794,18 @@ TEST_CASE("udp_dstport2", "[.cmd]") {
|
||||
proxy.Call("udp_dstport2", {"50084"}, -1, PUT, oss);
|
||||
REQUIRE(oss.str() == "udp_dstport2 50084\n");
|
||||
}
|
||||
|
||||
test_valid_port("udp_dstport2", {}, -1, PUT);
|
||||
test_valid_port("udp_dstport2", {}, 0, PUT);
|
||||
// should fail for the second module
|
||||
if (det.size() > 1) {
|
||||
REQUIRE_THROWS(proxy.Call("udp_dstport2", {"65535"}, -1, PUT));
|
||||
}
|
||||
|
||||
for (int i = 0; i != det.size(); ++i) {
|
||||
det.setDestinationUDPPort2(prev_val[i], {i});
|
||||
if (prev_val[i] != 0) {
|
||||
det.setDestinationUDPPort2(prev_val[i], {i});
|
||||
}
|
||||
}
|
||||
} else {
|
||||
REQUIRE_THROWS(proxy.Call("udp_dstport2", {}, -1, GET));
|
||||
@ -2976,7 +2999,7 @@ TEST_CASE("zmqport", "[.cmd]") {
|
||||
det.setNumberofUDPInterfaces(2);
|
||||
socketsperdetector *= 2;
|
||||
}
|
||||
int port = 3500;
|
||||
uint16_t port = 3500;
|
||||
auto port_str = std::to_string(port);
|
||||
{
|
||||
std::ostringstream oss;
|
||||
@ -3005,6 +3028,12 @@ TEST_CASE("zmqport", "[.cmd]") {
|
||||
std::to_string(port + i * socketsperdetector) +
|
||||
'\n');
|
||||
}
|
||||
test_valid_port("zmqport", {}, -1, PUT);
|
||||
test_valid_port("zmqport", {}, 0, PUT);
|
||||
// should fail for the second module
|
||||
if (det.size() > 1) {
|
||||
REQUIRE_THROWS(proxy.Call("zmqport", {"65535"}, -1, PUT));
|
||||
}
|
||||
if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
|
||||
det.setNumberofUDPInterfaces(prev);
|
||||
}
|
||||
@ -3384,6 +3413,12 @@ TEST_CASE("port", "[.cmd]") {
|
||||
proxy.Call("port", {}, 0, GET, oss);
|
||||
REQUIRE(oss.str() == "port 1942\n");
|
||||
}
|
||||
test_valid_port("port", {}, -1, PUT);
|
||||
test_valid_port("port", {}, 0, PUT);
|
||||
// should fail for the second module
|
||||
if (det.size() > 1) {
|
||||
REQUIRE_THROWS(proxy.Call("port", {"65536"}, -1, PUT));
|
||||
}
|
||||
det.setControlPort(prev_val, {0});
|
||||
}
|
||||
|
||||
@ -3401,6 +3436,12 @@ TEST_CASE("stopport", "[.cmd]") {
|
||||
proxy.Call("stopport", {}, 0, GET, oss);
|
||||
REQUIRE(oss.str() == "stopport 1942\n");
|
||||
}
|
||||
test_valid_port("stopport", {}, -1, PUT);
|
||||
test_valid_port("stopport", {}, 0, PUT);
|
||||
// should fail for the second module
|
||||
if (det.size() > 1) {
|
||||
REQUIRE_THROWS(proxy.Call("stopport", {"65536"}, -1, PUT));
|
||||
}
|
||||
det.setStopPort(prev_val, {0});
|
||||
}
|
||||
|
||||
|
@ -28,7 +28,7 @@ class Receiver : private virtual slsDetectorDefs {
|
||||
* throws an exception in case of failure
|
||||
* @param tcpip_port_no TCP/IP port number
|
||||
*/
|
||||
Receiver(int tcpip_port_no = 1954);
|
||||
Receiver(uint16_t tcpip_port_no = 1954);
|
||||
|
||||
~Receiver();
|
||||
|
||||
|
@ -23,7 +23,7 @@ void BinaryDataFile::CreateFirstBinaryDataFile(const std::string &fNamePrefix,
|
||||
const uint64_t fIndex,
|
||||
const bool ovEnable,
|
||||
const bool sMode,
|
||||
const uint32_t uPortNumber,
|
||||
const uint16_t uPortNumber,
|
||||
const uint32_t mFramesPerFile) {
|
||||
|
||||
subFileIndex = 0;
|
||||
|
@ -16,7 +16,7 @@ class BinaryDataFile : private virtual slsDetectorDefs, public File {
|
||||
void CloseFile() override;
|
||||
void CreateFirstBinaryDataFile(const std::string &fNamePrefix,
|
||||
const uint64_t fIndex, const bool ovEnable,
|
||||
const bool sMode, const uint32_t uPortNumber,
|
||||
const bool sMode, const uint16_t uPortNumber,
|
||||
const uint32_t mFramesPerFile) override;
|
||||
|
||||
void WriteToFile(char *imageData, sls_receiver_header &header,
|
||||
|
@ -41,10 +41,9 @@ ClientInterface::~ClientInterface() {
|
||||
tcpThread->join();
|
||||
}
|
||||
|
||||
ClientInterface::ClientInterface(int portNumber)
|
||||
: detType(GOTTHARD),
|
||||
portNumber(portNumber > 0 ? portNumber : DEFAULT_TCP_RX_PORTNO),
|
||||
server(portNumber) {
|
||||
ClientInterface::ClientInterface(uint16_t portNumber)
|
||||
: detType(GOTTHARD), portNumber(portNumber), server(portNumber) {
|
||||
validatePortNumber(portNumber);
|
||||
functionTable();
|
||||
parentThreadId = gettid();
|
||||
tcpThread =
|
||||
@ -1064,9 +1063,12 @@ int ClientInterface::get_file_format(Interface &socket) {
|
||||
}
|
||||
|
||||
int ClientInterface::set_streaming_port(Interface &socket) {
|
||||
auto port = socket.Receive<int>();
|
||||
if (port < 0) {
|
||||
throw RuntimeError("Invalid zmq port " + std::to_string(port));
|
||||
auto port = socket.Receive<uint16_t>();
|
||||
try {
|
||||
validatePortNumber(port);
|
||||
} catch (...) {
|
||||
throw RuntimeError(
|
||||
"Could not set streaming (zmq) port number. Invalid value.");
|
||||
}
|
||||
verifyIdle(socket);
|
||||
impl()->setStreamingPort(port);
|
||||
@ -1074,7 +1076,7 @@ int ClientInterface::set_streaming_port(Interface &socket) {
|
||||
}
|
||||
|
||||
int ClientInterface::get_streaming_port(Interface &socket) {
|
||||
int retval = impl()->getStreamingPort();
|
||||
uint16_t retval = impl()->getStreamingPort();
|
||||
LOG(logDEBUG1) << "streaming port:" << retval;
|
||||
return socket.sendResult(retval);
|
||||
}
|
||||
@ -1449,7 +1451,7 @@ int ClientInterface::set_udp_ip2(Interface &socket) {
|
||||
}
|
||||
|
||||
int ClientInterface::set_udp_port(Interface &socket) {
|
||||
auto arg = socket.Receive<int>();
|
||||
auto arg = socket.Receive<uint16_t>();
|
||||
verifyIdle(socket);
|
||||
LOG(logDEBUG1) << "Setting UDP Port:" << arg;
|
||||
impl()->setUDPPortNumber(arg);
|
||||
@ -1457,7 +1459,7 @@ int ClientInterface::set_udp_port(Interface &socket) {
|
||||
}
|
||||
|
||||
int ClientInterface::set_udp_port2(Interface &socket) {
|
||||
auto arg = socket.Receive<int>();
|
||||
auto arg = socket.Receive<uint16_t>();
|
||||
verifyIdle(socket);
|
||||
if (detType != JUNGFRAU && detType != MOENCH && detType != EIGER &&
|
||||
detType != GOTTHARD2) {
|
||||
|
@ -17,7 +17,7 @@ class ServerInterface;
|
||||
class ClientInterface : private virtual slsDetectorDefs {
|
||||
enum numberMode { DEC, HEX };
|
||||
detectorType detType;
|
||||
int portNumber{0};
|
||||
uint16_t portNumber{0};
|
||||
ServerSocket server;
|
||||
std::unique_ptr<Implementation> receiver;
|
||||
std::unique_ptr<std::thread> tcpThread;
|
||||
@ -29,7 +29,7 @@ class ClientInterface : private virtual slsDetectorDefs {
|
||||
|
||||
public:
|
||||
virtual ~ClientInterface();
|
||||
ClientInterface(int portNumber = -1);
|
||||
ClientInterface(uint16_t portNumber = DEFAULT_TCP_RX_PORTNO);
|
||||
std::string getReceiverVersion();
|
||||
|
||||
//***callback functions***
|
||||
|
@ -127,7 +127,7 @@ void DataProcessor::CreateFirstFiles(const std::string &fileNamePrefix,
|
||||
const uint64_t fileIndex,
|
||||
const bool overWriteEnable,
|
||||
const bool silentMode,
|
||||
const uint32_t udpPortNumber,
|
||||
const uint16_t udpPortNumber,
|
||||
const uint64_t numImages,
|
||||
const bool detectorDataStream) {
|
||||
if (dataFile == nullptr) {
|
||||
|
@ -56,7 +56,7 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
|
||||
|
||||
void CreateFirstFiles(const std::string &fileNamePrefix,
|
||||
const uint64_t fileIndex, const bool overWriteEnable,
|
||||
const bool silentMode, const uint32_t udpPortNumber,
|
||||
const bool silentMode, const uint16_t udpPortNumber,
|
||||
const uint64_t numImages,
|
||||
const bool detectorDataStream);
|
||||
#ifdef HDF5C
|
||||
|
@ -84,8 +84,8 @@ void DataStreamer::RecordFirstIndex(uint64_t fnum, size_t firstImageIndex) {
|
||||
<< ", First Streamer Index:" << fnum;
|
||||
}
|
||||
|
||||
void DataStreamer::CreateZmqSockets(uint32_t port, const IpAddr ip, int hwm) {
|
||||
uint32_t portnum = port + index;
|
||||
void DataStreamer::CreateZmqSockets(uint16_t port, const IpAddr ip, int hwm) {
|
||||
uint16_t portnum = port + index;
|
||||
std::string sip = ip.str();
|
||||
try {
|
||||
zmqSocket = new ZmqSocket(portnum, (ip != 0 ? sip.c_str() : nullptr));
|
||||
|
@ -48,7 +48,7 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
|
||||
* @param ip streaming source ip
|
||||
* @param hwm streaming high water mark
|
||||
*/
|
||||
void CreateZmqSockets(uint32_t port, const IpAddr ip, int hwm);
|
||||
void CreateZmqSockets(uint16_t port, const IpAddr ip, int hwm);
|
||||
void CloseZmqSocket();
|
||||
void RestreamStop();
|
||||
|
||||
|
@ -58,7 +58,7 @@ class File : private virtual slsDetectorDefs {
|
||||
virtual void CreateFirstHDF5DataFile(
|
||||
const std::string &fileNamePrefix, const uint64_t fileIndex,
|
||||
const bool overWriteEnable, const bool silentMode,
|
||||
const uint32_t udpPortNumber, const uint32_t maxFramesPerFile,
|
||||
const uint16_t udpPortNumber, const uint32_t maxFramesPerFile,
|
||||
const uint64_t numImages, const uint32_t nPixelsX,
|
||||
const uint32_t nPixelsY, const uint32_t dynamicRange) {
|
||||
LOG(logERROR)
|
||||
@ -70,7 +70,7 @@ class File : private virtual slsDetectorDefs {
|
||||
const uint64_t fileIndex,
|
||||
const bool overWriteEnable,
|
||||
const bool silentMode,
|
||||
const uint32_t udpPortNumber,
|
||||
const uint16_t udpPortNumber,
|
||||
const uint32_t maxFramesPerFile) {
|
||||
LOG(logERROR)
|
||||
<< "This is a generic function CreateFirstBinaryDataFile that "
|
||||
|
@ -88,7 +88,7 @@ void HDF5DataFile::CloseFile() {
|
||||
|
||||
void HDF5DataFile::CreateFirstHDF5DataFile(
|
||||
const std::string &fNamePrefix, const uint64_t fIndex, const bool owEnable,
|
||||
const bool sMode, const uint32_t uPortNumber, const uint32_t mFramesPerFile,
|
||||
const bool sMode, const uint16_t uPortNumber, const uint32_t mFramesPerFile,
|
||||
const uint64_t nImages, const uint32_t nX, const uint32_t nY,
|
||||
const uint32_t dr) {
|
||||
|
||||
|
@ -25,7 +25,7 @@ class HDF5DataFile : private virtual slsDetectorDefs, public File {
|
||||
|
||||
void CreateFirstHDF5DataFile(const std::string &fNamePrefix,
|
||||
const uint64_t fIndex, const bool owEnable,
|
||||
const bool sMode, const uint32_t uPortNumber,
|
||||
const bool sMode, const uint16_t uPortNumber,
|
||||
const uint32_t mFramesPerFile,
|
||||
const uint64_t nImages, const uint32_t nX,
|
||||
const uint32_t nY, const uint32_t dr) override;
|
||||
@ -69,7 +69,7 @@ class HDF5DataFile : private virtual slsDetectorDefs, public File {
|
||||
uint64_t fileIndex{0};
|
||||
bool overWriteEnable{false};
|
||||
bool silentMode{false};
|
||||
uint32_t udpPortNumber{0};
|
||||
uint16_t udpPortNumber{0};
|
||||
|
||||
static const int EIGER_NUM_PIXELS{256 * 2 * 256};
|
||||
static const int EIGER_16_BIT_IMAGE_SIZE{EIGER_NUM_PIXELS * 2};
|
||||
|
@ -1140,17 +1140,17 @@ void Implementation::setEthernetInterface2(const std::string &c) {
|
||||
LOG(logINFO) << "Ethernet Interface 2: " << eth[1];
|
||||
}
|
||||
|
||||
uint32_t Implementation::getUDPPortNumber() const { return udpPortNum[0]; }
|
||||
uint16_t Implementation::getUDPPortNumber() const { return udpPortNum[0]; }
|
||||
|
||||
void Implementation::setUDPPortNumber(const uint32_t i) {
|
||||
void Implementation::setUDPPortNumber(const uint16_t i) {
|
||||
udpPortNum[0] = i;
|
||||
listener[0]->SetUdpPortNumber(i);
|
||||
LOG(logINFO) << "UDP Port Number[0]: " << udpPortNum[0];
|
||||
}
|
||||
|
||||
uint32_t Implementation::getUDPPortNumber2() const { return udpPortNum[1]; }
|
||||
uint16_t Implementation::getUDPPortNumber2() const { return udpPortNum[1]; }
|
||||
|
||||
void Implementation::setUDPPortNumber2(const uint32_t i) {
|
||||
void Implementation::setUDPPortNumber2(const uint16_t i) {
|
||||
udpPortNum[1] = i;
|
||||
if (listener.size() > 1) {
|
||||
listener[1]->SetUdpPortNumber(i);
|
||||
@ -1251,9 +1251,9 @@ void Implementation::setStreamingStartingFrameNumber(const uint32_t fnum) {
|
||||
LOG(logINFO) << "Streaming Start Frame num: " << streamingStartFnum;
|
||||
}
|
||||
|
||||
uint32_t Implementation::getStreamingPort() const { return streamingPort; }
|
||||
uint16_t Implementation::getStreamingPort() const { return streamingPort; }
|
||||
|
||||
void Implementation::setStreamingPort(const uint32_t i) {
|
||||
void Implementation::setStreamingPort(const uint16_t i) {
|
||||
streamingPort = i;
|
||||
LOG(logINFO) << "Streaming Port: " << streamingPort;
|
||||
}
|
||||
|
@ -117,11 +117,11 @@ class Implementation : private virtual slsDetectorDefs {
|
||||
std::string getEthernetInterface2() const;
|
||||
/* [Jungfrau][Moench] */
|
||||
void setEthernetInterface2(const std::string &c);
|
||||
uint32_t getUDPPortNumber() const;
|
||||
void setUDPPortNumber(const uint32_t i);
|
||||
uint32_t getUDPPortNumber2() const;
|
||||
uint16_t getUDPPortNumber() const;
|
||||
void setUDPPortNumber(const uint16_t i);
|
||||
uint16_t getUDPPortNumber2() const;
|
||||
/* [Eiger][Jungfrau][Moench] */
|
||||
void setUDPPortNumber2(const uint32_t i);
|
||||
void setUDPPortNumber2(const uint16_t i);
|
||||
int getUDPSocketBufferSize() const;
|
||||
void setUDPSocketBufferSize(const int s);
|
||||
int getActualUDPSocketBufferSize() const;
|
||||
@ -140,8 +140,8 @@ class Implementation : private virtual slsDetectorDefs {
|
||||
void setStreamingTimer(const uint32_t time_in_ms);
|
||||
uint32_t getStreamingStartingFrameNumber() const;
|
||||
void setStreamingStartingFrameNumber(const uint32_t fnum);
|
||||
uint32_t getStreamingPort() const;
|
||||
void setStreamingPort(const uint32_t i);
|
||||
uint16_t getStreamingPort() const;
|
||||
void setStreamingPort(const uint16_t i);
|
||||
IpAddr getStreamingSourceIP() const;
|
||||
void setStreamingSourceIP(const IpAddr ip);
|
||||
int getStreamingHwm() const;
|
||||
@ -336,7 +336,7 @@ class Implementation : private virtual slsDetectorDefs {
|
||||
|
||||
// network configuration (UDP)
|
||||
std::array<std::string, MAX_NUMBER_OF_LISTENING_THREADS> eth;
|
||||
std::array<uint32_t, MAX_NUMBER_OF_LISTENING_THREADS> udpPortNum{
|
||||
std::array<uint16_t, MAX_NUMBER_OF_LISTENING_THREADS> udpPortNum{
|
||||
{DEFAULT_UDP_DST_PORTNO, DEFAULT_UDP_DST_PORTNO + 1}};
|
||||
int actualUDPSocketBufferSize{0};
|
||||
|
||||
@ -345,7 +345,7 @@ class Implementation : private virtual slsDetectorDefs {
|
||||
uint32_t streamingFrequency{1};
|
||||
uint32_t streamingTimerInMs{DEFAULT_STREAMING_TIMER_IN_MS};
|
||||
uint32_t streamingStartFnum{0};
|
||||
uint32_t streamingPort{0};
|
||||
uint16_t streamingPort{0};
|
||||
IpAddr streamingSrcIP = IpAddr{};
|
||||
int streamingHwm{-1};
|
||||
std::map<std::string, std::string> additionalJsonHeader;
|
||||
|
@ -71,7 +71,7 @@ void Listener::SetFifo(Fifo *f) { fifo = f; }
|
||||
|
||||
void Listener::SetGeneralData(GeneralData *g) { generalData = g; }
|
||||
|
||||
void Listener::SetUdpPortNumber(const uint32_t portNumber) {
|
||||
void Listener::SetUdpPortNumber(const uint16_t portNumber) {
|
||||
udpPortNumber = portNumber;
|
||||
}
|
||||
|
||||
|
@ -39,7 +39,7 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
|
||||
|
||||
void SetFifo(Fifo *f);
|
||||
void SetGeneralData(GeneralData *g);
|
||||
void SetUdpPortNumber(const uint32_t portNumber);
|
||||
void SetUdpPortNumber(const uint16_t portNumber);
|
||||
void SetEthernetInterface(const std::string e);
|
||||
void SetActivate(bool enable);
|
||||
void SetDetectorDatastream(bool enable);
|
||||
@ -112,7 +112,7 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
|
||||
std::atomic<runStatus> *status;
|
||||
std::unique_ptr<UdpRxSocket> udpSocket{nullptr};
|
||||
|
||||
uint32_t udpPortNumber{0};
|
||||
uint16_t udpPortNumber{0};
|
||||
std::string eth;
|
||||
bool activated{false};
|
||||
bool detectorDataStream{true};
|
||||
|
@ -3,6 +3,7 @@
|
||||
/* Creates the slsMultiReceiver for running multiple receivers form a single
|
||||
* binary */
|
||||
#include "sls/Receiver.h"
|
||||
#include "sls/ToString.h"
|
||||
#include "sls/container_utils.h"
|
||||
#include "sls/logger.h"
|
||||
#include "sls/sls_detector_defs.h"
|
||||
@ -36,14 +37,12 @@ void sigInterruptHandler(int p) { sem_post(&semaphore); }
|
||||
/**
|
||||
* prints usage of this example program
|
||||
*/
|
||||
void printHelp() {
|
||||
cprintf(
|
||||
RESET,
|
||||
"Usage:\n"
|
||||
"./slsMultiReceiver(detReceiver) [start_tcp_port] "
|
||||
"[num_receivers] [optional: 1 for call back (print frame header for "
|
||||
"debugging), 0 for none (default)]\n\n");
|
||||
exit(EXIT_FAILURE);
|
||||
std::string getHelpMessage() {
|
||||
return std::string(
|
||||
"\n\nUsage:\n"
|
||||
"./slsMultiReceiver(detReceiver) [start_tcp_port (non-zero and 16 "
|
||||
"bit)] [num_receivers] [optional: 1 for call back (print frame header "
|
||||
"for debugging), 0 for none (default)]\n\n");
|
||||
}
|
||||
|
||||
/**
|
||||
@ -140,25 +139,31 @@ int main(int argc, char *argv[]) {
|
||||
|
||||
/** - set default values */
|
||||
int numReceivers = 1;
|
||||
int startTCPPort = 1954;
|
||||
uint16_t startTCPPort = 1954;
|
||||
int withCallback = 0;
|
||||
sem_init(&semaphore, 1, 0);
|
||||
|
||||
/** - get number of receivers and start tcp port from command line
|
||||
* arguments */
|
||||
if (argc != 3 && argc != 4)
|
||||
printHelp();
|
||||
if ((argc == 3) && ((!sscanf(argv[1], "%d", &startTCPPort)) ||
|
||||
(!sscanf(argv[2], "%d", &numReceivers))))
|
||||
printHelp();
|
||||
if ((argc == 4) && ((!sscanf(argv[1], "%d", &startTCPPort)) ||
|
||||
(!sscanf(argv[2], "%d", &numReceivers)) ||
|
||||
(!sscanf(argv[3], "%d", &withCallback))))
|
||||
printHelp();
|
||||
try {
|
||||
if (argc == 3 || argc == 4) {
|
||||
startTCPPort = sls::StringTo<uint16_t>(argv[1]);
|
||||
if (startTCPPort == 0) {
|
||||
throw;
|
||||
}
|
||||
numReceivers = std::stoi(argv[2]);
|
||||
if (argc == 4) {
|
||||
withCallback = std::stoi(argv[3]);
|
||||
}
|
||||
} else
|
||||
throw;
|
||||
} catch (...) {
|
||||
throw std::runtime_error(getHelpMessage());
|
||||
}
|
||||
|
||||
cprintf(BLUE, "Parent Process Created [ Tid: %ld ]\n", (long)gettid());
|
||||
cprintf(RESET, "Number of Receivers: %d\n", numReceivers);
|
||||
cprintf(RESET, "Start TCP Port: %d\n", startTCPPort);
|
||||
cprintf(RESET, "Start TCP Port: %hu\n", startTCPPort);
|
||||
cprintf(RESET, "Callback Enable: %d\n", withCallback);
|
||||
|
||||
/** - Catch signal SIGINT to close files and call destructors properly */
|
||||
|
@ -2,6 +2,7 @@
|
||||
// Copyright (C) 2021 Contributors to the SLS Detector Package
|
||||
#include "sls/Receiver.h"
|
||||
#include "ClientInterface.h"
|
||||
#include "sls/ToString.h"
|
||||
#include "sls/container_utils.h"
|
||||
#include "sls/logger.h"
|
||||
#include "sls/sls_detector_exceptions.h"
|
||||
@ -29,7 +30,7 @@ Receiver::~Receiver() = default;
|
||||
Receiver::Receiver(int argc, char *argv[]) : tcpipInterface(nullptr) {
|
||||
|
||||
// options
|
||||
int tcpip_port_no = 1954;
|
||||
uint16_t tcpip_port_no = 1954;
|
||||
uid_t userid = -1;
|
||||
|
||||
// parse command line for config
|
||||
@ -51,6 +52,15 @@ Receiver::Receiver(int argc, char *argv[]) : tcpipInterface(nullptr) {
|
||||
int option_index = 0;
|
||||
int c = 0;
|
||||
|
||||
std::string help_message =
|
||||
"\nUsage: " + std::string(argv[0]) + " [arguments]\n" +
|
||||
"Possible arguments are:\n" +
|
||||
"\t-t, --rx_tcpport <port> : TCP Communication Port with "
|
||||
"client. Non-zero and 16 bit.\n" +
|
||||
"\t-u, --uid <user id> : Set effective user id if receiver "
|
||||
"\n" +
|
||||
"\t started with privileges. \n\n";
|
||||
|
||||
while (c != -1) {
|
||||
c = getopt_long(argc, argv, "hvf:t:u:", long_options, &option_index);
|
||||
|
||||
@ -61,12 +71,18 @@ Receiver::Receiver(int argc, char *argv[]) : tcpipInterface(nullptr) {
|
||||
switch (c) {
|
||||
|
||||
case 't':
|
||||
sscanf(optarg, "%d", &tcpip_port_no);
|
||||
try {
|
||||
tcpip_port_no = sls::StringTo<uint16_t>(optarg);
|
||||
validatePortNumber(tcpip_port_no);
|
||||
} catch (...) {
|
||||
throw RuntimeError("Could not scan TCP port number." +
|
||||
help_message);
|
||||
}
|
||||
break;
|
||||
|
||||
case 'u':
|
||||
if (sscanf(optarg, "%u", &userid) != 1) {
|
||||
throw RuntimeError("Could not scan uid");
|
||||
throw RuntimeError("Could not scan uid" + help_message);
|
||||
}
|
||||
break;
|
||||
|
||||
@ -76,19 +92,9 @@ Receiver::Receiver(int argc, char *argv[]) : tcpipInterface(nullptr) {
|
||||
exit(EXIT_SUCCESS);
|
||||
|
||||
case 'h':
|
||||
std::cout << help_message << std::endl;
|
||||
exit(EXIT_SUCCESS);
|
||||
default:
|
||||
std::cout << std::endl;
|
||||
|
||||
std::string help_message =
|
||||
"Usage: " + std::string(argv[0]) + " [arguments]\n" +
|
||||
"Possible arguments are:\n" +
|
||||
"\t-t, --rx_tcpport <port> : TCP Communication Port with "
|
||||
"client. \n" +
|
||||
"\t-u, --uid <user id> : Set effective user id if receiver "
|
||||
"\n" +
|
||||
"\t started with privileges. \n\n";
|
||||
|
||||
// std::cout << help_message << std::endl;
|
||||
throw RuntimeError(help_message);
|
||||
}
|
||||
}
|
||||
@ -118,7 +124,7 @@ Receiver::Receiver(int argc, char *argv[]) : tcpipInterface(nullptr) {
|
||||
tcpipInterface = make_unique<ClientInterface>(tcpip_port_no);
|
||||
}
|
||||
|
||||
Receiver::Receiver(int tcpip_port_no) {
|
||||
Receiver::Receiver(uint16_t tcpip_port_no) {
|
||||
// might throw an exception
|
||||
tcpipInterface = make_unique<ClientInterface>(tcpip_port_no);
|
||||
}
|
||||
|
@ -316,6 +316,7 @@ template <> defs::vetoAlgorithm StringTo(const std::string &s);
|
||||
template <> defs::gainMode StringTo(const std::string &s);
|
||||
template <> defs::polarity StringTo(const std::string &s);
|
||||
|
||||
template <> uint16_t StringTo(const std::string &s);
|
||||
template <> uint32_t StringTo(const std::string &s);
|
||||
template <> uint64_t StringTo(const std::string &s);
|
||||
template <> int StringTo(const std::string &s);
|
||||
|
@ -7,6 +7,7 @@ UDP socket class to receive data. The intended use is in the
|
||||
receiver listener loop. Should be used RAII style...
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h> //ssize_t
|
||||
namespace sls {
|
||||
|
||||
@ -15,8 +16,8 @@ class UdpRxSocket {
|
||||
int sockfd_{-1};
|
||||
|
||||
public:
|
||||
UdpRxSocket(int port, ssize_t packet_size, const char *hostname = nullptr,
|
||||
int kernel_buffer_size = 0);
|
||||
UdpRxSocket(uint16_t port, ssize_t packet_size,
|
||||
const char *hostname = nullptr, int kernel_buffer_size = 0);
|
||||
~UdpRxSocket();
|
||||
bool ReceivePacket(char *dst) noexcept;
|
||||
int getBufferSize() const;
|
||||
|
@ -103,7 +103,7 @@ class ZmqSocket {
|
||||
* @param hostname_or_ip hostname or ip of server
|
||||
* @param portnumber port number
|
||||
*/
|
||||
ZmqSocket(const char *const hostname_or_ip, const uint32_t portnumber);
|
||||
ZmqSocket(const char *const hostname_or_ip, const uint16_t portnumber);
|
||||
|
||||
/**
|
||||
* Constructor for a server
|
||||
@ -111,7 +111,7 @@ class ZmqSocket {
|
||||
* @param portnumber port number
|
||||
* @param ethip is the ip of the ethernet interface to stream zmq from
|
||||
*/
|
||||
ZmqSocket(const uint32_t portnumber, const char *ethip);
|
||||
ZmqSocket(const uint16_t portnumber, const char *ethip);
|
||||
|
||||
/** Returns high water mark for outbound messages */
|
||||
int GetSendHighWaterMark();
|
||||
@ -143,7 +143,7 @@ class ZmqSocket {
|
||||
* Returns Port Number
|
||||
* @returns Port Number
|
||||
*/
|
||||
uint32_t GetPortNumber() { return portno; }
|
||||
uint16_t GetPortNumber() { return portno; }
|
||||
|
||||
/**
|
||||
* Returns Server Address
|
||||
@ -251,7 +251,7 @@ class ZmqSocket {
|
||||
};
|
||||
|
||||
/** Port Number */
|
||||
uint32_t portno;
|
||||
uint16_t portno;
|
||||
|
||||
/** Socket descriptor */
|
||||
mySocketDescriptors sockfd;
|
||||
|
@ -64,8 +64,8 @@ class MacAddr {
|
||||
|
||||
struct UdpDestination {
|
||||
uint32_t entry{};
|
||||
uint32_t port{};
|
||||
uint32_t port2{};
|
||||
uint16_t port{};
|
||||
uint16_t port2{};
|
||||
IpAddr ip;
|
||||
IpAddr ip2;
|
||||
MacAddr mac;
|
||||
@ -88,5 +88,6 @@ IpAddr HostnameToIp(const char *hostname);
|
||||
std::string IpToInterfaceName(const std::string &ip);
|
||||
MacAddr InterfaceNameToMac(const std::string &inf);
|
||||
IpAddr InterfaceNameToIp(const std::string &ifn);
|
||||
|
||||
void validatePortNumber(uint16_t port);
|
||||
void validatePortRange(uint16_t startPort, int numPorts);
|
||||
} // namespace sls
|
||||
|
@ -30,8 +30,8 @@
|
||||
// C includes
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
//Need macros for C compatibility
|
||||
//NOLINTBEGIN(cppcoreguidelines-macro-usage)
|
||||
// Need macros for C compatibility
|
||||
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
|
||||
#define BIT32_MASK 0xFFFFFFFF
|
||||
#define MAX_RX_DBIT 64
|
||||
|
||||
@ -80,7 +80,7 @@
|
||||
#define DEFAULT_STREAMING_TIMER_IN_MS 500
|
||||
|
||||
#define NUM_RX_THREAD_IDS 9
|
||||
//NOLINTEND(cppcoreguidelines-macro-usage)
|
||||
// NOLINTEND(cppcoreguidelines-macro-usage)
|
||||
#ifdef __cplusplus
|
||||
class slsDetectorDefs {
|
||||
public:
|
||||
@ -556,10 +556,10 @@ enum streamingInterface {
|
||||
int moduleIndex{0};
|
||||
char hostname[MAX_STR_LENGTH];
|
||||
int udpInterfaces{1};
|
||||
int udp_dstport{0};
|
||||
uint16_t udp_dstport{0};
|
||||
uint32_t udp_dstip{0U};
|
||||
uint64_t udp_dstmac{0LU};
|
||||
int udp_dstport2{0};
|
||||
uint16_t udp_dstport2{0};
|
||||
uint32_t udp_dstip2{0U};
|
||||
uint64_t udp_dstmac2{0LU};
|
||||
int64_t frames{0};
|
||||
|
@ -60,6 +60,6 @@ bool is_int(const std::string &s);
|
||||
bool replace_first(std::string *s, const std::string &substr,
|
||||
const std::string &repl);
|
||||
|
||||
std::pair<std::string, int> ParseHostPort(const std::string &s);
|
||||
std::pair<std::string, uint16_t> ParseHostPort(const std::string &s);
|
||||
|
||||
} // namespace sls
|
||||
|
@ -4,10 +4,10 @@
|
||||
#define RELEASE "developer"
|
||||
#define APILIB "developer 0x230224"
|
||||
#define APIRECEIVER "developer 0x230224"
|
||||
#define APICTB "developer 0x230829"
|
||||
#define APIGOTTHARD "developer 0x230829"
|
||||
#define APIGOTTHARD2 "developer 0x230829"
|
||||
#define APIJUNGFRAU "developer 0x230829"
|
||||
#define APIMYTHEN3 "developer 0x230829"
|
||||
#define APIMOENCH "developer 0x230829"
|
||||
#define APIEIGER "developer 0x230829"
|
||||
#define APICTB "developer 0x230922"
|
||||
#define APIGOTTHARD "developer 0x230922"
|
||||
#define APIGOTTHARD2 "developer 0x230922"
|
||||
#define APIJUNGFRAU "developer 0x230922"
|
||||
#define APIMYTHEN3 "developer 0x230922"
|
||||
#define APIMOENCH "developer 0x230922"
|
||||
#define APIEIGER "developer 0x230922"
|
||||
|
@ -1083,6 +1083,17 @@ template <> defs::polarity StringTo(const std::string &s) {
|
||||
throw RuntimeError("Unknown polarity mode " + s);
|
||||
}
|
||||
|
||||
template <> uint16_t StringTo(const std::string &s) {
|
||||
int base = s.find("0x") != std::string::npos ? 16 : 10;
|
||||
int value = std::stoi(s, nullptr, base);
|
||||
if (value < std::numeric_limits<uint16_t>::min() ||
|
||||
value > std::numeric_limits<uint16_t>::max()) {
|
||||
throw RuntimeError("Cannot scan uint16_t from string '" + s +
|
||||
"'. Value must be in range 0 - 65535.");
|
||||
}
|
||||
return static_cast<uint16_t>(value);
|
||||
}
|
||||
|
||||
template <> uint32_t StringTo(const std::string &s) {
|
||||
int base = s.find("0x") != std::string::npos ? 16 : 10;
|
||||
return std::stoul(s, nullptr, base);
|
||||
|
@ -15,8 +15,8 @@
|
||||
|
||||
namespace sls {
|
||||
|
||||
UdpRxSocket::UdpRxSocket(int port, ssize_t packet_size, const char *hostname,
|
||||
int kernel_buffer_size)
|
||||
UdpRxSocket::UdpRxSocket(uint16_t port, ssize_t packet_size,
|
||||
const char *hostname, int kernel_buffer_size)
|
||||
: packet_size_(packet_size) {
|
||||
struct addrinfo hints {};
|
||||
hints.ai_family = AF_UNSPEC;
|
||||
|
@ -15,7 +15,7 @@ namespace sls {
|
||||
|
||||
using namespace rapidjson;
|
||||
ZmqSocket::ZmqSocket(const char *const hostname_or_ip,
|
||||
const uint32_t portnumber)
|
||||
const uint16_t portnumber)
|
||||
: portno(portnumber), sockfd(false) {
|
||||
// Extra check that throws if conversion fails, could be removed
|
||||
auto ipstr = HostnameToIp(hostname_or_ip).str();
|
||||
@ -55,7 +55,7 @@ ZmqSocket::ZmqSocket(const char *const hostname_or_ip,
|
||||
<< GetReceiveHighWaterMark();
|
||||
}
|
||||
|
||||
ZmqSocket::ZmqSocket(const uint32_t portnumber, const char *ethip)
|
||||
ZmqSocket::ZmqSocket(const uint16_t portnumber, const char *ethip)
|
||||
: portno(portnumber), sockfd(true) {
|
||||
// create context
|
||||
sockfd.contextDescriptor = zmq_ctx_new();
|
||||
@ -289,24 +289,24 @@ int ZmqSocket::ReceiveHeader(const int index, zmqHeader &zHeader,
|
||||
header_buffer.get(), MAX_STR_LENGTH, 0);
|
||||
if (bytes_received > 0) {
|
||||
#ifdef ZMQ_DETAIL
|
||||
cprintf(BLUE, "Header %d [%d] Length: %d Header:%s \n", index, portno,
|
||||
cprintf(BLUE, "Header %d [%hu] Length: %d Header:%s \n", index, portno,
|
||||
bytes_received, header_buffer.get());
|
||||
#endif
|
||||
if (ParseHeader(index, bytes_received, header_buffer.get(), zHeader,
|
||||
version)) {
|
||||
#ifdef ZMQ_DETAIL
|
||||
cprintf(RED, "Parsed Header %d [%d] Length: %d Header:%s \n", index,
|
||||
portno, bytes_received, header_buffer.get());
|
||||
cprintf(RED, "Parsed Header %d [%hu] Length: %d Header:%s \n",
|
||||
index, portno, bytes_received, header_buffer.get());
|
||||
#endif
|
||||
if (!zHeader.data) {
|
||||
#ifdef ZMQ_DETAIL
|
||||
cprintf(RED, "%d [%d] Received end of acquisition\n", index,
|
||||
cprintf(RED, "%d [%hu] Received end of acquisition\n", index,
|
||||
portno);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
#ifdef ZMQ_DETAIL
|
||||
cprintf(GREEN, "%d [%d] data\n", index, portno);
|
||||
cprintf(GREEN, "%d [%hu] data\n", index, portno);
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
|
@ -10,6 +10,7 @@
|
||||
#include <cstring>
|
||||
#include <ifaddrs.h>
|
||||
#include <iomanip>
|
||||
#include <limits>
|
||||
#include <net/if.h>
|
||||
#include <netdb.h>
|
||||
#include <sstream>
|
||||
@ -203,4 +204,18 @@ MacAddr InterfaceNameToMac(const std::string &inf) {
|
||||
return MacAddr(mac);
|
||||
}
|
||||
|
||||
void validatePortNumber(uint16_t port) {
|
||||
// random local port. might work if internal = bad practise
|
||||
if (port == 0) {
|
||||
throw RuntimeError("Invalid port number. Must be between 1 - 65535.");
|
||||
}
|
||||
}
|
||||
|
||||
void validatePortRange(uint16_t startPort, int numPorts) {
|
||||
validatePortNumber(startPort);
|
||||
if ((startPort + numPorts) > std::numeric_limits<uint16_t>::max()) {
|
||||
throw RuntimeError("Invalid port range. Must be between 1 - 65535.");
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace sls
|
||||
|
@ -4,9 +4,12 @@
|
||||
#include "sls/string_utils.h"
|
||||
#include "sls/container_utils.h"
|
||||
#include "sls/network_utils.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <iomanip>
|
||||
#include <sls/ToString.h>
|
||||
#include <sstream>
|
||||
|
||||
namespace sls {
|
||||
|
||||
std::vector<std::string> split(const std::string &strToSplit, char delimeter) {
|
||||
@ -50,15 +53,15 @@ bool replace_first(std::string *s, const std::string &substr,
|
||||
return false;
|
||||
}
|
||||
|
||||
std::pair<std::string, int> ParseHostPort(const std::string &s) {
|
||||
std::pair<std::string, uint16_t> ParseHostPort(const std::string &s) {
|
||||
// TODO deal with to many :, port not there?
|
||||
// no port return hostname as is and port as 0
|
||||
std::string host;
|
||||
int port{0};
|
||||
uint16_t port{0};
|
||||
auto res = split(s, ':');
|
||||
host = res[0];
|
||||
if (res.size() > 1) {
|
||||
port = std::stoi(res[1]);
|
||||
port = StringTo<uint16_t>(res[1]);
|
||||
}
|
||||
return std::make_pair(host, port);
|
||||
}
|
||||
|
@ -6,7 +6,7 @@
|
||||
namespace sls {
|
||||
|
||||
TEST_CASE("Throws when cannot create socket") {
|
||||
REQUIRE_THROWS(ZmqSocket("sdiasodjajpvv", 5076001));
|
||||
REQUIRE_THROWS(ZmqSocket("sdiasodjajpvv", 50001));
|
||||
}
|
||||
|
||||
TEST_CASE("Get port number for sub") {
|
||||
|
@ -115,7 +115,7 @@ TEST_CASE("Copy construct a MacAddr") {
|
||||
}
|
||||
|
||||
TEST_CASE("udp dst struct basic properties") {
|
||||
static_assert(sizeof(UdpDestination) == 36,
|
||||
static_assert(sizeof(UdpDestination) == 32,
|
||||
"udpDestination struct size does not match");
|
||||
UdpDestination dst{};
|
||||
REQUIRE(dst.entry == 0);
|
||||
|
Loading…
x
Reference in New Issue
Block a user