2015-02-24 01:46:48 +01:00
|
|
|
|
/*
|
2020-04-21 07:01:59 +02:00
|
|
|
|
* MinIO Cloud Storage, (C) 2015-2020 MinIO, Inc.
|
2015-02-24 01:46:48 +01: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,
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 10:34:20 +02:00
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
2015-02-24 01:46:48 +01:00
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
|
* limitations under the License.
|
|
|
|
|
*/
|
|
|
|
|
|
2016-08-19 01:23:42 +02:00
|
|
|
|
package cmd
|
2015-02-16 02:03:27 +01:00
|
|
|
|
|
|
|
|
|
import (
|
2019-12-12 19:01:15 +01:00
|
|
|
|
"bufio"
|
2018-04-06 00:04:40 +02:00
|
|
|
|
"context"
|
2016-03-13 01:08:15 +01:00
|
|
|
|
"encoding/hex"
|
fs: Break fs package to top-level and introduce ObjectAPI interface.
ObjectAPI interface brings in changes needed for XL ObjectAPI layer.
The new interface for any ObjectAPI layer is as below
```
// ObjectAPI interface.
type ObjectAPI interface {
// Bucket resource API.
DeleteBucket(bucket string) *probe.Error
ListBuckets() ([]BucketInfo, *probe.Error)
MakeBucket(bucket string) *probe.Error
GetBucketInfo(bucket string) (BucketInfo, *probe.Error)
// Bucket query API.
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsResult, *probe.Error)
ListMultipartUploads(bucket string, resources BucketMultipartResourcesMetadata) (BucketMultipartResourcesMetadata, *probe.Error)
// Object resource API.
GetObject(bucket, object string, startOffset int64) (io.ReadCloser, *probe.Error)
GetObjectInfo(bucket, object string) (ObjectInfo, *probe.Error)
PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string) (ObjectInfo, *probe.Error)
DeleteObject(bucket, object string) *probe.Error
// Object query API.
NewMultipartUpload(bucket, object string) (string, *probe.Error)
PutObjectPart(bucket, object, uploadID string, partID int, size int64, data io.Reader, md5Hex string) (string, *probe.Error)
ListObjectParts(bucket, object string, resources ObjectResourcesMetadata) (ObjectResourcesMetadata, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []CompletePart) (ObjectInfo, *probe.Error)
AbortMultipartUpload(bucket, object, uploadID string) *probe.Error
}
```
2016-03-31 01:15:28 +02:00
|
|
|
|
"encoding/xml"
|
2017-11-08 00:18:59 +01:00
|
|
|
|
"io"
|
2015-02-16 02:03:27 +01:00
|
|
|
|
"net/http"
|
2016-02-07 12:37:54 +01:00
|
|
|
|
"net/url"
|
fs: Break fs package to top-level and introduce ObjectAPI interface.
ObjectAPI interface brings in changes needed for XL ObjectAPI layer.
The new interface for any ObjectAPI layer is as below
```
// ObjectAPI interface.
type ObjectAPI interface {
// Bucket resource API.
DeleteBucket(bucket string) *probe.Error
ListBuckets() ([]BucketInfo, *probe.Error)
MakeBucket(bucket string) *probe.Error
GetBucketInfo(bucket string) (BucketInfo, *probe.Error)
// Bucket query API.
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsResult, *probe.Error)
ListMultipartUploads(bucket string, resources BucketMultipartResourcesMetadata) (BucketMultipartResourcesMetadata, *probe.Error)
// Object resource API.
GetObject(bucket, object string, startOffset int64) (io.ReadCloser, *probe.Error)
GetObjectInfo(bucket, object string) (ObjectInfo, *probe.Error)
PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string) (ObjectInfo, *probe.Error)
DeleteObject(bucket, object string) *probe.Error
// Object query API.
NewMultipartUpload(bucket, object string) (string, *probe.Error)
PutObjectPart(bucket, object, uploadID string, partID int, size int64, data io.Reader, md5Hex string) (string, *probe.Error)
ListObjectParts(bucket, object string, resources ObjectResourcesMetadata) (ObjectResourcesMetadata, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []CompletePart) (ObjectInfo, *probe.Error)
AbortMultipartUpload(bucket, object, uploadID string) *probe.Error
}
```
2016-03-31 01:15:28 +02:00
|
|
|
|
"sort"
|
2015-05-04 08:16:10 +02:00
|
|
|
|
"strconv"
|
2018-08-15 12:30:19 +02:00
|
|
|
|
"strings"
|
2020-04-17 20:20:56 +02:00
|
|
|
|
"sync"
|
2015-02-16 02:03:27 +01:00
|
|
|
|
|
2019-02-06 05:58:09 +01:00
|
|
|
|
"time"
|
|
|
|
|
|
2018-04-22 04:23:54 +02:00
|
|
|
|
"github.com/gorilla/mux"
|
2019-05-30 01:35:12 +02:00
|
|
|
|
miniogo "github.com/minio/minio-go/v6"
|
|
|
|
|
"github.com/minio/minio-go/v6/pkg/encrypt"
|
2019-11-26 01:33:34 +01:00
|
|
|
|
"github.com/minio/minio/cmd/config/etcd/dns"
|
2019-10-07 07:50:24 +02:00
|
|
|
|
"github.com/minio/minio/cmd/config/storageclass"
|
2018-08-17 21:52:14 +02:00
|
|
|
|
"github.com/minio/minio/cmd/crypto"
|
2019-07-03 07:34:32 +02:00
|
|
|
|
xhttp "github.com/minio/minio/cmd/http"
|
2018-04-06 00:04:40 +02:00
|
|
|
|
"github.com/minio/minio/cmd/logger"
|
2020-01-27 23:12:34 +01:00
|
|
|
|
objectlock "github.com/minio/minio/pkg/bucket/object/lock"
|
|
|
|
|
"github.com/minio/minio/pkg/bucket/object/tagging"
|
|
|
|
|
"github.com/minio/minio/pkg/bucket/policy"
|
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"
|
2017-10-22 07:30:34 +02:00
|
|
|
|
"github.com/minio/minio/pkg/hash"
|
2019-11-20 22:18:09 +01:00
|
|
|
|
iampolicy "github.com/minio/minio/pkg/iam/policy"
|
2017-11-08 00:18:59 +01:00
|
|
|
|
"github.com/minio/minio/pkg/ioutil"
|
2018-08-15 12:30:19 +02:00
|
|
|
|
"github.com/minio/minio/pkg/s3select"
|
2018-03-01 20:37:57 +01:00
|
|
|
|
"github.com/minio/sio"
|
2015-05-10 04:39:00 +02:00
|
|
|
|
)
|
|
|
|
|
|
2017-08-08 20:04:04 +02:00
|
|
|
|
// supportedHeadGetReqParams - supported request parameters for GET and HEAD presigned request.
|
|
|
|
|
var supportedHeadGetReqParams = map[string]string{
|
2019-07-03 07:34:32 +02:00
|
|
|
|
"response-expires": xhttp.Expires,
|
|
|
|
|
"response-content-type": xhttp.ContentType,
|
|
|
|
|
"response-cache-control": xhttp.CacheControl,
|
|
|
|
|
"response-content-encoding": xhttp.ContentEncoding,
|
|
|
|
|
"response-content-language": xhttp.ContentLanguage,
|
|
|
|
|
"response-content-disposition": xhttp.ContentDisposition,
|
2016-02-07 12:37:54 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-09-28 05:36:17 +02:00
|
|
|
|
const (
|
|
|
|
|
compressionAlgorithmV1 = "golang/snappy/LZ77"
|
2019-09-26 08:08:24 +02:00
|
|
|
|
compressionAlgorithmV2 = "klauspost/compress/s2"
|
2019-12-12 19:01:15 +01:00
|
|
|
|
|
|
|
|
|
// When an upload exceeds encryptBufferThreshold ...
|
|
|
|
|
encryptBufferThreshold = 1 << 20
|
|
|
|
|
// add an input buffer of this size.
|
|
|
|
|
encryptBufferSize = 1 << 20
|
2018-09-28 05:36:17 +02:00
|
|
|
|
)
|
|
|
|
|
|
2017-08-08 20:04:04 +02:00
|
|
|
|
// setHeadGetRespHeaders - set any requested parameters as response headers.
|
|
|
|
|
func setHeadGetRespHeaders(w http.ResponseWriter, reqParams url.Values) {
|
2016-02-07 12:37:54 +01:00
|
|
|
|
for k, v := range reqParams {
|
2020-04-21 07:01:59 +02:00
|
|
|
|
if header, ok := supportedHeadGetReqParams[strings.ToLower(k)]; ok {
|
2016-02-07 12:37:54 +01:00
|
|
|
|
w.Header()[header] = v
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-08-15 12:30:19 +02:00
|
|
|
|
// SelectObjectContentHandler - GET Object?select
|
|
|
|
|
// ----------
|
|
|
|
|
// This implementation of the GET operation retrieves object content based
|
|
|
|
|
// on an SQL expression. In the request, along with the sql expression, you must
|
|
|
|
|
// also specify a data serialization format (JSON, CSV) of the object.
|
|
|
|
|
func (api objectAPIHandlers) SelectObjectContentHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
ctx := newContext(r, w, "SelectObject")
|
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "SelectObject", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2018-08-15 12:30:19 +02:00
|
|
|
|
// Fetch object stat info.
|
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2018-08-15 12:30:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-10-10 00:04:53 +02:00
|
|
|
|
if crypto.S3KMS.IsRequested(r.Header) { // SSE-KMS is not supported
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
2018-10-10 00:04:53 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if !api.EncryptionEnabled() && crypto.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrBadRequest), r.URL, guessIsBrowserReq(r))
|
2018-12-15 06:39:59 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-09-21 04:22:09 +02:00
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2018-09-21 04:22:09 +02:00
|
|
|
|
|
2019-01-05 23:16:43 +01:00
|
|
|
|
// get gateway encryption options
|
2019-02-09 06:31:06 +01:00
|
|
|
|
opts, err := getOpts(ctx, r, bucket, object)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-01-09 01:53:04 +01:00
|
|
|
|
|
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-21 04:22:09 +02:00
|
|
|
|
// Check for auth type to return S3 compatible error.
|
|
|
|
|
// type to return the correct error (NoSuchKey vs AccessDenied)
|
2018-08-15 12:30:19 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.GetObjectAction, bucket, object); s3Error != ErrNone {
|
|
|
|
|
if getRequestAuthType(r) == authTypeAnonymous {
|
|
|
|
|
// As per "Permission" section in
|
2018-09-21 04:22:09 +02:00
|
|
|
|
// https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html
|
|
|
|
|
// If the object you request does not exist,
|
|
|
|
|
// the error Amazon S3 returns depends on
|
|
|
|
|
// whether you also have the s3:ListBucket
|
|
|
|
|
// permission.
|
|
|
|
|
// * If you have the s3:ListBucket permission
|
|
|
|
|
// on the bucket, Amazon S3 will return an
|
|
|
|
|
// HTTP status code 404 ("no such key")
|
|
|
|
|
// error.
|
|
|
|
|
// * if you don’t have the s3:ListBucket
|
|
|
|
|
// permission, Amazon S3 will return an HTTP
|
|
|
|
|
// status code 403 ("access denied") error.`
|
2018-08-15 12:30:19 +02:00
|
|
|
|
if globalPolicySys.IsAllowed(policy.Args{
|
|
|
|
|
Action: policy.ListBucketAction,
|
|
|
|
|
BucketName: bucket,
|
2019-10-16 17:59:59 +02:00
|
|
|
|
ConditionValues: getConditionValues(r, "", "", nil),
|
2018-08-15 12:30:19 +02:00
|
|
|
|
IsOwner: false,
|
|
|
|
|
}) {
|
2019-01-05 23:16:43 +01:00
|
|
|
|
_, err = getObjectInfo(ctx, bucket, object, opts)
|
2019-02-12 10:25:52 +01:00
|
|
|
|
if toAPIError(ctx, err).Code == "NoSuchKey" {
|
2018-08-15 12:30:19 +02:00
|
|
|
|
s3Error = ErrNoSuchKey
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2018-08-15 12:30:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-09-21 04:22:09 +02:00
|
|
|
|
|
|
|
|
|
// Get request range.
|
|
|
|
|
rangeHeader := r.Header.Get("Range")
|
|
|
|
|
if rangeHeader != "" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrUnsupportedRangeHeader), r.URL, guessIsBrowserReq(r))
|
2018-09-21 04:22:09 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-08-15 12:30:19 +02:00
|
|
|
|
if r.ContentLength <= 0 {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrEmptyRequestBody), r.URL, guessIsBrowserReq(r))
|
2018-08-15 12:30:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-01-05 23:16:43 +01:00
|
|
|
|
|
2018-09-21 04:22:09 +02:00
|
|
|
|
getObjectNInfo := objectAPI.GetObjectNInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectNInfo = api.CacheAPI().GetObjectNInfo
|
|
|
|
|
}
|
2019-01-09 01:53:04 +01:00
|
|
|
|
getObject := func(offset, length int64) (rc io.ReadCloser, err error) {
|
|
|
|
|
isSuffixLength := false
|
|
|
|
|
if offset < 0 {
|
|
|
|
|
isSuffixLength = true
|
2018-08-15 12:30:19 +02:00
|
|
|
|
}
|
2019-01-09 01:53:04 +01:00
|
|
|
|
rs := &HTTPRangeSpec{
|
|
|
|
|
IsSuffixLength: isSuffixLength,
|
|
|
|
|
Start: offset,
|
2019-01-16 17:22:04 +01:00
|
|
|
|
End: offset + length,
|
2018-08-15 12:30:19 +02:00
|
|
|
|
}
|
|
|
|
|
|
2019-01-09 01:53:04 +01:00
|
|
|
|
return getObjectNInfo(ctx, bucket, object, rs, r.Header, readLock, ObjectOptions{})
|
2018-08-15 12:30:19 +02:00
|
|
|
|
}
|
|
|
|
|
|
2019-01-29 02:59:48 +01:00
|
|
|
|
objInfo, err := getObjectInfo(ctx, bucket, object, opts)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2019-01-29 02:59:48 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-24 22:51:48 +02:00
|
|
|
|
|
|
|
|
|
s3Select, err := s3select.NewS3Select(r.Body)
|
|
|
|
|
if err != nil {
|
|
|
|
|
if serr, ok := err.(s3select.SelectError); ok {
|
|
|
|
|
encodedErrorResponse := encodeResponse(APIErrorResponse{
|
|
|
|
|
Code: serr.ErrorCode(),
|
|
|
|
|
Message: serr.ErrorMessage(),
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Key: object,
|
|
|
|
|
Resource: r.URL.Path,
|
|
|
|
|
RequestID: w.Header().Get(xhttp.AmzRequestID),
|
|
|
|
|
HostID: globalDeploymentID,
|
|
|
|
|
})
|
|
|
|
|
writeResponse(w, serr.HTTPStatusCode(), encodedErrorResponse, mimeXML)
|
|
|
|
|
} else {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
}
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
getRetPerms := checkRequestAuthType(ctx, r, policy.GetObjectRetentionAction, bucket, object)
|
2020-01-17 00:41:56 +01:00
|
|
|
|
legalHoldPerms := checkRequestAuthType(ctx, r, policy.GetObjectLegalHoldAction, bucket, object)
|
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
// filter object lock metadata if permission does not permit
|
2020-01-17 00:41:56 +01:00
|
|
|
|
objInfo.UserDefined = objectlock.FilterObjectLockMetadata(objInfo.UserDefined, getRetPerms != ErrNone, legalHoldPerms != ErrNone)
|
2019-01-29 02:59:48 +01:00
|
|
|
|
|
2019-01-09 01:53:04 +01:00
|
|
|
|
if err = s3Select.Open(getObject); err != nil {
|
|
|
|
|
if serr, ok := err.(s3select.SelectError); ok {
|
2019-02-13 08:48:11 +01:00
|
|
|
|
encodedErrorResponse := encodeResponse(APIErrorResponse{
|
|
|
|
|
Code: serr.ErrorCode(),
|
|
|
|
|
Message: serr.ErrorMessage(),
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Key: object,
|
|
|
|
|
Resource: r.URL.Path,
|
2019-07-03 07:34:32 +02:00
|
|
|
|
RequestID: w.Header().Get(xhttp.AmzRequestID),
|
2019-07-01 21:22:01 +02:00
|
|
|
|
HostID: globalDeploymentID,
|
2019-02-13 08:48:11 +01:00
|
|
|
|
})
|
|
|
|
|
writeResponse(w, serr.HTTPStatusCode(), encodedErrorResponse, mimeXML)
|
2019-01-09 01:53:04 +01:00
|
|
|
|
} else {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-11-15 00:55:10 +01:00
|
|
|
|
}
|
2018-10-22 21:12:22 +02:00
|
|
|
|
return
|
2018-08-15 12:30:19 +02:00
|
|
|
|
}
|
2018-10-22 21:12:22 +02:00
|
|
|
|
|
2019-01-09 01:53:04 +01:00
|
|
|
|
s3Select.Evaluate(w)
|
|
|
|
|
s3Select.Close()
|
|
|
|
|
|
2018-11-03 02:40:08 +01:00
|
|
|
|
// Notify object accessed via a GET request.
|
|
|
|
|
sendEvent(eventArgs{
|
|
|
|
|
EventName: event.ObjectAccessedGet,
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
2019-03-25 19:45:42 +01:00
|
|
|
|
Host: handlers.GetSourceIP(r),
|
2018-11-03 02:40:08 +01:00
|
|
|
|
})
|
2018-08-15 12:30:19 +02:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-01 05:15:48 +02:00
|
|
|
|
// GetObjectHandler - GET Object
|
2015-02-24 01:46:48 +01:00
|
|
|
|
// ----------
|
|
|
|
|
// This implementation of the GET operation retrieves object. To use GET,
|
|
|
|
|
// you must have READ access to the object.
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) GetObjectHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "GetObject")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "GetObject", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-18 06:07:19 +02:00
|
|
|
|
if crypto.S3.IsRequested(r.Header) || crypto.S3KMS.IsRequested(r.Header) { // If SSE-S3 or SSE-KMS present -> AWS fails with undefined error
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrBadRequest), r.URL, guessIsBrowserReq(r))
|
2018-08-18 06:07:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if !api.EncryptionEnabled() && crypto.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrBadRequest), r.URL, guessIsBrowserReq(r))
|
2018-12-15 06:39:59 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-18 06:07:19 +02:00
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-31 22:10:12 +02:00
|
|
|
|
|
2018-12-12 20:43:44 +01:00
|
|
|
|
if vid := r.URL.Query().Get("versionId"); vid != "" && vid != "null" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
2018-12-12 20:43:44 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-05 23:16:43 +01:00
|
|
|
|
// get gateway encryption options
|
2019-02-09 06:31:06 +01:00
|
|
|
|
opts, err := getOpts(ctx, r, bucket, object)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-21 04:22:09 +02:00
|
|
|
|
// Check for auth type to return S3 compatible error.
|
|
|
|
|
// type to return the correct error (NoSuchKey vs AccessDenied)
|
2018-05-02 08:43:27 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.GetObjectAction, bucket, object); s3Error != ErrNone {
|
|
|
|
|
if getRequestAuthType(r) == authTypeAnonymous {
|
2018-09-21 04:22:09 +02:00
|
|
|
|
// As per "Permission" section in
|
|
|
|
|
// https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html
|
|
|
|
|
// If the object you request does not exist,
|
|
|
|
|
// the error Amazon S3 returns depends on
|
|
|
|
|
// whether you also have the s3:ListBucket
|
|
|
|
|
// permission.
|
|
|
|
|
// * If you have the s3:ListBucket permission
|
|
|
|
|
// on the bucket, Amazon S3 will return an
|
|
|
|
|
// HTTP status code 404 ("no such key")
|
|
|
|
|
// error.
|
|
|
|
|
// * if you don’t have the s3:ListBucket
|
|
|
|
|
// permission, Amazon S3 will return an HTTP
|
|
|
|
|
// status code 403 ("access denied") error.`
|
2018-05-02 08:43:27 +02:00
|
|
|
|
if globalPolicySys.IsAllowed(policy.Args{
|
2018-04-25 00:53:30 +02:00
|
|
|
|
Action: policy.ListBucketAction,
|
|
|
|
|
BucketName: bucket,
|
2019-10-16 17:59:59 +02:00
|
|
|
|
ConditionValues: getConditionValues(r, "", "", nil),
|
2018-04-25 00:53:30 +02:00
|
|
|
|
IsOwner: false,
|
|
|
|
|
}) {
|
2018-09-21 04:22:09 +02:00
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
_, err = getObjectInfo(ctx, bucket, object, opts)
|
2019-02-12 10:25:52 +01:00
|
|
|
|
if toAPIError(ctx, err).Code == "NoSuchKey" {
|
2018-05-02 08:43:27 +02:00
|
|
|
|
s3Error = ErrNoSuchKey
|
|
|
|
|
}
|
2018-04-25 00:53:30 +02:00
|
|
|
|
}
|
2015-08-04 01:17:21 +02:00
|
|
|
|
}
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2018-05-02 08:43:27 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-28 22:08:30 +02:00
|
|
|
|
|
2018-09-21 04:22:09 +02:00
|
|
|
|
getObjectNInfo := objectAPI.GetObjectNInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectNInfo = api.CacheAPI().GetObjectNInfo
|
2018-08-28 22:08:30 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Get request range.
|
2018-09-21 04:22:09 +02:00
|
|
|
|
var rs *HTTPRangeSpec
|
2018-08-28 22:08:30 +02:00
|
|
|
|
rangeHeader := r.Header.Get("Range")
|
|
|
|
|
if rangeHeader != "" {
|
2018-09-21 04:22:09 +02:00
|
|
|
|
if rs, err = parseRequestRangeSpec(rangeHeader); err != nil {
|
|
|
|
|
// Handle only errInvalidRange. Ignore other
|
|
|
|
|
// parse error and treat it as regular Get
|
|
|
|
|
// request like Amazon S3.
|
2018-08-28 22:08:30 +02:00
|
|
|
|
if err == errInvalidRange {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidRange), r.URL, guessIsBrowserReq(r))
|
2018-08-28 22:08:30 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-12 03:50:54 +02:00
|
|
|
|
logger.LogIf(ctx, err, logger.Application)
|
2018-08-28 22:08:30 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-27 12:06:45 +02:00
|
|
|
|
gr, err := getObjectNInfo(ctx, bucket, object, rs, r.Header, readLock, opts)
|
2018-09-21 04:22:09 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2016-06-27 03:10:08 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-09-21 04:22:09 +02:00
|
|
|
|
defer gr.Close()
|
|
|
|
|
objInfo := gr.ObjInfo
|
2016-06-27 03:10:08 +02:00
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
// filter object lock metadata if permission does not permit
|
|
|
|
|
getRetPerms := checkRequestAuthType(ctx, r, policy.GetObjectRetentionAction, bucket, object)
|
2020-01-17 00:41:56 +01:00
|
|
|
|
legalHoldPerms := checkRequestAuthType(ctx, r, policy.GetObjectLegalHoldAction, bucket, object)
|
|
|
|
|
|
|
|
|
|
// filter object lock metadata if permission does not permit
|
|
|
|
|
objInfo.UserDefined = objectlock.FilterObjectLockMetadata(objInfo.UserDefined, getRetPerms != ErrNone, legalHoldPerms != ErrNone)
|
2019-11-20 22:18:09 +01:00
|
|
|
|
|
2018-09-21 04:22:09 +02:00
|
|
|
|
if objectAPI.IsEncryptionSupported() {
|
2019-01-05 23:16:43 +01:00
|
|
|
|
objInfo.UserDefined = CleanMinioInternalMetadataKeys(objInfo.UserDefined)
|
2018-11-15 02:36:41 +01:00
|
|
|
|
if _, err = DecryptObjectInfo(&objInfo, r.Header); err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-09-21 04:22:09 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-05-29 00:13:15 +02:00
|
|
|
|
}
|
2017-04-08 10:39:20 +02:00
|
|
|
|
|
2018-09-21 04:22:09 +02:00
|
|
|
|
// Validate pre-conditions if any.
|
2020-04-21 07:01:59 +02:00
|
|
|
|
if checkPreconditions(ctx, w, r, objInfo, opts) {
|
2018-09-21 04:22:09 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-31 22:10:12 +02:00
|
|
|
|
|
2018-09-21 04:22:09 +02:00
|
|
|
|
// Set encryption response headers
|
|
|
|
|
if objectAPI.IsEncryptionSupported() {
|
2018-09-23 19:24:10 +02:00
|
|
|
|
if crypto.IsEncrypted(objInfo.UserDefined) {
|
|
|
|
|
switch {
|
|
|
|
|
case crypto.S3.IsEncrypted(objInfo.UserDefined):
|
|
|
|
|
w.Header().Set(crypto.SSEHeader, crypto.SSEAlgorithmAES256)
|
|
|
|
|
case crypto.SSEC.IsEncrypted(objInfo.UserDefined):
|
|
|
|
|
w.Header().Set(crypto.SSECAlgorithm, r.Header.Get(crypto.SSECAlgorithm))
|
|
|
|
|
w.Header().Set(crypto.SSECKeyMD5, r.Header.Get(crypto.SSECKeyMD5))
|
|
|
|
|
}
|
2016-07-11 02:12:22 +02:00
|
|
|
|
}
|
2017-11-08 00:18:59 +01:00
|
|
|
|
}
|
2016-07-24 07:51:12 +02:00
|
|
|
|
|
2018-11-12 20:07:43 +01:00
|
|
|
|
if err = setObjectHeaders(w, objInfo, rs); err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-09-21 04:22:09 +02:00
|
|
|
|
return
|
2018-08-31 22:10:12 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-09-21 04:22:09 +02:00
|
|
|
|
setHeadGetRespHeaders(w, r.URL.Query())
|
2018-08-09 00:39:47 +02:00
|
|
|
|
|
2018-09-21 04:22:09 +02:00
|
|
|
|
statusCodeWritten := false
|
|
|
|
|
httpWriter := ioutil.WriteOnClose(w)
|
|
|
|
|
if rs != nil {
|
2018-08-09 00:39:47 +02:00
|
|
|
|
statusCodeWritten = true
|
|
|
|
|
w.WriteHeader(http.StatusPartialContent)
|
|
|
|
|
}
|
2018-09-21 04:22:09 +02:00
|
|
|
|
// Write object content to response body
|
|
|
|
|
if _, err = io.Copy(httpWriter, gr); err != nil {
|
2018-08-09 00:39:47 +02:00
|
|
|
|
if !httpWriter.HasWritten() && !statusCodeWritten { // write error response only if no data or headers has been written to client yet
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2016-07-11 02:12:22 +02:00
|
|
|
|
}
|
2016-05-29 00:13:15 +02:00
|
|
|
|
return
|
fs: Break fs package to top-level and introduce ObjectAPI interface.
ObjectAPI interface brings in changes needed for XL ObjectAPI layer.
The new interface for any ObjectAPI layer is as below
```
// ObjectAPI interface.
type ObjectAPI interface {
// Bucket resource API.
DeleteBucket(bucket string) *probe.Error
ListBuckets() ([]BucketInfo, *probe.Error)
MakeBucket(bucket string) *probe.Error
GetBucketInfo(bucket string) (BucketInfo, *probe.Error)
// Bucket query API.
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsResult, *probe.Error)
ListMultipartUploads(bucket string, resources BucketMultipartResourcesMetadata) (BucketMultipartResourcesMetadata, *probe.Error)
// Object resource API.
GetObject(bucket, object string, startOffset int64) (io.ReadCloser, *probe.Error)
GetObjectInfo(bucket, object string) (ObjectInfo, *probe.Error)
PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string) (ObjectInfo, *probe.Error)
DeleteObject(bucket, object string) *probe.Error
// Object query API.
NewMultipartUpload(bucket, object string) (string, *probe.Error)
PutObjectPart(bucket, object, uploadID string, partID int, size int64, data io.Reader, md5Hex string) (string, *probe.Error)
ListObjectParts(bucket, object string, resources ObjectResourcesMetadata) (ObjectResourcesMetadata, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []CompletePart) (ObjectInfo, *probe.Error)
AbortMultipartUpload(bucket, object, uploadID string) *probe.Error
}
```
2016-03-31 01:15:28 +02:00
|
|
|
|
}
|
2018-02-24 00:07:21 +01:00
|
|
|
|
|
2017-11-08 00:18:59 +01:00
|
|
|
|
if err = httpWriter.Close(); err != nil {
|
2018-08-09 00:39:47 +02:00
|
|
|
|
if !httpWriter.HasWritten() && !statusCodeWritten { // write error response only if no data or headers has been written to client yet
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2017-11-08 00:18:59 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-07-11 02:12:22 +02:00
|
|
|
|
}
|
2017-03-21 18:32:17 +01:00
|
|
|
|
|
|
|
|
|
// Notify object accessed via a GET request.
|
2018-03-15 21:03:41 +01:00
|
|
|
|
sendEvent(eventArgs{
|
2018-08-23 23:40:54 +02:00
|
|
|
|
EventName: event.ObjectAccessedGet,
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
2019-03-25 19:45:42 +01:00
|
|
|
|
Host: handlers.GetSourceIP(r),
|
2017-03-21 18:32:17 +01:00
|
|
|
|
})
|
2015-02-16 02:03:27 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-01 05:15:48 +02:00
|
|
|
|
// HeadObjectHandler - HEAD Object
|
2015-02-24 01:46:48 +01:00
|
|
|
|
// -----------
|
|
|
|
|
// The HEAD operation retrieves metadata from an object without returning the object itself.
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) HeadObjectHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "HeadObject")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "HeadObject", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, errorCodes.ToAPIErr(ErrServerNotInitialized))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-18 06:07:19 +02:00
|
|
|
|
if crypto.S3.IsRequested(r.Header) || crypto.S3KMS.IsRequested(r.Header) { // If SSE-S3 or SSE-KMS present -> AWS fails with undefined error
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, errorCodes.ToAPIErr(ErrBadRequest))
|
2018-08-18 06:07:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if !api.EncryptionEnabled() && crypto.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrBadRequest), r.URL, guessIsBrowserReq(r))
|
2018-12-15 06:39:59 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-18 06:07:19 +02:00
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2016-08-11 03:47:49 +02:00
|
|
|
|
|
2018-12-12 20:43:44 +01:00
|
|
|
|
if vid := r.URL.Query().Get("versionId"); vid != "" && vid != "null" {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, errorCodes.ToAPIErr(ErrNoSuchVersion))
|
2018-12-12 20:43:44 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-21 22:48:58 +02:00
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
2018-03-28 23:14:06 +02:00
|
|
|
|
if api.CacheAPI() != nil {
|
2018-09-21 22:48:58 +02:00
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
2018-03-28 23:14:06 +02:00
|
|
|
|
}
|
|
|
|
|
|
2019-02-09 06:31:06 +01:00
|
|
|
|
opts, err := getOpts(ctx, r, bucket, object)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-11-15 02:36:41 +01:00
|
|
|
|
|
2018-05-02 08:43:27 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.GetObjectAction, bucket, object); s3Error != ErrNone {
|
|
|
|
|
if getRequestAuthType(r) == authTypeAnonymous {
|
2018-09-21 04:22:09 +02:00
|
|
|
|
// As per "Permission" section in
|
|
|
|
|
// https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html
|
|
|
|
|
// If the object you request does not exist,
|
|
|
|
|
// the error Amazon S3 returns depends on
|
|
|
|
|
// whether you also have the s3:ListBucket
|
|
|
|
|
// permission.
|
|
|
|
|
// * If you have the s3:ListBucket permission
|
|
|
|
|
// on the bucket, Amazon S3 will return an
|
|
|
|
|
// HTTP status code 404 ("no such key")
|
|
|
|
|
// error.
|
|
|
|
|
// * if you don’t have the s3:ListBucket
|
|
|
|
|
// permission, Amazon S3 will return an HTTP
|
|
|
|
|
// status code 403 ("access denied") error.`
|
2018-05-02 08:43:27 +02:00
|
|
|
|
if globalPolicySys.IsAllowed(policy.Args{
|
2018-04-25 00:53:30 +02:00
|
|
|
|
Action: policy.ListBucketAction,
|
|
|
|
|
BucketName: bucket,
|
2019-10-16 17:59:59 +02:00
|
|
|
|
ConditionValues: getConditionValues(r, "", "", nil),
|
2018-04-25 00:53:30 +02:00
|
|
|
|
IsOwner: false,
|
|
|
|
|
}) {
|
2018-11-15 02:36:41 +01:00
|
|
|
|
_, err = getObjectInfo(ctx, bucket, object, opts)
|
2019-02-12 10:25:52 +01:00
|
|
|
|
if toAPIError(ctx, err).Code == "NoSuchKey" {
|
2018-05-02 08:43:27 +02:00
|
|
|
|
s3Error = ErrNoSuchKey
|
|
|
|
|
}
|
2018-04-25 00:53:30 +02:00
|
|
|
|
}
|
2015-09-19 12:20:07 +02:00
|
|
|
|
}
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, errorCodes.ToAPIErr(s3Error))
|
2018-05-02 08:43:27 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-04-25 00:53:30 +02:00
|
|
|
|
|
2018-09-23 19:24:10 +02:00
|
|
|
|
// Get request range.
|
|
|
|
|
var rs *HTTPRangeSpec
|
|
|
|
|
rangeHeader := r.Header.Get("Range")
|
|
|
|
|
if rangeHeader != "" {
|
|
|
|
|
if rs, err = parseRequestRangeSpec(rangeHeader); err != nil {
|
|
|
|
|
// Handle only errInvalidRange. Ignore other
|
|
|
|
|
// parse error and treat it as regular Get
|
|
|
|
|
// request like Amazon S3.
|
|
|
|
|
if err == errInvalidRange {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, errorCodes.ToAPIErr(ErrInvalidRange))
|
2018-09-23 19:24:10 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-21 22:48:58 +02:00
|
|
|
|
objInfo, err := getObjectInfo(ctx, bucket, object, opts)
|
2018-05-02 08:43:27 +02:00
|
|
|
|
if err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2015-08-04 01:17:21 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-11-20 22:18:09 +01:00
|
|
|
|
|
|
|
|
|
// filter object lock metadata if permission does not permit
|
|
|
|
|
getRetPerms := checkRequestAuthType(ctx, r, policy.GetObjectRetentionAction, bucket, object)
|
2020-01-17 00:41:56 +01:00
|
|
|
|
legalHoldPerms := checkRequestAuthType(ctx, r, policy.GetObjectLegalHoldAction, bucket, object)
|
|
|
|
|
|
|
|
|
|
// filter object lock metadata if permission does not permit
|
|
|
|
|
objInfo.UserDefined = objectlock.FilterObjectLockMetadata(objInfo.UserDefined, getRetPerms != ErrNone, legalHoldPerms != ErrNone)
|
2019-11-20 22:18:09 +01:00
|
|
|
|
|
2018-02-24 00:07:21 +01:00
|
|
|
|
if objectAPI.IsEncryptionSupported() {
|
2018-11-15 02:36:41 +01:00
|
|
|
|
if _, err = DecryptObjectInfo(&objInfo, r.Header); err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2017-11-08 00:18:59 +01:00
|
|
|
|
return
|
2018-09-23 19:24:10 +02:00
|
|
|
|
}
|
2019-01-05 23:16:43 +01:00
|
|
|
|
objInfo.UserDefined = CleanMinioInternalMetadataKeys(objInfo.UserDefined)
|
2018-09-23 19:24:10 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Set encryption response headers
|
|
|
|
|
if objectAPI.IsEncryptionSupported() {
|
|
|
|
|
if crypto.IsEncrypted(objInfo.UserDefined) {
|
|
|
|
|
switch {
|
|
|
|
|
case crypto.S3.IsEncrypted(objInfo.UserDefined):
|
2018-08-17 21:52:14 +02:00
|
|
|
|
w.Header().Set(crypto.SSEHeader, crypto.SSEAlgorithmAES256)
|
2018-09-23 19:24:10 +02:00
|
|
|
|
case crypto.SSEC.IsEncrypted(objInfo.UserDefined):
|
2018-10-16 21:24:27 +02:00
|
|
|
|
// Validate the SSE-C Key set in the header.
|
|
|
|
|
if _, err = crypto.SSEC.UnsealObjectKey(r.Header, objInfo.UserDefined, bucket, object); err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2018-10-16 21:24:27 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-17 21:52:14 +02:00
|
|
|
|
w.Header().Set(crypto.SSECAlgorithm, r.Header.Get(crypto.SSECAlgorithm))
|
|
|
|
|
w.Header().Set(crypto.SSECKeyMD5, r.Header.Get(crypto.SSECKeyMD5))
|
|
|
|
|
}
|
2017-11-08 00:18:59 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2016-02-29 03:10:37 +01:00
|
|
|
|
|
2016-07-11 02:12:22 +02:00
|
|
|
|
// Validate pre-conditions if any.
|
2020-04-21 07:01:59 +02:00
|
|
|
|
if checkPreconditions(ctx, w, r, objInfo, opts) {
|
2016-02-29 03:10:37 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-11 02:12:22 +02:00
|
|
|
|
// Set standard object headers.
|
2018-11-12 20:07:43 +01:00
|
|
|
|
if err = setObjectHeaders(w, objInfo, rs); err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2018-09-21 04:22:09 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-02-29 03:10:37 +01:00
|
|
|
|
|
2017-08-08 20:04:04 +02:00
|
|
|
|
// Set any additional requested response headers.
|
|
|
|
|
setHeadGetRespHeaders(w, r.URL.Query())
|
|
|
|
|
|
2016-07-27 20:57:08 +02:00
|
|
|
|
// Successful response.
|
2018-09-23 19:24:10 +02:00
|
|
|
|
if rs != nil {
|
|
|
|
|
w.WriteHeader(http.StatusPartialContent)
|
|
|
|
|
} else {
|
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
|
}
|
2017-03-21 18:32:17 +01:00
|
|
|
|
|
|
|
|
|
// Notify object accessed via a HEAD request.
|
2018-03-15 21:03:41 +01:00
|
|
|
|
sendEvent(eventArgs{
|
2018-08-23 23:40:54 +02:00
|
|
|
|
EventName: event.ObjectAccessedHead,
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
2019-03-25 19:45:42 +01:00
|
|
|
|
Host: handlers.GetSourceIP(r),
|
2017-03-21 18:32:17 +01:00
|
|
|
|
})
|
2015-02-16 02:03:27 +01:00
|
|
|
|
}
|
|
|
|
|
|
2016-12-27 01:29:26 +01:00
|
|
|
|
// Extract metadata relevant for an CopyObject operation based on conditional
|
|
|
|
|
// header values specified in X-Amz-Metadata-Directive.
|
2018-07-11 05:27:10 +02:00
|
|
|
|
func getCpObjMetadataFromHeader(ctx context.Context, r *http.Request, userMeta map[string]string) (map[string]string, error) {
|
2018-02-24 00:07:21 +01:00
|
|
|
|
// Make a copy of the supplied metadata to avoid
|
|
|
|
|
// to change the original one.
|
|
|
|
|
defaultMeta := make(map[string]string, len(userMeta))
|
|
|
|
|
for k, v := range userMeta {
|
|
|
|
|
defaultMeta[k] = v
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-05 23:16:43 +01:00
|
|
|
|
// remove SSE Headers from source info
|
|
|
|
|
crypto.RemoveSSEHeaders(defaultMeta)
|
|
|
|
|
|
2020-04-17 02:42:44 +02:00
|
|
|
|
// Storage class is special, it can be replaced regardless of the
|
|
|
|
|
// metadata directive, if set should be preserved and replaced
|
|
|
|
|
// to the destination metadata.
|
|
|
|
|
sc := r.Header.Get(xhttp.AmzStorageClass)
|
|
|
|
|
if sc == "" {
|
|
|
|
|
sc = r.URL.Query().Get(xhttp.AmzStorageClass)
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-27 01:29:26 +01:00
|
|
|
|
// if x-amz-metadata-directive says REPLACE then
|
|
|
|
|
// we extract metadata from the input headers.
|
2020-01-20 17:45:59 +01:00
|
|
|
|
if isDirectiveReplace(r.Header.Get(xhttp.AmzMetadataDirective)) {
|
2020-04-17 02:42:44 +02:00
|
|
|
|
emetadata, err := extractMetadata(ctx, r)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
if sc != "" {
|
|
|
|
|
emetadata[xhttp.AmzStorageClass] = sc
|
|
|
|
|
}
|
|
|
|
|
return emetadata, nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if sc != "" {
|
|
|
|
|
defaultMeta[xhttp.AmzStorageClass] = sc
|
2016-12-27 01:29:26 +01:00
|
|
|
|
}
|
2017-01-06 09:37:00 +01:00
|
|
|
|
|
2016-12-27 01:29:26 +01:00
|
|
|
|
// if x-amz-metadata-directive says COPY then we
|
|
|
|
|
// return the default metadata.
|
2020-01-20 17:45:59 +01:00
|
|
|
|
if isDirectiveCopy(r.Header.Get(xhttp.AmzMetadataDirective)) {
|
2017-07-06 01:56:10 +02:00
|
|
|
|
return defaultMeta, nil
|
2016-12-27 01:29:26 +01:00
|
|
|
|
}
|
2017-01-06 09:37:00 +01:00
|
|
|
|
|
2016-12-27 01:29:26 +01:00
|
|
|
|
// Copy is default behavior if not x-amz-metadata-directive is set.
|
2017-07-06 01:56:10 +02:00
|
|
|
|
return defaultMeta, nil
|
2016-12-27 01:29:26 +01:00
|
|
|
|
}
|
|
|
|
|
|
2020-01-20 17:45:59 +01:00
|
|
|
|
// Extract tags relevant for an CopyObject operation based on conditional
|
|
|
|
|
// header values specified in X-Amz-Tagging-Directive.
|
|
|
|
|
func getCpObjTagsFromHeader(ctx context.Context, r *http.Request, tags string) (string, error) {
|
|
|
|
|
// if x-amz-tagging-directive says REPLACE then
|
|
|
|
|
// we extract tags from the input headers.
|
|
|
|
|
if isDirectiveReplace(r.Header.Get(xhttp.AmzTagDirective)) {
|
|
|
|
|
if tags := r.Header.Get(xhttp.AmzObjectTagging); tags != "" {
|
|
|
|
|
return extractTags(ctx, tags)
|
|
|
|
|
}
|
2020-04-29 06:56:37 +02:00
|
|
|
|
// If x-amz-tagging-directive is explicitly set to replace and x-amz-tagging is not set.
|
|
|
|
|
// The S3 behavior is to unset the tags.
|
|
|
|
|
return "", nil
|
2020-01-20 17:45:59 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Copy is default behavior if x-amz-tagging-directive is not set.
|
|
|
|
|
return tags, nil
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-17 20:20:56 +02:00
|
|
|
|
// getRemoteInstanceTransport contains a singleton roundtripper.
|
|
|
|
|
var getRemoteInstanceTransport http.RoundTripper
|
|
|
|
|
var getRemoteInstanceTransportOnce sync.Once
|
|
|
|
|
|
2018-11-30 02:35:11 +01:00
|
|
|
|
// Returns a minio-go Client configured to access remote host described by destDNSRecord
|
|
|
|
|
// Applicable only in a federated deployment
|
2018-12-19 14:13:47 +01:00
|
|
|
|
var getRemoteInstanceClient = func(r *http.Request, host string) (*miniogo.Core, error) {
|
2019-10-23 07:59:13 +02:00
|
|
|
|
cred := getReqAccessCred(r, globalServerRegion)
|
2018-12-19 14:13:47 +01:00
|
|
|
|
// In a federated deployment, all the instances share config files
|
|
|
|
|
// and hence expected to have same credentials.
|
|
|
|
|
core, err := miniogo.NewCore(host, cred.AccessKey, cred.SecretKey, globalIsSSL)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
2020-04-17 20:20:56 +02:00
|
|
|
|
getRemoteInstanceTransportOnce.Do(func() {
|
|
|
|
|
getRemoteInstanceTransport = NewGatewayHTTPTransport()
|
|
|
|
|
})
|
|
|
|
|
core.SetCustomTransport(getRemoteInstanceTransport)
|
2018-12-19 14:13:47 +01:00
|
|
|
|
return core, nil
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-20 19:19:22 +02:00
|
|
|
|
// Check if the destination bucket is on a remote site, this code only gets executed
|
|
|
|
|
// when federation is enabled, ie when globalDNSConfig is non 'nil'.
|
|
|
|
|
//
|
|
|
|
|
// This function is similar to isRemoteCallRequired but specifically for COPY object API
|
|
|
|
|
// if destination and source are same we do not need to check for destnation bucket
|
|
|
|
|
// to exist locally.
|
|
|
|
|
func isRemoteCopyRequired(ctx context.Context, srcBucket, dstBucket string, objAPI ObjectLayer) bool {
|
|
|
|
|
if srcBucket == dstBucket {
|
|
|
|
|
return false
|
|
|
|
|
}
|
|
|
|
|
return isRemoteCallRequired(ctx, dstBucket, objAPI)
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-19 14:13:47 +01:00
|
|
|
|
// Check if the bucket is on a remote site, this code only gets executed when federation is enabled.
|
2019-08-20 19:19:22 +02:00
|
|
|
|
func isRemoteCallRequired(ctx context.Context, bucket string, objAPI ObjectLayer) bool {
|
2018-12-19 14:13:47 +01:00
|
|
|
|
if globalDNSConfig == nil {
|
|
|
|
|
return false
|
|
|
|
|
}
|
2019-12-29 17:56:45 +01:00
|
|
|
|
if globalBucketFederation {
|
|
|
|
|
_, err := objAPI.GetBucketInfo(ctx, bucket)
|
|
|
|
|
return err == toObjectErr(errVolumeNotFound, bucket)
|
|
|
|
|
}
|
|
|
|
|
return false
|
2018-11-30 02:35:11 +01:00
|
|
|
|
}
|
|
|
|
|
|
2016-02-27 12:04:52 +01:00
|
|
|
|
// CopyObjectHandler - Copy Object
|
|
|
|
|
// ----------
|
|
|
|
|
// This implementation of the PUT operation adds an object to a bucket
|
|
|
|
|
// while reading the object from another source.
|
2018-09-25 21:39:46 +02:00
|
|
|
|
// Notice: The S3 client can send secret keys in headers for encryption related jobs,
|
|
|
|
|
// the handler should ensure to remove these keys before sending them to the object layer.
|
|
|
|
|
// Currently these keys are:
|
|
|
|
|
// - X-Amz-Server-Side-Encryption-Customer-Key
|
|
|
|
|
// - X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) CopyObjectHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "CopyObject")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "CopyObject", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-10-10 00:04:53 +02:00
|
|
|
|
if crypto.S3KMS.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r)) // SSE-KMS is not supported
|
2018-08-18 06:07:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if !api.EncryptionEnabled() && crypto.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
2018-12-15 06:39:59 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-18 06:07:19 +02:00
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
dstBucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
dstObject, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2016-08-11 03:47:49 +02:00
|
|
|
|
|
2018-04-25 00:53:30 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.PutObjectAction, dstBucket, dstObject); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2016-02-27 12:04:52 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-06 23:00:29 +02:00
|
|
|
|
// TODO: Reject requests where body/payload is present, for now we don't even read it.
|
2016-02-27 12:04:52 +01:00
|
|
|
|
|
2019-01-10 22:10:10 +01:00
|
|
|
|
// Read escaped copy source path to check for parameters.
|
2019-07-03 07:34:32 +02:00
|
|
|
|
cpSrcPath := r.Header.Get(xhttp.AmzCopySource)
|
2016-02-27 12:04:52 +01:00
|
|
|
|
|
2018-12-12 20:43:44 +01:00
|
|
|
|
// Check https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html
|
|
|
|
|
// Regardless of whether you have enabled versioning, each object in your bucket
|
|
|
|
|
// has a version ID. If you have not enabled versioning, Amazon S3 sets the value
|
|
|
|
|
// of the version ID to null. If you have enabled versioning, Amazon S3 assigns a
|
|
|
|
|
// unique version ID value for the object.
|
|
|
|
|
if u, err := url.Parse(cpSrcPath); err == nil {
|
|
|
|
|
// Check if versionId query param was added, if yes then check if
|
|
|
|
|
// its non "null" value, we should error out since we do not support
|
|
|
|
|
// any versions other than "null".
|
|
|
|
|
if vid := u.Query().Get("versionId"); vid != "" && vid != "null" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
2018-12-12 20:43:44 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-01-10 22:10:10 +01:00
|
|
|
|
// Note that url.Parse does the unescaping
|
2018-12-12 20:43:44 +01:00
|
|
|
|
cpSrcPath = u.Path
|
|
|
|
|
}
|
2019-07-03 07:34:32 +02:00
|
|
|
|
if vid := r.Header.Get(xhttp.AmzCopySourceVersionID); vid != "" {
|
2019-01-10 22:10:10 +01:00
|
|
|
|
// Check if versionId header was added, if yes then check if
|
|
|
|
|
// its non "null" value, we should error out since we do not support
|
|
|
|
|
// any versions other than "null".
|
|
|
|
|
if vid != "null" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
2019-01-10 22:10:10 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-12-12 20:43:44 +01:00
|
|
|
|
|
2020-01-21 23:07:49 +01:00
|
|
|
|
srcBucket, srcObject := path2BucketObject(cpSrcPath)
|
2016-12-27 01:29:26 +01:00
|
|
|
|
// If source object is empty or bucket is empty, reply back invalid copy source.
|
|
|
|
|
if srcObject == "" || srcBucket == "" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidCopySource), r.URL, guessIsBrowserReq(r))
|
2016-02-27 12:04:52 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-27 01:12:44 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.GetObjectAction, srcBucket, srcObject); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2018-10-27 01:12:44 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-27 01:29:26 +01:00
|
|
|
|
// Check if metadata directive is valid.
|
2020-01-20 17:45:59 +01:00
|
|
|
|
if !isDirectiveValid(r.Header.Get(xhttp.AmzMetadataDirective)) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidMetadataDirective), r.URL, guessIsBrowserReq(r))
|
2016-02-27 12:04:52 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-09-23 22:35:04 +02:00
|
|
|
|
|
2020-01-20 17:45:59 +01:00
|
|
|
|
// check if tag directive is valid
|
|
|
|
|
if !isDirectiveValid(r.Header.Get(xhttp.AmzTagDirective)) {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidTagDirective), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-17 02:42:44 +02:00
|
|
|
|
// Validate storage class metadata if present
|
|
|
|
|
dstSc := r.Header.Get(xhttp.AmzStorageClass)
|
|
|
|
|
if dstSc != "" && !storageclass.IsValid(dstSc) {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidStorageClass), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-05 10:42:34 +01:00
|
|
|
|
// Check if bucket encryption is enabled
|
|
|
|
|
_, encEnabled := globalBucketSSEConfigSys.Get(dstBucket)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
// This request header needs to be set prior to setting ObjectOptions
|
2020-02-05 10:42:34 +01:00
|
|
|
|
if (globalAutoEncryption || encEnabled) && !crypto.SSEC.IsRequested(r.Header) {
|
2019-01-05 23:16:43 +01:00
|
|
|
|
r.Header.Add(crypto.SSEHeader, crypto.SSEAlgorithmAES256)
|
|
|
|
|
}
|
2016-02-27 12:04:52 +01:00
|
|
|
|
|
2018-09-10 18:42:43 +02:00
|
|
|
|
var srcOpts, dstOpts ObjectOptions
|
2020-02-12 04:38:02 +01:00
|
|
|
|
srcOpts, err = copySrcOpts(ctx, r, srcBucket, srcObject)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
|
|
|
|
logger.LogIf(ctx, err)
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
// convert copy src encryption options for GET calls
|
|
|
|
|
var getOpts = ObjectOptions{}
|
|
|
|
|
getSSE := encrypt.SSE(srcOpts.ServerSideEncryption)
|
|
|
|
|
if getSSE != srcOpts.ServerSideEncryption {
|
|
|
|
|
getOpts.ServerSideEncryption = getSSE
|
|
|
|
|
}
|
2019-02-09 06:31:06 +01:00
|
|
|
|
dstOpts, err = copyDstOpts(ctx, r, dstBucket, dstObject, nil)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
|
|
|
|
logger.LogIf(ctx, err)
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-07-09 21:13:40 +02:00
|
|
|
|
|
2019-04-10 20:31:50 +02:00
|
|
|
|
cpSrcDstSame := isStringEqual(pathJoin(srcBucket, srcObject), pathJoin(dstBucket, dstObject))
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
2018-09-25 21:39:46 +02:00
|
|
|
|
getObjectNInfo := objectAPI.GetObjectNInfo
|
|
|
|
|
|
|
|
|
|
var lock = noLock
|
|
|
|
|
if !cpSrcDstSame {
|
|
|
|
|
lock = readLock
|
|
|
|
|
}
|
2019-03-06 21:38:41 +01:00
|
|
|
|
checkCopyPrecondFn := func(o ObjectInfo, encETag string) bool {
|
|
|
|
|
return checkCopyObjectPreconditions(ctx, w, r, o, encETag)
|
|
|
|
|
}
|
|
|
|
|
getOpts.CheckCopyPrecondFn = checkCopyPrecondFn
|
|
|
|
|
srcOpts.CheckCopyPrecondFn = checkCopyPrecondFn
|
2018-10-25 17:50:06 +02:00
|
|
|
|
var rs *HTTPRangeSpec
|
2019-01-05 23:16:43 +01:00
|
|
|
|
gr, err := getObjectNInfo(ctx, srcBucket, srcObject, rs, r.Header, lock, getOpts)
|
2018-09-25 21:39:46 +02:00
|
|
|
|
if err != nil {
|
2019-03-06 21:38:41 +01:00
|
|
|
|
if isErrPreconditionFailed(err) {
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-09-25 21:39:46 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
defer gr.Close()
|
|
|
|
|
srcInfo := gr.ObjInfo
|
|
|
|
|
|
2020-01-20 17:45:59 +01:00
|
|
|
|
// maximum Upload size for object in a single CopyObject operation.
|
2018-02-21 09:48:47 +01:00
|
|
|
|
if isMaxObjectSize(srcInfo.Size) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrEntityTooLarge), r.URL, guessIsBrowserReq(r))
|
2016-02-27 12:04:52 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-24 00:07:21 +01:00
|
|
|
|
// We have to copy metadata only if source and destination are same.
|
|
|
|
|
// this changes for encryption which can be observed below.
|
|
|
|
|
if cpSrcDstSame {
|
|
|
|
|
srcInfo.metadataOnly = true
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-17 02:42:44 +02:00
|
|
|
|
var chStorageClass bool
|
|
|
|
|
if dstSc != "" {
|
|
|
|
|
sc, ok := srcInfo.UserDefined[xhttp.AmzStorageClass]
|
|
|
|
|
if (ok && dstSc != sc) || (srcInfo.StorageClass != dstSc) {
|
|
|
|
|
chStorageClass = true
|
|
|
|
|
srcInfo.metadataOnly = false
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-28 05:36:17 +02:00
|
|
|
|
var reader io.Reader
|
|
|
|
|
var length = srcInfo.Size
|
2018-10-23 20:46:20 +02:00
|
|
|
|
|
|
|
|
|
// Set the actual size to the decrypted size if encrypted.
|
|
|
|
|
actualSize := srcInfo.Size
|
|
|
|
|
if crypto.IsEncrypted(srcInfo.UserDefined) {
|
|
|
|
|
actualSize, err = srcInfo.DecryptedSize()
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-10-23 20:46:20 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-11-27 22:23:32 +01:00
|
|
|
|
length = actualSize
|
2018-10-23 20:46:20 +02:00
|
|
|
|
}
|
2020-05-01 00:55:54 +02:00
|
|
|
|
if err := enforceBucketQuota(ctx, dstBucket, actualSize); err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2018-10-23 20:46:20 +02:00
|
|
|
|
|
2018-12-11 21:05:41 +01:00
|
|
|
|
var compressMetadata map[string]string
|
2018-09-28 05:36:17 +02:00
|
|
|
|
// No need to compress for remote etcd calls
|
|
|
|
|
// Pass the decompressed stream to such calls.
|
2018-12-19 14:13:47 +01:00
|
|
|
|
isCompressed := objectAPI.IsCompressionSupported() && isCompressible(r.Header, srcObject) && !isRemoteCopyRequired(ctx, srcBucket, dstBucket, objectAPI)
|
2018-10-23 20:46:20 +02:00
|
|
|
|
if isCompressed {
|
2018-12-11 21:05:41 +01:00
|
|
|
|
compressMetadata = make(map[string]string, 2)
|
|
|
|
|
// Preserving the compression metadata.
|
2019-09-26 08:08:24 +02:00
|
|
|
|
compressMetadata[ReservedMetadataPrefix+"compression"] = compressionAlgorithmV2
|
2018-12-11 21:05:41 +01:00
|
|
|
|
compressMetadata[ReservedMetadataPrefix+"actual-size"] = strconv.FormatInt(actualSize, 10)
|
2018-10-23 20:46:20 +02:00
|
|
|
|
// Remove all source encrypted related metadata to
|
|
|
|
|
// avoid copying them in target object.
|
|
|
|
|
crypto.RemoveInternalEntries(srcInfo.UserDefined)
|
2018-09-28 05:36:17 +02:00
|
|
|
|
|
2019-09-26 08:08:24 +02:00
|
|
|
|
s2c := newS2CompressReader(gr)
|
|
|
|
|
defer s2c.Close()
|
|
|
|
|
reader = s2c
|
2019-03-05 17:35:37 +01:00
|
|
|
|
length = -1
|
2018-09-28 05:36:17 +02:00
|
|
|
|
} else {
|
|
|
|
|
// Remove the metadata for remote calls.
|
|
|
|
|
delete(srcInfo.UserDefined, ReservedMetadataPrefix+"compression")
|
|
|
|
|
delete(srcInfo.UserDefined, ReservedMetadataPrefix+"actual-size")
|
|
|
|
|
reader = gr
|
|
|
|
|
}
|
2018-03-03 02:24:02 +01:00
|
|
|
|
|
2019-05-09 03:35:40 +02:00
|
|
|
|
srcInfo.Reader, err = hash.NewReader(reader, length, "", "", actualSize, globalCLIContext.StrictS3Compat)
|
2018-03-03 02:24:02 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-03 02:24:02 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-11-27 22:23:32 +01:00
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
rawReader := srcInfo.Reader
|
2018-11-27 22:23:32 +01:00
|
|
|
|
pReader := NewPutObjReader(srcInfo.Reader, nil, nil)
|
|
|
|
|
|
2018-02-24 00:07:21 +01:00
|
|
|
|
var encMetadata = make(map[string]string)
|
2018-10-23 20:46:20 +02:00
|
|
|
|
if objectAPI.IsEncryptionSupported() && !isCompressed {
|
2018-10-19 19:41:13 +02:00
|
|
|
|
// Encryption parameters not applicable for this object.
|
|
|
|
|
if !crypto.IsEncrypted(srcInfo.UserDefined) && crypto.SSECopy.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, errInvalidEncryptionParameters), r.URL, guessIsBrowserReq(r))
|
2018-10-19 19:41:13 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
// Encryption parameters not present for this object.
|
|
|
|
|
if crypto.SSEC.IsEncrypted(srcInfo.UserDefined) && !crypto.SSECopy.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidSSECustomerAlgorithm), r.URL, guessIsBrowserReq(r))
|
2018-10-19 19:41:13 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-11-15 02:36:41 +01:00
|
|
|
|
|
2020-04-10 02:01:45 +02:00
|
|
|
|
var oldKey, newKey []byte
|
|
|
|
|
var objEncKey crypto.ObjectKey
|
2018-08-17 21:52:14 +02:00
|
|
|
|
sseCopyS3 := crypto.S3.IsEncrypted(srcInfo.UserDefined)
|
2018-10-19 19:41:13 +02:00
|
|
|
|
sseCopyC := crypto.SSEC.IsEncrypted(srcInfo.UserDefined) && crypto.SSECopy.IsRequested(r.Header)
|
2018-08-17 21:52:14 +02:00
|
|
|
|
sseC := crypto.SSEC.IsRequested(r.Header)
|
|
|
|
|
sseS3 := crypto.S3.IsRequested(r.Header)
|
2018-10-15 20:07:36 +02:00
|
|
|
|
|
|
|
|
|
isSourceEncrypted := sseCopyC || sseCopyS3
|
|
|
|
|
isTargetEncrypted := sseC || sseS3
|
|
|
|
|
|
|
|
|
|
if sseC {
|
|
|
|
|
newKey, err = ParseSSECustomerRequest(r)
|
2018-02-24 00:07:21 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-02-24 00:07:21 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-11-05 19:26:10 +01:00
|
|
|
|
|
|
|
|
|
// If src == dst and either
|
|
|
|
|
// - the object is encrypted using SSE-C and two different SSE-C keys are present
|
|
|
|
|
// - the object is encrypted using SSE-S3 and the SSE-S3 header is present
|
2020-04-17 02:42:44 +02:00
|
|
|
|
// - the object storage class is not changing
|
|
|
|
|
// then execute a key rotation.
|
2019-01-05 23:16:43 +01:00
|
|
|
|
var keyRotation bool
|
2020-04-17 02:42:44 +02:00
|
|
|
|
if cpSrcDstSame && (sseCopyC && sseC) && !chStorageClass {
|
2019-09-23 22:35:04 +02:00
|
|
|
|
oldKey, err = ParseSSECopyCustomerRequest(r.Header, srcInfo.UserDefined)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
2018-03-03 02:24:02 +01:00
|
|
|
|
}
|
2018-12-19 23:12:53 +01:00
|
|
|
|
|
2018-02-24 00:07:21 +01:00
|
|
|
|
for k, v := range srcInfo.UserDefined {
|
2019-12-06 08:16:06 +01:00
|
|
|
|
if HasPrefix(k, ReservedMetadataPrefix) {
|
2018-12-19 23:12:53 +01:00
|
|
|
|
encMetadata[k] = v
|
|
|
|
|
}
|
2018-02-24 00:07:21 +01:00
|
|
|
|
}
|
2018-11-05 19:26:10 +01:00
|
|
|
|
|
|
|
|
|
// In case of SSE-S3 oldKey and newKey aren't used - the KMS manages the keys.
|
2018-07-10 02:18:28 +02:00
|
|
|
|
if err = rotateKey(oldKey, newKey, srcBucket, srcObject, encMetadata); err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-02-24 00:07:21 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-03-12 21:52:38 +01:00
|
|
|
|
|
|
|
|
|
// Since we are rotating the keys, make sure to update the metadata.
|
|
|
|
|
srcInfo.metadataOnly = true
|
2019-01-05 23:16:43 +01:00
|
|
|
|
keyRotation = true
|
2018-02-24 00:07:21 +01:00
|
|
|
|
} else {
|
2018-10-15 20:07:36 +02:00
|
|
|
|
if isSourceEncrypted || isTargetEncrypted {
|
2018-02-24 00:07:21 +01:00
|
|
|
|
// We are not only copying just metadata instead
|
|
|
|
|
// we are creating a new object at this point, even
|
|
|
|
|
// if source and destination are same objects.
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if !keyRotation {
|
|
|
|
|
srcInfo.metadataOnly = false
|
|
|
|
|
}
|
2018-02-24 00:07:21 +01:00
|
|
|
|
}
|
2018-10-15 20:07:36 +02:00
|
|
|
|
|
|
|
|
|
// Calculate the size of the target object
|
|
|
|
|
var targetSize int64
|
|
|
|
|
|
|
|
|
|
switch {
|
|
|
|
|
case !isSourceEncrypted && !isTargetEncrypted:
|
2018-11-27 22:23:32 +01:00
|
|
|
|
targetSize = srcInfo.Size
|
2018-10-15 20:07:36 +02:00
|
|
|
|
case isSourceEncrypted && isTargetEncrypted:
|
2019-01-10 00:17:21 +01:00
|
|
|
|
objInfo := ObjectInfo{Size: actualSize}
|
|
|
|
|
targetSize = objInfo.EncryptedSize()
|
2018-10-15 20:07:36 +02:00
|
|
|
|
case !isSourceEncrypted && isTargetEncrypted:
|
|
|
|
|
targetSize = srcInfo.EncryptedSize()
|
|
|
|
|
case isSourceEncrypted && !isTargetEncrypted:
|
|
|
|
|
targetSize, _ = srcInfo.DecryptedSize()
|
|
|
|
|
}
|
2018-11-27 22:23:32 +01:00
|
|
|
|
|
2018-10-15 20:07:36 +02:00
|
|
|
|
if isTargetEncrypted {
|
2018-11-15 02:36:41 +01:00
|
|
|
|
reader, objEncKey, err = newEncryptReader(srcInfo.Reader, newKey, dstBucket, dstObject, encMetadata, sseS3)
|
2018-02-24 00:07:21 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-02-24 00:07:21 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-03-03 02:24:02 +01:00
|
|
|
|
}
|
2018-08-17 21:52:14 +02:00
|
|
|
|
|
2018-10-15 20:07:36 +02:00
|
|
|
|
if isSourceEncrypted {
|
|
|
|
|
// Remove all source encrypted related metadata to
|
|
|
|
|
// avoid copying them in target object.
|
2018-10-19 19:50:52 +02:00
|
|
|
|
crypto.RemoveInternalEntries(srcInfo.UserDefined)
|
2018-10-15 20:07:36 +02:00
|
|
|
|
}
|
|
|
|
|
|
2019-05-09 03:35:40 +02:00
|
|
|
|
// do not try to verify encrypted content
|
|
|
|
|
srcInfo.Reader, err = hash.NewReader(reader, targetSize, "", "", targetSize, globalCLIContext.StrictS3Compat)
|
2018-03-03 02:24:02 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-03 02:24:02 +01:00
|
|
|
|
return
|
2018-02-24 00:07:21 +01:00
|
|
|
|
}
|
2018-11-27 22:23:32 +01:00
|
|
|
|
|
2020-04-12 05:20:30 +02:00
|
|
|
|
if isTargetEncrypted {
|
|
|
|
|
pReader = NewPutObjReader(rawReader, srcInfo.Reader, &objEncKey)
|
|
|
|
|
}
|
2018-02-24 00:07:21 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2018-09-25 21:39:46 +02:00
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
srcInfo.PutObjReader = pReader
|
|
|
|
|
|
2018-07-11 05:27:10 +02:00
|
|
|
|
srcInfo.UserDefined, err = getCpObjMetadataFromHeader(ctx, r, srcInfo.UserDefined)
|
2017-07-06 01:56:10 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2017-10-03 19:38:25 +02:00
|
|
|
|
return
|
2017-07-06 01:56:10 +02:00
|
|
|
|
}
|
2020-01-20 17:45:59 +01:00
|
|
|
|
|
|
|
|
|
tags, err := getCpObjTagsFromHeader(ctx, r, srcInfo.UserTags)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if tags != "" {
|
|
|
|
|
srcInfo.UserDefined[xhttp.AmzObjectTagging] = tags
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-06 22:44:16 +02:00
|
|
|
|
srcInfo.UserDefined = objectlock.FilterObjectLockMetadata(srcInfo.UserDefined, true, true)
|
|
|
|
|
retPerms := isPutActionAllowed(getRequestAuthType(r), dstBucket, dstObject, r, iampolicy.PutObjectRetentionAction)
|
|
|
|
|
holdPerms := isPutActionAllowed(getRequestAuthType(r), dstBucket, dstObject, r, iampolicy.PutObjectLegalHoldAction)
|
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
|
|
|
|
}
|
2020-01-17 00:41:56 +01:00
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
// apply default bucket configuration/governance headers for dest side.
|
2020-01-17 00:41:56 +01:00
|
|
|
|
retentionMode, retentionDate, legalHold, s3Err := checkPutObjectLockAllowed(ctx, r, dstBucket, dstObject, getObjectInfo, retPerms, holdPerms)
|
2020-04-06 22:44:16 +02:00
|
|
|
|
if s3Err == ErrNone && retentionMode.Valid() {
|
2020-04-13 23:03:23 +02:00
|
|
|
|
srcInfo.UserDefined[strings.ToLower(xhttp.AmzObjectLockMode)] = string(retentionMode)
|
|
|
|
|
srcInfo.UserDefined[strings.ToLower(xhttp.AmzObjectLockRetainUntilDate)] = retentionDate.UTC().Format(time.RFC3339)
|
2019-11-20 22:18:09 +01:00
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
if s3Err == ErrNone && legalHold.Status.Valid() {
|
2020-04-13 23:03:23 +02:00
|
|
|
|
srcInfo.UserDefined[strings.ToLower(xhttp.AmzObjectLockLegalHold)] = string(legalHold.Status)
|
2020-01-17 00:41:56 +01:00
|
|
|
|
}
|
2019-11-20 22:18:09 +01:00
|
|
|
|
if s3Err != ErrNone {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
2018-12-11 21:05:41 +01:00
|
|
|
|
// Store the preserved compression metadata.
|
|
|
|
|
for k, v := range compressMetadata {
|
|
|
|
|
srcInfo.UserDefined[k] = v
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-24 00:07:21 +01:00
|
|
|
|
// We need to preserve the encryption headers set in EncryptRequest,
|
|
|
|
|
// so we do not want to override them, copy them instead.
|
|
|
|
|
for k, v := range encMetadata {
|
|
|
|
|
srcInfo.UserDefined[k] = v
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-25 21:39:46 +02:00
|
|
|
|
// Ensure that metadata does not contain sensitive information
|
|
|
|
|
crypto.RemoveSensitiveEntries(srcInfo.UserDefined)
|
2020-01-20 17:45:59 +01:00
|
|
|
|
// Check if x-amz-metadata-directive or x-amz-tagging-directive was not set to REPLACE and source,
|
|
|
|
|
// destination are same objects. Apply this restriction also when
|
2018-02-24 00:07:21 +01:00
|
|
|
|
// metadataOnly is true indicating that we are not overwriting the object.
|
2018-03-07 01:04:48 +01:00
|
|
|
|
// if encryption is enabled we do not need explicit "REPLACE" metadata to
|
|
|
|
|
// be enabled as well - this is to allow for key-rotation.
|
2020-01-20 17:45:59 +01:00
|
|
|
|
if !isDirectiveReplace(r.Header.Get(xhttp.AmzMetadataDirective)) && !isDirectiveReplace(r.Header.Get(xhttp.AmzTagDirective)) &&
|
|
|
|
|
srcInfo.metadataOnly && !crypto.IsEncrypted(srcInfo.UserDefined) {
|
2016-12-27 01:29:26 +01:00
|
|
|
|
// If x-amz-metadata-directive is not set to REPLACE then we need
|
|
|
|
|
// to error out if source and destination are same.
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidCopyDest), r.URL, guessIsBrowserReq(r))
|
2016-12-27 01:29:26 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-12-11 01:15:12 +01:00
|
|
|
|
|
2018-05-11 21:02:30 +02:00
|
|
|
|
var objInfo ObjectInfo
|
|
|
|
|
|
2018-12-19 14:13:47 +01:00
|
|
|
|
if isRemoteCopyRequired(ctx, srcBucket, dstBucket, objectAPI) {
|
|
|
|
|
var dstRecords []dns.SrvRecord
|
|
|
|
|
dstRecords, err = globalDNSConfig.Get(dstBucket)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-05-16 03:20:22 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-12-19 14:13:47 +01:00
|
|
|
|
|
|
|
|
|
// Send PutObject request to appropriate instance (in federated deployment)
|
|
|
|
|
client, rerr := getRemoteInstanceClient(r, getHostFromSrv(dstRecords))
|
|
|
|
|
if rerr != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, rerr), r.URL, guessIsBrowserReq(r))
|
2018-12-19 14:13:47 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
remoteObjInfo, rerr := client.PutObject(dstBucket, dstObject, srcInfo.Reader,
|
|
|
|
|
srcInfo.Size, "", "", srcInfo.UserDefined, dstOpts.ServerSideEncryption)
|
|
|
|
|
if rerr != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, rerr), r.URL, guessIsBrowserReq(r))
|
2018-12-19 14:13:47 +01:00
|
|
|
|
return
|
2018-05-11 21:02:30 +02:00
|
|
|
|
}
|
2018-12-19 14:13:47 +01:00
|
|
|
|
objInfo.ETag = remoteObjInfo.ETag
|
|
|
|
|
objInfo.ModTime = remoteObjInfo.LastModified
|
2018-05-11 21:02:30 +02:00
|
|
|
|
} else {
|
2020-02-07 23:36:46 +01:00
|
|
|
|
copyObjectFn := objectAPI.CopyObject
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
copyObjectFn = api.CacheAPI().CopyObject
|
|
|
|
|
}
|
2018-05-11 21:02:30 +02:00
|
|
|
|
// Copy source object to destination, if source and destination
|
|
|
|
|
// object is same then only metadata is updated.
|
2020-02-07 23:36:46 +01:00
|
|
|
|
objInfo, err = copyObjectFn(ctx, srcBucket, srcObject, dstBucket, dstObject, srcInfo, srcOpts, dstOpts)
|
2018-05-11 21:02:30 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-05-11 21:02:30 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-02-27 12:04:52 +01:00
|
|
|
|
}
|
2016-04-16 21:48:41 +02:00
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
response := generateCopyObjectResponse(getDecryptedETag(r.Header, objInfo, false), objInfo.ModTime)
|
2016-03-06 21:16:22 +01:00
|
|
|
|
encodedSuccessResponse := encodeResponse(response)
|
2017-01-06 09:37:00 +01:00
|
|
|
|
|
|
|
|
|
// Write success response.
|
|
|
|
|
writeSuccessResponseXML(w, encodedSuccessResponse)
|
2016-07-24 07:51:12 +02:00
|
|
|
|
|
2018-10-23 20:46:20 +02:00
|
|
|
|
if objInfo.IsCompressed() {
|
|
|
|
|
objInfo.Size = actualSize
|
2018-09-28 05:36:17 +02:00
|
|
|
|
}
|
|
|
|
|
|
2016-09-29 07:46:19 +02:00
|
|
|
|
// Notify object created event.
|
2018-03-15 21:03:41 +01:00
|
|
|
|
sendEvent(eventArgs{
|
2018-11-03 02:40:08 +01:00
|
|
|
|
EventName: event.ObjectCreatedCopy,
|
|
|
|
|
BucketName: dstBucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
2019-03-25 19:45:42 +01:00
|
|
|
|
Host: handlers.GetSourceIP(r),
|
2016-09-29 07:46:19 +02:00
|
|
|
|
})
|
2016-02-27 12:04:52 +01:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-01 05:15:48 +02:00
|
|
|
|
// PutObjectHandler - PUT Object
|
2015-02-24 01:46:48 +01:00
|
|
|
|
// ----------
|
|
|
|
|
// This implementation of the PUT operation adds an object to a bucket.
|
2018-09-25 21:39:46 +02:00
|
|
|
|
// Notice: The S3 client can send secret keys in headers for encryption related jobs,
|
|
|
|
|
// the handler should ensure to remove these keys before sending them to the object layer.
|
|
|
|
|
// Currently these keys are:
|
|
|
|
|
// - X-Amz-Server-Side-Encryption-Customer-Key
|
|
|
|
|
// - X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) PutObjectHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "PutObject")
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "PutObject", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-06-20 02:37:08 +02:00
|
|
|
|
if crypto.S3KMS.IsRequested(r.Header) && !api.AllowSSEKMS() {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r)) // SSE-KMS is not supported
|
2016-02-27 12:04:52 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if !api.EncryptionEnabled() && crypto.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
2018-12-15 06:39:59 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-02-16 02:42:39 +01:00
|
|
|
|
vars := mux.Vars(r)
|
2016-02-27 12:04:52 +01:00
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2015-04-23 04:29:39 +02:00
|
|
|
|
|
2019-06-29 07:09:17 +02:00
|
|
|
|
// To detect if the client has disconnected.
|
|
|
|
|
r.Body = &detectDisconnect{r.Body, r.Context().Done()}
|
|
|
|
|
|
2018-08-18 06:07:19 +02:00
|
|
|
|
// X-Amz-Copy-Source shouldn't be set for this call.
|
2019-08-22 10:02:39 +02:00
|
|
|
|
if _, ok := r.Header[xhttp.AmzCopySource]; ok {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidCopySource), r.URL, guessIsBrowserReq(r))
|
2018-08-18 06:07:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-27 05:36:16 +01:00
|
|
|
|
// Validate storage class metadata if present
|
2019-10-07 07:50:24 +02:00
|
|
|
|
if sc := r.Header.Get(xhttp.AmzStorageClass); sc != "" {
|
|
|
|
|
if !storageclass.IsValid(sc) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidStorageClass), r.URL, guessIsBrowserReq(r))
|
2017-12-27 05:36:16 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-03-12 10:08:55 +01:00
|
|
|
|
// Get Content-Md5 sent by client and verify if valid
|
2018-03-16 19:22:34 +01:00
|
|
|
|
md5Bytes, err := checkValidMD5(r.Header)
|
2016-03-13 01:08:15 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidDigest), r.URL, guessIsBrowserReq(r))
|
2015-04-23 01:28:13 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-02-16 07:07:52 +01:00
|
|
|
|
|
2015-12-28 08:00:36 +01:00
|
|
|
|
/// if Content-Length is unknown/missing, deny the request
|
2016-02-16 02:42:39 +01:00
|
|
|
|
size := r.ContentLength
|
2016-08-09 05:56:29 +02:00
|
|
|
|
rAuthType := getRequestAuthType(r)
|
|
|
|
|
if rAuthType == authTypeStreamingSigned {
|
2019-08-22 10:02:39 +02:00
|
|
|
|
if sizeStr, ok := r.Header[xhttp.AmzDecodedContentLength]; ok {
|
2018-03-16 19:22:34 +01:00
|
|
|
|
if sizeStr[0] == "" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentLength), r.URL, guessIsBrowserReq(r))
|
2018-03-16 19:22:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
size, err = strconv.ParseInt(sizeStr[0], 10, 64)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-16 19:22:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-08-09 05:56:29 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2017-01-21 01:33:01 +01:00
|
|
|
|
if size == -1 {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentLength), r.URL, guessIsBrowserReq(r))
|
2015-04-29 11:19:51 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-09-30 23:32:13 +02:00
|
|
|
|
|
2015-04-29 19:51:59 +02:00
|
|
|
|
/// maximum Upload size for objects in a single operation
|
2015-04-29 11:19:51 +02:00
|
|
|
|
if isMaxObjectSize(size) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrEntityTooLarge), r.URL, guessIsBrowserReq(r))
|
2015-04-29 11:19:51 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2015-07-03 05:31:22 +02:00
|
|
|
|
|
2018-07-11 05:27:10 +02:00
|
|
|
|
metadata, err := extractMetadata(ctx, r)
|
2017-07-06 01:56:10 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2017-07-06 01:56:10 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-07-11 05:27:10 +02:00
|
|
|
|
|
2020-03-19 00:19:29 +01:00
|
|
|
|
if tags := r.Header.Get(xhttp.AmzObjectTagging); tags != "" {
|
2020-01-20 17:45:59 +01:00
|
|
|
|
metadata[xhttp.AmzObjectTagging], err = extractTags(ctx, tags)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-20 21:07:03 +01:00
|
|
|
|
if rAuthType == authTypeStreamingSigned {
|
2017-03-28 02:02:04 +02:00
|
|
|
|
if contentEncoding, ok := metadata["content-encoding"]; ok {
|
|
|
|
|
contentEncoding = trimAwsChunkedContentEncoding(contentEncoding)
|
|
|
|
|
if contentEncoding != "" {
|
|
|
|
|
// Make sure to trim and save the content-encoding
|
|
|
|
|
// parameter for a streaming signature which is set
|
|
|
|
|
// to a custom value for example: "aws-chunked,gzip".
|
|
|
|
|
metadata["content-encoding"] = contentEncoding
|
|
|
|
|
} else {
|
|
|
|
|
// Trimmed content encoding is empty when the header
|
|
|
|
|
// value is set to "aws-chunked" only.
|
|
|
|
|
|
|
|
|
|
// Make sure to delete the content-encoding parameter
|
|
|
|
|
// for a streaming signature which is set to value
|
|
|
|
|
// for example: "aws-chunked"
|
|
|
|
|
delete(metadata, "content-encoding")
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-02-20 21:07:03 +01:00
|
|
|
|
}
|
|
|
|
|
|
2017-10-22 07:30:34 +02:00
|
|
|
|
var (
|
|
|
|
|
md5hex = hex.EncodeToString(md5Bytes)
|
|
|
|
|
sha256hex = ""
|
2017-11-08 00:18:59 +01:00
|
|
|
|
reader io.Reader
|
|
|
|
|
s3Err APIErrorCode
|
2018-03-28 23:14:06 +02:00
|
|
|
|
putObject = objectAPI.PutObject
|
2017-10-22 07:30:34 +02:00
|
|
|
|
)
|
2017-11-08 00:18:59 +01:00
|
|
|
|
reader = r.Body
|
2018-10-09 23:00:01 +02:00
|
|
|
|
|
|
|
|
|
// Check if put is allowed
|
2019-11-20 22:18:09 +01:00
|
|
|
|
if s3Err = isPutActionAllowed(rAuthType, bucket, object, r, iampolicy.PutObjectAction); s3Err != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
2018-10-09 23:00:01 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-09 05:56:29 +02:00
|
|
|
|
switch rAuthType {
|
|
|
|
|
case authTypeStreamingSigned:
|
|
|
|
|
// Initialize stream signature verifier.
|
2017-11-08 00:18:59 +01:00
|
|
|
|
reader, s3Err = newSignV4ChunkedReader(r)
|
|
|
|
|
if s3Err != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
2016-08-09 05:56:29 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-09-30 23:32:13 +02:00
|
|
|
|
case authTypeSignedV2, authTypePresignedV2:
|
2017-11-08 00:18:59 +01:00
|
|
|
|
s3Err = isReqAuthenticatedV2(r)
|
|
|
|
|
if s3Err != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
2016-09-30 23:32:13 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-01-09 08:19:50 +01:00
|
|
|
|
|
2016-04-07 12:04:18 +02:00
|
|
|
|
case authTypePresigned, authTypeSigned:
|
2019-10-23 07:59:13 +02:00
|
|
|
|
if s3Err = reqSignatureV4Verify(r, globalServerRegion, serviceS3); s3Err != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
2016-10-03 00:51:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if !skipContentSha256Cksum(r) {
|
2019-02-28 02:46:55 +01:00
|
|
|
|
sha256hex = getContentSha256Cksum(r, serviceS3)
|
2016-10-03 00:51:49 +02:00
|
|
|
|
}
|
2016-02-17 03:50:36 +01:00
|
|
|
|
}
|
2020-05-01 00:55:54 +02:00
|
|
|
|
if err := enforceBucketQuota(ctx, bucket, size); err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-02-05 10:42:34 +01:00
|
|
|
|
// Check if bucket encryption is enabled
|
|
|
|
|
_, encEnabled := globalBucketSSEConfigSys.Get(bucket)
|
2019-05-02 17:28:18 +02:00
|
|
|
|
// This request header needs to be set prior to setting ObjectOptions
|
2020-02-05 10:42:34 +01:00
|
|
|
|
if (globalAutoEncryption || encEnabled) && !crypto.SSEC.IsRequested(r.Header) && !crypto.S3KMS.IsRequested(r.Header) {
|
2019-05-02 17:28:18 +02:00
|
|
|
|
r.Header.Add(crypto.SSEHeader, crypto.SSEAlgorithmAES256)
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-28 05:36:17 +02:00
|
|
|
|
actualSize := size
|
|
|
|
|
|
|
|
|
|
if objectAPI.IsCompressionSupported() && isCompressible(r.Header, object) && size > 0 {
|
|
|
|
|
// Storing the compression metadata.
|
2019-09-26 08:08:24 +02:00
|
|
|
|
metadata[ReservedMetadataPrefix+"compression"] = compressionAlgorithmV2
|
2018-09-28 05:36:17 +02:00
|
|
|
|
metadata[ReservedMetadataPrefix+"actual-size"] = strconv.FormatInt(size, 10)
|
|
|
|
|
|
2019-05-09 03:35:40 +02:00
|
|
|
|
actualReader, err := hash.NewReader(reader, size, md5hex, sha256hex, actualSize, globalCLIContext.StrictS3Compat)
|
2018-09-28 05:36:17 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-09-28 05:36:17 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-09-28 09:44:59 +02:00
|
|
|
|
|
2018-09-28 05:36:17 +02:00
|
|
|
|
// Set compression metrics.
|
2019-09-26 08:08:24 +02:00
|
|
|
|
s2c := newS2CompressReader(actualReader)
|
|
|
|
|
defer s2c.Close()
|
|
|
|
|
reader = s2c
|
2018-09-28 05:36:17 +02:00
|
|
|
|
size = -1 // Since compressed size is un-predictable.
|
|
|
|
|
md5hex = "" // Do not try to verify the content.
|
|
|
|
|
sha256hex = ""
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-09 03:35:40 +02:00
|
|
|
|
hashReader, err := hash.NewReader(reader, size, md5hex, sha256hex, actualSize, globalCLIContext.StrictS3Compat)
|
2017-10-22 07:30:34 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2017-10-22 07:30:34 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-11-15 02:36:41 +01:00
|
|
|
|
|
|
|
|
|
rawReader := hashReader
|
|
|
|
|
pReader := NewPutObjReader(rawReader, nil, nil)
|
|
|
|
|
|
2019-01-05 23:16:43 +01:00
|
|
|
|
// get gateway encryption options
|
2018-11-15 02:36:41 +01:00
|
|
|
|
var opts ObjectOptions
|
2019-02-09 06:31:06 +01:00
|
|
|
|
opts, err = putOpts(ctx, r, bucket, object, metadata)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
2019-11-15 11:16:27 +01:00
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
putObject = api.CacheAPI().PutObject
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
|
|
|
|
retPerms := isPutActionAllowed(getRequestAuthType(r), bucket, object, r, iampolicy.PutObjectRetentionAction)
|
2020-01-17 00:41:56 +01:00
|
|
|
|
holdPerms := isPutActionAllowed(getRequestAuthType(r), bucket, object, r, iampolicy.PutObjectLegalHoldAction)
|
|
|
|
|
|
2020-04-06 22:44:16 +02:00
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-17 00:41:56 +01:00
|
|
|
|
retentionMode, retentionDate, legalHold, s3Err := checkPutObjectLockAllowed(ctx, r, bucket, object, getObjectInfo, retPerms, holdPerms)
|
2020-04-06 22:44:16 +02:00
|
|
|
|
if s3Err == ErrNone && retentionMode.Valid() {
|
2019-11-20 22:18:09 +01:00
|
|
|
|
metadata[strings.ToLower(xhttp.AmzObjectLockMode)] = string(retentionMode)
|
|
|
|
|
metadata[strings.ToLower(xhttp.AmzObjectLockRetainUntilDate)] = retentionDate.UTC().Format(time.RFC3339)
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
if s3Err == ErrNone && legalHold.Status.Valid() {
|
2020-01-17 00:41:56 +01:00
|
|
|
|
metadata[strings.ToLower(xhttp.AmzObjectLockLegalHold)] = string(legalHold.Status)
|
|
|
|
|
}
|
2019-11-20 22:18:09 +01:00
|
|
|
|
if s3Err != ErrNone {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
2018-03-28 01:44:45 +02:00
|
|
|
|
}
|
2019-01-05 23:16:43 +01:00
|
|
|
|
|
2020-04-10 02:01:45 +02:00
|
|
|
|
var objectEncryptionKey crypto.ObjectKey
|
2018-02-10 00:19:30 +01:00
|
|
|
|
if objectAPI.IsEncryptionSupported() {
|
2019-12-06 08:16:06 +01:00
|
|
|
|
if crypto.IsRequested(r.Header) && !HasSuffix(object, SlashSeparator) { // handle SSE requests
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if crypto.SSECopy.IsRequested(r.Header) {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, errInvalidEncryptionParameters), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
reader, objectEncryptionKey, err = EncryptRequest(hashReader, r, bucket, object, metadata)
|
2018-02-10 00:19:30 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-02-10 00:19:30 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
info := ObjectInfo{Size: size}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
|
2019-05-09 03:35:40 +02:00
|
|
|
|
// do not try to verify encrypted content
|
|
|
|
|
hashReader, err = hash.NewReader(reader, info.EncryptedSize(), "", "", size, globalCLIContext.StrictS3Compat)
|
2018-02-10 00:19:30 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-02-10 00:19:30 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
pReader = NewPutObjReader(rawReader, hashReader, &objectEncryptionKey)
|
2017-11-08 00:18:59 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-25 21:39:46 +02:00
|
|
|
|
// Ensure that metadata does not contain sensitive information
|
|
|
|
|
crypto.RemoveSensitiveEntries(metadata)
|
|
|
|
|
|
2018-03-28 23:14:06 +02:00
|
|
|
|
// Create the object..
|
2019-02-09 06:31:06 +01:00
|
|
|
|
objInfo, err := putObject(ctx, bucket, object, pReader, opts)
|
2015-09-19 12:20:07 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2015-08-04 01:17:21 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-02-24 00:07:21 +01:00
|
|
|
|
|
2018-12-19 23:12:53 +01:00
|
|
|
|
etag := objInfo.ETag
|
2020-04-10 02:01:45 +02:00
|
|
|
|
switch {
|
|
|
|
|
case objInfo.IsCompressed():
|
2019-05-09 03:35:40 +02:00
|
|
|
|
if !strings.HasSuffix(objInfo.ETag, "-1") {
|
|
|
|
|
etag = objInfo.ETag + "-1"
|
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
case crypto.IsEncrypted(objInfo.UserDefined):
|
|
|
|
|
switch {
|
|
|
|
|
case crypto.S3.IsEncrypted(objInfo.UserDefined):
|
|
|
|
|
w.Header().Set(crypto.SSEHeader, crypto.SSEAlgorithmAES256)
|
|
|
|
|
etag, _ = DecryptETag(objectEncryptionKey, ObjectInfo{ETag: etag})
|
|
|
|
|
case crypto.SSEC.IsEncrypted(objInfo.UserDefined):
|
|
|
|
|
w.Header().Set(crypto.SSECAlgorithm, r.Header.Get(crypto.SSECAlgorithm))
|
|
|
|
|
w.Header().Set(crypto.SSECKeyMD5, r.Header.Get(crypto.SSECKeyMD5))
|
|
|
|
|
|
|
|
|
|
if len(etag) >= 32 && strings.Count(etag, "-") != 1 {
|
|
|
|
|
etag = etag[len(etag)-32:]
|
2018-09-23 19:24:10 +02:00
|
|
|
|
}
|
2018-02-10 00:19:30 +01:00
|
|
|
|
}
|
2017-11-08 00:18:59 +01:00
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
// 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.
|
|
|
|
|
w.Header()[xhttp.ETag] = []string{`"` + etag + `"`}
|
2017-01-06 09:37:00 +01:00
|
|
|
|
writeSuccessResponseHeadersOnly(w)
|
2016-07-24 07:51:12 +02:00
|
|
|
|
|
2016-09-29 07:46:19 +02:00
|
|
|
|
// Notify object created event.
|
2018-03-15 21:03:41 +01:00
|
|
|
|
sendEvent(eventArgs{
|
2018-11-03 02:40:08 +01:00
|
|
|
|
EventName: event.ObjectCreatedPut,
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
2019-03-25 19:45:42 +01:00
|
|
|
|
Host: handlers.GetSourceIP(r),
|
2016-09-29 07:46:19 +02:00
|
|
|
|
})
|
2015-02-16 02:03:27 +01:00
|
|
|
|
}
|
2015-05-08 04:55:30 +02:00
|
|
|
|
|
2016-04-12 21:45:15 +02:00
|
|
|
|
/// Multipart objectAPIHandlers
|
2015-06-08 20:06:06 +02:00
|
|
|
|
|
2016-10-06 22:34:33 +02:00
|
|
|
|
// NewMultipartUploadHandler - New multipart upload.
|
2018-09-25 21:39:46 +02:00
|
|
|
|
// Notice: The S3 client can send secret keys in headers for encryption related jobs,
|
|
|
|
|
// the handler should ensure to remove these keys before sending them to the object layer.
|
|
|
|
|
// Currently these keys are:
|
|
|
|
|
// - X-Amz-Server-Side-Encryption-Customer-Key
|
|
|
|
|
// - X-Amz-Copy-Source-Server-Side-Encryption-Customer-Key
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) NewMultipartUploadHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "NewMultipartUpload")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "NewMultipartUpload", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-06-20 02:37:08 +02:00
|
|
|
|
if crypto.S3KMS.IsRequested(r.Header) && !api.AllowSSEKMS() {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r)) // SSE-KMS is not supported
|
2018-08-18 06:07:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if !api.EncryptionEnabled() && crypto.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
2018-12-15 06:39:59 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-18 06:07:19 +02:00
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2018-04-06 00:04:40 +02:00
|
|
|
|
|
2019-01-16 21:12:06 +01:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.PutObjectAction, bucket, object); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2019-01-16 21:12:06 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-02-05 10:42:34 +01:00
|
|
|
|
// Check if bucket encryption is enabled
|
|
|
|
|
_, encEnabled := globalBucketSSEConfigSys.Get(bucket)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
// This request header needs to be set prior to setting ObjectOptions
|
2020-02-05 10:42:34 +01:00
|
|
|
|
if (globalAutoEncryption || encEnabled) && !crypto.SSEC.IsRequested(r.Header) && !crypto.S3KMS.IsRequested(r.Header) {
|
2019-01-05 23:16:43 +01:00
|
|
|
|
r.Header.Add(crypto.SSEHeader, crypto.SSEAlgorithmAES256)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// get gateway encryption options
|
|
|
|
|
var opts ObjectOptions
|
|
|
|
|
|
2019-02-09 06:31:06 +01:00
|
|
|
|
opts, err = putOpts(ctx, r, bucket, object, nil)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-27 05:36:16 +01:00
|
|
|
|
// Validate storage class metadata if present
|
2019-10-07 07:50:24 +02:00
|
|
|
|
if sc := r.Header.Get(xhttp.AmzStorageClass); sc != "" {
|
|
|
|
|
if !storageclass.IsValid(sc) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidStorageClass), r.URL, guessIsBrowserReq(r))
|
2017-12-27 05:36:16 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-01 20:37:57 +01:00
|
|
|
|
var encMetadata = map[string]string{}
|
|
|
|
|
|
|
|
|
|
if objectAPI.IsEncryptionSupported() {
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if crypto.IsRequested(r.Header) {
|
2018-11-15 02:36:41 +01:00
|
|
|
|
if err = setEncryptionMetadata(r, bucket, object, encMetadata); err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-01 20:37:57 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
// Set this for multipart only operations, we need to differentiate during
|
|
|
|
|
// decryption if the file was actually multipart or not.
|
|
|
|
|
encMetadata[ReservedMetadataPrefix+"Encrypted-Multipart"] = ""
|
|
|
|
|
}
|
2017-11-08 00:18:59 +01:00
|
|
|
|
}
|
|
|
|
|
|
2016-07-23 05:31:45 +02:00
|
|
|
|
// Extract metadata that needs to be saved.
|
2018-07-11 05:27:10 +02:00
|
|
|
|
metadata, err := extractMetadata(ctx, r)
|
2017-07-06 01:56:10 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2017-07-06 01:56:10 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
retPerms := isPutActionAllowed(getRequestAuthType(r), bucket, object, r, iampolicy.PutObjectRetentionAction)
|
2020-01-17 00:41:56 +01:00
|
|
|
|
holdPerms := isPutActionAllowed(getRequestAuthType(r), bucket, object, r, iampolicy.PutObjectLegalHoldAction)
|
|
|
|
|
|
2020-04-06 22:44:16 +02:00
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
retentionMode, retentionDate, legalHold, s3Err := checkPutObjectLockAllowed(ctx, r, bucket, object, getObjectInfo, retPerms, holdPerms)
|
|
|
|
|
if s3Err == ErrNone && retentionMode.Valid() {
|
2019-11-20 22:18:09 +01:00
|
|
|
|
metadata[strings.ToLower(xhttp.AmzObjectLockMode)] = string(retentionMode)
|
|
|
|
|
metadata[strings.ToLower(xhttp.AmzObjectLockRetainUntilDate)] = retentionDate.UTC().Format(time.RFC3339)
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
if s3Err == ErrNone && legalHold.Status.Valid() {
|
2020-01-17 00:41:56 +01:00
|
|
|
|
metadata[strings.ToLower(xhttp.AmzObjectLockLegalHold)] = string(legalHold.Status)
|
|
|
|
|
}
|
2019-11-20 22:18:09 +01:00
|
|
|
|
if s3Err != ErrNone {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
2018-03-01 20:37:57 +01:00
|
|
|
|
// We need to preserve the encryption headers set in EncryptRequest,
|
|
|
|
|
// so we do not want to override them, copy them instead.
|
|
|
|
|
for k, v := range encMetadata {
|
|
|
|
|
metadata[k] = v
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-25 21:39:46 +02:00
|
|
|
|
// Ensure that metadata does not contain sensitive information
|
|
|
|
|
crypto.RemoveSensitiveEntries(metadata)
|
|
|
|
|
|
2018-09-28 05:36:17 +02:00
|
|
|
|
if objectAPI.IsCompressionSupported() && isCompressible(r.Header, object) {
|
|
|
|
|
// Storing the compression metadata.
|
2019-09-26 08:08:24 +02:00
|
|
|
|
metadata[ReservedMetadataPrefix+"compression"] = compressionAlgorithmV2
|
2018-09-28 05:36:17 +02:00
|
|
|
|
}
|
|
|
|
|
|
2019-02-09 06:31:06 +01:00
|
|
|
|
opts, err = putOpts(ctx, r, bucket, object, metadata)
|
|
|
|
|
if err != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeErrorResponseHeadersOnly(w, toAPIError(ctx, err))
|
2019-02-09 06:31:06 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-03-28 23:14:06 +02:00
|
|
|
|
newMultipartUpload := objectAPI.NewMultipartUpload
|
2019-08-10 02:09:08 +02:00
|
|
|
|
|
2019-02-09 06:31:06 +01:00
|
|
|
|
uploadID, err := newMultipartUpload(ctx, bucket, object, opts)
|
2015-09-19 12:20:07 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2015-08-04 01:17:21 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2015-09-19 12:20:07 +02:00
|
|
|
|
|
|
|
|
|
response := generateInitiateMultipartUploadResponse(bucket, object, uploadID)
|
2016-03-06 21:16:22 +01:00
|
|
|
|
encodedSuccessResponse := encodeResponse(response)
|
2017-01-06 09:37:00 +01:00
|
|
|
|
|
|
|
|
|
// Write success response.
|
|
|
|
|
writeSuccessResponseXML(w, encodedSuccessResponse)
|
2015-05-08 04:55:30 +02:00
|
|
|
|
}
|
|
|
|
|
|
2017-01-31 18:38:34 +01:00
|
|
|
|
// CopyObjectPartHandler - uploads a part by copying data from an existing object as data source.
|
|
|
|
|
func (api objectAPIHandlers) CopyObjectPartHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "CopyObjectPart")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "CopyObjectPart", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2017-01-31 18:38:34 +01:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2017-01-31 18:38:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-10-10 00:04:53 +02:00
|
|
|
|
if crypto.S3KMS.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r)) // SSE-KMS is not supported
|
2018-08-18 06:07:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if !api.EncryptionEnabled() && crypto.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
2018-12-15 06:39:59 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-18 06:07:19 +02:00
|
|
|
|
|
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
dstBucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
dstObject, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2017-01-31 18:38:34 +01:00
|
|
|
|
|
2018-04-25 00:53:30 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.PutObjectAction, dstBucket, dstObject); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2017-01-31 18:38:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-10 22:10:10 +01:00
|
|
|
|
// Read escaped copy source path to check for parameters.
|
2019-07-03 07:34:32 +02:00
|
|
|
|
cpSrcPath := r.Header.Get(xhttp.AmzCopySource)
|
2017-01-31 18:38:34 +01:00
|
|
|
|
|
2018-12-14 07:04:37 +01:00
|
|
|
|
// Check https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html
|
|
|
|
|
// Regardless of whether you have enabled versioning, each object in your bucket
|
|
|
|
|
// has a version ID. If you have not enabled versioning, Amazon S3 sets the value
|
|
|
|
|
// of the version ID to null. If you have enabled versioning, Amazon S3 assigns a
|
|
|
|
|
// unique version ID value for the object.
|
|
|
|
|
if u, err := url.Parse(cpSrcPath); err == nil {
|
|
|
|
|
// Check if versionId query param was added, if yes then check if
|
|
|
|
|
// its non "null" value, we should error out since we do not support
|
|
|
|
|
// any versions other than "null".
|
|
|
|
|
if vid := u.Query().Get("versionId"); vid != "" && vid != "null" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
2018-12-14 07:04:37 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-01-10 22:10:10 +01:00
|
|
|
|
// Note that url.Parse does the unescaping
|
2018-12-14 07:04:37 +01:00
|
|
|
|
cpSrcPath = u.Path
|
|
|
|
|
}
|
2019-07-03 07:34:32 +02:00
|
|
|
|
if vid := r.Header.Get(xhttp.AmzCopySourceVersionID); vid != "" {
|
2019-01-10 22:10:10 +01:00
|
|
|
|
// Check if X-Amz-Copy-Source-Version-Id header was added, if yes then check if
|
|
|
|
|
// its non "null" value, we should error out since we do not support
|
|
|
|
|
// any versions other than "null".
|
|
|
|
|
if vid != "null" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
2019-01-10 22:10:10 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-12-14 07:04:37 +01:00
|
|
|
|
|
2020-01-21 23:07:49 +01:00
|
|
|
|
srcBucket, srcObject := path2BucketObject(cpSrcPath)
|
2017-01-31 18:38:34 +01:00
|
|
|
|
// If source object is empty or bucket is empty, reply back invalid copy source.
|
|
|
|
|
if srcObject == "" || srcBucket == "" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidCopySource), r.URL, guessIsBrowserReq(r))
|
2017-01-31 18:38:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-27 01:12:44 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.GetObjectAction, srcBucket, srcObject); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2018-10-27 01:12:44 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-31 18:38:34 +01:00
|
|
|
|
uploadID := r.URL.Query().Get("uploadId")
|
|
|
|
|
partIDString := r.URL.Query().Get("partNumber")
|
|
|
|
|
|
|
|
|
|
partID, err := strconv.Atoi(partIDString)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidPart), r.URL, guessIsBrowserReq(r))
|
2017-01-31 18:38:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// check partID with maximum part ID for multipart objects
|
|
|
|
|
if isMaxPartID(partID) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidMaxParts), r.URL, guessIsBrowserReq(r))
|
2017-01-31 18:38:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-11-15 02:36:41 +01:00
|
|
|
|
|
2018-09-10 18:42:43 +02:00
|
|
|
|
var srcOpts, dstOpts ObjectOptions
|
2019-02-09 06:31:06 +01:00
|
|
|
|
srcOpts, err = copySrcOpts(ctx, r, srcBucket, srcObject)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
// convert copy src and dst encryption options for GET/PUT calls
|
|
|
|
|
var getOpts = ObjectOptions{}
|
|
|
|
|
if srcOpts.ServerSideEncryption != nil {
|
|
|
|
|
getOpts.ServerSideEncryption = encrypt.SSE(srcOpts.ServerSideEncryption)
|
|
|
|
|
}
|
2019-02-09 06:31:06 +01:00
|
|
|
|
dstOpts, err = copyDstOpts(ctx, r, dstBucket, dstObject, nil)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2017-01-31 18:38:34 +01:00
|
|
|
|
|
2018-09-25 21:39:46 +02:00
|
|
|
|
getObjectNInfo := objectAPI.GetObjectNInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectNInfo = api.CacheAPI().GetObjectNInfo
|
2018-03-01 20:37:57 +01:00
|
|
|
|
}
|
|
|
|
|
|
2017-01-31 18:38:34 +01:00
|
|
|
|
// Get request range.
|
2018-09-25 21:39:46 +02:00
|
|
|
|
var rs *HTTPRangeSpec
|
2019-07-03 07:34:32 +02:00
|
|
|
|
rangeHeader := r.Header.Get(xhttp.AmzCopySourceRange)
|
2018-09-25 21:39:46 +02:00
|
|
|
|
if rangeHeader != "" {
|
|
|
|
|
var parseRangeErr error
|
|
|
|
|
if rs, parseRangeErr = parseCopyPartRangeSpec(rangeHeader); parseRangeErr != nil {
|
|
|
|
|
// Handle only errInvalidRange
|
|
|
|
|
// Ignore other parse error and treat it as regular Get request like Amazon S3.
|
|
|
|
|
logger.GetReqInfo(ctx).AppendTags("rangeHeader", rangeHeader)
|
|
|
|
|
logger.LogIf(ctx, parseRangeErr)
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeCopyPartErr(ctx, w, parseRangeErr, r.URL, guessIsBrowserReq(r))
|
2018-09-25 21:39:46 +02:00
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-03-06 21:38:41 +01:00
|
|
|
|
checkCopyPartPrecondFn := func(o ObjectInfo, encETag string) bool {
|
|
|
|
|
return checkCopyObjectPartPreconditions(ctx, w, r, o, encETag)
|
|
|
|
|
}
|
|
|
|
|
getOpts.CheckCopyPrecondFn = checkCopyPartPrecondFn
|
|
|
|
|
srcOpts.CheckCopyPrecondFn = checkCopyPartPrecondFn
|
2018-09-25 21:39:46 +02:00
|
|
|
|
|
2019-01-05 23:16:43 +01:00
|
|
|
|
gr, err := getObjectNInfo(ctx, srcBucket, srcObject, rs, r.Header, readLock, getOpts)
|
2018-09-25 21:39:46 +02:00
|
|
|
|
if err != nil {
|
2019-03-06 21:38:41 +01:00
|
|
|
|
if isErrPreconditionFailed(err) {
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-09-25 21:39:46 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
defer gr.Close()
|
|
|
|
|
srcInfo := gr.ObjInfo
|
|
|
|
|
|
2018-10-22 23:23:23 +02:00
|
|
|
|
actualPartSize := srcInfo.Size
|
|
|
|
|
if crypto.IsEncrypted(srcInfo.UserDefined) {
|
|
|
|
|
actualPartSize, err = srcInfo.DecryptedSize()
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-10-22 23:23:23 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-05-01 00:55:54 +02:00
|
|
|
|
if err := enforceBucketQuota(ctx, dstBucket, actualPartSize); err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2018-09-25 21:39:46 +02:00
|
|
|
|
// Special care for CopyObjectPart
|
2018-10-22 23:23:23 +02:00
|
|
|
|
if partRangeErr := checkCopyPartRangeWithSize(rs, actualPartSize); partRangeErr != nil {
|
2019-02-12 10:25:52 +01:00
|
|
|
|
writeCopyPartErr(ctx, w, partRangeErr, r.URL, guessIsBrowserReq(r))
|
2018-09-21 04:22:09 +02:00
|
|
|
|
return
|
2017-01-31 18:38:34 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-09-25 21:39:46 +02:00
|
|
|
|
// Get the object offset & length
|
2018-10-25 17:50:06 +02:00
|
|
|
|
startOffset, length, err := rs.GetOffsetLength(actualPartSize)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-10-25 17:50:06 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-09-28 05:36:17 +02:00
|
|
|
|
|
2017-01-31 18:38:34 +01:00
|
|
|
|
/// maximum copy size for multipart objects in a single operation
|
2017-03-03 19:14:17 +01:00
|
|
|
|
if isMaxAllowedPartSize(length) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrEntityTooLarge), r.URL, guessIsBrowserReq(r))
|
2017-01-31 18:38:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-20 19:19:22 +02:00
|
|
|
|
if isRemoteCopyRequired(ctx, srcBucket, dstBucket, objectAPI) {
|
|
|
|
|
var dstRecords []dns.SrvRecord
|
|
|
|
|
dstRecords, err = globalDNSConfig.Get(dstBucket)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Send PutObject request to appropriate instance (in federated deployment)
|
|
|
|
|
client, rerr := getRemoteInstanceClient(r, getHostFromSrv(dstRecords))
|
|
|
|
|
if rerr != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, rerr), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
partInfo, err := client.PutObjectPart(dstBucket, dstObject, uploadID, partID,
|
|
|
|
|
srcInfo.Reader, srcInfo.Size, "", "", dstOpts.ServerSideEncryption)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
response := generateCopyObjectPartResponse(partInfo.ETag, partInfo.LastModified)
|
|
|
|
|
encodedSuccessResponse := encodeResponse(response)
|
|
|
|
|
|
|
|
|
|
// Write success response.
|
|
|
|
|
writeSuccessResponseXML(w, encodedSuccessResponse)
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-25 17:50:06 +02:00
|
|
|
|
actualPartSize = length
|
2018-09-28 05:36:17 +02:00
|
|
|
|
var reader io.Reader
|
|
|
|
|
|
2018-10-23 20:46:20 +02:00
|
|
|
|
var li ListPartsInfo
|
2019-01-05 23:16:43 +01:00
|
|
|
|
li, err = objectAPI.ListObjectParts(ctx, dstBucket, dstObject, uploadID, 0, 1, dstOpts)
|
2018-10-23 20:46:20 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-10-23 20:46:20 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-10-25 17:50:06 +02:00
|
|
|
|
|
2018-10-23 20:46:20 +02:00
|
|
|
|
// Read compression metadata preserved in the init multipart for the decision.
|
|
|
|
|
_, compressPart := li.UserDefined[ReservedMetadataPrefix+"compression"]
|
|
|
|
|
isCompressed := compressPart
|
|
|
|
|
// Compress only if the compression is enabled during initial multipart.
|
|
|
|
|
if isCompressed {
|
2019-09-26 08:08:24 +02:00
|
|
|
|
s2c := newS2CompressReader(gr)
|
|
|
|
|
defer s2c.Close()
|
|
|
|
|
reader = s2c
|
2018-09-28 05:36:17 +02:00
|
|
|
|
length = -1
|
|
|
|
|
} else {
|
|
|
|
|
reader = gr
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-09 03:35:40 +02:00
|
|
|
|
srcInfo.Reader, err = hash.NewReader(reader, length, "", "", actualPartSize, globalCLIContext.StrictS3Compat)
|
2018-03-03 02:24:02 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-03 02:24:02 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-09-28 05:36:17 +02:00
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
rawReader := srcInfo.Reader
|
|
|
|
|
pReader := NewPutObjReader(rawReader, nil, nil)
|
|
|
|
|
|
|
|
|
|
isEncrypted := false
|
2020-04-10 02:01:45 +02:00
|
|
|
|
var objectEncryptionKey crypto.ObjectKey
|
2018-10-23 20:46:20 +02:00
|
|
|
|
if objectAPI.IsEncryptionSupported() && !isCompressed {
|
2019-01-05 23:16:43 +01:00
|
|
|
|
li, lerr := objectAPI.ListObjectParts(ctx, dstBucket, dstObject, uploadID, 0, 1, dstOpts)
|
|
|
|
|
if lerr != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, lerr), r.URL, guessIsBrowserReq(r))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
li.UserDefined = CleanMinioInternalMetadataKeys(li.UserDefined)
|
2019-02-09 06:31:06 +01:00
|
|
|
|
dstOpts, err = copyDstOpts(ctx, r, dstBucket, dstObject, li.UserDefined)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-17 21:52:14 +02:00
|
|
|
|
if crypto.IsEncrypted(li.UserDefined) {
|
2018-10-25 17:50:06 +02:00
|
|
|
|
if !crypto.SSEC.IsRequested(r.Header) && crypto.SSEC.IsEncrypted(li.UserDefined) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrSSEMultipartEncrypted), r.URL, guessIsBrowserReq(r))
|
2018-10-29 14:40:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if crypto.S3.IsEncrypted(li.UserDefined) && crypto.SSEC.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrSSEMultipartEncrypted), r.URL, guessIsBrowserReq(r))
|
2018-09-21 04:22:09 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-02-05 22:36:38 +01:00
|
|
|
|
isEncrypted = true
|
2018-03-01 20:37:57 +01:00
|
|
|
|
var key []byte
|
2018-08-17 21:52:14 +02:00
|
|
|
|
if crypto.SSEC.IsRequested(r.Header) {
|
|
|
|
|
key, err = ParseSSECustomerRequest(r)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-08-17 21:52:14 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-03-01 20:37:57 +01:00
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
key, err = decryptObjectInfo(key, dstBucket, dstObject, li.UserDefined)
|
2018-03-01 20:37:57 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-01 20:37:57 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
copy(objectEncryptionKey[:], key)
|
2018-03-01 20:37:57 +01:00
|
|
|
|
|
2020-04-10 02:01:45 +02:00
|
|
|
|
partEncryptionKey := objectEncryptionKey.DerivePartKey(uint32(partID))
|
|
|
|
|
reader, err = sio.EncryptReader(reader, sio.Config{Key: partEncryptionKey[:]})
|
2018-03-01 20:37:57 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-01 20:37:57 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-07-12 20:23:32 +02:00
|
|
|
|
info := ObjectInfo{Size: length}
|
2019-05-09 03:35:40 +02:00
|
|
|
|
srcInfo.Reader, err = hash.NewReader(reader, info.EncryptedSize(), "", "", length, globalCLIContext.StrictS3Compat)
|
2018-03-01 20:37:57 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-01 20:37:57 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
pReader = NewPutObjReader(rawReader, srcInfo.Reader, &objectEncryptionKey)
|
2018-03-01 20:37:57 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2018-11-15 02:36:41 +01:00
|
|
|
|
srcInfo.PutObjReader = pReader
|
2017-01-31 18:38:34 +01:00
|
|
|
|
// Copy source object to destination, if source and destination
|
|
|
|
|
// object is same then only metadata is updated.
|
2018-10-25 17:50:06 +02:00
|
|
|
|
partInfo, err := objectAPI.CopyObjectPart(ctx, srcBucket, srcObject, dstBucket, dstObject, uploadID, partID,
|
|
|
|
|
startOffset, length, srcInfo, srcOpts, dstOpts)
|
2017-01-31 18:38:34 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2017-01-31 18:38:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
if isEncrypted {
|
2020-04-10 02:01:45 +02:00
|
|
|
|
partInfo.ETag = tryDecryptETag(objectEncryptionKey[:], partInfo.ETag, crypto.SSEC.IsRequested(r.Header))
|
2018-11-15 02:36:41 +01:00
|
|
|
|
}
|
|
|
|
|
|
2017-01-31 18:38:34 +01:00
|
|
|
|
response := generateCopyObjectPartResponse(partInfo.ETag, partInfo.LastModified)
|
|
|
|
|
encodedSuccessResponse := encodeResponse(response)
|
|
|
|
|
|
|
|
|
|
// Write success response.
|
|
|
|
|
writeSuccessResponseXML(w, encodedSuccessResponse)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// PutObjectPartHandler - uploads an incoming part for an ongoing multipart operation.
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) PutObjectPartHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "PutObjectPart")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "PutObjectPart", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-10-10 00:04:53 +02:00
|
|
|
|
if crypto.S3KMS.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r)) // SSE-KMS is not supported
|
2018-08-18 06:07:19 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-09-20 23:56:12 +02:00
|
|
|
|
if !api.EncryptionEnabled() && crypto.IsRequested(r.Header) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNotImplemented), r.URL, guessIsBrowserReq(r))
|
2018-12-15 06:39:59 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-08-18 06:07:19 +02:00
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2016-08-11 03:47:49 +02:00
|
|
|
|
|
2020-02-25 16:52:28 +01:00
|
|
|
|
// To detect if the client has disconnected.
|
|
|
|
|
r.Body = &detectDisconnect{r.Body, r.Context().Done()}
|
|
|
|
|
|
2017-03-04 01:32:04 +01:00
|
|
|
|
// X-Amz-Copy-Source shouldn't be set for this call.
|
2019-07-03 07:34:32 +02:00
|
|
|
|
if _, ok := r.Header[xhttp.AmzCopySource]; ok {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidCopySource), r.URL, guessIsBrowserReq(r))
|
2017-03-04 01:32:04 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2016-03-06 01:43:48 +01:00
|
|
|
|
// get Content-Md5 sent by client and verify if valid
|
2018-03-16 19:22:34 +01:00
|
|
|
|
md5Bytes, err := checkValidMD5(r.Header)
|
2016-03-13 01:08:15 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidDigest), r.URL, guessIsBrowserReq(r))
|
2015-10-17 04:09:35 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-28 08:00:36 +01:00
|
|
|
|
/// if Content-Length is unknown/missing, throw away
|
2016-02-16 02:42:39 +01:00
|
|
|
|
size := r.ContentLength
|
2016-08-09 05:56:29 +02:00
|
|
|
|
|
|
|
|
|
rAuthType := getRequestAuthType(r)
|
|
|
|
|
// For auth type streaming signature, we need to gather a different content length.
|
|
|
|
|
if rAuthType == authTypeStreamingSigned {
|
2019-07-03 07:34:32 +02:00
|
|
|
|
if sizeStr, ok := r.Header[xhttp.AmzDecodedContentLength]; ok {
|
2018-03-16 19:22:34 +01:00
|
|
|
|
if sizeStr[0] == "" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentLength), r.URL, guessIsBrowserReq(r))
|
2018-03-16 19:22:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
size, err = strconv.ParseInt(sizeStr[0], 10, 64)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-16 19:22:34 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-08-09 05:56:29 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2015-12-28 08:00:36 +01:00
|
|
|
|
if size == -1 {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentLength), r.URL, guessIsBrowserReq(r))
|
2015-12-28 08:00:36 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-08 07:43:19 +02:00
|
|
|
|
/// maximum Upload size for multipart objects in a single operation
|
2017-03-03 19:14:17 +01:00
|
|
|
|
if isMaxAllowedPartSize(size) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrEntityTooLarge), r.URL, guessIsBrowserReq(r))
|
2015-05-08 04:55:30 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2015-05-01 01:29:03 +02:00
|
|
|
|
|
2016-02-16 02:42:39 +01:00
|
|
|
|
uploadID := r.URL.Query().Get("uploadId")
|
|
|
|
|
partIDString := r.URL.Query().Get("partNumber")
|
2015-05-10 04:39:00 +02:00
|
|
|
|
|
2016-04-29 23:24:10 +02:00
|
|
|
|
partID, err := strconv.Atoi(partIDString)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidPart), r.URL, guessIsBrowserReq(r))
|
2016-03-02 20:22:58 +01:00
|
|
|
|
return
|
2015-05-08 04:55:30 +02:00
|
|
|
|
}
|
2015-07-03 05:31:22 +02:00
|
|
|
|
|
2016-05-24 10:52:47 +02:00
|
|
|
|
// check partID with maximum part ID for multipart objects
|
|
|
|
|
if isMaxPartID(partID) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidMaxParts), r.URL, guessIsBrowserReq(r))
|
2016-05-24 10:52:47 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-22 07:30:34 +02:00
|
|
|
|
var (
|
|
|
|
|
md5hex = hex.EncodeToString(md5Bytes)
|
|
|
|
|
sha256hex = ""
|
2018-03-01 20:37:57 +01:00
|
|
|
|
reader io.Reader
|
2018-10-09 23:00:01 +02:00
|
|
|
|
s3Error APIErrorCode
|
2017-10-22 07:30:34 +02:00
|
|
|
|
)
|
2018-03-01 20:37:57 +01:00
|
|
|
|
reader = r.Body
|
2019-11-20 22:18:09 +01:00
|
|
|
|
if s3Error = isPutActionAllowed(rAuthType, bucket, object, r, iampolicy.PutObjectAction); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2018-10-09 23:00:01 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2016-08-09 05:56:29 +02:00
|
|
|
|
switch rAuthType {
|
|
|
|
|
case authTypeStreamingSigned:
|
|
|
|
|
// Initialize stream signature verifier.
|
2017-10-22 07:30:34 +02:00
|
|
|
|
reader, s3Error = newSignV4ChunkedReader(r)
|
2016-08-09 05:56:29 +02:00
|
|
|
|
if s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2016-08-09 05:56:29 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-09-30 23:32:13 +02:00
|
|
|
|
case authTypeSignedV2, authTypePresignedV2:
|
2018-10-09 23:00:01 +02:00
|
|
|
|
if s3Error = isReqAuthenticatedV2(r); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2016-09-30 23:32:13 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-04-07 12:04:18 +02:00
|
|
|
|
case authTypePresigned, authTypeSigned:
|
2019-10-23 07:59:13 +02:00
|
|
|
|
if s3Error = reqSignatureV4Verify(r, globalServerRegion, serviceS3); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2016-10-03 00:51:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if !skipContentSha256Cksum(r) {
|
2019-02-28 02:46:55 +01:00
|
|
|
|
sha256hex = getContentSha256Cksum(r, serviceS3)
|
2016-10-03 00:51:49 +02:00
|
|
|
|
}
|
2016-02-17 03:50:36 +01:00
|
|
|
|
}
|
2017-10-22 07:30:34 +02:00
|
|
|
|
|
2020-05-01 00:55:54 +02:00
|
|
|
|
if err := enforceBucketQuota(ctx, bucket, size); err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-28 05:36:17 +02:00
|
|
|
|
actualSize := size
|
|
|
|
|
|
2019-01-05 23:16:43 +01:00
|
|
|
|
// get encryption options
|
|
|
|
|
var opts ObjectOptions
|
|
|
|
|
if crypto.SSEC.IsRequested(r.Header) {
|
2019-02-09 06:31:06 +01:00
|
|
|
|
opts, err = putOpts(ctx, r, bucket, object, nil)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
2018-09-28 05:36:17 +02:00
|
|
|
|
var li ListPartsInfo
|
2019-01-05 23:16:43 +01:00
|
|
|
|
li, err = objectAPI.ListObjectParts(ctx, bucket, object, uploadID, 0, 1, opts)
|
2018-09-28 05:36:17 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-09-28 05:36:17 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
// Read compression metadata preserved in the init multipart for the decision.
|
|
|
|
|
_, compressPart := li.UserDefined[ReservedMetadataPrefix+"compression"]
|
|
|
|
|
|
|
|
|
|
isCompressed := false
|
|
|
|
|
if objectAPI.IsCompressionSupported() && compressPart {
|
2019-05-09 03:35:40 +02:00
|
|
|
|
actualReader, err := hash.NewReader(reader, size, md5hex, sha256hex, actualSize, globalCLIContext.StrictS3Compat)
|
2018-09-28 05:36:17 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-09-28 05:36:17 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-09-28 09:44:59 +02:00
|
|
|
|
|
2018-09-28 05:36:17 +02:00
|
|
|
|
// Set compression metrics.
|
2019-09-26 08:08:24 +02:00
|
|
|
|
s2c := newS2CompressReader(actualReader)
|
|
|
|
|
defer s2c.Close()
|
|
|
|
|
reader = s2c
|
2018-09-28 05:36:17 +02:00
|
|
|
|
size = -1 // Since compressed size is un-predictable.
|
|
|
|
|
md5hex = "" // Do not try to verify the content.
|
|
|
|
|
sha256hex = ""
|
|
|
|
|
isCompressed = true
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-09 03:35:40 +02:00
|
|
|
|
hashReader, err := hash.NewReader(reader, size, md5hex, sha256hex, actualSize, globalCLIContext.StrictS3Compat)
|
2017-10-22 07:30:34 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2017-10-22 07:30:34 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-11-15 02:36:41 +01:00
|
|
|
|
rawReader := hashReader
|
|
|
|
|
pReader := NewPutObjReader(rawReader, nil, nil)
|
|
|
|
|
|
2018-10-19 01:05:05 +02:00
|
|
|
|
isEncrypted := false
|
2020-04-10 02:01:45 +02:00
|
|
|
|
var objectEncryptionKey crypto.ObjectKey
|
2018-09-28 05:36:17 +02:00
|
|
|
|
if objectAPI.IsEncryptionSupported() && !isCompressed {
|
2018-03-01 20:37:57 +01:00
|
|
|
|
var li ListPartsInfo
|
2019-01-05 23:16:43 +01:00
|
|
|
|
li, err = objectAPI.ListObjectParts(ctx, bucket, object, uploadID, 0, 1, ObjectOptions{})
|
2018-03-01 20:37:57 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-01 20:37:57 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-01-05 23:16:43 +01:00
|
|
|
|
li.UserDefined = CleanMinioInternalMetadataKeys(li.UserDefined)
|
2018-08-17 21:52:14 +02:00
|
|
|
|
if crypto.IsEncrypted(li.UserDefined) {
|
2018-10-19 01:05:05 +02:00
|
|
|
|
if !crypto.SSEC.IsRequested(r.Header) && crypto.SSEC.IsEncrypted(li.UserDefined) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrSSEMultipartEncrypted), r.URL, guessIsBrowserReq(r))
|
2018-09-21 04:22:09 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-01-05 23:16:43 +01:00
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
isEncrypted = true // to detect SSE-S3 encryption
|
2019-02-09 06:31:06 +01:00
|
|
|
|
opts, err = putOpts(ctx, r, bucket, object, li.UserDefined)
|
2019-01-05 23:16:43 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2019-01-05 23:16:43 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-01 20:37:57 +01:00
|
|
|
|
var key []byte
|
2018-08-17 21:52:14 +02:00
|
|
|
|
if crypto.SSEC.IsRequested(r.Header) {
|
|
|
|
|
key, err = ParseSSECustomerRequest(r)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-08-17 21:52:14 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-03-01 20:37:57 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Calculating object encryption key
|
2020-04-10 02:01:45 +02:00
|
|
|
|
key, err = decryptObjectInfo(key, bucket, object, li.UserDefined)
|
2018-03-01 20:37:57 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-01 20:37:57 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
copy(objectEncryptionKey[:], key)
|
2018-03-01 20:37:57 +01:00
|
|
|
|
|
2020-04-10 02:01:45 +02:00
|
|
|
|
partEncryptionKey := objectEncryptionKey.DerivePartKey(uint32(partID))
|
2019-12-12 19:01:15 +01:00
|
|
|
|
in := io.Reader(hashReader)
|
|
|
|
|
if size > encryptBufferThreshold {
|
|
|
|
|
// The encryption reads in blocks of 64KB.
|
|
|
|
|
// We add a buffer on bigger files to reduce the number of syscalls upstream.
|
|
|
|
|
in = bufio.NewReaderSize(hashReader, encryptBufferSize)
|
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
reader, err = sio.EncryptReader(in, sio.Config{Key: partEncryptionKey[:]})
|
2018-03-01 20:37:57 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-01 20:37:57 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
info := ObjectInfo{Size: size}
|
2019-05-09 03:35:40 +02:00
|
|
|
|
// do not try to verify encrypted content
|
|
|
|
|
hashReader, err = hash.NewReader(reader, info.EncryptedSize(), "", "", size, globalCLIContext.StrictS3Compat)
|
2018-03-01 20:37:57 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-03-01 20:37:57 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-10 02:01:45 +02:00
|
|
|
|
pReader = NewPutObjReader(rawReader, hashReader, &objectEncryptionKey)
|
2018-03-01 20:37:57 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-28 23:14:06 +02:00
|
|
|
|
putObjectPart := objectAPI.PutObjectPart
|
2019-08-10 02:09:08 +02:00
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
partInfo, err := putObjectPart(ctx, bucket, object, uploadID, partID, pReader, opts)
|
2015-09-19 12:20:07 +02:00
|
|
|
|
if err != nil {
|
2016-03-13 01:08:15 +01:00
|
|
|
|
// Verify if the underlying error is signature mismatch.
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2015-08-04 01:17:21 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-12-19 23:12:53 +01:00
|
|
|
|
|
|
|
|
|
etag := partInfo.ETag
|
2019-05-09 03:35:40 +02:00
|
|
|
|
if isEncrypted {
|
2020-04-10 02:01:45 +02:00
|
|
|
|
etag = tryDecryptETag(objectEncryptionKey[:], partInfo.ETag, crypto.SSEC.IsRequested(r.Header))
|
2016-02-01 21:19:54 +01:00
|
|
|
|
}
|
2019-07-03 07:34:32 +02:00
|
|
|
|
w.Header()[xhttp.ETag] = []string{"\"" + etag + "\""}
|
2017-01-06 09:37:00 +01:00
|
|
|
|
|
|
|
|
|
writeSuccessResponseHeadersOnly(w)
|
2015-05-08 04:55:30 +02:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-01 05:15:48 +02:00
|
|
|
|
// AbortMultipartUploadHandler - Abort multipart upload
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) AbortMultipartUploadHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "AbortMultipartUpload")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "AbortMultipartUpload", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-02-16 02:42:39 +01:00
|
|
|
|
vars := mux.Vars(r)
|
2015-05-10 01:06:35 +02:00
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2015-05-10 01:06:35 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-03-28 23:14:06 +02:00
|
|
|
|
abortMultipartUpload := objectAPI.AbortMultipartUpload
|
2018-04-25 00:53:30 +02:00
|
|
|
|
|
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.AbortMultipartUploadAction, bucket, object); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2016-03-13 01:08:15 +01:00
|
|
|
|
return
|
2016-02-16 02:42:39 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-10-18 16:31:46 +02:00
|
|
|
|
uploadID, _, _, _, s3Error := getObjectResources(r.URL.Query())
|
|
|
|
|
if s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2018-10-18 16:31:46 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-03-28 23:14:06 +02:00
|
|
|
|
if err := abortMultipartUpload(ctx, bucket, object, uploadID); err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2015-08-04 01:17:21 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-11-03 02:40:08 +01:00
|
|
|
|
|
2015-10-17 05:02:37 +02:00
|
|
|
|
writeSuccessNoContent(w)
|
2015-05-10 01:06:35 +02:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-01 05:15:48 +02:00
|
|
|
|
// ListObjectPartsHandler - List object parts
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) ListObjectPartsHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "ListObjectParts")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "ListObjectParts", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-02-16 02:42:39 +01:00
|
|
|
|
vars := mux.Vars(r)
|
2015-10-17 04:09:35 +02:00
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2015-10-17 04:09:35 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-25 00:53:30 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.ListMultipartUploadPartsAction, bucket, object); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2016-03-13 01:08:15 +01:00
|
|
|
|
return
|
2016-02-16 02:42:39 +01:00
|
|
|
|
}
|
|
|
|
|
|
2019-02-24 07:14:24 +01:00
|
|
|
|
uploadID, partNumberMarker, maxParts, encodingType, s3Error := getObjectResources(r.URL.Query())
|
2018-10-18 16:31:46 +02:00
|
|
|
|
if s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2018-10-18 16:31:46 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 10:34:20 +02:00
|
|
|
|
if partNumberMarker < 0 {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidPartNumberMarker), r.URL, guessIsBrowserReq(r))
|
2015-07-17 02:22:45 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 10:34:20 +02:00
|
|
|
|
if maxParts < 0 {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidMaxParts), r.URL, guessIsBrowserReq(r))
|
2015-07-17 02:22:45 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2019-01-05 23:16:43 +01:00
|
|
|
|
var opts ObjectOptions
|
|
|
|
|
listPartsInfo, err := objectAPI.ListObjectParts(ctx, bucket, object, uploadID, partNumberMarker, maxParts, opts)
|
2015-09-19 12:20:07 +02:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2015-08-04 01:17:21 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2018-11-15 02:36:41 +01:00
|
|
|
|
var ssec bool
|
|
|
|
|
if objectAPI.IsEncryptionSupported() {
|
|
|
|
|
var li ListPartsInfo
|
2019-01-05 23:16:43 +01:00
|
|
|
|
li, err = objectAPI.ListObjectParts(ctx, bucket, object, uploadID, 0, 1, opts)
|
2018-11-15 02:36:41 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-11-15 02:36:41 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if crypto.IsEncrypted(li.UserDefined) {
|
|
|
|
|
var key []byte
|
|
|
|
|
if crypto.SSEC.IsEncrypted(li.UserDefined) {
|
|
|
|
|
ssec = true
|
|
|
|
|
}
|
|
|
|
|
var objectEncryptionKey []byte
|
|
|
|
|
if crypto.S3.IsEncrypted(li.UserDefined) {
|
|
|
|
|
// Calculating object encryption key
|
|
|
|
|
objectEncryptionKey, err = decryptObjectInfo(key, bucket, object, li.UserDefined)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-11-15 02:36:41 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
parts := make([]PartInfo, len(listPartsInfo.Parts))
|
|
|
|
|
for i, p := range listPartsInfo.Parts {
|
|
|
|
|
part := p
|
|
|
|
|
part.ETag = tryDecryptETag(objectEncryptionKey, p.ETag, ssec)
|
|
|
|
|
parts[i] = part
|
|
|
|
|
}
|
|
|
|
|
listPartsInfo.Parts = parts
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-24 07:14:24 +01:00
|
|
|
|
response := generateListPartsResponse(listPartsInfo, encodingType)
|
2016-03-06 21:16:22 +01:00
|
|
|
|
encodedSuccessResponse := encodeResponse(response)
|
2017-01-06 09:37:00 +01:00
|
|
|
|
|
accessPolicy: Implement Put, Get, Delete access policy.
This patch implements Get,Put,Delete bucket policies
Supporting - http://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html
Currently supports following actions.
"*": true,
"s3:*": true,
"s3:GetObject": true,
"s3:ListBucket": true,
"s3:PutObject": true,
"s3:CreateBucket": true,
"s3:GetBucketLocation": true,
"s3:DeleteBucket": true,
"s3:DeleteObject": true,
"s3:AbortMultipartUpload": true,
"s3:ListBucketMultipartUploads": true,
"s3:ListMultipartUploadParts": true,
following conditions for "StringEquals" and "StringNotEquals"
"s3:prefix", "s3:max-keys"
2016-02-04 01:46:56 +01:00
|
|
|
|
// Write success response.
|
2017-01-06 09:37:00 +01:00
|
|
|
|
writeSuccessResponseXML(w, encodedSuccessResponse)
|
2015-05-09 20:41:26 +02:00
|
|
|
|
}
|
|
|
|
|
|
2019-02-21 07:20:15 +01:00
|
|
|
|
type whiteSpaceWriter struct {
|
|
|
|
|
http.ResponseWriter
|
|
|
|
|
http.Flusher
|
|
|
|
|
written bool
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (w *whiteSpaceWriter) Write(b []byte) (n int, err error) {
|
|
|
|
|
n, err = w.ResponseWriter.Write(b)
|
|
|
|
|
w.written = true
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (w *whiteSpaceWriter) WriteHeader(statusCode int) {
|
|
|
|
|
if !w.written {
|
|
|
|
|
w.ResponseWriter.WriteHeader(statusCode)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Send empty whitespaces every 10 seconds to the client till completeMultiPartUpload() is
|
|
|
|
|
// done so that the client does not time out. Downside is we might send 200 OK and
|
|
|
|
|
// then send error XML. But accoording to S3 spec the client is supposed to check
|
|
|
|
|
// for error XML even if it received 200 OK. But for erasure this is not a problem
|
|
|
|
|
// as completeMultiPartUpload() is quick. Even For FS, it would not be an issue as
|
|
|
|
|
// we do background append as and when the parts arrive and completeMultiPartUpload
|
|
|
|
|
// is quick. Only in a rare case where parts would be out of order will
|
|
|
|
|
// FS:completeMultiPartUpload() take a longer time.
|
2019-10-16 03:35:41 +02:00
|
|
|
|
func sendWhiteSpace(w http.ResponseWriter) <-chan bool {
|
2019-02-21 07:20:15 +01:00
|
|
|
|
doneCh := make(chan bool)
|
2019-02-06 05:58:09 +01:00
|
|
|
|
go func() {
|
|
|
|
|
ticker := time.NewTicker(time.Second * 10)
|
2019-02-21 07:20:15 +01:00
|
|
|
|
headerWritten := false
|
2019-02-06 05:58:09 +01:00
|
|
|
|
for {
|
|
|
|
|
select {
|
|
|
|
|
case <-ticker.C:
|
2019-02-21 07:20:15 +01:00
|
|
|
|
// Write header if not written yet.
|
|
|
|
|
if !headerWritten {
|
|
|
|
|
w.Write([]byte(xml.Header))
|
|
|
|
|
headerWritten = true
|
2019-02-06 05:58:09 +01:00
|
|
|
|
}
|
2019-02-21 07:20:15 +01:00
|
|
|
|
|
|
|
|
|
// Once header is written keep writing empty spaces
|
|
|
|
|
// which are ignored by client SDK XML parsers.
|
|
|
|
|
// This occurs when server takes long time to completeMultiPartUpload()
|
|
|
|
|
w.Write([]byte(" "))
|
2019-02-06 05:58:09 +01:00
|
|
|
|
w.(http.Flusher).Flush()
|
2019-02-21 07:20:15 +01:00
|
|
|
|
case doneCh <- headerWritten:
|
2019-02-06 05:58:09 +01:00
|
|
|
|
ticker.Stop()
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}()
|
|
|
|
|
return doneCh
|
|
|
|
|
}
|
|
|
|
|
|
2016-09-22 05:08:08 +02:00
|
|
|
|
// CompleteMultipartUploadHandler - Complete multipart upload.
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) CompleteMultipartUploadHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "CompleteMultipartUpload")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "CompleteMultipartUpload", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-02-16 02:42:39 +01:00
|
|
|
|
vars := mux.Vars(r)
|
2015-05-08 04:55:30 +02:00
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2015-06-30 23:42:29 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-25 00:53:30 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.PutObjectAction, bucket, object); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2016-11-21 22:51:05 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-23 04:36:46 +01:00
|
|
|
|
// Content-Length is required and should be non-zero
|
|
|
|
|
if r.ContentLength <= 0 {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentLength), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
fs: Break fs package to top-level and introduce ObjectAPI interface.
ObjectAPI interface brings in changes needed for XL ObjectAPI layer.
The new interface for any ObjectAPI layer is as below
```
// ObjectAPI interface.
type ObjectAPI interface {
// Bucket resource API.
DeleteBucket(bucket string) *probe.Error
ListBuckets() ([]BucketInfo, *probe.Error)
MakeBucket(bucket string) *probe.Error
GetBucketInfo(bucket string) (BucketInfo, *probe.Error)
// Bucket query API.
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsResult, *probe.Error)
ListMultipartUploads(bucket string, resources BucketMultipartResourcesMetadata) (BucketMultipartResourcesMetadata, *probe.Error)
// Object resource API.
GetObject(bucket, object string, startOffset int64) (io.ReadCloser, *probe.Error)
GetObjectInfo(bucket, object string) (ObjectInfo, *probe.Error)
PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string) (ObjectInfo, *probe.Error)
DeleteObject(bucket, object string) *probe.Error
// Object query API.
NewMultipartUpload(bucket, object string) (string, *probe.Error)
PutObjectPart(bucket, object, uploadID string, partID int, size int64, data io.Reader, md5Hex string) (string, *probe.Error)
ListObjectParts(bucket, object string, resources ObjectResourcesMetadata) (ObjectResourcesMetadata, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []CompletePart) (ObjectInfo, *probe.Error)
AbortMultipartUpload(bucket, object, uploadID string) *probe.Error
}
```
2016-03-31 01:15:28 +02:00
|
|
|
|
// Get upload id.
|
2018-10-18 16:31:46 +02:00
|
|
|
|
uploadID, _, _, _, s3Error := getObjectResources(r.URL.Query())
|
|
|
|
|
if s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
2018-10-18 16:31:46 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-03-02 20:22:58 +01:00
|
|
|
|
|
2017-11-14 09:25:10 +01:00
|
|
|
|
complMultipartUpload := &CompleteMultipartUpload{}
|
2020-02-23 04:36:46 +01:00
|
|
|
|
if err = xmlDecoder(r.Body, complMultipartUpload, r.ContentLength); err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
fs: Break fs package to top-level and introduce ObjectAPI interface.
ObjectAPI interface brings in changes needed for XL ObjectAPI layer.
The new interface for any ObjectAPI layer is as below
```
// ObjectAPI interface.
type ObjectAPI interface {
// Bucket resource API.
DeleteBucket(bucket string) *probe.Error
ListBuckets() ([]BucketInfo, *probe.Error)
MakeBucket(bucket string) *probe.Error
GetBucketInfo(bucket string) (BucketInfo, *probe.Error)
// Bucket query API.
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsResult, *probe.Error)
ListMultipartUploads(bucket string, resources BucketMultipartResourcesMetadata) (BucketMultipartResourcesMetadata, *probe.Error)
// Object resource API.
GetObject(bucket, object string, startOffset int64) (io.ReadCloser, *probe.Error)
GetObjectInfo(bucket, object string) (ObjectInfo, *probe.Error)
PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string) (ObjectInfo, *probe.Error)
DeleteObject(bucket, object string) *probe.Error
// Object query API.
NewMultipartUpload(bucket, object string) (string, *probe.Error)
PutObjectPart(bucket, object, uploadID string, partID int, size int64, data io.Reader, md5Hex string) (string, *probe.Error)
ListObjectParts(bucket, object string, resources ObjectResourcesMetadata) (ObjectResourcesMetadata, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []CompletePart) (ObjectInfo, *probe.Error)
AbortMultipartUpload(bucket, object, uploadID string) *probe.Error
}
```
2016-03-31 01:15:28 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-05-25 21:11:26 +02:00
|
|
|
|
if len(complMultipartUpload.Parts) == 0 {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMalformedXML), r.URL, guessIsBrowserReq(r))
|
2016-05-25 21:11:26 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2017-11-14 09:25:10 +01:00
|
|
|
|
if !sort.IsSorted(CompletedParts(complMultipartUpload.Parts)) {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidPartOrder), r.URL, guessIsBrowserReq(r))
|
fs: Break fs package to top-level and introduce ObjectAPI interface.
ObjectAPI interface brings in changes needed for XL ObjectAPI layer.
The new interface for any ObjectAPI layer is as below
```
// ObjectAPI interface.
type ObjectAPI interface {
// Bucket resource API.
DeleteBucket(bucket string) *probe.Error
ListBuckets() ([]BucketInfo, *probe.Error)
MakeBucket(bucket string) *probe.Error
GetBucketInfo(bucket string) (BucketInfo, *probe.Error)
// Bucket query API.
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsResult, *probe.Error)
ListMultipartUploads(bucket string, resources BucketMultipartResourcesMetadata) (BucketMultipartResourcesMetadata, *probe.Error)
// Object resource API.
GetObject(bucket, object string, startOffset int64) (io.ReadCloser, *probe.Error)
GetObjectInfo(bucket, object string) (ObjectInfo, *probe.Error)
PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string) (ObjectInfo, *probe.Error)
DeleteObject(bucket, object string) *probe.Error
// Object query API.
NewMultipartUpload(bucket, object string) (string, *probe.Error)
PutObjectPart(bucket, object, uploadID string, partID int, size int64, data io.Reader, md5Hex string) (string, *probe.Error)
ListObjectParts(bucket, object string, resources ObjectResourcesMetadata) (ObjectResourcesMetadata, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []CompletePart) (ObjectInfo, *probe.Error)
AbortMultipartUpload(bucket, object, uploadID string) *probe.Error
}
```
2016-03-31 01:15:28 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
|
|
|
|
// Reject retention or governance headers if set, CompleteMultipartUpload spec
|
|
|
|
|
// does not use these headers, and should not be passed down to checkPutObjectLockAllowed
|
|
|
|
|
if objectlock.IsObjectLockRequested(r.Header) || objectlock.IsObjectLockGovernanceBypassSet(r.Header) {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidRequest), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-13 23:03:23 +02:00
|
|
|
|
if _, _, _, s3Err := checkPutObjectLockAllowed(ctx, r, bucket, object, objectAPI.GetObjectInfo, ErrNone, ErrNone); s3Err != ErrNone {
|
2020-04-06 22:44:16 +02:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-15 02:36:41 +01:00
|
|
|
|
var objectEncryptionKey []byte
|
|
|
|
|
var opts ObjectOptions
|
|
|
|
|
var isEncrypted, ssec bool
|
|
|
|
|
if objectAPI.IsEncryptionSupported() {
|
|
|
|
|
var li ListPartsInfo
|
2019-01-05 23:16:43 +01:00
|
|
|
|
li, err = objectAPI.ListObjectParts(ctx, bucket, object, uploadID, 0, 1, opts)
|
2018-11-15 02:36:41 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-11-15 02:36:41 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if crypto.IsEncrypted(li.UserDefined) {
|
|
|
|
|
var key []byte
|
2019-01-05 23:16:43 +01:00
|
|
|
|
isEncrypted = true
|
|
|
|
|
ssec = crypto.SSEC.IsEncrypted(li.UserDefined)
|
2018-11-15 02:36:41 +01:00
|
|
|
|
if crypto.S3.IsEncrypted(li.UserDefined) {
|
|
|
|
|
// Calculating object encryption key
|
|
|
|
|
objectEncryptionKey, err = decryptObjectInfo(key, bucket, object, li.UserDefined)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-11-15 02:36:41 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
partsMap := make(map[string]PartInfo)
|
|
|
|
|
if isEncrypted {
|
|
|
|
|
var partNumberMarker int
|
|
|
|
|
maxParts := 1000
|
|
|
|
|
for {
|
2019-01-05 23:16:43 +01:00
|
|
|
|
listPartsInfo, err := objectAPI.ListObjectParts(ctx, bucket, object, uploadID, partNumberMarker, maxParts, opts)
|
2018-11-15 02:36:41 +01:00
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-11-15 02:36:41 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
for _, part := range listPartsInfo.Parts {
|
|
|
|
|
partsMap[strconv.Itoa(part.PartNumber)] = part
|
|
|
|
|
}
|
|
|
|
|
partNumberMarker = listPartsInfo.NextPartNumberMarker
|
|
|
|
|
if !listPartsInfo.IsTruncated {
|
|
|
|
|
break
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-01-05 23:16:43 +01:00
|
|
|
|
|
fs: Break fs package to top-level and introduce ObjectAPI interface.
ObjectAPI interface brings in changes needed for XL ObjectAPI layer.
The new interface for any ObjectAPI layer is as below
```
// ObjectAPI interface.
type ObjectAPI interface {
// Bucket resource API.
DeleteBucket(bucket string) *probe.Error
ListBuckets() ([]BucketInfo, *probe.Error)
MakeBucket(bucket string) *probe.Error
GetBucketInfo(bucket string) (BucketInfo, *probe.Error)
// Bucket query API.
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsResult, *probe.Error)
ListMultipartUploads(bucket string, resources BucketMultipartResourcesMetadata) (BucketMultipartResourcesMetadata, *probe.Error)
// Object resource API.
GetObject(bucket, object string, startOffset int64) (io.ReadCloser, *probe.Error)
GetObjectInfo(bucket, object string) (ObjectInfo, *probe.Error)
PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string) (ObjectInfo, *probe.Error)
DeleteObject(bucket, object string) *probe.Error
// Object query API.
NewMultipartUpload(bucket, object string) (string, *probe.Error)
PutObjectPart(bucket, object, uploadID string, partID int, size int64, data io.Reader, md5Hex string) (string, *probe.Error)
ListObjectParts(bucket, object string, resources ObjectResourcesMetadata) (ObjectResourcesMetadata, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []CompletePart) (ObjectInfo, *probe.Error)
AbortMultipartUpload(bucket, object, uploadID string) *probe.Error
}
```
2016-03-31 01:15:28 +02:00
|
|
|
|
// Complete parts.
|
2017-11-14 09:25:10 +01:00
|
|
|
|
var completeParts []CompletePart
|
2016-04-11 10:29:18 +02:00
|
|
|
|
for _, part := range complMultipartUpload.Parts {
|
2017-03-16 04:48:49 +01:00
|
|
|
|
part.ETag = canonicalizeETag(part.ETag)
|
2018-11-15 02:36:41 +01:00
|
|
|
|
if isEncrypted {
|
|
|
|
|
// ETag is stored in the backend in encrypted form. Validate client sent ETag with
|
|
|
|
|
// decrypted ETag.
|
|
|
|
|
if bkPartInfo, ok := partsMap[strconv.Itoa(part.PartNumber)]; ok {
|
|
|
|
|
bkETag := tryDecryptETag(objectEncryptionKey, bkPartInfo.ETag, ssec)
|
|
|
|
|
if bkETag != part.ETag {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidPart), r.URL, guessIsBrowserReq(r))
|
2018-11-15 02:36:41 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
part.ETag = bkPartInfo.ETag
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-04-11 10:29:18 +02:00
|
|
|
|
completeParts = append(completeParts, part)
|
|
|
|
|
}
|
2016-08-11 03:47:49 +02:00
|
|
|
|
|
2018-03-28 23:14:06 +02:00
|
|
|
|
completeMultiPartUpload := objectAPI.CompleteMultipartUpload
|
2019-02-21 07:20:15 +01:00
|
|
|
|
|
|
|
|
|
// This code is specifically to handle the requirements for slow
|
|
|
|
|
// complete multipart upload operations on FS mode.
|
|
|
|
|
writeErrorResponseWithoutXMLHeader := func(ctx context.Context, w http.ResponseWriter, err APIError, reqURL *url.URL) {
|
|
|
|
|
switch err.Code {
|
|
|
|
|
case "SlowDown", "XMinioServerNotInitialized", "XMinioReadQuorum", "XMinioWriteQuorum":
|
|
|
|
|
// Set retry-after header to indicate user-agents to retry request after 120secs.
|
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
|
2019-07-03 07:34:32 +02:00
|
|
|
|
w.Header().Set(xhttp.RetryAfter, "120")
|
2019-02-21 07:20:15 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Generate error response.
|
|
|
|
|
errorResponse := getAPIErrorResponse(ctx, err, reqURL.Path,
|
2019-07-03 07:34:32 +02:00
|
|
|
|
w.Header().Get(xhttp.AmzRequestID), globalDeploymentID)
|
2019-02-21 07:20:15 +01:00
|
|
|
|
encodedErrorResponse, _ := xml.Marshal(errorResponse)
|
|
|
|
|
setCommonHeaders(w)
|
2019-07-03 07:34:32 +02:00
|
|
|
|
w.Header().Set(xhttp.ContentType, string(mimeXML))
|
2019-02-21 07:20:15 +01:00
|
|
|
|
w.Write(encodedErrorResponse)
|
|
|
|
|
w.(http.Flusher).Flush()
|
|
|
|
|
}
|
2019-07-11 22:19:25 +02:00
|
|
|
|
w.Header().Set(xhttp.ContentType, "text/event-stream")
|
2019-02-21 07:20:15 +01:00
|
|
|
|
w = &whiteSpaceWriter{ResponseWriter: w, Flusher: w.(http.Flusher)}
|
2019-10-16 03:35:41 +02:00
|
|
|
|
completeDoneCh := sendWhiteSpace(w)
|
2018-11-15 02:36:41 +01:00
|
|
|
|
objInfo, err := completeMultiPartUpload(ctx, bucket, object, uploadID, completeParts, opts)
|
2019-02-06 05:58:09 +01:00
|
|
|
|
// Stop writing white spaces to the client. Note that close(doneCh) style is not used as it
|
|
|
|
|
// can cause white space to be written after we send XML response in a race condition.
|
2019-02-21 07:20:15 +01:00
|
|
|
|
headerWritten := <-completeDoneCh
|
2015-09-19 12:20:07 +02:00
|
|
|
|
if err != nil {
|
2019-02-21 07:20:15 +01:00
|
|
|
|
if headerWritten {
|
|
|
|
|
writeErrorResponseWithoutXMLHeader(ctx, w, toAPIError(ctx, err), r.URL)
|
|
|
|
|
} else {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2016-06-28 23:51:49 +02:00
|
|
|
|
}
|
2015-08-04 01:17:21 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2016-06-16 05:31:06 +02:00
|
|
|
|
|
2016-03-13 01:08:15 +01:00
|
|
|
|
// Get object location.
|
2019-02-23 04:18:01 +01:00
|
|
|
|
location := getObjectLocation(r, globalDomainNames, bucket, object)
|
2016-03-02 05:01:40 +01:00
|
|
|
|
// Generate complete multipart response.
|
2017-05-14 21:05:51 +02:00
|
|
|
|
response := generateCompleteMultpartUploadResponse(bucket, object, location, objInfo.ETag)
|
2019-02-21 07:20:15 +01:00
|
|
|
|
var encodedSuccessResponse []byte
|
|
|
|
|
if !headerWritten {
|
|
|
|
|
encodedSuccessResponse = encodeResponse(response)
|
|
|
|
|
} else {
|
|
|
|
|
encodedSuccessResponse, err = xml.Marshal(response)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponseWithoutXMLHeader(ctx, w, toAPIError(ctx, err), r.URL)
|
|
|
|
|
return
|
|
|
|
|
}
|
2016-07-01 03:48:50 +02:00
|
|
|
|
}
|
2016-07-24 07:51:12 +02:00
|
|
|
|
|
2016-11-10 16:41:02 +01:00
|
|
|
|
// Set etag.
|
2019-07-03 07:34:32 +02:00
|
|
|
|
w.Header()[xhttp.ETag] = []string{"\"" + objInfo.ETag + "\""}
|
2016-11-10 16:41:02 +01:00
|
|
|
|
|
2016-07-24 07:51:12 +02:00
|
|
|
|
// Write success response.
|
2017-01-06 09:37:00 +01:00
|
|
|
|
writeSuccessResponseXML(w, encodedSuccessResponse)
|
2016-07-24 07:51:12 +02:00
|
|
|
|
|
2016-09-29 07:46:19 +02:00
|
|
|
|
// Notify object created event.
|
2018-03-15 21:03:41 +01:00
|
|
|
|
sendEvent(eventArgs{
|
2018-11-03 02:40:08 +01:00
|
|
|
|
EventName: event.ObjectCreatedCompleteMultipartUpload,
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
2019-03-25 19:45:42 +01:00
|
|
|
|
Host: handlers.GetSourceIP(r),
|
2016-09-29 07:46:19 +02:00
|
|
|
|
})
|
2015-05-08 04:55:30 +02:00
|
|
|
|
}
|
2015-06-08 20:06:06 +02:00
|
|
|
|
|
2016-04-12 21:45:15 +02:00
|
|
|
|
/// Delete objectAPIHandlers
|
2015-06-08 20:06:06 +02:00
|
|
|
|
|
2016-03-06 01:43:48 +01:00
|
|
|
|
// DeleteObjectHandler - delete an object
|
2016-04-12 21:45:15 +02:00
|
|
|
|
func (api objectAPIHandlers) DeleteObjectHandler(w http.ResponseWriter, r *http.Request) {
|
2018-07-21 03:46:32 +02:00
|
|
|
|
ctx := newContext(r, w, "DeleteObject")
|
2018-03-14 20:01:47 +01:00
|
|
|
|
|
2018-11-22 05:03:24 +01:00
|
|
|
|
defer logger.AuditLog(w, r, "DeleteObject", mustGetClaimsFromToken(r))
|
2018-10-12 21:25:59 +02:00
|
|
|
|
|
2016-02-16 02:42:39 +01:00
|
|
|
|
vars := mux.Vars(r)
|
2015-10-16 20:26:01 +02:00
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2015-10-16 20:26:01 +02:00
|
|
|
|
|
2016-08-11 03:47:49 +02:00
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
2016-08-11 03:47:49 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-25 00:53:30 +02:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.DeleteObjectAction, bucket, object); s3Error != ErrNone {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
accessPolicy: Implement Put, Get, Delete access policy.
This patch implements Get,Put,Delete bucket policies
Supporting - http://docs.aws.amazon.com/AmazonS3/latest/dev/access-policy-language-overview.html
Currently supports following actions.
"*": true,
"s3:*": true,
"s3:GetObject": true,
"s3:ListBucket": true,
"s3:PutObject": true,
"s3:CreateBucket": true,
"s3:GetBucketLocation": true,
"s3:DeleteBucket": true,
"s3:DeleteObject": true,
"s3:AbortMultipartUpload": true,
"s3:ListBucketMultipartUploads": true,
"s3:ListMultipartUploadParts": true,
following conditions for "StringEquals" and "StringNotEquals"
"s3:prefix", "s3:max-keys"
2016-02-04 01:46:56 +01:00
|
|
|
|
return
|
2016-02-04 21:52:25 +01:00
|
|
|
|
}
|
2016-11-21 22:51:05 +01:00
|
|
|
|
|
2018-12-14 07:04:37 +01:00
|
|
|
|
if vid := r.URL.Query().Get("versionId"); vid != "" && vid != "null" {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
2018-12-14 07:04:37 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
2018-03-28 01:44:45 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-07-01 07:35:43 +02:00
|
|
|
|
if globalDNSConfig != nil {
|
|
|
|
|
_, err := globalDNSConfig.Get(bucket)
|
|
|
|
|
if err != nil {
|
2019-02-14 01:07:21 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
2018-07-01 07:35:43 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-06 22:44:16 +02:00
|
|
|
|
apiErr := ErrNone
|
|
|
|
|
if _, ok := globalBucketObjectLockConfig.Get(bucket); ok {
|
|
|
|
|
apiErr = enforceRetentionBypassForDelete(ctx, r, bucket, object, getObjectInfo)
|
|
|
|
|
if apiErr != ErrNone && apiErr != ErrNoSuchKey {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(apiErr), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if apiErr == ErrNone {
|
|
|
|
|
// http://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectDELETE.html
|
|
|
|
|
if err := deleteObject(ctx, objectAPI, api.CacheAPI(), bucket, object, r); err != nil {
|
|
|
|
|
switch err.(type) {
|
|
|
|
|
case BucketNotFound:
|
|
|
|
|
// When bucket doesn't exist specially handle it.
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
// Ignore delete object errors while replying to client, since we are suppposed to reply only 204.
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-17 05:02:37 +02:00
|
|
|
|
writeSuccessNoContent(w)
|
2015-06-08 20:06:06 +02:00
|
|
|
|
}
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
|
|
|
|
// PutObjectLegalHoldHandler - set legal hold configuration to object,
|
|
|
|
|
func (api objectAPIHandlers) PutObjectLegalHoldHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
ctx := newContext(r, w, "PutObjectLegalHold")
|
|
|
|
|
|
|
|
|
|
defer logger.AuditLog(w, r, "PutObjectLegalHold", mustGetClaimsFromToken(r))
|
|
|
|
|
|
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
|
|
|
|
if vid := r.URL.Query().Get("versionId"); vid != "" && vid != "null" {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-17 00:41:56 +01:00
|
|
|
|
// Check permissions to perform this legal hold operation
|
2020-03-04 16:04:12 +01:00
|
|
|
|
if s3Err := checkRequestAuthType(ctx, r, policy.PutObjectLegalHoldAction, bucket, object); s3Err != ErrNone {
|
2020-01-17 00:41:56 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if _, err := objectAPI.GetBucketInfo(ctx, bucket); err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-03-04 16:04:12 +01:00
|
|
|
|
if !hasContentMD5(r.Header) {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentMD5), r.URL, guessIsBrowserReq(r))
|
2020-01-17 00:41:56 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-02-16 07:07:52 +01:00
|
|
|
|
|
2020-01-17 00:41:56 +01:00
|
|
|
|
if _, ok := globalBucketObjectLockConfig.Get(bucket); !ok {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidBucketObjectLockConfiguration), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
legalHold, err := objectlock.ParseObjectLegalHold(r.Body)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-12 23:50:18 +01:00
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
|
|
|
|
}
|
|
|
|
|
opts, err := getOpts(ctx, r, bucket, object)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-17 00:41:56 +01:00
|
|
|
|
objInfo, err := getObjectInfo(ctx, bucket, object, opts)
|
|
|
|
|
if err != nil {
|
2019-11-12 23:50:18 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-01-17 00:41:56 +01:00
|
|
|
|
objInfo.UserDefined[strings.ToLower(xhttp.AmzObjectLockLegalHold)] = strings.ToUpper(string(legalHold.Status))
|
|
|
|
|
objInfo.metadataOnly = true
|
|
|
|
|
|
|
|
|
|
if _, err = objectAPI.CopyObject(ctx, bucket, object, bucket, object, objInfo, ObjectOptions{}, ObjectOptions{}); err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-19 03:45:48 +01:00
|
|
|
|
writeSuccessResponseHeadersOnly(w)
|
2020-01-17 00:41:56 +01:00
|
|
|
|
// Notify object event.
|
|
|
|
|
sendEvent(eventArgs{
|
|
|
|
|
EventName: event.ObjectCreatedPutLegalHold,
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
|
|
|
|
Host: handlers.GetSourceIP(r),
|
|
|
|
|
})
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// GetObjectLegalHoldHandler - get legal hold configuration to object,
|
|
|
|
|
func (api objectAPIHandlers) GetObjectLegalHoldHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
ctx := newContext(r, w, "GetObjectLegalHold")
|
|
|
|
|
|
|
|
|
|
defer logger.AuditLog(w, r, "GetObjectLegalHold", mustGetClaimsFromToken(r))
|
|
|
|
|
|
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
|
|
|
|
if vid := r.URL.Query().Get("versionId"); vid != "" && vid != "null" {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-01-17 00:41:56 +01:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.GetObjectLegalHoldAction, bucket, object); s3Error != ErrNone {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-06 22:44:16 +02:00
|
|
|
|
if _, ok := globalBucketObjectLockConfig.Get(bucket); !ok {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidBucketObjectLockConfiguration), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-12 23:50:18 +01:00
|
|
|
|
opts, err := getOpts(ctx, r, bucket, object)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-17 00:41:56 +01:00
|
|
|
|
objInfo, err := getObjectInfo(ctx, bucket, object, opts)
|
|
|
|
|
if err != nil {
|
2019-11-12 23:50:18 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-17 00:41:56 +01:00
|
|
|
|
legalHold := objectlock.GetObjectLegalHoldMeta(objInfo.UserDefined)
|
2020-02-19 03:45:48 +01:00
|
|
|
|
if legalHold.IsEmpty() {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchObjectLockConfiguration), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
2020-01-17 00:41:56 +01:00
|
|
|
|
writeSuccessResponseXML(w, encodeResponse(legalHold))
|
|
|
|
|
// Notify object legal hold accessed via a GET request.
|
|
|
|
|
sendEvent(eventArgs{
|
|
|
|
|
EventName: event.ObjectAccessedGetLegalHold,
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
|
|
|
|
Host: handlers.GetSourceIP(r),
|
|
|
|
|
})
|
2019-11-12 23:50:18 +01:00
|
|
|
|
}
|
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
// PutObjectRetentionHandler - set object hold configuration to object,
|
2019-11-12 23:50:18 +01:00
|
|
|
|
func (api objectAPIHandlers) PutObjectRetentionHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
ctx := newContext(r, w, "PutObjectRetention")
|
|
|
|
|
|
|
|
|
|
defer logger.AuditLog(w, r, "PutObjectRetention", mustGetClaimsFromToken(r))
|
|
|
|
|
|
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
|
|
|
|
if vid := r.URL.Query().Get("versionId"); vid != "" && vid != "null" {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
|
|
|
|
cred, owner, claims, s3Err := validateSignature(getRequestAuthType(r), r)
|
|
|
|
|
if s3Err != ErrNone {
|
2019-11-20 22:18:09 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-25 19:58:39 +01:00
|
|
|
|
if _, err := objectAPI.GetBucketInfo(ctx, bucket); err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
2020-03-04 16:04:12 +01:00
|
|
|
|
if !hasContentMD5(r.Header) {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrMissingContentMD5), r.URL, guessIsBrowserReq(r))
|
2019-11-20 22:18:09 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-02-16 07:07:52 +01:00
|
|
|
|
|
2020-01-14 02:29:31 +01:00
|
|
|
|
if _, ok := globalBucketObjectLockConfig.Get(bucket); !ok {
|
2019-11-20 22:18:09 +01:00
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidBucketObjectLockConfiguration), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
2020-01-17 00:41:56 +01:00
|
|
|
|
objRetention, err := objectlock.ParseObjectRetention(r.Body)
|
2019-11-25 19:58:39 +01:00
|
|
|
|
if err != nil {
|
|
|
|
|
apiErr := errorCodes.ToAPIErr(ErrMalformedXML)
|
|
|
|
|
apiErr.Description = err.Error()
|
|
|
|
|
writeErrorResponse(ctx, w, apiErr, r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-04-06 22:44:16 +02:00
|
|
|
|
|
2019-11-12 23:50:18 +01:00
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-06 22:44:16 +02:00
|
|
|
|
objInfo, s3Err := enforceRetentionBypassForPut(ctx, r, bucket, object, getObjectInfo, objRetention, cred, owner, claims)
|
2019-11-20 22:18:09 +01:00
|
|
|
|
if s3Err != ErrNone {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-03-04 16:04:12 +01:00
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
objInfo.UserDefined[strings.ToLower(xhttp.AmzObjectLockMode)] = string(objRetention.Mode)
|
|
|
|
|
objInfo.UserDefined[strings.ToLower(xhttp.AmzObjectLockRetainUntilDate)] = objRetention.RetainUntilDate.UTC().Format(time.RFC3339)
|
2020-04-06 22:44:16 +02:00
|
|
|
|
objInfo.metadataOnly = true // Perform only metadata updates.
|
2019-11-20 22:18:09 +01:00
|
|
|
|
if _, err = objectAPI.CopyObject(ctx, bucket, object, bucket, object, objInfo, ObjectOptions{}, ObjectOptions{}); err != nil {
|
2019-11-12 23:50:18 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
writeSuccessNoContent(w)
|
|
|
|
|
// Notify object event.
|
|
|
|
|
sendEvent(eventArgs{
|
|
|
|
|
EventName: event.ObjectCreatedPutRetention,
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
|
|
|
|
Host: handlers.GetSourceIP(r),
|
|
|
|
|
})
|
2019-11-12 23:50:18 +01:00
|
|
|
|
}
|
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
// GetObjectRetentionHandler - get object retention configuration of object,
|
2019-11-12 23:50:18 +01:00
|
|
|
|
func (api objectAPIHandlers) GetObjectRetentionHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
ctx := newContext(r, w, "GetObjectRetention")
|
|
|
|
|
defer logger.AuditLog(w, r, "GetObjectRetention", mustGetClaimsFromToken(r))
|
|
|
|
|
|
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
|
|
|
|
if vid := r.URL.Query().Get("versionId"); vid != "" && vid != "null" {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrNoSuchVersion), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
objectAPI := api.ObjectAPI()
|
|
|
|
|
if objectAPI == nil {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-11-20 22:18:09 +01:00
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.GetObjectRetentionAction, bucket, object); s3Error != ErrNone {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-11-12 23:50:18 +01:00
|
|
|
|
|
|
|
|
|
getObjectInfo := objectAPI.GetObjectInfo
|
|
|
|
|
if api.CacheAPI() != nil {
|
|
|
|
|
getObjectInfo = api.CacheAPI().GetObjectInfo
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
opts, err := getOpts(ctx, r, bucket, object)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-20 22:18:09 +01:00
|
|
|
|
objInfo, err := getObjectInfo(ctx, bucket, object, opts)
|
|
|
|
|
if err != nil {
|
2019-11-12 23:50:18 +01:00
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-17 00:41:56 +01:00
|
|
|
|
retention := objectlock.GetObjectRetentionMeta(objInfo.UserDefined)
|
2019-11-20 22:18:09 +01:00
|
|
|
|
|
|
|
|
|
writeSuccessResponseXML(w, encodeResponse(retention))
|
|
|
|
|
// Notify object retention accessed via a GET request.
|
|
|
|
|
sendEvent(eventArgs{
|
|
|
|
|
EventName: event.ObjectAccessedGetRetention,
|
|
|
|
|
BucketName: bucket,
|
|
|
|
|
Object: objInfo,
|
|
|
|
|
ReqParams: extractReqParams(r),
|
|
|
|
|
RespElements: extractRespElements(w),
|
|
|
|
|
UserAgent: r.UserAgent(),
|
|
|
|
|
Host: handlers.GetSourceIP(r),
|
|
|
|
|
})
|
2019-11-12 23:50:18 +01:00
|
|
|
|
}
|
2020-01-20 17:45:59 +01:00
|
|
|
|
|
|
|
|
|
// GetObjectTaggingHandler - GET object tagging
|
|
|
|
|
func (api objectAPIHandlers) GetObjectTaggingHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
ctx := newContext(r, w, "GetObjectTagging")
|
|
|
|
|
defer logger.AuditLog(w, r, "GetObjectTagging", mustGetClaimsFromToken(r))
|
|
|
|
|
|
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-01-20 17:45:59 +01:00
|
|
|
|
|
|
|
|
|
objAPI := api.ObjectAPI()
|
|
|
|
|
if objAPI == nil {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Allow getObjectTagging if policy action is set.
|
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.GetObjectTaggingAction, bucket, object); s3Error != ErrNone {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Get object tags
|
|
|
|
|
tags, err := objAPI.GetObjectTag(ctx, bucket, object)
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
writeSuccessResponseXML(w, encodeResponse(tags))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// PutObjectTaggingHandler - PUT object tagging
|
|
|
|
|
func (api objectAPIHandlers) PutObjectTaggingHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
ctx := newContext(r, w, "PutObjectTagging")
|
|
|
|
|
defer logger.AuditLog(w, r, "PutObjectTagging", mustGetClaimsFromToken(r))
|
|
|
|
|
|
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
2020-02-12 04:38:02 +01:00
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
2020-01-20 17:45:59 +01:00
|
|
|
|
|
|
|
|
|
objAPI := api.ObjectAPI()
|
|
|
|
|
if objAPI == nil {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Allow putObjectTagging if policy action is set
|
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.PutObjectTaggingAction, bucket, object); s3Error != ErrNone {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tagging, err := tagging.ParseTagging(io.LimitReader(r.Body, r.ContentLength))
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Put object tags
|
|
|
|
|
err = objAPI.PutObjectTag(ctx, bucket, object, tagging.String())
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
writeSuccessResponseHeadersOnly(w)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// DeleteObjectTaggingHandler - DELETE object tagging
|
|
|
|
|
func (api objectAPIHandlers) DeleteObjectTaggingHandler(w http.ResponseWriter, r *http.Request) {
|
|
|
|
|
ctx := newContext(r, w, "DeleteObjectTagging")
|
|
|
|
|
defer logger.AuditLog(w, r, "DeleteObjectTagging", mustGetClaimsFromToken(r))
|
|
|
|
|
|
|
|
|
|
objAPI := api.ObjectAPI()
|
|
|
|
|
if objAPI == nil {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrServerNotInitialized), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-12 04:38:02 +01:00
|
|
|
|
vars := mux.Vars(r)
|
|
|
|
|
bucket := vars["bucket"]
|
|
|
|
|
object, err := url.PathUnescape(vars["object"])
|
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-20 17:45:59 +01:00
|
|
|
|
// Allow deleteObjectTagging if policy action is set
|
|
|
|
|
if s3Error := checkRequestAuthType(ctx, r, policy.DeleteObjectTaggingAction, bucket, object); s3Error != ErrNone {
|
|
|
|
|
writeErrorResponse(ctx, w, errorCodes.ToAPIErr(s3Error), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Delete object tags
|
2020-02-12 04:38:02 +01:00
|
|
|
|
err = objAPI.DeleteObjectTag(ctx, bucket, object)
|
2020-01-20 17:45:59 +01:00
|
|
|
|
if err != nil {
|
|
|
|
|
writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL, guessIsBrowserReq(r))
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-17 07:21:24 +01:00
|
|
|
|
writeSuccessNoContent(w)
|
2020-01-20 17:45:59 +01:00
|
|
|
|
}
|