14 |
15 | ___
16 |
17 | ⚠️ **NOTE: Please note that this project is still in development and could introduce breaking changes.**
18 |
19 | ⚠️ **WARNING: Do not use this as your main/only backup solution.**
20 |
21 | ___
22 |
23 |
24 | ## Main features:
25 | - Fast response times and low CPU and very low memory footprint
26 | - iOS and Android photo backup (using the circled.me app available on the AppStore and Google Play)
27 | - Supports either locally mounted disks or
28 | - S3-compatible Services - this allows different users to use their own S3 bucket on the same server
29 | - Push notifications for new Album photos, etc
30 | - Video/Audio Calls using the mobile app OR any browser
31 | - Face detection and tagging
32 | - Albums
33 | - Adding local server contributors and viewers
34 | - Sharing albums with anyone with a "secret" link
35 | - Chat with push notifications
36 | - Filtering photos by tagged person, year, month, location, etc
37 | - Moments - automatically grouping photos by time and location
38 | - Reverse geocoding for all assets
39 | - Automatic video conversion to web-compatible H.264 format
40 |
41 |
42 | ## Compiling and Running the server
43 | To compile the server you will need go 1.21 or above and simply build it within the cloned repository: `CGO_ENABLED=1 go build`.
44 |
45 | The easiest way to try and run the server is to use the latest image available on Docker Hub, see example docker-compose file below.
46 | The latest version of the server uses SQLite as default DB engine.
47 |
48 | ```bash
49 | docker-compose -f docker-compose-example.yaml up
50 | ```
51 |
52 | Now you can use the app and connect to your server at `http://
42 |
55 |
56 |
43 |
44 |
53 |
54 |  |
46 |
47 | {{ .name }} 48 | {{ .subtitle }} 49 | {{ .ownerName }} 50 | |
51 |
57 | {{ range .assets }}
58 | {{ if eq .Type 1 }}
59 |
60 | {{ else if eq .MimeType "video/mp4" }}
61 |
64 | {{ end }}
65 | {{ end }}
66 |
67 |
68 |
69 |
70 |
71 |
72 |
79 |
80 |
--------------------------------------------------------------------------------
/templates/upload_files.tmpl:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
31 |
92 |
93 |
--------------------------------------------------------------------------------
/utils/cache_router.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "strconv"
5 |
6 | "github.com/gin-gonic/gin"
7 | )
8 |
9 | const (
10 | CacheNoCache = 0
11 | CacheCustom = -1
12 | )
13 |
14 | type CacheRouter struct {
15 | CacheTime int // defaults to CacheNoCache = 0
16 | }
17 |
18 | func (cr *CacheRouter) Handler() gin.HandlerFunc {
19 | return func(c *gin.Context) {
20 | if cr.CacheTime != CacheCustom {
21 | if cr.CacheTime == CacheNoCache {
22 | c.Header("cache-control", "no-cache")
23 | } else {
24 | c.Header("cache-control", "private, max-age="+strconv.Itoa(cr.CacheTime))
25 | }
26 | }
27 | c.Next()
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/utils/error_log_middleware.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "log"
5 |
6 | "github.com/gin-gonic/gin"
7 | )
8 |
9 | type errorLogWriter struct {
10 | gin.ResponseWriter
11 | gc *gin.Context
12 | }
13 |
14 | func (w errorLogWriter) Write(b []byte) (int, error) {
15 | status := w.gc.Writer.Status()
16 | if status >= 400 {
17 | log.Printf("[DEBUG ERROR]: Status %d, Body: %s", status, string(b))
18 | }
19 | return w.ResponseWriter.Write(b)
20 | }
21 |
22 | // ErrorLogMiddleware doesn't work with GZIP
23 | func ErrorLogMiddleware(c *gin.Context) {
24 | blw := &errorLogWriter{gc: c, ResponseWriter: c.Writer}
25 | c.Writer = blw
26 | c.Next()
27 | }
28 |
--------------------------------------------------------------------------------
/utils/utils.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "bytes"
5 | "crypto/rand"
6 | "crypto/sha512"
7 | "encoding/base64"
8 | "encoding/binary"
9 | "encoding/hex"
10 | "image"
11 | _ "image/gif"
12 | "image/jpeg"
13 | _ "image/png"
14 | "io"
15 | "math"
16 | "math/big"
17 | "strconv"
18 | "time"
19 |
20 | "github.com/nfnt/resize"
21 | )
22 |
23 | // Sha512String hashes and encodes in hex the result
24 | func Sha512String(s string) string {
25 | hash := sha512.New()
26 | hash.Write([]byte(s))
27 | return hex.EncodeToString(hash.Sum(nil))
28 | }
29 |
30 | func Float32ArrayToByteArray(fa []float32) []byte {
31 | buf := bytes.Buffer{}
32 | _ = binary.Write(&buf, binary.LittleEndian, fa)
33 | return buf.Bytes()
34 | }
35 |
36 | func ByteArrayToFloat32Array(b []byte) (result []float32) {
37 | for i := 0; i < len(b); i += 4 {
38 | ui32 := uint32(b[i+0]) +
39 | uint32(b[i+1])<<8 +
40 | uint32(b[i+2])<<16 +
41 | uint32(b[i+3])<<24
42 | result = append(result, math.Float32frombits(ui32))
43 | }
44 | return
45 | }
46 |
47 | func GetSeason(month time.Month, gpsLat *float64) string {
48 | if gpsLat == nil {
49 | return ""
50 | }
51 | if *gpsLat < 0 {
52 | month += 6 // add half an year for southern hemisphere
53 | }
54 | if month >= 3 && month <= 5 {
55 | return "Spring"
56 | } else if month >= 6 && month <= 8 {
57 | return "Summer"
58 | } else if month >= 9 && month <= 11 {
59 | return "Autumn/Fall"
60 | }
61 | return "Winter"
62 | }
63 |
64 | func GetDatesString(min, max int64) string {
65 | if min == 0 || max == 0 {
66 | return "empty :("
67 | }
68 | minString := time.Unix(min, 0).Format("2 Jan 2006")
69 | if max-min <= 86400 {
70 | return minString
71 | }
72 | maxString := time.Unix(max, 0).Format("2 Jan 2006")
73 | return minString + " - " + maxString
74 | }
75 |
76 | func RandSalt(saltSize int) string {
77 | b := make([]byte, saltSize)
78 | _, err := rand.Read(b)
79 | if err != nil {
80 | panic(err)
81 | }
82 | return base64.StdEncoding.EncodeToString(b)
83 | }
84 |
85 | func Rand16BytesToBase62() string {
86 | buf := make([]byte, 16)
87 | _, err := rand.Read(buf)
88 | if err != nil {
89 | panic(err)
90 | }
91 | var i big.Int
92 | return i.SetBytes(buf).Text(62)
93 | }
94 |
95 | func Rand8BytesToBase62() string {
96 | buf := make([]byte, 8)
97 | _, err := rand.Read(buf)
98 | if err != nil {
99 | panic(err)
100 | }
101 | var i big.Int
102 | return i.SetBytes(buf).Text(62)
103 | }
104 |
105 | type ImageThumbConverted struct {
106 | ThumbSize int64
107 | NewX uint16
108 | NewY uint16
109 | OldX uint16
110 | OldY uint16
111 | }
112 |
113 | func CreateThumb(size uint, reader io.Reader, writer io.Writer) (result ImageThumbConverted, err error) {
114 | image, _, err := image.Decode(reader)
115 | if err != nil {
116 | return result, err
117 | }
118 | var newBuf bytes.Buffer
119 | newImage := resize.Thumbnail(size, size, image, resize.Lanczos3)
120 | if err = jpeg.Encode(&newBuf, newImage, &jpeg.Options{Quality: 90}); err != nil {
121 | return
122 | }
123 | imageRect := newImage.Bounds().Size()
124 | result.NewX = uint16(imageRect.X)
125 | result.NewY = uint16(imageRect.Y)
126 |
127 | imageRect = image.Bounds().Size()
128 | result.OldX = uint16(imageRect.X)
129 | result.OldY = uint16(imageRect.Y)
130 |
131 | result.ThumbSize, err = io.Copy(writer, &newBuf)
132 | return
133 | }
134 |
135 | func StringToFloat64Ptr(in string) *float64 {
136 | f, _ := strconv.ParseFloat(in, 64)
137 | return &f
138 | }
139 |
140 | func StringToUInt16(in string) uint16 {
141 | i, _ := strconv.ParseUint(in, 10, 16)
142 | return uint16(i)
143 | }
144 |
--------------------------------------------------------------------------------
/web/album.go:
--------------------------------------------------------------------------------
1 | package web
2 |
3 | import (
4 | "net/http"
5 | "server/db"
6 | "server/handlers"
7 | "server/utils"
8 |
9 | "github.com/gin-gonic/gin"
10 | )
11 |
12 | func AlbumView(c *gin.Context) {
13 | token := c.Param("token")
14 | rows, err := db.Instance.
15 | Table("album_shares").
16 | Select("album_id, albums.name, owners.name, hide_original, hero_asset_id").
17 | Where("token = ? and (expires_at is null or expires_at=0 or expires_at>"+db.TimestampFunc+")", token).
18 | Joins("join albums on album_shares.album_id = albums.id").
19 | Joins("join users on album_shares.user_id = users.id").
20 | Joins("join users as owners on albums.user_id = owners.id").
21 | Rows()
22 |
23 | if err != nil {
24 | c.JSON(http.StatusInternalServerError, handlers.DBError1Response)
25 | return
26 | }
27 | // Get album info
28 | var albumId uint64
29 | var albumName string
30 | var userName string
31 | var hideOriginal int
32 | var heroAssetID *uint64
33 | if rows.Next() {
34 | if err = rows.Scan(&albumId, &albumName, &userName, &hideOriginal, &heroAssetID); err != nil {
35 | c.JSON(http.StatusInternalServerError, handlers.Response{Error: "something went really wrong"})
36 | rows.Close()
37 | return
38 | }
39 | }
40 | rows.Close()
41 | // Get all assets for the album
42 | rows, err = db.Instance.
43 | Table("album_assets").
44 | Select(handlers.AssetsSelectClause).
45 | Joins("join assets on album_assets.asset_id = assets.id").
46 | Joins("left join favourite_assets on favourite_assets.asset_id = assets.id").
47 | Joins(handlers.LeftJoinForLocations).
48 | Where("album_assets.album_id = ? and assets.deleted=0 and assets.size>0 and assets.thumb_size>0", albumId).
49 | Order("assets.created_at ASC").
50 | Rows()
51 |
52 | if err != nil {
53 | c.JSON(http.StatusInternalServerError, handlers.DBError1Response)
54 | return
55 | }
56 | defer rows.Close()
57 | result := handlers.LoadAssetsFromRows(c, rows)
58 | if result == nil {
59 | c.HTML(http.StatusOK, "album_view.tmpl", gin.H{})
60 | return
61 | }
62 | var createdMin, createdMax uint64
63 | createdMin = 100000000000
64 | for i, row := range *result {
65 | // Hide private information
66 | (*result)[i].Owner = 0
67 | (*result)[i].DID = ""
68 | if hideOriginal > 0 {
69 | (*result)[i].GpsLat = nil
70 | (*result)[i].GpsLong = nil
71 | (*result)[i].Location = nil
72 | }
73 | if createdMax < row.Created {
74 | createdMax = row.Created
75 | }
76 | if createdMin > row.Created {
77 | createdMin = row.Created
78 | }
79 | }
80 | downloadParam := "download"
81 | if hideOriginal > 0 {
82 | downloadParam = "thumb"
83 | }
84 | json := gin.H{
85 | "ownerName": "@" + userName,
86 | "subtitle": utils.GetDatesString(int64(createdMin), int64(createdMax)),
87 | "name": albumName,
88 | "assets": result,
89 | "downloadParam": downloadParam,
90 | "heroAssetID": 0,
91 | }
92 | if heroAssetID != nil {
93 | json["heroAssetID"] = *heroAssetID
94 | } else if len(*result) > 0 {
95 | json["heroAssetID"] = (*result)[0].ID
96 | }
97 | if c.Query("format") == "json" {
98 | c.JSON(http.StatusOK, json)
99 | return
100 | }
101 | // json["baseURL"] = config.SELF_BASE_URL + c.Request.URL.String()
102 | json["baseURL"] = c.Request.URL.String()
103 | c.HTML(http.StatusOK, "album_view.tmpl", json)
104 | }
105 |
106 | func AlbumAssetView(c *gin.Context) {
107 | token := c.Param("token")
108 | r := handlers.AssetFetchRequest{}
109 | err := c.ShouldBindQuery(&r)
110 | if err != nil {
111 | c.JSON(http.StatusBadRequest, handlers.Response{Error: err.Error()})
112 | return
113 | }
114 | // Verify we have permission to view this asset
115 | hideOriginalCond := ""
116 | if r.Download == 1 {
117 | hideOriginalCond = " and album_shares.hide_original = 0"
118 | }
119 | rows, err := db.Instance.Table("album_shares").Select("album_assets.album_id").
120 | Where("token = ? and "+
121 | "album_assets.asset_id = ? and "+
122 | "(expires_at is null or expires_at=0 or expires_at>"+db.TimestampFunc+")"+
123 | hideOriginalCond, token, r.ID).
124 | Joins("join album_assets on album_shares.album_id = album_assets.album_id").Rows()
125 |
126 | if err != nil {
127 | c.JSON(http.StatusInternalServerError, handlers.Response{Error: "something went wrong"})
128 | return
129 | }
130 | defer rows.Close()
131 | if !rows.Next() {
132 | c.JSON(http.StatusNotFound, handlers.Response{Error: "something went totally wrong"})
133 | return
134 | }
135 | // Return the asset
136 | handlers.RealAssetFetch(c, 0)
137 | }
138 |
--------------------------------------------------------------------------------
/web/call.go:
--------------------------------------------------------------------------------
1 | package web
2 |
3 | import (
4 | "log"
5 | "net/http"
6 | "server/auth"
7 | "server/config"
8 | "server/models"
9 |
10 | "github.com/gin-gonic/gin"
11 | )
12 |
13 | func CallView(c *gin.Context) {
14 | id := c.Param("id")
15 | vc, err := models.VideoCallByID(id)
16 | if err != nil {
17 | c.JSON(http.StatusInternalServerError, gin.H{"error": "Internal Server Error"})
18 | return
19 | }
20 | if vc.ID == "" {
21 | c.JSON(http.StatusNotFound, gin.H{"error": "Not Found"})
22 | return
23 | }
24 | // Load the user session by setting the token cookie manually from the query
25 | sessionToken := c.Query("token")
26 | c.Request.Header.Add("Cookie", "token="+sessionToken)
27 | session := auth.LoadSession(c)
28 | user := session.User()
29 | log.Printf("User %d is trying to join call %s", user.ID, vc.ID)
30 |
31 | c.HTML(http.StatusOK, "call_view.tmpl", gin.H{
32 | "id": vc.ID,
33 | "wsQuery": "token=" + sessionToken,
34 | "turnIP": config.TURN_SERVER_IP,
35 | "turnPort": config.TURN_SERVER_PORT,
36 | })
37 | }
38 |
--------------------------------------------------------------------------------
/web/upload.go:
--------------------------------------------------------------------------------
1 | package web
2 |
3 | import (
4 | "fmt"
5 | "net/http"
6 | "server/db"
7 | "server/handlers"
8 | "server/models"
9 | "strconv"
10 | "time"
11 |
12 | "github.com/gin-gonic/gin"
13 | )
14 |
15 | type UploadConfirmation struct {
16 | ID uint64 `json:"id" binding:"required"` // Local DB ID
17 | Size int64 `json:"size" binding:"required"`
18 | MimeType string `json:"mime_type" binding:""`
19 | }
20 |
21 | type NewAssetResponse struct {
22 | ID uint64 `json:"id"`
23 | URL string `json:"url"`
24 | }
25 |
26 | func getUploadRequest(c *gin.Context) (req models.UploadRequest, err error) {
27 | token := c.Param("token")
28 | // Valid for 3 hours
29 | err = db.Instance.
30 | Where("token = ? and created_at >= "+db.TimestampFunc+"-3*3600", token).
31 | Preload("User").
32 | Find(&req).Error
33 | return
34 | }
35 |
36 | func UploadRequestProcess(c *gin.Context) {
37 | req, err := getUploadRequest(c)
38 | if err != nil || req.ID == 0 {
39 | fmt.Println(err)
40 | c.JSON(http.StatusInternalServerError, handlers.Response{Error: "something went wrong"})
41 | return
42 | }
43 | handlers.BackupLocalAsset(req.UserID, c)
44 | }
45 |
46 | func UploadRequestView(c *gin.Context) {
47 | req, err := getUploadRequest(c)
48 | if err != nil || req.ID == 0 {
49 | fmt.Println(err)
50 | c.JSON(http.StatusInternalServerError, handlers.Response{Error: "something went wrong"})
51 | return
52 | }
53 | // Some cleanup
54 | db.Instance.Exec("delete from upload_requests where created_at < " + db.TimestampFunc + "-7200")
55 |
56 | c.HTML(http.StatusOK, "upload_files.tmpl", gin.H{
57 | "who": "@" + req.User.Name,
58 | })
59 | }
60 |
61 | func UploadRequestNewURL(c *gin.Context) {
62 | req, err := getUploadRequest(c)
63 | if err != nil || req.ID == 0 {
64 | c.JSON(http.StatusInternalServerError, handlers.Response{Error: "something went wrong"})
65 | return
66 | }
67 | prefix := req.Token
68 | if len(prefix) > 10 {
69 | prefix = prefix[:10]
70 | }
71 | // TODO: user NewMetadata here too instead of all this
72 | if req.User.HasNoRemainingQuota() {
73 | c.JSON(http.StatusForbidden, handlers.Response{Error: "Quota exceeded"})
74 | return
75 | }
76 | asset := models.Asset{
77 | UserID: req.UserID,
78 | BucketID: *req.User.BucketID,
79 | RemoteID: prefix + "_" + strconv.FormatInt(time.Now().UnixNano(), 10),
80 | Name: c.Query("name"),
81 | CreatedAt: time.Now().UnixMilli() / 1000,
82 | }
83 | result := db.Instance.Create(&asset)
84 | if result.Error != nil {
85 | c.JSON(http.StatusInternalServerError, handlers.DBError1Response)
86 | return
87 | }
88 | if db.Instance.Preload("Bucket").Preload("User").First(&asset).Error != nil {
89 | c.JSON(http.StatusInternalServerError, handlers.DBError1Response)
90 | return
91 | }
92 | response := NewAssetResponse{
93 | ID: asset.ID,
94 | URL: asset.CreateUploadURI(false, req.Token), // TODO: Thumb?
95 | }
96 | // Save as Paths are updated
97 | if db.Instance.Save(&asset).Error != nil {
98 | c.JSON(http.StatusInternalServerError, handlers.DBError2Response)
99 | return
100 | }
101 | c.JSON(http.StatusOK, response)
102 | }
103 |
104 | func UploadRequestConfirm(c *gin.Context) {
105 | req, err := getUploadRequest(c)
106 | if err != nil || req.ID == 0 {
107 | c.JSON(http.StatusInternalServerError, handlers.Response{Error: "something went wrong"})
108 | return
109 | }
110 | var r UploadConfirmation
111 | err = c.ShouldBindJSON(&r)
112 | if err != nil {
113 | c.JSON(http.StatusBadRequest, handlers.Response{Error: err.Error()})
114 | return
115 | }
116 | asset := models.Asset{
117 | ID: r.ID,
118 | UserID: req.UserID,
119 | }
120 | result := db.Instance.First(&asset)
121 | if result.Error != nil {
122 | c.JSON(http.StatusInternalServerError, handlers.DBError1Response)
123 | return
124 | }
125 | asset.Size = r.Size
126 | asset.MimeType = r.MimeType
127 | db.Instance.Updates(&asset)
128 | c.JSON(http.StatusOK, handlers.OKResponse)
129 | }
130 |
131 | func DisallowRobots(c *gin.Context) {
132 | // c.String(http.StatusOK, "User-agent: *\nDisallow: /\n")
133 | c.String(http.StatusOK, "User-agent: facebookexternalhit\nAllow: /w/*\n\n"+"User-agent: *\nDisallow: /\n")
134 | }
135 |
--------------------------------------------------------------------------------
/webrtc/room.go:
--------------------------------------------------------------------------------
1 | package webrtc
2 |
3 | import (
4 | "encoding/json"
5 | "log"
6 | "server/utils"
7 | "sync"
8 | "time"
9 |
10 | "github.com/gorilla/websocket"
11 | )
12 |
13 | const (
14 | roomAbandonedTimeout = 1 * time.Minute
15 | userAbandonedTimeout = 20 * time.Second
16 | )
17 |
18 | type Client struct {
19 | conn *websocket.Conn
20 | ID string
21 | UserID uint64
22 | lastSeen time.Time
23 | }
24 |
25 | type Room struct {
26 | ID string
27 | mutex sync.RWMutex
28 | clients []*Client
29 | }
30 |
31 | var (
32 | rooms = make(map[string]*Room)
33 | lastSeen = make(map[string]time.Time)
34 | mutex sync.Mutex
35 | )
36 |
37 | func init() {
38 | go backgroundCleanup()
39 | }
40 |
41 | func ValidateRoom(room string) bool {
42 | mutex.Lock()
43 | _, exists := rooms[room]
44 | mutex.Unlock()
45 | return exists
46 | }
47 |
48 | func backgroundCleanup() {
49 | for {
50 | // Check for abandoned clients every 20 seconds
51 | mutex.Lock()
52 | checkAbandonedRooms()
53 | tmpRooms := make(map[string]*Room, len(rooms))
54 | for id, room := range rooms {
55 | tmpRooms[id] = room
56 | }
57 | mutex.Unlock()
58 | for _, room := range tmpRooms {
59 | abandoned := []string{}
60 | room.CheckAbandonedClients(func(clientId string) {
61 | abandoned = append(abandoned, clientId)
62 | })
63 | for _, clientId := range abandoned {
64 | room.Broadcast(clientId, map[string]interface{}{
65 | "type": "left",
66 | "from": clientId,
67 | })
68 | log.Printf("Client %s abandoned room\n", clientId)
69 | }
70 | }
71 | time.Sleep(userAbandonedTimeout)
72 | }
73 | }
74 |
75 | // checkAbandonedRooms checks for abandoned rooms and removes them (assumes the main mutex is locked)
76 | func checkAbandonedRooms() {
77 | for id, last := range lastSeen {
78 | if time.Since(last) > roomAbandonedTimeout {
79 | log.Printf("Room %s has been abandoned\n", id)
80 | delete(rooms, id)
81 | delete(lastSeen, id)
82 | }
83 | }
84 | }
85 |
86 | func GetRoom(id string) (room *Room, isNew bool) {
87 | mutex.Lock()
88 | defer mutex.Unlock()
89 | if room, exists := rooms[id]; exists {
90 | lastSeen[id] = time.Now()
91 | return room, false
92 | }
93 | room = &Room{
94 | ID: id,
95 | }
96 | rooms[id] = room
97 | lastSeen[id] = time.Now()
98 | return room, true
99 | }
100 |
101 | func (r *Room) CheckAbandonedClients(callback func(string)) {
102 | r.mutex.Lock()
103 | log.Printf("Checking for abandoned clients in room %s\n", r.ID)
104 | // Iterate over clients in reverse order to remove abandoned clients as there might be more than one
105 | for i := len(r.clients) - 1; i >= 0; i-- {
106 | client := r.clients[i]
107 | log.Printf("Client %s, last seen %v ago\n", client.ID, time.Since(client.lastSeen))
108 | if time.Since(client.lastSeen) > userAbandonedTimeout {
109 | callback(client.ID)
110 | r.clients = append(r.clients[:i], r.clients[i+1:]...)
111 | break
112 | }
113 | }
114 | r.mutex.Unlock()
115 | }
116 |
117 | func (r *Room) SeenClient(client *Client) {
118 | // Update the last seen time for the room
119 | mutex.Lock()
120 | lastSeen[r.ID] = time.Now()
121 | mutex.Unlock()
122 | // Update the last seen time for the client
123 | r.mutex.RLock()
124 | defer r.mutex.RUnlock()
125 | for _, c := range r.clients {
126 | if c == client {
127 | c.lastSeen = time.Now()
128 | break
129 | }
130 | }
131 | }
132 |
133 | func (r *Room) SetUpClient(conn *websocket.Conn, id string, userID uint64) (client *Client, isNew bool, numClients int) {
134 | // Is the client already in the room?
135 | for _, c := range r.clients {
136 | if c.ID == id {
137 | // Update the connection and last seen time
138 | c.conn = conn
139 | c.lastSeen = time.Now()
140 | return c, false, len(r.clients)
141 | }
142 | }
143 | // Add new client to the room
144 | client = &Client{
145 | conn: conn,
146 | ID: utils.Rand8BytesToBase62(),
147 | lastSeen: time.Now(),
148 | UserID: userID,
149 | }
150 | r.clients = append(r.clients, client)
151 | return client, true, len(r.clients)
152 | }
153 |
154 | func (r *Room) RemoveClient(client *Client) {
155 | r.mutex.Lock()
156 | for i, c := range r.clients {
157 | if c == client {
158 | r.clients = append(r.clients[:i], r.clients[i+1:]...)
159 | break
160 | }
161 | }
162 | r.mutex.Unlock()
163 | }
164 |
165 | func (r *Room) Broadcast(from string, data interface{}) {
166 | message, _ := json.Marshal(data)
167 | r.mutex.RLock()
168 | for _, client := range r.clients {
169 | if client.ID != from {
170 | log.Printf("Sending (brodacast) message to %s: %s\n", client.ID, string(message))
171 | client.conn.WriteMessage(websocket.TextMessage, message)
172 | }
173 | }
174 | r.mutex.RUnlock()
175 | }
176 |
177 | func (r *Room) MessageTo(clientId string, data interface{}) {
178 | message, _ := json.Marshal(data)
179 | r.mutex.RLock()
180 | for _, client := range r.clients {
181 | if client.ID == clientId {
182 | log.Printf("Sending (private) message to %s: %s\n", client.ID, string(message))
183 | client.conn.WriteMessage(websocket.TextMessage, message)
184 | break
185 | }
186 | }
187 | r.mutex.RUnlock()
188 | }
189 |
190 | func (r *Room) GetOnlineUsers() (result []uint64) {
191 | r.mutex.RLock()
192 | for _, client := range r.clients {
193 | result = append(result, client.UserID)
194 | }
195 | r.mutex.RUnlock()
196 | return
197 | }
198 |
--------------------------------------------------------------------------------
/webrtc/turn.go:
--------------------------------------------------------------------------------
1 | package webrtc
2 |
3 | import (
4 | "fmt"
5 | "net"
6 | "strconv"
7 |
8 | "log"
9 |
10 | "github.com/pion/turn/v2"
11 | )
12 |
13 | const (
14 | realm = "circled.me"
15 | )
16 |
17 | type TurnServer struct {
18 | Port int
19 | PublicIP string
20 | TrafficMinPort int
21 | TrafficMaxPort int
22 | AuthFunc func(userToken string) bool
23 | server *turn.Server
24 | }
25 |
26 | func (ts *TurnServer) Start() (err error) {
27 | udpListener, err := net.ListenPacket("udp4", "0.0.0.0:"+strconv.Itoa(ts.Port))
28 | if err != nil {
29 | return fmt.Errorf("Failed to create TURN server listener: %s", err)
30 | }
31 |
32 | ts.server, err = turn.NewServer(turn.ServerConfig{
33 | Realm: realm,
34 | AuthHandler: func(username string, realm string, srcAddr net.Addr) ([]byte, bool) { // nolint: revive
35 | if ts.AuthFunc(username) {
36 | return turn.GenerateAuthKey(username, realm, username), true
37 | }
38 | return nil, false
39 | },
40 | // PacketConnConfigs is a list of UDP Listeners and the configuration around them
41 | PacketConnConfigs: []turn.PacketConnConfig{
42 | {
43 | PacketConn: udpListener,
44 | RelayAddressGenerator: &turn.RelayAddressGeneratorPortRange{
45 | RelayAddress: net.ParseIP(ts.PublicIP), // Claim that we are listening on IP passed by user (This should be your Public IP)
46 | Address: "0.0.0.0", // But actually be listening on every interface
47 | MinPort: uint16(ts.TrafficMinPort),
48 | MaxPort: uint16(ts.TrafficMaxPort),
49 | },
50 | },
51 | },
52 | })
53 | return
54 | }
55 |
56 | func (ts *TurnServer) Stop() {
57 | if err := ts.server.Close(); err != nil {
58 | log.Printf("Closing TURN server error: %v", err)
59 | }
60 | }
61 |
--------------------------------------------------------------------------------