/******************************************************************************
* Copyright (c) 2000-2021 Ericsson Telecom AB
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
*
* Contributors:
* Peter Dimitrov- initial implementation and initial documentation
* Adam Delic
* Eduard Czimbalmos
* Endre Kulcsar
* Gabor Bettesch
* Gabor Szalai
* Tamas Buti
* Zoltan Medve
******************************************************************************/
//
// File: SCTPasp_PT.cc
// Description: SCTPasp test port source
// Rev: <RnXnn>
// Prodnr: CNL 113 469
//
#include "SCTPasp_PT.hh"
#include <sys/types.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <netdb.h>
#include <stdarg.h>
#include <memory.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#define BUFLEN 1024
#define MAP_LENGTH 10
#ifdef SCTP_ADAPTION_LAYER
#ifdef LKSCTP_1_0_7
#undef LKSCTP_1_0_7
#error LKSCTP_1_0_7 defined but the lksctp older than 1.0.7. Use only -DUSE_SCTP, version is automatically selected
#endif
#ifdef LKSCTP_1_0_9
#error LKSCTP_1_0_9 defined but the lksctp older than 1.0.7. Use only -DUSE_SCTP, version is automatically selected
#undef LKSCTP_1_0_9
#endif
#else
// 1.0.7 or newer
#ifdef SCTP_AUTH_CHUNK
// 1.0.9 or newer
#ifdef LKSCTP_1_0_7
#undef LKSCTP_1_0_7
#error LKSCTP_1_0_7 defined but the lksctp newer than 1.0.7. Use only -DUSE_SCTP, version is automatically selected
#endif
#ifndef LKSCTP_1_0_9
#define LKSCTP_1_0_9
#endif
#else
// 1.0.7
#ifdef LKSCTP_1_0_9
#undef LKSCTP_1_0_9
#error LKSCTP_1_0_9 defined but the lksctp older than 1.0.9. Use only -DUSE_SCTP, version is automatically selected
#endif
#ifndef LKSCTP_1_0_7
#define LKSCTP_1_0_7
#endif
#endif
#endif
namespace SCTPasp__PortType {
/* is any of the bytes from offset .. u8_size in 'u8' non-zero? return offset or -1 if all zero */
static int byte_nonzero(const uint8_t *u8, unsigned int offset, unsigned int u8_size)
{
int j;
for (j = offset; j < u8_size; j++) {
if (u8[j] != 0)
return j;
}
return -1;
}
static int sctp_sockopt_event_subscribe_size = 0;
static int determine_sctp_sockopt_event_subscribe_size(void)
{
uint8_t buf[256];
socklen_t buf_len = sizeof(buf);
int sd, rc;
/* only do this once */
if (sctp_sockopt_event_subscribe_size != 0)
return 0;
sd = socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP);
if (sd < 0)
return sd;
rc = getsockopt(sd, IPPROTO_SCTP, SCTP_EVENTS, buf, &buf_len);
close(sd);
if (rc < 0)
return rc;
sctp_sockopt_event_subscribe_size = buf_len;
//LOGP(DLINP, LOGL_INFO, "sizes of 'struct sctp_event_subscribe': compile-time %zu, kernel: %u\n",
// sizeof(struct sctp_event_subscribe), sctp_sockopt_event_subscribe_size);
return 0;
}
/* Attempt to work around Linux kernel ABI breakage
*
* The Linux kernel ABI for the SCTP_EVENTS socket option has been broken repeatedly.
* - until commit 35ea82d611da59f8bea44a37996b3b11bb1d3fd7 ( kernel < 4.11), the size is 10 bytes
* - in 4.11 it is 11 bytes
* - in 4.12 .. 5.4 it is 13 bytes
* - in kernels >= 5.5 it is 14 bytes
*
* This wouldn't be a problem if the kernel didn't have a "stupid" assumption that the structure
* size passed by userspace will match 1:1 the length of the structure at kernel compile time. In
* an ideal world, it would just use the known first bytes and assume the remainder is all zero.
* But as it doesn't do that, let's try to work around this */
static int sctp_setsockopt_events_linux_workaround(int fd, const struct sctp_event_subscribe *event)
{
const unsigned int compiletime_size = sizeof(*event);
int rc;
if (determine_sctp_sockopt_event_subscribe_size() < 0) {
//LOGP(DLINP, LOGL_ERROR, "Cannot determine SCTP_EVENTS socket option size\n");
return -1;
}
if (compiletime_size == sctp_sockopt_event_subscribe_size) {
/* no kernel workaround needed */
return setsockopt(fd, IPPROTO_SCTP, SCTP_EVENTS, event, compiletime_size);
} else if (compiletime_size < sctp_sockopt_event_subscribe_size) {
/* we are using an older userspace with a more modern kernel and hence need
* to pad the data */
uint8_t buf[sctp_sockopt_event_subscribe_size];
memcpy(buf, event, compiletime_size);
memset(buf + sizeof(*event), 0, sctp_sockopt_event_subscribe_size - compiletime_size);
return setsockopt(fd, IPPROTO_SCTP, SCTP_EVENTS, buf, sctp_sockopt_event_subscribe_size);
} else /* if (compiletime_size > sctp_sockopt_event_subscribe_size) */ {
/* we are using a newer userspace with an older kernel and hence need to truncate
* the data - but only if the caller didn't try to enable any of the events of the
* truncated portion */
rc = byte_nonzero((const uint8_t *)event, sctp_sockopt_event_subscribe_size,
compiletime_size);
if (rc >= 0) {
//LOGP(DLINP, LOGL_ERROR, "Kernel only supports sctp_event_subscribe of %u bytes, "
// "but caller tried to enable more modern event at offset %u\n",
// sctp_sockopt_event_subscribe_size, rc);
return -1;
}
return setsockopt(fd, IPPROTO_SCTP, SCTP_EVENTS, event, sctp_sockopt_event_subscribe_size);
}
}
struct SCTPasp__PT_PROVIDER::fd_map_item
{ // used by map operations
int fd; // socket descriptor
boolean erased;
boolean processing_message; // if true only part of the message is received
boolean einprogress; // connection establishment is in progress
void * buf; // buffer
ssize_t buflen; // length of the buffer
ssize_t nr; // number of received bytes
struct sockaddr_storage sin; // storing remote address
socklen_t saLen;
};
struct SCTPasp__PT_PROVIDER::fd_map_server_item // server item
{ // used by map operations
int fd; // socket descriptor
boolean erased;
CHARSTRING* local_IP_address;
unsigned short local_port;
};
SCTPasp__PT_PROVIDER::SCTPasp__PT_PROVIDER(const char *par_port_name)
: PORT(par_port_name)
{
simple_mode = FALSE;
reconnect = FALSE;
reconnect_max_attempts = 6;
server_mode = FALSE;
debug = FALSE;
server_backlog = 1;
local_IP_address = "0.0.0.0";
(void) memset(&initmsg, 0, sizeof(struct sctp_initmsg));
initmsg.sinit_num_ostreams = 64;
initmsg.sinit_max_instreams = 64;
initmsg.sinit_max_attempts = 0;
initmsg.sinit_max_init_timeo = 0;
(void) memset(&events, 0, sizeof (events));
events.sctp_data_io_event = TRUE;
events.sctp_association_event = TRUE;
events.sctp_address_event = TRUE;
events.sctp_send_failure_event = TRUE;
events.sctp_peer_error_event = TRUE;
events.sctp_shutdown_event = TRUE;
events.sctp_partial_delivery_event = TRUE;
#if defined(LKSCTP_1_0_7) || defined(LKSCTP_1_0_9)
events.sctp_adaptation_layer_event = TRUE;
#else
events.sctp_adaption_layer_event = TRUE;
#endif
local_port_is_present = FALSE;
peer_IP_address_is_present = FALSE;
peer_port_is_present = FALSE;
fd_map=NULL;
list_len=0;
fd_map_server=NULL;
list_len_server=0;
fd = -1;
local_port=-1;
peer_port=-1;
receiving_fd=-1;
}
SCTPasp__PT_PROVIDER::~SCTPasp__PT_PROVIDER()
{
for(int i=0;i<list_len;i++) map_delete_item(i);
Free(fd_map);
if(!simple_mode)
{
for(int i=0;i<list_len_server;i++) map_delete_item_server(i);
Free(fd_map_server);
}
}
void SCTPasp__PT_PROVIDER::set_parameter(const char *parameter_name,
const char *parameter_value)
{
if(strcmp(parameter_name, "simple_mode") == 0)
{
if (strcasecmp(parameter_value,"yes") == 0)
simple_mode = TRUE;
else if(strcasecmp(parameter_value,"no") == 0)
simple_mode = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. Only yes and no can be used!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "reconnect") == 0)
{
if (strcasecmp(parameter_value,"yes") == 0)
reconnect = TRUE;
else if(strcasecmp(parameter_value,"no") == 0)
reconnect = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. Only yes and no can be used!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "reconnect_max_attempts") == 0)
{
int value;
if ( (sscanf(parameter_value, "%d", &value) == 1) && (value>=0) )
reconnect_max_attempts = value;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be positive integer!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "server_mode") == 0)
{
if (strcasecmp(parameter_value,"yes") == 0)
server_mode = TRUE;
else if(strcasecmp(parameter_value,"no") == 0)
server_mode = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. Only yes and no can be used!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "debug") == 0)
{
if (strcasecmp(parameter_value,"yes") == 0)
debug = TRUE;
else if(strcasecmp(parameter_value,"no") == 0)
debug = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. Only yes and no can be used!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "server_backlog") == 0)
{
int value;
if ( (sscanf(parameter_value, "%d", &value) == 1) && (value>=0) )
server_backlog = value;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be positive integer!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "local_IP_address") == 0)
{
local_IP_address = parameter_value;
}
else if(strcmp(parameter_name, "local_port") == 0)
{
unsigned short value;
if (sscanf(parameter_value, "%hu", &value) == 1)
{
local_port = value;
local_port_is_present = TRUE;
}
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be positive integer!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "peer_IP_address") == 0)
{
peer_IP_address = parameter_value;
peer_IP_address_is_present = TRUE;
}
else if(strcmp(parameter_name, "peer_port") == 0)
{
unsigned short value;
if (sscanf(parameter_value, "%hu", &value) == 1)
{
peer_port = value;
peer_port_is_present = TRUE;
}
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be positive integer!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sinit_num_ostreams") == 0)
{
long value;
if ( (sscanf(parameter_value, "%ld", &value) == 1) && (value>=0) )
initmsg.sinit_num_ostreams = value;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be positive integer!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sinit_max_instreams") == 0)
{
long value;
if ( (sscanf(parameter_value, "%ld", &value) == 1) && (value>=0) )
initmsg.sinit_max_instreams = value;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be positive integer!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sinit_max_attempts") == 0)
{
long value;
if ( (sscanf(parameter_value, "%ld", &value) == 1) && (value>=0) )
initmsg.sinit_max_attempts = value;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be positive integer!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sinit_max_init_timeo") == 0)
{
long value;
if ( (sscanf(parameter_value, "%ld", &value) == 1) && (value>=0) )
initmsg.sinit_max_init_timeo = value;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be positive integer!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sctp_association_event") == 0)
{
if (strcasecmp(parameter_value,"enabled") == 0)
events.sctp_association_event = TRUE;
else if(strcasecmp(parameter_value,"disabled") == 0)
events.sctp_association_event = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be enabled or disabled!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sctp_address_event") == 0)
{
if (strcasecmp(parameter_value,"enabled") == 0)
events.sctp_address_event = TRUE;
else if(strcasecmp(parameter_value,"disabled") == 0)
events.sctp_address_event = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be enabled or disabled!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sctp_send_failure_event") == 0)
{
if (strcasecmp(parameter_value,"enabled") == 0)
events.sctp_send_failure_event = TRUE;
else if(strcasecmp(parameter_value,"disabled") == 0)
events.sctp_send_failure_event = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be enabled or disabled!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sctp_peer_error_event") == 0)
{
if (strcasecmp(parameter_value,"enabled") == 0)
events.sctp_peer_error_event = TRUE;
else if(strcasecmp(parameter_value,"disabled") == 0)
events.sctp_peer_error_event = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be enabled or disabled!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sctp_shutdown_event") == 0)
{
if (strcasecmp(parameter_value,"enabled") == 0)
events.sctp_shutdown_event = TRUE;
else if(strcasecmp(parameter_value,"disabled") == 0)
events.sctp_shutdown_event = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be enabled or disabled!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sctp_partial_delivery_event") == 0)
{
if (strcasecmp(parameter_value,"enabled") == 0)
events.sctp_partial_delivery_event = TRUE;
else if(strcasecmp(parameter_value,"disabled") == 0)
events.sctp_partial_delivery_event = FALSE;
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be enabled or disabled!" ,
parameter_value, parameter_name);
}
else if(strcmp(parameter_name, "sctp_adaption_layer_event") == 0)
{
if (strcasecmp(parameter_value,"enabled") == 0)
#if defined(LKSCTP_1_0_7) || defined(LKSCTP_1_0_9)
events.sctp_adaptation_layer_event = TRUE;
#else
events.sctp_adaption_layer_event = TRUE;
#endif
else if(strcasecmp(parameter_value,"disabled") == 0)
#if defined(LKSCTP_1_0_7) || defined(LKSCTP_1_0_9)
events.sctp_adaptation_layer_event = FALSE;
#else
events.sctp_adaption_layer_event = FALSE;
#endif
else
error("set_parameter(): Invalid parameter value: %s for parameter %s. It should be enabled or disabled!" ,
parameter_value, parameter_name);
}
else
TTCN_warning("%s: unknown & unhandled parameter: %s",
get_name(), parameter_name);
errno = 0;
}
void SCTPasp__PT_PROVIDER::Handle_Fd_Event_Writable(int my_fd){
int i= map_get_item(my_fd);
if(i!=-1 && !simple_mode && !fd_map[i].erased && fd_map[i].einprogress )
{
if (connect(fd_map[i].fd, (struct sockaddr *)&fd_map[i].sin,
fd_map[i].saLen) == -1)
{
Handler_Remove_Fd_Write(fd_map[i].fd);
if(errno == EISCONN)
{
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = fd_map[i].fd;
asp_sctp_result.error__status() = FALSE;
asp_sctp_result.error__message() = OMIT_VALUE;
incoming_message(asp_sctp_result);
fd_map[i].einprogress = FALSE;
Handler_Add_Fd_Read(fd_map[i].fd);
log("Connection successfully established to (%s):(%d)",(const char*)peer_IP_address, peer_port);
}
else
{
close(fd_map[i].fd);
fd = -1;
TTCN_warning("Connect error!");
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = fd_map[i].fd;
asp_sctp_result.error__status() = TRUE;
asp_sctp_result.error__message() = strerror(errno);
incoming_message(asp_sctp_result);
map_delete_item_fd(fd_map[i].fd);
errno = 0;
log("Connection establishment to (%s):(%d) failed !",
(const char*)peer_IP_address, peer_port);
}
}
}
}
void SCTPasp__PT_PROVIDER::Handle_Fd_Event_Error(int my_fd){
Handle_Fd_Event_Readable(my_fd);
}
CHARSTRING get_ip(struct sockaddr_storage *sa){
char ret_val[INET6_ADDRSTRLEN];
ret_val[0]='\0';
if(sa->ss_family == AF_INET){
struct sockaddr_in* sa4=(struct sockaddr_in*)sa;
inet_ntop(AF_INET,&(sa4->sin_addr),ret_val,INET6_ADDRSTRLEN);
} else if(sa->ss_family == AF_INET6) {
struct sockaddr_in6* sa6=(struct sockaddr_in6*)sa;
inet_ntop(AF_INET6,&(sa6->sin6_addr),ret_val,INET6_ADDRSTRLEN);
}
return CHARSTRING(ret_val);
}
int get_port(struct sockaddr_storage *sa){
if(sa->ss_family == AF_INET){
struct sockaddr_in* sa4=(struct sockaddr_in*)sa;
return ntohs(sa4->sin_port);
} else if(sa->ss_family == AF_INET6) {
struct sockaddr_in6* sa6=(struct sockaddr_in6*)sa;
return ntohs(sa6->sin6_port);
}
return 0;
}
void SCTPasp__PT_PROVIDER::Handle_Fd_Event_Readable(int my_fd){
// Accepting new client
if(!simple_mode)
{
for(int i=0;i<list_len_server;i++)
{
if(!fd_map_server[i].erased && fd_map_server[i].fd==my_fd)
{
int newclient_fd;
struct sockaddr_storage peer_address;
socklen_t addrlen = sizeof(peer_address);
if ((newclient_fd = accept(fd_map_server[i].fd, (struct sockaddr *)&peer_address, &addrlen)) == -1)
error("Event handler: accept error (server mode)!");
else
{
map_put_item(newclient_fd);
setNonBlocking(newclient_fd);
Handler_Add_Fd_Read(newclient_fd);
incoming_message(SCTPasp__Types::ASP__SCTP__Connected(
INTEGER(newclient_fd),
*fd_map_server[i].local_IP_address,
INTEGER(fd_map_server[i].local_port),
get_ip(&peer_address),
get_port(&peer_address)));
}
}
}
}
else
{
if(server_mode && fd==my_fd)
{
int newclient_fd;
struct sockaddr_storage peer_address;
socklen_t addrlen = sizeof(peer_address);
if ((newclient_fd = accept(fd, (struct sockaddr *)&peer_address, &addrlen)) == -1)
error("Event handler: accept error (server mode)!");
else
{
map_put_item(newclient_fd);
setNonBlocking(newclient_fd);
Handler_Add_Fd_Read(newclient_fd);
}
}
}
// Receiving data
int i= map_get_item(my_fd);
if(i!=-1) // valid fd
{
log("Calling Event_Handler.");
receiving_fd = fd_map[i].fd;
struct cmsghdr *cmsg;
struct sctp_sndrcvinfo *sri;
char cbuf[sizeof (*cmsg) + sizeof (*sri)];
struct msghdr msg;
struct iovec iov;
size_t cmsglen = sizeof (*cmsg) + sizeof (*sri);
if ( !fd_map[i].processing_message )
{
fd_map[i].buf = Malloc(BUFLEN);
fd_map[i].buflen = BUFLEN;
iov.iov_base = fd_map[i].buf;
iov.iov_len = fd_map[i].buflen;
}
else
{
// Set the next read offset
log("Event_Handler: setting the next read offset.");
iov.iov_base = (char *)fd_map[i].buf + fd_map[i].nr;
iov.iov_len = fd_map[i].buflen - fd_map[i].nr;
}
// Set up the msghdr structure for receiving
memset(&msg, 0, sizeof (msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = cbuf;
msg.msg_controllen = cmsglen;
memset(cbuf, 0, sizeof (*cmsg) + sizeof (*sri));
cmsg = (struct cmsghdr *)cbuf;
sri = (struct sctp_sndrcvinfo *)(cmsg + 1);
return_value_t value = getmsg(receiving_fd, &msg);
switch(value)
{
case WHOLE_MESSAGE_RECEIVED:
fd_map[i].processing_message = FALSE;
// Intercept notifications here
if (msg.msg_flags & MSG_NOTIFICATION)
{
log("Calling event_handler for an incoming notification.");
handle_event(fd_map[i].buf);
}
else
{
log("Incoming data.");
unsigned int ui = ntohl(sri->sinfo_ppid);
INTEGER i_ppid;
if (ui <= (unsigned long)INT_MAX)
i_ppid = ui;
else {
char sbuf[16];
sprintf(sbuf, "%u", ui);
i_ppid = INTEGER(sbuf);
}
incoming_message(SCTPasp__Types::ASP__SCTP(
INTEGER(receiving_fd),
INTEGER(sri->sinfo_stream),
i_ppid,
OCTETSTRING(fd_map[i].nr,(const unsigned char *)fd_map[i].buf)));
}
Free(fd_map[i].buf);
fd_map[i].buf = NULL;
break;
case PARTIAL_RECEIVE:
fd_map[i].processing_message = TRUE;
break;
case EOF_OR_ERROR:
if (!server_mode) fd = -1; // setting closed socket to -1 in client mode (and reconnect mode)
map_delete_item(i);
if (events.sctp_association_event) incoming_message(SCTPasp__Types::ASP__SCTP__ASSOC__CHANGE(
INTEGER(receiving_fd),
SCTPasp__Types::SAC__STATE(SCTP_COMM_LOST)));
log("getmsg() returned with NULL. Socket is closed.");
if (reconnect) forced_reconnect(reconnect_max_attempts);
break;
}//endswitch
}// endif
}
void SCTPasp__PT_PROVIDER::user_map(const char *system_port)
{
log("Calling user_map(%s).",system_port);
if(simple_mode)
{
if ( server_mode && reconnect )
{
error("user_map(): server mode and reconnect mode are mutually exclusive!");
}
if ( server_mode && !local_port_is_present )
{
error("user_map(): in server mode local_port must be defined!");
}
// Server mode: turns on listening
if (server_mode)
{
log("Running in SERVER_MODE.");
struct sockaddr_storage sa;
socklen_t saLen=sizeof(sa);
int sock_type=fill_addr_struct(local_IP_address,local_port,&sa,saLen);
fd=create_socket(sock_type);
if(bind(fd,(const struct sockaddr *)&sa,saLen)!=0){
error("bind failed: %d, %s", errno, strerror(errno));
}
if (listen(fd, server_backlog) == -1) error("Listen error!");
log("Listening @ (%s):(%d)", (const char*)local_IP_address, local_port);
Handler_Add_Fd_Read(fd);
} else if (reconnect) {
log("Running in RECONNECT MODE.");
forced_reconnect(reconnect_max_attempts+1);
} else {
log("Running in CLIENT MODE.");
}
}
else
{
log("Running in NORMAL MODE.");
}
log("Leaving user_map().");
}
void SCTPasp__PT_PROVIDER::user_unmap(const char *system_port)
{
log("Calling user_unmap(%s).",system_port);
if(!simple_mode)
{
for(int i=0;i<list_len;i++) map_delete_item(i);
for(int i=0;i<list_len_server;i++) map_delete_item_server(i);
}
else
{
for(int i=0;i<list_len;i++) map_delete_item(i);
if(server_mode && fd != -1) {
close(fd);
Handler_Remove_Fd(fd, EVENT_ALL);
}
}
log("Leaving user_unmap().");
}
void SCTPasp__PT_PROVIDER::user_start()
{
log("Calling user_start().");
log("Leaving user_start().");
}
void SCTPasp__PT_PROVIDER::user_stop()
{
log("Calling user_stop().");
log("Leaving user_stop().");
}
void SCTPasp__PT_PROVIDER::outgoing_send(const SCTPasp__Types::ASP__SCTP__Connect& send_par)
{
log("Calling outgoing_send (ASP_SCTP_CONNECT).");
if(simple_mode)
{
if (server_mode)
error("ASP_SCTP_CONNECT is not allowed in server mode!");
if(fd != -1)
error("ASP_SCTP_CONNECT called during active connection.");
}
if( !peer_IP_address_is_present && !send_par.peer__hostname().ispresent() )
error("Peer IP address should be defined!");
if( !peer_port_is_present && !send_par.peer__portnumber().ispresent() )
error("Peer port should be defined!");
if(send_par.peer__hostname().ispresent())
{
peer_IP_address = send_par.peer__hostname()();
}
if(send_par.peer__portnumber().ispresent()){
peer_port = (int) send_par.peer__portnumber()();
}
struct sockaddr_storage sa;
socklen_t saLen;
int sock_type=fill_addr_struct(peer_IP_address,peer_port,&sa,saLen);
fd=create_socket(sock_type);
if(simple_mode && local_port_is_present){
// we should bind
struct sockaddr_storage loc_sa;
socklen_t loc_saLen;
int loc_sock_type=fill_addr_struct(local_IP_address,local_port,&loc_sa,loc_saLen);
if(sock_type!=loc_sock_type)
error("The local and peer IP addreses are different type: %s %i %s %i", (const char*)peer_IP_address,sock_type,(const char*)local_IP_address,loc_sock_type);
if(bind(fd,(const struct sockaddr *)&loc_sa,loc_saLen)!=0){
error("bind failed %d %s",errno, strerror(errno));
}
}
log("Connecting to (%s):(%d)", (const char*)peer_IP_address, peer_port);
// setting non-blocking mode
if(!simple_mode) setNonBlocking(fd);
if (connect(fd, (const struct sockaddr *)&sa, saLen) == -1)
{
if(errno == EINPROGRESS && !simple_mode)
{
map_put_item(fd);
int i = map_get_item(fd);
fd_map[i].einprogress = TRUE;
fd_map[i].sin = sa;
fd_map[i].saLen = saLen;
Handler_Add_Fd_Write(fd);
log("Connection in progress to (%s):(%d)",(const char*)peer_IP_address, peer_port);
}
else
{
close(fd);
fd = -1;
TTCN_warning("Connect error!");
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = OMIT_VALUE;
asp_sctp_result.error__status() = TRUE;
asp_sctp_result.error__message() = strerror(errno);
incoming_message(asp_sctp_result);
}
errno = 0;
}
else
{
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = fd;
asp_sctp_result.error__status() = FALSE;
asp_sctp_result.error__message() = OMIT_VALUE;
incoming_message(asp_sctp_result);
map_put_item(fd);
if(simple_mode) setNonBlocking(fd);
Handler_Add_Fd_Read(fd);
log("Connection successfully established to (%s):(%d)", (const char*)peer_IP_address, peer_port);
}
log("Leaving outgoing_send (ASP_SCTP_CONNECT).");
}
void SCTPasp__PT_PROVIDER::outgoing_send(const SCTPasp__Types::ASP__SCTP__ConnectFrom& send_par)
{
log("Calling outgoing_send (ASP_SCTP_CONNECTFROM).");
if(!simple_mode)
{
if( !peer_IP_address_is_present && !send_par.peer__hostname().ispresent() )
error("Peer IP address should be defined!");
if( !peer_port_is_present && !send_par.peer__portnumber().ispresent() )
error("Peer port should be defined!");
// work around for create_socket()
if(send_par.peer__hostname().ispresent())
{
peer_IP_address = send_par.peer__hostname()();
}
if(send_par.peer__portnumber().ispresent()){
peer_port = (int) send_par.peer__portnumber()();
}
struct sockaddr_storage sa;
socklen_t saLen;
int sock_type=fill_addr_struct(peer_IP_address,peer_port,&sa,saLen);
struct sockaddr_storage loc_sa;
socklen_t loc_saLen;
int loc_sock_type=fill_addr_struct(send_par.local__hostname().ispresent()?send_par.local__hostname()():local_IP_address,
(int) send_par.local__portnumber(),&loc_sa,loc_saLen);
if(sock_type!=loc_sock_type)
error("The local and peer IP addreses are different type: %s %i %s %i", (const char*)peer_IP_address,sock_type,(const char*)local_IP_address,loc_sock_type);
fd=create_socket(sock_type);
if(bind(fd,(const struct sockaddr *)&loc_sa,loc_saLen)!=0){
error("bind failed %d %s",errno, strerror(errno));
}
log("Connecting to (%s):(%d)", (const char*)peer_IP_address, peer_port);
// setting non-blocking mode
setNonBlocking(fd);
if (connect(fd, (struct sockaddr *)&sa, saLen) == -1)
{
if(errno == EINPROGRESS)
{
map_put_item(fd);
int i = map_get_item(fd);
fd_map[i].einprogress = TRUE;
fd_map[i].sin = sa;
fd_map[i].saLen = saLen;
Handler_Add_Fd_Write(fd);
log("Connection in progress to (%s):(%d)",(const char*)peer_IP_address, peer_port);
}
else
{
close(fd);
fd = -1;
TTCN_warning("Connect error!");
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = OMIT_VALUE;
asp_sctp_result.error__status() = TRUE;
asp_sctp_result.error__message() = strerror(errno);
incoming_message(asp_sctp_result);
}
errno = 0;
}
else
{
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = fd;
asp_sctp_result.error__status() = FALSE;
asp_sctp_result.error__message() = OMIT_VALUE;
incoming_message(asp_sctp_result);
map_put_item(fd);
Handler_Add_Fd_Read(fd);
log("Connection successfully established to (%s):(%d)", (const char*)peer_IP_address, peer_port);
}
}
log("Leaving outgoing_send (ASP_SCTP_CONNECTFROM).");
}
void SCTPasp__PT_PROVIDER::outgoing_send(const SCTPasp__Types::ASP__SCTP__Listen& send_par)
{
log("Calling outgoing_send (ASP_SCTP_LISTEN).");
if(!simple_mode)
{
const CHARSTRING& loc_name=send_par.local__hostname().ispresent()?send_par.local__hostname()():local_IP_address;
struct sockaddr_storage loc_sa;
socklen_t loc_saLen;
int loc_sock_type=fill_addr_struct(loc_name,(int) send_par.local__portnumber(),&loc_sa,loc_saLen);
fd=create_socket(loc_sock_type);
if(bind(fd,(const struct sockaddr *)&loc_sa,loc_saLen)!=0){
error("bind failed %d %s",errno, strerror(errno));
}
if (listen(fd, server_backlog) == -1) error("Listen error!");
map_put_item_server(fd, loc_name, (int) send_par.local__portnumber());
log("Listening @ (%s):(%d)", (const char *)loc_name, (int) send_par.local__portnumber());
Handler_Add_Fd_Read(fd);
#ifdef SCTP_REPORT_LISTEN_RESULT
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = fd;
asp_sctp_result.error__status() = FALSE;
asp_sctp_result.error__message() = OMIT_VALUE;
incoming_message(asp_sctp_result);
#endif
}
log("Leaving outgoing_send (ASP_SCTP_LISTEN).");
}
void SCTPasp__PT_PROVIDER::outgoing_send(const SCTPasp__Types::ASP__SCTP__SetSocketOptions& send_par)
{
log("Calling outgoing_send (ASP_SCTP_SETSOCKETOPTIONS).");
switch (send_par.get_selection())
{
case SCTPasp__Types::ASP__SCTP__SetSocketOptions::ALT_Sctp__init:
{
(void) memset(&initmsg, 0, sizeof(struct sctp_initmsg));
const SCTPasp__Types::SCTP__INIT& init = send_par.Sctp__init();
initmsg.sinit_num_ostreams = (int) init.sinit__num__ostreams();
initmsg.sinit_max_instreams = (int) init.sinit__max__instreams();
initmsg.sinit_max_attempts = (int) init.sinit__max__attempts();
initmsg.sinit_max_init_timeo = (int) init.sinit__max__init__timeo();
log("Setting SCTP socket options (initmsg).");
if (setsockopt(fd, IPPROTO_SCTP, SCTP_INITMSG, &initmsg,
sizeof(struct sctp_initmsg)) < 0)
{
TTCN_warning("Setsockopt error!");
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = fd;
asp_sctp_result.error__status() = TRUE;
asp_sctp_result.error__message() = strerror(errno);
incoming_message(asp_sctp_result);
errno = 0;
}
else
{
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = fd;
asp_sctp_result.error__status() = FALSE;
asp_sctp_result.error__message() = OMIT_VALUE;
incoming_message(asp_sctp_result);
}
break;
}
case SCTPasp__Types::ASP__SCTP__SetSocketOptions::ALT_Sctp__events:
{
const SCTPasp__Types::SCTP__EVENTS& event = send_par.Sctp__events();
events.sctp_data_io_event = (boolean) event.sctp__data__io__event();
events.sctp_association_event = (boolean) event.sctp__association__event();
events.sctp_address_event = (boolean) event.sctp__address__event();
events.sctp_send_failure_event = (boolean) event.sctp__send__failure__event();
events.sctp_peer_error_event = (boolean) event.sctp__peer__error__event();
events.sctp_shutdown_event = (boolean) event.sctp__shutdown__event();
events.sctp_partial_delivery_event = (boolean) event.sctp__partial__delivery__event();
#if defined(LKSCTP_1_0_7) || defined(LKSCTP_1_0_9)
events.sctp_adaptation_layer_event = (boolean) event.sctp__adaption__layer__event();
#else
events.sctp_adaption_layer_event = (boolean) event.sctp__adaption__layer__event();
#endif
break;
}
case SCTPasp__Types::ASP__SCTP__SetSocketOptions::ALT_So__linger:
{
struct linger so_linger;
(void) memset(&so_linger, 0, sizeof (so_linger));
const SCTPasp__Types::SO__LINGER& so = send_par.So__linger();
so_linger.l_onoff = (int) so.l__onoff();
so_linger.l_linger = (int) so.l__linger();
// Setting a socket level option
log("Setting SCTP socket options (so_linger).");
if (setsockopt(fd, SOL_SOCKET, SCTP_EVENTS, &so_linger, sizeof (so_linger)) < 0)
{
TTCN_warning("Setsockopt error!");
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = fd;
asp_sctp_result.error__status() = TRUE;
asp_sctp_result.error__message() = strerror(errno);
incoming_message(asp_sctp_result);
errno = 0;
}
else
{
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = fd;
asp_sctp_result.error__status() = FALSE;
asp_sctp_result.error__message() = OMIT_VALUE;
incoming_message(asp_sctp_result);
}
break;
}
case SCTPasp__Types::ASP__SCTP__SetSocketOptions::ALT_Sctp__rtoinfo:
{
struct sctp_rtoinfo sctp_rtoinfo;
(void) memset(&sctp_rtoinfo, 0, sizeof (sctp_rtoinfo));
const SCTPasp__Types::SCTP__RTOINFO& rto = send_par.Sctp__rtoinfo();
int local_fd = (int) rto.client__id();
sctp_rtoinfo.srto_initial = (int) rto.srto__initial();
sctp_rtoinfo.srto_max = (int) rto.srto__max();
sctp_rtoinfo.srto_min = (int) rto.srto__min();
// Setting a SCTP level socket option
log("Setting SCTP socket options (sctp_rtoinfo).");
if (setsockopt(local_fd, IPPROTO_SCTP, SCTP_RTOINFO, &sctp_rtoinfo,
sizeof (sctp_rtoinfo)) < 0)
{
TTCN_warning("Setsockopt error!");
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = local_fd;
asp_sctp_result.error__status() = TRUE;
asp_sctp_result.error__message() = strerror(errno);
incoming_message(asp_sctp_result);
errno = 0;
}
else
{
SCTPasp__Types::ASP__SCTP__RESULT asp_sctp_result;
asp_sctp_result.client__id() = local_fd;
asp_sctp_result.error__status() = FALSE;
asp_sctp_result.error__message() = OMIT_VALUE;
incoming_message(asp_sctp_result);
}
break;
}
default:
error("Setsocketoptions error: UNBOUND value!");
break;
}
log("Leaving outgoing_send (ASP_SCTP_SETSOCKETOPTIONS).");
}
void SCTPasp__PT_PROVIDER::outgoing_send(const SCTPasp__Types::ASP__SCTP__Close& send_par)
{
log("Calling outgoing_send (ASP_SCTP_CLOSE).");
if(!simple_mode)
{
if(send_par.client__id().ispresent())
{
int local_fd = (int) (const INTEGER&) send_par.client__id();
log("NORMAL MODE: closing client/server socket (fd = %d).", local_fd);
map_delete_item_fd(local_fd);
map_delete_item_fd_server(local_fd);
}
else
{ // if OMIT is given then all sockets will be closed
log("NORMAL MODE: closing all sockets.");
for(int i=0;i<list_len;i++) map_delete_item(i);
for(int i=0;i<list_len_server;i++) map_delete_item_server(i);
}
}
else
{
if (server_mode)
{ // closing the given connection
if(send_par.client__id().ispresent())
{
int local_fd = (int) (const INTEGER&) send_par.client__id();
log("SERVER MODE: closing client socket (fd = %d).", local_fd);
map_delete_item_fd(local_fd);
}
else
{ // if OMIT is given in server mode then all clients will be closed
log("SERVER MODE: closing all client sockets.");
for(int i=0;i<list_len;i++) map_delete_item(i);
}
}
else
{ // closing the connection to the server
if ( send_par.client__id().ispresent() )
error("In client mode the client_id field of ASP_SCTP_Close should be set to OMIT!");
log("CLIENT MODE: closing socket (fd = %d).", fd);
map_delete_item_fd(fd);
fd=-1;
}
}
log("Leaving outgoing_send (ASP_SCTP_CLOSE).");
}
void SCTPasp__PT_PROVIDER::outgoing_send(const SCTPasp__Types::ASP__SCTP& send_par)
{
log("Calling outgoing_send (ASP_SCTP).");
struct cmsghdr *cmsg;
struct sctp_sndrcvinfo *sri;
char cbuf[sizeof (*cmsg) + sizeof (*sri)];
struct msghdr msg;
struct iovec iov;
const unsigned char *buf;
buf = (const unsigned char *)send_par.data();
iov.iov_len = send_par.data().lengthof();
memset(&msg, 0, sizeof (msg));
iov.iov_base = (char *)buf;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = cbuf;
msg.msg_controllen = sizeof (*cmsg) + sizeof (*sri);
memset(cbuf, 0, sizeof (*cmsg) + sizeof (*sri));
cmsg = (struct cmsghdr *)cbuf;
sri = (struct sctp_sndrcvinfo *)(cmsg + 1);
cmsg->cmsg_len = sizeof (*cmsg) + sizeof (*sri);
cmsg->cmsg_level = IPPROTO_SCTP;
cmsg->cmsg_type = SCTP_SNDRCV;
sri->sinfo_stream = (int) send_par.sinfo__stream();
int target;
if(!simple_mode)
{
if (!send_par.client__id().ispresent())
error("In NORMAL mode the client_id field of ASP_SCTP should be set to a valid value and not to omit!");
target = (int) (const INTEGER&) send_par.client__id();
if ( (map_get_item(target)==-1) && (map_get_item_server(target)==-1)) error("Bad client id! %d",target);
}
else
{
if (server_mode)
{
if (!send_par.client__id().ispresent())
error("In server mode the client_id field of ASP_SCTP should be set to a valid value and not to omit!");
}
else // client mode
{
if (send_par.client__id().ispresent())
error("In client mode the client_id field of ASP_SCTP should be set to OMIT!");
}
target = fd;
if (server_mode)
target = (int) (const INTEGER&) send_par.client__id();
if (map_get_item(target)==-1) error("Bad client id! %d",target);
}
uint32_t ui;
if (send_par.sinfo__ppid().get_val().is_native() && send_par.sinfo__ppid() > 0)
ui = (int)send_par.sinfo__ppid();
else {
OCTETSTRING os = int2oct(send_par.sinfo__ppid(), 4);
unsigned char* p = (unsigned char*)&ui;
*(p++) = os[3].get_octet();
*(p++) = os[2].get_octet();
*(p++) = os[1].get_octet();
*(p++) = os[0].get_octet();
}
sri->sinfo_ppid = htonl(ui);
log("Sending SCTP message to file descriptor %d.", target);
if (sendmsg(target, &msg, 0) < 0)
{
SCTPasp__Types::ASP__SCTP__SENDMSG__ERROR asp_sctp_sendmsg_error;
if (server_mode) asp_sctp_sendmsg_error.client__id() = target;
else asp_sctp_sendmsg_error.client__id() = OMIT_VALUE;
asp_sctp_sendmsg_error.sinfo__stream() = send_par.sinfo__stream();
asp_sctp_sendmsg_error.sinfo__ppid() = send_par.sinfo__ppid();
asp_sctp_sendmsg_error.data() = send_par.data();
incoming_message(asp_sctp_sendmsg_error);
TTCN_warning("Sendmsg error! Strerror=%s", strerror(errno));
errno = 0;
}
log("Leaving outgoing_send (ASP_SCTP).");
}
SCTPasp__PT_PROVIDER::return_value_t SCTPasp__PT_PROVIDER::getmsg(int fd, struct msghdr *msg)
{
log("Calling getmsg().");
int index = map_get_item(fd);
if ( !fd_map[index].processing_message ) fd_map[index].nr = 0;
ssize_t value = recvmsg(fd, msg, 0);
if (value <= 0) // EOF or error
{
log("Leaving getmsg(): EOF or error.");
errno = 0;
return EOF_OR_ERROR;
}
fd_map[index].nr += value;
log("getmsg(): [%d] bytes received. Receiving buffer now has [%d] bytes.", value, fd_map[index].nr);
// Whole message is received, return it.
if (msg->msg_flags & MSG_EOR)
{
log("Leaving getmsg(): whole message is received.");
return WHOLE_MESSAGE_RECEIVED;
}
// Maybe we need a bigger buffer, do realloc().
if (fd_map[index].buflen == fd_map[index].nr)
{
log("getmsg(): resizing receiving buffer: [%d] bytes -> [%d] bytes",
fd_map[index].buflen, (fd_map[index].buflen * 2));
fd_map[index].buf = Realloc(fd_map[index].buf, fd_map[index].buflen * 2);
fd_map[index].buflen *= 2;
}
log("Leaving getmsg(): part of the message is received.");
return PARTIAL_RECEIVE;
}
void SCTPasp__PT_PROVIDER::handle_event(void *buf)
{
union sctp_notification *snp;
snp = (sctp_notification *)buf;
switch (snp->sn_header.sn_type)
{
case SCTP_ASSOC_CHANGE:
{
log("incoming SCTP_ASSOC_CHANGE event.");
struct sctp_assoc_change *sac;
sac = &snp->sn_assoc_change;
// #ifdef LKSCTP_1_0_7
SCTPasp__Types::SAC__STATE sac_state_ttcn;
switch(sac->sac_state)
{
case SCTP_COMM_UP:
sac_state_ttcn = SCTPasp__Types::SAC__STATE::SCTP__COMM__UP;
break;
case SCTP_COMM_LOST:
sac_state_ttcn = SCTPasp__Types::SAC__STATE::SCTP__COMM__LOST;
break;
case SCTP_RESTART:
sac_state_ttcn = SCTPasp__Types::SAC__STATE::SCTP__RESTART;
break;
case SCTP_SHUTDOWN_COMP:
sac_state_ttcn = SCTPasp__Types::SAC__STATE::SCTP__SHUTDOWN__COMP;
break;
case SCTP_CANT_STR_ASSOC:
sac_state_ttcn = SCTPasp__Types::SAC__STATE::SCTP__CANT__STR__ASSOC;
break;
default:
sac_state_ttcn = SCTPasp__Types::SAC__STATE::SCTP__UNKNOWN__SAC__STATE;
TTCN_warning("Unexpected sac_state value received %d", sac->sac_state);
break;
}
// #endif
if(sac->sac_state == SCTP_COMM_LOST)
{
if(simple_mode)
{
if (!server_mode) fd = -1; // setting closed socket to -1 in client mode (and reconnect mode)
map_delete_item_fd(receiving_fd);
}
else
{
map_delete_item_fd(receiving_fd);
map_delete_item_fd_server(receiving_fd);
}
}
if (events.sctp_association_event) incoming_message(SCTPasp__Types::ASP__SCTP__ASSOC__CHANGE(
INTEGER(receiving_fd),
sac_state_ttcn
));
if(simple_mode)
{
if (reconnect && (sac->sac_state == SCTP_COMM_LOST) ) forced_reconnect(reconnect_max_attempts);
}
break;
}
case SCTP_PEER_ADDR_CHANGE:{
log("incoming SCTP_PEER_ADDR_CHANGE event.");
struct sctp_paddr_change *spc;
spc = &snp->sn_paddr_change;
// #ifdef LKSCTP_1_0_7
SCTPasp__Types::SPC__STATE spc_state_ttcn;
switch(spc->spc_state)
{
case SCTP_ADDR_AVAILABLE:
spc_state_ttcn = SCTPasp__Types::SPC__STATE::SCTP__ADDR__AVAILABLE;
break;
case SCTP_ADDR_UNREACHABLE:
spc_state_ttcn = SCTPasp__Types::SPC__STATE::SCTP__ADDR__UNREACHABLE;
break;
case SCTP_ADDR_REMOVED:
spc_state_ttcn = SCTPasp__Types::SPC__STATE::SCTP__ADDR__REMOVED;
break;
case SCTP_ADDR_ADDED:
spc_state_ttcn = SCTPasp__Types::SPC__STATE::SCTP__ADDR__ADDED;
break;
case SCTP_ADDR_MADE_PRIM:
spc_state_ttcn = SCTPasp__Types::SPC__STATE::SCTP__ADDR__MADE__PRIM;
break;
#if defined(LKSCTP_1_0_7) || defined(LKSCTP_1_0_9)
case SCTP_ADDR_CONFIRMED:
spc_state_ttcn = SCTPasp__Types::SPC__STATE::SCTP__ADDR__CONFIRMED;
break;
#endif
default:
spc_state_ttcn = SCTPasp__Types::SPC__STATE::SCTP__UNKNOWN__SPC__STATE;
TTCN_warning("Unexpected spc_state value received %d", spc->spc_state);
break;
}
// #endif
if (events.sctp_address_event) incoming_message(SCTPasp__Types::ASP__SCTP__PEER__ADDR__CHANGE(
INTEGER(receiving_fd),
spc_state_ttcn
));
break;
}
case SCTP_REMOTE_ERROR:
log("incoming SCTP_REMOTE_ERROR event.");
//struct sctp_remote_error *sre;
//sre = &snp->sn_remote_error;
if (events.sctp_peer_error_event) incoming_message(SCTPasp__Types::ASP__SCTP__REMOTE__ERROR(INTEGER(receiving_fd)));
break;
case SCTP_SEND_FAILED:
log("incoming SCTP_SEND_FAILED event.");
//struct sctp_send_failed *ssf;
//ssf = &snp->sn_send_failed;
if (events.sctp_send_failure_event) incoming_message(SCTPasp__Types::ASP__SCTP__SEND__FAILED(INTEGER(receiving_fd)));
break;
case SCTP_SHUTDOWN_EVENT:
log("incoming SCTP_SHUTDOWN_EVENT event.");
//struct sctp_shutdown_event *sse;
//sse = &snp->sn_shutdown_event;
if (events.sctp_shutdown_event) incoming_message(SCTPasp__Types::ASP__SCTP__SHUTDOWN__EVENT(INTEGER(receiving_fd)));
break;
#if defined(LKSCTP_1_0_7) || defined(LKSCTP_1_0_9)
case SCTP_ADAPTATION_INDICATION:
log("incoming SCTP_ADAPTION_INDICATION event.");
//struct sctp_adaptation_event *sai;
//sai = &snp->sn_adaptation_event;
if (events.sctp_adaptation_layer_event) incoming_message(SCTPasp__Types::ASP__SCTP__ADAPTION__INDICATION(INTEGER(receiving_fd)));
break;
#else
case SCTP_ADAPTION_INDICATION:
log("incoming SCTP_ADAPTION_INDICATION event.");
//struct sctp_adaption_event *sai;
//sai = &snp->sn_adaption_event;
if (events.sctp_adaption_layer_event) incoming_message(SCTPasp__Types::ASP__SCTP__ADAPTION__INDICATION(INTEGER(receiving_fd)));
break;
#endif
case SCTP_PARTIAL_DELIVERY_EVENT:
log("incoming SCTP_PARTIAL_DELIVERY_EVENT event.");
//struct sctp_pdapi_event *pdapi;
//pdapi = &snp->sn_pdapi_event;
if (events.sctp_partial_delivery_event) incoming_message(SCTPasp__Types::ASP__SCTP__PARTIAL__DELIVERY__EVENT(INTEGER(receiving_fd)));
break;
default:
TTCN_warning("Unknown notification type!");
break;
}
}
void SCTPasp__PT_PROVIDER::log(const char *fmt, ...)
{
if(debug)
{
va_list ap;
va_start(ap, fmt);
TTCN_Logger::begin_event(TTCN_DEBUG);
TTCN_Logger::log_event("SCTPasp Test Port (%s): ", get_name());
TTCN_Logger::log_event_va_list(fmt, ap);
TTCN_Logger::end_event();
va_end(ap);
}
}
void SCTPasp__PT_PROVIDER::error(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
TTCN_Logger::begin_event(TTCN_ERROR);
TTCN_Logger::log_event("SCTPasp Test Port (%s): ", get_name());
TTCN_Logger::log_event_va_list(fmt, ap);
TTCN_Logger::end_event();
va_end(ap);
TTCN_error("Fatal error in SCTPasp Test Port %s (see above).", get_name());
}
void SCTPasp__PT_PROVIDER::forced_reconnect(int attempts)
{
struct sockaddr_storage sa;
socklen_t saLen;
int sock_type=fill_addr_struct(peer_IP_address,peer_port,&sa,saLen);
log("[reconnect] Connecting to (%s):(%d)", (const char*)peer_IP_address, peer_port);
unsigned int sleep_interval = 1;
int i;
for(i = 0; i < attempts; i++)
{
fd=create_socket(sock_type);
if (connect(fd, (struct sockaddr *)&sa, saLen) == -1)
{
close(fd);
fd = -1;
TTCN_warning("Connect error!");
errno = 0;
if( ((i % 2 ) == 0) && (i != 0)) sleep_interval *= 2;
sleep(sleep_interval);
}
else
{
map_put_item(fd);
setNonBlocking(fd);
Handler_Add_Fd_Read(fd);
log("[reconnect] Connection successfully established to (%s):(%d)", (const char *)peer_IP_address, peer_port);
break;
}
}
if (i == attempts) error("Forced reconnect failed! Remote end is unreachable!");
}
void SCTPasp__PT_PROVIDER::map_put_item(int fd)
{
int i=0;
while((i<list_len) && !fd_map[i].erased) i++; // searching for the free item
if(i==list_len)
{ // list is full add new elemnts
list_len+=MAP_LENGTH;
fd_map=(fd_map_item *)Realloc(fd_map,(list_len)*sizeof(fd_map_item));
for(int k=i;k<list_len;k++)
{ // init new elements
fd_map[k].fd=-1;
fd_map[k].erased=TRUE;
fd_map[k].einprogress=FALSE;
fd_map[k].buf=NULL;
fd_map[k].buflen=0;
fd_map[k].processing_message=FALSE;
fd_map[k].nr=0;
fd_map[k].saLen=0;
memset(&fd_map[k].sin,0,sizeof(struct sockaddr_storage));
}
}
fd_map[i].fd=fd; // adding new connection
fd_map[i].erased=FALSE;
}
int SCTPasp__PT_PROVIDER::map_get_item(int fd)
{
for(int i = 0; i < list_len; i++)
if( !(fd_map[i].erased) && (fd_map[i].fd == fd) ) return i;
return(-1);
}
void SCTPasp__PT_PROVIDER::map_delete_item_fd(int fd)
{
if(fd!=-1)
for(int i = 0; i < list_len; i++)
if( fd_map[i].fd == fd )
{
map_delete_item(i);
break;
}
}
void SCTPasp__PT_PROVIDER::map_delete_item(int index)
{
if((index>=list_len) || (index<0)) error("map_delete_item: index out of range (0-%d): %d",list_len-1,index);
if(fd_map[index].fd!=-1) {close(fd_map[index].fd);Handler_Remove_Fd(fd_map[index].fd, EVENT_ALL);}
fd_map[index].fd=-1;
fd_map[index].erased=TRUE;
fd_map[index].einprogress=FALSE;
if(fd_map[index].buf) Free(fd_map[index].buf);
fd_map[index].buf=NULL;
fd_map[index].buflen=0;
fd_map[index].processing_message=FALSE;
fd_map[index].nr=0;
fd_map[index].saLen=0;
memset(&fd_map[index].sin,0,sizeof(struct sockaddr_storage));
}
void SCTPasp__PT_PROVIDER::map_put_item_server(int fd, const CHARSTRING& local_IP_address, unsigned short local_port)
{
int i=0;
while((i<list_len_server) && !fd_map_server[i].erased) i++; // searching for the free item
if(i==list_len_server)
{ // list is full add new elemnts
list_len_server+=MAP_LENGTH;
fd_map_server=(fd_map_server_item *)Realloc(fd_map_server,(list_len_server)*sizeof(fd_map_server_item));
for(int k=i;k<list_len_server;k++)
{ // init new elements
fd_map_server[k].fd=-1;
fd_map_server[k].erased=TRUE;
fd_map_server[k].local_IP_address = NULL;
fd_map_server[k].local_port = 0;
}
}
fd_map_server[i].fd=fd; // adding new connection
fd_map_server[i].erased=FALSE;
if(fd_map_server[i].local_IP_address == NULL){
fd_map_server[i].local_IP_address = new CHARSTRING();
}
*fd_map_server[i].local_IP_address = local_IP_address;
fd_map_server[i].local_port = local_port;
}
int SCTPasp__PT_PROVIDER::map_get_item_server(int fd)
{
for(int i = 0; i < list_len_server; i++)
if( !(fd_map_server[i].erased) && (fd_map_server[i].fd == fd) ) return i;
return(-1);
}
void SCTPasp__PT_PROVIDER::map_delete_item_fd_server(int fd)
{
if(fd!=-1)
for(int i = 0; i < list_len_server; i++)
if( fd_map_server[i].fd == fd )
{
map_delete_item_server(i);
break;
}
}
void SCTPasp__PT_PROVIDER::map_delete_item_server(int index)
{
if((index>=list_len_server) || (index<0)) error("map_delete_item: index out of range (0-%d): %d",list_len_server-1,index);
if(fd_map_server[index].fd!=-1) {close(fd_map_server[index].fd);Handler_Remove_Fd(fd_map_server[index].fd, EVENT_ALL);}
fd_map_server[index].fd=-1;
fd_map_server[index].erased=TRUE;
if(fd_map_server[index].local_IP_address != NULL){ delete fd_map_server[index].local_IP_address;}
fd_map_server[index].local_IP_address = NULL;
fd_map_server[index].local_port = 0;
}
int SCTPasp__PT_PROVIDER::fill_addr_struct(const char* name, int port, struct sockaddr_storage* sa, socklen_t& saLen){
//int err = 0;
int addrtype = -1;
struct sockaddr_in saddr;
struct sockaddr_in6 saddr6;
memset(sa,0,sizeof(struct sockaddr_storage));
struct sockaddr_in* v4=(sockaddr_in*)sa;
struct sockaddr_in6* v6=(sockaddr_in6*)sa;
if(inet_pton(AF_INET, name, &(saddr.sin_addr))) {
saLen = sizeof(*v4);
v4->sin_family = AF_INET;
v4->sin_port = htons(port);
memcpy(&(v4->sin_addr), &(saddr.sin_addr), sizeof(saddr.sin_addr));
addrtype = AF_INET;
}
else if(inet_pton(AF_INET6, name, &(saddr6.sin6_addr))) {
saLen = sizeof(*v6);
v6->sin6_family = AF_INET6;
v6->sin6_port = htons(port);
memcpy(&(v6->sin6_addr), &(saddr6.sin6_addr), sizeof(saddr6.sin6_addr));
addrtype = AF_INET6;
}
else {
struct addrinfo myaddr, *res;
memset(&myaddr,0,sizeof(myaddr));
myaddr.ai_flags = AI_ADDRCONFIG|AI_PASSIVE;
myaddr.ai_socktype = SOCK_STREAM;
myaddr.ai_protocol = 0;
// if ((err = getaddrinfo(name, NULL, &myaddr, &res)) != 0) {
if (getaddrinfo(name, NULL, &myaddr, &res) != 0) {
//printf("SetSockAddr: getaddrinfo error: %i, %s", err, gai_strerror(err));
error("Can't resolve host name: %s",name);
}
if (res->ai_addr->sa_family == AF_INET) { // IPv4
struct sockaddr_in *saddr = (struct sockaddr_in *) res->ai_addr;
saLen = sizeof(*v4);
v4->sin_family = AF_INET;
v4->sin_port = htons(port);
memcpy(&(v4->sin_addr), &(saddr->sin_addr), sizeof(saddr->sin_addr));
addrtype = AF_INET;
}
else if (res->ai_addr->sa_family == AF_INET6){ // IPv6
struct sockaddr_in6 *saddr = (struct sockaddr_in6 *) res->ai_addr;
saLen = sizeof(*v6);
memcpy(v6,saddr,saLen);
v6->sin6_port = htons(port);
addrtype = AF_INET6;
}
freeaddrinfo(res);
}
return addrtype;
}
int SCTPasp__PT_PROVIDER::create_socket(int addr_family)
{
int local_fd;
log("Creating SCTP socket.");
usleep(200000);
if ((local_fd = socket(addr_family, SOCK_STREAM, IPPROTO_SCTP)) == -1)
error("Socket error: cannot create socket! %d %s %d %d",errno, strerror(errno),addr_family,AF_INET);
log("Setting SCTP socket options (initmsg).");
if (setsockopt(local_fd, IPPROTO_SCTP, SCTP_INITMSG, &initmsg,
sizeof(struct sctp_initmsg)) < 0)
{
TTCN_warning("Setsockopt error!");
errno = 0;
}
log("Setting SCTP socket options (events).");
if (sctp_setsockopt_events_linux_workaround(local_fd, &events) < 0)
{
TTCN_warning("Setsockopt error!");
errno = 0;
}
return local_fd;
}
void SCTPasp__PT_PROVIDER::setNonBlocking(int fd)
{
int flags = fcntl(fd, F_GETFL);
flags |= O_NONBLOCK;
int result = fcntl(fd, F_SETFL, flags);
if (result==-1) error("SCTPasp__PT::setNonBlocking(): Fcntl() error!");
}
}