diff --git a/slsDetectorSoftware/src/slsDetector.cpp b/slsDetectorSoftware/src/slsDetector.cpp index 7215bd856..4c162475e 100755 --- a/slsDetectorSoftware/src/slsDetector.cpp +++ b/slsDetectorSoftware/src/slsDetector.cpp @@ -1,6 +1,5 @@ #include "slsDetector.h" #include "ClientSocket.h" -#include "ServerInterface.h" #include "SharedMemory.h" #include "file_utils.h" #include "multiSlsDetector.h" @@ -3216,10 +3215,10 @@ int slsDetector::setReceiverOnline(int value) { } else { shm()->rxOnlineFlag = OFFLINE_FLAG; if (value == ONLINE_FLAG) { - // connect and set offline flag - auto receiver = - ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort); - receiver.close(); + // Connect and ask for receiver id to verify that + // it's online and working + int64_t retval{0}; + sendToReceiver(F_GET_RECEIVER_ID, nullptr, retval); shm()->rxOnlineFlag = ONLINE_FLAG; if (shm()->receiverAPIVersion == 0) { checkReceiverVersionCompatibility(); diff --git a/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h b/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h index 00431f8f8..19b13b3b4 100755 --- a/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h +++ b/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h @@ -10,8 +10,8 @@ class MySocketTCP; class ServerInterface; -class slsReceiverImplementation; - +#include "slsReceiverImplementation.h" +#include "ServerSocket.h" /** @@ -113,7 +113,7 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs { int function_table(); /** Decodes Function */ - int decode_function(); + int decode_function(sls::ServerInterface2 &socket); /** function not implemented for specific detector */ void functionNotImplemented(); @@ -126,208 +126,211 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs { void validate(T arg, T retval, std::string modename, numberMode hex); /** Unrecognized Function */ - int M_nofunc(); + int M_nofunc(sls::ServerInterface2 & socket); /** Execute command */ - int exec_command(); + int exec_command(sls::ServerInterface2 &socket); /** Exit Receiver Server */ - int exit_server(); + int exit_server(sls::ServerInterface2 &socket); /** Locks Receiver */ - int lock_receiver(); + int lock_receiver(sls::ServerInterface2 &socket); /** Get Last Client IP*/ - int get_last_client_ip(); + int get_last_client_ip(sls::ServerInterface2 &socket); /** Set port */ - int set_port(); + int set_port(sls::ServerInterface2 &socket); /** Updates Client if different clients connect */ - int update_client(); + int update_client(sls::ServerInterface2 &socket); /** Sends the updated parameters to client */ - int send_update(); + int send_update(sls::ServerInterface2 &socket); /** get version, calls get_version */ - int get_id(); + int get_id(sls::ServerInterface2 &socket); /** Set detector type */ - int set_detector_type(); + int set_detector_type(sls::ServerInterface2 &socket); /** set detector hostname */ - int set_detector_hostname(); + int set_detector_hostname(sls::ServerInterface2 &socket); /** set roi */ - int set_roi(); + int set_roi(sls::ServerInterface2 &socket); /** Set up UDP Details */ - int setup_udp(); + int setup_udp(sls::ServerInterface2 &socket); /** set acquisition period, frame number etc */ - int set_timer(); + int set_timer(sls::ServerInterface2 &socket); /** set dynamic range */ - int set_dynamic_range(); + int set_dynamic_range(sls::ServerInterface2 &socket); /** Sets the receiver streaming frequency */ - int set_streaming_frequency(); + int set_streaming_frequency(sls::ServerInterface2 &socket); /** Gets receiver status */ - int get_status(); + int get_status(sls::ServerInterface2 &socket); /** 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*/ - int stop_receiver(); + int stop_receiver(sls::ServerInterface2 &socket); /** Set File path */ - int set_file_dir(); + int set_file_dir(sls::ServerInterface2 &socket); /** Set File name without frame index, file index and extension */ - int set_file_name(); + int set_file_name(sls::ServerInterface2 &socket); /** Set File index */ - int set_file_index(); + int set_file_index(sls::ServerInterface2 &socket); /** Gets frame index for each acquisition */ - int get_frame_index(); + int get_frame_index(sls::ServerInterface2 &socket); /** Gets Total Frames Caught */ - int get_frames_caught(); + int get_frames_caught(sls::ServerInterface2 &socket); /** Resets Total Frames Caught */ - int reset_frames_caught(); + int reset_frames_caught(sls::ServerInterface2 &socket); /** Enable File Write*/ - int enable_file_write(); + int enable_file_write(sls::ServerInterface2 &socket); /** Enable Master File Write */ - int enable_master_file_write(); + int enable_master_file_write(sls::ServerInterface2 &socket); /** enable compression */ - int enable_compression(); + int enable_compression(sls::ServerInterface2 &socket); /** enable overwrite */ - int enable_overwrite(); + int enable_overwrite(sls::ServerInterface2 &socket); /** enable 10Gbe */ - int enable_tengiga(); + int enable_tengiga(sls::ServerInterface2 &socket); /** set fifo depth */ - int set_fifo_depth(); + int set_fifo_depth(sls::ServerInterface2 &socket); /** activate/ deactivate */ - int set_activate(); + int set_activate(sls::ServerInterface2 &socket); /* 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 */ - int set_streaming_timer(); + int set_streaming_timer(sls::ServerInterface2 &socket); /** enable flipped data */ - int set_flipped_data(); + int set_flipped_data(sls::ServerInterface2 &socket); /** set file format */ - int set_file_format(); + int set_file_format(sls::ServerInterface2 &socket); /** set position id */ - int set_detector_posid(); + int set_detector_posid(sls::ServerInterface2 &socket); /** set multi detector size */ - int set_multi_detector_size(); + int set_multi_detector_size(sls::ServerInterface2 &socket); /** set streaming port */ - int set_streaming_port(); + int set_streaming_port(sls::ServerInterface2 &socket); /** set streaming source ip */ - int set_streaming_source_ip(); + int set_streaming_source_ip(sls::ServerInterface2 &socket); /** set silent mode */ - int set_silent_mode(); + int set_silent_mode(sls::ServerInterface2 &socket); /** enable gap pixels */ - int enable_gap_pixels(); + int enable_gap_pixels(sls::ServerInterface2 &socket); /** restream stop packet */ - int restream_stop(); + int restream_stop(sls::ServerInterface2 &socket); /** set additional json header */ - int set_additional_json_header(); + int set_additional_json_header(sls::ServerInterface2 &socket); /** get additional json header */ - int get_additional_json_header(); + int get_additional_json_header(sls::ServerInterface2 &socket); /** 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 */ - int get_real_udp_socket_buffer_size(); + int get_real_udp_socket_buffer_size(sls::ServerInterface2 &socket); /** set frames per file */ - int set_frames_per_file(); + int set_frames_per_file(sls::ServerInterface2 &socket); /** check version compatibility */ - int check_version_compatibility(); + int check_version_compatibility(sls::ServerInterface2 &socket); /** set frame discard policy */ - int set_discard_policy(); + int set_discard_policy(sls::ServerInterface2 &socket); /** set partial frame padding enable*/ - int set_padding_enable(); + int set_padding_enable(sls::ServerInterface2 &socket); /** set deactivated receiver padding enable */ - int set_deactivated_padding_enable(); + int set_deactivated_padding_enable(sls::ServerInterface2 &socket); /** set readout flags */ - int set_readout_flags(); + int set_readout_flags(sls::ServerInterface2 &socket); /** set adc mask */ - int set_adc_mask(); + int set_adc_mask(sls::ServerInterface2 &socket); /** set receiver dbit list */ - int set_dbit_list(); + int set_dbit_list(sls::ServerInterface2 &socket); /** get receiver dbit list */ - int get_dbit_list(); + int get_dbit_list(sls::ServerInterface2 &socket); /** set dbit offset */ - int set_dbit_offset(); + int set_dbit_offset(sls::ServerInterface2 &socket); + int LogSocketCrash(); + void NullObjectError(int& ret, char* mess); + /** detector type */ detectorType myDetectorType; /** slsReceiverBase object */ - slsReceiverImplementation *receiver; + std::unique_ptr receiver{nullptr}; /** Function List */ - int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])(); + int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])(sls::ServerInterface2& socket); /** Message */ - char mess[MAX_STR_LENGTH]; + char mess[MAX_STR_LENGTH]{}; /** success/failure */ - int ret; + int ret{OK}; /** function index */ - int fnum; + int fnum{-1}; /** Lock Status if server locked to a client */ - int lockStatus; + int lockStatus{0}; /** kill tcp server thread */ - int killTCPServerThread; + int killTCPServerThread{0}; /** thread for TCP server */ pthread_t TCPServer_thread; /** tcp thread created flag*/ - bool tcpThreadCreated; + bool tcpThreadCreated{false}; /** port number */ int portNumber; @@ -345,16 +348,16 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs { * we write depending on file write enable * users get data to write depending on call backs registered */ - int (*startAcquisitionCallBack)(char*, char*, uint64_t, uint32_t, void*); - void *pStartAcquisition; + int (*startAcquisitionCallBack)(char*, char*, uint64_t, uint32_t, void*) = nullptr; + void *pStartAcquisition{nullptr}; /** * Call back for acquisition finished * callback argument is * total frames caught */ - void (*acquisitionFinishedCallBack)(uint64_t, void*); - void *pAcquisitionFinished; + void (*acquisitionFinishedCallBack)(uint64_t, void*) = nullptr; + void *pAcquisitionFinished{nullptr}; /** @@ -365,7 +368,7 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs { * dataSize in bytes is the size of the data in bytes. */ void (*rawDataReadyCallBack)(char* , - char*, uint32_t, void*); + char*, uint32_t, void*) = nullptr; /** * Call back for raw data (modified) @@ -375,17 +378,18 @@ class slsReceiverTCPIPInterface : private virtual slsDetectorDefs { * revDatasize is the reference of data size in bytes. Can be modified to the new size to be written/streamed. (only smaller value). */ void (*rawDataModifyReadyCallBack)(char* , - char*, uint32_t &, void*); + char*, uint32_t &, void*) = nullptr; - void *pRawDataReady; + void *pRawDataReady{nullptr}; protected: - /** Socket */ - MySocketTCP* mySock; - /** client interface */ - ServerInterface* interface; + std::unique_ptr server{nullptr}; + + private: + int VerifyLock(int &ret, char *mess); + int VerifyLockAndIdle(int &ret, char *mess, int fnum); }; diff --git a/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp b/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp index 0c7701cb6..5cb082b2f 100755 --- a/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp +++ b/slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp @@ -5,70 +5,35 @@ #include "FixedCapacityContainer.h" -#include "MySocketTCP.h" -#include "ServerInterface.h" +#include "ServerSocket.h" #include "slsReceiver.h" #include "slsReceiverImplementation.h" #include "slsReceiverTCPIPInterface.h" #include "slsReceiverUsers.h" #include "versionAPI.h" +#include "string_utils.h" +#include "sls_detector_exceptions.h" #include -#include //EXIT #include #include #include -#include //unique_ptr +#include #include #include #include #include +using sls::SocketError; + slsReceiverTCPIPInterface::~slsReceiverTCPIPInterface() { stop(); - if(mySock) { - delete mySock; - mySock=nullptr; - } - - delete interface; - - delete receiver; } slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int pn): myDetectorType(GOTTHARD), - receiver(nullptr), - ret(OK), - fnum(-1), - lockStatus(0), - killTCPServerThread(0), - tcpThreadCreated(false), - portNumber(DEFAULT_PORTNO+2), - mySock(nullptr), - interface(nullptr) + portNumber(pn > 0 ? pn : DEFAULT_PORTNO + 2) { - //***callback parameters*** - startAcquisitionCallBack = nullptr; - pStartAcquisition = nullptr; - acquisitionFinishedCallBack = nullptr; - pAcquisitionFinished = nullptr; - rawDataReadyCallBack = nullptr; - rawDataModifyReadyCallBack = nullptr; - pRawDataReady = nullptr; - - // create socket - portNumber = (pn > 0 ? pn : DEFAULT_PORTNO + 2); - MySocketTCP* m = new MySocketTCP(portNumber); - mySock = m; - interface = new ServerInterface(mySock, -1, "Receiver"); - - //initialize variables - strcpy(mySock->lastClientIP,"none"); - strcpy(mySock->thisClientIP,"none1"); - memset(mess,0,sizeof(mess)); - strcpy(mess,"dummy message"); - function_table(); } @@ -81,9 +46,7 @@ int slsReceiverTCPIPInterface::start(){ return FAIL; } tcpThreadCreated = true; - //#ifdef VERYVERBOSE FILE_LOG(logDEBUG) << "TCP Server thread created successfully."; - //#endif return OK; } @@ -92,7 +55,8 @@ void slsReceiverTCPIPInterface::stop(){ if (tcpThreadCreated) { FILE_LOG(logINFO) << "Shutting down TCP Socket on port " << portNumber; killTCPServerThread = 1; - if(mySock) mySock->ShutDownSocket(); + if(server) + server->shutDownSocket(); FILE_LOG(logDEBUG) << "TCP Socket closed on port " << portNumber; pthread_join(TCPServer_thread, nullptr); tcpThreadCreated = false; @@ -137,46 +101,50 @@ void* slsReceiverTCPIPInterface::startTCPServerThread(void *this_pointer){ return this_pointer; } +void slsReceiverTCPIPInterface::startTCPServer() { + FILE_LOG(logINFOBLUE) << "Created [ TCP server Tid: " + << syscall(SYS_gettid) << "]"; + FILE_LOG(logINFO) << "SLS Receiver starting TCP Server on port " + << portNumber << std::endl; + int ret = OK; + server = sls::make_unique(portNumber); + while (true) { + FILE_LOG(logDEBUG1) << "Start accept loop"; + try { + auto socket = server->accept(); + constexpr int time_us = 5000000; + socket.setReceiveTimeout(time_us); + ret = decode_function(socket); -void slsReceiverTCPIPInterface::startTCPServer(){ - FILE_LOG(logINFOBLUE) << "Created [ TCP server Tid: " << syscall(SYS_gettid) << "]";; - FILE_LOG(logINFO) << "SLS Receiver starting TCP Server on port " << portNumber << std::endl; - int ret = OK; - - while(true) { - if(mySock->Connect() >= 0){ - ret = decode_function(); - mySock->Disconnect(); + // if tcp command was to exit server + if (ret == GOODBYE) { + FILE_LOG(logINFO) << "Shutting down UDP Socket"; + if (receiver) { + receiver->shutDownUDPSockets(); + } + FILE_LOG(logINFOBLUE) + << "Exiting [ TCP server Tid: " << syscall(SYS_gettid) + << "]"; + pthread_exit(nullptr); + } + }catch(const sls::SocketError& e){ + std::cout << "Accept failed\n"; } - //if tcp command was to exit server - if(ret == GOODBYE){ - FILE_LOG(logINFO) << "Shutting down UDP Socket"; - if(receiver){ - receiver->shutDownUDPSockets(); - } - - mySock->exitServer(); - FILE_LOG(logINFOBLUE) << "Exiting [ TCP server Tid: " << syscall(SYS_gettid) <<"]"; - pthread_exit(nullptr); - } - - //if user entered exit - if(killTCPServerThread) { - if (ret != GOODBYE) { - if(receiver){ - receiver->shutDownUDPSockets(); - } - } - FILE_LOG(logINFOBLUE) << "Exiting [ TCP server Tid: " << syscall(SYS_gettid) <<"]"; - pthread_exit(nullptr); - } - } + // if user entered exit + if (killTCPServerThread) { + if (ret != GOODBYE) { + if (receiver) { + receiver->shutDownUDPSockets(); + } + } + FILE_LOG(logINFOBLUE) + << "Exiting [ TCP server Tid: " << syscall(SYS_gettid) << "]"; + pthread_exit(nullptr); + } + } } - - - int slsReceiverTCPIPInterface::function_table(){ flist[F_EXEC_RECEIVER_COMMAND] = &slsReceiverTCPIPInterface::exec_command; flist[F_EXIT_RECEIVER] = &slsReceiverTCPIPInterface::exit_server; @@ -241,41 +209,38 @@ int slsReceiverTCPIPInterface::function_table(){ return OK; } - - - -int slsReceiverTCPIPInterface::decode_function(){ - ret = FAIL; - int n = mySock->ReceiveDataOnly(&fnum,sizeof(fnum)); - if (n <= 0) { - FILE_LOG(logDEBUG3) << "Could not read socket. " - "Received " << n << " bytes," << - "fnum:" << fnum << " " - "(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ")"; - return FAIL; - } - else - FILE_LOG(logDEBUG3) << "Received " << n << " bytes"; - - if (fnum <= NUM_DET_FUNCTIONS || fnum >= NUM_REC_FUNCTIONS) { - FILE_LOG(logERROR) << "Unknown function enum " << fnum; - ret = (this->M_nofunc)(); - } else{ - FILE_LOG(logDEBUG1) << "calling function fnum: "<< fnum << " " - "(" << getFunctionNameFromEnum((enum detFuncs)fnum) << ") " - "located at " << flist[fnum]; - ret = (this->*flist[fnum])(); - - if (ret == FAIL) { - FILE_LOG(logDEBUG1) << "Failed to execute function = " << fnum << " (" - << getFunctionNameFromEnum((enum detFuncs)fnum) << ")"; - } else FILE_LOG(logDEBUG1) << "Function " << - getFunctionNameFromEnum((enum detFuncs)fnum) << " executed OK"; - } - return ret; +int slsReceiverTCPIPInterface::decode_function(sls::ServerInterface2 &socket) { + ret = FAIL; + int n = socket.read(&fnum, sizeof(fnum)); + if (n <= 0) { + FILE_LOG(logDEBUG3) + << "Could not read socket. Received " << n + << " bytes, fnum:" << fnum << " (" + << getFunctionNameFromEnum((enum detFuncs)fnum) << ")"; + return FAIL; + } else { + FILE_LOG(logDEBUG3) << "Received " << n << " bytes"; + } + if (fnum <= NUM_DET_FUNCTIONS || fnum >= NUM_REC_FUNCTIONS) { + FILE_LOG(logERROR) << "Unknown function enum " << fnum; + ret = (this->M_nofunc)(socket); + } else { + FILE_LOG(logDEBUG1) << "calling function fnum: " << fnum << " (" + << getFunctionNameFromEnum((enum detFuncs)fnum) + << ") located at " << flist[fnum]; + ret = (this->*flist[fnum])(socket); + if (ret == FAIL) { + FILE_LOG(logDEBUG1) + << "Failed to execute function = " << fnum << " (" + << getFunctionNameFromEnum((enum detFuncs)fnum) << ")"; + } else + FILE_LOG(logDEBUG1) + << "Function " << getFunctionNameFromEnum((enum detFuncs)fnum) + << " executed OK"; + } + return ret; } - void slsReceiverTCPIPInterface::functionNotImplemented() { ret = FAIL; sprintf(mess, "Function (%s) is not implemented for this detector\n", @@ -303,37 +268,53 @@ void slsReceiverTCPIPInterface::validate(T arg, T retval, std::string modename, } } -int slsReceiverTCPIPInterface::M_nofunc(){ +int slsReceiverTCPIPInterface::M_nofunc(sls::ServerInterface2 &socket){ ret = FAIL; memset(mess, 0, sizeof(mess)); - // to receive any arguments int n = 1; while (n > 0) - n = mySock->ReceiveDataOnly(mess, MAX_STR_LENGTH); + n = socket.read(mess, MAX_STR_LENGTH); sprintf(mess,"Unrecognized Function enum %d. Please do not proceed.\n", fnum); FILE_LOG(logERROR) << mess; - return interface->Server_SendResult(false, ret, nullptr, 0, mess); + return socket.sendResult(false, ret, nullptr, 0, mess); } +int slsReceiverTCPIPInterface::VerifyLock(int &ret, char *mess) { + if (server->getThisClient() != server->getLockedBy() && lockStatus) { + ret = FAIL; + sprintf(mess, "Receiver locked\n"); + FILE_LOG(logERROR) << mess; + } + return ret; +} +int slsReceiverTCPIPInterface::VerifyLockAndIdle(int &ret, char *mess, int fnum) { + VerifyLock(ret, mess); + if (ret == FAIL) + return ret; + if (receiver->getStatus() != IDLE) { + sprintf(mess, "Can not execute %s when receiver is not idle\n", + getFunctionNameFromEnum((enum detFuncs)fnum)); + } + ret = OK; + return ret; +} - -int slsReceiverTCPIPInterface::exec_command() { +int slsReceiverTCPIPInterface::exec_command(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); - char cmd[MAX_STR_LENGTH] = {0}; - char retval[MAX_STR_LENGTH] = {0}; + char cmd[MAX_STR_LENGTH]{}; + char retval[MAX_STR_LENGTH]{}; // get args, return if socket crashed - if (interface->Server_ReceiveArg(ret, mess, cmd, MAX_STR_LENGTH) == FAIL) + if (socket.receiveArg(ret, mess, cmd, MAX_STR_LENGTH) == FAIL) return FAIL; FILE_LOG(logINFO) << "Executing command (" << cmd << ")"; // verify if receiver is unlocked - if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { - + if (VerifyLock(ret, mess) == OK) { const size_t tempsize = 256; std::array temp; std::string sresult; @@ -352,83 +333,76 @@ int slsReceiverTCPIPInterface::exec_command() { FILE_LOG(logINFO) << "Result of cmd (" << cmd << "):\n" << retval; } } - return interface->Server_SendResult(false, ret, retval, MAX_STR_LENGTH, mess); + return socket.sendResult(false, ret, retval, MAX_STR_LENGTH, mess); } -int slsReceiverTCPIPInterface::exit_server() { +int slsReceiverTCPIPInterface::exit_server(sls::ServerInterface2 &socket) { FILE_LOG(logINFO) << "Closing server"; ret = OK; memset(mess, 0, sizeof(mess)); - interface->Server_SendResult(false, ret, nullptr, 0); + socket.sendResult(false, ret, nullptr, 0, nullptr); return GOODBYE; } +int slsReceiverTCPIPInterface::lock_receiver(sls::ServerInterface2 &socket) { + ret = OK; + memset(mess, 0, sizeof(mess)); + int lock = 0; + // get args, return if socket crashed + if (socket.receiveArg(ret, mess, &lock, sizeof(lock)) == FAIL) + return FAIL; + FILE_LOG(logDEBUG1) << "Locking Server to " << lock; -int slsReceiverTCPIPInterface::lock_receiver() { + // execute action + if (lock >= 0) { + if (!lockStatus || (server->getLockedBy() == server->getThisClient())) { + lockStatus = lock; + lock ? server->setLockedBy(server->getThisClient()) + : server->setLockedBy(sls::IpAddr{}); + } else{ + sprintf(mess, "Receiver locked\n"); + FILE_LOG(logERROR) << mess; + } + + } + return socket.sendResult(true, ret, &lockStatus, + sizeof(lockStatus), mess); +} + +int slsReceiverTCPIPInterface::get_last_client_ip(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); - int lock = 0; - - // get args, return if socket crashed - if (interface->Server_ReceiveArg(ret, mess, &lock, sizeof(lock)) == FAIL) - return FAIL; - FILE_LOG(logDEBUG1) << "Locking Server to " << lock; - - // execute action - if (lock >= 0) { - if (!lockStatus || // if it was unlocked, anyone can lock - (!strcmp(mySock->lastClientIP,mySock->thisClientIP)) || // if it was locked, need same ip - (!strcmp(mySock->lastClientIP,"none"))) // if it was locked, must be by "none" - { - lockStatus = lock; - strcpy(mySock->lastClientIP,mySock->thisClientIP); - } else - interface->Server_LockedError(ret, mess); - } - return interface->Server_SendResult(true, ret, &lockStatus,sizeof(lockStatus), mess); + char ip[INET_ADDRSTRLEN]{}; + sls::strcpy_safe(ip, server->getLastClient().str().c_str()); + return socket.sendResult(true, ret, &ip, sizeof(ip)); } -int slsReceiverTCPIPInterface::get_last_client_ip() { - ret = OK; - memset(mess, 0, sizeof(mess)); - return interface->Server_SendResult(true, ret,mySock->lastClientIP, sizeof(mySock->lastClientIP)); -} - - - -int slsReceiverTCPIPInterface::set_port() { +int slsReceiverTCPIPInterface::set_port(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int p_number = -1; - MySocketTCP* mySocket = nullptr; - char oldLastClientIP[INET_ADDRSTRLEN] = {0}; - - // get args, return if socket crashed - if (interface->Server_ReceiveArg(ret, mess, &p_number, sizeof(p_number)) == FAIL) + if (socket.receiveArg(ret, mess, &p_number, sizeof(p_number)) == FAIL) return FAIL; - // verify if receiver is unlocked - if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { - // port number too low + if (VerifyLock(ret, mess) == OK) { if (p_number < 1024) { ret = FAIL; sprintf(mess,"Port Number (%d) too low\n", p_number); FILE_LOG(logERROR) << mess; } else { FILE_LOG(logINFO) << "set port to " << p_number <lastClientIP); - // create new socket try { - mySocket = new MySocketTCP(p_number); - strcpy(mySock->lastClientIP,oldLastClientIP); + auto new_server = sls::make_unique(p_number); + new_server->setLockedBy(server->getLockedBy()); + new_server->setLastClient(server->getLastClient()); + server = std::move(new_server); } catch(SocketError &e) { ret = FAIL; - // same socket, could not bind port sprintf(mess, "%s", e.what()); FILE_LOG(logERROR) << mess; } catch (...) { @@ -439,120 +413,113 @@ int slsReceiverTCPIPInterface::set_port() { } } - interface->Server_SendResult(true, ret, &p_number,sizeof(p_number), mess); - // delete old socket - if(ret != FAIL){ - mySock->Disconnect(); - delete mySock; - mySock = mySocket; - interface->SetSocket(mySock); - } + socket.sendResult(true, ret, &p_number,sizeof(p_number), mess); return ret; } -int slsReceiverTCPIPInterface::update_client() { +int slsReceiverTCPIPInterface::update_client(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); - // no arg, check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); - - interface->Server_SendResult(false, ret, nullptr, 0, mess); + if(receiver == nullptr) + NullObjectError(ret, mess); + socket.sendResult(false, ret, nullptr, 0, mess); if (ret == FAIL) return ret; // update - return send_update(); + return send_update(socket); } -int slsReceiverTCPIPInterface::send_update() { +int slsReceiverTCPIPInterface::send_update(sls::ServerInterface2 &socket) { int n = 0; int i32 = -1; - char cstring[MAX_STR_LENGTH] = {0}; + char cstring[MAX_STR_LENGTH]{}; - - n += mySock->SendDataOnly(mySock->lastClientIP,sizeof(mySock->lastClientIP)); + char ip[INET_ADDRSTRLEN]{}; + sls::strcpy_safe(ip, server->getLastClient().str().c_str()); + n += socket.sendData(ip,sizeof(ip)); // filepath strcpy(cstring, receiver->getFilePath().c_str()); - n += mySock->SendDataOnly(cstring, sizeof(cstring)); + n += socket.sendData(cstring, sizeof(cstring)); // filename strcpy(cstring, receiver->getFileName().c_str()); - n += mySock->SendDataOnly(cstring, sizeof(cstring)); + n += socket.sendData(cstring, sizeof(cstring)); // index i32=receiver->getFileIndex(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); //file format i32=(int)receiver->getFileFormat(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); //frames per file i32=(int)receiver->getFramesPerFile(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); //frame discard policy i32=(int)receiver->getFrameDiscardPolicy(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); //frame padding i32=(int)receiver->getFramePaddingEnable(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // file write enable i32=(int)receiver->getFileWriteEnable(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // master file write enable i32=(int)receiver->getMasterFileWriteEnable(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // file overwrite enable i32=(int)receiver->getOverwriteEnable(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // gap pixels i32=(int)receiver->getGapPixelsEnable(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // streaming frequency i32=(int)receiver->getStreamingFrequency(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // streaming port i32=(int)receiver->getStreamingPort(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // streaming source ip strcpy(cstring, receiver->getStreamingSourceIP().c_str()); - n += mySock->SendDataOnly(cstring, sizeof(cstring)); + n += socket.sendData(cstring, sizeof(cstring)); // additional json header strcpy(cstring, receiver->getAdditionalJsonHeader().c_str()); - n += mySock->SendDataOnly(cstring, sizeof(cstring)); + n += socket.sendData(cstring, sizeof(cstring)); // data streaming enable i32=(int)receiver->getDataStreamEnable(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // activate i32=(int)receiver->getActivate(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // deactivated padding enable i32=(int)receiver->getDeactivatedPadding(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // silent mode i32=(int)receiver->getSilentMode(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); + n += socket.sendData(&i32, sizeof(i32)); // dbit list { @@ -560,48 +527,48 @@ int slsReceiverTCPIPInterface::send_update() { int retvalsize = list.size(); int retval[retvalsize]; std::copy(std::begin(list), std::end(list), retval); - mySock->SendDataOnly(&retvalsize, sizeof(retvalsize)); - mySock->SendDataOnly(retval, sizeof(retval)); + socket.sendData(&retvalsize, sizeof(retvalsize)); + socket.sendData(retval, sizeof(retval)); } // dbit offset i32=receiver->getDbitOffset(); - n += mySock->SendDataOnly(&i32, sizeof(i32)); - - if (!lockStatus) - strcpy(mySock->lastClientIP, mySock->thisClientIP); + n += socket.sendData(&i32, sizeof(i32)); return OK; } -int slsReceiverTCPIPInterface::get_id(){ +int slsReceiverTCPIPInterface::get_id(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); int64_t retval = getReceiverVersion(); - return interface->Server_SendResult(true, ret, &retval, sizeof(retval)); + return socket.sendResult(true, ret, &retval, sizeof(retval)); } -int slsReceiverTCPIPInterface::set_detector_type(){ +int slsReceiverTCPIPInterface::set_detector_type(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); detectorType arg = GENERIC; detectorType retval = GENERIC; // get args, return if socket crashed - if (interface->Server_ReceiveArg(ret, mess, &arg, sizeof(arg)) == FAIL) + if (socket.receiveArg(ret, mess, &arg, sizeof(arg)) == FAIL) return FAIL; // set if (arg >= 0) { // if object exists, verify unlocked and idle, else only verify lock (connecting first time) - if (receiver == nullptr) - interface->Server_VerifyLock(ret, mess, lockStatus); - else - interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum); + if (receiver == nullptr){ + VerifyLock(ret, mess); + } + else{ + VerifyLockAndIdle(ret, mess, fnum); + } + if (ret == OK) { switch(arg) { case GOTTHARD: @@ -618,7 +585,7 @@ int slsReceiverTCPIPInterface::set_detector_type(){ } if(ret == OK) { if(receiver == nullptr){ - receiver = new slsReceiverImplementation(); + receiver = sls::make_unique(); } myDetectorType = arg; ret = receiver->setDetectorType(myDetectorType); @@ -633,10 +600,6 @@ int slsReceiverTCPIPInterface::set_detector_type(){ receiver->registerCallBackRawDataReady(rawDataReadyCallBack,pRawDataReady); if(rawDataModifyReadyCallBack) receiver->registerCallBackRawDataModifyReady(rawDataModifyReadyCallBack,pRawDataReady); - - // client has started updating receiver, update ip - if (!lockStatus) - strcpy(mySock->lastClientIP, mySock->thisClientIP); } } @@ -644,27 +607,30 @@ int slsReceiverTCPIPInterface::set_detector_type(){ //get retval = myDetectorType; validate((int)arg, (int)retval, std::string("set detector type"), DEC); - return interface->Server_SendResult(false, ret, &retval, sizeof(retval), mess); + return socket.sendResult(false, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_detector_hostname() { +int slsReceiverTCPIPInterface::set_detector_hostname(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); char hostname[MAX_STR_LENGTH] = {0}; char retval[MAX_STR_LENGTH] = {0}; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, hostname,MAX_STR_LENGTH, true, receiver) == FAIL) + socket.receiveArg(ret, mess, hostname, MAX_STR_LENGTH); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; - + } + // base object not null if (ret == OK) { // set if (strlen(hostname)) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) + if (VerifyLockAndIdle(ret, mess, fnum) == OK) receiver->setDetectorHostname(hostname); } // get @@ -677,30 +643,33 @@ int slsReceiverTCPIPInterface::set_detector_hostname() { } } - return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); + return socket.sendResult(true, ret, retval, MAX_STR_LENGTH, mess); +} + +int slsReceiverTCPIPInterface::LogSocketCrash(){ + FILE_LOG(logERROR) << "Reading from socket failed. Possible socket crash"; + return FAIL; +} + +void slsReceiverTCPIPInterface::NullObjectError(int& ret, char* mess){ + ret=FAIL; + strcpy(mess,"Receiver not set up. Please use rx_hostname first.\n"); + FILE_LOG(logERROR) << mess; } -int slsReceiverTCPIPInterface::set_roi() { +int slsReceiverTCPIPInterface::set_roi(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); + static_assert(sizeof(ROI) == 4*sizeof(int), "ROI not packed"); int narg = -1; - std::vector arg; + socket.read(&narg,sizeof(narg)); - // receive arguments - if (mySock->ReceiveDataOnly(&narg,sizeof(narg)) < 0 ) - return interface->Server_SocketCrash(); + std::vector arg; for (int iloop = 0; iloop < narg; ++iloop) { - ROI temp; - if ( mySock->ReceiveDataOnly(&temp.xmin, sizeof(int)) < 0 ) - return interface->Server_SocketCrash(); - if ( mySock->ReceiveDataOnly(&temp.xmax, sizeof(int)) < 0 ) - return interface->Server_SocketCrash(); - if ( mySock->ReceiveDataOnly(&temp.ymin, sizeof(int)) < 0 ) - return interface->Server_SocketCrash(); - if ( mySock->ReceiveDataOnly(&temp.ymax, sizeof(int)) < 0 ) - return interface->Server_SocketCrash(); + ROI temp{}; + socket.read(&temp, sizeof(temp)); arg.push_back(temp); } FILE_LOG(logDEBUG1) << "Set ROI narg: " << narg; @@ -715,34 +684,35 @@ int slsReceiverTCPIPInterface::set_roi() { // base object not null else if (receiver == nullptr) - interface->Server_NullObjectError(ret, mess); + NullObjectError(ret, mess); else { - // only set - // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) + if (VerifyLockAndIdle(ret, mess, fnum) == OK) ret = receiver->setROI(arg); } - arg.clear(); - return interface->Server_SendResult(true, ret, nullptr, 0, mess); + return socket.sendResult(true, ret, nullptr, 0, mess); } -int slsReceiverTCPIPInterface::setup_udp(){ +int slsReceiverTCPIPInterface::setup_udp(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); - char args[][MAX_STR_LENGTH] = {{""}, {""}, {""}, {""}, {""}}; - char retvals[2][MAX_STR_LENGTH] = {{""}, {""}}; + char args[5][MAX_STR_LENGTH]{}; + char retvals[2][MAX_STR_LENGTH]{}; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, args, sizeof(args), true, receiver) == FAIL) + socket.receiveArg(ret, mess, args, sizeof(args)); + if (receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } + // base object not null if (ret == OK) { // only set // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { //setup interfaces count int numInterfaces = atoi(args[0]) > 1 ? 2 : 1; @@ -758,7 +728,7 @@ int slsReceiverTCPIPInterface::setup_udp(){ } FILE_LOG(logINFO) << "Receiver UDP IP: " << ip1; // get eth - std::string temp = genericSocket::ipToName(ip1); + std::string temp = sls::IpToInterfaceName(ip1); if (temp == "none"){ ret = FAIL; strcpy(mess, "Failed to get ethernet interface or IP \n"); @@ -780,7 +750,7 @@ int slsReceiverTCPIPInterface::setup_udp(){ } //get mac address if (ret != FAIL) { - temp = genericSocket::nameToMac(eth); + temp = sls::InterfaceNameToMac(eth).str(); if (temp=="00:00:00:00:00:00") { ret = FAIL; strcpy(mess,"failed to get mac adddress to listen to\n"); @@ -797,7 +767,7 @@ int slsReceiverTCPIPInterface::setup_udp(){ receiver->setUDPPortNumber2(port2); FILE_LOG(logINFO) << "Receiver UDP IP 2: " << ip2; // get eth - temp = genericSocket::ipToName(ip2); + temp = sls::IpToInterfaceName(ip2); if (temp == "none"){ ret = FAIL; strcpy(mess, "Failed to get 2nd ethernet interface or IP \n"); @@ -817,7 +787,7 @@ int slsReceiverTCPIPInterface::setup_udp(){ //get mac address if (ret != FAIL) { - temp = genericSocket::nameToMac(eth); + temp = sls::InterfaceNameToMac(eth).str(); if (temp=="00:00:00:00:00:00") { ret = FAIL; strcpy(mess,"failed to get 2nd mac adddress to listen to\n"); @@ -838,20 +808,24 @@ int slsReceiverTCPIPInterface::setup_udp(){ } } } - return interface->Server_SendResult(true, ret, retvals, sizeof(retvals), mess); + return socket.sendResult(true, ret, retvals, sizeof(retvals), mess); } -int slsReceiverTCPIPInterface::set_timer() { + +int slsReceiverTCPIPInterface::set_timer(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int64_t index[2] = {-1, -1}; int64_t retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { @@ -860,7 +834,7 @@ int slsReceiverTCPIPInterface::set_timer() { // set if (index[1] >= 0) { // verify if receiver is unlocked - if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { + if (VerifyLock(ret, mess) == OK) { switch (index[0]) { case ACQUISITION_TIME: ret = receiver->setAcquisitionTime(index[1]); @@ -943,27 +917,30 @@ int slsReceiverTCPIPInterface::set_timer() { validate((int)index[1], (int)retval, std::string("set timer"), DEC); FILE_LOG(logDEBUG1) << slsDetectorDefs::getTimerType((timerIndex)(index[0])) << ":" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_dynamic_range() { +int slsReceiverTCPIPInterface::set_dynamic_range(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int dr = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &dr, sizeof(dr), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &dr, sizeof(dr)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (dr >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting dynamic range: " << dr; bool exists = false; switch (dr) { @@ -998,27 +975,30 @@ int slsReceiverTCPIPInterface::set_dynamic_range() { validate(dr, retval, std::string("set dynamic range"), DEC); FILE_LOG(logDEBUG1) << "dynamic range: " << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_streaming_frequency() { +int slsReceiverTCPIPInterface::set_streaming_frequency(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int index = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (index >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting streaming frequency: " << index; ret = receiver->setStreamingFrequency(index); if(ret == FAIL) { @@ -1031,41 +1011,42 @@ int slsReceiverTCPIPInterface::set_streaming_frequency() { retval = receiver->getStreamingFrequency(); validate(index, retval, std::string("set streaming frequency"), DEC); } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::get_status(){ +int slsReceiverTCPIPInterface::get_status(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); enum runStatus retval = ERROR; - // no arg, check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); + if(receiver == nullptr){ + NullObjectError(ret, mess); + } if (ret == OK) { FILE_LOG(logDEBUG1) << "Getting Status"; retval = receiver->getStatus(); FILE_LOG(logDEBUG1) << "Status:" << runStatusType(retval); } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::start_receiver(){ +int slsReceiverTCPIPInterface::start_receiver(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); - // no arg, and check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); - + if(receiver == nullptr){ + NullObjectError(ret, mess); + } // receiver is not null if (ret == OK) { // only set // verify if receiver is unlocked - if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { + if (VerifyLock(ret, mess) == OK) { // should not be idle enum runStatus s = receiver->getStatus(); if (s != IDLE) { @@ -1081,23 +1062,24 @@ int slsReceiverTCPIPInterface::start_receiver(){ } } } - return interface->Server_SendResult(true, ret, nullptr, 0, mess); + return socket.sendResult(true, ret, nullptr, 0, mess); } -int slsReceiverTCPIPInterface::stop_receiver(){ +int slsReceiverTCPIPInterface::stop_receiver(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); - // no arg, and check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); - + + if(receiver == nullptr){ + NullObjectError(ret, mess); + } // receiver is not null if (ret == OK) { // only set // verify if receiver is unlocked - if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { + if (VerifyLock(ret, mess) == OK) { if(receiver->getStatus() != IDLE) { FILE_LOG(logDEBUG1) << "Stopping Receiver"; receiver->stopReceiver(); @@ -1112,20 +1094,23 @@ int slsReceiverTCPIPInterface::stop_receiver(){ } } } - return interface->Server_SendResult(true, ret, nullptr, 0, mess); + return socket.sendResult(true, ret, nullptr, 0, mess); } -int slsReceiverTCPIPInterface::set_file_dir() { +int slsReceiverTCPIPInterface::set_file_dir(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); char fPath[MAX_STR_LENGTH] = {0}; char retval[MAX_STR_LENGTH] = {0}; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, fPath, sizeof(fPath), true, receiver) == FAIL) + socket.receiveArg(ret, mess, fPath, sizeof(fPath)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { @@ -1144,20 +1129,23 @@ int slsReceiverTCPIPInterface::set_file_dir() { } else FILE_LOG(logDEBUG1) << "file path:" << retval; } - return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); + return socket.sendResult(true, ret, retval, MAX_STR_LENGTH, mess); } -int slsReceiverTCPIPInterface::set_file_name() { +int slsReceiverTCPIPInterface::set_file_name(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); char fName[MAX_STR_LENGTH] = {0}; char retval[MAX_STR_LENGTH] = {0}; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, fName, sizeof(fName), true, receiver) == FAIL) + socket.receiveArg(ret, mess, fName, sizeof(fName)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { @@ -1176,27 +1164,30 @@ int slsReceiverTCPIPInterface::set_file_name() { } else FILE_LOG(logDEBUG1) << "file name:" << retval; } - return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); + return socket.sendResult(true, ret, retval, MAX_STR_LENGTH, mess); } -int slsReceiverTCPIPInterface::set_file_index() { +int slsReceiverTCPIPInterface::set_file_index(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int index = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (index >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting file index: " << index; receiver->setFileIndex(index); } @@ -1206,84 +1197,90 @@ int slsReceiverTCPIPInterface::set_file_index() { validate(index, retval, std::string("set file index"), DEC); FILE_LOG(logDEBUG1) << "file index:" << retval; } - return interface->Server_SendResult(true, ret, &retval,sizeof(retval), mess); + return socket.sendResult(true, ret, &retval,sizeof(retval), mess); } -int slsReceiverTCPIPInterface::get_frame_index(){ +int slsReceiverTCPIPInterface::get_frame_index(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); int retval = -1; - // no arg, check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); + if(receiver == nullptr){ + NullObjectError(ret, mess); + } if (ret == OK) { FILE_LOG(logDEBUG1) << "Getting frame index"; retval = receiver->getAcquisitionIndex(); FILE_LOG(logDEBUG1) << "frame index:" << retval; } - return interface->Server_SendResult(true, ret, &retval,sizeof(retval), mess); + return socket.sendResult(true, ret, &retval,sizeof(retval), mess); } -int slsReceiverTCPIPInterface::get_frames_caught(){ +int slsReceiverTCPIPInterface::get_frames_caught(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); int retval = -1; - // no arg, check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); + if(receiver == nullptr){ + NullObjectError(ret, mess); + } if (ret == OK) { FILE_LOG(logDEBUG1) << "Getting frames caught"; retval = receiver->getTotalFramesCaught(); FILE_LOG(logDEBUG1) << "frames caught:" << retval; } - return interface->Server_SendResult(true, ret, &retval,sizeof(retval), mess); + return socket.sendResult(true, ret, &retval,sizeof(retval), mess); } -int slsReceiverTCPIPInterface::reset_frames_caught(){ +int slsReceiverTCPIPInterface::reset_frames_caught(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); - // no arg, and check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); + if(receiver == nullptr){ + NullObjectError(ret, mess); + } // receiver is not null if (ret == OK) { // only set // verify if receiver is unlocked - if (interface->Server_VerifyLock(ret, mess, lockStatus) == OK) { + if (VerifyLock(ret, mess) == OK) { FILE_LOG(logDEBUG1) << "Reset frames caught"; receiver->resetAcquisitionCount(); } } - return interface->Server_SendResult(true, ret, nullptr, 0, mess); + return socket.sendResult(true, ret, nullptr, 0, mess); } -int slsReceiverTCPIPInterface::enable_file_write(){ +int slsReceiverTCPIPInterface::enable_file_write(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); int enable = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &enable, sizeof(enable), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &enable, sizeof(enable)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (enable >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting File write enable:" << enable; receiver->setFileWriteEnable(enable); } @@ -1293,27 +1290,30 @@ int slsReceiverTCPIPInterface::enable_file_write(){ validate(enable, retval, std::string("set file write enable"), DEC); FILE_LOG(logDEBUG1) << "file write enable:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::enable_master_file_write(){ +int slsReceiverTCPIPInterface::enable_master_file_write(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); int enable = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &enable, sizeof(enable), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &enable, sizeof(enable)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (enable >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting Master File write enable:" << enable; receiver->setMasterFileWriteEnable(enable); } @@ -1323,26 +1323,29 @@ int slsReceiverTCPIPInterface::enable_master_file_write(){ validate(enable, retval, std::string("set master file write enable"), DEC); FILE_LOG(logDEBUG1) << "master file write enable:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::enable_overwrite() { +int slsReceiverTCPIPInterface::enable_overwrite(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int index = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (index >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting File overwrite enable:" << index; receiver->setOverwriteEnable(index); } @@ -1352,20 +1355,23 @@ int slsReceiverTCPIPInterface::enable_overwrite() { validate(index, retval, std::string("set file overwrite enable"), DEC); FILE_LOG(logDEBUG1) << "file overwrite enable:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::enable_tengiga() { +int slsReceiverTCPIPInterface::enable_tengiga(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int val = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &val, sizeof(val), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &val, sizeof(val)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } if (myDetectorType != EIGER && myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) functionNotImplemented(); @@ -1375,7 +1381,7 @@ int slsReceiverTCPIPInterface::enable_tengiga() { // set if (val >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting 10GbE:" << val; ret = receiver->setTenGigaEnable(val); } @@ -1385,27 +1391,30 @@ int slsReceiverTCPIPInterface::enable_tengiga() { validate(val, retval, std::string("set 10GbE"), DEC); FILE_LOG(logDEBUG1) << "10Gbe:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_fifo_depth() { +int slsReceiverTCPIPInterface::set_fifo_depth(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int value = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &value, sizeof(value), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &value, sizeof(value)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (value >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting fifo depth:" << value; ret = receiver->setFifoDepth(value); if (ret == FAIL) { @@ -1419,20 +1428,23 @@ int slsReceiverTCPIPInterface::set_fifo_depth() { validate(value, retval, std::string("set fifo depth"), DEC); FILE_LOG(logDEBUG1) << "fifo depth:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_activate() { +int slsReceiverTCPIPInterface::set_activate(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int enable = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &enable, sizeof(enable), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &enable, sizeof(enable)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } if (myDetectorType != EIGER) functionNotImplemented(); @@ -1442,7 +1454,7 @@ int slsReceiverTCPIPInterface::set_activate() { // set if (enable >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting activate:" << enable; receiver->setActivate(enable > 0 ? true : false); } @@ -1452,27 +1464,29 @@ int slsReceiverTCPIPInterface::set_activate() { validate(enable, retval, std::string("set activate"), DEC); FILE_LOG(logDEBUG1) << "Activate: " << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_data_stream_enable(){ +int slsReceiverTCPIPInterface::set_data_stream_enable(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); int index = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; - + } // base object not null if (ret == OK) { // set if (index >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting data stream enable:" << index; ret = receiver->setDataStreamEnable(index); } @@ -1482,27 +1496,30 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(){ validate(index, retval, std::string("set data stream enable"), DEC); FILE_LOG(logDEBUG1) << "data streaming enable:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_streaming_timer(){ +int slsReceiverTCPIPInterface::set_streaming_timer(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); int index = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (index >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting streaming timer:" << index; receiver->setStreamingTimer(index); } @@ -1512,20 +1529,23 @@ int slsReceiverTCPIPInterface::set_streaming_timer(){ validate(index, retval, std::string("set data stream timer"), DEC); FILE_LOG(logDEBUG1) << "Streaming timer:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_flipped_data(){ +int slsReceiverTCPIPInterface::set_flipped_data(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); int args[2] = {0,-1}; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, args, sizeof(args), true, receiver) == FAIL) + socket.receiveArg(ret, mess, args, sizeof(args)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } if (myDetectorType != EIGER) functionNotImplemented(); @@ -1535,7 +1555,7 @@ int slsReceiverTCPIPInterface::set_flipped_data(){ // set if (args[1] >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting flipped data:" << args[1]; receiver->setFlippedData(args[0],args[1]); } @@ -1545,27 +1565,30 @@ int slsReceiverTCPIPInterface::set_flipped_data(){ validate(args[1], retval, std::string("set flipped data"), DEC); FILE_LOG(logDEBUG1) << "Flipped Data:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_file_format() { +int slsReceiverTCPIPInterface::set_file_format(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); fileFormat retval = GET_FILE_FORMAT; fileFormat f = GET_FILE_FORMAT; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &f, sizeof(f), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &f, sizeof(f)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (f >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting file format:" << f; receiver->setFileFormat(f); } @@ -1575,27 +1598,30 @@ int slsReceiverTCPIPInterface::set_file_format() { validate(f, retval, std::string("set file format"), DEC); FILE_LOG(logDEBUG1) << "File Format: " << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_detector_posid() { +int slsReceiverTCPIPInterface::set_detector_posid(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int arg = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &arg, sizeof(arg), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &arg, sizeof(arg)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (arg >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting detector position id:" << arg; receiver->setDetectorPositionId(arg); } @@ -1605,27 +1631,30 @@ int slsReceiverTCPIPInterface::set_detector_posid() { validate(arg, retval, std::string("set detector position id"), DEC); FILE_LOG(logDEBUG1) << "Position Id:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_multi_detector_size() { +int slsReceiverTCPIPInterface::set_multi_detector_size(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); - int arg[2] = {-1, -1}; + int arg[]{-1, -1}; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, arg, sizeof(arg), true, receiver) == FAIL) + socket.receiveArg(ret, mess, arg, sizeof(arg)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if((arg[0] > 0) && (arg[1] > 0)) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting multi detector size:" << arg[0] << "," << arg[1]; receiver->setMultiDetectorSize(arg); } @@ -1640,27 +1669,30 @@ int slsReceiverTCPIPInterface::set_multi_detector_size() { } FILE_LOG(logDEBUG1) << "Multi Detector Size:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_streaming_port() { +int slsReceiverTCPIPInterface::set_streaming_port(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int port = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &port, sizeof(port), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &port, sizeof(port)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (port >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting streaming port:" << port; receiver->setStreamingPort(port); } @@ -1670,26 +1702,29 @@ int slsReceiverTCPIPInterface::set_streaming_port() { validate(port, retval, std::string("set streaming port"), DEC); FILE_LOG(logDEBUG1) << "streaming port:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_streaming_source_ip() { +int slsReceiverTCPIPInterface::set_streaming_source_ip(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); char arg[MAX_STR_LENGTH] = {0}; char retval[MAX_STR_LENGTH] = {0}; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, arg, MAX_STR_LENGTH, true, receiver) == FAIL) + socket.receiveArg(ret, mess, arg, MAX_STR_LENGTH); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // only set // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting streaming source ip:" << arg; receiver->setStreamingSourceIP(arg); } @@ -1697,27 +1732,30 @@ int slsReceiverTCPIPInterface::set_streaming_source_ip() { strcpy(retval, receiver->getStreamingSourceIP().c_str()); FILE_LOG(logDEBUG1) << "streaming source ip:" << retval; } - return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); + return socket.sendResult(true, ret, retval, MAX_STR_LENGTH, mess); } -int slsReceiverTCPIPInterface::set_silent_mode() { +int slsReceiverTCPIPInterface::set_silent_mode(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int value = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &value, sizeof(value), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &value, sizeof(value)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (value >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting silent mode:" << value; receiver->setSilentMode(value); } @@ -1727,20 +1765,23 @@ int slsReceiverTCPIPInterface::set_silent_mode() { validate(value, retval, std::string("set silent mode"), DEC); FILE_LOG(logDEBUG1) << "silent mode:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::enable_gap_pixels() { +int slsReceiverTCPIPInterface::enable_gap_pixels(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int enable = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &enable, sizeof(enable), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &enable, sizeof(enable)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } if (myDetectorType != EIGER) functionNotImplemented(); @@ -1750,7 +1791,7 @@ int slsReceiverTCPIPInterface::enable_gap_pixels() { // set if (enable >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting gap pixels enable:" << enable; receiver->setGapPixelsEnable(enable); } @@ -1760,23 +1801,24 @@ int slsReceiverTCPIPInterface::enable_gap_pixels() { validate(enable, retval, std::string("set gap pixels enable"), DEC); FILE_LOG(logDEBUG1) << "Gap Pixels Enable: " << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::restream_stop(){ +int slsReceiverTCPIPInterface::restream_stop(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); - // no arg, and check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); + if(receiver == nullptr){ + NullObjectError(ret, mess); + } // receiver is not null if (ret == OK) { // only set // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { if (receiver->getDataStreamEnable() == false) { ret = FAIL; sprintf(mess,"Could not restream stop packet as data Streaming is disabled.\n"); @@ -1791,26 +1833,29 @@ int slsReceiverTCPIPInterface::restream_stop(){ } } } - return interface->Server_SendResult(true, ret, nullptr, 0, mess); + return socket.sendResult(true, ret, nullptr, 0, mess); } -int slsReceiverTCPIPInterface::set_additional_json_header() { +int slsReceiverTCPIPInterface::set_additional_json_header(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); char arg[MAX_STR_LENGTH] = {0}; char retval[MAX_STR_LENGTH] = {0}; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, arg, sizeof(arg), true, receiver) == FAIL) + socket.receiveArg(ret, mess, arg, sizeof(arg)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // only set // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting additional json header: " << arg; receiver->setAdditionalJsonHeader(arg); } @@ -1818,18 +1863,19 @@ int slsReceiverTCPIPInterface::set_additional_json_header() { strcpy(retval, receiver->getAdditionalJsonHeader().c_str()); FILE_LOG(logDEBUG1) << "additional json header:" << retval; } - return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); + return socket.sendResult(true, ret, retval, MAX_STR_LENGTH, mess); } -int slsReceiverTCPIPInterface::get_additional_json_header() { +int slsReceiverTCPIPInterface::get_additional_json_header(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); char retval[MAX_STR_LENGTH] = {0}; - // no arg, check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); + if(receiver == nullptr){ + NullObjectError(ret, mess); + } // base object not null if (ret == OK) { @@ -1837,27 +1883,30 @@ int slsReceiverTCPIPInterface::get_additional_json_header() { strcpy(retval, receiver->getAdditionalJsonHeader().c_str()); FILE_LOG(logDEBUG1) << "additional json header:" << retval; } - return interface->Server_SendResult(true, ret, retval, MAX_STR_LENGTH, mess); + return socket.sendResult(true, ret, retval, MAX_STR_LENGTH, mess); } -int slsReceiverTCPIPInterface::set_udp_socket_buffer_size() { +int slsReceiverTCPIPInterface::set_udp_socket_buffer_size(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int64_t index = -1; int64_t retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (index >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting UDP Socket Buffer size: " << index; if (receiver->setUDPSocketBufferSize(index) == FAIL) { ret = FAIL; @@ -1872,44 +1921,48 @@ int slsReceiverTCPIPInterface::set_udp_socket_buffer_size() { validate(index, retval, std::string("set udp socket buffer size (No CAP_NET_ADMIN privileges?)"), DEC); FILE_LOG(logDEBUG1) << "UDP Socket Buffer Size:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::get_real_udp_socket_buffer_size(){ +int slsReceiverTCPIPInterface::get_real_udp_socket_buffer_size(sls::ServerInterface2 &socket){ ret = OK; memset(mess, 0, sizeof(mess)); int64_t retval = -1; - // no arg, check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); + if(receiver == nullptr){ + NullObjectError(ret, mess); + } if (ret == OK) { FILE_LOG(logDEBUG1) << "Getting actual UDP buffer size"; retval = receiver->getActualUDPSocketBufferSize(); } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_frames_per_file() { +int slsReceiverTCPIPInterface::set_frames_per_file(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int index = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (index >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting frames per file: " << index; receiver->setFramesPerFile(index); } @@ -1919,19 +1972,20 @@ int slsReceiverTCPIPInterface::set_frames_per_file() { validate(index, retval, std::string("set frames per file"), DEC); FILE_LOG(logDEBUG1) << "frames per file:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::check_version_compatibility() { +int slsReceiverTCPIPInterface::check_version_compatibility(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int64_t arg = -1; - // get args, return if socket crashed - if (interface->Server_ReceiveArg(ret, mess, &arg, sizeof(arg)) == FAIL) + socket.receiveArg(ret, mess, &arg, sizeof(arg)); + if (ret == FAIL) return FAIL; + FILE_LOG(logDEBUG1) << "Checking versioning compatibility with value " << arg; int64_t client_requiredVersion = arg; int64_t rx_apiVersion = APIRECEIVER; @@ -1959,27 +2013,30 @@ int slsReceiverTCPIPInterface::check_version_compatibility() { FILE_LOG(logERROR) << mess; } else FILE_LOG(logINFO) << "Compatibility with Client: Successful"; - return interface->Server_SendResult(true, ret, nullptr, 0, mess); + return socket.sendResult(true, ret, nullptr, 0, mess); } -int slsReceiverTCPIPInterface::set_discard_policy() { +int slsReceiverTCPIPInterface::set_discard_policy(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int index = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (index >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting frames discard policy: " << index; receiver->setFrameDiscardPolicy((frameDiscardPolicy)index); } @@ -1989,27 +2046,30 @@ int slsReceiverTCPIPInterface::set_discard_policy() { validate(index, retval, std::string("set discard policy"), DEC); FILE_LOG(logDEBUG1) << "frame discard policy:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_padding_enable() { +int slsReceiverTCPIPInterface::set_padding_enable(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int index = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &index, sizeof(index), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &index, sizeof(index)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null if (ret == OK) { // set if (index >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { index = (index == 0) ? 0 : 1; FILE_LOG(logDEBUG1) << "Setting frames padding enable: " << index; receiver->setFramePaddingEnable(index); @@ -2020,20 +2080,23 @@ int slsReceiverTCPIPInterface::set_padding_enable() { validate(index, retval, std::string("set frame padding enable"), DEC); FILE_LOG(logDEBUG1) << "Frame Padding Enable:" << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_deactivated_padding_enable() { +int slsReceiverTCPIPInterface::set_deactivated_padding_enable(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int enable = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &enable, sizeof(enable), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &enable, sizeof(enable)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } if (myDetectorType != EIGER) functionNotImplemented(); @@ -2042,8 +2105,7 @@ int slsReceiverTCPIPInterface::set_deactivated_padding_enable() { else if (ret == OK) { // set if (enable >= 0) { - // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting deactivated padding enable: " << enable; receiver->setDeactivatedPadding(enable > 0 ? true : false); } @@ -2053,19 +2115,22 @@ int slsReceiverTCPIPInterface::set_deactivated_padding_enable() { validate(enable, retval, std::string("set deactivated padding enable"), DEC); FILE_LOG(logDEBUG1) << "Deactivated Padding Enable: " << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_readout_flags() { +int slsReceiverTCPIPInterface::set_readout_flags(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); readOutFlags arg = GET_READOUT_FLAGS; readOutFlags retval = GET_READOUT_FLAGS; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &arg, sizeof(arg), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &arg, sizeof(arg)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } if (myDetectorType == JUNGFRAU || myDetectorType == GOTTHARD || myDetectorType == MOENCH) functionNotImplemented(); @@ -2075,7 +2140,7 @@ int slsReceiverTCPIPInterface::set_readout_flags() { // set if (arg >= 0) { // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting readout flag: " << arg; ret = receiver->setReadOutFlags(arg); } @@ -2085,31 +2150,30 @@ int slsReceiverTCPIPInterface::set_readout_flags() { validate((int)arg, (int)(retval & arg), std::string("set readout flags"), HEX); FILE_LOG(logDEBUG1) << "Readout flags: " << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_adc_mask() { +int slsReceiverTCPIPInterface::set_adc_mask(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); uint32_t arg = -1; uint32_t retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &arg, sizeof(arg), true, receiver) == FAIL) + socket.receiveArg(ret, mess, &arg, sizeof(arg)); + if(receiver == nullptr){ + NullObjectError(ret, mess); return FAIL; + } // base object not null - else if (ret == OK) { - // set - // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (ret == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting ADC enable mask: " << arg; receiver->setADCEnableMask(arg); } - - // get retval = receiver->getADCEnableMask(); if (ret == OK && retval != arg) { ret = FAIL; @@ -2118,22 +2182,26 @@ int slsReceiverTCPIPInterface::set_adc_mask() { } FILE_LOG(logDEBUG1) << "ADC enable mask retval: " << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_dbit_list() { +int slsReceiverTCPIPInterface::set_dbit_list(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); sls::FixedCapacityContainer args; - if (interface->Server_ReceiveArg(ret, mess, &args, sizeof(args), true, receiver) == FAIL) { - return FAIL; + if (socket.receiveArg(ret, mess, &args, sizeof(args)) == FAIL) { + if(receiver == nullptr){ + NullObjectError(ret, mess); + } + return FAIL; + } else if (ret == OK) { FILE_LOG(logDEBUG1) << "Setting DBIT list"; for (auto &it : args) { FILE_LOG(logDEBUG1) << it << " "; } FILE_LOG(logDEBUG1) << "\n"; - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { if (args.size() > 64) { ret = FAIL; sprintf(mess, "Could not set dbit list as size is > 64\n"); @@ -2141,54 +2209,53 @@ int slsReceiverTCPIPInterface::set_dbit_list() { } else receiver->setDbitList(args); } - - } - return interface->Server_SendResult(true, ret, nullptr, 0, mess); + return socket.sendResult(true, ret, nullptr, 0, mess); } -int slsReceiverTCPIPInterface::get_dbit_list() { +int slsReceiverTCPIPInterface::get_dbit_list(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); sls::FixedCapacityContainer retval; - // no arg, check receiver is null - interface->Server_ReceiveArg(ret, mess, nullptr, 0, true, receiver); - + if(receiver == nullptr){ + NullObjectError(ret, mess); + } // base object not null if (ret == OK) { - // get retval = receiver->getDbitList(); FILE_LOG(logDEBUG1) << "Dbit list size retval:" << retval.size(); } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); } -int slsReceiverTCPIPInterface::set_dbit_offset() { +int slsReceiverTCPIPInterface::set_dbit_offset(sls::ServerInterface2 &socket) { ret = OK; memset(mess, 0, sizeof(mess)); int arg = -1; int retval = -1; // get args, return if socket crashed, ret is fail if receiver is not null - if (interface->Server_ReceiveArg(ret, mess, &arg, sizeof(arg), true, receiver) == FAIL) + if (socket.receiveArg(ret, mess, &arg, sizeof(arg)) == FAIL){ + if(receiver == nullptr){ + NullObjectError(ret, mess); + } return FAIL; + } + // base object not null else if (ret == OK) { - // set if (arg >= 0) { - // verify if receiver is unlocked and idle - if (interface->Server_VerifyLockAndIdle(ret, mess, lockStatus, receiver->getStatus(), fnum) == OK) { + if (VerifyLockAndIdle(ret, mess, fnum) == OK) { FILE_LOG(logDEBUG1) << "Setting Dbit offset: " << arg; receiver->setDbitOffset(arg); } } - // get retval = receiver->getDbitOffset(); validate(arg, retval, std::string("set dbit offset"), DEC); FILE_LOG(logDEBUG1) << "Dbit offset retval: " << retval; } - return interface->Server_SendResult(true, ret, &retval, sizeof(retval), mess); -} \ No newline at end of file + return socket.sendResult(true, ret, &retval, sizeof(retval), mess); +} diff --git a/slsSupportLib/CMakeLists.txt b/slsSupportLib/CMakeLists.txt index f9a0134ac..ec5cbfb6a 100755 --- a/slsSupportLib/CMakeLists.txt +++ b/slsSupportLib/CMakeLists.txt @@ -6,6 +6,7 @@ set(SOURCES src/DataSocket.cpp src/ServerSocket.cpp src/ServerInterface.cpp + src/ServerInterface2.cpp src/network_utils.cpp ) @@ -27,7 +28,7 @@ set(PUBLICHEADERS include/ClientSocket.h include/DataSocket.h include/ServerSocket.h - include/ServerInterface.h + include/ServerInterface2.h include/network_utils.h include/FixedCapacityContainer.h ) diff --git a/slsSupportLib/include/DataSocket.h b/slsSupportLib/include/DataSocket.h index a4ad27fe1..05f008bba 100755 --- a/slsSupportLib/include/DataSocket.h +++ b/slsSupportLib/include/DataSocket.h @@ -18,9 +18,11 @@ class DataSocket { int getSocketId() const { return socketId_; } - size_t sendData(const void *buffer, size_t size); - size_t receiveData(void *buffer, size_t size); + int sendData(const void *buffer, size_t size); + int receiveData(void *buffer, size_t size); + int read(void *buffer, size_t size); int setTimeOut(int t_seconds); + int setReceiveTimeout(int us); void close(); void shutDownSocket(); diff --git a/slsSupportLib/include/ServerInterface2.h b/slsSupportLib/include/ServerInterface2.h new file mode 100644 index 000000000..997ee3e13 --- /dev/null +++ b/slsSupportLib/include/ServerInterface2.h @@ -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 \ No newline at end of file diff --git a/slsSupportLib/include/ServerSocket.h b/slsSupportLib/include/ServerSocket.h index 4e15a820a..74831a46d 100755 --- a/slsSupportLib/include/ServerSocket.h +++ b/slsSupportLib/include/ServerSocket.h @@ -1,7 +1,8 @@ #pragma once #include "DataSocket.h" - +#include "ServerInterface2.h" +#include "network_utils.h" #include #include #include @@ -13,16 +14,20 @@ namespace sls { class ServerSocket : public DataSocket { public: ServerSocket(int port); - DataSocket accept(); - const std::string &getLastClient(); + ServerInterface2 accept(); + IpAddr getLastClient() noexcept { return lastClient; } + IpAddr getThisClient() noexcept { return thisClient; } + IpAddr getLockedBy() noexcept { return lockedBy; } + void setLockedBy(IpAddr addr) { lockedBy = addr; } + void setLastClient(IpAddr addr) { lastClient = addr; } int getPort() const; - void SendResult(int &ret, void *retval, int retvalSize, char* mess); + void SendResult(int &ret, void *retval, int retvalSize, char *mess); private: - std::string lastClient_ = std::string(INET_ADDRSTRLEN, '\0'); - std::string thisClient_ = std::string(INET_ADDRSTRLEN, '\0'); + IpAddr thisClient; + IpAddr lastClient; + IpAddr lockedBy; int serverPort; - // char lastClient_[INET_ADDRSTRLEN]{}; }; }; // namespace sls \ No newline at end of file diff --git a/slsSupportLib/include/network_utils.h b/slsSupportLib/include/network_utils.h index 59a7432a1..e4a963033 100755 --- a/slsSupportLib/include/network_utils.h +++ b/slsSupportLib/include/network_utils.h @@ -4,13 +4,12 @@ namespace sls { -uint32_t HostnameToIp(const char *hostname); - class IpAddr { private: uint32_t addr_{0}; public: + constexpr IpAddr() noexcept{} constexpr IpAddr(uint32_t address) noexcept : addr_{address} {} IpAddr(const std::string &address); IpAddr(const char *address); @@ -57,6 +56,10 @@ class MacAddr { constexpr uint64_t uint64() const noexcept { return addr_; } }; +uint32_t HostnameToIp(const char *hostname); +std::string IpToInterfaceName(const std::string& ip); +MacAddr InterfaceNameToMac(std::string inf); + std::ostream &operator<<(std::ostream &out, const IpAddr &addr); std::ostream &operator<<(std::ostream &out, const MacAddr &addr); diff --git a/slsSupportLib/src/DataSocket.cpp b/slsSupportLib/src/DataSocket.cpp index 1af3db89f..a38d821d4 100755 --- a/slsSupportLib/src/DataSocket.cpp +++ b/slsSupportLib/src/DataSocket.cpp @@ -9,6 +9,7 @@ #include #include #include +#include namespace sls { @@ -39,18 +40,31 @@ DataSocket &DataSocket::operator=(DataSocket &&move) noexcept { return *this; } -size_t DataSocket::receiveData(void *buffer, size_t size) { +int DataSocket::receiveData(void *buffer, size_t size) { size_t dataRead = 0; while (dataRead < size) { dataRead += - read(getSocketId(), reinterpret_cast(buffer) + dataRead, + ::read(getSocketId(), reinterpret_cast(buffer) + dataRead, size - dataRead); } return dataRead; } -size_t DataSocket::sendData(const void *buffer, size_t size) { - size_t dataSent = 0; +int DataSocket::read(void *buffer, size_t size){ + return ::read(getSocketId(), reinterpret_cast(buffer), size); +} + +int DataSocket::setReceiveTimeout(int us) { + timeval t{}; + t.tv_sec = 0; + t.tv_usec = us; + return ::setsockopt(getSocketId(), SOL_SOCKET, SO_RCVTIMEO, &t, + sizeof(struct timeval)); +} + + +int DataSocket::sendData(const void *buffer, size_t size) { + int dataSent = 0; while (dataSent < size) { dataSent += write(getSocketId(), reinterpret_cast(buffer) + dataSent, diff --git a/slsSupportLib/src/ServerInterface2.cpp b/slsSupportLib/src/ServerInterface2.cpp new file mode 100644 index 000000000..44c53782b --- /dev/null +++ b/slsSupportLib/src/ServerInterface2.cpp @@ -0,0 +1,38 @@ +#include "ServerInterface2.h" +#include +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) { + assert(sizeofArg > 0); + int bytes_read = read(arg, sizeofArg); + if (bytes_read == sizeofArg) { + return defs::OK; + } else { + FILE_LOG(logERROR) << "Read: " << bytes_read << " instead of " + << sizeofArg; + return defs::FAIL; + } +} + +} // namespace sls diff --git a/slsSupportLib/src/ServerSocket.cpp b/slsSupportLib/src/ServerSocket.cpp index 0876c212c..35048268b 100755 --- a/slsSupportLib/src/ServerSocket.cpp +++ b/slsSupportLib/src/ServerSocket.cpp @@ -1,4 +1,6 @@ +#include "ServerInterface2.h" #include "ServerSocket.h" + #include "DataSocket.h" #include "logger.h" #include "sls_detector_defs.h" @@ -27,7 +29,7 @@ ServerSocket::ServerSocket(int port) if (bind(getSocketId(), (struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 0) { close(); - throw std::runtime_error("Server ERROR: cannot bind socket"); + throw sls::SocketError("Server ERROR: cannot bind socket"); } if (listen(getSocketId(), DEFAULT_BACKLOG) != 0) { close(); @@ -35,25 +37,21 @@ ServerSocket::ServerSocket(int port) } } -DataSocket ServerSocket::accept() { +ServerInterface2 ServerSocket::accept() { + lastClient = thisClient; //update from previous connection struct sockaddr_in clientAddr; socklen_t addr_size = sizeof clientAddr; int newSocket = ::accept(getSocketId(), (struct sockaddr *)&clientAddr, &addr_size); if (newSocket == -1) { - throw std::runtime_error("Server ERROR: socket accept failed\n"); + throw sls::SocketError("Server ERROR: socket accept failed\n"); } - inet_ntop(AF_INET, &(clientAddr.sin_addr), &thisClient_.front(), - INET_ADDRSTRLEN); - std::cout << "lastClient: " << lastClient_ << " thisClient: " << thisClient_ - << '\n'; - // Here goes any check for locks etc - lastClient_ = thisClient_; - - return DataSocket(newSocket); + char tc[INET_ADDRSTRLEN]{}; + inet_ntop(AF_INET, &(clientAddr.sin_addr), tc, INET_ADDRSTRLEN); + thisClient = tc; + return ServerInterface2(newSocket); } -const std::string &ServerSocket::getLastClient() { return lastClient_; } int ServerSocket::getPort() const { return serverPort; } diff --git a/slsSupportLib/src/network_utils.cpp b/slsSupportLib/src/network_utils.cpp index 6c3e25caa..6c8f153a4 100755 --- a/slsSupportLib/src/network_utils.cpp +++ b/slsSupportLib/src/network_utils.cpp @@ -6,16 +6,20 @@ #include #include #include - +#include #include #include #include #include +#include +#include +#include #include "network_utils.h" namespace sls { + IpAddr::IpAddr(const std::string &address) { inet_pton(AF_INET, address.c_str(), &addr_); } @@ -86,4 +90,60 @@ uint32_t HostnameToIp(const char *hostname) { return ip; } +std::string IpToInterfaceName(const std::string &ip) { + //TODO! Copied from genericSocket needs to be refactored! + struct ifaddrs *addrs, *iap; + struct sockaddr_in *sa; + + char buf[32]; + const int buf_len = sizeof(buf); + memset(buf, 0, buf_len); + strcpy(buf, "none"); + + getifaddrs(&addrs); + for (iap = addrs; iap != NULL; iap = iap->ifa_next) { + if (iap->ifa_addr && (iap->ifa_flags & IFF_UP) && + iap->ifa_addr->sa_family == AF_INET) { + sa = (struct sockaddr_in *)(iap->ifa_addr); + inet_ntop(iap->ifa_addr->sa_family, (void *)&(sa->sin_addr), buf, + buf_len); + if (ip == std::string(buf)) { + strcpy(buf, iap->ifa_name); + break; + } + } + } + freeifaddrs(addrs); + return std::string(buf); +} + +MacAddr InterfaceNameToMac(std::string inf) { + //TODO! Copied from genericSocket needs to be refactored! + struct ifreq ifr; + char mac[32]; + const int mac_len = sizeof(mac); + memset(mac,0,mac_len); + + int sock=socket(PF_INET, SOCK_STREAM, 0); + strncpy(ifr.ifr_name,inf.c_str(),sizeof(ifr.ifr_name)-1); + ifr.ifr_name[sizeof(ifr.ifr_name)-1]='\0'; + + + if (-1==ioctl(sock, SIOCGIFHWADDR, &ifr)) { + perror("ioctl(SIOCGIFHWADDR) "); + return std::string("00:00:00:00:00:00"); + } + for (int j=0, k=0; j<6; j++) { + k+=snprintf(mac+k, mac_len-k-1, j ? ":%02X" : "%02X", + (int)(unsigned int)(unsigned char)ifr.ifr_hwaddr.sa_data[j]); + } + mac[mac_len-1]='\0'; + + if(sock!=1){ + close(sock); + } + return MacAddr(mac); + + } + } // namespace sls diff --git a/slsSupportLib/tests/test-network_utils.cpp b/slsSupportLib/tests/test-network_utils.cpp index 43a08795a..44149ca88 100755 --- a/slsSupportLib/tests/test-network_utils.cpp +++ b/slsSupportLib/tests/test-network_utils.cpp @@ -101,4 +101,4 @@ TEST_CASE("MAC Output operator gives same result as string", "[support]") { CHECK(os.str() == addr.str()); } -//TODO!(Erik) Look up a real hostname and verify the IP \ No newline at end of file +//TODO!(Erik) Look up a real hostname and verify the IP