detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-23 18:17:59 +02:00
Code Issues Actions Packages Releases Activity

new constuctor

Browse Source
This commit is contained in:
Erik Frojdh
2019-03-28 15:48:26 +01:00
parent 5a4122ae7c
commit 94c4e4c352
9 changed files with 172 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
slsSupportLib/include/ClientInterface.h
View File

@ -66,9 +66,6 @@ private:
*/
sls::ClientSocket* socket_;
/** index for client debugging purposes */
int index;
};

12
slsSupportLib/include/ClientSocket.h
View File

@ -10,7 +10,9 @@ namespace sls {
class ClientSocket : public DataSocket {
public:
ClientSocket(const bool isRx, const std::string &hostname, uint16_t port_number);
int sendCommandThenRead(int fnum, void *args, size_t args_size, void *retval, size_t retval_size);
ClientSocket(const bool isRx, struct sockaddr_in addr);
int sendCommandThenRead(int fnum, void *args, size_t args_size, void *retval,
size_t retval_size);
private:
void readReply(int &ret, void *retval, size_t retval_size);
@ -19,15 +21,17 @@ class ClientSocket : public DataSocket {
};
class ReceiverSocket : public ClientSocket {
public:
public:
ReceiverSocket(const std::string &hostname, uint16_t port_number)
: ClientSocket(true, hostname, port_number){};
ReceiverSocket(struct sockaddr_in addr) : ClientSocket(true, addr){};
};
class DetectorSocket : public ClientSocket {
public:
public:
DetectorSocket(const std::string &hostname, uint16_t port_number)
: ClientSocket(false, hostname, port_number){};
DetectorSocket(struct sockaddr_in addr) : ClientSocket(false, addr){};
};
}; //namespace sls
}; // namespace sls

3
slsSupportLib/include/DataSocket.h
View File

@ -3,6 +3,7 @@
#include <cstddef>
#include <cstdint>
#include <netdb.h>
#include <string>
namespace sls {
class DataSocket {
@ -29,4 +30,6 @@ class DataSocket {
int ConvertHostnameToInternetAddress(const char *const hostname, struct ::addrinfo **res);
int ConvertInternetAddresstoIpString(struct ::addrinfo *res, char *ip, const int ipsize);
struct ::sockaddr_in ConvertHostnameToInternetAddress(const std::string &hostname);
}; // namespace sls

26
slsSupportLib/src/ClientInterface.cpp
View File

@ -1,10 +1,9 @@
#include "ClientInterface.h"
#include "ClientSocket.h"
ClientInterface::ClientInterface(sls::ClientSocket* socket, int n): socket_(socket),
index(n){}
ClientInterface::ClientInterface(sls::ClientSocket *socket, int n) : socket_(socket){}
void ClientInterface::Client_Receive(int& ret, char* mess, void* retval, int sizeOfRetval) {
void ClientInterface::Client_Receive(int &ret, char *mess, void *retval, int sizeOfRetval) {
// get result of operation
socket_->receiveData(reinterpret_cast<char *>(&ret), sizeof(ret));
@ -12,35 +11,32 @@ void ClientInterface::Client_Receive(int& ret, char* mess, void* retval, int siz
if (ret == FAIL) {
bool created = false;
// allocate mess if null
if (!mess){
if (!mess) {
created = true;
mess = new char[MAX_STR_LENGTH];
memset(mess, 0, MAX_STR_LENGTH);
}
// get error message
socket_->receiveData(mess,MAX_STR_LENGTH);
socket_->receiveData(mess, MAX_STR_LENGTH);
// cprintf(RED, "%s %d returned error: %s", type.c_str(), index, mess);
// unrecognized function, do not ask for retval
if(strstr(mess,"Unrecognized Function") != nullptr)
if (strstr(mess, "Unrecognized Function") != nullptr)
unrecognizedFunction = true;
// delete allocated mess
if (created)
delete [] mess;
delete[] mess;
}
// get retval
if (!unrecognizedFunction)
socket_->receiveData( reinterpret_cast<char *>(retval), sizeOfRetval);
socket_->receiveData(reinterpret_cast<char *>(retval), sizeOfRetval);
}
int ClientInterface::Client_Send(int fnum,
void* args, int sizeOfArgs,
void* retval, int sizeOfRetval,
char* mess) {
int ClientInterface::Client_Send(int fnum, void *args, int sizeOfArgs, void *retval,
int sizeOfRetval, char *mess) {
int ret = FAIL;
socket_->sendData(reinterpret_cast<char *>(&fnum),sizeof(fnum));
socket_->sendData(reinterpret_cast<char *>(&fnum), sizeof(fnum));
socket_->sendData(reinterpret_cast<char *>(args), sizeOfArgs);
Client_Receive(ret, mess, retval, sizeOfRetval);
return ret;
return ret;
}

13
slsSupportLib/src/ClientSocket.cpp
View File

@ -42,6 +42,19 @@ ClientSocket::ClientSocket(const bool isRx, const std::string &host, uint16_t po
freeaddrinfo(result);
}
ClientSocket::ClientSocket(const bool isRx, struct sockaddr_in addr)
: DataSocket(socket(AF_INET, SOCK_STREAM, 0)), isReceiver(isRx) {
if (::connect(getSocketId(), (struct sockaddr *)&addr, sizeof(addr)) != 0) {
char address[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &addr.sin_addr, address, INET_ADDRSTRLEN);
const std::string name{(isReceiver ? "Receiver" : "Detector")};
std::string msg = "ClientSocket: Cannot connect to " + name + ":" + address + " on port " +
std::to_string(addr.sin_port) + "\n";
throw SocketError(msg);
}
}
int ClientSocket::sendCommandThenRead(int fnum, void *args, size_t args_size, void *retval,
size_t retval_size) {
int ret = slsDetectorDefs::FAIL;

96
slsSupportLib/src/DataSocket.cpp
View File

@ -1,13 +1,15 @@
#include "DataSocket.h"
#include "logger.h"
#include "sls_detector_exceptions.h"
#include <algorithm>
#include <arpa/inet.h>
#include <cstring>
#include <iostream>
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netdb.h>
#include <unistd.h>
namespace sls {
@ -20,18 +22,14 @@ DataSocket::~DataSocket() {
try {
close();
} catch (...) {
//pass
// pass
}
}
}
void DataSocket::swap(DataSocket &other) noexcept {
std::swap(socketId_, other.socketId_);
}
void DataSocket::swap(DataSocket &other) noexcept { std::swap(socketId_, other.socketId_); }
DataSocket::DataSocket(DataSocket &&move) noexcept {
move.swap(*this);
}
DataSocket::DataSocket(DataSocket &&move) noexcept { move.swap(*this); }
DataSocket &DataSocket::operator=(DataSocket &&move) noexcept {
move.swap(*this);
return *this;
@ -41,7 +39,8 @@ size_t DataSocket::receiveData(void *buffer, size_t size) {
// std::cout << "Sending\n";
size_t dataRead = 0;
while (dataRead < size) {
dataRead += read(getSocketId(), reinterpret_cast<char *>(buffer) + dataRead, size - dataRead);
dataRead +=
read(getSocketId(), reinterpret_cast<char *>(buffer) + dataRead, size - dataRead);
}
return dataRead;
}
@ -50,7 +49,8 @@ size_t DataSocket::sendData(void *buffer, size_t size) {
// std::cout << "Receiving\n";
size_t dataSent = 0;
while (dataSent < size) {
dataSent += write(getSocketId(), reinterpret_cast<char *>(buffer) + dataSent, size - dataSent);
dataSent +=
write(getSocketId(), reinterpret_cast<char *>(buffer) + dataSent, size - dataSent);
}
return dataSent;
}
@ -62,17 +62,15 @@ int DataSocket::setTimeOut(int t_seconds) {
struct timeval t;
t.tv_sec = 0;
t.tv_usec = 0;
//Receive timeout indefinet
if (::setsockopt(getSocketId(), SOL_SOCKET, SO_RCVTIMEO,
&t, sizeof(struct timeval)) < 0) {
// Receive timeout indefinet
if (::setsockopt(getSocketId(), SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)) < 0) {
FILE_LOG(logERROR) << "setsockopt SO_RCVTIMEO " << 0;
}
t.tv_sec = t_seconds;
t.tv_usec = 0;
//Sending timeout in seconds
if (::setsockopt(getSocketId(), SOL_SOCKET, SO_SNDTIMEO,
&t, sizeof(struct timeval)) < 0) {
// Sending timeout in seconds
if (::setsockopt(getSocketId(), SOL_SOCKET, SO_SNDTIMEO, &t, sizeof(struct timeval)) < 0) {
FILE_LOG(logERROR) << "setsockopt SO_SNDTIMEO " << t_seconds;
}
return 0;
@ -86,6 +84,26 @@ void DataSocket::close() {
}
}
struct sockaddr_in ConvertHostnameToInternetAddress(const std::string &hostname) {
struct addrinfo hints, *result;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags |= AI_CANONNAME;
struct sockaddr_in serverAddr {};
if (getaddrinfo(hostname.c_str(), NULL, &hints, &result) != 0) {
freeaddrinfo(result);
std::string msg = "ClientSocket cannot decode host:" + hostname + "\n";
throw SocketError(msg);
}
serverAddr.sin_family = AF_INET;
memcpy((char *)&serverAddr.sin_addr.s_addr, &((struct sockaddr_in *)result->ai_addr)->sin_addr,
sizeof(in_addr_t));
freeaddrinfo(result);
return serverAddr;
}
int ConvertHostnameToInternetAddress(const char *const hostname, struct ::addrinfo **res) {
// criteria in selecting socket address structures returned by res
struct ::addrinfo hints;
@ -95,11 +113,13 @@ int ConvertHostnameToInternetAddress(const char *const hostname, struct ::addrin
// get host info into res
int errcode = getaddrinfo(hostname, NULL, &hints, res);
if (errcode != 0) {
FILE_LOG(logERROR) << "Could not convert hostname (" << hostname << ") to internet address (zmq):" << gai_strerror(errcode);
FILE_LOG(logERROR) << "Could not convert hostname (" << hostname
<< ") to internet address (zmq):" << gai_strerror(errcode);
} else {
if (*res == NULL) {
FILE_LOG(logERROR) << "Could not converthostname (" << hostname << ") to internet address (zmq):"
"gettaddrinfo returned null";
FILE_LOG(logERROR) << "Could not converthostname (" << hostname
<< ") to internet address (zmq):"
"gettaddrinfo returned null";
} else {
return 0;
}
@ -108,23 +128,23 @@ int ConvertHostnameToInternetAddress(const char *const hostname, struct ::addrin
return 1;
};
/**
* Convert Internet Address structure pointer to ip string (char*)
* Clears the internet address structure as well
* @param res pointer to internet address structure
* @param ip pointer to char array to store result in
* @param ipsize size available in ip buffer
* @return 1 for fail, 0 for success
*/
// Do not make this static (for multi threading environment)
int ConvertInternetAddresstoIpString (struct ::addrinfo *res, char* ip, const int ipsize) {
if (inet_ntop (res->ai_family, &((struct sockaddr_in *) res->ai_addr)->sin_addr, ip, ipsize) != NULL) {
::freeaddrinfo(res);
return 0;
}
FILE_LOG(logERROR) << "Could not convert internet address to ip string";
return 1;
}
/**
* Convert Internet Address structure pointer to ip string (char*)
* Clears the internet address structure as well
* @param res pointer to internet address structure
* @param ip pointer to char array to store result in
* @param ipsize size available in ip buffer
* @return 1 for fail, 0 for success
*/
// Do not make this static (for multi threading environment)
int ConvertInternetAddresstoIpString(struct ::addrinfo *res, char *ip, const int ipsize) {
if (inet_ntop(res->ai_family, &((struct sockaddr_in *)res->ai_addr)->sin_addr, ip, ipsize) !=
NULL) {
::freeaddrinfo(res);
return 0;
}
FILE_LOG(logERROR) << "Could not convert internet address to ip string";
return 1;
}
} // namespace sls