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