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