func (rb *ManagedRoomBinding) banAgent(ctx scope.Context, agentID proto.UserID, until time.Time) error {
ban := &BannedAgent{
AgentID: agentID.String(),
Room: sql.NullString{
String: rb.Name,
Valid: true,
},
Created: time.Now(),
Expires: gorp.NullTime{
Time: until,
Valid: !until.IsZero(),
},
}
// Loop within transaction in read committed mode to simulate UPSERT.
t, err := rb.DbMap.Begin()
if err != nil {
return err
}
for {
// Try to insert; if this fails due to duplicate key value, try to update.
if err := rb.DbMap.Insert(ban); err != nil {
if !strings.HasPrefix(err.Error(), "pq: duplicate key value") {
rollback(ctx, t)
return err
}
} else {
break
}
n, err := rb.DbMap.Update(ban)
if err != nil {
rollback(ctx, t)
return err
}
if n > 0 {
break
}
}
bounceEvent := &proto.BounceEvent{Reason: "banned", AgentID: agentID}
if err := rb.broadcast(ctx, t, proto.BounceEventType, bounceEvent); err != nil {
rollback(ctx, t)
return err
}
if err := t.Commit(); err != nil {
return err
}
return nil
}
func (b *TestBackend) NotifyUser(ctx scope.Context, userID proto.UserID, packetType proto.PacketType, payload interface{}, excluding ...proto.Session) error {
kind, id := userID.Parse()
for _, room := range b.rooms {
mRoom, _ := room.(*memRoom)
for u, sessList := range mRoom.live {
for _, sess := range sessList {
if u == userID || (kind == "agent" && sess.AgentID() == id) {
if !isExcluded(sess, excluding) {
if err := sess.Send(ctx, packetType, payload); err != nil {
return err
}
}
}
}
}
}
return nil
}
func (rb *RoomBinding) banAgent(ctx scope.Context, agentID proto.UserID, until time.Time) error {
ban := &BannedAgent{
AgentID: agentID.String(),
Room: sql.NullString{
String: rb.Name,
Valid: true,
},
Created: time.Now(),
Expires: gorp.NullTime{
Time: until,
Valid: !until.IsZero(),
},
}
if err := rb.DbMap.Insert(ban); err != nil {
return err
}
bounceEvent := &proto.BounceEvent{Reason: "banned", AgentID: agentID.String()}
return rb.broadcast(ctx, rb.Room, proto.BounceEventType, bounceEvent)
}
func (lm ListenerMap) NotifyUser(ctx scope.Context, userID proto.UserID, event *proto.Packet, exclude ...string) error {
excludeSet := map[string]struct{}{}
for _, exc := range exclude {
excludeSet[exc] = struct{}{}
}
payload, err := event.Payload()
if err != nil {
return err
}
kind, id := userID.Parse()
for sessionID, listener := range lm {
// check that the listener is not excluded
if _, ok := excludeSet[sessionID]; ok {
continue
}
if listener.Identity().ID() == userID || (kind == "agent" && id == listener.AgentID()) {
listener.Send(ctx, event.Type, payload)
}
}
return nil
}
func (rb *ManagedRoomBinding) unbanAgent(ctx scope.Context, agentID proto.UserID) error {
_, err := rb.DbMap.Exec(
"DELETE FROM banned_agent WHERE agent_id = $1 AND room = $2", agentID.String(), rb.Name)
return err
}
func (b *Backend) unbanAgent(ctx scope.Context, rb *RoomBinding, agentID proto.UserID) error {
switch rb {
case global:
_, err := b.DbMap.Exec("DELETE FROM banned_agent WHERE room IS NULL AND agent_id = $1", agentID.String())
return err
default:
_, err := b.DbMap.Exec("DELETE FROM banned_agent WHERE room = $1 AND agent_id = $2", rb.RoomName, agentID.String())
return err
}
}
func (t *PMTracker) Initiate(
ctx scope.Context, kms security.KMS, room proto.Room, client *proto.Client, recipient proto.UserID) (
snowflake.Snowflake, error) {
initiatorNick, ok, err := room.ResolveNick(ctx, proto.UserID(fmt.Sprintf("account:%s", client.Account.ID())))
if err != nil {
return 0, err
}
if !ok {
initiatorNick = fmt.Sprintf("account:%s", client.Account.ID())
}
recipientNick, ok, err := room.ResolveNick(ctx, recipient)
if err != nil {
return 0, err
}
if !ok {
recipientNick = string(recipient)
}
pm, err := proto.InitiatePM(ctx, t.Backend, kms, client, initiatorNick, recipient, recipientNick)
if err != nil {
return 0, err
}
row := &PM{
ID: pm.ID.String(),
Initiator: pm.Initiator.String(),
InitiatorNick: pm.InitiatorNick,
Receiver: string(pm.Receiver),
ReceiverNick: pm.ReceiverNick,
ReceiverMAC: pm.ReceiverMAC,
IV: pm.IV,
EncryptedSystemKey: pm.EncryptedSystemKey.Ciphertext,
EncryptedInitiatorKey: pm.EncryptedInitiatorKey.Ciphertext,
}
if pm.EncryptedReceiverKey != nil {
row.EncryptedReceiverKey = pm.EncryptedReceiverKey.Ciphertext
}
// Look for existing PM to reuse.
tx, err := t.DbMap.Begin()
if err != nil {
return 0, err
}
var existingRow PM
err = tx.SelectOne(
&existingRow,
"SELECT id FROM pm WHERE initiator = $1 AND receiver = $2",
client.Account.ID().String(), string(recipient))
if err != nil && err != sql.ErrNoRows {
rollback(ctx, tx)
return 0, err
}
if err == nil {
rollback(ctx, tx)
var pmID snowflake.Snowflake
if err := pmID.FromString(existingRow.ID); err != nil {
return 0, err
}
return pmID, nil
}
kind, id := recipient.Parse()
if kind == "account" {
var existingRow PM
err = tx.SelectOne(
&existingRow,
"SELECT id FROM pm WHERE initiator = $1 AND receiver = $2",
id, string(client.UserID()))
if err != nil && err != sql.ErrNoRows {
rollback(ctx, tx)
return 0, err
}
if err == nil {
rollback(ctx, tx)
var pmID snowflake.Snowflake
if err := pmID.FromString(existingRow.ID); err != nil {
return 0, err
}
return pmID, nil
}
}
if err := tx.Insert(row); err != nil {
rollback(ctx, tx)
return 0, err
}
if err := tx.Commit(); err != nil {
return 0, err
}
return pm.ID, nil
}