From ad701f7a973c8c9da46fe756e1c0d0e7216a7c40 Mon Sep 17 00:00:00 2001 From: cheetah Date: Sun, 10 Sep 2023 11:05:31 +0000 Subject: [PATCH] just missing rtp streams --- common/disconnectcauses.go | 34 ++++++++++++ common/terminalClient.go | 107 +++++++++++++++++++++++++++++++++++-- common/terminalMessage.go | 78 ++++++++++++++++++++++----- main.go | 62 +++++++++++++++++++-- 4 files changed, 258 insertions(+), 23 deletions(-) create mode 100644 common/disconnectcauses.go diff --git a/common/disconnectcauses.go b/common/disconnectcauses.go new file mode 100644 index 0000000..576ff4a --- /dev/null +++ b/common/disconnectcauses.go @@ -0,0 +1,34 @@ +package common + +type TetraFlexCallDisconnectCauses byte + +const ( + DisconnectReason_NotDisconnected TetraFlexCallDisconnectCauses = 255 + DisconnectReason_Unknown TetraFlexCallDisconnectCauses = 0 + DisconnectReason_UserRequested TetraFlexCallDisconnectCauses = 1 + DisconnectReason_CalledPartyBusy TetraFlexCallDisconnectCauses = 2 + DisconnectReason_CalledPartyNotReachable TetraFlexCallDisconnectCauses = 3 + DisconnectReason_CalledPartyNotSupportEncryption TetraFlexCallDisconnectCauses = 4 + DisconnectReason_Congestion TetraFlexCallDisconnectCauses = 5 + DisconnectReason_NotAllowedTrafficCase TetraFlexCallDisconnectCauses = 6 + DisconnectReason_IncompatibleTrafficCase TetraFlexCallDisconnectCauses = 7 + DisconnectReason_RequestedServiceNotAvailable TetraFlexCallDisconnectCauses = 8 + DisconnectReason_PreEmptiveUseResource TetraFlexCallDisconnectCauses = 9 + DisconnectReason_InvalidCallIdentifier TetraFlexCallDisconnectCauses = 10 + DisconnectReason_CallRejectedByCalled TetraFlexCallDisconnectCauses = 11 + DisconnectReason_NoIdleCCEntity TetraFlexCallDisconnectCauses = 12 + DisconnectReason_ExpiryTimer TetraFlexCallDisconnectCauses = 13 + DisconnectReason_SwMIRequestedDisconnection TetraFlexCallDisconnectCauses = 14 + DisconnectReason_AcknowledgedServiceNotCompleted TetraFlexCallDisconnectCauses = 15 + DisconnectReason_UnknownTetraIdentity TetraFlexCallDisconnectCauses = 16 + DisconnectReason_SSSpecificDisconnection TetraFlexCallDisconnectCauses = 17 + DisconnectReason_UnknownExternalSubscriberIdentity TetraFlexCallDisconnectCauses = 18 + DisconnectReason_CallRestorationOthersFailed TetraFlexCallDisconnectCauses = 19 + DisconnectReason_CalledPartyRequiresEncryption TetraFlexCallDisconnectCauses = 20 + DisconnectReason_ConcurrentSetupNotSupported TetraFlexCallDisconnectCauses = 21 + DisconnectReason_CalledPartySameDM TetraFlexCallDisconnectCauses = 22 + DisconnectReason_NonCallOwnerRequestedDisconnection TetraFlexCallDisconnectCauses = 23 + DisconnectReason_CallCompletedElsewhere TetraFlexCallDisconnectCauses = 32 + DisconnectReason_NetworkFailure TetraFlexCallDisconnectCauses = 100 + DisconnectReason_IgnoreCallSilently TetraFlexCallDisconnectCauses = 255 +) diff --git a/common/terminalClient.go b/common/terminalClient.go index 0270b9f..4eb3d68 100644 --- a/common/terminalClient.go +++ b/common/terminalClient.go @@ -103,7 +103,7 @@ func (tc *TerminalClient) SubscribeEvents(messageTypes []tmkind.TetraFlexTermina func (tc *TerminalClient) AttachGroups(groups []GroupConfig) (err error) { tfGroupAttachReq, err := NewTMIpApiGroupAttachRequest(groups) if err != nil { - panic(err) + return nil } fmt.Println(hex.EncodeToString(tfGroupAttachReq.Encode())) tc.HandlerMap[tfGroupAttachReq.handler] = make(chan HandlerResponse) @@ -120,13 +120,110 @@ func (tc *TerminalClient) AttachGroups(groups []GroupConfig) (err error) { return nil } -func (tc *TerminalClient) CallSetup(address TetraFlexAddress, callType TetraFlexCallTypes, callPriority TetraFlexCallPriorities, hookCall bool, identityInfo TetraFlexIdentityInfo) (err error) { - // +func (tc *TerminalClient) CallSetup(address TetraFlexAddress, callType TetraFlexCallTypes, callPriority TetraFlexCallPriorities, hookCall bool, identityInfo TetraFlexIdentityInfo) (callRef byte, err error) { + tfCallSetupReq, err := NewTMIpApiCallSetupRequest(address, callType, callPriority, hookCall, identityInfo) + if err != nil { + return callRef, err + } + fmt.Println(hex.EncodeToString(tfCallSetupReq.Encode())) + tc.HandlerMap[tfCallSetupReq.handler] = make(chan HandlerResponse) + + //fmt.Println(hex.EncodeToString(tfAuthReq.Encode())) + err = tc.Send(tfCallSetupReq) + if err != nil { + return callRef, err + } + response := <-tc.HandlerMap[tfCallSetupReq.handler] + if !response.Success { + return callRef, response.Error + } + //fmt.Println(hex.EncodeToString(response.TMR.payload)) + callRef, err = response.TMR.readByte() + if err != nil { + return callRef, err + } + return callRef, nil +} +func (tc *TerminalClient) CallDisconnect(callRef byte, disconnectCause TetraFlexCallDisconnectCauses) (err error) { + tfCallDisconnectReq, err := NewTMIpApiCallDisconnectRequest(callRef, disconnectCause) + if err != nil { + return nil + } + fmt.Println(hex.EncodeToString(tfCallDisconnectReq.Encode())) + tc.HandlerMap[tfCallDisconnectReq.handler] = make(chan HandlerResponse) + + //fmt.Println(hex.EncodeToString(tfAuthReq.Encode())) + err = tc.Send(tfCallDisconnectReq) + if err != nil { + return err + } + response := <-tc.HandlerMap[tfCallDisconnectReq.handler] + if !response.Success { + return response.Error + } + + return nil +} +func (tc *TerminalClient) CallConnect(callRef byte) (err error) { + tfCallConnectReq, err := NewTMIpApiCallConnectRequest(callRef) + if err != nil { + return nil + } + fmt.Println(hex.EncodeToString(tfCallConnectReq.Encode())) + tc.HandlerMap[tfCallConnectReq.handler] = make(chan HandlerResponse) + + //fmt.Println(hex.EncodeToString(tfAuthReq.Encode())) + err = tc.Send(tfCallConnectReq) + if err != nil { + return err + } + response := <-tc.HandlerMap[tfCallConnectReq.handler] + if !response.Success { + return response.Error + } + return nil } +func (tc *TerminalClient) PTTRequest(callRef byte, identityInfo TetraFlexIdentityInfo, octaStateByte byte) (err error) { + // IpApiCallPttRequest + tfPTTRequest, err := NewTMIpApiCallPTTRequest(callRef, identityInfo, octaStateByte) + if err != nil { + return err + } + fmt.Println(hex.EncodeToString(tfPTTRequest.Encode())) + tc.HandlerMap[tfPTTRequest.handler] = make(chan HandlerResponse) -func (tc *TerminalClient) PTTRequest() { + //fmt.Println(hex.EncodeToString(tfAuthReq.Encode())) + err = tc.Send(tfPTTRequest) + if err != nil { + return err + } + response := <-tc.HandlerMap[tfPTTRequest.handler] + if !response.Success { + return response.Error + } + return nil +} +func (tc *TerminalClient) PTTRelease(callRef byte) (err error) { // IpApiCallPttRequest + tfPTTRelease, err := NewTMIpApiCallPTTRelease(callRef) + if err != nil { + + return err + } + fmt.Println(hex.EncodeToString(tfPTTRelease.Encode())) + tc.HandlerMap[tfPTTRelease.handler] = make(chan HandlerResponse) + + //fmt.Println(hex.EncodeToString(tfAuthReq.Encode())) + err = tc.Send(tfPTTRelease) + if err != nil { + return err + } + response := <-tc.HandlerMap[tfPTTRelease.handler] + if !response.Success { + return response.Error + } + return nil } /* @@ -134,6 +231,8 @@ groupAddr := common.NewAddressFromSSINumber(103) identityNum := common.NewAddressFromSSINumber(1007) response, err = common.NewTMIpApiCallSetupRequest(*groupAddr, common.CallTypeGroup, common.CallPriorityDefault, false, common.TetraFlexIdentityInfo{ + + Description: "blurb", Kind: common.IdentityKindTerminal, Address: *identityNum, diff --git a/common/terminalMessage.go b/common/terminalMessage.go index a82ccef..3524085 100644 --- a/common/terminalMessage.go +++ b/common/terminalMessage.go @@ -321,20 +321,6 @@ func NewTMIpApiGroupAttachRequest(groupConfig []GroupConfig) (tm *TerminalMessag return terminalMessage, nil } -func NewTMIpApiCallConnectRequest(callRef byte) (tm *TerminalMessage, err error) { - terminalMessage, err := NewTerminalMessage(64, tmkind.IpApiCallConnectRequest, NextHandlerID()) - if err != nil { - return nil, err - } - if err = terminalMessage.WriteByte(callRef); err != nil { - return nil, err - } - //Fill 55 - if err = terminalMessage.FillZero(55); err != nil { - return nil, err - } - return terminalMessage, nil -} func NewTMIpApiSoftwareInfoRequest(ref byte) (tm *TerminalMessage, err error) { terminalMessage, err := NewTerminalMessage(64, tmkind.IpApiSoftwareInfoRequest, NextHandlerID()) if err != nil { @@ -414,6 +400,35 @@ func NewTMIpApiCallSetupRequest(address TetraFlexAddress, callType TetraFlexCall } return terminalMessage, nil } +func NewTMIpApiCallConnectRequest(callRef byte) (tm *TerminalMessage, err error) { + terminalMessage, err := NewTerminalMessage(64, tmkind.IpApiCallConnectRequest, NextHandlerID()) + if err != nil { + return nil, err + } + if err = terminalMessage.WriteByte(callRef); err != nil { + return nil, err + } + if err = terminalMessage.FillZero(55); err != nil { + return nil, err + } + return terminalMessage, nil +} +func NewTMIpApiCallDisconnectRequest(callRef byte, disconnectCause TetraFlexCallDisconnectCauses) (tm *TerminalMessage, err error) { + terminalMessage, err := NewTerminalMessage(64, tmkind.IpApiCallDisconnectRequest, NextHandlerID()) + if err != nil { + return nil, err + } + if err = terminalMessage.WriteByte(callRef); err != nil { + return nil, err + } + if err = terminalMessage.WriteByte(byte(disconnectCause)); err != nil { + return nil, err + } + if err = terminalMessage.FillZero(54); err != nil { + return nil, err + } + return terminalMessage, nil +} func NewTMIpApiCallStreamRequest(uint1 uint, callRef byte, streamRef byte, audioChannelType TetraFlexAudioChannelTypes) (tm *TerminalMessage, err error) { terminalMessage, err := NewTerminalMessage(64, tmkind.IpApiCallStreamRequest, NextHandlerID()) if err != nil { @@ -510,3 +525,38 @@ func NewTMIpApiCallPTTRequest(callRef byte, identityInfo TetraFlexIdentityInfo, } return terminalMessage, nil } +func NewTMIpApiCallPTTRelease(callRef byte) (tm *TerminalMessage, err error) { + terminalMessage, err := NewTerminalMessage(128, tmkind.IpApiCallPttRequest, NextHandlerID()) + if err != nil { + return nil, err + } + if err = terminalMessage.WriteByte(callRef); err != nil { + return nil, err + } + if err = terminalMessage.WriteByte(255); err != nil { + return nil, err + } + if err = terminalMessage.FillZero(2); err != nil { + return nil, err + } + //WriteIdentityInfoAddress + if err = terminalMessage.WriteTFAddress(TetraFlexAddressEmpty); err != nil { + return nil, err + } + //WriteIdentityInfoDescr (protoHelper1:334) + if err = terminalMessage.WriteString("", 64); err != nil { + return nil, err + } + //WriteIdentityInfoKind + if err = terminalMessage.WriteByte(0); err != nil { + return nil, err + } + //WriteIdentityInfoUnfied () + if err = terminalMessage.WriteByte(0); err != nil { + return nil, err + } + if err = terminalMessage.FillZero(10); err != nil { + return nil, err + } + return terminalMessage, nil +} diff --git a/main.go b/main.go index 2267b06..5d011c4 100644 --- a/main.go +++ b/main.go @@ -16,14 +16,14 @@ func main() { rand.Seed(time.Now().UnixNano()) var err error - terminalClient := common.NewTerminalClient("192.168.133.106:42381") - //data := make([]byte, 256) + terminalClient := common.NewTerminalClient("192.168.133.106:42381") + // err = terminalClient.Connect() if err != nil { panic(err) } - + // myAddr := common.TetraFlexAddress{ Kind: common.UserNo, UserNo: "1005", @@ -32,7 +32,7 @@ func main() { if err != nil { panic(err) } - + // err = terminalClient.SubscribeEvents([]tmkind.TetraFlexTerminalMessageKinds{ tmkind.IpApiCallUpdateNotification, tmkind.IpApiSdsTlReportNotification, @@ -44,6 +44,8 @@ func main() { if err != nil { panic(err) } + // + //fmt.Println(hex.EncodeToString(parsedMsg.Bytes())) regInfoBytes, _ := json.Marshal(terminalClient.RegistrationInfo) fmt.Println(string(regInfoBytes)) @@ -65,7 +67,58 @@ func main() { if err != nil { panic(err) } + fmt.Println("Groups attached") + go func() { + fmt.Println("Test started, waiting 3s") + time.Sleep(3 * time.Second) + groupAddr := common.NewAddressFromSSINumber(101) + fmt.Println("Test callSetup") + callRef, err := terminalClient.CallSetup(*groupAddr, common.CallTypeGroup, common.CallPriorityDefault, false, common.TetraFlexIdentityInfo{ + Description: "Blaa", + + /* Kind: common.IdentityKindApplication, + Address: *common.NewAddressFromSSINumber(1002), + UnifiedSSIKinds: common.UnifiedKindExternalNumber, + */ + Kind: common.IdentityKindTerminal, + Address: *common.NewAddressFromSSINumber(1002), + UnifiedSSIKinds: common.UnifiedKindPersonalNumber, + }) + if err != nil { + panic(err) + } + fmt.Printf("callRef=%d\n", callRef) + + // IpApiCallStreamRequest + err = terminalClient.PTTRequest(callRef, common.TetraFlexIdentityInfo{ + Description: "Blaa", + + /* Kind: common.IdentityKindApplication, + Address: *common.NewAddressFromSSINumber(1002), + UnifiedSSIKinds: common.UnifiedKindExternalNumber, + */ + Kind: common.IdentityKindTerminal, + Address: *common.NewAddressFromSSINumber(1002), + UnifiedSSIKinds: common.UnifiedKindPersonalNumber, + }, 0) + if err != nil { + panic(err) + } + time.Sleep(3 * time.Second) + // PTT Release + err = terminalClient.PTTRelease(callRef) + if err != nil { + panic(err) + } + time.Sleep(3 * time.Second) + err = terminalClient.CallDisconnect(callRef, common.DisconnectReason_CallRejectedByCalled) + if err != nil { + panic(err) + } + // IpApiCallPttRequest + }() + // idk send help xD for { select { case parsedMsg := <-terminalClient.RX: @@ -80,7 +133,6 @@ func main() { //terminalClient.SendTM() } } - //if parsedMsg.Kind == tmkind.IpApiNo } } }