Merge branch 'master' into advanced-permissions-phase-1

4 files changed, 156 insertions, 64 deletions

diff --git a/app/import.go b/app/import.go
index 6291794b0..5a3158fab 100644
--- a/app/import.go
+++ b/app/import.go
@@ -817,6 +817,12 @@ func (a *App) ImportUserTeams(user *model.User, data *[]UserTeamImportData) *mod
 			}
 		}
 
+		if defaultChannel, err := a.GetChannelByName(model.DEFAULT_CHANNEL, team.Id); err != nil {
+			return err
+		} else if _, err = a.addUserToChannel(user, defaultChannel, member); err != nil {
+			return err
+		}
+
 		if err := a.ImportUserChannels(user, team, member, tdata.Channels); err != nil {
 			return err
 		}
diff --git a/app/license.go b/app/license.go
index 6a2206747..148b10317 100644
--- a/app/license.go
+++ b/app/license.go
@@ -129,7 +129,7 @@ func (a *App) SetLicense(license *model.License) bool {
 	}
 
 	a.licenseValue.Store((*model.License)(nil))
-	a.SetClientLicense(map[string]string{"IsLicensed": "false"})
+	a.clientLicenseValue.Store(map[string]string(nil))
 	return false
 }
 
@@ -148,8 +148,10 @@ func (a *App) SetClientLicense(m map[string]string) {
 }
 
 func (a *App) ClientLicense() map[string]string {
-	clientLicense, _ := a.clientLicenseValue.Load().(map[string]string)
-	return clientLicense
+	if clientLicense, _ := a.clientLicenseValue.Load().(map[string]string); clientLicense != nil {
+		return clientLicense
+	}
+	return map[string]string{"IsLicensed": "false"}
 }
 
 func (a *App) RemoveLicense() *model.AppError {
diff --git a/app/post.go b/app/post.go
index 3f6252faa..3f157672b 100644
--- a/app/post.go
+++ b/app/post.go
@@ -6,12 +6,11 @@ package app
 import (
 	"crypto/hmac"
 	"crypto/sha1"
-	"crypto/sha256"
-	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"net/url"
 	"regexp"
 	"strings"
 
@@ -727,23 +726,68 @@ func (a *App) GetFileInfosForPost(postId string, readFromMaster bool) ([]*model.
 	return infos, nil
 }
 
-func (a *App) GetOpenGraphMetadata(url string) *opengraph.OpenGraph {
+func (a *App) GetOpenGraphMetadata(requestURL string) *opengraph.OpenGraph {
 	og := opengraph.NewOpenGraph()
 
-	res, err := a.HTTPClient(false).Get(url)
+	res, err := a.HTTPClient(false).Get(requestURL)
 	if err != nil {
-		l4g.Error("GetOpenGraphMetadata request failed for url=%v with err=%v", url, err.Error())
+		l4g.Error("GetOpenGraphMetadata request failed for url=%v with err=%v", requestURL, err.Error())
 		return og
 	}
 	defer consumeAndClose(res)
 
 	if err := og.ProcessHTML(res.Body); err != nil {
-		l4g.Error("GetOpenGraphMetadata processing failed for url=%v with err=%v", url, err.Error())
+		l4g.Error("GetOpenGraphMetadata processing failed for url=%v with err=%v", requestURL, err.Error())
 	}
 
+	makeOpenGraphURLsAbsolute(og, requestURL)
+
 	return og
 }
 
+func makeOpenGraphURLsAbsolute(og *opengraph.OpenGraph, requestURL string) {
+	parsedRequestURL, err := url.Parse(requestURL)
+	if err != nil {
+		l4g.Warn("makeOpenGraphURLsAbsolute failed to parse url=%v", requestURL)
+		return
+	}
+
+	makeURLAbsolute := func(resultURL string) string {
+		if resultURL == "" {
+			return resultURL
+		}
+
+		parsedResultURL, err := url.Parse(resultURL)
+		if err != nil {
+			l4g.Warn("makeOpenGraphURLsAbsolute failed to parse result url=%v", resultURL)
+			return resultURL
+		}
+
+		if parsedResultURL.IsAbs() {
+			return resultURL
+		}
+
+		return parsedRequestURL.ResolveReference(parsedResultURL).String()
+	}
+
+	og.URL = makeURLAbsolute(og.URL)
+
+	for _, image := range og.Images {
+		image.URL = makeURLAbsolute(image.URL)
+		image.SecureURL = makeURLAbsolute(image.SecureURL)
+	}
+
+	for _, audio := range og.Audios {
+		audio.URL = makeURLAbsolute(audio.URL)
+		audio.SecureURL = makeURLAbsolute(audio.SecureURL)
+	}
+
+	for _, video := range og.Videos {
+		video.URL = makeURLAbsolute(video.URL)
+		video.SecureURL = makeURLAbsolute(video.SecureURL)
+	}
+}
+
 func (a *App) DoPostAction(postId string, actionId string, userId string) *model.AppError {
 	pchan := a.Srv.Store.Post().GetSingle(postId)
 
@@ -897,18 +941,6 @@ func (a *App) ImageProxyAdder() func(string) string {
 			mac.Write([]byte(url))
 			digest := hex.EncodeToString(mac.Sum(nil))
 			return proxyURL + digest + "/" + hex.EncodeToString([]byte(url))
-		case "willnorris/imageproxy":
-			options := strings.Split(options, "|")
-			if len(options) > 1 {
-				mac := hmac.New(sha256.New, []byte(options[1]))
-				mac.Write([]byte(url))
-				digest := base64.URLEncoding.EncodeToString(mac.Sum(nil))
-				if options[0] == "" {
-					return proxyURL + "s" + digest + "/" + url
-				}
-				return proxyURL + options[0] + ",s" + digest + "/" + url
-			}
-			return proxyURL + options[0] + "/" + url
 		}
 
 		return url
@@ -931,12 +963,6 @@ func (a *App) ImageProxyRemover() (f func(string) string) {
 					}
 				}
 			}
-		case "willnorris/imageproxy":
-			if strings.HasPrefix(url, proxyURL) {
-				if slash := strings.IndexByte(url[len(proxyURL):], '/'); slash >= 0 {
-					return url[len(proxyURL)+slash+1:]
-				}
-			}
 		}
 
 		return url
diff --git a/app/post_test.go b/app/post_test.go
index 207935d58..2e499d3b3 100644
--- a/app/post_test.go
+++ b/app/post_test.go
@@ -8,9 +8,11 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 	"time"
 
+	"github.com/dyatlov/go-opengraph/opengraph"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -245,38 +247,27 @@ func TestImageProxy(t *testing.T) {
 			ImageURL:        "http://mydomain.com/myimage",
 			ProxiedImageURL: "https://127.0.0.1/f8dace906d23689e8d5b12c3cefbedbf7b9b72f5/687474703a2f2f6d79646f6d61696e2e636f6d2f6d79696d616765",
 		},
-		"willnorris/imageproxy": {
-			ProxyType:       "willnorris/imageproxy",
-			ProxyURL:        "https://127.0.0.1",
-			ProxyOptions:    "x1000",
-			ImageURL:        "http://mydomain.com/myimage",
-			ProxiedImageURL: "https://127.0.0.1/x1000/http://mydomain.com/myimage",
-		},
-		"willnorris/imageproxy_SameSite": {
-			ProxyType:       "willnorris/imageproxy",
+		"atmos/camo_SameSite": {
+			ProxyType:       "atmos/camo",
 			ProxyURL:        "https://127.0.0.1",
+			ProxyOptions:    "foo",
 			ImageURL:        "http://mymattermost.com/myimage",
 			ProxiedImageURL: "http://mymattermost.com/myimage",
 		},
-		"willnorris/imageproxy_PathOnly": {
-			ProxyType:       "willnorris/imageproxy",
+		"atmos/camo_PathOnly": {
+			ProxyType:       "atmos/camo",
 			ProxyURL:        "https://127.0.0.1",
+			ProxyOptions:    "foo",
 			ImageURL:        "/myimage",
 			ProxiedImageURL: "/myimage",
 		},
-		"willnorris/imageproxy_EmptyImageURL": {
-			ProxyType:       "willnorris/imageproxy",
+		"atmos/camo_EmptyImageURL": {
+			ProxyType:       "atmos/camo",
 			ProxyURL:        "https://127.0.0.1",
+			ProxyOptions:    "foo",
 			ImageURL:        "",
 			ProxiedImageURL: "",
 		},
-		"willnorris/imageproxy_WithSigning": {
-			ProxyType:       "willnorris/imageproxy",
-			ProxyURL:        "https://127.0.0.1",
-			ProxyOptions:    "x1000|foo",
-			ImageURL:        "http://mydomain.com/myimage",
-			ProxiedImageURL: "https://127.0.0.1/x1000,sbhHVoG5d60UvnNtGh6Iy6x4PaMmnsh8JfZ7JfErKjGU=/http://mydomain.com/myimage",
-		},
 	} {
 		t.Run(name, func(t *testing.T) {
 			th.App.UpdateConfig(func(cfg *model.Config) {
@@ -303,25 +294,92 @@ func TestImageProxy(t *testing.T) {
 	}
 }
 
-var imageProxyBenchmarkSink *model.Post
-
-func BenchmarkPostWithProxyRemovedFromImageURLs(b *testing.B) {
-	th := Setup().InitBasic()
-	defer th.TearDown()
-
-	th.App.UpdateConfig(func(cfg *model.Config) {
-		cfg.ServiceSettings.ImageProxyType = model.NewString("willnorris/imageproxy")
-		cfg.ServiceSettings.ImageProxyOptions = model.NewString("x1000|foo")
-		cfg.ServiceSettings.ImageProxyURL = model.NewString("https://127.0.0.1")
-	})
+func TestMakeOpenGraphURLsAbsolute(t *testing.T) {
+	for name, tc := range map[string]struct {
+		HTML       string
+		RequestURL string
+		URL        string
+		ImageURL   string
+	}{
+		"absolute URLs": {
+			HTML: `
+				<html>
+					<head>
+						<meta property="og:url" content="https://example.com/apps/mattermost">
+						<meta property="og:image" content="https://images.example.com/image.png">
+					</head>
+				</html>`,
+			RequestURL: "https://example.com",
+			URL:        "https://example.com/apps/mattermost",
+			ImageURL:   "https://images.example.com/image.png",
+		},
+		"URLs starting with /": {
+			HTML: `
+				<html>
+					<head>
+						<meta property="og:url" content="/apps/mattermost">
+						<meta property="og:image" content="/image.png">
+					</head>
+				</html>`,
+			RequestURL: "http://example.com",
+			URL:        "http://example.com/apps/mattermost",
+			ImageURL:   "http://example.com/image.png",
+		},
+		"HTTPS URLs starting with /": {
+			HTML: `
+				<html>
+					<head>
+						<meta property="og:url" content="/apps/mattermost">
+						<meta property="og:image" content="/image.png">
+					</head>
+				</html>`,
+			RequestURL: "https://example.com",
+			URL:        "https://example.com/apps/mattermost",
+			ImageURL:   "https://example.com/image.png",
+		},
+		"missing image URL": {
+			HTML: `
+				<html>
+					<head>
+						<meta property="og:url" content="/apps/mattermost">
+					</head>
+				</html>`,
+			RequestURL: "http://example.com",
+			URL:        "http://example.com/apps/mattermost",
+			ImageURL:   "",
+		},
+		"relative URLs": {
+			HTML: `
+				<html>
+					<head>
+						<meta property="og:url" content="index.html">
+						<meta property="og:image" content="../resources/image.png">
+					</head>
+				</html>`,
+			RequestURL: "http://example.com/content/index.html",
+			URL:        "http://example.com/content/index.html",
+			ImageURL:   "http://example.com/resources/image.png",
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			og := opengraph.NewOpenGraph()
+			if err := og.ProcessHTML(strings.NewReader(tc.HTML)); err != nil {
+				t.Fatal(err)
+			}
 
-	post := &model.Post{
-		Message: "![foo](http://mydomain.com/myimage)",
-	}
+			makeOpenGraphURLsAbsolute(og, tc.RequestURL)
 
-	b.ResetTimer()
+			if og.URL != tc.URL {
+				t.Fatalf("incorrect url, expected %v, got %v", tc.URL, og.URL)
+			}
 
-	for i := 0; i < b.N; i++ {
-		imageProxyBenchmarkSink = th.App.PostWithProxyAddedToImageURLs(post)
+			if len(og.Images) > 0 {
+				if og.Images[0].URL != tc.ImageURL {
+					t.Fatalf("incorrect image url, expected %v, got %v", tc.ImageURL, og.Images[0].URL)
+				}
+			} else if tc.ImageURL != "" {
+				t.Fatalf("missing image url, expected %v, got nothing", tc.ImageURL)
+			}
+		})
 	}
 }