RIC-E2-TERMINATION/sctpThread.h

   1 /*
   2  * Copyright 2019 AT&T Intellectual Property
   3  * Copyright 2019 Nokia
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /*
  19  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20  * platform project (RICP).
  21  */
  22
  23
  24 #ifndef X2_SCTP_THREAD_H
  25 #define X2_SCTP_THREAD_H
  26
  27 #include <algorithm>
  28
  29 #include <cstdio>
  30 #include <cerrno>
  31 #include <cstdlib>
  32 #include <cstring>
  33 #include <random>
  34 #include <sys/socket.h>
  35 #include <arpa/inet.h>
  36 #include <netinet/in_systm.h>
  37 #include <netinet/in.h>
  38 #include <netinet/ip.h>
  39 #include <netinet/ip_icmp.h>
  40 #include <netinet/sctp.h>
  41 #include <thread>
  42 #include <atomic>
  43 #include <sys/param.h>
  44 #include <sys/file.h>
  45 #include <ctime>
  46 #include <netdb.h>
  47 #include <sys/epoll.h>
  48 #include <mutex>
  49 #include <shared_mutex>
  50 #include <iterator>
  51 #include <map>
  52
  53 #include <rmr/rmr.h>
  54 #include <rmr/RIC_message_types.h>
  55 #include <mdclog/mdclog.h>
  56 #include <functional>
  57 #include <iostream>
  58
  59 #include <boost/algorithm/string/predicate.hpp>
  60 #include <boost/lexical_cast.hpp>
  61 #include <boost/move/utility.hpp>
  62 #include <boost/log/sources/logger.hpp>
  63 #include <boost/log/sources/record_ostream.hpp>
  64 #include <boost/log/sources/global_logger_storage.hpp>
  65 #include <boost/log/utility/setup/file.hpp>
  66 #include <boost/log/utility/setup/common_attributes.hpp>
  67
  68
  69 #include <mdclog/mdclog.h>
  70
  71 #include "3rdparty/asn1cFiles/E2AP-PDU.h"
  72 #include <3rdparty/asn1cFiles/ProtocolIE-Container.h>
  73 #include "3rdparty/asn1cFiles/InitiatingMessage.h"
  74 #include "3rdparty/asn1cFiles/SuccessfulOutcome.h"
  75 #include "3rdparty/asn1cFiles/UnsuccessfulOutcome.h"
  76 #include "3rdparty/asn1cFiles/ProtocolIE-Container.h"
  77 #include "3rdparty/asn1cFiles/ProtocolIE-Field.h"
  78
  79 #ifdef __TRACING__
  80 #include "openTracing.h"
  81 #endif
  82
  83 #include "mapWrapper.h"
  84
  85 #include "base64.h"
  86
  87 using namespace std;
  88 namespace logging = boost::log;
  89 namespace src = boost::log::sources;
  90 namespace keywords = boost::log::keywords;
  91 namespace sinks = boost::log::sinks;
  92 namespace posix_time = boost::posix_time;
  93 namespace expr = boost::log::expressions;
  94
  95 #define SRC_PORT 36422
  96 #define SA      struct sockaddr
  97 #define MAX_ENODB_NAME_SIZE 64
  98
  99 #define MAXEVENTS 128
 100
 101 #define RECEIVE_SCTP_BUFFER_SIZE (64*1024)
 102 #define RECEIVE_XAPP_BUFFER_SIZE RECEIVE_SCTP_BUFFER_SIZE
 103
 104 typedef mapWrapper Sctp_Map_t;
 105
 106 #ifdef __TRACING__
 107 typedef const std::unique_ptr<opentracing::Span> otSpan;
 108 #else
 109 typedef const int otSpan;
 110 #endif
 111
 112 #define VOLUME_URL_SIZE 256
 113
 114 typedef struct sctp_params {
 115     uint16_t rmrPort = 0;
 116     int      epoll_fd = 0;
 117     int      rmrListenFd = 0;
 118     void     *rmrCtx = nullptr;
 119     Sctp_Map_t *sctpMap = nullptr;
 120     char       rmrAddress[256] {}; // "tcp:portnumber" "tcp:5566" listen to all address on port 5566
 121     mdclog_severity_t logLevel = MDCLOG_INFO;
 122     char volume[VOLUME_URL_SIZE];
 123     //shared_timed_mutex fence; // moved to mapWrapper
 124 } sctp_params_t;
 125
 126 typedef struct ConnectedCU {
 127     int fileDescriptor = 0;
 128     char hostName[NI_MAXHOST] {};
 129     char portNumber[NI_MAXSERV] {};
 130     char enodbName[MAX_ENODB_NAME_SIZE] {};
 131     char asnData[RECEIVE_SCTP_BUFFER_SIZE] {};
 132     size_t asnLength = 0;
 133     int mtype = 0;
 134     bool isConnected = false;
 135 } ConnectedCU_t ;
 136
 137 #define MAX_RMR_BUFF_ARRY 32
 138 typedef struct RmrMessagesBuffer {
 139     void *rmrCtx;
 140     rmr_mbuf_t *sendMessage;
 141     rmr_mbuf_t *sendBufferedMessages[MAX_RMR_BUFF_ARRY];
 142     rmr_mbuf_t *rcvMessage;
 143     rmr_mbuf_t *rcvBufferedMessages[MAX_RMR_BUFF_ARRY];
 144 } RmrMessagesBuffer_t;
 145
 146 typedef struct formatedMessage {
 147     char enodbName[MAX_ENODB_NAME_SIZE];
 148     struct timespec time;
 149     int messageType;
 150     char direction;
 151     ssize_t asnLength;
 152     unsigned char *asndata;
 153 } FormatedMessage_t;
 154
 155 typedef struct ReportingMessages {
 156     FormatedMessage_t message;
 157     int outLen;
 158     unsigned char base64Data[RECEIVE_SCTP_BUFFER_SIZE * 2];
 159     char buffer[RECEIVE_SCTP_BUFFER_SIZE * 8];
 160     size_t bufferLen;
 161 } ReportingMessages_t;
 162
 163
 164 void listener(sctp_params_t *params);
 165
 166 int setSocketNoBlocking(int socket);
 167
 168 void cleanHashEntry(ConnectedCU_t *peerInfo, Sctp_Map_t *m, otSpan *pSpan);
 169
 170 int getSetupRequestMetaData(ReportingMessages_t &message, char *data, char *host, uint16_t &port, otSpan *pSpan);
 171
 172 /**
 173  *
 174  * @param message
 175  * @param rmrMessageBuffer
 176  * @param pSpan
 177  */
 178 void getRequestMetaData(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, otSpan *pSpan);
 179
 180 /**
 181  *
 182  * @param sctpMap
 183  * @param messagBuffer
 184  * @param message
 185  * @param failedMesgId
 186  * @param pSpan
 187  * @return
 188  */
 189 int sendMessagetoCu(Sctp_Map_t *sctpMap,
 190                     RmrMessagesBuffer_t &messagBuffer,
 191                     ReportingMessages_t &message,
 192                     int failedMesgId, otSpan *pSpan);
 193
 194 void sendFailedSendingMessagetoXapp(RmrMessagesBuffer_t &rmrMessageBuffer,
 195                                     ReportingMessages_t &message,
 196                                     int failedMesgId,
 197                                     otSpan *pSpan);
 198
 199 int sendRequestToXapp(ReportingMessages_t &message,
 200                       int requestId,
 201                       RmrMessagesBuffer_t &rmrMmessageBuffer,
 202                       otSpan *pSpan);
 203
 204 /**
 205  *
 206  * @param message
 207  * @param msgType
 208  * @param requestType
 209  * @param rmrMessageBuffer
 210  * @param sctpMap
 211  * @param pSpan
 212  * @return
 213  */
 214 int sendResponseToXapp(ReportingMessages_t &message,
 215                        int msgType,
 216                        int requestType,
 217                        RmrMessagesBuffer_t &rmrMessageBuffer,
 218                        Sctp_Map_t *sctpMap,
 219                        otSpan *pSpan);
 220
 221 /**
 222  *
 223  * @param peerInfo
 224  * @param message
 225  * @param m
 226  * @param pSpan
 227  * @return
 228  */
 229 int sendSctpMsg(ConnectedCU_t *peerInfo,
 230                 ReportingMessages_t &message,
 231                 Sctp_Map_t *m,
 232                 otSpan *pSpan);
 233
 234 /**
 235  *
 236  * @param events
 237  * @param sctpMap
 238  * @param numOfMessages
 239  * @param rmrMessageBuffer
 240  * @param ts
 241  * @param pSpan
 242  * @return
 243  */
 244 int receiveDataFromSctp(struct epoll_event *events,
 245                         Sctp_Map_t *sctpMap,
 246                         int &numOfMessages,
 247                         RmrMessagesBuffer_t &rmrMessageBuffer,
 248                         struct timespec &ts,
 249                         otSpan *pSpan);
 250
 251 /**
 252  *
 253  * @param rmrAddress
 254  * @param pSpan
 255  * @return
 256  */
 257 void *getRmrContext(char *rmrAddress, otSpan *pSpan);
 258
 259 /**
 260  *
 261  * @param epoll_fd
 262  * @param rmrCtx
 263  * @param sctpMap
 264  * @param messagBuffer
 265  * @param pSpan
 266  * @return
 267  */
 268 int receiveXappMessages(int epoll_fd,
 269                         Sctp_Map_t *sctpMap,
 270                         RmrMessagesBuffer_t &rmrMessageBuffer,
 271                         struct timespec &ts,
 272                         otSpan *pSpan);
 273
 274 /**
 275  *
 276  * @param rmrMessageBuffer
 277  * @param message
 278  * @param epoll_fd
 279  * @param sctpMap
 280  * @param pSpan
 281  * @return
 282  */
 283 int connectToCUandSetUp(RmrMessagesBuffer_t &rmrMessageBuffer,
 284                            ReportingMessages_t &message,
 285                            int epoll_fd,
 286                            Sctp_Map_t *sctpMap,
 287                            otSpan *pSpan);
 288
 289 /**
 290  *
 291  * @param messagBuffer
 292  * @param failedMsgId
 293  * @param sctpMap
 294  * @param pSpan
 295  * @return
 296  */
 297 int sendDirectionalSctpMsg(RmrMessagesBuffer_t &messagBuffer,
 298                            ReportingMessages_t &message,
 299                            int failedMsgId,
 300                            Sctp_Map_t *sctpMap,
 301                            otSpan *pSpan);
 302 /**
 303  *
 304  * @param pdu
 305  * @param message
 306  * @param rmrMessageBuffer
 307  * @param pSpan
 308  */
 309 void asnInitiatingRequest(E2AP_PDU_t *pdu,
 310                           ReportingMessages_t &message,
 311                           RmrMessagesBuffer_t &rmrMessageBuffer,
 312                           otSpan *pSpan);
 313 /**
 314  *
 315  * @param pdu
 316  * @param message
 317  * @param sctpMap
 318  * @param rmrMessageBuffer
 319  * @param pSpan
 320  */
 321 void asnSuccsesfulMsg(E2AP_PDU_t *pdu,
 322                       ReportingMessages_t &message,
 323                       Sctp_Map_t *sctpMap,
 324                       RmrMessagesBuffer_t &rmrMessageBuffer,
 325                       otSpan *pSpan);
 326 /**
 327  *
 328  * @param pdu
 329  * @param message
 330  * @param sctpMap
 331  * @param rmrMessageBuffer
 332  * @param pSpan
 333  */
 334 void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu,
 335                         ReportingMessages_t &message,
 336                         Sctp_Map_t *sctpMap,
 337                         RmrMessagesBuffer_t &rmrMessageBuffer,
 338                         otSpan *pSpan);
 339
 340 /**
 341  *
 342  * @param rmrMessageBuffer
 343  * @param message
 344  * @param pSpan
 345  * @return
 346  */
 347 int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &message, otSpan *pSpan);
 348
 349 /**
 350  *
 351  * @param epoll_fd
 352  * @param peerInfo
 353  * @param events
 354  * @param sctpMap
 355  * @param enodbName
 356  * @param msgType
 357  * @param pSpan
 358  * @returnsrc::logger_mt& lg = my_logger::get();
 359  */
 360 int addToEpoll(int epoll_fd, ConnectedCU_t *peerInfo, uint32_t events, Sctp_Map_t *sctpMap, char *enodbName, int msgType, otSpan *pSpan);
 361 /**
 362  *
 363  * @param epoll_fd
 364  * @param peerInfo
 365  * @param events
 366  * @param sctpMap
 367  * @param enodbName
 368  * @param msgType
 369  * @param pSpan
 370  * @return
 371  */
 372 int modifyToEpoll(int epoll_fd, ConnectedCU_t *peerInfo, uint32_t events, Sctp_Map_t *sctpMap, char *enodbName, int msgType, otSpan *pSpan);
 373
 374 /**
 375  *
 376  * @param message
 377  */
 378 void buildJsonMessage(ReportingMessages_t &message);
 379
 380 /**
 381  *
 382  *
 383  * @param state
 384  * @return
 385  */
 386 string translateRmrErrorMessages(int state);
 387
 388 #ifndef RIC_SCTP_CONNECTION_FAILURE
 389 #define RIC_SCTP_CONNECTION_FAILURE  10080
 390 #endif
 391
 392 #endif //X2_SCTP_THREAD_H