2015-06-30 23:42:29 +02:00
/ *
2019-04-09 20:39:42 +02:00
* MinIO Cloud Storage , ( C ) 2015 , 2016 , 2017 , 2018 MinIO , Inc .
2015-06-30 23:42:29 +02:00
*
* Licensed under the Apache License , Version 2.0 ( the "License" ) ;
* you may not use this file except in compliance with the License .
* You may obtain a copy of the License at
*
* http : //www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing , software
* distributed under the License is distributed on an "AS IS" BASIS ,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND , either express or implied .
* See the License for the specific language governing permissions and
* limitations under the License .
* /
2016-08-19 01:23:42 +02:00
package cmd
2015-06-30 23:42:29 +02:00
import (
2018-04-05 17:18:42 +02:00
"context"
2016-10-25 08:47:03 +02:00
"encoding/base64"
2016-03-06 01:43:48 +01:00
"encoding/xml"
2018-04-05 17:18:42 +02:00
"fmt"
2016-02-16 02:42:39 +01:00
"io"
2019-08-13 17:49:26 +02:00
"net"
2015-06-30 23:42:29 +02:00
"net/http"
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
"net/url"
2017-01-11 22:26:42 +01:00
"path"
2017-11-15 23:10:45 +01:00
"path/filepath"
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
"strings"
2015-06-30 23:42:29 +02:00
2018-04-22 04:23:54 +02:00
"github.com/gorilla/mux"
2018-05-11 21:02:30 +02:00
2019-05-30 01:35:12 +02:00
"github.com/minio/minio-go/v6/pkg/set"
2019-11-26 01:33:34 +01:00
"github.com/minio/minio/cmd/config/etcd/dns"
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"
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-08-12 19:27:38 +02:00
iampolicy "github.com/minio/minio/pkg/iam/policy"
2018-04-25 00:53:30 +02:00
"github.com/minio/minio/pkg/policy"
2018-04-05 17:18:42 +02:00
"github.com/minio/minio/pkg/sync/errgroup"
2015-06-30 23:42:29 +02:00
)
2019-11-12 23:50:18 +01:00
const (
2019-11-20 22:18:09 +01:00
getBucketVersioningResponse = ` <VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/"/> `
objectLockConfig = "object-lock.xml"
bucketObjectLockEnabledConfigFile = "object-lock-enabled.json"
bucketObjectLockEnabledConfig = ` { "x-amz-bucket-object-lock-enabled":true} `
2019-11-12 23:50:18 +01:00
)
2018-04-05 17:18:42 +02:00
// Check if there are buckets on server without corresponding entry in etcd backend and
// make entries. Here is the general flow
// - Range over all the available buckets
// - Check if a bucket has an entry in etcd backend
// -- If no, make an entry
2019-12-17 05:30:57 +01:00
// -- If yes, check if the entry matches local IP check if we
// need to update the entry then proceed to update
// -- If yes, check if the IP of entry matches local IP.
// This means entry is for this instance.
// -- If IP of the entry doesn't match, this means entry is
// for another instance. Log an error to console.
2019-11-09 18:27:23 +01:00
func initFederatorBackend ( buckets [ ] BucketInfo , objLayer ObjectLayer ) {
if len ( buckets ) == 0 {
2018-04-05 17:18:42 +02:00
return
}
2019-08-13 17:49:26 +02:00
// Get buckets in the DNS
dnsBuckets , err := globalDNSConfig . List ( )
if err != nil && err != dns . ErrNoEntriesFound {
logger . LogIf ( context . Background ( ) , err )
return
}
bucketSet := set . NewStringSet ( )
// Add buckets that are not registered with the DNS
2019-11-09 18:27:23 +01:00
g := errgroup . WithNErrs ( len ( buckets ) )
for index := range buckets {
bucketSet . Add ( buckets [ index ] . Name )
2019-10-14 18:44:51 +02:00
index := index
2018-04-05 17:18:42 +02:00
g . Go ( func ( ) error {
2019-11-09 18:27:23 +01:00
r , gerr := globalDNSConfig . Get ( buckets [ index ] . Name )
2018-04-05 17:18:42 +02:00
if gerr != nil {
2018-07-12 23:12:40 +02:00
if gerr == dns . ErrNoEntriesFound {
2019-11-09 18:27:23 +01:00
return globalDNSConfig . Put ( buckets [ index ] . Name )
2018-04-05 17:18:42 +02:00
}
return gerr
}
2019-12-17 05:30:57 +01:00
if ! globalDomainIPs . Intersection ( set . CreateStringSet ( getHostsSlice ( r ) ... ) ) . IsEmpty ( ) {
if globalDomainIPs . Difference ( set . CreateStringSet ( getHostsSlice ( r ) ... ) ) . IsEmpty ( ) {
// No difference in terms of domainIPs and nothing
// has changed so we don't change anything on the etcd.
return nil
}
// if domain IPs intersect then it won't be an empty set.
// such an intersection means that bucket exists on etcd.
// but if we do see a difference with local domain IPs with
// hostSlice from etcd then we should update with newer
// domainIPs, we proceed to do that here.
return globalDNSConfig . Put ( buckets [ index ] . Name )
2018-04-05 17:18:42 +02:00
}
2019-12-17 05:30:57 +01:00
// No IPs seem to intersect, this means that bucket exists but has
// different IP addresses perhaps from a different deployment.
// bucket names are globally unique in federation at a given
// path prefix, name collision is not allowed. We simply log
// an error and continue.
return fmt . Errorf ( "Unable to add bucket DNS entry for bucket %s, an entry exists for the same bucket. Use one of these IP addresses %v to access the bucket" , buckets [ index ] . Name , globalDomainIPs . ToSlice ( ) )
2018-04-05 17:18:42 +02:00
} , index )
}
for _ , err := range g . Wait ( ) {
if err != nil {
logger . LogIf ( context . Background ( ) , err )
2019-08-13 17:49:26 +02:00
}
}
g = errgroup . WithNErrs ( len ( dnsBuckets ) )
// Remove buckets that are in DNS for this server, but aren't local
for index := range dnsBuckets {
index := index
g . Go ( func ( ) error {
// This is a local bucket that exists, so we can continue
if bucketSet . Contains ( dnsBuckets [ index ] . Key ) {
return nil
}
// This is not for our server, so we can continue
2019-11-12 23:42:35 +01:00
hostPort := net . JoinHostPort ( dnsBuckets [ index ] . Host , string ( dnsBuckets [ index ] . Port ) )
2019-08-13 17:49:26 +02:00
if globalDomainIPs . Intersection ( set . CreateStringSet ( hostPort ) ) . IsEmpty ( ) {
return nil
}
2019-12-17 05:30:57 +01:00
// We go to here, so we know the bucket no longer exists,
// but is registered in DNS to this server
2019-08-13 17:49:26 +02:00
if err := globalDNSConfig . DeleteRecord ( dnsBuckets [ index ] ) ; err != nil {
2019-12-17 05:30:57 +01:00
return fmt . Errorf ( "Failed to remove DNS entry for %s due to %w" ,
dnsBuckets [ index ] . Key , err )
2019-08-13 17:49:26 +02:00
}
return nil
} , index )
}
for _ , err := range g . Wait ( ) {
if err != nil {
logger . LogIf ( context . Background ( ) , err )
2018-04-05 17:18:42 +02:00
}
}
}
2015-12-27 08:38:38 +01:00
// GetBucketLocationHandler - GET Bucket location.
// -------------------------
// This operation returns bucket location.
2016-04-12 21:45:15 +02:00
func ( api objectAPIHandlers ) GetBucketLocationHandler ( w http . ResponseWriter , r * http . Request ) {
2018-07-21 03:46:32 +02:00
ctx := newContext ( r , w , "GetBucketLocation" )
2018-03-14 20:01:47 +01:00
2018-11-22 05:03:24 +01:00
defer logger . AuditLog ( w , r , "GetBucketLocation" , mustGetClaimsFromToken ( r ) )
2018-10-12 21:25:59 +02:00
2016-02-16 02:42:39 +01:00
vars := mux . Vars ( r )
2015-12-27 08:38:38 +01:00
bucket := vars [ "bucket" ]
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 . GetBucketLocationAction , bucket , "" ) ; 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
2016-02-04 21:52:25 +01:00
}
2018-03-28 23:14:06 +02:00
getBucketInfo := objectAPI . GetBucketInfo
2019-08-10 02:09:08 +02:00
2018-03-28 23:14:06 +02:00
if _ , err := getBucketInfo ( ctx , bucket ) ; err != nil {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2016-01-20 02:49:48 +01:00
return
2015-12-27 08:38:38 +01:00
}
2016-02-16 02:42:39 +01:00
// Generate response.
2016-03-06 21:16:22 +01:00
encodedSuccessResponse := encodeResponse ( LocationResponse { } )
config/main: Re-write config files - add to new config v3
- New config format.
```
{
"version": "3",
"address": ":9000",
"backend": {
"type": "fs",
"disk": "/path"
},
"credential": {
"accessKey": "WLGDGYAQYIGI833EV05A",
"secretKey": "BYvgJM101sHngl2uzjXS/OBF/aMxAN06JrJ3qJlF"
},
"region": "us-east-1",
"logger": {
"file": {
"enable": false,
"fileName": "",
"level": "error"
},
"syslog": {
"enable": false,
"address": "",
"level": "debug"
},
"console": {
"enable": true,
"level": "fatal"
}
}
}
```
New command lines in lieu of supporting XL.
Minio initialize filesystem backend.
~~~
$ minio init fs <path>
~~~
Minio initialize XL backend.
~~~
$ minio init xl <url1>...<url16>
~~~
For 'fs' backend it starts the server.
~~~
$ minio server
~~~
For 'xl' backend it waits for servers to join.
~~~
$ minio server
... [PROGRESS BAR] of servers connecting
~~~
Now on other servers execute 'join' and they connect.
~~~
....
minio join <url1> -- from <url2> && minio server
minio join <url1> -- from <url3> && minio server
...
...
minio join <url1> -- from <url16> && minio server
~~~
2016-02-13 00:27:10 +01:00
// Get current region.
2019-10-23 07:59:13 +02:00
region := globalServerRegion
2017-01-18 21:24:34 +01:00
if region != globalMinioDefaultRegion {
2016-03-06 21:16:22 +01:00
encodedSuccessResponse = encodeResponse ( LocationResponse {
config/main: Re-write config files - add to new config v3
- New config format.
```
{
"version": "3",
"address": ":9000",
"backend": {
"type": "fs",
"disk": "/path"
},
"credential": {
"accessKey": "WLGDGYAQYIGI833EV05A",
"secretKey": "BYvgJM101sHngl2uzjXS/OBF/aMxAN06JrJ3qJlF"
},
"region": "us-east-1",
"logger": {
"file": {
"enable": false,
"fileName": "",
"level": "error"
},
"syslog": {
"enable": false,
"address": "",
"level": "debug"
},
"console": {
"enable": true,
"level": "fatal"
}
}
}
```
New command lines in lieu of supporting XL.
Minio initialize filesystem backend.
~~~
$ minio init fs <path>
~~~
Minio initialize XL backend.
~~~
$ minio init xl <url1>...<url16>
~~~
For 'fs' backend it starts the server.
~~~
$ minio server
~~~
For 'xl' backend it waits for servers to join.
~~~
$ minio server
... [PROGRESS BAR] of servers connecting
~~~
Now on other servers execute 'join' and they connect.
~~~
....
minio join <url1> -- from <url2> && minio server
minio join <url1> -- from <url3> && minio server
...
...
minio join <url1> -- from <url16> && minio server
~~~
2016-02-13 00:27:10 +01:00
Location : region ,
2016-02-16 02:42:39 +01:00
} )
}
2017-01-06 09:37:00 +01:00
// Write success response.
writeSuccessResponseXML ( w , encodedSuccessResponse )
2015-12-27 08:38:38 +01:00
}
2015-07-01 05:15:48 +02:00
// ListMultipartUploadsHandler - GET Bucket (List Multipart uploads)
2015-06-30 23:42:29 +02:00
// -------------------------
// This operation lists in-progress multipart uploads. An in-progress
// multipart upload is a multipart upload that has been initiated,
2015-10-17 04:09:35 +02:00
// using the Initiate Multipart Upload request, but has not yet been
// completed or aborted. This operation returns at most 1,000 multipart
// uploads in the response.
2015-06-30 23:42:29 +02:00
//
2016-04-12 21:45:15 +02:00
func ( api objectAPIHandlers ) ListMultipartUploadsHandler ( w http . ResponseWriter , r * http . Request ) {
2018-07-21 03:46:32 +02:00
ctx := newContext ( r , w , "ListMultipartUploads" )
2018-03-14 20:01:47 +01:00
2018-11-22 05:03:24 +01:00
defer logger . AuditLog ( w , r , "ListMultipartUploads" , 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" ]
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 . ListBucketMultipartUploadsAction , bucket , "" ) ; s3Error != ErrNone {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( s3Error ) , r . URL , guessIsBrowserReq ( r ) )
2016-02-16 02:42:39 +01:00
return
2016-02-04 21:52:25 +01:00
}
2019-02-24 07:14:24 +01:00
prefix , keyMarker , uploadIDMarker , delimiter , maxUploads , encodingType , errCode := getBucketMultipartResources ( r . URL . Query ( ) )
2019-02-12 10:25:52 +01:00
if errCode != ErrNone {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( errCode ) , r . URL , guessIsBrowserReq ( r ) )
2018-10-18 16:31:46 +02:00
return
}
2019-02-12 10:25:52 +01:00
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 maxUploads < 0 {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrInvalidMaxUploads ) , r . URL , guessIsBrowserReq ( r ) )
2015-07-17 02:22:45 +02:00
return
}
2019-02-12 10:25:52 +01:00
2016-04-05 21:26:17 +02:00
if keyMarker != "" {
2016-04-29 23:24:10 +02:00
// Marker not common with prefix is not implemented.
2019-12-06 08:16:06 +01:00
if ! HasPrefix ( keyMarker , prefix ) {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrNotImplemented ) , r . URL , guessIsBrowserReq ( r ) )
2016-04-29 23:24:10 +02:00
return
2016-04-05 21:26:17 +02:00
}
2015-06-30 23:42:29 +02:00
}
2018-03-14 20:01:47 +01:00
listMultipartsInfo , err := objectAPI . ListMultipartUploads ( ctx , bucket , prefix , keyMarker , uploadIDMarker , delimiter , maxUploads )
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
// generate response
2019-02-24 07:14:24 +01:00
response := generateListMultipartUploadsResponse ( bucket , listMultipartsInfo , encodingType )
2016-03-06 21:16:22 +01:00
encodedSuccessResponse := encodeResponse ( response )
2017-01-06 09:37:00 +01:00
2016-01-08 09:40:06 +01:00
// write success response.
2017-01-06 09:37:00 +01:00
writeSuccessResponseXML ( w , encodedSuccessResponse )
2015-06-30 23:42:29 +02:00
}
2016-10-09 18:21:37 +02:00
// ListBucketsHandler - GET Service.
2015-06-30 23:42:29 +02:00
// -----------
// This implementation of the GET operation returns a list of all buckets
// owned by the authenticated sender of the request.
2016-04-12 21:45:15 +02:00
func ( api objectAPIHandlers ) ListBucketsHandler ( w http . ResponseWriter , r * http . Request ) {
2018-07-21 03:46:32 +02:00
ctx := newContext ( r , w , "ListBuckets" )
2018-03-14 20:01:47 +01:00
2018-11-22 05:03:24 +01:00
defer logger . AuditLog ( w , r , "ListBuckets" , 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-02-12 10:25:52 +01:00
listBuckets := objectAPI . ListBuckets
2018-04-25 00:53:30 +02:00
2019-08-12 19:27:38 +02:00
accessKey , owner , s3Error := checkRequestAuthTypeToAccessKey ( ctx , r , policy . ListAllMyBucketsAction , "" , "" )
if s3Error != ErrNone {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( s3Error ) , r . URL , guessIsBrowserReq ( r ) )
2016-02-16 02:42:39 +01:00
return
2016-02-04 21:52:25 +01:00
}
2019-02-12 10:25:52 +01:00
2018-02-03 03:18:52 +01:00
// If etcd, dns federation configured list buckets from etcd.
var bucketsInfo [ ] BucketInfo
if globalDNSConfig != nil {
dnsBuckets , err := globalDNSConfig . List ( )
2018-07-12 23:12:40 +02:00
if err != nil && err != dns . ErrNoEntriesFound {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2018-02-03 03:18:52 +01:00
return
}
2018-05-16 03:20:22 +02:00
bucketSet := set . NewStringSet ( )
2018-02-03 03:18:52 +01:00
for _ , dnsRecord := range dnsBuckets {
2018-05-16 03:20:22 +02:00
if bucketSet . Contains ( dnsRecord . Key ) {
continue
}
2018-02-03 03:18:52 +01:00
bucketsInfo = append ( bucketsInfo , BucketInfo {
2019-03-13 01:57:08 +01:00
Name : dnsRecord . Key ,
2018-02-03 03:18:52 +01:00
Created : dnsRecord . CreationDate ,
} )
2018-05-16 03:20:22 +02:00
bucketSet . Add ( dnsRecord . Key )
2018-02-03 03:18:52 +01:00
}
} else {
// Invoke the list buckets.
var err error
bucketsInfo , err = listBuckets ( ctx )
if err != nil {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2018-02-03 03:18:52 +01:00
return
}
2015-08-04 01:17:21 +02:00
}
2016-07-17 22:23:15 +02:00
2019-08-12 19:27:38 +02:00
// Set prefix value for "s3:prefix" policy conditionals.
r . Header . Set ( "prefix" , "" )
// Set delimiter value for "s3:delimiter" policy conditionals.
r . Header . Set ( "delimiter" , SlashSeparator )
2019-08-22 07:20:11 +02:00
// err will be nil here as we already called this function
// earlier in this request.
claims , _ := getClaimsFromToken ( r )
2019-08-12 19:27:38 +02:00
var newBucketsInfo [ ] BucketInfo
for _ , bucketInfo := range bucketsInfo {
if globalIAMSys . IsAllowed ( iampolicy . Args {
AccountName : accessKey ,
Action : iampolicy . ListBucketAction ,
BucketName : bucketInfo . Name ,
2019-10-16 17:59:59 +02:00
ConditionValues : getConditionValues ( r , "" , accessKey , claims ) ,
2019-08-12 19:27:38 +02:00
IsOwner : owner ,
ObjectName : "" ,
2019-08-22 07:20:11 +02:00
Claims : claims ,
2019-08-12 19:27:38 +02:00
} ) {
newBucketsInfo = append ( newBucketsInfo , bucketInfo )
}
}
2016-07-17 22:23:15 +02:00
// Generate response.
2019-08-12 19:27:38 +02:00
response := generateListBucketsResponse ( newBucketsInfo )
2016-07-17 22:23:15 +02:00
encodedSuccessResponse := encodeResponse ( response )
2017-01-06 09:37:00 +01:00
2016-07-17 22:23:15 +02:00
// Write response.
2017-01-06 09:37:00 +01:00
writeSuccessResponseXML ( w , encodedSuccessResponse )
2015-06-30 23:42:29 +02:00
}
2016-03-06 01:43:48 +01:00
// DeleteMultipleObjectsHandler - deletes multiple objects.
2016-04-12 21:45:15 +02:00
func ( api objectAPIHandlers ) DeleteMultipleObjectsHandler ( w http . ResponseWriter , r * http . Request ) {
2018-07-21 03:46:32 +02:00
ctx := newContext ( r , w , "DeleteMultipleObjects" )
2018-03-14 20:01:47 +01:00
2018-11-22 05:03:24 +01:00
defer logger . AuditLog ( w , r , "DeleteMultipleObjects" , mustGetClaimsFromToken ( r ) )
2018-11-03 02:40:08 +01:00
2016-03-06 01:43:48 +01:00
vars := mux . Vars ( r )
bucket := vars [ "bucket" ]
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
}
2016-03-06 01:43:48 +01:00
// Content-Length is required and should be non-zero
// http://docs.aws.amazon.com/AmazonS3/latest/API/multiobjectdeleteapi.html
if r . ContentLength <= 0 {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMissingContentLength ) , r . URL , guessIsBrowserReq ( r ) )
2016-03-06 01:43:48 +01:00
return
}
// Content-Md5 is requied should be set
// http://docs.aws.amazon.com/AmazonS3/latest/API/multiobjectdeleteapi.html
if _ , ok := r . Header [ "Content-Md5" ] ; ! ok {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMissingContentMD5 ) , r . URL , guessIsBrowserReq ( r ) )
2016-03-06 01:43:48 +01:00
return
}
// Allocate incoming content length bytes.
2018-06-11 19:51:38 +02:00
var deleteXMLBytes [ ] byte
const maxBodySize = 2 * 1000 * 1024 // The max. XML contains 1000 object names (each at most 1024 bytes long) + XML overhead
if r . ContentLength > maxBodySize { // Only allocated memory for at most 1000 objects
deleteXMLBytes = make ( [ ] byte , maxBodySize )
} else {
deleteXMLBytes = make ( [ ] byte , r . ContentLength )
}
2016-03-06 01:43:48 +01:00
// Read incoming body XML bytes.
2016-04-29 23:24:10 +02:00
if _ , err := io . ReadFull ( r . Body , deleteXMLBytes ) ; err != nil {
2019-10-12 03:50:54 +02:00
logger . LogIf ( ctx , err , logger . Application )
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAdminAPIErr ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2016-03-06 01:43:48 +01:00
return
}
// Unmarshal list of keys to be deleted.
deleteObjects := & DeleteObjectsRequest { }
2016-04-29 23:24:10 +02:00
if err := xml . Unmarshal ( deleteXMLBytes , deleteObjects ) ; err != nil {
2019-10-12 03:50:54 +02:00
logger . LogIf ( ctx , err , logger . Application )
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMalformedXML ) , r . URL , guessIsBrowserReq ( r ) )
2016-03-06 01:43:48 +01:00
return
}
2018-03-28 01:44:45 +02:00
2019-05-13 21:25:49 +02:00
deleteObjectsFn := objectAPI . DeleteObjects
2018-07-21 06:21:01 +02:00
if api . CacheAPI ( ) != nil {
2019-05-13 21:25:49 +02:00
deleteObjectsFn = api . CacheAPI ( ) . DeleteObjects
2018-07-21 06:21:01 +02:00
}
2016-09-02 10:59:08 +02:00
2019-11-20 02:42:27 +01:00
var objectsToDelete = map [ string ] int { }
2019-11-20 22:18:09 +01:00
getObjectInfoFn := objectAPI . GetObjectInfo
if api . CacheAPI ( ) != nil {
getObjectInfoFn = api . CacheAPI ( ) . GetObjectInfo
}
2019-04-22 16:54:43 +02:00
var dErrs = make ( [ ] APIErrorCode , len ( deleteObjects . Objects ) )
2019-05-13 21:25:49 +02:00
2016-09-02 10:59:08 +02:00
for index , object := range deleteObjects . Objects {
2019-04-22 16:54:43 +02:00
if dErrs [ index ] = checkRequestAuthType ( ctx , r , policy . DeleteObjectAction , bucket , object . ObjectName ) ; dErrs [ index ] != ErrNone {
if dErrs [ index ] == ErrSignatureDoesNotMatch || dErrs [ index ] == ErrInvalidAccessKeyID {
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( dErrs [ index ] ) , r . URL , guessIsBrowserReq ( r ) )
return
2017-08-15 21:49:31 +02:00
}
2018-07-21 06:21:01 +02:00
continue
}
2019-11-20 22:18:09 +01:00
govBypassPerms := checkRequestAuthType ( ctx , r , policy . BypassGovernanceRetentionAction , bucket , object . ObjectName )
2019-11-25 19:58:39 +01:00
if _ , err := enforceRetentionBypassForDelete ( ctx , r , bucket , object . ObjectName , getObjectInfoFn , govBypassPerms ) ; err != ErrNone {
2019-11-20 22:18:09 +01:00
dErrs [ index ] = err
continue
}
2019-11-20 02:42:27 +01:00
// Avoid duplicate objects, we use map to filter them out.
if _ , ok := objectsToDelete [ object . ObjectName ] ; ! ok {
objectsToDelete [ object . ObjectName ] = index
}
2019-05-13 21:25:49 +02:00
}
2019-11-20 02:42:27 +01:00
toNames := func ( input map [ string ] int ) ( output [ ] string ) {
2019-05-13 21:25:49 +02:00
output = make ( [ ] string , len ( input ) )
2019-11-21 02:51:10 +01:00
idx := 0
for name := range input {
output [ idx ] = name
idx ++
2019-04-22 16:54:43 +02:00
}
2019-05-13 21:25:49 +02:00
return
}
2019-11-21 02:51:10 +01:00
deleteList := toNames ( objectsToDelete )
errs , err := deleteObjectsFn ( ctx , bucket , deleteList )
2019-05-13 21:25:49 +02:00
if err != nil {
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
return
}
2019-11-21 02:51:10 +01:00
for i , objName := range deleteList {
dIdx := objectsToDelete [ objName ]
dErrs [ dIdx ] = toAPIErrorCode ( ctx , errs [ i ] )
2016-09-02 10:59:08 +02:00
}
// Collect deleted objects and errors if any.
2016-03-06 01:43:48 +01:00
var deletedObjects [ ] ObjectIdentifier
2016-09-02 10:59:08 +02:00
var deleteErrors [ ] DeleteError
2019-04-22 16:54:43 +02:00
for index , errCode := range dErrs {
2016-09-02 10:59:08 +02:00
object := deleteObjects . Objects [ index ]
// Success deleted objects are collected separately.
2019-04-22 16:54:43 +02:00
if errCode == ErrNone || errCode == ErrNoSuchKey {
2016-09-07 20:49:12 +02:00
deletedObjects = append ( deletedObjects , object )
continue
}
2019-04-22 16:54:43 +02:00
apiErr := getAPIError ( errCode )
2016-09-02 10:59:08 +02:00
// Error during delete should be collected separately.
deleteErrors = append ( deleteErrors , DeleteError {
2019-02-12 10:25:52 +01:00
Code : apiErr . Code ,
Message : apiErr . Description ,
2016-09-02 10:59:08 +02:00
Key : object . ObjectName ,
} )
2016-03-06 01:43:48 +01:00
}
2016-09-02 10:59:08 +02:00
2016-03-06 01:43:48 +01:00
// Generate response
response := generateMultiDeleteResponse ( deleteObjects . Quiet , deletedObjects , deleteErrors )
encodedSuccessResponse := encodeResponse ( response )
2017-01-06 09:37:00 +01:00
2016-03-06 01:43:48 +01:00
// Write success response.
2017-01-06 09:37:00 +01:00
writeSuccessResponseXML ( w , encodedSuccessResponse )
2016-09-02 10:59:08 +02:00
2016-09-29 07:46:19 +02:00
// Notify deleted event for objects.
for _ , dobj := range deletedObjects {
2018-03-15 21:03:41 +01:00
sendEvent ( eventArgs {
EventName : event . ObjectRemovedDelete ,
BucketName : bucket ,
Object : ObjectInfo {
2016-09-29 07:46:19 +02:00
Name : dobj . ObjectName ,
} ,
2018-11-03 02:40:08 +01:00
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-09-02 10:59:08 +02:00
}
2016-03-06 01:43:48 +01:00
}
2015-07-01 05:15:48 +02:00
// PutBucketHandler - PUT Bucket
2015-06-30 23:42:29 +02:00
// ----------
// This implementation of the PUT operation creates a new bucket for authenticated request
2016-04-12 21:45:15 +02:00
func ( api objectAPIHandlers ) PutBucketHandler ( w http . ResponseWriter , r * http . Request ) {
2018-07-21 03:46:32 +02:00
ctx := newContext ( r , w , "PutBucket" )
2018-03-14 20:01:47 +01:00
2018-11-22 05:03:24 +01:00
defer logger . AuditLog ( w , r , "PutBucket" , 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-04-25 00:53:30 +02:00
vars := mux . Vars ( r )
bucket := vars [ "bucket" ]
2019-11-12 23:50:18 +01:00
objectLockEnabled := false
2019-12-14 00:51:28 +01:00
if vs , found := r . Header [ http . CanonicalHeaderKey ( "x-amz-bucket-object-lock-enabled" ) ] ; found {
v := strings . ToLower ( strings . Join ( vs , "" ) )
if v != "true" && v != "false" {
2019-11-12 23:50:18 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrInvalidRequest ) , r . URL , guessIsBrowserReq ( r ) )
return
}
2019-12-14 00:51:28 +01:00
objectLockEnabled = v == "true"
2019-11-12 23:50:18 +01:00
}
2018-04-25 00:53:30 +02:00
if s3Error := checkRequestAuthType ( ctx , r , policy . CreateBucketAction , bucket , "" ) ; s3Error != ErrNone {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( s3Error ) , r . URL , guessIsBrowserReq ( r ) )
2016-02-04 21:52:25 +01:00
return
2015-07-14 18:17:30 +02:00
}
2017-04-03 23:50:09 +02:00
// Parse incoming location constraint.
location , s3Error := parseLocationConstraint ( r )
if s3Error != ErrNone {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( s3Error ) , r . URL , guessIsBrowserReq ( r ) )
2016-08-26 05:00:47 +02:00
return
2016-04-21 02:35:38 +02:00
}
2016-07-24 07:51:12 +02:00
2017-04-03 23:50:09 +02:00
// Validate if location sent by the client is valid, reject
// requests which do not follow valid region requirements.
if ! isValidLocation ( location ) {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrInvalidRegion ) , r . URL , guessIsBrowserReq ( r ) )
2017-04-03 23:50:09 +02:00
return
}
2018-02-03 03:18:52 +01:00
if globalDNSConfig != nil {
if _ , err := globalDNSConfig . Get ( bucket ) ; err != nil {
2018-07-12 23:12:40 +02:00
if err == dns . ErrNoEntriesFound {
2018-02-03 03:18:52 +01:00
// Proceed to creating a bucket.
if err = objectAPI . MakeBucketWithLocation ( ctx , bucket , location ) ; err != nil {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2018-02-03 03:18:52 +01:00
return
}
2019-11-12 23:50:18 +01:00
if objectLockEnabled {
2019-11-20 22:18:09 +01:00
configFile := path . Join ( bucketConfigPrefix , bucket , bucketObjectLockEnabledConfigFile )
if err = saveConfig ( ctx , objectAPI , configFile , [ ] byte ( bucketObjectLockEnabledConfig ) ) ; err != nil {
2019-11-12 23:50:18 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
return
}
}
2018-02-03 03:18:52 +01:00
if err = globalDNSConfig . Put ( bucket ) ; err != nil {
objectAPI . DeleteBucket ( ctx , bucket )
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2018-02-03 03:18:52 +01:00
return
}
// Make sure to add Location information here only for bucket
2019-07-03 07:34:32 +02:00
w . Header ( ) . Set ( xhttp . Location ,
getObjectLocation ( r , globalDomainNames , bucket , "" ) )
2018-02-03 03:18:52 +01:00
writeSuccessResponseHeadersOnly ( w )
return
}
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2018-02-03 03:18:52 +01:00
return
}
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrBucketAlreadyOwnedByYou ) , r . URL , guessIsBrowserReq ( r ) )
2018-02-16 02:45:57 +01:00
return
}
2016-07-24 07:51:12 +02:00
// Proceed to creating a bucket.
2018-03-14 20:01:47 +01:00
err := objectAPI . MakeBucketWithLocation ( ctx , bucket , location )
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
}
2017-01-06 09:37:00 +01:00
2019-11-12 23:50:18 +01:00
if objectLockEnabled {
2019-11-20 22:18:09 +01:00
configFile := path . Join ( bucketConfigPrefix , bucket , bucketObjectLockEnabledConfigFile )
if err = saveConfig ( ctx , objectAPI , configFile , [ ] byte ( bucketObjectLockEnabledConfig ) ) ; 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
globalBucketObjectLockConfig . Set ( bucket , Retention { } )
2019-11-21 22:18:32 +01:00
globalNotificationSys . PutBucketObjectLockConfig ( ctx , bucket , Retention { } )
2019-11-12 23:50:18 +01:00
}
2015-09-19 12:20:07 +02:00
// Make sure to add Location information here only for bucket
2019-07-03 07:34:32 +02:00
w . Header ( ) . Set ( xhttp . Location , path . Clean ( r . URL . Path ) ) // Clean any trailing slashes.
2017-01-06 09:37:00 +01:00
writeSuccessResponseHeadersOnly ( w )
2015-06-30 23:42:29 +02:00
}
2015-10-02 08:51:17 +02:00
// PostPolicyBucketHandler - POST policy
// ----------
// This implementation of the POST operation handles object creation with a specified
// signature policy in multipart/form-data
2016-04-12 21:45:15 +02:00
func ( api objectAPIHandlers ) PostPolicyBucketHandler ( w http . ResponseWriter , r * http . Request ) {
2018-07-21 03:46:32 +02:00
ctx := newContext ( r , w , "PostPolicyBucket" )
2018-03-14 20:01:47 +01:00
2018-11-22 05:03:24 +01:00
defer logger . AuditLog ( w , r , "PostPolicyBucket" , 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-02-12 10:25:52 +01:00
2018-12-15 06:39:59 +01: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-12-15 06:39:59 +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
}
2019-02-12 10:25:52 +01:00
2017-11-14 01:30:20 +01:00
bucket := mux . Vars ( r ) [ "bucket" ]
2019-06-29 07:09:17 +02:00
// To detect if the client has disconnected.
r . Body = & detectDisconnect { r . Body , r . Context ( ) . Done ( ) }
2017-02-02 19:45:00 +01:00
// Require Content-Length to be set in the request
size := r . ContentLength
if size < 0 {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMissingContentLength ) , r . URL , guessIsBrowserReq ( r ) )
2017-02-02 19:45:00 +01:00
return
}
2019-02-23 04:18:01 +01:00
resource , err := getResource ( r . URL . Path , r . Host , globalDomainNames )
2017-11-15 23:10:45 +01:00
if err != nil {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrInvalidRequest ) , r . URL , guessIsBrowserReq ( r ) )
2017-11-15 23:10:45 +01:00
return
}
// Make sure that the URL does not contain object name.
if bucket != filepath . Clean ( resource [ 1 : ] ) {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMethodNotAllowed ) , r . URL , guessIsBrowserReq ( r ) )
2017-11-15 23:10:45 +01:00
return
}
2017-02-02 19:45:00 +01:00
2015-10-02 08:51:17 +02:00
// Here the parameter is the size of the form data that should
2016-03-23 01:54:31 +01:00
// be loaded in memory, the remaining being put in temporary files.
2016-04-29 23:24:10 +02:00
reader , err := r . MultipartReader ( )
if err != nil {
2018-04-06 00:04:40 +02:00
logger . LogIf ( ctx , err )
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMalformedPOSTRequest ) , r . URL , guessIsBrowserReq ( r ) )
2015-10-02 08:51:17 +02:00
return
}
2017-02-02 19:45:00 +01:00
// Read multipart data and save in memory and in the disk if needed
form , err := reader . ReadForm ( maxFormMemory )
if err != nil {
2019-10-12 03:50:54 +02:00
logger . LogIf ( ctx , err , logger . Application )
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMalformedPOSTRequest ) , r . URL , guessIsBrowserReq ( r ) )
2017-02-02 19:45:00 +01:00
return
}
2019-07-10 07:18:43 +02:00
// Remove all tmp files created during multipart upload
2017-02-02 19:45:00 +01:00
defer form . RemoveAll ( )
// Extract all form fields
2018-04-06 00:04:40 +02:00
fileBody , fileName , fileSize , formValues , err := extractPostPolicyFormValues ( ctx , form )
2016-02-04 21:52:25 +01:00
if err != nil {
2019-10-12 03:50:54 +02:00
logger . LogIf ( ctx , err , logger . Application )
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMalformedPOSTRequest ) , r . URL , guessIsBrowserReq ( r ) )
2015-10-02 08:51:17 +02:00
return
}
2017-02-02 19:45:00 +01:00
2017-02-09 21:37:32 +01:00
// Check if file is provided, error out otherwise.
if fileBody == nil {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrPOSTFileRequired ) , r . URL , guessIsBrowserReq ( r ) )
2017-02-09 21:37:32 +01:00
return
}
2017-02-02 19:45:00 +01:00
// Close multipart file
defer fileBody . Close ( )
2017-03-13 22:41:13 +01:00
formValues . Set ( "Bucket" , bucket )
2016-02-16 02:42:39 +01:00
2017-03-13 22:41:13 +01:00
if fileName != "" && strings . Contains ( formValues . Get ( "Key" ) , "${filename}" ) {
2016-07-28 02:51:55 +02:00
// S3 feature to replace ${filename} found in Key form field
// by the filename attribute passed in multipart
2017-03-13 22:41:13 +01:00
formValues . Set ( "Key" , strings . Replace ( formValues . Get ( "Key" ) , "${filename}" , fileName , - 1 ) )
}
object := formValues . Get ( "Key" )
successRedirect := formValues . Get ( "success_action_redirect" )
successStatus := formValues . Get ( "success_action_status" )
var redirectURL * url . URL
if successRedirect != "" {
redirectURL , err = url . Parse ( successRedirect )
if err != nil {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMalformedPOSTRequest ) , r . URL , guessIsBrowserReq ( r ) )
2017-03-13 22:41:13 +01:00
return
}
2016-07-28 02:51:55 +02:00
}
2016-02-16 02:42:39 +01:00
// Verify policy signature.
2019-02-12 10:25:52 +01:00
errCode := doesPolicySignatureMatch ( formValues )
if errCode != ErrNone {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( errCode ) , r . URL , guessIsBrowserReq ( r ) )
2015-10-02 08:51:17 +02:00
return
}
2016-10-25 08:47:03 +02:00
2017-03-13 22:41:13 +01:00
policyBytes , err := base64 . StdEncoding . DecodeString ( formValues . Get ( "Policy" ) )
2016-10-25 08:47:03 +02:00
if err != nil {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMalformedPOSTRequest ) , r . URL , guessIsBrowserReq ( r ) )
2016-10-25 08:47:03 +02:00
return
}
2018-12-03 21:01:28 +01:00
// Handle policy if it is set.
if len ( policyBytes ) > 0 {
2019-09-22 23:20:49 +02:00
2018-12-03 21:01:28 +01:00
postPolicyForm , err := parsePostPolicyForm ( string ( policyBytes ) )
if err != nil {
2019-09-22 23:20:49 +02:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrPostPolicyConditionInvalidFormat ) , r . URL , guessIsBrowserReq ( r ) )
2017-02-02 19:45:00 +01:00
return
2016-11-21 13:15:26 +01:00
}
2017-02-02 19:45:00 +01:00
2018-12-03 21:01:28 +01:00
// Make sure formValues adhere to policy restrictions.
2019-03-05 21:10:47 +01:00
if err = checkPostPolicy ( formValues , postPolicyForm ) ; err != nil {
writeCustomErrorResponseXML ( ctx , w , errorCodes . ToAPIErr ( ErrAccessDenied ) , err . Error ( ) , r . URL , guessIsBrowserReq ( r ) )
2017-02-02 19:45:00 +01:00
return
2016-11-21 13:15:26 +01:00
}
2018-12-03 21:01:28 +01:00
// Ensure that the object size is within expected range, also the file size
// should not exceed the maximum single Put size (5 GiB)
lengthRange := postPolicyForm . Conditions . ContentLengthRange
if lengthRange . Valid {
if fileSize < lengthRange . Min {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , errDataTooSmall ) , r . URL , guessIsBrowserReq ( r ) )
2018-12-03 21:01:28 +01:00
return
}
if fileSize > lengthRange . Max || isMaxObjectSize ( fileSize ) {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , errDataTooLarge ) , r . URL , guessIsBrowserReq ( r ) )
2018-12-03 21:01:28 +01:00
return
}
}
2016-10-25 08:47:03 +02:00
}
2016-12-20 01:14:04 +01:00
// Extract metadata to be saved from received Form.
2018-07-11 05:27:10 +02:00
metadata := make ( map [ string ] string )
err = extractMetadataFromMap ( ctx , formValues , metadata )
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
}
2016-10-03 00:51:49 +02:00
2019-05-09 03:35:40 +02:00
hashReader , err := hash . NewReader ( fileBody , fileSize , "" , "" , fileSize , globalCLIContext . StrictS3Compat )
2017-10-22 07:30:34 +02:00
if err != nil {
2018-04-06 00:04:40 +02:00
logger . LogIf ( ctx , err )
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 )
var objectEncryptionKey [ ] byte
2018-12-14 22:35:48 +01:00
2019-01-05 23:16:43 +01:00
// This request header needs to be set prior to setting ObjectOptions
2018-12-14 22:35:48 +01:00
if globalAutoEncryption && ! crypto . SSEC . IsRequested ( r . Header ) {
r . Header . Add ( crypto . SSEHeader , crypto . SSEAlgorithmAES256 )
}
2019-01-05 23:16:43 +01:00
// get gateway encryption options
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
}
2018-03-05 17:02:56 +01:00
if objectAPI . IsEncryptionSupported ( ) {
2019-12-06 08:16:06 +01:00
if crypto . IsRequested ( formValues ) && ! 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
}
2018-03-05 17:02:56 +01:00
var reader io . Reader
var key [ ] byte
2018-08-17 21:52:14 +02:00
if crypto . SSEC . IsRequested ( formValues ) {
key , err = ParseSSECustomerHeader ( formValues )
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-05 17:02:56 +01:00
}
2018-11-15 02:36:41 +01:00
reader , objectEncryptionKey , err = newEncryptReader ( hashReader , key , bucket , object , metadata , crypto . S3 . IsRequested ( formValues ) )
2018-03-05 17:02:56 +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-05 17:02:56 +01:00
return
}
info := ObjectInfo { Size : fileSize }
2019-05-09 03:35:40 +02:00
// do not try to verify encrypted content
hashReader , err = hash . NewReader ( reader , info . EncryptedSize ( ) , "" , "" , fileSize , globalCLIContext . StrictS3Compat )
2018-03-05 17:02:56 +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-05 17:02:56 +01:00
return
}
2018-11-15 02:36:41 +01:00
pReader = NewPutObjReader ( rawReader , hashReader , objectEncryptionKey )
2018-03-05 17:02:56 +01:00
}
}
2019-02-09 06:31:06 +01:00
objInfo , err := objectAPI . PutObject ( ctx , bucket , object , pReader , opts )
2016-02-04 21:52:25 +01:00
if err != nil {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2015-10-02 08:51:17 +02:00
return
}
2017-03-13 22:41:13 +01:00
2019-02-23 04:18:01 +01:00
location := getObjectLocation ( r , globalDomainNames , bucket , object )
2019-07-03 07:34:32 +02:00
w . Header ( ) [ xhttp . ETag ] = [ ] string { ` " ` + objInfo . ETag + ` " ` }
w . Header ( ) . Set ( xhttp . Location , location )
2016-08-05 07:01:58 +02:00
2017-03-13 22:41:13 +01:00
// Notify object created event.
2018-03-15 21:03:41 +01:00
defer sendEvent ( eventArgs {
2018-11-03 02:40:08 +01:00
EventName : event . ObjectCreatedPost ,
BucketName : objInfo . 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-13 22:41:13 +01:00
} )
if successRedirect != "" {
// Replace raw query params..
redirectURL . RawQuery = getRedirectPostRawQuery ( objInfo )
writeRedirectSeeOther ( w , redirectURL . String ( ) )
return
}
2016-07-24 07:51:12 +02:00
2017-03-13 22:41:13 +01:00
// Decide what http response to send depending on success_action_status parameter
switch successStatus {
case "201" :
resp := encodeResponse ( PostResponse {
Bucket : objInfo . Bucket ,
Key : objInfo . Name ,
2017-05-14 21:05:51 +02:00
ETag : ` " ` + objInfo . ETag + ` " ` ,
2017-09-25 01:43:21 +02:00
Location : location ,
2017-03-13 22:41:13 +01:00
} )
writeResponse ( w , http . StatusCreated , resp , "application/xml" )
case "200" :
writeSuccessResponseHeadersOnly ( w )
default :
2016-12-18 22:39:56 +01:00
writeSuccessNoContent ( w )
}
2015-10-02 08:51:17 +02:00
}
2015-07-01 05:15:48 +02:00
// HeadBucketHandler - HEAD Bucket
2015-06-30 23:42:29 +02:00
// ----------
// This operation is useful to determine if a bucket exists.
// The operation returns a 200 OK if the bucket exists and you
// have permission to access it. Otherwise, the operation might
// return responses such as 404 Not Found and 403 Forbidden.
2016-04-12 21:45:15 +02:00
func ( api objectAPIHandlers ) HeadBucketHandler ( w http . ResponseWriter , r * http . Request ) {
2018-07-21 03:46:32 +02:00
ctx := newContext ( r , w , "HeadBucket" )
2018-03-14 20:01:47 +01:00
2018-11-22 05:03:24 +01:00
defer logger . AuditLog ( w , r , "HeadBucket" , mustGetClaimsFromToken ( r ) )
2018-10-12 21:25:59 +02:00
2016-02-16 02:42:39 +01:00
vars := mux . Vars ( r )
2015-06-30 23:42:29 +02:00
bucket := vars [ "bucket" ]
2015-07-03 05:31:22 +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
}
2016-11-21 22:51:05 +01:00
2018-04-25 00:53:30 +02:00
if s3Error := checkRequestAuthType ( ctx , r , policy . ListBucketAction , bucket , "" ) ; s3Error != ErrNone {
2019-02-12 10:25:52 +01:00
writeErrorResponseHeadersOnly ( w , errorCodes . ToAPIErr ( s3Error ) )
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
}
2018-04-25 00:53:30 +02:00
2018-03-28 23:14:06 +02:00
getBucketInfo := objectAPI . GetBucketInfo
2019-08-10 02:09:08 +02:00
2018-03-28 23:14:06 +02:00
if _ , err := getBucketInfo ( ctx , bucket ) ; err != nil {
2019-02-12 10:25:52 +01:00
writeErrorResponseHeadersOnly ( w , toAPIError ( ctx , err ) )
2015-08-04 01:17:21 +02:00
return
}
2017-01-06 09:37:00 +01:00
writeSuccessResponseHeadersOnly ( w )
2015-06-30 23:42:29 +02:00
}
2015-10-16 20:26:01 +02:00
// DeleteBucketHandler - Delete bucket
2016-04-12 21:45:15 +02:00
func ( api objectAPIHandlers ) DeleteBucketHandler ( w http . ResponseWriter , r * http . Request ) {
2018-07-21 03:46:32 +02:00
ctx := newContext ( r , w , "DeleteBucket" )
2018-03-14 20:01:47 +01:00
2018-11-22 05:03:24 +01:00
defer logger . AuditLog ( w , r , "DeleteBucket" , mustGetClaimsFromToken ( r ) )
2018-10-12 21:25:59 +02:00
2018-04-25 00:53:30 +02:00
vars := mux . Vars ( r )
bucket := vars [ "bucket" ]
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 . DeleteBucketAction , bucket , "" ) ; s3Error != ErrNone {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( s3Error ) , r . URL , guessIsBrowserReq ( r ) )
2016-02-16 02:42:39 +01:00
return
2016-02-04 21:52:25 +01:00
}
2018-03-28 23:14:06 +02:00
deleteBucket := objectAPI . DeleteBucket
2019-08-10 02:09:08 +02:00
2016-07-24 07:51:12 +02:00
// Attempt to delete bucket.
2018-03-28 23:14:06 +02:00
if err := deleteBucket ( ctx , bucket ) ; err != nil {
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2015-10-16 20:26:01 +02:00
return
}
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
2018-02-03 03:18:52 +01:00
if globalDNSConfig != nil {
if err := globalDNSConfig . Delete ( bucket ) ; err != nil {
// Deleting DNS entry failed, attempt to create the bucket again.
objectAPI . MakeBucketWithLocation ( ctx , bucket , "" )
2019-02-14 01:07:21 +01:00
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
2018-02-03 03:18:52 +01:00
return
}
}
2019-04-18 02:29:49 +02:00
globalNotificationSys . DeleteBucket ( ctx , bucket )
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.
2015-10-17 05:02:37 +02:00
writeSuccessNoContent ( w )
2015-10-16 20:26:01 +02:00
}
2019-11-12 23:50:18 +01:00
// PutBucketVersioningHandler - PUT Bucket Versioning.
// ----------
// No-op. Available for API compatibility.
func ( api objectAPIHandlers ) PutBucketVersioningHandler ( w http . ResponseWriter , r * http . Request ) {
ctx := newContext ( r , w , "PutBucketVersioning" )
defer logger . AuditLog ( w , r , "PutBucketVersioning" , mustGetClaimsFromToken ( r ) )
vars := mux . Vars ( r )
bucket := vars [ "bucket" ]
objectAPI := api . ObjectAPI ( )
if objectAPI == nil {
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrServerNotInitialized ) , r . URL , guessIsBrowserReq ( r ) )
return
}
getBucketInfo := objectAPI . GetBucketInfo
if _ , err := getBucketInfo ( ctx , bucket ) ; err != nil {
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
return
}
// Write success response.
writeSuccessResponseHeadersOnly ( w )
}
// GetBucketVersioningHandler - GET Bucket Versioning.
// ----------
// No-op. Available for API compatibility.
func ( api objectAPIHandlers ) GetBucketVersioningHandler ( w http . ResponseWriter , r * http . Request ) {
ctx := newContext ( r , w , "GetBucketVersioning" )
defer logger . AuditLog ( w , r , "GetBucketVersioning" , mustGetClaimsFromToken ( r ) )
vars := mux . Vars ( r )
bucket := vars [ "bucket" ]
objectAPI := api . ObjectAPI ( )
if objectAPI == nil {
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrServerNotInitialized ) , r . URL , guessIsBrowserReq ( r ) )
return
}
getBucketInfo := objectAPI . GetBucketInfo
if _ , err := getBucketInfo ( ctx , bucket ) ; err != nil {
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
return
}
// Write success response.
writeSuccessResponseXML ( w , [ ] byte ( getBucketVersioningResponse ) )
}
// PutBucketObjectLockConfigHandler - PUT Bucket object lock configuration.
// ----------
// Places an Object Lock configuration on the specified bucket. The rule
// specified in the Object Lock configuration will be applied by default
// to every new object placed in the specified bucket.
func ( api objectAPIHandlers ) PutBucketObjectLockConfigHandler ( w http . ResponseWriter , r * http . Request ) {
ctx := newContext ( r , w , "PutBucketObjectLockConfig" )
defer logger . AuditLog ( w , r , "PutBucketObjectLockConfig" , mustGetClaimsFromToken ( r ) )
vars := mux . Vars ( r )
bucket := vars [ "bucket" ]
objectAPI := api . ObjectAPI ( )
if objectAPI == nil {
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrServerNotInitialized ) , r . URL , guessIsBrowserReq ( r ) )
return
}
// Deny if WORM is enabled
if globalWORMEnabled {
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrMethodNotAllowed ) , r . URL , guessIsBrowserReq ( r ) )
return
}
2019-11-20 22:18:09 +01:00
if s3Error := checkRequestAuthType ( ctx , r , policy . PutBucketObjectLockConfigurationAction , bucket , "" ) ; s3Error != ErrNone {
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( s3Error ) , r . URL , guessIsBrowserReq ( r ) )
return
}
2019-11-12 23:50:18 +01:00
config , err := parseObjectLockConfig ( r . Body )
if err != nil {
2019-11-13 17:21:41 +01:00
apiErr := errorCodes . ToAPIErr ( ErrMalformedXML )
apiErr . Description = err . Error ( )
writeErrorResponse ( ctx , w , apiErr , r . URL , guessIsBrowserReq ( r ) )
2019-11-12 23:50:18 +01:00
return
}
2019-11-20 22:18:09 +01:00
configFile := path . Join ( bucketConfigPrefix , bucket , bucketObjectLockEnabledConfigFile )
2019-11-12 23:50:18 +01:00
configData , err := readConfig ( ctx , objectAPI , configFile )
if err != nil {
aerr := toAPIError ( ctx , err )
if err == errConfigNotFound {
aerr = errorCodes . ToAPIErr ( ErrMethodNotAllowed )
}
writeErrorResponse ( ctx , w , aerr , r . URL , guessIsBrowserReq ( r ) )
return
}
2019-11-20 22:18:09 +01:00
if string ( configData ) != bucketObjectLockEnabledConfig {
2019-11-12 23:50:18 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrInternalError ) , r . URL , guessIsBrowserReq ( r ) )
return
}
2019-11-20 22:18:09 +01:00
data , err := xml . Marshal ( config )
if err != nil {
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
return
}
configFile = path . Join ( bucketConfigPrefix , bucket , objectLockConfig )
if err = saveConfig ( ctx , objectAPI , configFile , data ) ; err != nil {
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
return
}
2019-11-12 23:50:18 +01:00
if config . Rule != nil {
retention := config . ToRetention ( )
2019-11-20 22:18:09 +01:00
globalBucketObjectLockConfig . Set ( bucket , retention )
2019-11-12 23:50:18 +01:00
globalNotificationSys . PutBucketObjectLockConfig ( ctx , bucket , retention )
} else {
2019-11-21 22:18:32 +01:00
globalBucketObjectLockConfig . Remove ( bucket )
globalNotificationSys . RemoveBucketObjectLockConfig ( ctx , bucket )
2019-11-12 23:50:18 +01:00
}
// Write success response.
writeSuccessResponseHeadersOnly ( w )
}
// GetBucketObjectLockConfigHandler - GET Bucket object lock configuration.
// ----------
// Gets the Object Lock configuration for a bucket. The rule specified in
// the Object Lock configuration will be applied by default to every new
// object placed in the specified bucket.
func ( api objectAPIHandlers ) GetBucketObjectLockConfigHandler ( w http . ResponseWriter , r * http . Request ) {
ctx := newContext ( r , w , "GetBucketObjectLockConfig" )
defer logger . AuditLog ( w , r , "GetBucketObjectLockConfig" , mustGetClaimsFromToken ( r ) )
vars := mux . Vars ( r )
bucket := vars [ "bucket" ]
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
// check if user has permissions to perform this operation
if s3Error := checkRequestAuthType ( ctx , r , policy . GetBucketObjectLockConfigurationAction , bucket , "" ) ; s3Error != ErrNone {
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( s3Error ) , r . URL , guessIsBrowserReq ( r ) )
return
}
configFile := path . Join ( bucketConfigPrefix , bucket , bucketObjectLockEnabledConfigFile )
2019-11-12 23:50:18 +01:00
configData , err := readConfig ( ctx , objectAPI , configFile )
if err != nil {
2019-11-21 10:54:49 +01:00
var aerr APIError
2019-11-12 23:50:18 +01:00
if err == errConfigNotFound {
aerr = errorCodes . ToAPIErr ( ErrMethodNotAllowed )
2019-11-21 10:54:49 +01:00
} else {
aerr = toAPIError ( ctx , err )
2019-11-12 23:50:18 +01:00
}
writeErrorResponse ( ctx , w , aerr , r . URL , guessIsBrowserReq ( r ) )
return
}
2019-11-20 22:18:09 +01:00
if string ( configData ) != bucketObjectLockEnabledConfig {
2019-11-12 23:50:18 +01:00
writeErrorResponse ( ctx , w , errorCodes . ToAPIErr ( ErrInternalError ) , r . URL , guessIsBrowserReq ( r ) )
return
}
configFile = path . Join ( bucketConfigPrefix , bucket , objectLockConfig )
configData , err = readConfig ( ctx , objectAPI , configFile )
if err != nil {
if err != errConfigNotFound {
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
return
}
if configData , err = xml . Marshal ( newObjectLockConfig ( ) ) ; err != nil {
writeErrorResponse ( ctx , w , toAPIError ( ctx , err ) , r . URL , guessIsBrowserReq ( r ) )
return
}
}
// Write success response.
writeSuccessResponseXML ( w , configData )
}