simulators/e2sim/src/SCTP/e2sim_sctp.cpp

   1 /*****************************************************************************
   2 #                                                                            *
   3 # Copyright 2019 AT&T Intellectual Property                                  *
   4 # Copyright 2019 Nokia                                                       *
   5 #                                                                            *
   6 # Licensed under the Apache License, Version 2.0 (the "License");            *
   7 # you may not use this file except in compliance with the License.           *
   8 # You may obtain a copy of the License at                                    *
   9 #                                                                            *
  10 #      http://www.apache.org/licenses/LICENSE-2.0                            *
  11 #                                                                            *
  12 # Unless required by applicable law or agreed to in writing, software        *
  13 # distributed under the License is distributed on an "AS IS" BASIS,          *
  14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
  15 # See the License for the specific language governing permissions and        *
  16 # limitations under the License.                                             *
  17 #                                                                            *
  18 ******************************************************************************/
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <unistd.h>             //for close()
  22 #include <stdlib.h>
  23 #include <sys/socket.h>
  24 #include <netinet/in.h>
  25 #include <netinet/sctp.h>
  26 #include <arpa/inet.h>  //for inet_ntop()
  27 #include <assert.h>
  28
  29 #include "e2sim_sctp.hpp"
  30 // #include "e2sim_defs.h"
  31
  32
  33 #include <sys/types.h>
  34 #include <sys/socket.h>
  35 #include <netinet/sctp.h>
  36 #include <signal.h>
  37 #include <unistd.h>
  38 #include <string.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41
  42 int sctp_start_server(const char *server_ip_str, const int server_port)
  43 {
  44   if(server_port < 1 || server_port > 65535) {
  45       LOG_E("Invalid port number (%d). Valid values are between 1 and 65535.\n", server_port);
  46       exit(1);
  47   }
  48
  49   int server_fd, af;
  50   struct sockaddr* server_addr;
  51   size_t addr_len;
  52
  53   struct sockaddr_in  server4_addr;
  54   memset(&server4_addr, 0, sizeof(struct sockaddr_in));
  55
  56   struct sockaddr_in6 server6_addr;
  57   memset(&server6_addr, 0, sizeof(struct sockaddr_in6));
  58
  59   if(inet_pton(AF_INET, server_ip_str, &server4_addr.sin_addr) == 1)
  60   {
  61     server4_addr.sin_family = AF_INET;
  62     server4_addr.sin_port   = htons(server_port);
  63
  64     server_addr = (struct sockaddr*)&server4_addr;
  65     af          = AF_INET;
  66     addr_len    = sizeof(server4_addr);
  67   }
  68   else if(inet_pton(AF_INET6, server_ip_str, &server6_addr.sin6_addr) == 1)
  69   {
  70     server6_addr.sin6_family = AF_INET6;
  71     server6_addr.sin6_port   = htons(server_port);
  72
  73     server_addr = (struct sockaddr*)&server6_addr;
  74     af          = AF_INET6;
  75     addr_len    = sizeof(server6_addr);
  76   }
  77   else {
  78     perror("inet_pton()");
  79     exit(1);
  80   }
  81
  82   if((server_fd = socket(af, SOCK_STREAM, IPPROTO_SCTP)) == -1) {
  83     perror("socket");
  84     exit(1);
  85   }
  86
  87   //set send_buffer
  88   // int sendbuff = 10000;
  89   // socklen_t optlen = sizeof(sendbuff);
  90   // if(getsockopt(server_fd, SOL_SOCKET, SO_SNDBUF, &sendbuff, &optlen) == -1) {
  91   //   perror("getsockopt send");
  92   //   exit(1);
  93   // }
  94   // else
  95   //   LOG_D("[SCTP] send buffer size = %d\n", sendbuff);
  96
  97
  98   if(bind(server_fd, server_addr, addr_len) == -1) {
  99     perror("bind");
 100     exit(1);
 101   }
 102
 103   if(listen(server_fd, SERVER_LISTEN_QUEUE_SIZE) != 0) {
 104     perror("listen");
 105     exit(1);
 106   }
 107
 108   assert(server_fd != 0);
 109
 110   LOG_I("[SCTP] Server started on %s:%d", server_ip_str, server_port);
 111
 112   return server_fd;
 113 }
 114
 115 int sctp_start_client(const char *server_ip_str, const int server_port)
 116 {
 117   int client_fd, af;
 118
 119   struct sockaddr* server_addr;
 120   size_t addr_len;
 121
 122   struct sockaddr_in  server4_addr;
 123   memset(&server4_addr, 0, sizeof(struct sockaddr_in));
 124
 125   struct sockaddr_in6 server6_addr;
 126   memset(&server6_addr, 0, sizeof(struct sockaddr_in6));
 127
 128   if(inet_pton(AF_INET, server_ip_str, &server4_addr.sin_addr) == 1)
 129   {
 130     server4_addr.sin_family = AF_INET;
 131     server4_addr.sin_port   = htons(server_port);
 132     server_addr = (struct sockaddr*)&server4_addr;
 133     addr_len    = sizeof(server4_addr);
 134   }
 135   else if(inet_pton(AF_INET6, server_ip_str, &server6_addr.sin6_addr) == 1)
 136   {
 137     server6_addr.sin6_family = AF_INET6;
 138     server6_addr.sin6_port   = htons(server_port);
 139     server_addr = (struct sockaddr*)&server6_addr;
 140     addr_len    = sizeof(server6_addr);
 141   }
 142   else {
 143     perror("inet_pton()");
 144     exit(1);
 145   }
 146
 147   if((client_fd = socket(AF_INET6, SOCK_STREAM, IPPROTO_SCTP)) == -1)
 148   {
 149      perror("socket");
 150      exit(1);
 151   }
 152
 153   // int sendbuff = 10000;
 154   // socklen_t optlen = sizeof(sendbuff);
 155   // if(getsockopt(client_fd, SOL_SOCKET, SO_SNDBUF, &sendbuff, &optlen) == -1) {
 156   //   perror("getsockopt send");
 157   //   exit(1);
 158   // }
 159   // else
 160   //   LOG_D("[SCTP] send buffer size = %d\n", sendbuff);
 161
 162   //--------------------------------
 163   //Bind before connect
 164   auto optval = 1;
 165   if( setsockopt(client_fd, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof optval) != 0 ){
 166     perror("setsockopt port");
 167     exit(1);
 168   }
 169
 170   if( setsockopt(client_fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval) != 0 ){
 171     perror("setsockopt addr");
 172     exit(1);
 173   }
 174
 175   struct sockaddr_in6  client6_addr {};
 176   client6_addr.sin6_family = AF_INET6;
 177   client6_addr.sin6_port   = htons(RIC_SCTP_SRC_PORT);
 178   client6_addr.sin6_addr   = in6addr_any;
 179
 180   LOG_I("[SCTP] Binding client socket to source port %d", RIC_SCTP_SRC_PORT);
 181   if(bind(client_fd, (struct sockaddr*)&client6_addr, sizeof(client6_addr)) == -1) {
 182     perror("bind");
 183     exit(1);
 184   }
 185   // end binding ---------------------
 186
 187   LOG_I("[SCTP] Connecting to server at %s:%d ...", server_ip_str, server_port);
 188   if(connect(client_fd, server_addr, addr_len) == -1) {
 189     perror("connect");
 190     exit(1);
 191   }
 192   assert(client_fd != 0);
 193
 194   LOG_I("[SCTP] Connection established");
 195
 196   return client_fd;
 197 }
 198
 199 int sctp_accept_connection(const char *server_ip_str, const int server_fd)
 200 {
 201   LOG_I("[SCTP] Waiting for new connection...");
 202
 203   struct sockaddr client_addr;
 204   socklen_t       client_addr_size;
 205   int             client_fd;
 206
 207   //Blocking call
 208   client_fd = accept(server_fd, &client_addr, &client_addr_size);
 209   if(client_fd == -1){
 210     perror("accept()");
 211     close(client_fd);
 212     exit(1);
 213   }
 214
 215   //Retrieve client IP_ADDR
 216   char client_ip6_addr[INET6_ADDRSTRLEN], client_ip4_addr[INET_ADDRSTRLEN];
 217   if(strchr(server_ip_str, ':') != NULL) //IPv6
 218   {
 219     struct sockaddr_in6* client_ipv6 = (struct sockaddr_in6*)&client_addr;
 220     inet_ntop(AF_INET6, &(client_ipv6->sin6_addr), client_ip6_addr, INET6_ADDRSTRLEN);
 221     LOG_I("[SCTP] New client connected from %s", client_ip6_addr);
 222   }
 223   else {
 224     struct sockaddr_in* client_ipv4 = (struct sockaddr_in*)&client_addr;
 225     inet_ntop(AF_INET, &(client_ipv4->sin_addr), client_ip4_addr, INET_ADDRSTRLEN);
 226     LOG_I("[SCTP] New client connected from %s", client_ip4_addr);
 227   }
 228
 229   return client_fd;
 230 }
 231
 232 int sctp_send_data(int &socket_fd, sctp_buffer_t &data)
 233 {
 234   int sent_len = send(socket_fd, (void*)(&(data.buffer[0])), data.len, 0);
 235
 236   if(sent_len == -1) {
 237     perror("[SCTP] sctp_send_data");
 238     exit(1);
 239   }
 240
 241   return sent_len;
 242 }
 243
 244 int sctp_send_data_X2AP(int &socket_fd, sctp_buffer_t &data)
 245 {
 246   int sent_len = sctp_sendmsg(socket_fd, (void*)(&(data.buffer[0])), data.len,
 247                   NULL, 0, (uint32_t) X2AP_PPID, 0, 0, 0, 0);
 248
 249   if(sent_len == -1) {
 250     perror("[SCTP] sctp_send_data");
 251     exit(1);
 252   }
 253
 254 }
 255
 256 /*
 257 Receive data from SCTP socket
 258 Outcome of recv()
 259 -1: exit the program
 260 0: close the connection
 261 +: new data
 262 */
 263 int sctp_receive_data(int &socket_fd, sctp_buffer_t &data)
 264 {
 265   //clear out the data before receiving
 266   memset(data.buffer, 0, sizeof(data.buffer));
 267   data.len = 0;
 268
 269   //receive data from the socket
 270   int recv_len = recv(socket_fd, &(data.buffer), sizeof(data.buffer), 0);
 271   if(recv_len == -1)
 272   {
 273     perror("[SCTP] recv");
 274     exit(1);
 275   }
 276   else if (recv_len == 0)
 277   {
 278     LOG_I("[SCTP] Connection closed by remote peer");
 279     if(close(socket_fd) == -1)
 280     {
 281       perror("[SCTP] close");
 282     }
 283     return -1;
 284   }
 285
 286   data.len = recv_len;
 287
 288   return recv_len;
 289 }