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

receiver socket

Browse Source
This commit is contained in:
Erik Frojdh 2019-05-15 17:51:48 +02:00
parent 40c2d9f760
commit e252b8e0e9
9 changed files with 440 additions and 342 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
slsReceiverSoftware/include/slsReceiverTCPIPInterface.h
View File

@ -113,7 +113,7 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
int function_table(); int function_table();
/** Decodes Function */ /** Decodes Function */
int decode_function(sls::DataSocket &socket); int decode_function(sls::ServerInterface2 &socket);
/** function not implemented for specific detector */ /** function not implemented for specific detector */
void functionNotImplemented(); void functionNotImplemented();
@ -126,177 +126,177 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
void validate(T arg, T retval, std::string modename, numberMode hex); void validate(T arg, T retval, std::string modename, numberMode hex);
/** Unrecognized Function */ /** Unrecognized Function */
int M_nofunc(sls::DataSocket & socket); int M_nofunc(sls::ServerInterface2 & socket);
/** Execute command */ /** Execute command */
int exec_command(); int exec_command(sls::ServerInterface2 &socket);
/** Exit Receiver Server */ /** Exit Receiver Server */
int exit_server(); int exit_server(sls::ServerInterface2 &socket);
/** Locks Receiver */ /** Locks Receiver */
int lock_receiver(); int lock_receiver(sls::ServerInterface2 &socket);
/** Get Last Client IP*/ /** Get Last Client IP*/
int get_last_client_ip(); int get_last_client_ip(sls::ServerInterface2 &socket);
/** Set port */ /** Set port */
int set_port(); int set_port(sls::ServerInterface2 &socket);
/** Updates Client if different clients connect */ /** Updates Client if different clients connect */
int update_client(); int update_client(sls::ServerInterface2 &socket);
/** Sends the updated parameters to client */ /** Sends the updated parameters to client */
int send_update(); int send_update(sls::ServerInterface2 &socket);
/** get version, calls get_version */ /** get version, calls get_version */
int get_id(); int get_id(sls::ServerInterface2 &socket);
/** Set detector type */ /** Set detector type */
int set_detector_type(); int set_detector_type(sls::ServerInterface2 &socket);
/** set detector hostname */ /** set detector hostname */
int set_detector_hostname(); int set_detector_hostname(sls::ServerInterface2 &socket);
/** set roi */ /** set roi */
int set_roi(); int set_roi(sls::ServerInterface2 &socket);
/** Set up UDP Details */ /** Set up UDP Details */
int setup_udp(); int setup_udp(sls::ServerInterface2 &socket);
/** set acquisition period, frame number etc */ /** set acquisition period, frame number etc */
int set_timer(); int set_timer(sls::ServerInterface2 &socket);
/** set dynamic range */ /** set dynamic range */
int set_dynamic_range(); int set_dynamic_range(sls::ServerInterface2 &socket);
/** Sets the receiver streaming frequency */ /** Sets the receiver streaming frequency */
int set_streaming_frequency(); int set_streaming_frequency(sls::ServerInterface2 &socket);
/** Gets receiver status */ /** Gets receiver status */
int get_status(); int get_status(sls::ServerInterface2 &socket);
/** Start Receiver - starts listening to udp packets from detector */ /** Start Receiver - starts listening to udp packets from detector */
int start_receiver(); int start_receiver(sls::ServerInterface2 &socket);
/** Stop Receiver - stops listening to udp packets from detector*/ /** Stop Receiver - stops listening to udp packets from detector*/
int stop_receiver(); int stop_receiver(sls::ServerInterface2 &socket);
/** Set File path */ /** Set File path */
int set_file_dir(); int set_file_dir(sls::ServerInterface2 &socket);
/** Set File name without frame index, file index and extension */ /** Set File name without frame index, file index and extension */
int set_file_name(); int set_file_name(sls::ServerInterface2 &socket);
/** Set File index */ /** Set File index */
int set_file_index(); int set_file_index(sls::ServerInterface2 &socket);
/** Gets frame index for each acquisition */ /** Gets frame index for each acquisition */
int get_frame_index(); int get_frame_index(sls::ServerInterface2 &socket);
/** Gets Total Frames Caught */ /** Gets Total Frames Caught */
int get_frames_caught(); int get_frames_caught(sls::ServerInterface2 &socket);
/** Resets Total Frames Caught */ /** Resets Total Frames Caught */
int reset_frames_caught(); int reset_frames_caught(sls::ServerInterface2 &socket);
/** Enable File Write*/ /** Enable File Write*/
int enable_file_write(); int enable_file_write(sls::ServerInterface2 &socket);
/** Enable Master File Write */ /** Enable Master File Write */
int enable_master_file_write(); int enable_master_file_write(sls::ServerInterface2 &socket);
/** enable compression */ /** enable compression */
int enable_compression(); int enable_compression(sls::ServerInterface2 &socket);
/** enable overwrite */ /** enable overwrite */
int enable_overwrite(); int enable_overwrite(sls::ServerInterface2 &socket);
/** enable 10Gbe */ /** enable 10Gbe */
int enable_tengiga(); int enable_tengiga(sls::ServerInterface2 &socket);
/** set fifo depth */ /** set fifo depth */
int set_fifo_depth(); int set_fifo_depth(sls::ServerInterface2 &socket);
/** activate/ deactivate */ /** activate/ deactivate */
int set_activate(); int set_activate(sls::ServerInterface2 &socket);
/* Set the data stream enable */ /* Set the data stream enable */
int set_data_stream_enable(); int set_data_stream_enable(sls::ServerInterface2 &socket);
/** Sets the steadming timer when frequency is set to 0 */ /** Sets the steadming timer when frequency is set to 0 */
int set_streaming_timer(); int set_streaming_timer(sls::ServerInterface2 &socket);
/** enable flipped data */ /** enable flipped data */
int set_flipped_data(); int set_flipped_data(sls::ServerInterface2 &socket);
/** set file format */ /** set file format */
int set_file_format(); int set_file_format(sls::ServerInterface2 &socket);
/** set position id */ /** set position id */
int set_detector_posid(); int set_detector_posid(sls::ServerInterface2 &socket);
/** set multi detector size */ /** set multi detector size */
int set_multi_detector_size(); int set_multi_detector_size(sls::ServerInterface2 &socket);
/** set streaming port */ /** set streaming port */
int set_streaming_port(); int set_streaming_port(sls::ServerInterface2 &socket);
/** set streaming source ip */ /** set streaming source ip */
int set_streaming_source_ip(); int set_streaming_source_ip(sls::ServerInterface2 &socket);
/** set silent mode */ /** set silent mode */
int set_silent_mode(); int set_silent_mode(sls::ServerInterface2 &socket);
/** enable gap pixels */ /** enable gap pixels */
int enable_gap_pixels(); int enable_gap_pixels(sls::ServerInterface2 &socket);
/** restream stop packet */ /** restream stop packet */
int restream_stop(); int restream_stop(sls::ServerInterface2 &socket);
/** set additional json header */ /** set additional json header */
int set_additional_json_header(); int set_additional_json_header(sls::ServerInterface2 &socket);
/** get additional json header */ /** get additional json header */
int get_additional_json_header(); int get_additional_json_header(sls::ServerInterface2 &socket);
/** set udp socket buffer size */ /** set udp socket buffer size */
int set_udp_socket_buffer_size(); int set_udp_socket_buffer_size(sls::ServerInterface2 &socket);
/** get real udp socket buffer size */ /** get real udp socket buffer size */
int get_real_udp_socket_buffer_size(); int get_real_udp_socket_buffer_size(sls::ServerInterface2 &socket);
/** set frames per file */ /** set frames per file */
int set_frames_per_file(); int set_frames_per_file(sls::ServerInterface2 &socket);
/** check version compatibility */ /** check version compatibility */
int check_version_compatibility(); int check_version_compatibility(sls::ServerInterface2 &socket);
/** set frame discard policy */ /** set frame discard policy */
int set_discard_policy(); int set_discard_policy(sls::ServerInterface2 &socket);
/** set partial frame padding enable*/ /** set partial frame padding enable*/
int set_padding_enable(); int set_padding_enable(sls::ServerInterface2 &socket);
/** set deactivated receiver padding enable */ /** set deactivated receiver padding enable */
int set_deactivated_padding_enable(); int set_deactivated_padding_enable(sls::ServerInterface2 &socket);
/** set readout flags */ /** set readout flags */
int set_readout_flags(); int set_readout_flags(sls::ServerInterface2 &socket);
/** set adc mask */ /** set adc mask */
int set_adc_mask(); int set_adc_mask(sls::ServerInterface2 &socket);
/** set receiver dbit list */ /** set receiver dbit list */
int set_dbit_list(); int set_dbit_list(sls::ServerInterface2 &socket);
/** get receiver dbit list */ /** get receiver dbit list */
int get_dbit_list(); int get_dbit_list(sls::ServerInterface2 &socket);
/** set dbit offset */ /** set dbit offset */
int set_dbit_offset(); int set_dbit_offset(sls::ServerInterface2 &socket);
/** detector type */ /** detector type */
@ -306,7 +306,7 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
slsReceiverImplementation *receiver; slsReceiverImplementation *receiver;
/** Function List */ /** Function List */
int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])(); int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])(sls::ServerInterface2& socket);
/** Message */ /** Message */
char mess[MAX_STR_LENGTH]; char mess[MAX_STR_LENGTH];
@ -390,4 +390,8 @@ protected:
/** client interface */ /** client interface */
ServerInterface* interface; ServerInterface* interface;
private:
int VerifyLock(int &ret, char *mess);
int VerifyLockAndIdle(int &ret, char *mess, int fnum);
}; };

539
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp
View File

File diff suppressed because it is too large Load Diff

1
slsSupportLib/CMakeLists.txt
View File

@ -6,6 +6,7 @@ set(SOURCES
src/DataSocket.cpp src/DataSocket.cpp
src/ServerSocket.cpp src/ServerSocket.cpp
src/ServerInterface.cpp src/ServerInterface.cpp
src/ServerInterface2.cpp
src/network_utils.cpp src/network_utils.cpp
) )

28
slsSupportLib/include/ServerInterface2.h Normal file
View File

@ -0,0 +1,28 @@
#pragma once
#include "DataSocket.h"
namespace sls {
class ServerInterface2;
}
#include "ServerSocket.h"
#include "sls_detector_defs.h"
namespace sls {
class ServerInterface2 : public DataSocket {
using defs = slsDetectorDefs;
public:
ServerInterface2(int socketId) : DataSocket(socketId){}
int sendResult(bool update, int ret, void *retval, int retvalSize,
char *mess = nullptr);
int receiveArg(int &ret, char *mess, void *arg, int sizeofArg);
private:
};
} // namespace sls

15
slsSupportLib/include/ServerSocket.h
View File

@ -1,7 +1,8 @@
#pragma once #pragma once
#include "DataSocket.h" #include "DataSocket.h"
#include "ServerInterface2.h"
#include "network_utils.h"
#include <cstdint> #include <cstdint>
#include <netdb.h> #include <netdb.h>
#include <string> #include <string>
@ -13,14 +14,18 @@ namespace sls {
class ServerSocket : public DataSocket { class ServerSocket : public DataSocket {
public: public:
ServerSocket(int port); ServerSocket(int port);
DataSocket accept(); ServerInterface2 accept();
const std::string &getLastClient(); constexpr IpAddr getLastClient() noexcept { return lastClient; }
constexpr IpAddr getThisClient() noexcept { return thisClient; }
constexpr IpAddr getLockedBy() noexcept { return lockedBy; }
void setLockedBy(IpAddr addr){ lockedBy = addr; }
int getPort() const; int getPort() const;
void SendResult(int &ret, void *retval, int retvalSize, char *mess); void SendResult(int &ret, void *retval, int retvalSize, char *mess);
private: private:
std::string lastClient_ = std::string(INET_ADDRSTRLEN, '\0'); IpAddr thisClient;
std::string thisClient_ = std::string(INET_ADDRSTRLEN, '\0'); IpAddr lastClient;
IpAddr lockedBy;
int serverPort; int serverPort;
// char lastClient_[INET_ADDRSTRLEN]{}; // char lastClient_[INET_ADDRSTRLEN]{};
}; };

1
slsSupportLib/include/network_utils.h
View File

@ -11,6 +11,7 @@ class IpAddr {
uint32_t addr_{0}; uint32_t addr_{0};
public: public:
constexpr IpAddr() noexcept{}
constexpr IpAddr(uint32_t address) noexcept : addr_{address} {} constexpr IpAddr(uint32_t address) noexcept : addr_{address} {}
IpAddr(const std::string &address); IpAddr(const std::string &address);
IpAddr(const char *address); IpAddr(const char *address);

32
slsSupportLib/src/ServerInterface2.cpp Normal file
View File

@ -0,0 +1,32 @@
#include "ServerInterface2.h"
namespace sls {
int ServerInterface2::sendResult(bool update, int ret, void *retval,
int retvalSize, char *mess) {
// if (update && ret == defs::OK && server_->DifferentClients()) {
// ret = defs::FORCE_UPDATE;
// }
sendData(&ret, sizeof(ret));
if (ret == defs::FAIL) {
// send error message
if (mess)
sendData(mess, MAX_STR_LENGTH);
// debugging feature. should not happen.
else
FILE_LOG(logERROR) << "No error message provided for this "
"failure. Will mess up TCP\n";
}
sendData(retval, retvalSize);
return ret;
}
int ServerInterface2::receiveArg(int &ret, char *mess, void *arg,
int sizeofArg) {
if (sizeofArg && receiveData(arg, sizeofArg) < 0)
return defs::FAIL;
return defs::OK;
}
} // namespace sls

17
slsSupportLib/src/ServerSocket.cpp
View File

@ -1,4 +1,6 @@
#include "ServerInterface2.h"
#include "ServerSocket.h" #include "ServerSocket.h"
#include "DataSocket.h" #include "DataSocket.h"
#include "logger.h" #include "logger.h"
#include "sls_detector_defs.h" #include "sls_detector_defs.h"
@ -35,7 +37,8 @@ ServerSocket::ServerSocket(int port)
} }
} }
DataSocket ServerSocket::accept() { ServerInterface2 ServerSocket::accept() {
lastClient = thisClient; //update from previous connection
struct sockaddr_in clientAddr; struct sockaddr_in clientAddr;
socklen_t addr_size = sizeof clientAddr; socklen_t addr_size = sizeof clientAddr;
int newSocket = int newSocket =
@ -43,17 +46,15 @@ DataSocket ServerSocket::accept() {
if (newSocket == -1) { if (newSocket == -1) {
throw sls::SocketError("Server ERROR: socket accept failed\n"); throw sls::SocketError("Server ERROR: socket accept failed\n");
} }
inet_ntop(AF_INET, &(clientAddr.sin_addr), &thisClient_.front(), char tc[INET_ADDRSTRLEN]{};
INET_ADDRSTRLEN); inet_ntop(AF_INET, &(clientAddr.sin_addr), tc, INET_ADDRSTRLEN);
std::cout << "lastClient: " << lastClient_ << " thisClient: " << thisClient_ thisClient = tc;
std::cout << "lastClient: " << lastClient << " thisClient: " << thisClient
<< '\n'; << '\n';
// Here goes any check for locks etc
lastClient_ = thisClient_;
return DataSocket(newSocket); return ServerInterface2(newSocket);
} }
const std::string &ServerSocket::getLastClient() { return lastClient_; }
int ServerSocket::getPort() const { return serverPort; } int ServerSocket::getPort() const { return serverPort; }

1
slsSupportLib/src/network_utils.cpp
View File

@ -16,6 +16,7 @@
namespace sls { namespace sls {
IpAddr::IpAddr(const std::string &address) { IpAddr::IpAddr(const std::string &address) {
inet_pton(AF_INET, address.c_str(), &addr_); inet_pton(AF_INET, address.c_str(), &addr_);
} }