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         "fmt"
  31         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  32         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
  33         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
  34         "unsafe"
  35 )
  36
  37 var packerif e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
  38
  39 type E2ap struct {
  40 }
  41
  42 /* RICsubscriptionDeleteFailure */
  43
  44 // Used by submgr
  45 func (c *E2ap) GetSubscriptionDeleteFailureSequenceNumber(payload []byte) (subId uint16, err error) {
  46         cptr := unsafe.Pointer(&payload[0])
  47         cret := C.e2ap_get_ric_subscription_delete_failure_sequence_number(cptr, C.size_t(len(payload)))
  48         if cret < 0 {
  49                 return 0, fmt.Errorf("e2ap wrapper is unable to get Subscirption Delete Failure Sequence Number due to wrong or invalid payload. Erroxappde: %v", cret)
  50         }
  51         subId = uint16(cret)
  52         return
  53 }
  54
  55 // Used by submgr
  56 func (c *E2ap) SetSubscriptionDeleteFailureSequenceNumber(payload []byte, newSubscriptionid uint16) (err error) {
  57         cptr := unsafe.Pointer(&payload[0])
  58         size := C.e2ap_set_ric_subscription_delete_failure_sequence_number(cptr, C.size_t(len(payload)), C.long(newSubscriptionid))
  59         if size < 0 {
  60                 return fmt.Errorf("e2ap wrapper is unable to set Subscription Delete Failure Sequence Number due to wrong or invalid payload. Erroxappde: %v", size)
  61         }
  62         return
  63 }
  64
  65 // Used by submgr
  66 func (c *E2ap) PackSubscriptionDeleteResponseFromSubDelReq(payload []byte, newSubscriptionid uint16) (newPayload []byte, err error) {
  67
  68         subDelReq, err := c.UnpackSubscriptionDeleteRequest(payload)
  69         if err != nil {
  70                 return make([]byte, 0), fmt.Errorf("PackSubDelRespFromSubDelReq: SubDelReq unpack failed: %s", err.Error())
  71         }
  72
  73         subDelResp := &e2ap.E2APSubscriptionDeleteResponse{}
  74         subDelResp.RequestId.Id = subDelReq.RequestId.Id
  75         subDelResp.RequestId.Seq = uint32(newSubscriptionid)
  76         subDelResp.FunctionId = subDelReq.FunctionId
  77
  78         packedData, err := c.PackSubscriptionDeleteResponse(subDelResp)
  79         if err != nil {
  80                 return make([]byte, 0), fmt.Errorf("PackSubDelRespFromSubDelReq: SubDelResp pack failed: %s", err.Error())
  81         }
  82         return packedData.Buf, nil
  83 }
  84
  85 //-----------------------------------------------------------------------------
  86 //
  87 //-----------------------------------------------------------------------------
  88 func (c *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscriptionRequest, error) {
  89         e2SubReq := packerif.NewPackerSubscriptionRequest()
  90         packedData := &packer.PackedData{}
  91         packedData.Buf = payload
  92         err := e2SubReq.UnPack(packedData)
  93         if err != nil {
  94                 return nil, err
  95         }
  96         err, subReq := e2SubReq.Get()
  97         if err != nil {
  98                 return nil, err
  99         }
 100         return subReq, nil
 101 }
 102
 103 func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (*packer.PackedData, error) {
 104         e2SubReq := packerif.NewPackerSubscriptionRequest()
 105         err := e2SubReq.Set(req)
 106         if err != nil {
 107                 return nil, err
 108         }
 109         err, packedData := e2SubReq.Pack(nil)
 110         if err != nil {
 111                 return nil, err
 112         }
 113         return packedData, nil
 114 }
 115
 116 //-----------------------------------------------------------------------------
 117 //
 118 //-----------------------------------------------------------------------------
 119 func (c *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
 120         e2SubResp := packerif.NewPackerSubscriptionResponse()
 121         packedData := &packer.PackedData{}
 122         packedData.Buf = payload
 123         err := e2SubResp.UnPack(packedData)
 124         if err != nil {
 125                 return nil, err
 126         }
 127         err, subResp := e2SubResp.Get()
 128         if err != nil {
 129                 return nil, err
 130         }
 131         return subResp, nil
 132 }
 133
 134 func (c *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (*packer.PackedData, error) {
 135         e2SubResp := packerif.NewPackerSubscriptionResponse()
 136         err := e2SubResp.Set(req)
 137         if err != nil {
 138                 return nil, err
 139         }
 140         err, packedData := e2SubResp.Pack(nil)
 141         if err != nil {
 142                 return nil, err
 143         }
 144         return packedData, nil
 145 }
 146
 147 //-----------------------------------------------------------------------------
 148 //
 149 //-----------------------------------------------------------------------------
 150 func (c *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscriptionFailure, error) {
 151         e2SubFail := packerif.NewPackerSubscriptionFailure()
 152         packedData := &packer.PackedData{}
 153         packedData.Buf = payload
 154         err := e2SubFail.UnPack(packedData)
 155         if err != nil {
 156                 return nil, err
 157         }
 158         err, subFail := e2SubFail.Get()
 159         if err != nil {
 160                 return nil, err
 161         }
 162         return subFail, nil
 163 }
 164
 165 func (c *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (*packer.PackedData, error) {
 166         e2SubFail := packerif.NewPackerSubscriptionFailure()
 167         err := e2SubFail.Set(req)
 168         if err != nil {
 169                 return nil, err
 170         }
 171         err, packedData := e2SubFail.Pack(nil)
 172         if err != nil {
 173                 return nil, err
 174         }
 175         return packedData, nil
 176 }
 177
 178 //-----------------------------------------------------------------------------
 179 //
 180 //-----------------------------------------------------------------------------
 181 func (c *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
 182         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 183         packedData := &packer.PackedData{}
 184         packedData.Buf = payload
 185         err := e2SubDelReq.UnPack(packedData)
 186         if err != nil {
 187                 return nil, err
 188         }
 189         err, subDelReq := e2SubDelReq.Get()
 190         if err != nil {
 191                 return nil, err
 192         }
 193         return subDelReq, nil
 194 }
 195
 196 func (c *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (*packer.PackedData, error) {
 197         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 198         err := e2SubDelReq.Set(req)
 199         if err != nil {
 200                 return nil, err
 201         }
 202         err, packedData := e2SubDelReq.Pack(nil)
 203         if err != nil {
 204                 return nil, err
 205         }
 206         return packedData, nil
 207 }
 208
 209 //-----------------------------------------------------------------------------
 210 //
 211 //-----------------------------------------------------------------------------
 212 func (c *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
 213         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 214         packedData := &packer.PackedData{}
 215         packedData.Buf = payload
 216         err := e2SubDelResp.UnPack(packedData)
 217         if err != nil {
 218                 return nil, err
 219         }
 220         err, subDelResp := e2SubDelResp.Get()
 221         if err != nil {
 222                 return nil, err
 223         }
 224         return subDelResp, nil
 225 }
 226
 227 func (c *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (*packer.PackedData, error) {
 228         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 229         err := e2SubDelResp.Set(req)
 230         if err != nil {
 231                 return nil, err
 232         }
 233         err, packedData := e2SubDelResp.Pack(nil)
 234         if err != nil {
 235                 return nil, err
 236         }
 237         return packedData, nil
 238 }