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