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