hunk.code_window:                 }
               }
           );
       }
  
hunk.labels: add keep keep keep
hunk.after_edit:                 this.setState({submitted: false});
  
hunk.file_path: webapp/components/edit_channel_header_modal.jsx
hunk.type: add
file: // Copyright (c) 2017-present Mattermost, Inc. All Rights Reserved.
  // See License.txt for license information.
  
  package api4
  
  import (
  	"net/http"
  	"net/url"
  	"strconv"
  	"strings"
  
  	l4g "github.com/alecthomas/log4go"
  	"github.com/mattermost/platform/app"
  	"github.com/mattermost/platform/model"
  	"github.com/mattermost/platform/utils"
  )
  
  const (
  	FILE_TEAM_ID = "noteam"
  
  	PREVIEW_IMAGE_TYPE   = "image/jpeg"
  	THUMBNAIL_IMAGE_TYPE = "image/jpeg"
  )
  
  var UNSAFE_CONTENT_TYPES = [...]string{
  	"application/javascript",
  	"application/ecmascript",
  	"text/javascript",
  	"text/ecmascript",
  	"application/x-javascript",
  	"text/html",
  }
  
  var MEDIA_CONTENT_TYPES = [...]string{
  	"image/jpeg",
  	"image/png",
  	"image/bmp",
  	"image/gif",
  	"video/avi",
  	"video/mpeg",
  	"video/mp4",
  	"audio/mpeg",
  	"audio/wav",
  }
  
  func InitFile() {
  	l4g.Debug(utils.T("api.file.init.debug"))
  
  	BaseRoutes.Files.Handle("", ApiSessionRequired(uploadFile)).Methods("POST")
  	BaseRoutes.File.Handle("", ApiSessionRequiredTrustRequester(getFile)).Methods("GET")
  	BaseRoutes.File.Handle("/thumbnail", ApiSessionRequiredTrustRequester(getFileThumbnail)).Methods("GET")
  	BaseRoutes.File.Handle("/link", ApiSessionRequired(getFileLink)).Methods("GET")
  	BaseRoutes.File.Handle("/preview", ApiSessionRequiredTrustRequester(getFilePreview)).Methods("GET")
  	BaseRoutes.File.Handle("/info", ApiSessionRequired(getFileInfo)).Methods("GET")
  
  	BaseRoutes.PublicFile.Handle("", ApiHandler(getPublicFile)).Methods("GET")
  
  }
  
  func uploadFile(c *Context, w http.ResponseWriter, r *http.Request) {
  	if !*utils.Cfg.FileSettings.EnableFileAttachments {
  		c.Err = model.NewAppError("uploadFile", "api.file.attachments.disabled.app_error", nil, "", http.StatusNotImplemented)
  		return
  	}
  
  	if r.ContentLength > *utils.Cfg.FileSettings.MaxFileSize {
  		c.Err = model.NewAppError("uploadFile", "api.file.upload_file.too_large.app_error", nil, "", http.StatusRequestEntityTooLarge)
  		return
  	}
  
  	if err := r.ParseMultipartForm(*utils.Cfg.FileSettings.MaxFileSize); err != nil {
  		http.Error(w, err.Error(), http.StatusInternalServerError)
  		return
  	}
  
  	m := r.MultipartForm
  
  	props := m.Value
  	if len(props["channel_id"]) == 0 {
  		c.SetInvalidParam("channel_id")
  		return
  	}
  	channelId := props["channel_id"][0]
  	if len(channelId) == 0 {
  		c.SetInvalidParam("channel_id")
  		return
  	}
  
  	if !app.SessionHasPermissionToChannel(c.Session, channelId, model.PERMISSION_UPLOAD_FILE) {
  		c.SetPermissionError(model.PERMISSION_UPLOAD_FILE)
  		return
  	}
  
  	resStruct, err := app.UploadFiles(FILE_TEAM_ID, channelId, c.Session.UserId, m.File["files"], m.Value["client_ids"])
  	if err != nil {
  		c.Err = err
  		return
  	}
  
  	w.WriteHeader(http.StatusCreated)
  	w.Write([]byte(resStruct.ToJson()))
  }
  
  func getFile(c *Context, w http.ResponseWriter, r *http.Request) {
  	c.RequireFileId()
  	if c.Err != nil {
  		return
  	}
  
  	forceDownload, convErr := strconv.ParseBool(r.URL.Query().Get("download"))
  	if convErr != nil {
  		forceDownload = false
  	}
  
  	info, err := app.GetFileInfo(c.Params.FileId)
  	if err != nil {
  		c.Err = err
  		return
  	}
  
  	if info.CreatorId != c.Session.UserId && !app.SessionHasPermissionToChannelByPost(c.Session, info.PostId, model.PERMISSION_READ_CHANNEL) {
  		c.SetPermissionError(model.PERMISSION_READ_CHANNEL)
  		return
  	}
  
  	data, err := app.ReadFile(info.Path)
  	if err != nil {
  		c.Err = err
  		c.Err.StatusCode = http.StatusNotFound
  		return
  	}
  
  	err = writeFileResponse(info.Name, info.MimeType, data, forceDownload, w, r)
  	if err != nil {
  		c.Err = err
  		return
  	}
  }
  
  func getFileThumbnail(c *Context, w http.ResponseWriter, r *http.Request) {
  	c.RequireFileId()
  	if c.Err != nil {
  		return
  	}
  
  	forceDownload, convErr := strconv.ParseBool(r.URL.Query().Get("download"))
  	if convErr != nil {
  		forceDownload = false
  	}
  
  	info, err := app.GetFileInfo(c.Params.FileId)
  	if err != nil {
  		c.Err = err
  		return
  	}
  
  	if info.CreatorId != c.Session.UserId && !app.SessionHasPermissionToChannelByPost(c.Session, info.PostId, model.PERMISSION_READ_CHANNEL) {
  		c.SetPermissionError(model.PERMISSION_READ_CHANNEL)
  		return
  	}
  
  	if info.ThumbnailPath == "" {
  		c.Err = model.NewLocAppError("getFileThumbnail", "api.file.get_file_thumbnail.no_thumbnail.app_error", nil, "file_id="+info.Id)
  		c.Err.StatusCode = http.StatusBadRequest
  		return
  	}
  
  	if data, err := app.ReadFile(info.ThumbnailPath); err != nil {
  		c.Err = err
  		c.Err.StatusCode = http.StatusNotFound
  	} else if err := writeFileResponse(info.Name, THUMBNAIL_IMAGE_TYPE, data, forceDownload, w, r); err != nil {
  		c.Err = err
  		return
  	}
  }
  
  func getFileLink(c *Context, w http.ResponseWriter, r *http.Request) {
  	c.RequireFileId()
  	if c.Err != nil {
  		return
  	}
  
  	if !utils.Cfg.FileSettings.EnablePublicLink {
  		c.Err = model.NewLocAppError("getPublicLink", "api.file.get_public_link.disabled.app_error", nil, "")
  		c.Err.StatusCode = http.StatusNotImplemented
  		return
  	}
  
  	info, err := app.GetFileInfo(c.Params.FileId)
  	if err != nil {
  		c.Err = err
  		return
  	}
  
  	if info.CreatorId != c.Session.UserId && !app.SessionHasPermissionToChannelByPost(c.Session, info.PostId, model.PERMISSION_READ_CHANNEL) {
  		c.SetPermissionError(model.PERMISSION_READ_CHANNEL)
  		return
  	}
  
  	if len(info.PostId) == 0 {
  		c.Err = model.NewLocAppError("getPublicLink", "api.file.get_public_link.no_post.app_error", nil, "file_id="+info.Id)
  		c.Err.StatusCode = http.StatusBadRequest
  		return
  	}
  
  	resp := make(map[string]string)
  	resp["link"] = app.GeneratePublicLink(c.GetSiteURLHeader(), info)
  
  	w.Write([]byte(model.MapToJson(resp)))
  }
  
  func getFilePreview(c *Context, w http.ResponseWriter, r *http.Request) {
  	c.RequireFileId()
  	if c.Err != nil {
  		return
  	}
  
  	forceDownload, convErr := strconv.ParseBool(r.URL.Query().Get("download"))
  	if convErr != nil {
  		forceDownload = false
  	}
  
  	info, err := app.GetFileInfo(c.Params.FileId)
  	if err != nil {
  		c.Err = err
  		return
  	}
  
  	if info.CreatorId != c.Session.UserId && !app.SessionHasPermissionToChannelByPost(c.Session, info.PostId, model.PERMISSION_READ_CHANNEL) {
  		c.SetPermissionError(model.PERMISSION_READ_CHANNEL)
  		return
  	}
  
  	if info.PreviewPath == "" {
  		c.Err = model.NewLocAppError("getFilePreview", "api.file.get_file_preview.no_preview.app_error", nil, "file_id="+info.Id)
  		c.Err.StatusCode = http.StatusBadRequest
  		return
  	}
  
  	if data, err := app.ReadFile(info.PreviewPath); err != nil {
  		c.Err = err
  		c.Err.StatusCode = http.StatusNotFound
  	} else if err := writeFileResponse(info.Name, PREVIEW_IMAGE_TYPE, data, forceDownload, w, r); err != nil {
  		c.Err = err
  		return
  	}
  }
  
  func getFileInfo(c *Context, w http.ResponseWriter, r *http.Request) {
  	c.RequireFileId()
  	if c.Err != nil {
  		return
  	}
  
  	info, err := app.GetFileInfo(c.Params.FileId)
  	if err != nil {
  		c.Err = err
  		return
  	}
  
  	if info.CreatorId != c.Session.UserId && !app.SessionHasPermissionToChannelByPost(c.Session, info.PostId, model.PERMISSION_READ_CHANNEL) {
  		c.SetPermissionError(model.PERMISSION_READ_CHANNEL)
  		return
  	}
  
  	w.Header().Set("Cache-Control", "max-age=2592000, public")
  	w.Write([]byte(info.ToJson()))
  }
  
  func getPublicFile(c *Context, w http.ResponseWriter, r *http.Request) {
  	c.RequireFileId()
  	if c.Err != nil {
  		return
  	}
  
  	if !utils.Cfg.FileSettings.EnablePublicLink {
  		c.Err = model.NewLocAppError("getPublicFile", "api.file.get_public_link.disabled.app_error", nil, "")
  		c.Err.StatusCode = http.StatusNotImplemented
  		return
  	}
  
  	info, err := app.GetFileInfo(c.Params.FileId)
  	if err != nil {
  		c.Err = err
  		return
  	}
  
  	hash := r.URL.Query().Get("h")
  
  	if len(hash) == 0 {
  		c.Err = model.NewLocAppError("getPublicFile", "api.file.get_file.public_invalid.app_error", nil, "")
  		c.Err.StatusCode = http.StatusBadRequest
  		return
  	}
  
  	if hash != app.GeneratePublicLinkHash(info.Id, *utils.Cfg.FileSettings.PublicLinkSalt) {
  		c.Err = model.NewLocAppError("getPublicFile", "api.file.get_file.public_invalid.app_error", nil, "")
  		c.Err.StatusCode = http.StatusBadRequest
  		return
  	}
  
  	if data, err := app.ReadFile(info.Path); err != nil {
  		c.Err = err
  		c.Err.StatusCode = http.StatusNotFound
  	} else if err := writeFileResponse(info.Name, info.MimeType, data, true, w, r); err != nil {
  		c.Err = err
  		return
  	}
  }
  
  func writeFileResponse(filename string, contentType string, bytes []byte, forceDownload bool, w http.ResponseWriter, r *http.Request) *model.AppError {
  	w.Header().Set("Cache-Control", "max-age=2592000, private")
  	w.Header().Set("Content-Length", strconv.Itoa(len(bytes)))
  	w.Header().Set("X-Content-Type-Options", "nosniff")
  
  	if contentType == "" {
  		contentType = "application/octet-stream"
  	} else {
  		for _, unsafeContentType := range UNSAFE_CONTENT_TYPES {
  			if strings.HasPrefix(contentType, unsafeContentType) {
  				contentType = "text/plain"
  				break
  			}
  		}
  	}
  
  	w.Header().Set("Content-Type", contentType)
  
  	var toDownload bool
  	if forceDownload {
  		toDownload = true
  	} else {
  		isMediaType := false
  
  		for _, mediaContentType := range MEDIA_CONTENT_TYPES {
  			if strings.HasPrefix(contentType, mediaContentType) {
  				isMediaType = true
  				break
  			}
  		}
  
  		toDownload = !isMediaType
  	}
  
  	if toDownload {
  		w.Header().Set("Content-Disposition", "attachment;filename=\""+filename+"\"; filename*=UTF-8''"+url.QueryEscape(filename))
  	} else {
  		w.Header().Set("Content-Disposition", "inline;filename=\""+filename+"\"; filename*=UTF-8''"+url.QueryEscape(filename))
  	}
  
  	// prevent file links from being embedded in iframes
  	w.Header().Set("X-Frame-Options", "DENY")
  	w.Header().Set("Content-Security-Policy", "Frame-ancestors 'none'")
  
  	w.Write(bytes)
  
  	return nil
  }
  