2016-07-11 02:32:59 +02:00
|
|
|
/*
|
2019-04-09 20:39:42 +02:00
|
|
|
* MinIO Cloud Storage, (C) 2016, 2017, 2018 MinIO, Inc.
|
2016-07-11 02:32:59 +02:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2016-08-19 01:23:42 +02:00
|
|
|
package cmd
|
2016-07-11 02:32:59 +02:00
|
|
|
|
|
|
|
import (
|
2018-03-14 20:01:47 +01:00
|
|
|
"context"
|
2020-05-21 23:12:52 +02:00
|
|
|
"fmt"
|
2016-07-11 02:32:59 +02:00
|
|
|
"net/http"
|
2019-04-01 21:19:52 +02:00
|
|
|
"regexp"
|
2020-06-13 05:04:01 +02:00
|
|
|
"strconv"
|
2016-07-11 02:32:59 +02:00
|
|
|
"time"
|
2018-03-15 21:03:41 +01:00
|
|
|
|
2019-03-06 21:38:41 +01:00
|
|
|
"github.com/minio/minio/cmd/crypto"
|
2019-07-03 07:34:32 +02:00
|
|
|
xhttp "github.com/minio/minio/cmd/http"
|
2020-06-13 05:04:01 +02:00
|
|
|
"github.com/minio/minio/pkg/bucket/lifecycle"
|
2018-03-15 21:03:41 +01:00
|
|
|
"github.com/minio/minio/pkg/event"
|
2018-07-02 23:40:18 +02:00
|
|
|
"github.com/minio/minio/pkg/handlers"
|
2016-07-11 02:32:59 +02:00
|
|
|
)
|
|
|
|
|
2019-04-01 21:19:52 +02:00
|
|
|
var (
|
|
|
|
etagRegex = regexp.MustCompile("\"*?([^\"]*?)\"*?$")
|
|
|
|
)
|
|
|
|
|
2017-01-31 18:38:34 +01:00
|
|
|
// Validates the preconditions for CopyObjectPart, returns true if CopyObjectPart
|
|
|
|
// operation should not proceed. Preconditions supported are:
|
|
|
|
// x-amz-copy-source-if-modified-since
|
|
|
|
// x-amz-copy-source-if-unmodified-since
|
|
|
|
// x-amz-copy-source-if-match
|
|
|
|
// x-amz-copy-source-if-none-match
|
2019-03-06 21:38:41 +01:00
|
|
|
func checkCopyObjectPartPreconditions(ctx context.Context, w http.ResponseWriter, r *http.Request, objInfo ObjectInfo, encETag string) bool {
|
|
|
|
return checkCopyObjectPreconditions(ctx, w, r, objInfo, encETag)
|
2017-01-31 18:38:34 +01:00
|
|
|
}
|
|
|
|
|
2016-07-12 04:24:34 +02:00
|
|
|
// Validates the preconditions for CopyObject, returns true if CopyObject operation should not proceed.
|
|
|
|
// Preconditions supported are:
|
|
|
|
// x-amz-copy-source-if-modified-since
|
|
|
|
// x-amz-copy-source-if-unmodified-since
|
|
|
|
// x-amz-copy-source-if-match
|
|
|
|
// x-amz-copy-source-if-none-match
|
2019-03-06 21:38:41 +01:00
|
|
|
func checkCopyObjectPreconditions(ctx context.Context, w http.ResponseWriter, r *http.Request, objInfo ObjectInfo, encETag string) bool {
|
2016-07-12 04:24:34 +02:00
|
|
|
// Return false for methods other than GET and HEAD.
|
2019-07-03 07:34:32 +02:00
|
|
|
if r.Method != http.MethodPut {
|
2016-07-12 04:24:34 +02:00
|
|
|
return false
|
|
|
|
}
|
2019-03-06 21:38:41 +01:00
|
|
|
if encETag == "" {
|
|
|
|
encETag = objInfo.ETag
|
|
|
|
}
|
2016-07-12 04:24:34 +02:00
|
|
|
// If the object doesn't have a modtime (IsZero), or the modtime
|
|
|
|
// is obviously garbage (Unix time == 0), then ignore modtimes
|
|
|
|
// and don't process the If-Modified-Since header.
|
|
|
|
if objInfo.ModTime.IsZero() || objInfo.ModTime.Equal(time.Unix(0, 0)) {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// Headers to be set of object content is not going to be written to the client.
|
|
|
|
writeHeaders := func() {
|
|
|
|
// set common headers
|
|
|
|
setCommonHeaders(w)
|
|
|
|
|
|
|
|
// set object-related metadata headers
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header().Set(xhttp.LastModified, objInfo.ModTime.UTC().Format(http.TimeFormat))
|
2016-07-12 04:24:34 +02:00
|
|
|
|
2017-05-14 21:05:51 +02:00
|
|
|
if objInfo.ETag != "" {
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header()[xhttp.ETag] = []string{"\"" + objInfo.ETag + "\""}
|
2016-07-12 04:24:34 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// x-amz-copy-source-if-modified-since: Return the object only if it has been modified
|
|
|
|
// since the specified time otherwise return 412 (precondition failed).
|
2019-07-03 07:34:32 +02:00
|
|
|
ifModifiedSinceHeader := r.Header.Get(xhttp.AmzCopySourceIfModifiedSince)
|
2016-07-12 04:24:34 +02:00
|
|
|
if ifModifiedSinceHeader != "" {
|
2017-04-12 21:34:57 +02:00
|
|
|
if givenTime, err := time.Parse(http.TimeFormat, ifModifiedSinceHeader); err == nil {
|
|
|
|
if !ifModifiedSince(objInfo.ModTime, givenTime) {
|
|
|
|
// If the object is not modified since the specified time.
|
|
|
|
writeHeaders()
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrPreconditionFailed), r.URL, guessIsBrowserReq(r))
|
2017-04-12 21:34:57 +02:00
|
|
|
return true
|
|
|
|
}
|
2016-07-12 04:24:34 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// x-amz-copy-source-if-unmodified-since : Return the object only if it has not been
|
|
|
|
// modified since the specified time, otherwise return a 412 (precondition failed).
|
2019-07-03 07:34:32 +02:00
|
|
|
ifUnmodifiedSinceHeader := r.Header.Get(xhttp.AmzCopySourceIfUnmodifiedSince)
|
2016-07-12 04:24:34 +02:00
|
|
|
if ifUnmodifiedSinceHeader != "" {
|
2017-04-12 21:34:57 +02:00
|
|
|
if givenTime, err := time.Parse(http.TimeFormat, ifUnmodifiedSinceHeader); err == nil {
|
|
|
|
if ifModifiedSince(objInfo.ModTime, givenTime) {
|
|
|
|
// If the object is modified since the specified time.
|
|
|
|
writeHeaders()
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrPreconditionFailed), r.URL, guessIsBrowserReq(r))
|
2017-04-12 21:34:57 +02:00
|
|
|
return true
|
|
|
|
}
|
2016-07-12 04:24:34 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-25 20:17:31 +01:00
|
|
|
shouldDecryptEtag := crypto.SSECopy.IsRequested(r.Header) && !crypto.IsMultiPart(objInfo.UserDefined)
|
|
|
|
|
2016-07-12 04:24:34 +02:00
|
|
|
// x-amz-copy-source-if-match : Return the object only if its entity tag (ETag) is the
|
|
|
|
// same as the one specified; otherwise return a 412 (precondition failed).
|
2019-07-03 07:34:32 +02:00
|
|
|
ifMatchETagHeader := r.Header.Get(xhttp.AmzCopySourceIfMatch)
|
2016-07-12 04:24:34 +02:00
|
|
|
if ifMatchETagHeader != "" {
|
2019-03-06 21:38:41 +01:00
|
|
|
etag := objInfo.ETag
|
2019-03-25 20:17:31 +01:00
|
|
|
if shouldDecryptEtag {
|
2019-03-06 21:38:41 +01:00
|
|
|
etag = encETag[len(encETag)-32:]
|
|
|
|
}
|
|
|
|
if objInfo.ETag != "" && !isETagEqual(etag, ifMatchETagHeader) {
|
2016-07-12 04:24:34 +02:00
|
|
|
// If the object ETag does not match with the specified ETag.
|
|
|
|
writeHeaders()
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrPreconditionFailed), r.URL, guessIsBrowserReq(r))
|
2016-07-12 04:24:34 +02:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If-None-Match : Return the object only if its entity tag (ETag) is different from the
|
|
|
|
// one specified otherwise, return a 304 (not modified).
|
2019-07-03 07:34:32 +02:00
|
|
|
ifNoneMatchETagHeader := r.Header.Get(xhttp.AmzCopySourceIfNoneMatch)
|
2016-07-12 04:24:34 +02:00
|
|
|
if ifNoneMatchETagHeader != "" {
|
2019-03-06 21:38:41 +01:00
|
|
|
etag := objInfo.ETag
|
2019-03-25 20:17:31 +01:00
|
|
|
if shouldDecryptEtag {
|
2019-03-06 21:38:41 +01:00
|
|
|
etag = encETag[len(encETag)-32:]
|
|
|
|
}
|
|
|
|
if objInfo.ETag != "" && isETagEqual(etag, ifNoneMatchETagHeader) {
|
2016-07-12 04:24:34 +02:00
|
|
|
// If the object ETag matches with the specified ETag.
|
|
|
|
writeHeaders()
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrPreconditionFailed), r.URL, guessIsBrowserReq(r))
|
2016-07-12 04:24:34 +02:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Object content should be written to http.ResponseWriter
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// Validates the preconditions. Returns true if GET/HEAD operation should not proceed.
|
|
|
|
// Preconditions supported are:
|
|
|
|
// If-Modified-Since
|
|
|
|
// If-Unmodified-Since
|
|
|
|
// If-Match
|
|
|
|
// If-None-Match
|
2020-04-21 07:01:59 +02:00
|
|
|
func checkPreconditions(ctx context.Context, w http.ResponseWriter, r *http.Request, objInfo ObjectInfo, opts ObjectOptions) bool {
|
2016-07-11 02:32:59 +02:00
|
|
|
// Return false for methods other than GET and HEAD.
|
2019-07-03 07:34:32 +02:00
|
|
|
if r.Method != http.MethodGet && r.Method != http.MethodHead {
|
2016-07-11 02:32:59 +02:00
|
|
|
return false
|
|
|
|
}
|
2016-07-12 04:24:34 +02:00
|
|
|
// If the object doesn't have a modtime (IsZero), or the modtime
|
|
|
|
// is obviously garbage (Unix time == 0), then ignore modtimes
|
|
|
|
// and don't process the If-Modified-Since header.
|
|
|
|
if objInfo.ModTime.IsZero() || objInfo.ModTime.Equal(time.Unix(0, 0)) {
|
|
|
|
return false
|
|
|
|
}
|
2016-07-11 02:32:59 +02:00
|
|
|
|
|
|
|
// Headers to be set of object content is not going to be written to the client.
|
|
|
|
writeHeaders := func() {
|
|
|
|
// set common headers
|
|
|
|
setCommonHeaders(w)
|
|
|
|
|
|
|
|
// set object-related metadata headers
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header().Set(xhttp.LastModified, objInfo.ModTime.UTC().Format(http.TimeFormat))
|
2016-07-11 02:32:59 +02:00
|
|
|
|
2017-05-14 21:05:51 +02:00
|
|
|
if objInfo.ETag != "" {
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header()[xhttp.ETag] = []string{"\"" + objInfo.ETag + "\""}
|
2016-07-11 02:32:59 +02:00
|
|
|
}
|
|
|
|
}
|
2020-04-21 07:01:59 +02:00
|
|
|
|
|
|
|
// Check if the part number is correct.
|
2020-06-10 18:22:15 +02:00
|
|
|
if opts.PartNumber > 1 && opts.PartNumber > len(objInfo.Parts) {
|
2020-04-21 07:01:59 +02:00
|
|
|
writeHeaders()
|
2020-06-10 18:22:15 +02:00
|
|
|
w.WriteHeader(http.StatusRequestedRangeNotSatisfiable)
|
2020-04-21 07:01:59 +02:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2016-07-11 02:32:59 +02:00
|
|
|
// If-Modified-Since : Return the object only if it has been modified since the specified time,
|
|
|
|
// otherwise return a 304 (not modified).
|
2019-07-03 07:34:32 +02:00
|
|
|
ifModifiedSinceHeader := r.Header.Get(xhttp.IfModifiedSince)
|
2016-07-11 02:32:59 +02:00
|
|
|
if ifModifiedSinceHeader != "" {
|
2017-04-12 21:34:57 +02:00
|
|
|
if givenTime, err := time.Parse(http.TimeFormat, ifModifiedSinceHeader); err == nil {
|
|
|
|
if !ifModifiedSince(objInfo.ModTime, givenTime) {
|
|
|
|
// If the object is not modified since the specified time.
|
|
|
|
writeHeaders()
|
|
|
|
w.WriteHeader(http.StatusNotModified)
|
|
|
|
return true
|
|
|
|
}
|
2016-07-11 02:32:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If-Unmodified-Since : Return the object only if it has not been modified since the specified
|
|
|
|
// time, otherwise return a 412 (precondition failed).
|
2019-07-03 07:34:32 +02:00
|
|
|
ifUnmodifiedSinceHeader := r.Header.Get(xhttp.IfUnmodifiedSince)
|
2016-07-11 02:32:59 +02:00
|
|
|
if ifUnmodifiedSinceHeader != "" {
|
2017-04-12 21:34:57 +02:00
|
|
|
if givenTime, err := time.Parse(http.TimeFormat, ifUnmodifiedSinceHeader); err == nil {
|
|
|
|
if ifModifiedSince(objInfo.ModTime, givenTime) {
|
|
|
|
// If the object is modified since the specified time.
|
|
|
|
writeHeaders()
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrPreconditionFailed), r.URL, guessIsBrowserReq(r))
|
2017-04-12 21:34:57 +02:00
|
|
|
return true
|
|
|
|
}
|
2016-07-11 02:32:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If-Match : Return the object only if its entity tag (ETag) is the same as the one specified;
|
|
|
|
// otherwise return a 412 (precondition failed).
|
2019-07-03 07:34:32 +02:00
|
|
|
ifMatchETagHeader := r.Header.Get(xhttp.IfMatch)
|
2016-07-11 02:32:59 +02:00
|
|
|
if ifMatchETagHeader != "" {
|
2017-05-14 21:05:51 +02:00
|
|
|
if !isETagEqual(objInfo.ETag, ifMatchETagHeader) {
|
2016-07-11 02:32:59 +02:00
|
|
|
// If the object ETag does not match with the specified ETag.
|
|
|
|
writeHeaders()
|
2019-02-14 01:07:21 +01:00
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrPreconditionFailed), r.URL, guessIsBrowserReq(r))
|
2016-07-11 02:32:59 +02:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If-None-Match : Return the object only if its entity tag (ETag) is different from the
|
|
|
|
// one specified otherwise, return a 304 (not modified).
|
2019-07-03 07:34:32 +02:00
|
|
|
ifNoneMatchETagHeader := r.Header.Get(xhttp.IfNoneMatch)
|
2016-07-11 02:32:59 +02:00
|
|
|
if ifNoneMatchETagHeader != "" {
|
2017-05-14 21:05:51 +02:00
|
|
|
if isETagEqual(objInfo.ETag, ifNoneMatchETagHeader) {
|
2016-07-11 02:32:59 +02:00
|
|
|
// If the object ETag matches with the specified ETag.
|
|
|
|
writeHeaders()
|
|
|
|
w.WriteHeader(http.StatusNotModified)
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Object content should be written to http.ResponseWriter
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// returns true if object was modified after givenTime.
|
2017-04-12 21:34:57 +02:00
|
|
|
func ifModifiedSince(objTime time.Time, givenTime time.Time) bool {
|
2016-07-11 02:32:59 +02:00
|
|
|
// The Date-Modified header truncates sub-second precision, so
|
|
|
|
// use mtime < t+1s instead of mtime <= t to check for unmodified.
|
2019-02-13 13:59:36 +01:00
|
|
|
return objTime.After(givenTime.Add(1 * time.Second))
|
2016-07-11 02:32:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// canonicalizeETag returns ETag with leading and trailing double-quotes removed,
|
|
|
|
// if any present
|
|
|
|
func canonicalizeETag(etag string) string {
|
2019-04-01 21:19:52 +02:00
|
|
|
return etagRegex.ReplaceAllString(etag, "$1")
|
2016-07-11 02:32:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// isETagEqual return true if the canonical representations of two ETag strings
|
|
|
|
// are equal, false otherwise
|
|
|
|
func isETagEqual(left, right string) bool {
|
|
|
|
return canonicalizeETag(left) == canonicalizeETag(right)
|
|
|
|
}
|
2017-04-27 08:27:48 +02:00
|
|
|
|
2020-06-13 05:04:01 +02:00
|
|
|
// setPutObjHeaders sets all the necessary headers returned back
|
|
|
|
// upon a success Put/Copy/CompleteMultipart/Delete requests
|
|
|
|
// to activate delete only headers set delete as true
|
|
|
|
func setPutObjHeaders(w http.ResponseWriter, objInfo ObjectInfo, delete bool) {
|
|
|
|
// We must not use the http.Header().Set method here because some (broken)
|
|
|
|
// clients expect the ETag header key to be literally "ETag" - not "Etag" (case-sensitive).
|
|
|
|
// Therefore, we have to set the ETag directly as map entry.
|
|
|
|
if objInfo.ETag != "" && !delete {
|
|
|
|
w.Header()[xhttp.ETag] = []string{`"` + objInfo.ETag + `"`}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the relevant version ID as part of the response header.
|
|
|
|
if objInfo.VersionID != "" {
|
|
|
|
w.Header()[xhttp.AmzVersionID] = []string{objInfo.VersionID}
|
|
|
|
// If version is a deleted marker, set this header as well
|
|
|
|
if objInfo.DeleteMarker && delete { // only returned during delete object
|
|
|
|
w.Header()[xhttp.AmzDeleteMarker] = []string{strconv.FormatBool(objInfo.DeleteMarker)}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if lc, err := globalLifecycleSys.Get(objInfo.Bucket); err == nil && !delete {
|
|
|
|
ruleID, expiryTime := lc.PredictExpiryTime(lifecycle.ObjectOpts{
|
|
|
|
Name: objInfo.Name,
|
|
|
|
UserTags: objInfo.UserTags,
|
|
|
|
VersionID: objInfo.VersionID,
|
|
|
|
ModTime: objInfo.ModTime,
|
|
|
|
IsLatest: objInfo.IsLatest,
|
|
|
|
DeleteMarker: objInfo.DeleteMarker,
|
|
|
|
})
|
2020-05-21 23:12:52 +02:00
|
|
|
if !expiryTime.IsZero() {
|
|
|
|
w.Header()[xhttp.AmzExpiration] = []string{
|
|
|
|
fmt.Sprintf(`expiry-date="%s", rule-id="%s"`, expiryTime.Format(http.TimeFormat), ruleID),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-27 08:27:48 +02:00
|
|
|
// deleteObject is a convenient wrapper to delete an object, this
|
|
|
|
// is a common function to be called from object handlers and
|
|
|
|
// web handlers.
|
2020-06-13 05:04:01 +02:00
|
|
|
func deleteObject(ctx context.Context, obj ObjectLayer, cache CacheObjectLayer, bucket, object string, r *http.Request, opts ObjectOptions) (objInfo ObjectInfo, err error) {
|
2018-03-28 23:14:06 +02:00
|
|
|
deleteObject := obj.DeleteObject
|
|
|
|
if cache != nil {
|
|
|
|
deleteObject = cache.DeleteObject
|
|
|
|
}
|
2017-04-27 08:27:48 +02:00
|
|
|
// Proceed to delete the object.
|
2020-06-13 05:04:01 +02:00
|
|
|
if objInfo, err = deleteObject(ctx, bucket, object, opts); err != nil {
|
|
|
|
return objInfo, err
|
2017-04-27 08:27:48 +02:00
|
|
|
}
|
|
|
|
|
2020-06-13 05:04:01 +02:00
|
|
|
// Requesting only a delete marker which was successfully attempted.
|
|
|
|
if objInfo.DeleteMarker {
|
|
|
|
// Notify object deleted marker event.
|
|
|
|
sendEvent(eventArgs{
|
|
|
|
EventName: event.ObjectRemovedDeleteMarkerCreated,
|
|
|
|
BucketName: bucket,
|
|
|
|
Object: objInfo,
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
UserAgent: r.UserAgent(),
|
|
|
|
Host: handlers.GetSourceIP(r),
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
// Notify object deleted event.
|
|
|
|
sendEvent(eventArgs{
|
|
|
|
EventName: event.ObjectRemovedDelete,
|
|
|
|
BucketName: bucket,
|
|
|
|
Object: objInfo,
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
UserAgent: r.UserAgent(),
|
|
|
|
Host: handlers.GetSourceIP(r),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
return objInfo, nil
|
2017-04-27 08:27:48 +02:00
|
|
|
}
|