e2ap/pkg/e2ap/e2ap_packerif.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 e2ap
  21
  22 import (
  23         "fmt"
  24         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
  25 )
  26
  27 //-----------------------------------------------------------------------------
  28 //
  29 //-----------------------------------------------------------------------------
  30 type E2APMsgPackerIf interface {
  31         Pack(*packer.PackedData) (error, *packer.PackedData)
  32         UnPack(msg *packer.PackedData) error
  33         String() string
  34 }
  35
  36 //-----------------------------------------------------------------------------
  37 //
  38 //-----------------------------------------------------------------------------
  39 type E2APMsgPackerSubscriptionRequestIf interface {
  40         E2APMsgPackerIf
  41         Set(*E2APSubscriptionRequest) error
  42         Get() (error, *E2APSubscriptionRequest)
  43 }
  44
  45 //-----------------------------------------------------------------------------
  46 //
  47 //-----------------------------------------------------------------------------
  48 type E2APMsgPackerSubscriptionResponseIf interface {
  49         E2APMsgPackerIf
  50         Set(*E2APSubscriptionResponse) error
  51         Get() (error, *E2APSubscriptionResponse)
  52 }
  53
  54 //-----------------------------------------------------------------------------
  55 //
  56 //-----------------------------------------------------------------------------
  57 type E2APMsgPackerSubscriptionFailureIf interface {
  58         E2APMsgPackerIf
  59         Set(*E2APSubscriptionFailure) error
  60         Get() (error, *E2APSubscriptionFailure)
  61 }
  62
  63 //-----------------------------------------------------------------------------
  64 //
  65 //-----------------------------------------------------------------------------
  66 type E2APMsgPackerSubscriptionDeleteRequestIf interface {
  67         E2APMsgPackerIf
  68         Set(*E2APSubscriptionDeleteRequest) error
  69         Get() (error, *E2APSubscriptionDeleteRequest)
  70 }
  71
  72 //-----------------------------------------------------------------------------
  73 //
  74 //-----------------------------------------------------------------------------
  75 type E2APMsgPackerSubscriptionDeleteResponseIf interface {
  76         E2APMsgPackerIf
  77         Set(*E2APSubscriptionDeleteResponse) error
  78         Get() (error, *E2APSubscriptionDeleteResponse)
  79 }
  80
  81 //-----------------------------------------------------------------------------
  82 //
  83 //-----------------------------------------------------------------------------
  84 type E2APMsgPackerSubscriptionDeleteFailureIf interface {
  85         E2APMsgPackerIf
  86         Set(*E2APSubscriptionDeleteFailure) error
  87         Get() (error, *E2APSubscriptionDeleteFailure)
  88 }
  89
  90 //-----------------------------------------------------------------------------
  91 //
  92 //-----------------------------------------------------------------------------
  93 type E2APMsgPackerIndicationIf interface {
  94         E2APMsgPackerIf
  95         Set(*E2APIndication) error
  96         Get() (error, *E2APIndication)
  97 }
  98
  99 //-----------------------------------------------------------------------------
 100 //
 101 //-----------------------------------------------------------------------------
 102 type E2APPackerIf interface {
 103         NewPackerSubscriptionRequest() E2APMsgPackerSubscriptionRequestIf
 104         NewPackerSubscriptionResponse() E2APMsgPackerSubscriptionResponseIf
 105         NewPackerSubscriptionFailure() E2APMsgPackerSubscriptionFailureIf
 106         NewPackerSubscriptionDeleteRequest() E2APMsgPackerSubscriptionDeleteRequestIf
 107         NewPackerSubscriptionDeleteResponse() E2APMsgPackerSubscriptionDeleteResponseIf
 108         NewPackerSubscriptionDeleteFailure() E2APMsgPackerSubscriptionDeleteFailureIf
 109         NewPackerIndication() E2APMsgPackerIndicationIf
 110         MessageInfo(msg *packer.PackedData) *packer.MessageInfo
 111 }
 112
 113 //-----------------------------------------------------------------------------
 114 //
 115 //-----------------------------------------------------------------------------
 116 type E2APAutoPacker struct {
 117         packer E2APPackerIf
 118 }
 119
 120 func NewE2APAutoPacker(packer E2APPackerIf) *E2APAutoPacker {
 121         return &E2APAutoPacker{packer: packer}
 122 }
 123
 124 // TODO improve openasn handling to reuse PDU etc...
 125 // Now practically decodes two times each E2/X2 message, as first round solves message type
 126 func (autopacker *E2APAutoPacker) UnPack(msg *packer.PackedData) (error, interface{}) {
 127         var err error = nil
 128         msgInfo := autopacker.packer.MessageInfo(msg)
 129         if msgInfo != nil {
 130                 switch msgInfo.MsgType {
 131                 case E2AP_InitiatingMessage:
 132                         switch msgInfo.MsgId {
 133                         case E2AP_RICSubscriptionRequest:
 134                                 unpa := autopacker.packer.NewPackerSubscriptionRequest()
 135                                 err = unpa.UnPack(msg)
 136                                 if err == nil {
 137                                         return unpa.Get()
 138                                 }
 139                         case E2AP_RICSubscriptionDeleteRequest:
 140                                 unpa := autopacker.packer.NewPackerSubscriptionDeleteRequest()
 141                                 err = unpa.UnPack(msg)
 142                                 if err == nil {
 143                                         return unpa.Get()
 144                                 }
 145                         case E2AP_RICIndication:
 146                                 unpa := autopacker.packer.NewPackerIndication()
 147                                 err = unpa.UnPack(msg)
 148                                 if err == nil {
 149                                         return unpa.Get()
 150                                 }
 151                         default:
 152                                 err = fmt.Errorf("MsgType: E2AP_InitiatingMessage => MsgId:%d unknown", msgInfo.MsgId)
 153                         }
 154                 case E2AP_SuccessfulOutcome:
 155                         switch msgInfo.MsgId {
 156                         case E2AP_RICSubscriptionResponse:
 157                                 unpa := autopacker.packer.NewPackerSubscriptionResponse()
 158                                 err = unpa.UnPack(msg)
 159                                 if err == nil {
 160                                         return unpa.Get()
 161                                 }
 162                         case E2AP_RICSubscriptionDeleteResponse:
 163                                 unpa := autopacker.packer.NewPackerSubscriptionDeleteResponse()
 164                                 err = unpa.UnPack(msg)
 165                                 if err == nil {
 166                                         return unpa.Get()
 167                                 }
 168                         default:
 169                                 err = fmt.Errorf("MsgType: E2AP_SuccessfulOutcome => MsgId:%d unknown", msgInfo.MsgId)
 170                         }
 171                 case E2AP_UnsuccessfulOutcome:
 172                         switch msgInfo.MsgId {
 173                         case E2AP_RICSubscriptionFailure:
 174                                 unpa := autopacker.packer.NewPackerSubscriptionFailure()
 175                                 err = unpa.UnPack(msg)
 176                                 if err == nil {
 177                                         return unpa.Get()
 178                                 }
 179                         case E2AP_RICSubscriptionDeleteFailure:
 180                                 unpa := autopacker.packer.NewPackerSubscriptionDeleteFailure()
 181                                 err = unpa.UnPack(msg)
 182                                 if err == nil {
 183                                         return unpa.Get()
 184                                 }
 185                         default:
 186                                 err = fmt.Errorf("MsgType: E2AP_UnsuccessfulOutcome => MsgId:%d unknown", msgInfo.MsgId)
 187                         }
 188                 default:
 189                         err = fmt.Errorf("MsgType: %d and MsgId:%d unknown", msgInfo.MsgType, msgInfo.MsgId)
 190                 }
 191         } else {
 192                 err = fmt.Errorf("MsgInfo not received")
 193         }
 194         return err, nil
 195 }
 196
 197 func (autopacker *E2APAutoPacker) Pack(data interface{}, trg *packer.PackedData) (error, *packer.PackedData) {
 198         var err error = nil
 199         switch themsg := data.(type) {
 200         case *E2APSubscriptionRequest:
 201                 pa := autopacker.packer.NewPackerSubscriptionRequest()
 202                 err = pa.Set(themsg)
 203                 if err == nil {
 204                         return pa.Pack(trg)
 205                 }
 206         case *E2APSubscriptionResponse:
 207                 pa := autopacker.packer.NewPackerSubscriptionResponse()
 208                 err = pa.Set(themsg)
 209                 if err == nil {
 210                         return pa.Pack(trg)
 211                 }
 212         case *E2APSubscriptionFailure:
 213                 pa := autopacker.packer.NewPackerSubscriptionFailure()
 214                 err = pa.Set(themsg)
 215                 if err == nil {
 216                         return pa.Pack(trg)
 217                 }
 218         case *E2APSubscriptionDeleteRequest:
 219                 pa := autopacker.packer.NewPackerSubscriptionDeleteRequest()
 220                 err = pa.Set(themsg)
 221                 if err == nil {
 222                         return pa.Pack(trg)
 223                 }
 224         case *E2APSubscriptionDeleteResponse:
 225                 pa := autopacker.packer.NewPackerSubscriptionDeleteResponse()
 226                 err = pa.Set(themsg)
 227                 if err == nil {
 228                         return pa.Pack(trg)
 229                 }
 230         case *E2APSubscriptionDeleteFailure:
 231                 pa := autopacker.packer.NewPackerSubscriptionDeleteFailure()
 232                 err = pa.Set(themsg)
 233                 if err == nil {
 234                         return pa.Pack(trg)
 235                 }
 236         case *E2APIndication:
 237                 pa := autopacker.packer.NewPackerIndication()
 238                 err = pa.Set(themsg)
 239                 if err == nil {
 240                         return pa.Pack(trg)
 241                 }
 242         default:
 243                 err = fmt.Errorf("unknown message")
 244         }
 245         return err, nil
 246 }