de68ec71a7f3654327e1ed79f4c797a0662ea27f
[sim/e2-interface.git] / e2sim / previous / 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 }