From ac3598008390c5185f6b71feffe31cb7fa61b9a7 Mon Sep 17 00:00:00 2001 From: Harald Welte Date: Wed, 12 Apr 2017 12:13:44 +0200 Subject: initial chekin of code received by Ericsson on 20170410 --- SCTPasp_CNL113469/SCTPasp_CNL113469.tpd | 50 + SCTPasp_CNL113469/doc/SCTPasp_CNL113469_PRI.doc | Bin 0 -> 64512 bytes SCTPasp_CNL113469/doc/SCTPasp_CNL113469_UG.doc | Bin 0 -> 162816 bytes SCTPasp_CNL113469/doc/SCTPasp_FS.pdf | Bin 0 -> 167590 bytes SCTPasp_CNL113469/src/SCTPasp_PT.cc | 1549 +++++++++++++++++++++++ SCTPasp_CNL113469/src/SCTPasp_PT.hh | 157 +++ SCTPasp_CNL113469/src/SCTPasp_PortType.ttcn | 62 + SCTPasp_CNL113469/src/SCTPasp_Types.ttcn | 201 +++ 8 files changed, 2019 insertions(+) create mode 100644 SCTPasp_CNL113469/SCTPasp_CNL113469.tpd create mode 100644 SCTPasp_CNL113469/doc/SCTPasp_CNL113469_PRI.doc create mode 100644 SCTPasp_CNL113469/doc/SCTPasp_CNL113469_UG.doc create mode 100644 SCTPasp_CNL113469/doc/SCTPasp_FS.pdf create mode 100644 SCTPasp_CNL113469/src/SCTPasp_PT.cc create mode 100644 SCTPasp_CNL113469/src/SCTPasp_PT.hh create mode 100644 SCTPasp_CNL113469/src/SCTPasp_PortType.ttcn create mode 100644 SCTPasp_CNL113469/src/SCTPasp_Types.ttcn (limited to 'SCTPasp_CNL113469') diff --git a/SCTPasp_CNL113469/SCTPasp_CNL113469.tpd b/SCTPasp_CNL113469/SCTPasp_CNL113469.tpd new file mode 100644 index 00000000..125ad9fc --- /dev/null +++ b/SCTPasp_CNL113469/SCTPasp_CNL113469.tpd @@ -0,0 +1,50 @@ + + + + SCTPasp_CNL113469 + + + + + + + + + + Default + + + + + true + true + true + bin/SCTPasp_CNL113469 + + USE_SCTP + + Level 3 - Creating object files with dependency update + + + bin + + + + + diff --git a/SCTPasp_CNL113469/doc/SCTPasp_CNL113469_PRI.doc b/SCTPasp_CNL113469/doc/SCTPasp_CNL113469_PRI.doc new file mode 100644 index 00000000..5923989c Binary files /dev/null and b/SCTPasp_CNL113469/doc/SCTPasp_CNL113469_PRI.doc differ diff --git a/SCTPasp_CNL113469/doc/SCTPasp_CNL113469_UG.doc b/SCTPasp_CNL113469/doc/SCTPasp_CNL113469_UG.doc new file mode 100644 index 00000000..e0c17fef Binary files /dev/null and b/SCTPasp_CNL113469/doc/SCTPasp_CNL113469_UG.doc differ diff --git a/SCTPasp_CNL113469/doc/SCTPasp_FS.pdf b/SCTPasp_CNL113469/doc/SCTPasp_FS.pdf new file mode 100644 index 00000000..0e66447b Binary files /dev/null and b/SCTPasp_CNL113469/doc/SCTPasp_FS.pdf differ diff --git a/SCTPasp_CNL113469/src/SCTPasp_PT.cc b/SCTPasp_CNL113469/src/SCTPasp_PT.cc new file mode 100644 index 00000000..6d7b02b4 --- /dev/null +++ b/SCTPasp_CNL113469/src/SCTPasp_PT.cc @@ -0,0 +1,1549 @@ +/****************************************************************************** +* Copyright (c) 2005, 2014 Ericsson AB +* All rights reserved. This program and the accompanying materials +* are made available under the terms of the Eclipse Public License v1.0 +* which accompanies this distribution, and is available at +* http://www.eclipse.org/legal/epl-v10.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: R11A +// Prodnr: CNL 113 469 +// + + +#include "SCTPasp_PT.hh" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 { + +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_in sin; // storing remote address +}; + + +struct SCTPasp__PT_PROVIDER::fd_map_server_item // server item +{ // used by map operations + int fd; // socket descriptor + boolean erased; + struct in_addr 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.s_addr = INADDR_ANY; + (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; + FD_ZERO(&readfds); + FD_ZERO(&writefds); + local_port=-1; + peer_port=-1; + receiving_fd=-1; +} + + +SCTPasp__PT_PROVIDER::~SCTPasp__PT_PROVIDER() +{ + for(int i=0;i=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 = get_in_addr((const char *) 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 = get_in_addr((const char *) 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::Event_Handler(const fd_set *read_fds, + const fd_set *write_fds, const fd_set */*error_fds*/, + double /*time_since_last_call*/) +{ + // Accepting new client + if(!simple_mode) + { + for(int i=0;isinfo_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) + FD_CLR(receiving_fd, &readfds); + Install_Handler(&readfds, NULL, NULL, 0.0); + 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 + }// endfor +} + + +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."); + create_socket(); + if (listen(fd, server_backlog) == -1) error("Listen error!"); + log("Listening @ (%s):(%d)", inet_ntoa(local_IP_address), local_port); + FD_SET(fd, &readfds); + Install_Handler(&readfds, NULL, NULL, 0.0); + } 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); + Uninstall_Handler(); + FD_ZERO(&readfds); + FD_ZERO(&writefds); + if(!simple_mode) + { + for(int i=0;icmsg_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) + FD_CLR(receiving_fd, &readfds); + Install_Handler(&readfds, NULL, NULL, 0.0); + map_delete_item_fd(receiving_fd); + } + else + { + FD_CLR(receiving_fd, &readfds); + Install_Handler(&readfds, NULL, NULL, 0.0); + 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_in sin; + sin.sin_family = AF_INET; + sin.sin_port = htons(peer_port); + sin.sin_addr.s_addr = peer_IP_address.s_addr; + log("[reconnect] Connecting to (%s):(%d)", inet_ntoa(peer_IP_address), peer_port); + unsigned int sleep_interval = 1; + int i; + for(i = 0; i < attempts; i++) + { + create_socket(); + if (connect(fd, (struct sockaddr *)&sin, sizeof (sin)) == -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); + FD_SET(fd, &readfds); + Install_Handler(&readfds, NULL, NULL, 0.0); + log("[reconnect] Connection successfully established to (%s):(%d)", inet_ntoa(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) || (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); + 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].sin.sin_family=AF_INET; + fd_map[index].sin.sin_port=0; + fd_map[index].sin.sin_addr.s_addr=0; +} + + +void SCTPasp__PT_PROVIDER::map_put_item_server(int fd, struct in_addr local_IP_address, unsigned short local_port) +{ + int i=0; + while((i=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); + fd_map_server[index].fd=-1; + fd_map_server[index].erased=TRUE; + fd_map_server[index].local_IP_address.s_addr = INADDR_ANY; + fd_map_server[index].local_port = 0; +} + + +void SCTPasp__PT_PROVIDER::create_socket() +{ + struct sockaddr_in sin; + + log("Creating SCTP socket."); + if ((fd = socket(AF_INET, SOCK_STREAM, IPPROTO_SCTP)) == -1) + error("Socket error: cannot create socket!"); + + if ( local_port_is_present ) { + sin.sin_family = AF_INET; + sin.sin_port = htons(local_port); + sin.sin_addr.s_addr = local_IP_address.s_addr; + log("Binding SCTP socket: bind address (%s):(%d)", + inet_ntoa(local_IP_address),local_port); + if (bind(fd, (struct sockaddr *)&sin, sizeof (sin)) == -1) + { + close(fd); + fd = -1; + error("Bind error!"); + } + } + + log("Setting SCTP socket options (initmsg)."); + if (setsockopt(fd, IPPROTO_SCTP, SCTP_INITMSG, &initmsg, + sizeof(struct sctp_initmsg)) < 0) + { + TTCN_warning("Setsockopt error!"); + errno = 0; + } + + log("Setting SCTP socket options (events)."); + if (setsockopt(fd, IPPROTO_SCTP, SCTP_EVENTS, &events, sizeof (events)) < 0) + { + TTCN_warning("Setsockopt error!"); + errno = 0; + } +} + + +in_addr SCTPasp__PT_PROVIDER::get_in_addr(const char *hostname) +{ + struct hostent *h; + if ((h=gethostbyname(hostname)) == NULL) + error("Gethostbyname error!"); + if(h->h_addr == NULL) error("Gethostbyname error! h->h_addr is NULL!"); + return *((struct in_addr *)h->h_addr); +} + +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!"); +} + + +} diff --git a/SCTPasp_CNL113469/src/SCTPasp_PT.hh b/SCTPasp_CNL113469/src/SCTPasp_PT.hh new file mode 100644 index 00000000..7d6311d3 --- /dev/null +++ b/SCTPasp_CNL113469/src/SCTPasp_PT.hh @@ -0,0 +1,157 @@ +/****************************************************************************** +* Copyright (c) 2005, 2014 Ericsson AB +* All rights reserved. This program and the accompanying materials +* are made available under the terms of the Eclipse Public License v1.0 +* which accompanies this distribution, and is available at +* http://www.eclipse.org/legal/epl-v10.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.hh +// Description: SCTPasp test port header +// Rev: R11A +// Prodnr: CNL 113 469 +// + + +#ifndef SCTPasp__PT_HH +#define SCTPasp__PT_HH + +#include +#include "SCTPasp_Types.hh" +#include +#include +#include + +namespace SCTPasp__Types { + class ASP__SCTP; + class ASP__SCTP__Connect; + class ASP__SCTP__ConnectFrom; + class ASP__SCTP__Listen; + + class SCTP__INIT; + class SCTP__EVENTS; + class SO__LINGER; + class SCTP__RTOINFO; + class SAC__STATE; + class SPC__STATE; + + class ASP__SCTP__SetSocketOptions; + class ASP__SCTP__Close; + class ASP__SCTP__ASSOC__CHANGE; + class ASP__SCTP__PEER__ADDR__CHANGE; + class ASP__SCTP__SEND__FAILED; + class ASP__SCTP__REMOTE__ERROR; + class ASP__SCTP__SHUTDOWN__EVENT; + class ASP__SCTP__PARTIAL__DELIVERY__EVENT; + class ASP__SCTP__ADAPTION__INDICATION; + class ASP__SCTP__Connected; + class ASP__SCTP__SENDMSG__ERROR; + class ASP__SCTP__RESULT; +} + +namespace SCTPasp__PortType { +class SCTPasp__PT_PROVIDER : public PORT { +public: + SCTPasp__PT_PROVIDER(const char *par_port_name = NULL); + ~SCTPasp__PT_PROVIDER(); + + void set_parameter(const char *parameter_name, + const char *parameter_value); + + void Event_Handler(const fd_set *read_fds, + const fd_set *write_fds, const fd_set *error_fds, + double time_since_last_call); + +protected: + void user_map(const char *system_port); + void user_unmap(const char *system_port); + + void user_start(); + void user_stop(); + + void outgoing_send(const SCTPasp__Types::ASP__SCTP__Connect& send_par); + void outgoing_send(const SCTPasp__Types::ASP__SCTP__ConnectFrom& send_par); + void outgoing_send(const SCTPasp__Types::ASP__SCTP__Listen& send_par); + void outgoing_send(const SCTPasp__Types::ASP__SCTP__SetSocketOptions& send_par); + void outgoing_send(const SCTPasp__Types::ASP__SCTP__Close& send_par); + void outgoing_send(const SCTPasp__Types::ASP__SCTP& send_par); + + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__ASSOC__CHANGE& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__PEER__ADDR__CHANGE& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__SEND__FAILED& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__REMOTE__ERROR& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__SHUTDOWN__EVENT& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__PARTIAL__DELIVERY__EVENT& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__ADAPTION__INDICATION& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__Connected& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__SENDMSG__ERROR& incoming_par) = 0; + virtual void incoming_message(const SCTPasp__Types::ASP__SCTP__RESULT& incoming_par) = 0; + +private: + enum return_value_t { WHOLE_MESSAGE_RECEIVED, PARTIAL_RECEIVE, EOF_OR_ERROR }; + return_value_t getmsg(int fd, struct msghdr *msg); + void handle_event(void *buf); + void log(const char *fmt, ...); + void error(const char *fmt, ...); + void handle_event_reconnect(void *buf); + void forced_reconnect(int attempts); + // map operations + void map_put_item(int fd); + int map_get_item(int fd); + void map_delete_item_fd(int fd); + void map_delete_item(int index); + + void map_put_item_server(int fd, struct in_addr local_IP_address, unsigned short local_port); + int map_get_item_server(int fd); + void map_delete_item_fd_server(int fd); + void map_delete_item_server(int index); + + void create_socket(); + in_addr get_in_addr(const char *hostname); + void setNonBlocking(int fd); + + boolean simple_mode; + boolean reconnect; + int reconnect_max_attempts; + boolean server_mode; + boolean debug; + int server_backlog; + struct in_addr local_IP_address; + struct in_addr peer_IP_address; + unsigned short local_port; + unsigned short peer_port; + + struct sctp_event_subscribe events; + struct sctp_initmsg initmsg; + + boolean local_port_is_present; + boolean peer_IP_address_is_present; + boolean peer_port_is_present; + + int fd; + fd_set readfds, writefds; + int receiving_fd; + + struct fd_map_item; + fd_map_item *fd_map; + int list_len; + + struct fd_map_server_item; + fd_map_server_item *fd_map_server; + int list_len_server; + + +}; +} +#endif diff --git a/SCTPasp_CNL113469/src/SCTPasp_PortType.ttcn b/SCTPasp_CNL113469/src/SCTPasp_PortType.ttcn new file mode 100644 index 00000000..27aae086 --- /dev/null +++ b/SCTPasp_CNL113469/src/SCTPasp_PortType.ttcn @@ -0,0 +1,62 @@ +/****************************************************************************** +* Copyright (c) 2005, 2014 Ericsson AB +* All rights reserved. This program and the accompanying materials +* are made available under the terms of the Eclipse Public License v1.0 +* which accompanies this distribution, and is available at +* http://www.eclipse.org/legal/epl-v10.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_PortType.ttcn +// Description: SCTPasp testport definition file +// Rev: R11A +// Prodnr: CNL 113 469 +// + +module SCTPasp_PortType +{ + +import from SCTPasp_Types all; + +//========================================================================= +//Port Types +//========================================================================= + +type port SCTPasp_PT message +{ + inout ASP_SCTP; + + out ASP_SCTP_Connect; + out ASP_SCTP_ConnectFrom; + out ASP_SCTP_Listen; + out ASP_SCTP_SetSocketOptions; + out ASP_SCTP_Close; + + in ASP_SCTP_ASSOC_CHANGE; + in ASP_SCTP_PEER_ADDR_CHANGE; + in ASP_SCTP_SEND_FAILED; + in ASP_SCTP_REMOTE_ERROR; + in ASP_SCTP_SHUTDOWN_EVENT; + in ASP_SCTP_PARTIAL_DELIVERY_EVENT; + in ASP_SCTP_ADAPTION_INDICATION; + + in ASP_SCTP_Connected; + in ASP_SCTP_SENDMSG_ERROR; + in ASP_SCTP_RESULT; + +} with { extension "provider" } + +}//end of module +with { +extension "version R11A" +} + diff --git a/SCTPasp_CNL113469/src/SCTPasp_Types.ttcn b/SCTPasp_CNL113469/src/SCTPasp_Types.ttcn new file mode 100644 index 00000000..f10fc588 --- /dev/null +++ b/SCTPasp_CNL113469/src/SCTPasp_Types.ttcn @@ -0,0 +1,201 @@ +/****************************************************************************** +* Copyright (c) 2005, 2014 Ericsson AB +* All rights reserved. This program and the accompanying materials +* are made available under the terms of the Eclipse Public License v1.0 +* which accompanies this distribution, and is available at +* http://www.eclipse.org/legal/epl-v10.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_Types.ttcn +// Description: SCTP ASP definition file +// Rev: R11A +// Prodnr: CNL 113 469 +// + + +module SCTPasp_Types +{ + +//========================================================================= +// Data Types +//========================================================================= + +type octetstring PDU_SCTP; + +type record ASP_SCTP +{ + integer client_id optional, + integer sinfo_stream, + integer sinfo_ppid, + PDU_SCTP data +} + + +type record ASP_SCTP_Connect +{ + charstring peer_hostname optional, + integer peer_portnumber (1..65535) optional +} + + +type record ASP_SCTP_ConnectFrom +{ + charstring local_hostname optional, + integer local_portnumber (1..65535), + charstring peer_hostname optional, + integer peer_portnumber (1..65535) optional +} + + +type record ASP_SCTP_Listen +{ + charstring local_hostname optional, + integer local_portnumber (1..65535) +} + + +type record SCTP_INIT +{ + integer sinit_num_ostreams, + integer sinit_max_instreams, + integer sinit_max_attempts, + integer sinit_max_init_timeo +} + +type record SCTP_EVENTS +{ + boolean sctp_data_io_event, + boolean sctp_association_event, + boolean sctp_address_event, + boolean sctp_send_failure_event, + boolean sctp_peer_error_event, + boolean sctp_shutdown_event, + boolean sctp_partial_delivery_event, + boolean sctp_adaption_layer_event +} + +type record SO_LINGER +{ + integer l_onoff, + integer l_linger +} + +type record SCTP_RTOINFO +{ + integer client_id, + integer srto_initial, + integer srto_max, + integer srto_min +} + +type union ASP_SCTP_SetSocketOptions +{ + SCTP_INIT Sctp_init, + SCTP_EVENTS Sctp_events, + SO_LINGER So_linger, + SCTP_RTOINFO Sctp_rtoinfo +} + + +type record ASP_SCTP_Close +{ + integer client_id optional +} + + +type enumerated SAC_STATE +{ + SCTP_COMM_UP, SCTP_COMM_LOST, SCTP_RESTART, + SCTP_SHUTDOWN_COMP, SCTP_CANT_STR_ASSOC, SCTP_UNKNOWN_SAC_STATE +} + +type record ASP_SCTP_ASSOC_CHANGE +{ + integer client_id, + SAC_STATE sac_state +} + + +type enumerated SPC_STATE +{ + SCTP_ADDR_AVAILABLE, SCTP_ADDR_UNREACHABLE, SCTP_ADDR_REMOVED, + SCTP_ADDR_ADDED, SCTP_ADDR_MADE_PRIM, SCTP_ADDR_CONFIRMED, SCTP_UNKNOWN_SPC_STATE +} + +type record ASP_SCTP_PEER_ADDR_CHANGE +{ + integer client_id, + SPC_STATE spc_state +} + + +type record ASP_SCTP_SEND_FAILED +{ + integer client_id +} + + +type record ASP_SCTP_REMOTE_ERROR +{ + integer client_id +} + + +type record ASP_SCTP_SHUTDOWN_EVENT +{ + integer client_id +} + + +type record ASP_SCTP_PARTIAL_DELIVERY_EVENT +{ + integer client_id +} + + +type record ASP_SCTP_ADAPTION_INDICATION +{ + integer client_id +} + + +type record ASP_SCTP_Connected +{ + integer client_id, + charstring local_hostname, + integer local_portnumber (1..65535), + charstring peer_hostname, + integer peer_portnumber (1..65535) +} + + +type record ASP_SCTP_SENDMSG_ERROR +{ + integer client_id optional, + integer sinfo_stream, + integer sinfo_ppid, + PDU_SCTP data +} + +type record ASP_SCTP_RESULT +{ + integer client_id optional, + boolean error_status, + charstring error_message optional +} + +}//end of module +with { +extension "version R11A" +} + -- cgit v1.2.3