detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-21 11:20:04 +02:00
Code Issues Actions Packages Releases Activity

Dev/fix port size (#805)

Browse Source 
* port datatype changing from int to uint16_t
* throwing for -1 given for uint16_t ports
This commit is contained in:
maliakal_d 2023-09-28 09:36:39 +02:00 committed by GitHub
parent 77d13f0794
commit 9834b07b47
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
61 changed files with 519 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer
View File

Binary file not shown.

8
slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c
View File

@ -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

BIN
slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer
View File

Binary file not shown.

12
slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c
View File

@ -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));
}

BIN
slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer
View File

Binary file not shown.

20
slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
View File

@ -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

BIN
slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer
View File

Binary file not shown.

8
slsDetectorServers/gotthardDetectorServer/slsDetectorFunctionList.c
View File

@ -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

BIN
slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer
View File

Binary file not shown.

20
slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c
View File

@ -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

BIN
slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer
View File

Binary file not shown.

20
slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c
View File

@ -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

BIN
slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer
View File

Binary file not shown.

8
slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
View File

@ -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

14
slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
View File

@ -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

10
slsDetectorServers/slsDetectorServer/src/slsDetectorServer.c
View File

@ -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;
}

108
slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
View File

@ -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];

32
slsDetectorSoftware/include/sls/Detector.h
View File

@ -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);
};

2
slsDetectorSoftware/src/CmdProxy.cpp
View File

@ -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");

15
slsDetectorSoftware/src/CmdProxy.h
View File

@ -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.");

70
slsDetectorSoftware/src/Detector.cpp
View File

@ -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;
}

33
slsDetectorSoftware/src/DetectorImpl.cpp
View File

@ -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());
}),

19
slsDetectorSoftware/src/DetectorImpl.h
View File

@ -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};

52
slsDetectorSoftware/src/Module.cpp
View File

@ -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);

42
slsDetectorSoftware/src/Module.h
View File

@ -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;

20
slsDetectorSoftware/tests/test-CmdProxy-global.cpp
View File

@ -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);

4
slsDetectorSoftware/tests/test-CmdProxy-global.h
View File

@ -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,

29
slsDetectorSoftware/tests/test-CmdProxy-rx.cpp
View File

@ -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);
}

47
slsDetectorSoftware/tests/test-CmdProxy.cpp
View File

@ -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});
}

2
slsReceiverSoftware/include/sls/Receiver.h
View File

@ -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();

2
slsReceiverSoftware/src/BinaryDataFile.cpp
View File

@ -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;

2
slsReceiverSoftware/src/BinaryDataFile.h
View File

@ -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,

22
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -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) {

4
slsReceiverSoftware/src/ClientInterface.h
View File

@ -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***

2
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -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) {

2
slsReceiverSoftware/src/DataProcessor.h
View File

@ -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

4
slsReceiverSoftware/src/DataStreamer.cpp
View File

@ -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));

2
slsReceiverSoftware/src/DataStreamer.h
View File

@ -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();

4
slsReceiverSoftware/src/File.h
View File

@ -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 "

2
slsReceiverSoftware/src/HDF5DataFile.cpp
View File

@ -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) {

4
slsReceiverSoftware/src/HDF5DataFile.h
View File

@ -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};

12
slsReceiverSoftware/src/Implementation.cpp
View File

@ -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;
}

16
slsReceiverSoftware/src/Implementation.h
View File

@ -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;

2
slsReceiverSoftware/src/Listener.cpp
View File

@ -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;
}

4
slsReceiverSoftware/src/Listener.h
View File

@ -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};

43
slsReceiverSoftware/src/MultiReceiverApp.cpp
View File

@ -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 */

38
slsReceiverSoftware/src/Receiver.cpp
View File

@ -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);
}

1
slsSupportLib/include/sls/ToString.h
View File

@ -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);

5
slsSupportLib/include/sls/UdpRxSocket.h
View File

@ -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;

8
slsSupportLib/include/sls/ZmqSocket.h
View File

@ -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;

7
slsSupportLib/include/sls/network_utils.h
View File

@ -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

10
slsSupportLib/include/sls/sls_detector_defs.h
View File

@ -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};

2
slsSupportLib/include/sls/string_utils.h
View File

@ -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

14
slsSupportLib/include/sls/versionAPI.h
View File

@ -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"

11
slsSupportLib/src/ToString.cpp
View File

@ -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);

4
slsSupportLib/src/UdpRxSocket.cpp
View File

@ -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;

14
slsSupportLib/src/ZmqSocket.cpp
View File

@ -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;
}

15
slsSupportLib/src/network_utils.cpp
View File

@ -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

9
slsSupportLib/src/string_utils.cpp
View File

@ -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);
}

2
slsSupportLib/tests/test-ZmqSocket.cpp
View File

@ -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") {

2
slsSupportLib/tests/test-network_utils.cpp
View File

@ -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);