void server_mode() {
sockaddr_storage_t msgname;
int server_socket,
error,
stream;
int assoc_num =0;
struct msghdr inmessage;
struct iovec iov;
char *big_buffer;
char incmsg[CMSG_SPACE(sizeof(sctp_cmsg_data_t))];
if ((big_buffer = malloc(REALLY_BIG)) == NULL) {
printf("malloc failure: %s\n", strerror(errno));
DUMP_CORE;
}
printf("Running in Server Mode...\n");
memset(&inmessage, 0, sizeof(inmessage));
iov.iov_base = big_buffer;
iov.iov_len = REALLY_BIG;
inmessage.msg_iov = &iov;
inmessage.msg_iovlen =1;
inmessage.msg_control = incmsg;
inmessage.msg_controllen = sizeof(incmsg);
inmessage.msg_name = &msgname;
inmessage.msg_namelen = sizeof (msgname);
stream = 1;
server_socket = socket(PF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
if (server_socket < 0) {
printf("Socket Failure: %s.\n", strerror(errno));
DUMP_CORE;
}
error = bind(server_socket, &server_loop.sa, sizeof(server_loop));
if (error != 0 ) {
printf("Bind Failure: %s.\n", strerror(errno));
DUMP_CORE;
}
error = listen(server_socket, 1);
if (error != 0) {
printf("Listen Failure: %s.\n", strerror(errno));
DUMP_CORE;
}
while (TRUE) {
error = recvmsg(server_socket, &inmessage, MSG_WAITALL);
if (error < 0) {
printf("Receive Failure: %s\n",
strerror(errno));
} else {
if (inmessage.msg_flags & MSG_NOTIFICATION)
assoc_num = event_received(&inmessage, assoc_num);
else
data_received(&inmessage, error, stream, server_socket);
}
}
}
void
MulticastDataLink::sample_received(ReceivedDataSample& sample)
{
switch (sample.header_.message_id_) {
case TRANSPORT_CONTROL: {
// Transport control samples are delivered to all sessions
// regardless of association status:
{
ACE_GUARD(ACE_SYNCH_RECURSIVE_MUTEX,
guard,
this->session_lock_);
char* ptr = sample.sample_->rd_ptr();
for (MulticastSessionMap::iterator it(this->sessions_.begin());
it != this->sessions_.end(); ++it) {
it->second->control_received(sample.header_.submessage_id_,
sample.sample_);
// reset read pointer
sample.sample_->rd_ptr(ptr);
}
}
if (this->check_fully_association_) {
this->transport_->check_fully_association ();
this->check_fully_association_ = false;
}
} break;
case SAMPLE_ACK:
ack_received(sample);
break;
default:
data_received(sample);
}
}
// handle_pcdata() testet, ob im Receive-Buffer Paket-Daten (auch unvollst.) liegen
// und kopiert diese nach 'rxdatapaket' um.
// Bei g�ltigen Paketen, wird 'handle_pc_paket()'
// aufgerufen.
void handle_pcdata(void) {
int rxbytes, burst_cnt = 5;
do {
rxbytes = data_received();
if (rxbytes > 4) { // a frame shout be have D0 length and crc
U16 length = 0;
if (data_look_byte(0) != FRAMESTARTID) {
data_flushrx(); // destroy garbage on COM/USB
} else {
length = data_look_word(1);
if (length <= (sizeof(rxdatapacket)-5)) {
if (length <= (rxbytes-5)) {
data_copyrx(rxdatapacket.data, length+5);
// data_flushrx(); // needed for buggy software, obsolete - using timeout
} else // packet still in receiving (on slow serial)
length = 0;
} else {
data_flushrx(); // incorrect packet
length = 0; // remove all data from buffer
} // fi incomplete
} // esle
if (length > 0) {
// packet begins with a valid frame / FRAMESTARTID checked before
U16 pkt_crc = 0;
if (status_control&STA_CRCENABLE_MASK) { // check CRC only, if needed.
pkt_crc = crc_ccitt(rxdatapacket.data, length+5);
} // fi check CRC
if (pkt_crc==0) handle_pc_paket(length); // crc correct
} // fi payload
} // fi was da
} while ( (rxbytes > 4) && ((--burst_cnt)>0) );
}
static void
udp_socket_event_handler(int fd, short event, void *arg)
{
ssize_t rc;
CONN_STATE *csp;
/* avoid compiler warning when WLOG_* is not defined */
CSF_UNUSED_ARG(event);
CSF_UNUSED_ARG(arg);
csp = (CONN_STATE *)smalloc(sizeof(CONN_STATE));
csp->ci.addrlen = sizeof(struct sockaddr);
WLOG_DEBUG("udp_socket_event_handler() called fd: %d, event: %d, arg: %p",
fd, event, arg);
rc = recvfrom(fd, recv_data, RECV_DATA_LEN, 0,
(struct sockaddr *) &(csp->ci.addr), &(csp->ci.addrlen));
if (rc < 0) {
WLOG_ERR("recvfrom() error: %s", strerror(errno));
return;
}
csp->ci.type = CSF_UDP;
csp->ci.fd = fd;
csp->ci.cp_ops = &udp_ops;
csp->ref_cnt = 1;
connection_made(csp);
data_received(csp, recv_data, rc);
connection_lost(csp);
/* reference count for free */
CS_RELE(csp);
}
void
MulticastDataLink::sample_received(ReceivedDataSample& sample)
{
switch (sample.header_.message_id_) {
case TRANSPORT_CONTROL: {
// Transport control samples are delivered to all sessions
// regardless of association status:
{
char* const ptr = sample.sample_ ? sample.sample_->rd_ptr() : 0;
ACE_GUARD(ACE_SYNCH_RECURSIVE_MUTEX,
guard,
this->session_lock_);
const TransportHeader& theader = receive_strategy()->received_header();
if (!is_active() && sample.header_.submessage_id_ == MULTICAST_SYN &&
sessions_.find(theader.source_) == sessions_.end()) {
// We have received a SYN but there is no session (yet) for this source.
// Depending on the data, we may need to send SYNACK.
guard.release();
syn_received_no_session(theader.source_, sample.sample_,
theader.swap_bytes());
if (ptr) {
sample.sample_->rd_ptr(ptr);
}
return;
}
MulticastSessionMap temp_sessions(sessions_);
guard.release();
for (MulticastSessionMap::iterator it(temp_sessions.begin());
it != temp_sessions.end(); ++it) {
it->second->control_received(sample.header_.submessage_id_,
sample.sample_);
// reset read pointer
if (ptr) {
sample.sample_->rd_ptr(ptr);
}
}
}
} break;
case SAMPLE_ACK:
ack_received(sample);
break;
default:
if (!duplicate_data_sample(sample.header_)) {
data_received(sample);
}
break;
}
}
void process_ready_sockets(int client_socket[], int assoc_num, fd_set *rfds) {
int i, stream, error;
struct msghdr inmessage;
struct iovec iov;
char *big_buffer;
char incmsg[CMSG_SPACE(sizeof (sctp_cmsg_data_t))];
sockaddr_storage_t msgname;
if ((big_buffer = malloc(REALLY_BIG)) == NULL) {
printf("malloc failure: %s\n", strerror(errno));
DUMP_CORE;
}
/* Setup inmessage to be able to receive in incomming message */
memset(&inmessage, 0, sizeof (inmessage));
iov.iov_base = big_buffer;
iov.iov_len = REALLY_BIG;
inmessage.msg_iov = &iov;
inmessage.msg_iovlen =1;
inmessage.msg_control = incmsg;
inmessage.msg_controllen = sizeof (incmsg);
inmessage.msg_name = &msgname;
inmessage.msg_namelen = sizeof (msgname);
stream = 1;
for( i = 0; i < assoc_num; i++) {
if (FD_ISSET(client_socket[i], rfds)) {
error = recvmsg(client_socket[i], &inmessage,
MSG_WAITALL);
if (error < 0)
printf("Receive Failure: %s\n",
strerror(errno));
else {
/* Test to find the type of message that was read(event/data) */
if (inmessage.msg_flags &
MSG_NOTIFICATION)
event_received(&inmessage,
0);
else
data_received(&inmessage, error,
stream,
client_socket[i]);
}
}
}
}
DecoderStack::DecoderStack(pv::SigSession &session,
const srd_decoder *const dec) :
_session(session),
_sample_count(0),
_frame_complete(false),
_samples_decoded(0)
{
connect(&_session, SIGNAL(frame_began()),
this, SLOT(on_new_frame()));
connect(&_session, SIGNAL(data_received()),
this, SLOT(on_data_received()));
connect(&_session, SIGNAL(frame_ended()),
this, SLOT(on_frame_ended()));
_stack.push_back(shared_ptr<decode::Decoder>(
new decode::Decoder(dec)));
}
DecoderStack::DecoderStack(pv::Session &session,
const srd_decoder *const dec) :
session_(session),
start_time_(0),
samplerate_(0),
sample_count_(0),
frame_complete_(false),
samples_decoded_(0)
{
connect(&session_, SIGNAL(frame_began()),
this, SLOT(on_new_frame()));
connect(&session_, SIGNAL(data_received()),
this, SLOT(on_data_received()));
connect(&session_, SIGNAL(frame_ended()),
this, SLOT(on_frame_ended()));
stack_.push_back(shared_ptr<decode::Decoder>(
new decode::Decoder(dec)));
}
/*
* User-facing routine
* Checks for new frames from PC and sends PC any new CAN bus frames
* Will echo out any frames from PC that do not match the local node ID
* Should be called once per main loop iteration during normal operation
*/
void runSerialCAN(word id) {
CANframe rxFrame;
// Check for a new frame from the PC
if ( readSerialCANframe(&rxFrame) == RX_COMPLETE ) {
if ( rxFrame.id == id ) {
CANput(rxFrame.payload);
} else {
CANsend(&rxFrame); // Echo frame from serial onto CAN bus if ID doesn't match
}
}
// Check for a recently sent frame
if ( data_sent() ) {
sendSerialCANframe(last_txframe());
}
// Check for a recently received frame
if ( data_received() ) {
sendSerialCANframe(last_rxframe());
}
}
void SocketServer::start() {
struct sockaddr_storage remoteaddr; // client address
socklen_t addrlen;
char remoteIP[INET6_ADDRSTRLEN];
// sigset_t mask;
// sigset_t orig_mask;
// key = connection id
std::map<int, SocketConnection*> connections;
// /**
// * I'm not sure of this signal handling code, but for now it works:
// * I register a signal handler for the process, then in the handler I look if it's a SIGKILL for the thread, then
// * flag it as killed.
// * The sigmask code, I think, it's for handling correctly a signal while pselect is waiting, then exit from it
// */
// struct sigaction act;
//
// memset (&act, 0, sizeof(act));
// act.sa_handler = signal_handler;
//
// /* should shut down on SIGTERM. */
// if (sigaction(SIGTERM, &act, 0)) {
// perror ("sigaction");
// throw std::exception();
// }
//
// sigemptyset (&mask);
// sigaddset (&mask, SIGPIPE);
//
// if (sigprocmask(SIG_BLOCK, &mask, &orig_mask) < 0) {
// perror ("sigprocmask");
// throw std::exception();
// }
// main loop
for(;;) {
read_fds = master; // copy it
if (select(fdmax+1, &read_fds, NULL, NULL, NULL) == -1) {
perror("select");
exit(4);
}
int i;
// run through the existing connections looking for data to read
for(i = 0; i <= fdmax; i++) {
if (FD_ISSET(i, &read_fds)) { // we got one!!
if (i == listenfd) {
// handle new connection
addrlen = sizeof remoteaddr;
int connfd = accept(listenfd, (struct sockaddr *)&remoteaddr, &addrlen);
if (connfd == -1) {
perror("accept() error");
} else {
FD_SET(connfd, &master); // add to master set
if (connfd > fdmax) { // keep track of the max
fdmax = connfd;
}
printf("new connection from %s on "
"socket %d\n",
inet_ntop(remoteaddr.ss_family,
get_in_addr((struct sockaddr*)&remoteaddr),
remoteIP, INET6_ADDRSTRLEN),
connfd);
}
} else {
// handle data from a client
auto found = connections.find(i);
if (found == connections.end()) {
connections[i] = new SocketConnection(i);
}
SocketConnection *connection = connections[i];
try {
int rcvd;
rcvd = connection->read(request_buffer, REQUEST_BUFFER_SIZE);
if (rcvd < 0) // receive error
{
perror("recv() error");
throw std::exception();
}
else if (rcvd == 0)
{
fprintf(stderr,"Client disconnected unexpectedly.\n");
throw std::exception();
}
if (data_received(connection, request_buffer, rcvd)) {
connections.erase(i);
delete(connection);
FD_CLR(i, &master); // remove from master set
}
} catch (std::exception &e) {
std::cerr << "exception handling request: " << e.what() << std::endl;
connections.erase(i);
connection_closed(connection);
delete(connection);
FD_CLR(i, &master); // remove from master set
}
}
}
}
}
}
void parcelhandler::register_counter_types()
{
HPX_STD_FUNCTION<boost::int64_t()> num_parcel_sends(
boost::bind(&parcelport::get_parcel_send_count, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> num_parcel_receives(
boost::bind(&parcelport::get_parcel_receive_count, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> num_message_sends(
boost::bind(&parcelport::get_message_send_count, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> num_message_receives(
boost::bind(&parcelport::get_message_receive_count, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> sending_time(
boost::bind(&parcelport::get_sending_time, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> receiving_time(
boost::bind(&parcelport::get_receiving_time, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> sending_serialization_time(
boost::bind(&parcelport::get_sending_serialization_time, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> receiving_serialization_time(
boost::bind(&parcelport::get_receiving_serialization_time, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> data_sent(
boost::bind(&parcelport::get_data_sent, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> data_received(
boost::bind(&parcelport::get_data_received, &pp_));
HPX_STD_FUNCTION<boost::int64_t()> queue_length(
boost::bind(&parcelhandler::get_queue_length, this));
performance_counters::generic_counter_type_data const counter_types[] =
{
{ "/parcels/count/sent", performance_counters::counter_raw,
"returns the number of sent parcels for the referenced locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, num_parcel_sends, _2),
&performance_counters::locality_counter_discoverer,
""
},
{ "/parcels/count/received", performance_counters::counter_raw,
"returns the number of received parcels for the referenced locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, num_parcel_receives, _2),
&performance_counters::locality_counter_discoverer,
""
},
{ "/messages/count/sent", performance_counters::counter_raw,
"returns the number of sent messages for the referenced locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, num_message_sends, _2),
&performance_counters::locality_counter_discoverer,
""
},
{ "/messages/count/received", performance_counters::counter_raw,
"returns the number of received messages for the referenced locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, num_message_receives, _2),
&performance_counters::locality_counter_discoverer,
""
},
{ "/time/data/sent", performance_counters::counter_raw,
"returns the total time between the start of each asynchronous "
"write and the invocation of the write callback for the referenced "
"locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, sending_time, _2),
&performance_counters::locality_counter_discoverer,
"ns"
},
{ "/time/data/received", performance_counters::counter_raw,
"returns the total time between the start of each asynchronous "
"read and the invocation of the read callback for the referenced "
"locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, receiving_time, _2),
&performance_counters::locality_counter_discoverer,
"ns"
},
{ "/time/serialize/sent", performance_counters::counter_raw,
"returns the total time required to serialize all sent parcels "
"for the referenced locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, sending_serialization_time, _2),
&performance_counters::locality_counter_discoverer,
"ns"
},
{ "/time/serialize/received", performance_counters::counter_raw,
"returns the total time required to de-serialize all received "
"parcels for the referenced locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, receiving_serialization_time, _2),
&performance_counters::locality_counter_discoverer,
"ns"
},
{ "/data/size/sent", performance_counters::counter_raw,
"returns the amount of parcel data (including headers) sent "
"by the referenced locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, data_sent, _2),
&performance_counters::locality_counter_discoverer,
"bytes"
},
{ "/data/size/received", performance_counters::counter_raw,
"returns the amount of parcel data (including headers) received "
"by the referenced locality",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, data_received, _2),
&performance_counters::locality_counter_discoverer,
"bytes"
},
{ "/parcelqueue/length", performance_counters::counter_raw,
"returns the number current length of the queue of incoming threads",
HPX_PERFORMANCE_COUNTER_V1,
boost::bind(&performance_counters::locality_raw_counter_creator,
_1, queue_length, _2),
&performance_counters::locality_counter_discoverer,
""
}
};
performance_counters::install_counter_types(
counter_types, sizeof(counter_types)/sizeof(counter_types[0]));
}
