src/cm/legtp.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   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 file contains DU APP and EGTP interface functions */
  20
  21 #include "du_egtp.h"
  22 #include "legtp.h"
  23
  24 /*******************************************************************
  25  *
  26  * @brief Packs EGTP confirm status
  27  *
  28  * @details
  29  *
  30  *    Function : packEgtpCfmStatus
  31  *
  32  *    Functionality:
  33  *       Packs EGTP confirm status
  34  *
  35  * @params[in] Confirm status
  36  *             Message buffer
  37  * @return ROK     - success
  38  *         RFAILED - failure
  39  *
  40  ******************************************************************/
  41 S16 packEgtpCfmStatus(CmStatus cfm, Buffer *mBuf)
  42 {
  43    SPkU16(cfm.status, mBuf);
  44    SPkU16(cfm.reason, mBuf);
  45
  46    RETVALUE(ROK);
  47 }
  48
  49 /*******************************************************************
  50  *
  51  * @brief Unpacks EGTP confirm status
  52  *
  53  * @details
  54  *
  55  *    Function : unpackEgtpCfmStatus
  56  *
  57  *    Functionality:
  58  *       Packs EGTP confirm status
  59  *
  60  * @params[in] Confirm status
  61  *             Message buffer
  62  * @return ROK     - success
  63  *         RFAILED - failure
  64  *
  65  ******************************************************************/
  66
  67 S16 unpackEgtpCfmStatus(CmStatus *cfm, Buffer *mBuf)
  68 {
  69    SUnpkU16(&(cfm->reason), mBuf);
  70    SUnpkU16(&(cfm->status), mBuf);
  71
  72    RETVALUE(ROK);
  73 }
  74
  75 /*******************************************************************
  76  *
  77  * @brief Packs EGTP configuration
  78  *
  79  * @details
  80  *
  81  *    Function : packEgtpCfgReq
  82  *
  83  *    Functionality:
  84  *       Packs EGTP configuration
  85  *
  86  * @params[in] Post structure
  87  *             EGTP configuration
  88  * @return ROK     - success
  89  *         RFAILED - failure
  90  *
  91  ******************************************************************/
  92 S16 packEgtpCfgReq(Pst *pst, EgtpConfig egtpCfg)
  93 {
  94    Buffer *mBuf;
  95
  96    if(SGetMsg(DFLT_REGION, DU_POOL, &mBuf) != ROK)
  97    {
  98       printf("\nDU_APP : Failed to allocate memory");
  99       RETVALUE(RFAILED);
 100    }
 101    if(egtpCfg.localIp.ipV4Pres)
 102    {
 103       SPkU32(egtpCfg.localIp.ipV4Addr, mBuf);
 104    }
 105    cmPkBool(egtpCfg.localIp.ipV4Pres, mBuf);
 106    SPkU16(egtpCfg.localPort, mBuf);
 107
 108    if(egtpCfg.destIp.ipV4Pres)
 109    {
 110       SPkU32(egtpCfg.destIp.ipV4Addr, mBuf);
 111    }
 112    cmPkBool(egtpCfg.destIp.ipV4Pres, mBuf);
 113    SPkU16(egtpCfg.destPort, mBuf);
 114
 115    SPkU32(egtpCfg.minTunnelId, mBuf);
 116    SPkU32(egtpCfg.maxTunnelId, mBuf);
 117
 118    SPstTsk(pst, mBuf);
 119
 120    RETVALUE(ROK);
 121 }
 122
 123 /*******************************************************************
 124  *
 125  * @brief Unpacks EGTP configuration
 126  *
 127  * @details
 128  *
 129  *    Function : unpackEgtpCfgReq
 130  *
 131  *    Functionality:
 132  *       Unpacks EGTP configuration
 133  *
 134  * @params[in] Configuration Request handler
 135  *             Post structure
 136  *             Message Buffer
 137  * @return ROK     - success
 138  *         RFAILED - failure
 139  *
 140  * ****************************************************************/
 141 S16 unpackEgtpCfgReq(EgtpCfgReq func, Pst *pst, Buffer *mBuf)
 142 {
 143    EgtpConfig egtpCfg;
 144
 145    cmMemset((U8 *)&egtpCfg, 0, sizeof(EgtpConfig));
 146
 147    SUnpkU32(&(egtpCfg.maxTunnelId), mBuf);
 148    SUnpkU32(&(egtpCfg.minTunnelId), mBuf);
 149
 150    SUnpkU16(&(egtpCfg.destPort), mBuf);
 151    cmUnpkBool(&(egtpCfg.destIp.ipV4Pres), mBuf);
 152    if(egtpCfg.destIp.ipV4Pres)
 153    {
 154       SUnpkU32(&(egtpCfg.destIp.ipV4Addr), mBuf);
 155    }
 156
 157    SUnpkU16(&(egtpCfg.localPort), mBuf);
 158    cmUnpkBool(&(egtpCfg.localIp.ipV4Pres), mBuf);
 159    if(egtpCfg.localIp.ipV4Pres)
 160    {
 161       SUnpkU32(&(egtpCfg.localIp.ipV4Addr), mBuf);
 162    }
 163
 164    SPutMsg(mBuf);
 165
 166    RETVALUE((*func)(pst, egtpCfg));
 167 }
 168
 169
 170 /*******************************************************************
 171  *
 172  * @brief Packs EGTP configuration results
 173  *
 174  * @details
 175  *
 176  *    Function : packEgtpCfgCfm
 177  *
 178  *    Functionality:
 179  *       Packs EGTP configuration result
 180  *
 181  * @params[in] Post structure
 182  *             Status confirm
 183  * @return ROK     - success
 184  *         RFAILED - failure
 185  *
 186  ******************************************************************/
 187
 188 S16 packEgtpCfgCfm(Pst *pst, CmStatus cfm)
 189 {
 190    Buffer *mBuf;
 191
 192    if(SGetMsg(DFLT_REGION, DU_POOL, &mBuf) != ROK)
 193    {
 194       printf("\nEGTP : Failed to allocate memory");
 195       RETVALUE(RFAILED);
 196    }
 197
 198    packEgtpCfmStatus(cfm, mBuf);
 199    SPstTsk(pst, mBuf);
 200    RETVALUE(ROK);
 201 }
 202
 203 /*******************************************************************
 204  *
 205  * @brief Unpacks EGTP configuration results
 206  *
 207  * @details
 208  *
 209  *    Function : unpackEgtpCfgCfm
 210  *
 211  *    Functionality:
 212  *       Unpacks EGTP configuration result
 213  *
 214  * @params[in] Config Cfm Hanlder
 215  *             Message buffer
 216  * @return ROK     - success
 217  *         RFAILED - failure
 218  *
 219  ******************************************************************/
 220
 221 S16 unpackEgtpCfgCfm(EgtpCfgCfm func, Buffer *mBuf)
 222 {
 223    CmStatus cfm;
 224
 225    cmMemset((U8 *)&cfm, 0, sizeof(CmStatus));
 226    unpackEgtpCfmStatus(&cfm, mBuf);
 227
 228    RETVALUE((*func)(cfm));
 229 }
 230
 231 /*******************************************************************
 232  *
 233  * @brief Packs EGTP server open request
 234  *
 235  * @details
 236  *
 237  *    Function : packEgtpSrvOpenReq
 238  *
 239  *    Functionality:
 240  *       Packs EGTP server open request
 241  *
 242  * @params[in] Post structure
 243  * @return ROK     - success
 244  *         RFAILED - failure
 245  *
 246   *******************************************************************/
 247 S16 packEgtpSrvOpenReq(Pst *pst)
 248 {
 249    Buffer *mBuf;
 250
 251    if(SGetMsg(DFLT_REGION, DU_POOL, &mBuf) != ROK)
 252    {
 253       printf("\nDU_APP : Failed to allocate memory");
 254       RETVALUE(RFAILED);
 255    }
 256
 257    SPstTsk(pst, mBuf);
 258    RETVALUE(ROK);
 259 }
 260
 261 /*******************************************************************
 262  *
 263  * @brief Unpacks EGTP server open req
 264  *
 265  * @details
 266  *
 267  *    Function : unpackEgtpSrvOpenReq
 268  *
 269  *    Functionality:
 270  *       Unpacks EGTP server open req
 271  *
 272  * @params[in] Hanlder function pointer
 273  *             Message buffer
 274  * @return ROK     - success
 275  *         RFAILED - failure
 276  *
 277  ******************************************************************/
 278 S16 unpackEgtpSrvOpenReq(EgtpSrvOpenReq func, Pst *pst, Buffer *mBuf)
 279 {
 280     RETVALUE((*func)(pst));
 281 }
 282
 283
 284 /*******************************************************************
 285  *
 286  * @brief Packs EGTP server open confirm
 287  *
 288  * @details
 289  *
 290  *    Function : packEgtpSrvOpenCfm
 291  *
 292  *    Functionality:
 293  *       Packs EGTP server open confirm
 294  *
 295  * @params[in] Post structure
 296  * @return ROK     - success
 297  *         RFAILED - failure
 298  *
 299  *******************************************************************/
 300 S16 packEgtpSrvOpenCfm(Pst *pst, CmStatus cfm)
 301 {
 302    Buffer *mBuf;
 303
 304    if(SGetMsg(DFLT_REGION, DU_POOL, &mBuf) != ROK)
 305    {
 306       printf("\nEGTP : Failed to allocate memory");
 307       RETVALUE(RFAILED);
 308    }
 309
 310    packEgtpCfmStatus(cfm, mBuf);
 311    SPstTsk(pst, mBuf);
 312    RETVALUE(ROK);
 313
 314 }
 315
 316 /*******************************************************************
 317  *
 318  * @brief Unpacks EGTP server open confirm
 319  *
 320  * @details
 321  *
 322  *    Function : unpackEgtpSrvOpenCfm
 323  *
 324  *    Functionality:
 325  *       Unpacks EGTP server open confirm
 326  *
 327  * @params[in] Hanlder function pointer
 328  *             Message buffer
 329  * @return ROK     - success
 330  *         RFAILED - failure
 331  *
 332  *******************************************************************/
 333 S16 unpackEgtpSrvOpenCfm(EgtpSrvOpenCfm func, Buffer *mBuf)
 334 {
 335    CmStatus cfm;
 336
 337    cmMemset((U8 *)&cfm, 0, sizeof(CmStatus));
 338    unpackEgtpCfmStatus(&cfm, mBuf);
 339
 340    RETVALUE((*func)(cfm));
 341 }
 342
 343 /*******************************************************************
 344  *
 345  * @brief Packs EGTP tunnel management request
 346  *
 347  * @details
 348  *
 349  *    Function : packEgtpTnlMgmtReq
 350  *
 351  *    Functionality:
 352  *       Packs EGTP tunnel management request
 353  *
 354  * @params[in] Post structure
 355  *             Tunnel action
 356  *             Local tunnel endpoint id
 357  *             Remote tunnel endpoint id
 358  * @return ROK     - success
 359  *         RFAILED - failure
 360  *
 361  *******************************************************************/
 362 S16 packEgtpTnlMgmtReq(Pst *pst, EgtpTnlEvt tnlEvt)
 363 {
 364    Buffer *mBuf;
 365
 366    if(SGetMsg(DFLT_REGION, DU_POOL, &mBuf) != ROK)
 367    {
 368       printf("\nDU_APP : Failed to allocate memory");
 369       RETVALUE(RFAILED);
 370    }
 371
 372    SPkU8(tnlEvt.action, mBuf);
 373    SPkU32(tnlEvt.lclTeid, mBuf);
 374    SPkU32(tnlEvt.remTeid, mBuf);
 375
 376    SPstTsk(pst, mBuf);
 377    RETVALUE(ROK);
 378 }
 379
 380
 381 /*******************************************************************
 382  *
 383  * @brief Unpacks EGTP tunnel management request
 384  *
 385  * @details
 386  *
 387  *    Function : unpackEgtpTnlMgmtReq
 388  *
 389  *    Functionality:
 390  *       Unpacks EGTP tunnel management request
 391  *
 392  * @params[in] Hanlder function pointer
 393  *             Post structure
 394  *             Message buffer
 395  * @return ROK     - success
 396  *         RFAILED - failure
 397  *
 398  * *******************************************************************/
 399 S16 unpackEgtpTnlMgmtReq(EgtpTnlMgmtReq func, Pst *pst, Buffer *mBuf)
 400 {
 401    EgtpTnlEvt tnlEvt;
 402
 403    cmMemset((U8 *)&tnlEvt, 0, sizeof(EgtpTnlEvt));
 404
 405    SUnpkU32(&(tnlEvt.remTeid), mBuf);
 406    SUnpkU32(&(tnlEvt.lclTeid), mBuf);
 407    SUnpkU8(&(tnlEvt.action), mBuf);
 408
 409    RETVALUE((* func)(pst, tnlEvt));
 410
 411 }
 412
 413 /*******************************************************************
 414  *
 415  * @brief Packs EGTP tunnel management confirm
 416  *
 417  * @details
 418  *
 419  *    Function : packEgtpTnlMgmtCfm
 420  *
 421  *    Functionality:
 422  *      Packs EGTP tunnel management cfm
 423  *
 424  * @params[in] Post structure
 425  *             Tunnel Event structure
 426  *
 427  * @return ROK     - success
 428  *         RFAILED - failure
 429  *
 430  ********************************************************************/
 431
 432 S16 packEgtpTnlMgmtCfm(Pst *pst, EgtpTnlEvt tnlEvt)
 433 {
 434    Buffer *mBuf;
 435
 436    if(SGetMsg(DFLT_REGION, DU_POOL, &mBuf) != ROK)
 437    {
 438       printf("\nEGTP : Failed to allocate memory");
 439       RETVALUE(RFAILED);
 440    }
 441
 442    SPkU8(tnlEvt.action, mBuf);
 443    SPkU32(tnlEvt.lclTeid, mBuf);
 444    SPkU32(tnlEvt.remTeid, mBuf);
 445
 446    packEgtpCfmStatus(tnlEvt.cfmStatus, mBuf);
 447
 448    SPstTsk(pst, mBuf);
 449    RETVALUE(ROK);
 450
 451 }
 452
 453 /*******************************************************************
 454  *
 455  * @brief Unpacks EGTP tunnel management confirm
 456  *
 457  * @details
 458  *
 459  *    Function : unpackEgtpTnlMgmtCfm
 460  *
 461  *    Functionality:
 462  *       Unpacks EGTP tunnel management confirm
 463  *
 464  * @params[in] Hanlder function pointer
 465  *             Post structure
 466  *             Message buffer
 467  * @return ROK     - success
 468  *         RFAILED - failure
 469  *
 470  * *******************************************************************/
 471 S16 unpackEgtpTnlMgmtCfm(EgtpTnlMgmtCfm func, Buffer *mBuf)
 472 {
 473    EgtpTnlEvt tnlEvt;
 474
 475    cmMemset((U8 *)&tnlEvt, 0, sizeof(EgtpTnlEvt));
 476
 477    unpackEgtpCfmStatus(&(tnlEvt.cfmStatus), mBuf);
 478    SUnpkU32(&(tnlEvt.remTeid), mBuf);
 479    SUnpkU32(&(tnlEvt.lclTeid), mBuf);
 480    SUnpkU8(&(tnlEvt.action), mBuf);
 481
 482    RETVALUE((* func)(tnlEvt));
 483
 484 }
 485
 486 /*******************************************************************
 487  *
 488  * @brief Packs Slot indication and sends to EGTP
 489  *
 490  * @details
 491  *
 492  *    Function : packEgtpSlotInd
 493  *
 494  *    Functionality:
 495  *       Packs slot indication and sends tp EGTP
 496  *
 497  * @params[in] Post structure
 498  * @return ROK     - success
 499  *         RFAILED - failure
 500  *
 501  *******************************************************************/
 502 S16 packEgtpSlotInd(Pst *pst)
 503 {
 504    Buffer *mBuf;
 505
 506    if(SGetMsg(DFLT_REGION, DU_POOL, &mBuf) != ROK)
 507    {
 508       printf("\nDU_APP : Failed to allocate memory");
 509       RETVALUE(RFAILED);
 510    }
 511
 512    SPstTsk(pst, mBuf);
 513    RETVALUE(ROK);
 514
 515 }
 516
 517 /*******************************************************************
 518  *
 519  * @brief Unpacks slot indication
 520  *
 521  * @details
 522  *
 523  *    Function : unpackEgtpSlotInd
 524  *
 525  *    Functionality:
 526  *       Unpacks slot indication
 527  *
 528  * @params[in]
 529  * @return ROK     - success
 530  *         RFAILED - failure
 531  *
 532 ******************************************************************/
 533 S16 unpackEgtpSlotInd(EgtpSlotInd func, Pst *pst, Buffer *mBuf)
 534 {
 535     RETVALUE((*func)());
 536 }