pkg/control/e2ap.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 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
  20 package control
  21
  22 /*
  23 #include <wrapper.h>
  24
  25 #cgo LDFLAGS: -le2ap_wrapper -le2ap
  26 */
  27 import "C"
  28
  29 import (
  30         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  31         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
  32         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
  33         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  34 )
  35
  36 var packerif e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
  37
  38 type E2ap struct {
  39 }
  40
  41 //-----------------------------------------------------------------------------
  42 //
  43 //-----------------------------------------------------------------------------
  44 func (c *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscriptionRequest, error) {
  45         e2SubReq := packerif.NewPackerSubscriptionRequest()
  46         packedData := &packer.PackedData{}
  47         packedData.Buf = payload
  48         err := e2SubReq.UnPack(packedData)
  49         if err != nil {
  50                 return nil, err
  51         }
  52         err, subReq := e2SubReq.Get()
  53         if err != nil {
  54                 return nil, err
  55         }
  56         return subReq, nil
  57 }
  58
  59 func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (int, *packer.PackedData, error) {
  60         e2SubReq := packerif.NewPackerSubscriptionRequest()
  61         err := e2SubReq.Set(req)
  62         if err != nil {
  63                 return 0, nil, err
  64         }
  65         err, packedData := e2SubReq.Pack(nil)
  66         if err != nil {
  67                 return 0, nil, err
  68         }
  69         return xapp.RIC_SUB_REQ, packedData, nil
  70 }
  71
  72 //-----------------------------------------------------------------------------
  73 //
  74 //-----------------------------------------------------------------------------
  75 func (c *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
  76         e2SubResp := packerif.NewPackerSubscriptionResponse()
  77         packedData := &packer.PackedData{}
  78         packedData.Buf = payload
  79         err := e2SubResp.UnPack(packedData)
  80         if err != nil {
  81                 return nil, err
  82         }
  83         err, subResp := e2SubResp.Get()
  84         if err != nil {
  85                 return nil, err
  86         }
  87         return subResp, nil
  88 }
  89
  90 func (c *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (int, *packer.PackedData, error) {
  91         e2SubResp := packerif.NewPackerSubscriptionResponse()
  92         err := e2SubResp.Set(req)
  93         if err != nil {
  94                 return 0, nil, err
  95         }
  96         err, packedData := e2SubResp.Pack(nil)
  97         if err != nil {
  98                 return 0, nil, err
  99         }
 100         return xapp.RIC_SUB_RESP, packedData, nil
 101 }
 102
 103 //-----------------------------------------------------------------------------
 104 //
 105 //-----------------------------------------------------------------------------
 106 func (c *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscriptionFailure, error) {
 107         e2SubFail := packerif.NewPackerSubscriptionFailure()
 108         packedData := &packer.PackedData{}
 109         packedData.Buf = payload
 110         err := e2SubFail.UnPack(packedData)
 111         if err != nil {
 112                 return nil, err
 113         }
 114         err, subFail := e2SubFail.Get()
 115         if err != nil {
 116                 return nil, err
 117         }
 118         return subFail, nil
 119 }
 120
 121 func (c *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (int, *packer.PackedData, error) {
 122         e2SubFail := packerif.NewPackerSubscriptionFailure()
 123         err := e2SubFail.Set(req)
 124         if err != nil {
 125                 return 0, nil, err
 126         }
 127         err, packedData := e2SubFail.Pack(nil)
 128         if err != nil {
 129                 return 0, nil, err
 130         }
 131         return xapp.RIC_SUB_FAILURE, packedData, nil
 132 }
 133
 134 //-----------------------------------------------------------------------------
 135 //
 136 //-----------------------------------------------------------------------------
 137 func (c *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
 138         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 139         packedData := &packer.PackedData{}
 140         packedData.Buf = payload
 141         err := e2SubDelReq.UnPack(packedData)
 142         if err != nil {
 143                 return nil, err
 144         }
 145         err, subDelReq := e2SubDelReq.Get()
 146         if err != nil {
 147                 return nil, err
 148         }
 149         return subDelReq, nil
 150 }
 151
 152 func (c *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (int, *packer.PackedData, error) {
 153         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 154         err := e2SubDelReq.Set(req)
 155         if err != nil {
 156                 return 0, nil, err
 157         }
 158         err, packedData := e2SubDelReq.Pack(nil)
 159         if err != nil {
 160                 return 0, nil, err
 161         }
 162         return xapp.RIC_SUB_DEL_REQ, packedData, nil
 163 }
 164
 165 //-----------------------------------------------------------------------------
 166 //
 167 //-----------------------------------------------------------------------------
 168 func (c *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
 169         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 170         packedData := &packer.PackedData{}
 171         packedData.Buf = payload
 172         err := e2SubDelResp.UnPack(packedData)
 173         if err != nil {
 174                 return nil, err
 175         }
 176         err, subDelResp := e2SubDelResp.Get()
 177         if err != nil {
 178                 return nil, err
 179         }
 180         return subDelResp, nil
 181 }
 182
 183 func (c *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (int, *packer.PackedData, error) {
 184         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 185         err := e2SubDelResp.Set(req)
 186         if err != nil {
 187                 return 0, nil, err
 188         }
 189         err, packedData := e2SubDelResp.Pack(nil)
 190         if err != nil {
 191                 return 0, nil, err
 192         }
 193         return xapp.RIC_SUB_DEL_RESP, packedData, nil
 194 }
 195
 196 //-----------------------------------------------------------------------------
 197 //
 198 //-----------------------------------------------------------------------------
 199 func (c *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscriptionDeleteFailure, error) {
 200         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 201         packedData := &packer.PackedData{}
 202         packedData.Buf = payload
 203         err := e2SubDelFail.UnPack(packedData)
 204         if err != nil {
 205                 return nil, err
 206         }
 207         err, subDelFail := e2SubDelFail.Get()
 208         if err != nil {
 209                 return nil, err
 210         }
 211         return subDelFail, nil
 212 }
 213
 214 func (c *E2ap) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (int, *packer.PackedData, error) {
 215         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 216         err := e2SubDelFail.Set(req)
 217         if err != nil {
 218                 return 0, nil, err
 219         }
 220         err, packedData := e2SubDelFail.Pack(nil)
 221         if err != nil {
 222                 return 0, nil, err
 223         }
 224         return xapp.RIC_SUB_DEL_FAILURE, packedData, nil
 225 }