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         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  31         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
  32         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
  33 )
  34
  35 var packerif e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer()
  36
  37 type E2ap struct {
  38 }
  39
  40 //-----------------------------------------------------------------------------
  41 //
  42 //-----------------------------------------------------------------------------
  43 func (c *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscriptionRequest, error) {
  44         e2SubReq := packerif.NewPackerSubscriptionRequest()
  45         packedData := &packer.PackedData{}
  46         packedData.Buf = payload
  47         err := e2SubReq.UnPack(packedData)
  48         if err != nil {
  49                 return nil, err
  50         }
  51         err, subReq := e2SubReq.Get()
  52         if err != nil {
  53                 return nil, err
  54         }
  55         return subReq, nil
  56 }
  57
  58 func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (*packer.PackedData, error) {
  59         e2SubReq := packerif.NewPackerSubscriptionRequest()
  60         err := e2SubReq.Set(req)
  61         if err != nil {
  62                 return nil, err
  63         }
  64         err, packedData := e2SubReq.Pack(nil)
  65         if err != nil {
  66                 return nil, err
  67         }
  68         return packedData, nil
  69 }
  70
  71 //-----------------------------------------------------------------------------
  72 //
  73 //-----------------------------------------------------------------------------
  74 func (c *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptionResponse, error) {
  75         e2SubResp := packerif.NewPackerSubscriptionResponse()
  76         packedData := &packer.PackedData{}
  77         packedData.Buf = payload
  78         err := e2SubResp.UnPack(packedData)
  79         if err != nil {
  80                 return nil, err
  81         }
  82         err, subResp := e2SubResp.Get()
  83         if err != nil {
  84                 return nil, err
  85         }
  86         return subResp, nil
  87 }
  88
  89 func (c *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (*packer.PackedData, error) {
  90         e2SubResp := packerif.NewPackerSubscriptionResponse()
  91         err := e2SubResp.Set(req)
  92         if err != nil {
  93                 return nil, err
  94         }
  95         err, packedData := e2SubResp.Pack(nil)
  96         if err != nil {
  97                 return nil, err
  98         }
  99         return packedData, nil
 100 }
 101
 102 //-----------------------------------------------------------------------------
 103 //
 104 //-----------------------------------------------------------------------------
 105 func (c *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscriptionFailure, error) {
 106         e2SubFail := packerif.NewPackerSubscriptionFailure()
 107         packedData := &packer.PackedData{}
 108         packedData.Buf = payload
 109         err := e2SubFail.UnPack(packedData)
 110         if err != nil {
 111                 return nil, err
 112         }
 113         err, subFail := e2SubFail.Get()
 114         if err != nil {
 115                 return nil, err
 116         }
 117         return subFail, nil
 118 }
 119
 120 func (c *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (*packer.PackedData, error) {
 121         e2SubFail := packerif.NewPackerSubscriptionFailure()
 122         err := e2SubFail.Set(req)
 123         if err != nil {
 124                 return nil, err
 125         }
 126         err, packedData := e2SubFail.Pack(nil)
 127         if err != nil {
 128                 return nil, err
 129         }
 130         return packedData, nil
 131 }
 132
 133 //-----------------------------------------------------------------------------
 134 //
 135 //-----------------------------------------------------------------------------
 136 func (c *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscriptionDeleteRequest, error) {
 137         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 138         packedData := &packer.PackedData{}
 139         packedData.Buf = payload
 140         err := e2SubDelReq.UnPack(packedData)
 141         if err != nil {
 142                 return nil, err
 143         }
 144         err, subDelReq := e2SubDelReq.Get()
 145         if err != nil {
 146                 return nil, err
 147         }
 148         return subDelReq, nil
 149 }
 150
 151 func (c *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (*packer.PackedData, error) {
 152         e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest()
 153         err := e2SubDelReq.Set(req)
 154         if err != nil {
 155                 return nil, err
 156         }
 157         err, packedData := e2SubDelReq.Pack(nil)
 158         if err != nil {
 159                 return nil, err
 160         }
 161         return packedData, nil
 162 }
 163
 164 //-----------------------------------------------------------------------------
 165 //
 166 //-----------------------------------------------------------------------------
 167 func (c *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubscriptionDeleteResponse, error) {
 168         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 169         packedData := &packer.PackedData{}
 170         packedData.Buf = payload
 171         err := e2SubDelResp.UnPack(packedData)
 172         if err != nil {
 173                 return nil, err
 174         }
 175         err, subDelResp := e2SubDelResp.Get()
 176         if err != nil {
 177                 return nil, err
 178         }
 179         return subDelResp, nil
 180 }
 181
 182 func (c *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (*packer.PackedData, error) {
 183         e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse()
 184         err := e2SubDelResp.Set(req)
 185         if err != nil {
 186                 return nil, err
 187         }
 188         err, packedData := e2SubDelResp.Pack(nil)
 189         if err != nil {
 190                 return nil, err
 191         }
 192         return packedData, nil
 193 }
 194
 195 //-----------------------------------------------------------------------------
 196 //
 197 //-----------------------------------------------------------------------------
 198 func (c *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscriptionDeleteFailure, error) {
 199         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 200         packedData := &packer.PackedData{}
 201         packedData.Buf = payload
 202         err := e2SubDelFail.UnPack(packedData)
 203         if err != nil {
 204                 return nil, err
 205         }
 206         err, subDelFail := e2SubDelFail.Get()
 207         if err != nil {
 208                 return nil, err
 209         }
 210         return subDelFail, nil
 211 }
 212
 213 func (c *E2ap) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (*packer.PackedData, error) {
 214         e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure()
 215         err := e2SubDelFail.Set(req)
 216         if err != nil {
 217                 return nil, err
 218         }
 219         err, packedData := e2SubDelFail.Pack(nil)
 220         if err != nil {
 221                 return nil, err
 222         }
 223         return packedData, nil
 224 }