"github.com/matrix-org/dendrite/setup/jetstream"

"github.com/matrix-org/dendrite/setup/process"

"github.com/sirupsen/logrus"

appserviceAPI "github.com/matrix-org/dendrite/appservice/api"

"github.com/matrix-org/dendrite/appservice/consumers"

"github.com/matrix-org/dendrite/appservice/query"

func generateAppServiceAccount(

userAPI userapi.AppserviceUserAPI,

as config.ApplicationService,

) error {

var accRes userapi.PerformAccountCreationResponse

err := userAPI.PerformAccountCreation(context.Background(), &userapi.PerformAccountCreationRequest{

"github.com/matrix-org/dendrite/setup/jetstream"

"github.com/matrix-org/dendrite/test"

"github.com/matrix-org/dendrite/userapi"

"github.com/matrix-org/dendrite/test/testrig"

)

room := test.NewRoom(t, alice)

// Invite Bob

"membership": "invite",

}, test.WithStateKey(bob.ID))

t.Fatal(err)

}

for _, ev := range txn.Events {

continue

}

// Usually we would check the event content for the membership, but since

"time"

"github.com/matrix-org/gomatrixserverlib"

"github.com/nats-io/nats.go"

"github.com/matrix-org/dendrite/roomserver/api"

return true

}

if appservice.IsInterestedInUserID(*event.StateKey()) {

return true

}

switch {

case ev.StateKey == nil:

continue

continue

}

var membership gomatrixserverlib.MemberContent

switch {

case err != nil:

continue

if appservice.IsInterestedInUserID(*ev.StateKey) {

return true

}

cfg.Global.TrustedIDServers = []string{}

cfg.Global.KeyID = gomatrixserverlib.KeyID(signing.KeyID)

cfg.Global.PrivateKey = sk

cfg.ClientAPI.RegistrationDisabled = false

cfg.ClientAPI.OpenRegistrationWithoutVerificationEnabled = true

"github.com/matrix-org/dendrite/setup/process"

userapiAPI "github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/pinecone/types"

"github.com/sirupsen/logrus"

}

}

hexKey, decodeErr := hex.DecodeString(string(userID.Domain()))

if decodeErr != nil || len(hexKey) != ed25519.PublicKeySize {

return "", fmt.Errorf("UserID domain is not a valid ed25519 public key: %v", userID.Domain())

if decodeErr != nil || len(hexKey) != ed25519.PublicKeySize {

return "", fmt.Errorf("Relay server uri is not a valid ed25519 public key: %v", nodeID)

} else {

}

}

}

func (m *DendriteMonolith) SetRelayServers(nodeID string, uris string) {

for _, uri := range strings.Split(uris, ",") {

uri = strings.TrimSpace(uri)

if len(uri) == 0 {

m.p2pMonolith.RelayRetriever.SetRelayServers(relays)

} else {

relay.UpdateNodeRelayServers(

relays,

m.p2pMonolith.ProcessCtx.Context(),

m.p2pMonolith.GetFederationAPI(),

relaysString += string(relay)

}

} else {

response := api.P2PQueryRelayServersResponse{}

err := m.p2pMonolith.GetFederationAPI().P2PQueryRelayServers(m.p2pMonolith.ProcessCtx.Context(), &request, &response)

if err != nil {

pubkey := m.p2pMonolith.Router.PublicKey()

userID := userutil.MakeUserID(

localpart,

)

userReq := &userapiAPI.PerformAccountCreationRequest{

AccountType: userapiAPI.AccountTypeUser,

prefix := hex.EncodeToString(pk)

cfg := monolith.GenerateDefaultConfig(sk, m.StorageDirectory, m.CacheDirectory, prefix)

cfg.Global.KeyID = gomatrixserverlib.KeyID(signing.KeyID)

cfg.Global.JetStream.InMemory = false

// NOTE : disabled for now since there is a 64 bit alignment panic on 32 bit systems

"strings"

"testing"

)

func TestMonolithStarts(t *testing.T) {

name string

serverKey string

expectedErr bool

}{

{

name: "valid userid as key",

"github.com/matrix-org/dendrite/test"

"github.com/matrix-org/dendrite/userapi"

"github.com/matrix-org/gomatrixserverlib"

"github.com/sirupsen/logrus"

_ "golang.org/x/mobile/bind"

Generate: true,

SingleDatabase: true,

})

cfg.Global.PrivateKey = sk

cfg.Global.KeyID = gomatrixserverlib.KeyID(signing.KeyID)

cfg.Global.JetStream.StoragePath = config.Path(fmt.Sprintf("%s/", m.StorageDirectory))

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/dendrite/setup/jetstream"

"github.com/matrix-org/dendrite/syncapi"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

"github.com/tidwall/gjson"

room := test.NewRoom(t, aliceAdmin, test.RoomPreset(test.PresetTrustedPrivateChat))

// Invite Bob

"membership": "invite",

}, test.WithStateKey(bob.ID))

room := test.NewRoom(t, aliceAdmin)

// Join Bob

"membership": "join",

}, test.WithStateKey(bob.ID))

room2 := test.NewRoom(t, aliceAdmin)

// Join Bob

"membership": "join",

}, test.WithStateKey(bob.ID))

"membership": "join",

}, test.WithStateKey(bob.ID))

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

)

var (

ctx = context.Background()

// space separated localpart+password -> account

lookup = make(map[string]*api.Account)

device = &api.Device{

"time"

"github.com/matrix-org/gomatrixserverlib"

"github.com/nats-io/nats.go"

log "github.com/sirupsen/logrus"

TopicTypingEvent string

TopicPresenceEvent string

JetStream nats.JetStreamContext

UserAPI userapi.ClientUserAPI

}

func (p *SyncAPIProducer) SendReceipt(

ctx context.Context,

) error {

m := &nats.Msg{

Subject: p.TopicReceiptEvent,

m.Header.Set("status_msg", *statusMsg)

}

_, err := p.JetStream.PublishMsg(m, nats.Context(ctx))

return err

"github.com/gorilla/mux"

"github.com/matrix-org/dendrite/internal"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

"github.com/nats-io/nats.go"

"github.com/sirupsen/logrus"

&roomserverAPI.PerformAdminDownloadStateRequest{

UserID: device.UserID,

RoomID: roomID,

},

res,

); err != nil {

"github.com/matrix-org/dendrite/roomserver/api"

userapi "github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

)

req *http.Request, rsAPI api.ClientRoomserverAPI, device *userapi.Device, roomID string,

) util.JSONResponse {

stateTuple := gomatrixserverlib.StateKeyTuple{

StateKey: "",

}

stateReq := &api.QueryCurrentStateRequest{

return util.ErrorResponse(fmt.Errorf("historyVisEvent.HistoryVisibility: %w", err))

}

}

queryReq := api.QueryMembershipForUserRequest{

RoomID: roomID,

UserID: device.UserID,

roomserverAPI "github.com/matrix-org/dendrite/roomserver/api"

roomserverVersion "github.com/matrix-org/dendrite/roomserver/version"

"github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/dendrite/clientapi/httputil"

"github.com/matrix-org/dendrite/clientapi/jsonerror"

createContent["room_version"] = roomVersion

powerLevelContent := eventutil.InitialPowerLevelsContent(userID)

joinRuleContent := gomatrixserverlib.JoinRuleContent{

}

historyVisibilityContent := gomatrixserverlib.HistoryVisibilityContent{

HistoryVisibility: historyVisibilityShared,

switch r.Preset {

case presetPrivateChat:

historyVisibilityContent.HistoryVisibility = historyVisibilityShared

case presetTrustedPrivateChat:

historyVisibilityContent.HistoryVisibility = historyVisibilityShared

for _, invitee := range r.Invite {

powerLevelContent.Users[invitee] = 100

}

case presetPublicChat:

historyVisibilityContent.HistoryVisibility = historyVisibilityShared

}

createEvent := fledglingEvent{

Content: createContent,

}

powerLevelEvent := fledglingEvent{

Content: powerLevelContent,

}

joinRuleEvent := fledglingEvent{

Content: joinRuleContent,

}

historyVisibilityEvent := fledglingEvent{

Content: historyVisibilityContent,

}

membershipEvent := fledglingEvent{

StateKey: userID,

Content: gomatrixserverlib.MemberContent{

DisplayName: profile.DisplayName,

AvatarURL: profile.AvatarURL,

},

if r.Name != "" {

nameEvent = &fledglingEvent{

Content: eventutil.NameContent{

Name: r.Name,

},

if r.Topic != "" {

topicEvent = &fledglingEvent{

Content: eventutil.TopicContent{

Topic: r.Topic,

},

if r.GuestCanJoin {

guestAccessEvent = &fledglingEvent{

Content: eventutil.GuestAccessContent{

GuestAccess: "can_join",

},

}

aliasEvent = &fledglingEvent{

Content: eventutil.CanonicalAlias{

Alias: roomAlias,

},

}

switch r.InitialState[i].Type {

continue

powerLevelEvent = r.InitialState[i]

joinRuleEvent = r.InitialState[i]

historyVisibilityEvent = r.InitialState[i]

guestAccessEvent = &r.InitialState[i]

nameEvent = &r.InitialState[i]

topicEvent = &r.InitialState[i]

default:

// If this is a direct message then we should invite the participants.

if len(r.Invite) > 0 {

// Build some stripped state for the invite.

for _, event := range builtEvents {

// Chosen events from the spec:

// https://spec.matrix.org/v1.3/client-server-api/#stripped-state

switch event.Type() {

fallthrough

fallthrough

fallthrough

fallthrough

fallthrough

fallthrough

fallthrough

ev := event.Event

globalStrippedState = append(

globalStrippedState,

)

}

}

for _, invitee := range r.Invite {

// Build the invite event.

inviteEvent, err := buildMembershipEvent(

roomID, r.IsDirect, cfg, evTime, rsAPI, asAPI,

)

if err != nil {

}

inviteStrippedState := append(

globalStrippedState,

)

// Send the invite event to the roomserver.

var inviteRes roomserverAPI.PerformInviteResponse

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

"github.com/matrix-org/dendrite/clientapi/httputil"

Servers []string `json:"servers"`

}

r.Servers = make([]string, len(servers))

for i, s := range servers {

r.Servers[i] = string(s)

var v roomVisibility

if len(res.RoomIDs) == 1 {

} else {

v.Visibility = "private"

}

queryEventsReq := roomserverAPI.QueryLatestEventsAndStateRequest{

RoomID: roomID,

StateToFetch: []gomatrixserverlib.StateKeyTuple{{

StateKey: "",

}},

}

// NOTSPEC: Check if the user's power is greater than power required to change m.room.canonical_alias event

power, _ := gomatrixserverlib.NewPowerLevelContentFromEvent(queryEventsRes.StateEvents[0].Event)

return util.JSONResponse{

Code: http.StatusForbidden,

JSON: jsonerror.Forbidden("userID doesn't have power level to change visibility"),

"strings"

"sync"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

"github.com/matrix-org/dendrite/clientapi/api"

}

}

if serverName != "" && !cfg.Matrix.IsLocalServerName(serverName) {

res, err := federation.GetPublicRoomsFiltered(

req.Context(), cfg.Matrix.ServerName, serverName,

"github.com/matrix-org/dendrite/clientapi/jsonerror"

roomserverAPI "github.com/matrix-org/dendrite/roomserver/api"

"github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/util"

)

for _, serverName := range serverNames {

joinReq.ServerNames = append(

joinReq.ServerNames,

)

}

}

"time"

"github.com/matrix-org/gomatrixserverlib"

appserviceAPI "github.com/matrix-org/dendrite/appservice/api"

"github.com/matrix-org/dendrite/clientapi/auth/authtypes"

}

}

}

func sendMembership(ctx context.Context, profileAPI userapi.ClientUserAPI, device *userapi.Device,

return util.ErrorResponse(err)

}

// kick is only valid if the user is not currently banned or left (that is, they are joined or invited)

return util.JSONResponse{

Code: http.StatusForbidden,

JSON: jsonerror.Unknown("cannot /kick banned or left users"),

}

}

// TODO: should we be using SendLeave instead?

}

func SendUnban(

}

// unban is only valid if the user is currently banned

return util.JSONResponse{

Code: http.StatusBadRequest,

JSON: jsonerror.Unknown("can only /unban users that are banned"),

}

}

// TODO: should we be using SendLeave instead?

}

func SendInvite(

asAPI appserviceAPI.AppServiceInternalAPI, evTime time.Time,

) (util.JSONResponse, error) {

event, err := buildMembershipEvent(

roomID, false, cfg, evTime, rsAPI, asAPI,

)

if err != nil {

func getPowerlevels(req *http.Request, rsAPI roomserverAPI.ClientRoomserverAPI, roomID string) (*gomatrixserverlib.PowerLevelContent, *util.JSONResponse) {

plEvent := roomserverAPI.GetStateEvent(req.Context(), rsAPI, roomID, gomatrixserverlib.StateKeyTuple{

StateKey: "",

})

if plEvent == nil {

"github.com/matrix-org/dendrite/clientapi/jsonerror"

roomserverAPI "github.com/matrix-org/dendrite/roomserver/api"

"github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/util"

)

for _, serverName := range serverNames {

peekReq.ServerNames = append(

peekReq.ServerNames,

)

}

}

"github.com/matrix-org/dendrite/setup/jetstream"

"github.com/matrix-org/dendrite/syncapi/types"

"github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/util"

"github.com/nats-io/nats.go"

log "github.com/sirupsen/logrus"

}

}

currentlyActive := p.CurrentlyActive()

return util.JSONResponse{

Code: http.StatusOK,

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

appserviceAPI "github.com/matrix-org/dendrite/appservice/api"

"github.com/matrix-org/dendrite/clientapi/auth/authtypes"

}

content := gomatrixserverlib.MemberContent{

}

content.DisplayName = newProfile.DisplayName

"github.com/matrix-org/dendrite/clientapi/jsonerror"

"github.com/matrix-org/dendrite/clientapi/producers"

"github.com/matrix-org/dendrite/userapi/api"

userapi "github.com/matrix-org/dendrite/userapi/api"

)

func SetReceipt(req *http.Request, userAPI api.ClientUserAPI, syncProducer *producers.SyncAPIProducer, device *userapi.Device, roomID, receiptType, eventID string) util.JSONResponse {

logrus.WithFields(logrus.Fields{

"roomID": roomID,

"receiptType": receiptType,

"time"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

"github.com/matrix-org/dendrite/clientapi/httputil"

allowedToRedact := ev.Sender() == device.UserID

if !allowedToRedact {

plEvent := roomserverAPI.GetStateEvent(req.Context(), rsAPI, roomID, gomatrixserverlib.StateKeyTuple{

StateKey: "",

})

if plEvent == nil {

builder := gomatrixserverlib.EventBuilder{

Sender: device.UserID,

RoomID: roomID,

Redacts: eventID,

}

err := builder.SetContent(r)

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/tokens"

"github.com/matrix-org/util"

"github.com/prometheus/client_golang/prometheus"

// previous parameters with the ones supplied. This mean you cannot "build up" request params.

type registerRequest struct {

// registration parameters

// user-interactive auth params

Auth authDict `json:"auth"`

}

var r registerRequest

if v := cfg.Matrix.VirtualHostForHTTPHost(host); v != nil {

r.ServerName = v.ServerName

} else {

func completeRegistration(

ctx context.Context,

userAPI userapi.ClientUserAPI,

password, appserviceID, ipAddr, userAgent, sessionID string,

inhibitLogin eventutil.WeakBoolean,

deviceDisplayName, deviceID *string,

// Squash username to all lowercase letters

username = strings.ToLower(username)

domain := cfg.Matrix.ServerName

if v := cfg.Matrix.VirtualHostForHTTPHost(host); v != nil {

domain = v.ServerName

}

"github.com/gorilla/mux"

"github.com/matrix-org/dendrite/setup/base"

userapi "github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

"github.com/nats-io/nats.go"

"github.com/prometheus/client_golang/prometheus"

}),

).Methods(http.MethodPost, http.MethodOptions)

v3mux.Handle("/join/{roomIDOrAlias}",

if r := rateLimits.Limit(req, device); r != nil {

return *r

}

if mscCfg.Enabled("msc2753") {

v3mux.Handle("/peek/{roomIDOrAlias}",

if r := rateLimits.Limit(req, device); r != nil {

return *r

}

}, httputil.WithAllowGuests()),

).Methods(http.MethodGet, http.MethodOptions)

v3mux.Handle("/rooms/{roomID}/join",

if r := rateLimits.Limit(req, device); r != nil {

return *r

}

}, httputil.WithAllowGuests()),

).Methods(http.MethodPost, http.MethodOptions)

v3mux.Handle("/rooms/{roomId}/receipt/{receiptType}/{eventId}",

if r := rateLimits.Limit(req, device); r != nil {

return *r

}

"time"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

"github.com/prometheus/client_golang/prometheus"

"github.com/sirupsen/logrus"

// If we're sending a membership update, make sure to strip the authorised

// via key if it is present, otherwise other servers won't be able to auth

// the event if the room is set to the "restricted" join rule.

delete(r, "join_authorised_via_users_server")

}

timeToGenerateEvent := time.Since(startedGeneratingEvent)

// validate that the aliases exists

aliasReq := api.AliasEvent{}

if err = json.Unmarshal(e.Content(), &aliasReq); err != nil {

return util.ErrorResponse(fmt.Errorf("unable to parse alias event: %w", err))

"github.com/matrix-org/dendrite/syncapi/synctypes"

userapi "github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

log "github.com/sirupsen/logrus"

)

// that marks the room as world-readable. If we don't then we assume that

// the room is not world-readable.

for _, ev := range stateRes.StateEvents {

content := map[string]string{}

if err := json.Unmarshal(ev.Content(), &content); err != nil {

util.GetLogger(ctx).WithError(err).Error("json.Unmarshal for history visibility failed")

StateKey: stateKey,

},

}

stateToFetch = append(stateToFetch, gomatrixserverlib.StateKeyTuple{

StateKey: "",

})

}

// that marks the room as world-readable. If we don't then we assume that

// the room is not world-readable.

for _, ev := range stateRes.StateEvents {

content := map[string]string{}

if err := json.Unmarshal(ev.Content(), &content); err != nil {

util.GetLogger(ctx).WithError(err).Error("json.Unmarshal for history visibility failed")

}

// If the user has never been in the room then stop at this point.

// We won't tell the user about a room they have never joined.

return util.JSONResponse{

Code: http.StatusForbidden,

JSON: jsonerror.Forbidden(fmt.Sprintf("Unknown room %q or user %q has never joined this room", roomID, device.UserID)),

"github.com/matrix-org/gomatrix"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

)

searchString string,

limit int,

federation *fclient.FederationClient,

) util.JSONResponse {

if limit < 10 {

limit = 10

"github.com/matrix-org/dendrite/setup/config"

userapi "github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib"

)

// MembershipRequest represents the body of an incoming POST request

}

var pubKeyRes struct {

}

if resp.StatusCode != http.StatusOK {

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/gomatrixserverlib"

)

// ParseUsernameParam extracts localpart from usernameParam.

// usernameParam can either be a user ID or just the localpart/username.

// If serverName is passed, it is verified against the domain obtained from usernameParam (if present)

// Returns error in case of invalid usernameParam.

localpart := usernameParam

if strings.HasPrefix(usernameParam, "@") {

}

// MakeUserID generates user ID from localpart & server name

return fmt.Sprintf("@%s:%s", localpart, string(server))

}

"testing"

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/gomatrixserverlib/fclient"

)

var (

)

// TestGoodUserID checks that correct localpart is returned for a valid user ID.

package defaults

"3bf0258d23c60952639cc4c69c71d1508a7d43a0475d9000ff900a1848411ec7": {},

}

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/dendrite/setup/process"

"github.com/matrix-org/gomatrixserverlib"

"github.com/sirupsen/logrus"

pineconeRouter "github.com/matrix-org/pinecone/router"

cfg = monolith.GenerateDefaultConfig(sk, *instanceDir, *instanceDir, *instanceName)

}

cfg.Global.KeyID = gomatrixserverlib.KeyID(signing.KeyID)

p2pMonolith := monolith.P2PMonolith{}

"github.com/matrix-org/dendrite/setup/process"

"github.com/matrix-org/dendrite/userapi"

userAPI "github.com/matrix-org/dendrite/userapi/api"

"github.com/sirupsen/logrus"

pineconeConnections "github.com/matrix-org/pinecone/connections"

eLog := logrus.WithField("pinecone", "events")

p.RelayRetriever = relay.NewRelayServerRetriever(

context.Background(),

p.dendrite.FederationAPI,

p.dendrite.RelayAPI,

stopRelayServerSync,

// eLog.Info("Broadcast received from: ", e.PeerID)

req := &federationAPI.PerformWakeupServersRequest{

}

res := &federationAPI.PerformWakeupServersResponse{}

if err := p.dendrite.FederationAPI.PerformWakeupServers(p.ProcessCtx.Context(), req, res); err != nil {

federationAPI "github.com/matrix-org/dendrite/federationapi/api"

relayServerAPI "github.com/matrix-org/dendrite/relayapi/api"

"github.com/sirupsen/logrus"

"go.uber.org/atomic"

)

type RelayServerRetriever struct {

ctx context.Context

federationAPI federationAPI.FederationInternalAPI

relayAPI relayServerAPI.RelayInternalAPI

queriedServersMutex sync.Mutex

running atomic.Bool

quit chan bool

func NewRelayServerRetriever(

ctx context.Context,

federationAPI federationAPI.FederationInternalAPI,

relayAPI relayServerAPI.RelayInternalAPI,

quit chan bool,

serverName: serverName,

federationAPI: federationAPI,

relayAPI: relayAPI,

running: *atomic.NewBool(false),

quit: quit,

}

}

func (r *RelayServerRetriever) InitializeRelayServers(eLog *logrus.Entry) {

response := federationAPI.P2PQueryRelayServersResponse{}

err := r.federationAPI.P2PQueryRelayServers(r.ctx, &request, &response)

if err != nil {

eLog.Infof("Registered relay servers: %v", response.RelayServers)

}

UpdateNodeRelayServers(r.serverName, servers, r.ctx, r.federationAPI)

// Replace list of servers to sync with and mark them all as unsynced.

r.queriedServersMutex.Lock()

defer r.queriedServersMutex.Unlock()

for _, server := range servers {

r.relayServersQueried[server] = false

}

r.StartSync()

}

r.queriedServersMutex.Lock()

defer r.queriedServersMutex.Unlock()

for server := range r.relayServersQueried {

relayServers = append(relayServers, server)

}

return relayServers

}

r.queriedServersMutex.Lock()

defer r.queriedServersMutex.Unlock()

for server, queried := range r.relayServersQueried {

result[server] = queried

}

t := time.NewTimer(relayServerRetryInterval)

for {

func() {

r.queriedServersMutex.Lock()

defer r.queriedServersMutex.Unlock()

}

}

logrus.Info("Querying relay servers for any available transactions")

for _, server := range relayServers {

if err != nil {

return

}

}

func UpdateNodeRelayServers(

ctx context.Context,

fedAPI federationAPI.FederationInternalAPI,

) {

}

// Remove old, non-matching relays

for _, existingServer := range response.RelayServers {

shouldRemove := true

for _, newServer := range relays {

federationAPI "github.com/matrix-org/dendrite/federationapi/api"

relayServerAPI "github.com/matrix-org/dendrite/relayapi/api"

"github.com/sirupsen/logrus"

"github.com/stretchr/testify/assert"

"gotest.tools/v3/poll"

)

type FakeFedAPI struct {

federationAPI.FederationInternalAPI

func (r *FakeRelayAPI) PerformRelayServerSync(

ctx context.Context,

) error {

return nil

}

"github.com/matrix-org/dendrite/cmd/dendrite-demo-pinecone/defaults"

"github.com/matrix-org/dendrite/federationapi/api"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

pineconeRouter "github.com/matrix-org/pinecone/router"

}

func (p *PineconeRoomProvider) Rooms() []fclient.PublicRoom {

for k := range defaults.DefaultServerNames {

list[k] = struct{}{}

}

for _, k := range p.r.Peers() {

}

return bulkFetchPublicRoomsFromServers(

context.Background(), p.fedClient,

)

}

// Returns a list of public rooms.

func bulkFetchPublicRoomsFromServers(

ctx context.Context, fedClient *fclient.FederationClient,

) (publicRooms []fclient.PublicRoom) {

limit := 200

// follow pipeline semantics, see https://blog.golang.org/pipelines for more info.

// concurrently query for public rooms

reqctx, reqcancel := context.WithTimeout(ctx, time.Second*5)

for hs := range homeservers {

defer wg.Done()

util.GetLogger(reqctx).WithField("hs", homeserverDomain).Info("Querying HS for public rooms")

fres, err := fedClient.GetPublicRooms(reqctx, origin, homeserverDomain, int(limit), "", false, "")

clienthttputil "github.com/matrix-org/dendrite/clientapi/httputil"

"github.com/matrix-org/dendrite/cmd/dendrite-demo-pinecone/defaults"

userapi "github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

pineconeRouter "github.com/matrix-org/pinecone/router"

}

func (p *PineconeUserProvider) QuerySearchProfiles(ctx context.Context, req *userapi.QuerySearchProfilesRequest, res *userapi.QuerySearchProfilesResponse) error {

for k := range defaults.DefaultServerNames {

list[k] = struct{}{}

}

for _, k := range p.r.Peers() {

}

res.Profiles = bulkFetchUserDirectoriesFromServers(context.Background(), req, p.fedClient, list)

return nil

func bulkFetchUserDirectoriesFromServers(

ctx context.Context, req *userapi.QuerySearchProfilesRequest,

fedClient *fclient.FederationClient,

) (profiles []authtypes.Profile) {

jsonBody, err := json.Marshal(req)

if err != nil {

// concurrently query for public rooms

reqctx, reqcancel := context.WithTimeout(ctx, time.Second*5)

for hs := range homeservers {

defer wg.Done()

util.GetLogger(reqctx).WithField("hs", homeserverDomain).Info("Querying HS for users")

"github.com/matrix-org/dendrite/setup/jetstream"

"github.com/matrix-org/dendrite/setup/process"

"github.com/matrix-org/gomatrixserverlib"

"github.com/gorilla/mux"

"github.com/matrix-org/dendrite/appservice"

}

}

cfg.Global.KeyID = gomatrixserverlib.KeyID(signing.KeyID)

configErrors := &config.ConfigErrors{}

"time"

"github.com/matrix-org/gomatrixserverlib"

)

const KeyID = "ed25519:dendrite-demo-yggdrasil"

func (f *YggdrasilKeys) FetchKeys(

ctx context.Context,

) (map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult, error) {

res := make(map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult)

for req := range requests {

Key: hexkey,

},

ExpiredTS: gomatrixserverlib.PublicKeyNotExpired,

}

}

return res, nil

"regexp"

"strings"

"github.com/neilalexander/utp"

"github.com/sirupsen/logrus"

return len(n.core.GetPeers())

}

nodemap := map[string]struct{}{}

for _, peer := range n.core.GetPeers() {

nodemap[hex.EncodeToString(peer.Key)] = struct{}{}

}

for node := range nodemap {

}

return nodes

}

"github.com/matrix-org/dendrite/cmd/dendrite-demo-yggdrasil/yggconn"

"github.com/matrix-org/dendrite/federationapi/api"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

)

func (p *YggdrasilRoomProvider) Rooms() []fclient.PublicRoom {

return bulkFetchPublicRoomsFromServers(

context.Background(), p.fedClient,

p.node.KnownNodes(),

)

}

// Returns a list of public rooms.

func bulkFetchPublicRoomsFromServers(

ctx context.Context, fedClient *fclient.FederationClient,

) (publicRooms []fclient.PublicRoom) {

limit := 200

// follow pipeline semantics, see https://blog.golang.org/pipelines for more info.

wg.Add(len(homeservers))

// concurrently query for public rooms

for _, hs := range homeservers {

defer wg.Done()

util.GetLogger(ctx).WithField("hs", homeserverDomain).Info("Querying HS for public rooms")

fres, err := fedClient.GetPublicRooms(ctx, origin, homeserverDomain, int(limit), "", false, "")

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

)

var requestFrom = flag.String("from", "", "the server name that the request should originate from")

panic("unexpected key block")

}

client := fclient.NewFederationClient(

[]*fclient.SigningIdentity{

{

}

}

method,

serverName,

u.RequestURI(),

)

}

if err = req.Sign(

gomatrixserverlib.KeyID(keyBlock.Headers["Key-ID"]),

privateKey,

); err != nil {

"fmt"

"path/filepath"

"golang.org/x/crypto/bcrypt"

"gopkg.in/yaml.v2"

"github.com/matrix-org/dendrite/setup/config"

)

func main() {

SingleDatabase: true,

})

if *serverName != "" {

}

uri := config.DataSource(*dbURI)

if uri.IsSQLite() || uri == "" {

"github.com/matrix-org/gomatrix"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/dendrite/federationapi/types"

)

P2PFederationAPI

QueryServerKeys(ctx context.Context, request *QueryServerKeysRequest, response *QueryServerKeysResponse) error

// Broadcasts an EDU to all servers in rooms we are joined to. Used in the yggdrasil demos.

PerformBroadcastEDU(

// containing only the server names (without information for membership events).

// The response will include this server if they are joined to the room.

QueryJoinedHostServerNamesInRoom(ctx context.Context, request *QueryJoinedHostServerNamesInRoomRequest, response *QueryJoinedHostServerNamesInRoomResponse) error

}

type P2PFederationAPI interface {

// implements as proxy calls, with built-in backoff/retries/etc. Errors returned from functions in

// this interface are of type FederationClientError

type KeyserverFederationAPI interface {

}

// an interface for gmsl.FederationClient - contains functions called by federationapi only.

SendTransaction(ctx context.Context, t gomatrixserverlib.Transaction) (res fclient.RespSend, err error)

// Perform operations

}

type P2PFederationClient interface {

}

// FederationClientError is returned from FederationClient methods in the event of a problem.

}

type QueryServerKeysRequest struct {

KeyIDToCriteria map[gomatrixserverlib.KeyID]gomatrixserverlib.PublicKeyNotaryQueryCriteria

}

}

type QueryPublicKeysRequest struct {

}

type QueryPublicKeysResponse struct {

}

type PerformDirectoryLookupRequest struct {

}

type PerformDirectoryLookupResponse struct {

}

type PerformJoinRequest struct {

}

type PerformJoinResponse struct {

LastError *gomatrix.HTTPError

}

}

type PerformInviteRequest struct {

}

type PerformInviteResponse struct {

// QueryJoinedHostServerNamesInRoomResponse is a response to QueryJoinedHostServerNames

type QueryJoinedHostServerNamesInRoomResponse struct {

}

type PerformBroadcastEDURequest struct {

}

type PerformWakeupServersRequest struct {

}

type PerformWakeupServersResponse struct {

}

type P2PQueryRelayServersRequest struct {

}

type P2PQueryRelayServersResponse struct {

}

type P2PAddRelayServersRequest struct {

}

type P2PAddRelayServersResponse struct {

}

type P2PRemoveRelayServersRequest struct {

}

type P2PRemoveRelayServersResponse struct {

"context"

"github.com/matrix-org/gomatrixserverlib"

)

type ServersInRoomProvider interface {

}

"github.com/getsentry/sentry-go"

"github.com/matrix-org/gomatrixserverlib"

"github.com/nats-io/nats.go"

"github.com/sirupsen/logrus"

durable string

db storage.Database

queues *queue.OutgoingQueues

rsAPI roomserverAPI.FederationRoomserverAPI

topic string

}

}

// Pack the EDU and marshal it

edu := &gomatrixserverlib.EDU{

Origin: string(originServerName),

}

event := gomatrixserverlib.DeviceListUpdateEvent{

"github.com/matrix-org/dendrite/setup/process"

"github.com/matrix-org/dendrite/syncapi/types"

"github.com/matrix-org/gomatrixserverlib"

"github.com/nats-io/nats.go"

log "github.com/sirupsen/logrus"

)

durable string

db storage.Database

queues *queue.OutgoingQueues

rsAPI roomserverAPI.FederationRoomserverAPI

topic string

outboundPresenceEnabled bool

statusMsg = &status

}

content := fedTypes.Presence{

Push: []fedTypes.PresenceContent{

}

edu := &gomatrixserverlib.EDU{

Origin: string(serverName),

}

if edu.Content, err = json.Marshal(content); err != nil {

"github.com/matrix-org/dendrite/setup/process"

syncTypes "github.com/matrix-org/dendrite/syncapi/types"

"github.com/matrix-org/gomatrixserverlib"

"github.com/nats-io/nats.go"

log "github.com/sirupsen/logrus"

)

durable string

db storage.Database

queues *queue.OutgoingQueues

topic string

}

return true

}

joined, err := t.db.GetJoinedHosts(ctx, receipt.RoomID)

if err != nil {

return false

}

for i := range joined {

names[i] = joined[i].ServerName

}

}

edu := &gomatrixserverlib.EDU{

Origin: string(receiptServerName),

}

if edu.Content, err = json.Marshal(content); err != nil {

"time"

syncAPITypes "github.com/matrix-org/dendrite/syncapi/types"

"github.com/matrix-org/gomatrixserverlib"

"github.com/nats-io/nats.go"

}

// If we added new hosts, inform them about our known presence events for this room

membership, _ := ore.Event.Membership()

s.sendPresence(ore.Event.RoomID(), addsJoinedHosts)

}

}

// Send the event.

return s.queues.SendEvent(

)

}

func (s *OutputRoomEventConsumer) sendPresence(roomID string, addedJoined []types.JoinedHost) {

for _, added := range addedJoined {

joined = append(joined, added.ServerName)

}

continue

}

content.Push = append(content.Push, types.PresenceContent{

CurrentlyActive: p.CurrentlyActive(),

}

edu := &gomatrixserverlib.EDU{

Origin: string(s.cfg.Matrix.ServerName),

}

if edu.Content, err = json.Marshal(content); err != nil {

// Returns an error if there was a problem talking to the room server.

func (s *OutputRoomEventConsumer) joinedHostsAtEvent(

ore api.OutputNewRoomEvent, oldJoinedHosts []types.JoinedHost,

// Combine the delta into a single delta so that the adds and removes can

// cancel each other out. This should reduce the number of times we need

// to fetch a state event from the room server.

removed[eventID] = true

}

for _, joinedHost := range oldJoinedHosts {

if removed[joinedHost.MemberEventID] {

// This m.room.member event is part of the current state of the

joined[inboundPeek.ServerName] = true

}

for serverName, include := range joined {

if include {

result = append(result, serverName)

if err != nil {

return nil, err

}

continue

}

_, serverName, err := gomatrixserverlib.SplitID('@', *ev.StateKey())

"github.com/getsentry/sentry-go"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

"github.com/nats-io/nats.go"

log "github.com/sirupsen/logrus"

durable string

db storage.Database

queues *queue.OutgoingQueues

topic string

}

// Pack the EDU and marshal it

edu := &gomatrixserverlib.EDU{

Origin: string(originServerName),

}

tdm := gomatrixserverlib.ToDeviceMessage{

}

log.Debugf("Sending send-to-device message into %q destination queue", destServerName)

log.WithError(err).Error("failed to send EDU")

return false

}

"github.com/matrix-org/dendrite/setup/jetstream"

"github.com/matrix-org/dendrite/setup/process"

"github.com/matrix-org/gomatrixserverlib"

"github.com/nats-io/nats.go"

log "github.com/sirupsen/logrus"

)

durable string

db storage.Database

queues *queue.OutgoingQueues

topic string

}

return false

}

for i := range joined {

names[i] = joined[i].ServerName

}

"github.com/matrix-org/dendrite/setup/process"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/dendrite/federationapi/api"

"github.com/matrix-org/dendrite/federationapi/routing"

)

type server struct {

}

func (s *server) renew() {

Generate: true,

SingleDatabase: false,

})

cfg.Global.PrivateKey = testPriv

cfg.Global.JetStream.InMemory = true

cfg.Global.JetStream.TopicPrefix = string(s.name[:1])

}

// Get the keys and JSON-ify them.

body, err := json.MarshalIndent(keys.JSON, "", " ")

if err != nil {

return nil, err

}

res, err := s.api.FetchKeys(

context.Background(),

},

)

if err != nil {

res, err := serverA.api.FetchKeys(

context.Background(),

},

)

if err != nil {

res, err = serverA.api.FetchKeys(

context.Background(),

},

)

if err != nil {

"github.com/matrix-org/gomatrix"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/nats-io/nats.go"

"github.com/matrix-org/dendrite/federationapi"

fedClientMutex sync.Mutex

api.FederationClient

allowJoins []*test.Room

key ed25519.PrivateKey

keyID gomatrixserverlib.KeyID

}

sentTxn bool

}

f.fedClientMutex.Lock()

defer f.fedClientMutex.Unlock()

fmt.Println("GetServerKeys:", matrixServer)

}

keys.ServerName = matrixServer

publicKey := pkey.Public().(ed25519.PublicKey)

keys.VerifyKeys = map[gomatrixserverlib.KeyID]gomatrixserverlib.VerifyKey{

keyID: {

},

}

toSign, err := json.Marshal(keys.ServerKeyFields)

return keys, nil

}

for _, r := range f.allowJoins {

if r.ID == roomID {

res.RoomVersion = r.Version

RoomID: roomID,

Type: "m.room.member",

StateKey: &userID,

PrevEvents: r.ForwardExtremities(),

}

var needed gomatrixserverlib.StateNeeded

}

return

}

f.fedClientMutex.Lock()

defer f.fedClientMutex.Unlock()

for _, r := range f.allowJoins {

f.fedClientMutex.Lock()

defer f.fedClientMutex.Unlock()

for _, edu := range t.EDUs {

f.sentTxn = true

}

}

jsctx, _ := natsInstance.Prepare(processCtx, &cfg.Global.JetStream)

defer jetstream.DeleteAllStreams(jsctx, &cfg.Global.JetStream)

serverAKeyID := gomatrixserverlib.KeyID("ed25519:servera")

serverAPrivKey := test.PrivateKeyA

creator := test.NewUser(t, test.WithSigningServer(serverA, serverAKeyID, serverAPrivKey))

fc := &fedClient{

allowJoins: []*test.Room{room},

t: t,

key ed25519.PrivateKey

keyID gomatrixserverlib.KeyID

}{

fsapi.PerformJoin(context.Background(), &api.PerformJoinRequest{

RoomID: room.ID,

UserID: joiningUser.ID,

}, &resp)

if resp.JoinedVia != serverA {

t.Errorf("PerformJoin: joined via %v want %v", resp.JoinedVia, serverA)

_, privKey, _ := ed25519.GenerateKey(nil)

cfg.Global.KeyID = gomatrixserverlib.KeyID("ed25519:auto")

cfg.Global.PrivateKey = privKey

cfg.Global.JetStream.InMemory = true

keyRing := &test.NopJSONVerifier{}

federationapi.AddPublicRoutes(processCtx, routers, cfg, &natsInstance, nil, nil, keyRing, nil, &internal.FederationInternalAPI{}, nil, caching.DisableMetrics)

baseURL, cancel := test.ListenAndServe(t, routers.Federation, true)

defer cancel()

fedCli := fclient.NewFederationClient(

cfg.Global.SigningIdentities(),

t.Errorf("failed to parse event: %s", err)

}

he := ev.Headered(tc.roomVer)

if err != nil {

t.Errorf("failed to create invite v2 request: %s", err)

continue

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/gomatrix"

"github.com/matrix-org/gomatrixserverlib"

"github.com/sirupsen/logrus"

)

}

}

stats := a.statistics.ForServer(s)

if stats.Blacklisted() {

return stats, &api.FederationClientError{

}

func (a *FederationInternalAPI) doRequestIfNotBackingOffOrBlacklisted(

) (interface{}, error) {

stats, err := a.isBlacklistedOrBackingOff(s)

if err != nil {

}

func (a *FederationInternalAPI) doRequestIfNotBlacklisted(

) (interface{}, error) {

stats := a.statistics.ForServer(s)

if blacklisted := stats.Blacklisted(); blacklisted {

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

)

// Functions here are "proxying" calls to the gomatrixserverlib federation

// client.

func (a *FederationInternalAPI) GetEventAuth(

roomVersion gomatrixserverlib.RoomVersion, roomID, eventID string,

) (res fclient.RespEventAuth, err error) {

ctx, cancel := context.WithTimeout(ctx, time.Second*30)

}

func (a *FederationInternalAPI) GetUserDevices(

) (fclient.RespUserDevices, error) {

ctx, cancel := context.WithTimeout(ctx, time.Second*30)

defer cancel()

}

func (a *FederationInternalAPI) ClaimKeys(

) (fclient.RespClaimKeys, error) {

ctx, cancel := context.WithTimeout(ctx, time.Second*30)

defer cancel()

}

func (a *FederationInternalAPI) QueryKeys(

) (fclient.RespQueryKeys, error) {

ires, err := a.doRequestIfNotBackingOffOrBlacklisted(s, func() (interface{}, error) {

return a.federation.QueryKeys(ctx, origin, s, keys)

}

func (a *FederationInternalAPI) Backfill(

) (res gomatrixserverlib.Transaction, err error) {

ctx, cancel := context.WithTimeout(ctx, time.Second*30)

defer cancel()

}

func (a *FederationInternalAPI) LookupState(

) (res gomatrixserverlib.StateResponse, err error) {

ctx, cancel := context.WithTimeout(ctx, time.Second*30)

defer cancel()

}

func (a *FederationInternalAPI) LookupStateIDs(

) (res gomatrixserverlib.StateIDResponse, err error) {

ctx, cancel := context.WithTimeout(ctx, time.Second*30)

defer cancel()

}

func (a *FederationInternalAPI) LookupMissingEvents(

missing fclient.MissingEvents, roomVersion gomatrixserverlib.RoomVersion,

) (res fclient.RespMissingEvents, err error) {

ctx, cancel := context.WithTimeout(ctx, time.Second*30)

}

func (a *FederationInternalAPI) GetEvent(

) (res gomatrixserverlib.Transaction, err error) {

ctx, cancel := context.WithTimeout(ctx, time.Second*30)

defer cancel()

}

func (a *FederationInternalAPI) LookupServerKeys(

) ([]gomatrixserverlib.ServerKeys, error) {

ctx, cancel := context.WithTimeout(ctx, time.Minute)

defer cancel()

}

func (a *FederationInternalAPI) MSC2836EventRelationships(

roomVersion gomatrixserverlib.RoomVersion,

) (res fclient.MSC2836EventRelationshipsResponse, err error) {

ctx, cancel := context.WithTimeout(ctx, time.Minute)

}

func (a *FederationInternalAPI) MSC2946Spaces(

) (res fclient.MSC2946SpacesResponse, err error) {

ctx, cancel := context.WithTimeout(ctx, time.Minute)

defer cancel()

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/dendrite/setup/process"

"github.com/matrix-org/dendrite/test"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/stretchr/testify/assert"

)

FailuresUntilBlacklist = 8

)

t.queryKeysCalled = true

if t.shouldFail {

return fclient.RespQueryKeys{}, fmt.Errorf("Failure")

return fclient.RespQueryKeys{}, nil

}

t.claimKeysCalled = true

if t.shouldFail {

return fclient.RespClaimKeys{}, fmt.Errorf("Failure")

"time"

"github.com/matrix-org/gomatrixserverlib"

"github.com/sirupsen/logrus"

)

func (s *FederationInternalAPI) FetchKeys(

_ context.Context,

) (map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult, error) {

// Run in a background context - we don't want to stop this work just

// because the caller gives up waiting.

ctx := context.Background()

results := map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult{}

for k, v := range requests {

origRequests[k] = v

}

// a request for our own server keys, either current or old.

func (s *FederationInternalAPI) handleLocalKeys(

_ context.Context,

results map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult,

) {

for req := range requests {

// Insert our own key into the response.

results[req] = gomatrixserverlib.PublicKeyLookupResult{

VerifyKey: gomatrixserverlib.VerifyKey{

},

ExpiredTS: gomatrixserverlib.PublicKeyNotExpired,

}

} else {

// The key request doesn't match our current key. Let's see

// Insert our own key into the response.

results[req] = gomatrixserverlib.PublicKeyLookupResult{

VerifyKey: gomatrixserverlib.VerifyKey{

},

ExpiredTS: oldVerifyKey.ExpiredAt,

ValidUntilTS: gomatrixserverlib.PublicKeyNotValid,

// satisfied from our local database/cache.

func (s *FederationInternalAPI) handleDatabaseKeys(

ctx context.Context,

results map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult,

) error {

// Ask the database/cache for the keys.

// the remaining requests.

func (s *FederationInternalAPI) handleFetcherKeys(

ctx context.Context,

fetcher gomatrixserverlib.KeyFetcher,

results map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult,

) error {

logrus.WithFields(logrus.Fields{

"github.com/matrix-org/gomatrix"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

"github.com/sirupsen/logrus"

// Deduplicate the server names we were provided but keep the ordering

// as this encodes useful information about which servers are most likely

// to respond.

for _, srv := range request.ServerNames {

if seenSet[srv] || r.cfg.Matrix.IsLocalServerName(srv) {

continue

ctx context.Context,

roomID, userID string,

content map[string]interface{},

supportedVersions []gomatrixserverlib.RoomVersion,

unsigned map[string]interface{},

) error {

// Set all the fields to be what they should be, this should be a no-op

// but it's possible that the remote server returned us something "odd"

respMakeJoin.JoinEvent.Sender = userID

respMakeJoin.JoinEvent.StateKey = &userID

respMakeJoin.JoinEvent.RoomID = roomID

content = map[string]interface{}{}

}

_ = json.Unmarshal(respMakeJoin.JoinEvent.Content, &content)

if err = respMakeJoin.JoinEvent.SetContent(content); err != nil {

return fmt.Errorf("respMakeJoin.JoinEvent.SetContent: %w", err)

}

// contain signatures that we don't know about.

if len(respSendJoin.Event) > 0 {

var remoteEvent *gomatrixserverlib.Event

if err == nil && isWellFormedMembershipEvent(

remoteEvent, roomID, userID,

) {

func isWellFormedMembershipEvent(event *gomatrixserverlib.Event, roomID, userID string) bool {

if membership, err := event.Membership(); err != nil {

return false

return false

}

if event.RoomID() != roomID {

// Deduplicate the server names we were provided but keep the ordering

// as this encodes useful information about which servers are most likely

// to respond.

for _, srv := range request.ServerNames {

if seenSet[srv] {

continue

func (r *FederationInternalAPI) performOutboundPeekUsingServer(

ctx context.Context,

roomID string,

supportedVersions []gomatrixserverlib.RoomVersion,

) error {

if !r.shouldAttemptDirectFederation(serverName) {

// Set all the fields to be what they should be, this should be a no-op

// but it's possible that the remote server returned us something "odd"

respMakeLeave.LeaveEvent.Sender = request.UserID

respMakeLeave.LeaveEvent.StateKey = &request.UserID

respMakeLeave.LeaveEvent.RoomID = request.RoomID

"destination": destination,

}).Info("Sending invite")

if err != nil {

return fmt.Errorf("gomatrixserverlib.NewInviteV2Request: %w", err)

}

return fmt.Errorf("r.federation.SendInviteV2: failed to send invite: %w", err)

}

if err != nil {

return fmt.Errorf("r.federation.SendInviteV2 failed to decode event response: %w", err)

}

return nil

}

for _, srv := range destinations {

wasBlacklisted := r.statistics.ForServer(srv).MarkServerAlive()

r.queues.RetryServer(srv, wasBlacklisted)

func sanityCheckAuthChain(authChain []*gomatrixserverlib.Event) error {

// sanity check we have a create event and it has a known room version

for _, ev := range authChain {

// make sure the room version is known

content := ev.Content()

verBody := struct {

// FederatedAuthProvider is an auth chain provider which fetches events from the server provided

func federatedAuthProvider(

ctx context.Context, federation api.FederationClient,

) gomatrixserverlib.AuthChainProvider {

// A list of events that we have retried, if they were not included in

// the auth events supplied in the send_join.

}

func (r *FederationInternalAPI) shouldAttemptDirectFederation(

) bool {

var shouldRelay bool

stats := r.statistics.ForServer(destination)

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/dendrite/setup/process"

"github.com/matrix-org/dendrite/test"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/stretchr/testify/assert"

)

shouldFail bool

}

return fclient.RespDirectory{}, nil

}

func TestPerformWakeupServers(t *testing.T) {

testDB := test.NewInMemoryFederationDatabase()

testDB.AddServerToBlacklist(server)

testDB.SetServerAssumedOffline(context.Background(), server)

blacklisted, err := testDB.IsServerBlacklisted(server)

)

req := api.PerformWakeupServersRequest{

}

res := api.PerformWakeupServersResponse{}

err = fedAPI.PerformWakeupServers(context.Background(), &req, &res)

func TestQueryRelayServers(t *testing.T) {

testDB := test.NewInMemoryFederationDatabase()

err := testDB.P2PAddRelayServersForServer(context.Background(), server, relayServers)

assert.NoError(t, err)

func TestRemoveRelayServers(t *testing.T) {

testDB := test.NewInMemoryFederationDatabase()

err := testDB.P2PAddRelayServersForServer(context.Background(), server, relayServers)

assert.NoError(t, err)

req := api.P2PRemoveRelayServersRequest{

Server: server,

}

res := api.P2PRemoveRelayServersResponse{}

err = fedAPI.P2PRemoveRelayServers(context.Background(), &req, &res)

finalRelays, err := testDB.P2PGetRelayServersForServer(context.Background(), server)

assert.NoError(t, err)

assert.Equal(t, 1, len(finalRelays))

}

func TestPerformDirectoryLookup(t *testing.T) {

func TestPerformDirectoryLookupRelaying(t *testing.T) {

testDB := test.NewInMemoryFederationDatabase()

testDB.SetServerAssumedOffline(context.Background(), server)

cfg := config.FederationAPI{

Matrix: &config.Global{

"github.com/matrix-org/dendrite/federationapi/api"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

)

return

}

ctx, cancel := context.WithTimeout(ctx, time.Second*30)

defer cancel()

ires, err := a.doRequestIfNotBackingOffOrBlacklisted(serverName, func() (interface{}, error) {

"time"

"github.com/matrix-org/gomatrixserverlib"

"github.com/nats-io/nats.go"

log "github.com/sirupsen/logrus"

func (p *SyncAPIProducer) SendReceipt(

ctx context.Context,

) error {

m := &nats.Msg{

Subject: p.TopicReceiptEvent,

if statusMsg != nil {

m.Header.Set("status_msg", *statusMsg)

}

m.Header.Set("last_active_ts", strconv.Itoa(int(lastActiveTS)))

log.Tracef("Sending presence to syncAPI: %+v", m.Header)

}

func (p *SyncAPIProducer) SendDeviceListUpdate(

) (err error) {

m := nats.NewMsg(p.TopicDeviceListUpdate)

m.Header.Set("origin", string(origin))

}

func (p *SyncAPIProducer) SendSigningKeyUpdate(

) (err error) {

m := nats.NewMsg(p.TopicSigningKeyUpdate)

m.Header.Set("origin", string(origin))

"github.com/matrix-org/gomatrix"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/sirupsen/logrus"

"go.uber.org/atomic"

queues *OutgoingQueues

db storage.Database

process *process.ProcessContext

rsAPI api.FederationRoomserverAPI

client fedapi.FederationClient // federation client

running atomic.Bool // is the queue worker running?

backingOff atomic.Bool // true if we're backing off

overflowed atomic.Bool // the queues exceed maxPDUsInMemory/maxEDUsInMemory, so we should consult the database for more

relaySuccess := false

logrus.Infof("Sending %q to relay servers: %v", t.TransactionID, relayServers)

// TODO : how to pass through actual userID here?!?!?!?!

if userErr != nil {

return userErr, sendMethod

}

// it so that we retry with the same transaction ID.

oq.transactionIDMutex.Lock()

if oq.transactionID == "" {

oq.transactionID = gomatrixserverlib.TransactionID(fmt.Sprintf("%d-%d", now, oq.statistics.SuccessCount()))

}

oq.transactionIDMutex.Unlock()

}

t.Origin = oq.origin

t.Destination = oq.destination

t.TransactionID = oq.transactionID

var pduReceipts []*receipt.Receipt

"github.com/getsentry/sentry-go"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/prometheus/client_golang/prometheus"

"github.com/sirupsen/logrus"

log "github.com/sirupsen/logrus"

process *process.ProcessContext

disabled bool

rsAPI api.FederationRoomserverAPI

client fedapi.FederationClient

statistics *statistics.Statistics

queuesMutex sync.Mutex // protects the below

}

func init() {

db storage.Database,

process *process.ProcessContext,

disabled bool,

client fedapi.FederationClient,

rsAPI api.FederationRoomserverAPI,

statistics *statistics.Statistics,

origin: origin,

client: client,

statistics: statistics,

}

for _, identity := range signing {

queues.signing[identity.ServerName] = identity

}

// Look up which servers we have pending items for and then rehydrate those queues.

if !disabled {

if names, err := db.GetPendingPDUServerNames(process.Context()); err == nil {

for _, serverName := range names {

serverNames[serverName] = struct{}{}

edu *gomatrixserverlib.EDU

}

if oqs.statistics.ForServer(destination).Blacklisted() {

return nil

}

// SendEvent sends an event to the destinations

func (oqs *OutgoingQueues) SendEvent(

) error {

if oqs.disabled {

log.Trace("Federation is disabled, not sending event")

// Deduplicate destinations and remove the origin from the list of

// destinations just to be sure.

for _, d := range destinations {

destmap[d] = struct{}{}

}

// SendEDU sends an EDU event to the destinations.

func (oqs *OutgoingQueues) SendEDU(

) error {

if oqs.disabled {

log.Trace("Federation is disabled, not sending EDU")

// Deduplicate destinations and remove the origin from the list of

// destinations just to be sure.

for _, d := range destinations {

destmap[d] = struct{}{}

}

}

// RetryServer attempts to resend events to the given server if we had given up.

if oqs.disabled {

return

}

"github.com/matrix-org/dendrite/internal/sqlutil"

"github.com/matrix-org/dendrite/test/testrig"

"github.com/matrix-org/gomatrixserverlib/fclient"

"go.uber.org/atomic"

"gotest.tools/v3/poll"

return fclient.RespSend{}, result

}

var result error

if !f.shouldTxRelaySucceed {

result = fmt.Errorf("relay transaction failed")

func mustCreateEDU(t *testing.T) *gomatrixserverlib.EDU {

t.Helper()

}

func testSetup(failuresUntilBlacklist uint32, failuresUntilAssumedOffline uint32, shouldTxSucceed bool, shouldTxRelaySucceed bool, t *testing.T, dbType test.DBType, realDatabase bool) (storage.Database, *stubFederationClient, *OutgoingQueues, *process.ProcessContext, func()) {

func TestSendPDUOnSuccessRemovedFromDB(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, true, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreatePDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestSendEDUOnSuccessRemovedFromDB(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, true, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreateEDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestSendPDUOnFailStoredInDB(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreatePDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestSendEDUOnFailStoredInDB(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreateEDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestSendPDUAgainDoesntInterruptBackoff(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreatePDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

fc.shouldTxSucceed = true

ev = mustCreatePDU(t)

assert.NoError(t, err)

pollEnd := time.Now().Add(1 * time.Second)

func TestSendEDUAgainDoesntInterruptBackoff(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreateEDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

fc.shouldTxSucceed = true

ev = mustCreateEDU(t)

assert.NoError(t, err)

pollEnd := time.Now().Add(1 * time.Second)

func TestSendPDUMultipleFailuresBlacklisted(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(2)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreatePDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestSendEDUMultipleFailuresBlacklisted(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(2)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreateEDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestSendPDUBlacklistedWithPriorExternalFailure(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(2)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

queues.statistics.ForServer(destination).Failure()

ev := mustCreatePDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestSendEDUBlacklistedWithPriorExternalFailure(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(2)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

queues.statistics.ForServer(destination).Failure()

ev := mustCreateEDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestRetryServerSendsPDUSuccessfully(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(1)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

// before it is blacklisted and deleted.

dest := queues.getQueue(destination)

ev := mustCreatePDU(t)

assert.NoError(t, err)

checkBlacklisted := func(log poll.LogT) poll.Result {

func TestRetryServerSendsEDUSuccessfully(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(1)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

// before it is blacklisted and deleted.

dest := queues.getQueue(destination)

ev := mustCreateEDU(t)

assert.NoError(t, err)

checkBlacklisted := func(log poll.LogT) poll.Result {

func TestSendPDUBatches(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

// test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {

// db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, true, t, dbType, true)

<-pc.WaitForShutdown()

}()

// Populate database with > maxPDUsPerTransaction

pduMultiplier := uint32(3)

for i := 0; i < maxPDUsPerTransaction*int(pduMultiplier); i++ {

}

ev := mustCreatePDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestSendEDUBatches(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

// test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {

// db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, true, t, dbType, true)

<-pc.WaitForShutdown()

}()

// Populate database with > maxEDUsPerTransaction

eduMultiplier := uint32(3)

for i := 0; i < maxEDUsPerTransaction*int(eduMultiplier); i++ {

}

ev := mustCreateEDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestSendPDUAndEDUBatches(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

// test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {

// db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, true, t, dbType, true)

<-pc.WaitForShutdown()

}()

// Populate database with > maxEDUsPerTransaction

multiplier := uint32(3)

for i := 0; i < maxPDUsPerTransaction*int(multiplier)+1; i++ {

}

ev := mustCreateEDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

func TestExternalFailureBackoffDoesntStartQueue(t *testing.T) {

t.Parallel()

failuresUntilBlacklist := uint32(16)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, true, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

dest := queues.getQueue(destination)

queues.statistics.ForServer(destination).Failure()

ev := mustCreatePDU(t)

headeredJSON, _ := json.Marshal(ev)

nid, _ := db.StoreJSON(pc.Context(), string(headeredJSON))

// NOTE : Only one test case against real databases can be run at a time.

t.Parallel()

failuresUntilBlacklist := uint32(1)

test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) {

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilBlacklist+1, false, false, t, dbType, true)

// NOTE : These defers aren't called if go test is killed so the dbs may not get cleaned up.

// before it is blacklisted and deleted.

dest := queues.getQueue(destination)

ev := mustCreatePDU(t)

assert.NoError(t, err)

// NOTE : The server can be blacklisted before this, so manually inject the event

t.Parallel()

failuresUntilBlacklist := uint32(7)

failuresUntilAssumedOffline := uint32(2)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilAssumedOffline, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreatePDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

t.Parallel()

failuresUntilBlacklist := uint32(7)

failuresUntilAssumedOffline := uint32(2)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilAssumedOffline, false, false, t, test.DBTypeSQLite, false)

defer close()

defer func() {

}()

ev := mustCreateEDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

t.Parallel()

failuresUntilBlacklist := uint32(16)

failuresUntilAssumedOffline := uint32(1)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilAssumedOffline, false, true, t, test.DBTypeSQLite, false)

defer close()

defer func() {

<-pc.WaitForShutdown()

}()

queues.statistics.ForServer(destination).AddRelayServers(relayServers)

ev := mustCreatePDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

t.Parallel()

failuresUntilBlacklist := uint32(16)

failuresUntilAssumedOffline := uint32(1)

db, fc, queues, pc, close := testSetup(failuresUntilBlacklist, failuresUntilAssumedOffline, false, true, t, test.DBTypeSQLite, false)

defer close()

defer func() {

<-pc.WaitForShutdown()

}()

queues.statistics.ForServer(destination).AddRelayServers(relayServers)

ev := mustCreateEDU(t)

assert.NoError(t, err)

check := func(log poll.LogT) poll.Result {

"github.com/matrix-org/dendrite/roomserver/api"

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

)

// https://matrix.org/docs/spec/server_server/unstable.html#get-matrix-federation-v1-backfill-roomid

func Backfill(

httpReq *http.Request,

rsAPI api.FederationRoomserverAPI,

roomID string,

cfg *config.FederationAPI,

txn := gomatrixserverlib.Transaction{

Origin: request.Destination(),

PDUs: eventJSONs,

}

// Send the events to the client.

"github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

"github.com/tidwall/gjson"

)

for sourceUserID, forSourceUser := range targetKey {

for sourceKeyID, sourceKey := range forSourceUser {

if device.Keys.Signatures == nil {

}

if _, ok := device.Keys.Signatures[sourceUserID]; !ok {

}

device.Keys.Signatures[sourceUserID][sourceKeyID] = sourceKey

}

// GetEventAuth returns event auth for the roomID and eventID

func GetEventAuth(

ctx context.Context,

rsAPI api.FederationRoomserverAPI,

roomID string,

eventID string,

"time"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

"github.com/matrix-org/dendrite/clientapi/jsonerror"

// GetEvent returns the requested event

func GetEvent(

ctx context.Context,

rsAPI api.FederationRoomserverAPI,

eventID string,

) util.JSONResponse {

err := allowedToSeeEvent(ctx, request.Origin(), rsAPI, eventID)

if err != nil {

return util.JSONResponse{Code: http.StatusOK, JSON: gomatrixserverlib.Transaction{

Origin: origin,

PDUs: []json.RawMessage{

event.JSON(),

},

// otherwise it returns an error response which can be sent to the client.

func allowedToSeeEvent(

ctx context.Context,

rsAPI api.FederationRoomserverAPI,

eventID string,

) *util.JSONResponse {

// InviteV2 implements /_matrix/federation/v2/invite/{roomID}/{eventID}

func InviteV2(

httpReq *http.Request,

roomID string,

eventID string,

cfg *config.FederationAPI,

rsAPI api.FederationRoomserverAPI,

keys gomatrixserverlib.JSONVerifier,

) util.JSONResponse {

err := json.Unmarshal(request.Content(), &inviteReq)

switch e := err.(type) {

case gomatrixserverlib.UnsupportedRoomVersionError:

// InviteV1 implements /_matrix/federation/v1/invite/{roomID}/{eventID}

func InviteV1(

httpReq *http.Request,

roomID string,

eventID string,

cfg *config.FederationAPI,

JSON: jsonerror.NotJSON("The request body could not be decoded into an invite v1 request. " + err.Error()),

}

}

if err := json.Unmarshal(event.Unsigned(), &strippedState); err != nil {

// just warn, they may not have added any.

util.GetLogger(httpReq.Context()).Warnf("failed to extract stripped state from invite event")

isInviteV2 bool,

event *gomatrixserverlib.Event,

roomVer gomatrixserverlib.RoomVersion,

roomID string,

eventID string,

cfg *config.FederationAPI,

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

"github.com/sirupsen/logrus"

// MakeJoin implements the /make_join API

func MakeJoin(

httpReq *http.Request,

cfg *config.FederationAPI,

rsAPI api.FederationRoomserverAPI,

roomID, userID string,

StateKey: &userID,

}

content := gomatrixserverlib.MemberContent{

AuthorisedVia: authorisedVia,

}

if err = builder.SetContent(content); err != nil {

// nolint:gocyclo

func SendJoin(

httpReq *http.Request,

cfg *config.FederationAPI,

rsAPI api.FederationRoomserverAPI,

keys gomatrixserverlib.JSONVerifier,

// Check that the sender belongs to the server that is sending us

// the request. By this point we've already asserted that the sender

// and the state key are equal so we don't need to check both.

if _, serverName, err = gomatrixserverlib.SplitID('@', event.Sender()); err != nil {

return util.JSONResponse{

Code: http.StatusForbidden,

JSON: jsonerror.BadJSON("missing content.membership key"),

}

}

return util.JSONResponse{

Code: http.StatusBadRequest,

JSON: jsonerror.BadJSON("membership must be 'join'"),

continue

}

if membership, merr := se.Membership(); merr == nil {

break

}

}

"github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"

"github.com/matrix-org/util"

"github.com/sirupsen/logrus"

"golang.org/x/crypto/ed25519"

// QueryDeviceKeys returns device keys for users on this server.

// https://matrix.org/docs/spec/server_server/latest#post-matrix-federation-v1-user-keys-query

func QueryDeviceKeys(

) util.JSONResponse {

var qkr queryKeysRequest

err := json.Unmarshal(request.Content(), &qkr)

// ClaimOneTimeKeys claims OTKs for users on this server.

// https://matrix.org/docs/spec/server_server/latest#post-matrix-federation-v1-user-keys-claim

func ClaimOneTimeKeys(

) util.JSONResponse {

var cor claimOTKsRequest

err := json.Unmarshal(request.Content(), &cor)

// LocalKeys returns the local keys for the server.

// See https://matrix.org/docs/spec/server_server/unstable.html#publishing-keys

keys, err := localKeys(cfg, serverName)

if err != nil {

return util.MessageResponse(http.StatusNotFound, err.Error())

return util.JSONResponse{Code: http.StatusOK, JSON: keys}

}

var keys gomatrixserverlib.ServerKeys

var identity *fclient.SigningIdentity

var err error

}

publicKey := cfg.Matrix.PrivateKey.Public().(ed25519.PublicKey)

keys.ServerName = cfg.Matrix.ServerName

keys.VerifyKeys = map[gomatrixserverlib.KeyID]gomatrixserverlib.VerifyKey{

cfg.Matrix.KeyID: {

},

}

keys.OldVerifyKeys = map[gomatrixserverlib.KeyID]gomatrixserverlib.OldVerifyKey{}

}

publicKey := virtualHost.PrivateKey.Public().(ed25519.PublicKey)

keys.ServerName = virtualHost.ServerName

keys.VerifyKeys = map[gomatrixserverlib.KeyID]gomatrixserverlib.VerifyKey{

virtualHost.KeyID: {

},

}

// TODO: Virtual hosts probably want to be able to specify old signing

fsAPI federationAPI.FederationInternalAPI,

req *gomatrixserverlib.PublicKeyNotaryLookupRequest,

) util.JSONResponse {

if !cfg.Matrix.IsLocalServerName(serverName) {

return util.JSONResponse{

Code: http.StatusNotFound,

"github.com/matrix-org/dendrite/roomserver/api"

"github.com/matrix-org/dendrite/setup/config"

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/util"

"github.com/sirupsen/logrus"

)

// MakeLeave implements the /make_leave API

func MakeLeave(

httpReq *http.Request,

cfg *config.FederationAPI,

rsAPI api.FederationRoomserverAPI,

roomID, userID string,

Type: "m.room.member",

StateKey: &userID,

}

if err != nil {

util.GetLogger(httpReq.Context()).WithError(err).Error("builder.SetContent failed")

return jsonerror.InternalServerError()

if !state.StateKeyEquals(userID) {

continue

}

return util.JSONResponse{

Code: http.StatusOK,

JSON: map[string]interface{}{

// nolint:gocyclo

func SendLeave(

httpReq *http.Request,

cfg *config.FederationAPI,

rsAPI api.FederationRoomserverAPI,

keys gomatrixserverlib.JSONVerifier,

// Check that the sender belongs to the server that is sending us

// the request. By this point we've already asserted that the sender

// and the state key are equal so we don't need to check both.

if _, serverName, err = gomatrixserverlib.SplitID('@', event.Sender()); err != nil {

return util.JSONResponse{

Code: http.StatusForbidden,

RoomID: roomID,

StateToFetch: []gomatrixserverlib.StateKeyTuple{

{

StateKey: *event.StateKey(),

},

},

// We are/were joined/invited/banned or something. Check if

// we can no-op here.

if len(queryRes.StateEvents) == 1 {

return util.JSONResponse{

Code: http.StatusOK,

JSON: struct{}{},

JSON: jsonerror.BadJSON("missing content.membership key"),

}

}

return util.JSONResponse{

Code: http.StatusBadRequest,

JSON: jsonerror.BadJSON("The membership in the event content must be set to leave"),

// Events are fetched from room DAG starting from latest_events until we reach earliest_events or the limit.

func GetMissingEvents(

httpReq *http.Request,

rsAPI api.FederationRoomserverAPI,

roomID string,

) util.JSONResponse {

// Peek implements the SS /peek API, handling inbound peeks

func Peek(

httpReq *http.Request,

cfg *config.FederationAPI,

rsAPI api.FederationRoomserverAPI,

roomID, peekID string,

"github.com/matrix-org/dendrite/test/testrig"

userAPI "github.com/matrix-org/dendrite/userapi/api"

"github.com/matrix-org/gomatrixserverlib"

"github.com/stretchr/testify/assert"

"golang.org/x/crypto/ed25519"

)

_, sk, _ := ed25519.GenerateKey(nil)

keyID := signing.KeyID

pk := sk.Public().(ed25519.PublicKey)

type queryContent struct{}

content := queryContent{}

err := req.SetContent(content)

"github.com/matrix-org/gomatrixserverlib"

"github.com/matrix-org/gomatrixserverlib/fclient"