// Copy form file to Blob func upload(f *multipart.FileHeader) (b *blob.Blob, err error) { // Open upload, err := f.Open() if err != nil { return } defer upload.Close() // Create blob b = blob.New() // Set filename from request b.Name = f.Filename // Set content-type from request if ct := f.Header.Get("Content-Type"); ct != "" { b.ContentType = ct } // Guess content-type from extension if missing if b.ContentType == "" || b.ContentType == ApplicationOctetStream { if ext := filepath.Ext(b.Name); ext != "" { b.ContentType = mime.TypeByExtension(ext) } } if b.ContentType == "" { b.ContentType = ApplicationOctetStream } // Write err = b.WriteFrom(upload) if err != nil { return } return }
func (p *FileResource) ContentTypesProvided(req Request, cxt Context) ([]MediaTypeHandler, Request, Context, int, os.Error) { frc := cxt.(FileResourceContext) var arr []MediaTypeHandler if frc.IsDir() { arr = []MediaTypeHandler{NewJsonDirectoryListing(frc.FullPath(), req.URL().Path), NewHtmlDirectoryListing(frc.FullPath(), req.URL().Path)} } else if frc.HasMultipleResources() { dir, _ := path.Split(frc.FullPath()) filenames := frc.MultipleResourceNames() arr = make([]MediaTypeHandler, len(filenames)) for i, filename := range filenames { extension := filepath.Ext(filename) mediaType := mime.TypeByExtension(extension) if len(mediaType) == 0 { // default to text/plain mediaType = MIME_TYPE_TEXT_PLAIN } fullFilename := path.Join(dir, filename) tempFrc := NewFileResourceContextWithPath(fullFilename) arr[i] = NewPassThroughMediaTypeHandler(mediaType, tempFrc, tempFrc.Len(), tempFrc.LastModified()) } } else { extension := filepath.Ext(frc.FullPath()) mediaType := mime.TypeByExtension(extension) if len(mediaType) == 0 { // default to text/plain mediaType = MIME_TYPE_TEXT_PLAIN } arr = []MediaTypeHandler{NewPassThroughMediaTypeHandler(mediaType, frc, frc.Len(), frc.LastModified())} } return arr, req, cxt, 0, nil }
func (s *Sisho) walkRepo() error { // * walk repo and generate constitution of repo. err := filepath.Walk(s.tmpDir, func(path string, info os.FileInfo, err error) error { if err != nil { return err } if info.IsDir() { return nil } isGitDir, isGitDirErr := regexp.MatchString(s.tmpDir+"/.git/", path) if isGitDirErr != nil { return err } if isGitDir { return nil } tmp := strings.Split(path, "/") name := tmp[len(tmp)-1] ext := filepath.Ext(path) r := regexp.MustCompile(s.tmpDir + "/") if util.IsBinary(ext) { a := ContentAsset{ Content: Content{ path: path, relativePath: r.ReplaceAllString(path, ""), name: name, contentType: mime.TypeByExtension(ext), }, ext: ext, } s.assets = append(s.assets, a) return nil } c := Code{ Content: Content{ path: path, relativePath: r.ReplaceAllString(path, ""), name: name, contentType: mime.TypeByExtension(ext), }, Title: "", TextLines: []string{}, } s.contents = append(s.contents, c) return nil }) if err == nil { return err } return nil }
//设置ContentType func (r Response) SetContentType(ext string) { var contentType string //判断传入的扩展名是否有. if !strings.HasPrefix(ext, ".") { ext = "." + ext } //如果能从系统mime中获取相应的type,则使用系统提供的mimetype;否则的话,将application/ext直接设置为content type if mime.TypeByExtension(ext) != "" { contentType = mime.TypeByExtension(ext) } else { contentType = "application/" + strings.TrimPrefix(ext, ".") + ";charset=utf-8" } r.SetHeader("Content-Type", contentType, true) }
func fileExtImpliesText(ext string) (yes, unknown bool) { defer func() { glog.V(2).Infof("'%s' -> yes=%v unknown=%v", ext, yes, unknown) }() if ext == "" { unknown = true return } mt := mime.TypeByExtension(ext) if strings.HasPrefix(mt, "text/") || strings.HasSuffix(mt, "+xml") || strings.HasSuffix(mt, ".json") || strings.HasSuffix(mt, "+json") { // Most likely text. yes = true glog.V(1).Infof("Most likely a text extension: %s", ext) return } if strings.HasPrefix(mt, "audio/") || strings.HasPrefix(mt, "image/") || strings.HasPrefix(mt, "video/") { // Almost certainly not text. glog.V(1).Infof("Most likely a binary extension: %s", ext) return } unknown = true return }
// Slower operations to fill props struct func (p *props) load(h hash.Hash, name string) *props { p.mime = mime.TypeByExtension(p.ext) r, err := os.Open(name) if err != nil { log.Print(name, ": Props: ", err) return p } defer r.Close() p.ftype = mapType(p.mime) // TODO: this is quite unreadable copy(p.chash[:], filehash(name, h, r)) copy(p.dident[:], strhash(p.dir, h)) // If the extension is empty, we need to detect // the MIME type via file contents if p.mime == "" { p.mime = sniffMIME(name, r) } // Non-images are completely processed at this point if !strings.HasPrefix(p.mime, "image/") { return p } // Image-specific processing if _, err := r.Seek(0, 0); err != nil { log.Print(name, ": Seek: ", err) return p } imgconf, _, err := image.DecodeConfig(r) if err != nil { log.Print(name, ": Image decoder: ", err) return p } p.isize = image.Point{imgconf.Width, imgconf.Height} return p }
func (w *messageWriter) addFiles(files []*file, isAttachment bool) { for _, f := range files { if _, ok := f.Header["Content-Type"]; !ok { mediaType := mime.TypeByExtension(filepath.Ext(f.Name)) if mediaType == "" { mediaType = "application/octet-stream" } f.setHeader("Content-Type", mediaType+`; name="`+f.Name+`"`) } if _, ok := f.Header["Content-Transfer-Encoding"]; !ok { f.setHeader("Content-Transfer-Encoding", string(Base64)) } if _, ok := f.Header["Content-Disposition"]; !ok { var disp string if isAttachment { disp = "attachment" } else { disp = "inline" } f.setHeader("Content-Disposition", disp+`; filename="`+f.Name+`"`) } if !isAttachment { if _, ok := f.Header["Content-ID"]; !ok { f.setHeader("Content-ID", "<"+f.Name+">") } } w.writeHeaders(f.Header) w.writeBody(f.CopyFunc, Base64) } }
func embeddedStatic() func(http.ResponseWriter, *http.Request, *log.Logger) { var modt = time.Now().UTC().Format(http.TimeFormat) return func(res http.ResponseWriter, req *http.Request, log *log.Logger) { file := req.URL.Path if file[0] == '/' { file = file[1:] } bs, ok := auto.Assets[file] if !ok { return } mtype := mime.TypeByExtension(filepath.Ext(req.URL.Path)) if len(mtype) != 0 { res.Header().Set("Content-Type", mtype) } res.Header().Set("Content-Length", fmt.Sprintf("%d", len(bs))) res.Header().Set("Last-Modified", modt) res.Write(bs) } }
func (h *fsHandler) newFSFile(f *os.File, fileInfo os.FileInfo, compressed bool) (*fsFile, error) { n := fileInfo.Size() contentLength := int(n) if n != int64(contentLength) { f.Close() return nil, fmt.Errorf("too big file: %d bytes", n) } // detect content-type ext := fileExtension(fileInfo.Name(), compressed) contentType := mime.TypeByExtension(ext) if len(contentType) == 0 { data, err := readFileHeader(f, compressed) if err != nil { return nil, fmt.Errorf("cannot read header of the file %q: %s", f.Name(), err) } contentType = http.DetectContentType(data) } lastModified := fileInfo.ModTime() ff := &fsFile{ h: h, f: f, contentType: contentType, contentLength: contentLength, compressed: compressed, lastModified: lastModified, lastModifiedStr: AppendHTTPDate(nil, lastModified), t: time.Now(), } return ff, nil }
// Returns a guess at the mime type from the extension func MimeType(o Object) string { mimeType := mime.TypeByExtension(path.Ext(o.Remote())) if mimeType == "" { mimeType = "application/octet-stream" } return mimeType }
func (ctx *Context) ContentType(ext string) { ctype := mime.TypeByExtension(ext) if ctype != "" { ctx.ResponseWriter.Header().Set("Content-Type", ctype) } }
// serveCombo serves the GUI JavaScript and CSS files, dynamically combined. func (h *guiHandler) serveCombo(w http.ResponseWriter, req *http.Request) { ctype := "" // The combo query is like /combo/?path/to/file1&path/to/file2 ... parts := strings.Split(req.URL.RawQuery, "&") paths := make([]string, 0, len(parts)) for _, p := range parts { fpath, err := getGUIComboPath(h.rootDir, p) if err != nil { sendError(w, errors.Annotate(err, "cannot combine files")) return } if fpath == "" { continue } paths = append(paths, fpath) // Assume the Juju GUI does not mix different content types when // combining contents. if ctype == "" { ctype = mime.TypeByExtension(filepath.Ext(fpath)) } } w.Header().Set("Content-Type", ctype) for _, fpath := range paths { sendGUIComboFile(w, fpath) } }
// Deploys a site to S3. func (s *Site) Deploy(user, pass, url string) error { auth := aws.Auth{AccessKey: user, SecretKey: pass} b := s3.New(auth, aws.USEast).Bucket(url) // walks _site directory and uploads file to S3 walker := func(fn string, fi os.FileInfo, err error) error { if fi.IsDir() { return nil } rel, _ := filepath.Rel(s.Dest, fn) typ := mime.TypeByExtension(filepath.Ext(rel)) content, err := ioutil.ReadFile(fn) log.Printf(MsgUploadFile, rel) if err != nil { return err } // try to upload the file ... sometimes this fails due to amazon // issues. If so, we'll re-try if err := b.Put(rel, content, typ, s3.PublicRead); err != nil { time.Sleep(100 * time.Millisecond) // sleep so that we don't immediately retry return b.Put(rel, content, typ, s3.PublicRead) } // file upload was a success, return nil return nil } return filepath.Walk(s.Dest, walker) }
func (s *s3Provider) WriteFile(path string, content io.ReadSeeker, public bool) error { bucket, path, err := s.getBucketPath(path) if err != nil { return err } ext := filepath.Ext(path) mimeType := mime.TypeByExtension(ext) if mimeType == "" { mimeType = "application/octet-stream" } params := &s3.PutObjectInput{ Bucket: aws.String(bucket), Key: aws.String(path), Body: content, ContentType: aws.String(mimeType), } if public { params.ACL = aws.String("public-read") } _, err = s.conn.PutObject(params) return err }
//File saving routines func saveFile(header *multipart.FileHeader, r io.Reader) (string, error) { if client, err := storage.GetNewStorageClient(); err == nil { h := public.NewHashString() objName := storage.PathJoin(storage.APPLICATIONS_FOLDER_NAME, h) //Determine the extension var ext string = "" if header != nil { if segs := strings.Split(header.Filename, "."); len(segs) > 1 { ext = "." + segs[len(segs)-1] objName = (objName + ext) } } obj := client.GetDefaultBucket().Object(objName) objWriter := obj.NewWriter(client.Ctx) _, err = io.Copy(objWriter, r) objWriter.Close() if err == nil { if attr, e := obj.Attrs(client.Ctx); attr != nil && e == nil { if mimeStr := mime.TypeByExtension(ext); len(mimeStr) > 0 { attr.ContentType = mimeStr obj.Update(client.Ctx, *attr) } } return objName, nil } else { return "", err } } else { return "", err } }
func walkpath(path string, f os.FileInfo, err error) error { fi, err := os.Open(path) if err != nil { panic(err) } defer func() { if err := fi.Close(); err != nil { panic(err) } }() ext := filepath.Ext(path) // This tests if something is a directory; basically, look for a file extension. If that doesn't exist, assume // it's a directory and don't upload it to S3 if len(ext) > 0 { key := path[2:len(path)] mtype := mime.TypeByExtension(ext) fmt.Println(key) err = s3Upload(&key, &bucket, fi, &mtype) if err != nil { panic(err) } } else { fmt.Println("Directory, skipping") } return err }
func makeVisitor(uploads chan FileUpload, bucket *s3.Bucket, waiter *sync.WaitGroup, args args) func(string, os.FileInfo, error) error { return func(fpath string, f os.FileInfo, err error) error { node := isfile(f) if node { contType := mime.TypeByExtension(path.Ext(fpath)) if contType == "" { contType = args.mimetype } fu := FileUpload{ ContentType: contType, Path: fpath, Bucket: bucket, } if runtime.NumGoroutine() > concurrency { uploadFile(fu, args, nil) } else { waiter.Add(1) go uploadFile(fu, args, func() { waiter.Done() }) } } return nil } }
func (cache *FileCache) HttpWriteFile(w http.ResponseWriter, r *http.Request) { path, err := url.QueryUnescape(r.URL.String()) if err != nil { http.ServeFile(w, r, r.URL.Path) } else if len(path) > 1 { path = path[1:len(path)] } else { http.ServeFile(w, r, ".") return } if cache.InCache(path) { itm := cache.items[path] ctype := http.DetectContentType(itm.Access()) mtype := mime.TypeByExtension(filepath.Ext(path)) if mtype != "" && mtype != ctype { ctype = mtype } w.Header().Set("content-length", fmt.Sprintf("%d", itm.Size)) w.Header().Set("content-disposition", fmt.Sprintf("filename=%s", filepath.Base(path))) w.Header().Set("content-type", ctype) w.Write(itm.Access()) return } go cache.Cache(path) http.ServeFile(w, r, path) }
// FileServerHandler function func FileServerHandler(c *echo.Context) error { fileType := mime.TypeByExtension(filepath.Ext(filepath.Base(c.Request().URL.String()))) log.Println(c.Request().URL.String()[1:]) c.Response().Header().Set("Content-Type", fileType) io.Copy(c.Response(), bytes.NewReader(staticFiles.Get(c.Request().URL.String()[1:]))) return nil }
func (v *Views) ServeHTTP(w http.ResponseWriter, r *http.Request, ss sessions.Session) { if v.Rewrite(w, r, ss) { // redirected return } var ok bool name := r.URL.Path[1:] if _, ok = v.Names[name]; !ok { name = v.Index } ext := path.Ext(name) ct := mime.TypeByExtension(ext) w.Header().Set("Content-Type", ct) data, _ := Asset(name) hdr := r.Header.Get("Accept-Encoding") if strings.Contains(hdr, "gzip") { w.Header().Set("Content-Encoding", "gzip") w.Write(data) } else { gz, err := gzip.NewReader(bytes.NewBuffer(data)) if err != nil { w.Write([]byte(err.Error())) return } io.Copy(w, gz) gz.Close() } }
func newFilePart(fullPathFilename string) (ret FilePart, err error) { fh, openErr := os.Open(fullPathFilename) if openErr != nil { glog.V(0).Info("Failed to open file: ", fullPathFilename) return ret, openErr } ret.Reader = fh if fi, fiErr := fh.Stat(); fiErr != nil { glog.V(0).Info("Failed to stat file:", fullPathFilename) return ret, fiErr } else { ret.ModTime = fi.ModTime().UTC().Unix() ret.FileSize = fi.Size() } ext := strings.ToLower(path.Ext(fullPathFilename)) ret.IsGzipped = ext == ".gz" if ret.IsGzipped { ret.FileName = fullPathFilename[0 : len(fullPathFilename)-3] } ret.FileName = fullPathFilename if ext != "" { ret.MimeType = mime.TypeByExtension(ext) } return ret, nil }
func (this *RequestContext) Static(version string) error { // host static files var mimetype string lastdot := strings.LastIndex(this.path, ".") if lastdot > -1 { mimetype = mime.TypeByExtension(this.path[lastdot:]) } w := *this.res var content []byte var err error if len(version) > 0 { content, err = getFileOfVersion(this.path, version) } else { content, err = ioutil.ReadFile(this.path) } if mimetype == "" { if len(content) == 0 { mimetype = "text/plain" } else { mimetype = http.DetectContentType(content) } } if err != nil { return err } w.Header().Set("Content-Type", mimetype) w.Write(content) return nil }
// UploadReleaseAsset creates an asset by uploading a file into a release repository. // To upload assets that cannot be represented by an os.File, call NewUploadRequest directly. // // GitHub API docs : http://developer.github.com/v3/repos/releases/#upload-a-release-asset func (s *RepositoriesService) UploadReleaseAsset(owner, repo string, id int, opt *UploadOptions, file *os.File) (*ReleaseAsset, *Response, error) { u := fmt.Sprintf("repos/%s/%s/releases/%d/assets", owner, repo, id) u, err := addOptions(u, opt) if err != nil { return nil, nil, err } stat, err := file.Stat() if err != nil { return nil, nil, err } if stat.IsDir() { return nil, nil, errors.New("the asset to upload can't be a directory") } mediaType := mime.TypeByExtension(filepath.Ext(file.Name())) req, err := s.client.NewUploadRequest(u, file, stat.Size(), mediaType) if err != nil { return nil, nil, err } asset := new(ReleaseAsset) resp, err := s.client.Do(req, asset) if err != nil { return nil, resp, err } return asset, resp, err }
// TypeByExtension returns the MIME type associated with the file extension ext. // The extension ext should begin with a leading dot, as in ".html". // When ext has no associated type, TypeByExtension returns "". // // Extensions are looked up first case-sensitively, then case-insensitively. // // The built-in table is small but on unix it is augmented by the local // system's mime.types file(s) if available under one or more of these // names: // // /etc/mime.types // /etc/apache2/mime.types // /etc/apache/mime.types // // On Windows, MIME types are extracted from the registry. // // Text types have the charset parameter set to "utf-8" by default. func TypeByExtension(fullfilename string) (t string) { ext := filepath.Ext(fullfilename) //these should be found by the windows(registry) and unix(apache) but on windows some machines have problems on this part. if t = mime.TypeByExtension(ext); t == "" { // no use of map here because we will have to lock/unlock it, by hand is better, no problem: if ext == ".json" { t = "application/json" } else if ext == ".zip" { t = "application/zip" } else if ext == ".3gp" { t = "video/3gpp" } else if ext == ".7z" { t = "application/x-7z-compressed" } else if ext == ".ace" { t = "application/x-ace-compressed" } else if ext == ".aac" { t = "audio/x-aac" } else if ext == ".ico" { // for any case t = "image/x-icon" } else { t = ContentBINARY } } return }
func (statics *AssestStruct) FileHandlerFunc(name string) http.HandlerFunc { if strings.Contains(name, "private") { return http.NotFound } static, err := statics.GetAssestFile(name) return func(w http.ResponseWriter, r *http.Request) { if err != nil { http.NotFound(w, r) return } modtime := time.Unix(static.Mtime, 0) modifiedSince := r.Header.Get("If-Modified-Since") if modifiedSince != "" { t, err := time.Parse(http.TimeFormat, modifiedSince) if err == nil && modtime.Before(t.Add(1*time.Second)) { w.Header().Del("Content-Type") w.Header().Del("Content-Length") w.Header().Set("Last-Modified", modtime.UTC().Format(http.TimeFormat)) w.WriteHeader(http.StatusNotModified) return } } mimeType := mime.TypeByExtension(filepath.Ext(static.Name)) if mimeType != "" { w.Header().Set("Content-Type", mimeType) } w.Header().Set("Last-Modified", modtime.UTC().Format(http.TimeFormat)) w.Write([]byte(static.Content)) } }
// Guess image mime types from gif/jpeg/png/webp func guessImageMimeTypes(r io.Reader) string { format, err := guessImageFormat(r) if format == "" || err != nil { return "" } return mime.TypeByExtension("." + format) }
func GetInfoForBytes(filename string, data []byte) (*FileInfo, *AppError) { size := len(data) var mimeType string extension := filepath.Ext(filename) isImage := IsFileExtImage(extension) if isImage { mimeType = GetImageMimeType(extension) } else { mimeType = mime.TypeByExtension(extension) } hasPreviewImage := isImage if mimeType == "image/gif" { // just show the gif itself instead of a preview image for animated gifs if gifImage, err := gif.DecodeAll(bytes.NewReader(data)); err != nil { return nil, NewLocAppError("GetInfoForBytes", "model.file_info.get.gif.app_error", nil, "filename="+filename) } else { hasPreviewImage = len(gifImage.Image) == 1 } } return &FileInfo{ Filename: filename, Size: size, Extension: extension[1:], MimeType: mimeType, HasPreviewImage: hasPreviewImage, }, nil }
func (s *staticDB) Put(file *os.File, size int) error { s.lock.Lock() defer s.lock.Unlock() if _, ok := s.assets[file.Name()]; ok { return fmt.Errorf("file already known, %q", file.Name()) } buf := bytes.NewBuffer(nil) _, err := io.Copy(buf, file) if err != nil { return err } data := buf.Bytes() mimetype := mime.TypeByExtension(filepath.Ext(file.Name())) if mimetype == "" { log.Printf("[INFO] Couldn't detect mimetype from exntension, sniffing content: %q", file.Name()) mimetype = http.DetectContentType(data) } log.Printf("[INFO] Mimetype of %q: %q", file.Name(), mimetype) h := md5.New() _, _ = h.Write(data) s.assets[file.Name()] = &asset{ md5hex: hex.EncodeToString(h.Sum(nil)), content: data, mimetype: mimetype, } return nil }
func (s embeddedStatic) mimeTypeForFile(file string) string { // We use a built in table of the common types since the system // TypeByExtension might be unreliable. But if we don't know, we delegate // to the system. ext := filepath.Ext(file) switch ext { case ".htm", ".html": return "text/html" case ".css": return "text/css" case ".js": return "application/javascript" case ".json": return "application/json" case ".png": return "image/png" case ".ttf": return "application/x-font-ttf" case ".woff": return "application/x-font-woff" case ".svg": return "image/svg+xml" default: return mime.TypeByExtension(ext) } }
// @router /test/file/download [get] func (c *TestController) Download() { filename := c.GetString("name") if filename == "" { http.Error(c.Ctx.ResponseWriter, "Not Found", 404) return } filename = fileDir + filename _, err := os.Stat(filename) if os.IsNotExist(err) { http.Error(c.Ctx.ResponseWriter, "Not Found", 404) return } ctype := mime.TypeByExtension(filepath.Ext(filename)) if ctype == "" { ctype = "application/oct-stream" } en := context.ParseEncoding(c.Ctx.Request) if en != "" { c.Ctx.ResponseWriter.Header().Set("Content-Encoding", en) } c.Ctx.ResponseWriter.Header().Set("Content-Type", ctype) f, err := os.Open(filename) context.WriteFile(en, c.Ctx.ResponseWriter, f) }