func newSession(
ctx scope.Context, server *Server, conn *websocket.Conn,
roomName string, room proto.Room, client *proto.Client, agentKey *security.ManagedKey) *session {
nextID := atomic.AddUint64(&sessionIDCounter, 1)
sessionCount.WithLabelValues(roomName).Set(float64(nextID))
sessionID := fmt.Sprintf("%x-%08x", client.Agent.IDString(), nextID)
ctx = LoggingContext(ctx, fmt.Sprintf("[%s] ", sessionID))
session := &session{
id: sessionID,
ctx: ctx,
server: server,
conn: conn,
identity: newMemIdentity(client.UserID(), server.ID, server.Era),
client: client,
agentKey: agentKey,
serverID: server.ID,
serverEra: server.Era,
roomName: roomName,
room: room,
backend: server.b,
kms: server.kms,
incoming: make(chan *proto.Packet),
outgoing: make(chan *proto.Packet, 100),
floodLimiter: ratelimit.NewBucketWithQuantum(time.Second, 50, 10),
}
return session
}
func (s *Server) resolveRoom(ctx scope.Context, prefix, roomName string, client *proto.Client) (room proto.Room, err error) {
// TODO: support room creation?
switch prefix {
case "pm:":
var (
sf snowflake.Snowflake
roomKey *security.ManagedKey
)
if err := sf.FromString(roomName); err != nil {
return nil, proto.ErrRoomNotFound
}
room, roomKey, err = s.b.PMTracker().Room(ctx, s.kms, sf, client)
if err != nil {
switch err {
case proto.ErrAccessDenied, proto.ErrPMNotFound:
return nil, proto.ErrRoomNotFound
default:
return nil, err
}
}
client.Authorization.AddMessageKey("pm:"+roomName, roomKey)
return room, nil
case "":
room, err = s.b.GetRoom(ctx, roomName)
if s.allowRoomCreation && err == proto.ErrRoomNotFound {
room, err = s.b.CreateRoom(ctx, s.kms, false, roomName)
}
if err != nil {
return nil, err
}
if err := client.RoomAuthorize(ctx, room); err != nil {
return nil, err
}
return room, nil
default:
return nil, proto.ErrRoomNotFound
}
}
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
}
func (t *PMTracker) Initiate(
ctx scope.Context, kms security.KMS, room proto.Room, client *proto.Client, recipient proto.UserID) (
snowflake.Snowflake, error) {
t.m.Lock()
defer t.m.Unlock()
// Look for reusable PM.
for pmID, pm := range t.pms {
if pm.pm.Initiator == client.Account.ID() && pm.pm.Receiver == recipient {
return pmID, nil
}
if pm.pm.Receiver == client.UserID() {
kind, id := pm.pm.Receiver.Parse()
if kind == "account" && id == pm.pm.Initiator.String() {
return pmID, nil
}
}
}
// Create new PM.
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.b, kms, client, initiatorNick, recipient, recipientNick)
if err != nil {
return 0, err
}
pmKey, _, otherName, err := pm.Access(ctx, t.b, kms, client)
if err != nil {
return 0, err
}
if t.pms == nil {
t.pms = map[snowflake.Snowflake]*PM{}
}
t.pms[pm.ID] = &PM{
RoomBase: RoomBase{
name: fmt.Sprintf("private chat with %s", otherName),
version: t.b.version,
log: newMemLog(),
messageKey: &roomMessageKey{
id: fmt.Sprintf("pm:%s", pm.ID),
timestamp: time.Now(),
key: *pmKey,
},
},
pm: pm,
}
return pm.ID, nil
}