diff --git a/auth/callbacks.go b/auth/callbacks.go
index 781164bb89e374f166b0ace4d4fb639e7c250d10..273ff6b0b7af5b36ff53d44e265ebaeaab0183cd 100644
--- a/auth/callbacks.go
+++ b/auth/callbacks.go
@@ -7,10 +7,6 @@
package auth
import (
- jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/cmix/identity/receptionID"
- "gitlab.com/elixxir/client/cmix/rounds"
- "gitlab.com/elixxir/crypto/contact"
"gitlab.com/xx_network/primitives/id"
"sync"
)
@@ -42,27 +38,8 @@ func (p *partnerCallbacks) DeletePartnerCallback(partnerId *id.ID) {
// getPartnerCallback returns the Callbacks for the given partnerId
func (p *partnerCallbacks) getPartnerCallback(partnerId *id.ID) Callbacks {
- return p.callbacks[*partnerId]
-}
-
-// DefaultAuthCallbacks is a simple structure for providing a default Callbacks implementation
-// It should generally not be used.
-type DefaultAuthCallbacks struct{}
-
-// Confirm will be called when an auth Confirm message is processed.
-func (a DefaultAuthCallbacks) Confirm(requestor contact.Contact,
- receptionID receptionID.EphemeralIdentity, round rounds.Round) {
- jww.ERROR.Printf("No valid auth callback assigned!")
-}
-
-// Request will be called when an auth Request message is processed.
-func (a DefaultAuthCallbacks) Request(requestor contact.Contact,
- receptionID receptionID.EphemeralIdentity, round rounds.Round) {
- jww.ERROR.Printf("No valid auth callback assigned!")
-}
+ p.RLock()
+ defer p.RUnlock()
-// Reset will be called when an auth Reset operation occurs.
-func (a DefaultAuthCallbacks) Reset(requestor contact.Contact,
- receptionID receptionID.EphemeralIdentity, round rounds.Round) {
- jww.ERROR.Printf("No valid auth callback assigned!")
+ return p.callbacks[*partnerId]
}
diff --git a/auth/receivedConfirm.go b/auth/receivedConfirm.go
index 118b79f354d9b8fc3b1b46c62ce217074e9f48ca..ad30186d15c911dbc739495ccf58df4bdcf05818 100644
--- a/auth/receivedConfirm.go
+++ b/auth/receivedConfirm.go
@@ -112,13 +112,11 @@ func (rcs *receivedConfirmService) Process(msg format.Message,
Facts: make([]fact.Fact, 0),
}
- authState.partnerCallbacks.RLock()
if cb := authState.partnerCallbacks.getPartnerCallback(c.ID); cb != nil {
cb.Confirm(c, receptionID, round)
} else {
authState.callbacks.Confirm(c, receptionID, round)
}
- authState.partnerCallbacks.RUnlock()
}
func (rcs *receivedConfirmService) String() string {
diff --git a/auth/receivedRequest.go b/auth/receivedRequest.go
index b410b04a3e29cca95dedd8bc14d310507e8bce57..4e3325996a6ca5c558d3531a019c68c92f026bf3 100644
--- a/auth/receivedRequest.go
+++ b/auth/receivedRequest.go
@@ -130,21 +130,17 @@ func (rrs *receivedRequestService) Process(message format.Message,
} else if authState.params.ReplayRequests {
//if we did not already accept, auto replay the request
if rrs.reset {
- authState.partnerCallbacks.RLock()
if cb := authState.partnerCallbacks.getPartnerCallback(c.ID); cb != nil {
cb.Reset(c, receptionID, round)
} else {
authState.callbacks.Reset(c, receptionID, round)
}
- authState.partnerCallbacks.RUnlock()
} else {
- authState.partnerCallbacks.RLock()
if cb := authState.partnerCallbacks.getPartnerCallback(c.ID); cb != nil {
cb.Request(c, receptionID, round)
} else {
authState.callbacks.Request(c, receptionID, round)
}
- authState.partnerCallbacks.RUnlock()
}
}
//if not confirm, and params.replay requests is true, we need to replay
@@ -254,8 +250,6 @@ func (rrs *receivedRequestService) Process(message format.Message,
}
// auto-confirm if we should
- authState.partnerCallbacks.RLock()
- defer authState.partnerCallbacks.RUnlock()
if autoConfirm || reset {
_, _ = authState.confirm(c, authState.params.getConfirmTag(reset))
//handle callbacks
diff --git a/auth/state.go b/auth/state.go
index a9c90931393d8af5acf790002bb18311614f0719..f8511ac70ed5ff25048fa44129f4c20d13737f33 100644
--- a/auth/state.go
+++ b/auth/state.go
@@ -124,13 +124,11 @@ func (s *state) CallAllReceivedRequests() {
rr := rrList[i]
eph := receptionID.BuildIdentityFromRound(rr.GetContact().ID,
rr.GetRound())
- s.partnerCallbacks.RLock()
if cb := s.partnerCallbacks.getPartnerCallback(rr.GetContact().ID); cb != nil {
cb.Request(rr.GetContact(), eph, rr.GetRound())
} else {
s.callbacks.Request(rr.GetContact(), eph, rr.GetRound())
}
- s.partnerCallbacks.RUnlock()
}
}
diff --git a/bindings/connect.go b/bindings/connect.go
index 754a5366c13361a2fea805c4cab402a5981e57aa..ec848b30b8eecfd9c649dd26fa2e68891d6df169 100644
--- a/bindings/connect.go
+++ b/bindings/connect.go
@@ -3,6 +3,8 @@ package bindings
import (
"encoding/json"
+ "time"
+
"gitlab.com/elixxir/client/catalog"
"gitlab.com/elixxir/client/connect"
e2e2 "gitlab.com/elixxir/client/e2e"
@@ -46,8 +48,9 @@ func (c *Cmix) Connect(e2eId int, recipientContact []byte) (
return nil, err
}
- connection, err := connect.Connect(cont, e2eClient.api,
- xxdk.GetDefaultE2EParams())
+ p := xxdk.GetDefaultE2EParams()
+ p.Base.Timeout = 45 * time.Second
+ connection, err := connect.Connect(cont, e2eClient.api, p)
if err != nil {
return nil, err
}
diff --git a/bindings/e2e.go b/bindings/e2e.go
index a0d5bb252c6e7ed642c502d9d1bd5b0e5b87c44d..0f9b86f02daf6f0d42986cda2cf37b217cb1cd46 100644
--- a/bindings/e2e.go
+++ b/bindings/e2e.go
@@ -9,7 +9,7 @@ package bindings
import (
"encoding/json"
- "gitlab.com/elixxir/client/auth"
+ jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/cmix/identity/receptionID"
"gitlab.com/elixxir/client/cmix/rounds"
"gitlab.com/elixxir/client/xxdk"
@@ -52,13 +52,20 @@ func LoginE2e(cmixId int, callbacks AuthCallbacks, identity []byte) (*E2e, error
return nil, err
}
- authCallbacks := &authCallback{bindingsCbs: callbacks}
+ var authCallbacks xxdk.AuthCallbacks
+ if callbacks == nil {
+ authCallbacks = defaultAuthCallbacks{}
+ } else {
+ authCallbacks = &authCallback{bindingsCbs: callbacks}
+ }
+
params := xxdk.GetDefaultE2EParams()
newE2e, err := xxdk.Login(cmix.api, authCallbacks, newIdentity, params)
if err != nil {
return nil, err
}
+
return e2eTrackerSingleton.make(newE2e), nil
}
@@ -76,7 +83,13 @@ func LoginE2eEphemeral(cmixId int, callbacks AuthCallbacks, identity []byte) (*E
return nil, err
}
- authCallbacks := &authCallback{bindingsCbs: callbacks}
+ var authCallbacks xxdk.AuthCallbacks
+ if callbacks == nil {
+ authCallbacks = defaultAuthCallbacks{}
+ } else {
+ authCallbacks = &authCallback{bindingsCbs: callbacks}
+ }
+
params := xxdk.GetDefaultE2EParams()
newE2e, err := xxdk.LoginEphemeral(cmix.api, authCallbacks, newIdentity, params)
@@ -97,7 +110,13 @@ func LoginE2eLegacy(cmixId int, callbacks AuthCallbacks) (*E2e, error) {
return nil, err
}
- authCallbacks := &authCallback{bindingsCbs: callbacks}
+ var authCallbacks xxdk.AuthCallbacks
+ if callbacks == nil {
+ authCallbacks = defaultAuthCallbacks{}
+ } else {
+ authCallbacks = &authCallback{bindingsCbs: callbacks}
+ }
+
params := xxdk.GetDefaultE2EParams()
newE2e, err := xxdk.LoginLegacy(cmix.api, params, authCallbacks)
@@ -169,39 +188,41 @@ func convertAuthCallbacks(requestor contact.Contact,
}
// Confirm will be called when an auth Confirm message is processed.
-func (a *authCallback) Confirm(requestor contact.Contact,
- receptionID receptionID.EphemeralIdentity, round rounds.Round,
- e2e *xxdk.E2e) {
- if a.bindingsCbs == nil {
- auth.DefaultAuthCallbacks{}.Confirm(requestor, receptionID,
- round)
- return
- }
- a.bindingsCbs.Confirm(convertAuthCallbacks(requestor, receptionID,
- round))
+func (a *authCallback) Confirm(partner contact.Contact,
+ receptionID receptionID.EphemeralIdentity, round rounds.Round, _ *xxdk.E2e) {
+ a.bindingsCbs.Confirm(convertAuthCallbacks(partner, receptionID, round))
}
// Request will be called when an auth Request message is processed.
-func (a *authCallback) Request(requestor contact.Contact,
- receptionID receptionID.EphemeralIdentity, round rounds.Round,
- e2e *xxdk.E2e) {
- if a.bindingsCbs == nil {
- auth.DefaultAuthCallbacks{}.Request(requestor, receptionID,
- round)
- return
- }
- a.bindingsCbs.Request(convertAuthCallbacks(requestor, receptionID,
- round))
+func (a *authCallback) Request(partner contact.Contact,
+ receptionID receptionID.EphemeralIdentity, round rounds.Round, _ *xxdk.E2e) {
+ a.bindingsCbs.Request(convertAuthCallbacks(partner, receptionID, round))
}
// Reset will be called when an auth Reset operation occurs.
-func (a *authCallback) Reset(requestor contact.Contact,
- receptionID receptionID.EphemeralIdentity, round rounds.Round,
- e2e *xxdk.E2e) {
- if a.bindingsCbs == nil {
- auth.DefaultAuthCallbacks{}.Reset(requestor, receptionID,
- round)
- return
- }
- a.bindingsCbs.Reset(convertAuthCallbacks(requestor, receptionID, round))
+func (a *authCallback) Reset(partner contact.Contact,
+ receptionID receptionID.EphemeralIdentity, round rounds.Round, _ *xxdk.E2e) {
+ a.bindingsCbs.Reset(convertAuthCallbacks(partner, receptionID, round))
+}
+
+// defaultAuthCallbacks is a simple structure for providing a default Callbacks implementation
+// It should generally not be used.
+type defaultAuthCallbacks struct{}
+
+// Confirm will be called when an auth Confirm message is processed.
+func (a defaultAuthCallbacks) Confirm(contact.Contact,
+ receptionID.EphemeralIdentity, rounds.Round, *xxdk.E2e) {
+ jww.ERROR.Printf("No valid auth callback assigned!")
+}
+
+// Request will be called when an auth Request message is processed.
+func (a defaultAuthCallbacks) Request(contact.Contact,
+ receptionID.EphemeralIdentity, rounds.Round, *xxdk.E2e) {
+ jww.ERROR.Printf("No valid auth callback assigned!")
+}
+
+// Reset will be called when an auth Reset operation occurs.
+func (a defaultAuthCallbacks) Reset(contact.Contact,
+ receptionID.EphemeralIdentity, rounds.Round, *xxdk.E2e) {
+ jww.ERROR.Printf("No valid auth callback assigned!")
}
diff --git a/bindings/e2eAuth.go b/bindings/e2eAuth.go
index fb21ad2d0f7de4345479b0681e6c56ee2d641598..77083daa290bfcd1dbd27ffe714e2d456624475d 100644
--- a/bindings/e2eAuth.go
+++ b/bindings/e2eAuth.go
@@ -216,9 +216,8 @@ func (e *E2e) AddPartnerCallback(partnerID []byte, cb AuthCallbacks) error {
return err
}
- acw := xxdk.MakeAuthCB(e.api, &authCallback{bindingsCbs: cb})
-
- e.api.GetAuth().AddPartnerCallback(partnerId, acw)
+ e.api.GetAuth().AddPartnerCallback(partnerId,
+ xxdk.MakeAuthCallbacksAdapter(&authCallback{bindingsCbs: cb}, e.api))
return nil
}
diff --git a/connect/authCallbacks.go b/connect/authCallbacks.go
new file mode 100644
index 0000000000000000000000000000000000000000..0a2cded398b9c29a9a6a199277bfe919189eaa31
--- /dev/null
+++ b/connect/authCallbacks.go
@@ -0,0 +1,147 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2022 Privategrity Corporation /
+// /
+// All rights reserved. /
+////////////////////////////////////////////////////////////////////////////////
+
+package connect
+
+import (
+ jww "github.com/spf13/jwalterweatherman"
+ "gitlab.com/elixxir/client/auth"
+ "gitlab.com/elixxir/client/cmix/identity/receptionID"
+ "gitlab.com/elixxir/client/cmix/rounds"
+ clientE2e "gitlab.com/elixxir/client/e2e"
+ "gitlab.com/elixxir/client/xxdk"
+ "gitlab.com/elixxir/crypto/contact"
+)
+
+// clientAuthCallback provides callback functionality for interfacing between
+// auth.State and Connection. This is used both for blocking creation of a
+// Connection object until the auth Request is confirmed and for dynamically
+// building new Connection objects when an auth Request is received.
+type clientAuthCallback struct {
+ // Used for signaling confirmation of E2E partnership
+ confirmCallback Callback
+ requestCallback Callback
+
+ // Used for building new Connection objects
+ connectionE2e clientE2e.Handler
+ connectionParams xxdk.E2EParams
+ authState auth.State
+}
+
+// getClientAuthCallback returns a callback interface to be passed into the creation
+// of an auth.State object.
+// it will accept requests only if a request callback is passed in
+func getClientAuthCallback(confirm, request Callback, e2e clientE2e.Handler,
+ auth auth.State, params xxdk.E2EParams) *clientAuthCallback {
+ return &clientAuthCallback{
+ confirmCallback: confirm,
+ requestCallback: request,
+ connectionE2e: e2e,
+ connectionParams: params,
+ authState: auth,
+ }
+}
+
+// Confirm will be called when an auth Confirm message is processed.
+func (a clientAuthCallback) Confirm(requestor contact.Contact,
+ _ receptionID.EphemeralIdentity, _ rounds.Round) {
+ jww.DEBUG.Printf("Connection auth request for %s confirmed",
+ requestor.ID.String())
+ defer a.authState.DeletePartnerCallback(requestor.ID)
+
+ // After confirmation, get the new partner
+ newPartner, err := a.connectionE2e.GetPartner(requestor.ID)
+ if err != nil {
+ jww.ERROR.Printf("Unable to build connection with "+
+ "partner %s: %+v", requestor.ID, err)
+ // Send a nil connection to avoid hold-ups down the line
+ if a.confirmCallback != nil {
+ a.confirmCallback(nil)
+ }
+ return
+ }
+
+ // Return the new Connection object
+ if a.confirmCallback != nil {
+ a.confirmCallback(BuildConnection(newPartner, a.connectionE2e,
+ a.authState, a.connectionParams))
+ }
+}
+
+// Request will be called when an auth Request message is processed.
+func (a clientAuthCallback) Request(contact.Contact,
+ receptionID.EphemeralIdentity, rounds.Round) {
+}
+
+// Reset will be called when an auth Reset operation occurs.
+func (a clientAuthCallback) Reset(contact.Contact,
+ receptionID.EphemeralIdentity, rounds.Round) {
+}
+
+// serverAuthCallback provides callback functionality for interfacing between
+// auth.State and Connection. This is used both for blocking creation of a
+// Connection object until the auth Request is confirmed and for dynamically
+// building new Connection objects when an auth Request is received.
+type serverAuthCallback struct {
+ // Used for signaling confirmation of E2E partnership
+ confirmCallback Callback
+ requestCallback Callback
+
+ // Used for building new Connection objects
+ connectionParams xxdk.E2EParams
+}
+
+// getServerAuthCallback returns a callback interface to be passed into the creation
+// of a xxdk.E2e object.
+// it will accept requests only if a request callback is passed in
+func getServerAuthCallback(confirm, request Callback,
+ params xxdk.E2EParams) *serverAuthCallback {
+ return &serverAuthCallback{
+ confirmCallback: confirm,
+ requestCallback: request,
+ connectionParams: params,
+ }
+}
+
+// Confirm will be called when an auth Confirm message is processed.
+func (a serverAuthCallback) Confirm(contact.Contact,
+ receptionID.EphemeralIdentity, rounds.Round, *xxdk.E2e) {
+}
+
+// Request will be called when an auth Request message is processed.
+func (a serverAuthCallback) Request(requestor contact.Contact,
+ _ receptionID.EphemeralIdentity, _ rounds.Round, e2e *xxdk.E2e) {
+ if a.requestCallback == nil {
+ jww.ERROR.Printf("Received a request when requests are" +
+ "not enable, will not accept")
+ }
+ _, err := e2e.GetAuth().Confirm(requestor)
+ if err != nil {
+ jww.ERROR.Printf("Unable to build connection with "+
+ "partner %s: %+v", requestor.ID, err)
+ // Send a nil connection to avoid hold-ups down the line
+ a.requestCallback(nil)
+ }
+ // After confirmation, get the new partner
+ newPartner, err := e2e.GetE2E().GetPartner(requestor.ID)
+ if err != nil {
+ jww.ERROR.Printf("Unable to build connection with "+
+ "partner %s: %+v", requestor.ID, err)
+ // Send a nil connection to avoid hold-ups down the line
+ a.requestCallback(nil)
+
+ return
+ }
+
+ // Return the new Connection object
+ a.requestCallback(BuildConnection(newPartner, e2e.GetE2E(),
+ e2e.GetAuth(), a.connectionParams))
+}
+
+// Reset will be called when an auth Reset operation occurs.
+func (a serverAuthCallback) Reset(contact.Contact,
+ receptionID.EphemeralIdentity, rounds.Round, *xxdk.E2e) {
+}
diff --git a/connect/connect.go b/connect/connect.go
index 26fd0792d11fa69f4c53b3935ebe58a30d3ec46a..458d2ade32e8c9514396f3df5e61d05d62eb2bfc 100644
--- a/connect/connect.go
+++ b/connect/connect.go
@@ -16,8 +16,6 @@ import (
jww "github.com/spf13/jwalterweatherman"
"gitlab.com/elixxir/client/auth"
"gitlab.com/elixxir/client/catalog"
- "gitlab.com/elixxir/client/cmix/identity/receptionID"
- "gitlab.com/elixxir/client/cmix/rounds"
clientE2e "gitlab.com/elixxir/client/e2e"
"gitlab.com/elixxir/client/e2e/ratchet/partner"
"gitlab.com/elixxir/client/e2e/receive"
@@ -83,15 +81,14 @@ type Callback func(connection Connection)
// partner.Manager is confirmed.
func Connect(recipient contact.Contact, e2eClient *xxdk.E2e,
p xxdk.E2EParams) (Connection, error) {
-
// Build callback for E2E negotiation
signalChannel := make(chan Connection, 1)
cb := func(connection Connection) {
signalChannel <- connection
}
- callback := getAuthCallback(cb, nil, e2eClient.GetE2E(), e2eClient.GetAuth(), p)
- cbs := xxdk.MakeAuthCB(e2eClient, callback)
- e2eClient.GetAuth().AddPartnerCallback(recipient.ID, cbs)
+ callback := getClientAuthCallback(cb, nil, e2eClient.GetE2E(),
+ e2eClient.GetAuth(), p)
+ e2eClient.GetAuth().AddPartnerCallback(recipient.ID, callback)
// Perform the auth request
_, err := e2eClient.GetAuth().Request(recipient, nil)
@@ -132,16 +129,10 @@ func StartServer(identity xxdk.ReceptionIdentity, cb Callback, net *xxdk.Cmix,
p xxdk.E2EParams) (*xxdk.E2e, error) {
// Build callback for E2E negotiation
- callback := getAuthCallback(nil, cb, nil, nil, p)
-
- client, err := xxdk.LoginEphemeral(net, callback, identity, p)
- if err != nil {
- return nil, err
- }
+ callback := getServerAuthCallback(nil, cb, p)
- callback.connectionE2e = client.GetE2E()
- callback.authState = client.GetAuth()
- return client, nil
+ // Return an ephemeral E2e object
+ return xxdk.LoginEphemeral(net, callback, identity, p)
}
// handler provides an implementation for the Connection interface.
@@ -199,97 +190,6 @@ func (h *handler) Unregister(listenerID receive.ListenerID) {
h.e2e.Unregister(listenerID)
}
-// authCallback provides callback functionality for interfacing between
-// auth.State and Connection. This is used both for blocking creation of a
-// Connection object until the auth Request is confirmed and for dynamically
-// building new Connection objects when an auth Request is received.
-type authCallback struct {
- // Used for signaling confirmation of E2E partnership
- confirmCallback Callback
- requestCallback Callback
-
- // Used for building new Connection objects
- connectionE2e clientE2e.Handler
- connectionParams xxdk.E2EParams
- authState auth.State
-}
-
-// getAuthCallback returns a callback interface to be passed into the creation
-// of an auth.State object.
-// it will accept requests only if a request callback is passed in
-func getAuthCallback(confirm, request Callback, e2e clientE2e.Handler,
- auth auth.State, params xxdk.E2EParams) *authCallback {
- return &authCallback{
- confirmCallback: confirm,
- requestCallback: request,
- connectionParams: params,
- authState: auth,
- }
-}
-
-// Confirm will be called when an auth Confirm message is processed.
-func (a authCallback) Confirm(requestor contact.Contact,
- receptionID receptionID.EphemeralIdentity, round rounds.Round, e2e *xxdk.E2e) {
- jww.DEBUG.Printf("Connection auth request for %s confirmed",
- requestor.ID.String())
- defer a.authState.DeletePartnerCallback(requestor.ID)
-
- // After confirmation, get the new partner
- newPartner, err := a.connectionE2e.GetPartner(requestor.ID)
- if err != nil {
- jww.ERROR.Printf("Unable to build connection with "+
- "partner %s: %+v", requestor.ID, err)
- // Send a nil connection to avoid hold-ups down the line
- if a.confirmCallback != nil {
- a.confirmCallback(nil)
- }
- return
- }
-
- // Return the new Connection object
- if a.confirmCallback != nil {
- a.confirmCallback(BuildConnection(newPartner, a.connectionE2e,
- a.authState, a.connectionParams))
- }
-}
-
-// Request will be called when an auth Request message is processed.
-func (a authCallback) Request(requestor contact.Contact,
- receptionID receptionID.EphemeralIdentity, round rounds.Round,
- e2e *xxdk.E2e) {
- if a.requestCallback == nil {
- jww.ERROR.Printf("Received a request when requests are" +
- "not enable, will not accept")
- }
- _, err := a.authState.Confirm(requestor)
- if err != nil {
- jww.ERROR.Printf("Unable to build connection with "+
- "partner %s: %+v", requestor.ID, err)
- // Send a nil connection to avoid hold-ups down the line
- a.requestCallback(nil)
- }
- // After confirmation, get the new partner
- newPartner, err := e2e.GetE2E().GetPartner(requestor.ID)
- if err != nil {
- jww.ERROR.Printf("Unable to build connection with "+
- "partner %s: %+v", requestor.ID, err)
- // Send a nil connection to avoid hold-ups down the line
- a.requestCallback(nil)
-
- return
- }
-
- // Return the new Connection object
- a.requestCallback(BuildConnection(newPartner, e2e.GetE2E(),
- a.authState, a.connectionParams))
-}
-
-// Reset will be called when an auth Reset operation occurs.
-func (a authCallback) Reset(requestor contact.Contact,
- receptionID receptionID.EphemeralIdentity, round rounds.Round,
- e2e *xxdk.E2e) {
-}
-
// FirstPartitionSize returns the max partition payload size for the
// first payload
func (h *handler) FirstPartitionSize() uint {
diff --git a/xxdk/e2e.go b/xxdk/e2e.go
index cb21a4fdded8f573f73649b792ddbdc68252304f..8e387c078047de544f126bbdadafe4dff43ec15b 100644
--- a/xxdk/e2e.go
+++ b/xxdk/e2e.go
@@ -38,6 +38,8 @@ type E2e struct {
e2eIdentity ReceptionIdentity
}
+// AuthCallbacks is an adapter for the auth.Callbacks interface
+// that allows for initializing an E2e object without an E2e-dependant auth.Callbacks
type AuthCallbacks interface {
Request(partner contact.Contact, receptionID receptionID.EphemeralIdentity,
round rounds.Round, e2e *E2e)
@@ -86,12 +88,10 @@ func LoginLegacy(client *Cmix, params E2EParams, callbacks AuthCallbacks) (
"the e2e processies")
}
- acw := MakeAuthCB(m, callbacks)
-
- m.auth, err = auth.NewStateLegacy(client.GetStorage().GetKV(),
- client.GetCmix(), m.e2e, client.GetRng(),
- client.GetEventReporter(), params.Auth, params.Session,
- acw, m.backup.TriggerBackup)
+ m.auth, err = auth.NewState(client.GetStorage().GetKV(), client.GetCmix(),
+ m.e2e, client.GetRng(), client.GetEventReporter(), params.Auth,
+ params.Session, MakeAuthCallbacksAdapter(callbacks, m),
+ m.backup.TriggerBackup)
if err != nil {
return nil, err
}
@@ -184,8 +184,6 @@ func LoginWithProtoClient(storageDir string, password []byte,
return nil, err
}
- c.network.AddIdentity(c.GetUser().ReceptionID, time.Time{}, true)
-
err = c.registerFollower()
if err != nil {
return nil, err
@@ -220,6 +218,8 @@ func login(client *Cmix, callbacks AuthCallbacks, identity ReceptionIdentity,
e2eIdentity: identity,
}
+ client.network.AddIdentity(identity.ID, time.Time{}, true)
+
//initialize the e2e storage
err = e2e.Init(kv, identity.ID, identity.DHKeyPrivate, e2eGrp,
rekey.GetDefaultEphemeralParams())
@@ -255,11 +255,10 @@ func login(client *Cmix, callbacks AuthCallbacks, identity ReceptionIdentity,
"the e2e processies")
}
- acw := MakeAuthCB(m, callbacks)
-
m.auth, err = auth.NewState(kv, client.GetCmix(),
m.e2e, client.GetRng(), client.GetEventReporter(),
- params.Auth, params.Session, acw, m.backup.TriggerBackup)
+ params.Auth, params.Session,
+ MakeAuthCallbacksAdapter(callbacks, m), m.backup.TriggerBackup)
if err != nil {
return nil, err
}
@@ -426,8 +425,16 @@ func (m *E2e) DeleteContact(partnerId *id.ID) error {
return nil
}
-// Adapter type to make the xxdk auth callbacks type compatible with the
-// auth.callbacks
+// MakeAuthCallbacksAdapter creates an authCallbacksAdapter
+func MakeAuthCallbacksAdapter(ac AuthCallbacks, e2e *E2e) *authCallbacksAdapter {
+ return &authCallbacksAdapter{
+ ac: ac,
+ e2e: e2e,
+ }
+}
+
+// authCallbacksAdapter is an adapter type to make the AuthCallbacks type
+// compatible with the auth.Callbacks type
type authCallbacksAdapter struct {
ac AuthCallbacks
e2e *E2e