Merge pull request #474 from harshavardhana/pr_out_finishing_all_the_test_case_support_for_acl_and_other_fixes

pkg/api/api_bucket_handlers.go

@@ -25,6 +25,35 @@ import (
 	"github.com/minio-io/minio/pkg/utils/log"
 )
 
+func (server *minioAPI) isValidOp(w http.ResponseWriter, req *http.Request, acceptsContentType contentType) bool {
+	vars := mux.Vars(req)
+	bucket := vars["bucket"]
+
+	bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
+	switch iodine.ToError(err).(type) {
+	case drivers.BucketNotFound:
+		{
+			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
+			return false
+		}
+	case drivers.BucketNameInvalid:
+		{
+			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
+			return false
+		}
+	case nil:
+		if stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate() {
+			writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
+			return false
+		}
+		if bucketMetadata.ACL.IsPublicRead() && req.Method == "PUT" {
+			writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
+			return false
+		}
+	}
+	return true
+}
+
 // GET Bucket (List Objects)
 // -------------------------
 // This implementation of the GET operation returns some or all (up to 1000)
@@ -37,6 +66,10 @@ func (server *minioAPI) listObjectsHandler(w http.ResponseWriter, req *http.Requ
 		writeErrorResponse(w, req, NotAcceptable, acceptsContentType, req.URL.Path)
 		return
 	}
+	// verify if bucket allows this operation
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
+	}
 
 	resources := getBucketResources(req.URL.Query())
 	if resources.Maxkeys == 0 {
@@ -46,16 +79,8 @@ func (server *minioAPI) listObjectsHandler(w http.ResponseWriter, req *http.Requ
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
 
-	// Enable this after tests supports them
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
 	objects, resources, err := server.driver.ListObjects(bucket, resources)
-	switch err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil: // success
 		{
 			// write headers
@@ -66,13 +91,9 @@ func (server *minioAPI) listObjectsHandler(w http.ResponseWriter, req *http.Requ
 			encodedSuccessResponse := encodeSuccessResponse(response, acceptsContentType)
 			w.Write(encodedSuccessResponse)
 		}
-	case drivers.BucketNotFound:
+	case drivers.ObjectNotFound:
 		{
-			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
+			writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
-		}
-	case drivers.BucketNameInvalid:
-		{
-			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
 		}
 	case drivers.ObjectNameInvalid:
 		{
@@ -99,7 +120,7 @@ func (server *minioAPI) listBucketsHandler(w http.ResponseWriter, req *http.Requ
 
 	buckets, err := server.driver.ListBuckets()
 	// cannot fallthrough in (type) switch :(
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil:
 		{
 			response := generateBucketsListResult(buckets)
@@ -138,7 +159,7 @@ func (server *minioAPI) putBucketHandler(w http.ResponseWriter, req *http.Reques
 	vars := mux.Vars(req)
 	bucket := vars["bucket"]
 	err := server.driver.CreateBucket(bucket, getACLTypeString(aclType))
-	switch err.(type) {
+	switch iodine.ToError(err).(type) {
 	case nil:
 		{
 			w.Header().Set("Server", "Minio")
@@ -174,37 +195,13 @@ func (server *minioAPI) headBucketHandler(w http.ResponseWriter, req *http.Reque
 		return
 	}
 
-	vars := mux.Vars(req)
+	// verify if bucket allows this operation
-	bucket := vars["bucket"]
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
+	}
 
-	// Enable this after tests supports them
+	// Always a success if isValidOp succeeds
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
-	_, err := server.driver.GetBucketMetadata(bucket)
-	switch err.(type) {
-	case nil:
-		{
 	w.Header().Set("Server", "Minio")
 	w.Header().Set("Connection", "close")
 	w.WriteHeader(http.StatusOK)
 }
-	case drivers.BucketNameInvalid:
-		{
-			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
-		}
-	case drivers.BucketNotFound:
-		{
-			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
-		}
-	default:
-		{
-			log.Error.Println(iodine.New(err, nil))
-			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
-		}
-	}
-}

pkg/api/api_generic_handlers.go

@@ -56,12 +56,17 @@ func validateHandler(conf config.Config, h http.Handler) http.Handler {
 
 // Validate handler ServeHTTP() wrapper
 func (h vHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	accessKey := stripAccessKey(r)
 	acceptsContentType := getContentType(r)
 	if acceptsContentType == unknownContentType {
 		writeErrorResponse(w, r, NotAcceptable, acceptsContentType, r.URL.Path)
 		return
 	}
+	// success
+	h.handler.ServeHTTP(w, r)
+
+	// Enable below only when webcli is ready
+
+	/*
 		switch true {
 		case accessKey != "":
 			if err := h.conf.ReadConfig(); err != nil {
@@ -93,6 +98,7 @@ func (h vHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			// w.WriteHeader(error.HTTPStatusCode)
 			// w.Write(writeErrorResponse(w, errorResponse, acceptsContentType))
 		}
+	*/
 }
 
 // Ignore resources handler is wrapper handler used for API request resource validation

pkg/api/api_object_handlers.go

@@ -36,22 +36,17 @@ func (server *minioAPI) getObjectHandler(w http.ResponseWriter, req *http.Reques
 		return
 	}
 
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
 	var object, bucket string
 	vars := mux.Vars(req)
 	bucket = vars["bucket"]
 	object = vars["object"]
 
-	// Enable this after tests supports them
-
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
 	metadata, err := server.driver.GetObjectMetadata(bucket, object, "")
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil: // success
 		{
 			httpRange, err := getRequestedRange(req, metadata.Size)
@@ -80,18 +75,10 @@ func (server *minioAPI) getObjectHandler(w http.ResponseWriter, req *http.Reques
 		{
 			writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
 		}
-	case drivers.BucketNotFound:
-		{
-			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
-		}
 	case drivers.ObjectNameInvalid:
 		{
 			writeErrorResponse(w, req, NoSuchKey, acceptsContentType, req.URL.Path)
 		}
-	case drivers.BucketNameInvalid:
-		{
-			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
-		}
 	default:
 		{
 			log.Error.Println(iodine.New(err, nil))
@@ -110,21 +97,17 @@ func (server *minioAPI) headObjectHandler(w http.ResponseWriter, req *http.Reque
 		return
 	}
 
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
 	var object, bucket string
 	vars := mux.Vars(req)
 	bucket = vars["bucket"]
 	object = vars["object"]
 
-	// verify for if bucket is private or public
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
 	metadata, err := server.driver.GetObjectMetadata(bucket, object, "")
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil:
 		{
 			setObjectHeaders(w, metadata)
@@ -156,19 +139,16 @@ func (server *minioAPI) putObjectHandler(w http.ResponseWriter, req *http.Reques
 		return
 	}
 
+	// handle PublicRead ACL here
+	if !server.isValidOp(w, req, acceptsContentType) {
+		return
+	}
+
 	var object, bucket string
 	vars := mux.Vars(req)
 	bucket = vars["bucket"]
 	object = vars["object"]
 
-	// verify for if bucket is private or public
-	// verify for if bucket is private or public
-	// bucketMetadata, err := server.driver.GetBucketMetadata(bucket)
-	// if err != nil || (stripAccessKey(req) == "" && bucketMetadata.ACL.IsPrivate()) || bucketMetadtata.ACL.IsPublicRead() {
-	//        writeErrorResponse(w, req, AccessDenied, acceptsContentType, req.URL.Path)
-	//        return
-	// }
-
 	// get Content-MD5 sent by client and verify if valid
 	md5 := req.Header.Get("Content-MD5")
 	if !isValidMD5(md5) {
@@ -176,24 +156,11 @@ func (server *minioAPI) putObjectHandler(w http.ResponseWriter, req *http.Reques
 		return
 	}
 	err := server.driver.CreateObject(bucket, object, "", md5, req.Body)
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case nil:
 		w.Header().Set("Server", "Minio")
 		w.Header().Set("Connection", "close")
 		w.WriteHeader(http.StatusOK)
-	case drivers.ImplementationError:
-		{
-			log.Error.Println(err)
-			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
-		}
-	case drivers.BucketNotFound:
-		{
-			writeErrorResponse(w, req, NoSuchBucket, acceptsContentType, req.URL.Path)
-		}
-	case drivers.BucketNameInvalid:
-		{
-			writeErrorResponse(w, req, InvalidBucketName, acceptsContentType, req.URL.Path)
-		}
 	case drivers.ObjectExists:
 		{
 			writeErrorResponse(w, req, NotImplemented, acceptsContentType, req.URL.Path)
@@ -206,6 +173,11 @@ func (server *minioAPI) putObjectHandler(w http.ResponseWriter, req *http.Reques
 		{
 			writeErrorResponse(w, req, InvalidDigest, acceptsContentType, req.URL.Path)
 		}
+	case drivers.ImplementationError:
+		{
+			log.Error.Println(err)
+			writeErrorResponse(w, req, InternalError, acceptsContentType, req.URL.Path)
+		}
 	default:
 		{
 			log.Error.Println(err)

pkg/api/api_test.go

@@ -14,10 +14,13 @@
  * limitations under the License.
  */
 
-package api_test
+package api
 
 import (
 	"bytes"
+	"crypto/hmac"
+	"crypto/sha1"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"log"
@@ -28,11 +31,11 @@ import (
 	"testing"
 	"time"
 
+	"encoding/base64"
 	"encoding/xml"
 	"net/http"
 	"net/http/httptest"
 
-	"github.com/minio-io/minio/pkg/api"
 	"github.com/minio-io/minio/pkg/storage/drivers"
 	"github.com/minio-io/minio/pkg/storage/drivers/donut"
 	"github.com/minio-io/minio/pkg/storage/drivers/memory"
@@ -107,7 +110,20 @@ func (s *MySuite) TearDownTest(c *C) {
 	s.Root = ""
 }
 
-func (s *MySuite) TestNonExistantObject(c *C) {
+func setAuthHeader(req *http.Request) {
+	hm := hmac.New(sha1.New, []byte("H+AVh8q5G7hEH2r3WxFP135+Q19Aw8yXWel8IGh/HrEjZyTNx/n4Xw=="))
+	ss := getStringToSign(req)
+	io.WriteString(hm, ss)
+
+	authHeader := new(bytes.Buffer)
+	fmt.Fprintf(authHeader, "AWS %s:", "AC5NH40NQLTL4D2W92PM")
+	encoder := base64.NewEncoder(base64.StdEncoding, authHeader)
+	encoder.Write(hm.Sum(nil))
+	encoder.Close()
+	req.Header.Set("Authorization", authHeader.String())
+}
+
+func (s *MySuite) TestNonExistantBucket(c *C) {
 	switch driver := s.Driver.(type) {
 	case *mocks.Driver:
 		{
@@ -115,12 +131,17 @@ func (s *MySuite) TestNonExistantObject(c *C) {
 		}
 	}
 	driver := s.Driver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
-	s.MockDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.BucketNotFound{Bucket: "bucket"}).Once()
+	s.MockDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, drivers.BucketNotFound{Bucket: "bucket"}).Once()
-	response, err := http.Get(testServer.URL + "/bucket/object")
+	request, err := http.NewRequest("HEAD", testServer.URL+"/bucket", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusNotFound)
 }
@@ -144,10 +165,11 @@ func (s *MySuite) TestEmptyObject(c *C) {
 	}
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
 	typedDriver.On("CreateObject", "bucket", "object", "", "", mock.Anything).Return(nil).Once()
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Twice()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(metadata, nil).Once()
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object").Return(int64(0), nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(metadata, nil).Once()
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -155,7 +177,12 @@ func (s *MySuite) TestEmptyObject(c *C) {
 	driver.CreateBucket("bucket", "private")
 	driver.CreateObject("bucket", "object", "", "", buffer)
 
-	response, err := http.Get(testServer.URL + "/bucket/object")
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -180,17 +207,23 @@ func (s *MySuite) TestBucket(c *C) {
 	metadata := drivers.BucketMetadata{
 		Name:    "bucket",
 		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
 	}
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
-	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Twice()
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once()
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
 	driver.CreateBucket("bucket", "private")
 
-	response, err := http.Head(testServer.URL + "/bucket")
+	request, err := http.NewRequest("HEAD", testServer.URL+"/bucket", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 }
@@ -214,11 +247,12 @@ func (s *MySuite) TestObject(c *C) {
 	}
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
 	typedDriver.On("CreateObject", "bucket", "object", "", "", mock.Anything).Return(nil).Once()
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Twice()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(metadata, nil).Twice()
 	typedDriver.SetGetObjectWriter("bucket", "object", []byte("hello world"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object").Return(int64(0), nil).Once()
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -226,7 +260,12 @@ func (s *MySuite) TestObject(c *C) {
 	driver.CreateBucket("bucket", "private")
 	driver.CreateObject("bucket", "object", "", "", buffer)
 
-	response, err := http.Get(testServer.URL + "/bucket/object")
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -272,7 +311,7 @@ func (s *MySuite) TestMultipleObjects(c *C) {
 		Md5:         "5eb63bbbe01eeed093cb22bb8f5acdc3", // TODO correct md5
 		Size:        11,
 	}
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -290,20 +329,34 @@ func (s *MySuite) TestMultipleObjects(c *C) {
 	driver.CreateObject("bucket", "object3", "", "", buffer3)
 
 	// test non-existant object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once()
-	response, err := http.Get(testServer.URL + "/bucket/object")
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
+	c.Assert(err, IsNil)
+
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 	//// test object 1
 
 	// get object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object1", "").Return(metadata1, nil).Once()
 	typedDriver.SetGetObjectWriter("bucket", "object1", []byte("hello one"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object1").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/object1")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/object1", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 
 	// get metadata
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object1", "").Return(metadata1, nil).Once()
 	metadata, err := driver.GetObjectMetadata("bucket", "object1", "")
 	c.Assert(err, IsNil)
@@ -320,13 +373,20 @@ func (s *MySuite) TestMultipleObjects(c *C) {
 
 	// test object 2
 	// get object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object2", "").Return(metadata2, nil).Once()
 	typedDriver.SetGetObjectWriter("bucket", "object2", []byte("hello two"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object2").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/object2")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/object2", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 
 	// get metadata
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object2", "").Return(metadata2, nil).Once()
 	metadata, err = driver.GetObjectMetadata("bucket", "object2", "")
 	c.Assert(err, IsNil)
@@ -343,15 +403,23 @@ func (s *MySuite) TestMultipleObjects(c *C) {
 
 	// test object 3
 	// get object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object3", "").Return(metadata3, nil).Once()
 	typedDriver.SetGetObjectWriter("bucket", "object3", []byte("hello three"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object3").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/object3")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/object3", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 
 	// get metadata
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object3", "").Return(metadata3, nil).Once()
 	metadata, err = driver.GetObjectMetadata("bucket", "object3", "")
+
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -373,11 +441,16 @@ func (s *MySuite) TestNotImplemented(c *C) {
 		}
 	}
 	driver := s.Driver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
-	response, err := http.Get(testServer.URL + "/bucket/object?acl")
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object?acl", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusNotImplemented)
 
@@ -393,19 +466,33 @@ func (s *MySuite) TestHeader(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 	typedDriver.AssertExpectations(c)
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
-	driver.CreateBucket("bucket", "private")
+	err := driver.CreateBucket("bucket", "private")
-
-	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once()
-	response, err := http.Get(testServer.URL + "/bucket/object")
 	c.Assert(err, IsNil)
+
+	bucketMetadata := drivers.BucketMetadata{
+		Name:    "bucket",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+	typedDriver.On("GetBucketMetadata", "bucket").Return(bucketMetadata, nil).Once()
+	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once()
+	request, err := http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
+	c.Assert(err, IsNil)
+
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 
 	buffer := bytes.NewBufferString("hello world")
+	typedDriver.On("GetBucketMetadata", "foo").Return(bucketMetadata, nil).Once()
 	typedDriver.On("CreateObject", "bucket", "object", "", "", mock.Anything).Return(nil).Once()
 	driver.CreateObject("bucket", "object", "", "", buffer)
 
@@ -418,13 +505,20 @@ func (s *MySuite) TestHeader(c *C) {
 		Size:        11,
 	}
 
+	typedDriver.On("GetBucketMetadata", "bucket").Return(bucketMetadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(objectMetadata, nil).Once()
 	typedDriver.SetGetObjectWriter("", "", []byte("hello world"))
 	typedDriver.On("GetObject", mock.Anything, "bucket", "object").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/object")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/object", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
+	typedDriver.On("GetBucketMetadata", "bucket").Return(bucketMetadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "object", "").Return(objectMetadata, nil).Once()
 	metadata, err := driver.GetObjectMetadata("bucket", "object", "")
 	c.Assert(err, IsNil)
@@ -441,7 +535,7 @@ func (s *MySuite) TestPutBucket(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -454,6 +548,7 @@ func (s *MySuite) TestPutBucket(c *C) {
 	request, err := http.NewRequest("PUT", testServer.URL+"/bucket", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	client := http.Client{}
 	response, err := client.Do(request)
@@ -477,7 +572,7 @@ func (s *MySuite) TestPutObject(c *C) {
 	}
 	driver := s.Driver
 	typedDriver := s.MockDriver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -486,7 +581,9 @@ func (s *MySuite) TestPutObject(c *C) {
 	resources.Maxkeys = 1000
 	resources.Prefix = ""
 
-	typedDriver.On("ListObjects", "bucket", mock.Anything).Return([]drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{}, drivers.BucketNotFound{}).Once()
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
+	typedDriver.On("ListObjects", "bucket", mock.Anything).Return([]drivers.ObjectMetadata{},
+		drivers.BucketResourcesMetadata{}, drivers.BucketNotFound{}).Once()
 	objects, resources, err := driver.ListObjects("bucket", resources)
 	c.Assert(len(objects), Equals, 0)
 	c.Assert(resources.IsTruncated, Equals, false)
@@ -498,9 +595,10 @@ func (s *MySuite) TestPutObject(c *C) {
 
 	// Put Bucket before - Put Object into a bucket
 	typedDriver.On("CreateBucket", "bucket", "private").Return(nil).Once()
-	request, err := http.NewRequest("PUT", testServer.URL+"/bucket", bytes.NewBufferString(""))
+	request, err := http.NewRequest("PUT", testServer.URL+"/bucket", nil)
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	client := http.Client{}
 	response, err := client.Do(request)
@@ -510,6 +608,7 @@ func (s *MySuite) TestPutObject(c *C) {
 	typedDriver.On("CreateObject", "bucket", "two", "", "", mock.Anything).Return(nil).Once()
 	request, err = http.NewRequest("PUT", testServer.URL+"/bucket/two", bytes.NewBufferString("hello world"))
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
 
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
@@ -529,6 +628,7 @@ func (s *MySuite) TestPutObject(c *C) {
 	resources.Maxkeys = 1000
 	resources.Prefix = ""
 
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Twice()
 	typedDriver.On("ListObjects", "bucket", mock.Anything).Return([]drivers.ObjectMetadata{{}}, drivers.BucketResourcesMetadata{}, nil).Once()
 	objects, resources, err = driver.ListObjects("bucket", resources)
 	c.Assert(len(objects), Equals, 1)
@@ -561,13 +661,17 @@ func (s *MySuite) TestListBuckets(c *C) {
 	}
 	driver := s.Driver
 	typedDriver := s.MockDriver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
 	typedDriver.On("ListBuckets").Return([]drivers.BucketMetadata{}, nil).Once()
-	response, err := http.Get(testServer.URL + "/")
+	request, err := http.NewRequest("GET", testServer.URL+"/", nil)
-	defer response.Body.Close()
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
+	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -583,8 +687,12 @@ func (s *MySuite) TestListBuckets(c *C) {
 		{Name: "foo", Created: time.Now()},
 	}
 	typedDriver.On("ListBuckets").Return(bucketMetadata, nil).Once()
-	response, err = http.Get(testServer.URL + "/")
+	request, err = http.NewRequest("GET", testServer.URL+"/", nil)
-	defer response.Body.Close()
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -603,8 +711,12 @@ func (s *MySuite) TestListBuckets(c *C) {
 	}
 
 	typedDriver.On("ListBuckets").Return(bucketMetadata, nil).Once()
-	response, err = http.Get(testServer.URL + "/")
+	request, err = http.NewRequest("GET", testServer.URL+"/", nil)
-	defer response.Body.Close()
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -616,8 +728,8 @@ func (s *MySuite) TestListBuckets(c *C) {
 	c.Assert(listResponse.Buckets.Bucket[1].Name, Equals, "foo")
 }
 
-func readListBucket(reader io.Reader) (api.BucketListResponse, error) {
+func readListBucket(reader io.Reader) (BucketListResponse, error) {
-	var results api.BucketListResponse
+	var results BucketListResponse
 	decoder := xml.NewDecoder(reader)
 	err := decoder.Decode(&results)
 	return results, err
@@ -687,7 +799,7 @@ func (s *MySuite) TestXMLNameNotInBucketListJson(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -696,14 +808,13 @@ func (s *MySuite) TestXMLNameNotInBucketListJson(c *C) {
 	c.Assert(err, IsNil)
 
 	typedDriver.On("ListBuckets").Return([]drivers.BucketMetadata{{Name: "foo", Created: time.Now()}}, nil)
-	request, err := http.NewRequest("GET", testServer.URL+"/", bytes.NewBufferString(""))
+	request, err := http.NewRequest("GET", testServer.URL+"/", nil)
 	c.Assert(err, IsNil)
-
 	request.Header.Add("Accept", "application/json")
+	setAuthHeader(request)
 
 	client := http.Client{}
 	response, err := client.Do(request)
-
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -721,7 +832,7 @@ func (s *MySuite) TestXMLNameNotInObjectListJson(c *C) {
 	}
 	driver := s.Driver
 	typedDriver := s.MockDriver
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -729,15 +840,25 @@ func (s *MySuite) TestXMLNameNotInObjectListJson(c *C) {
 	err := driver.CreateBucket("foo", "private")
 	c.Assert(err, IsNil)
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return([]drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{}, nil).Once()
+	resources := drivers.BucketResourcesMetadata{}
-	request, err := http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
+	resources.Maxkeys = 1000
-	c.Assert(err, IsNil)
+	resources.Prefix = ""
 
+	metadata := drivers.BucketMetadata{
+		Name:    "foo",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
+	typedDriver.On("ListObjects", "foo", resources).Return([]drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{}, nil).Once()
+	request, err := http.NewRequest("GET", testServer.URL+"/foo", nil)
+	c.Assert(err, IsNil)
 	request.Header.Add("Accept", "application/json")
+	setAuthHeader(request)
 
 	client := http.Client{}
 	response, err := client.Do(request)
-
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
 
@@ -756,7 +877,7 @@ func (s *MySuite) TestContentTypePersists(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -764,11 +885,19 @@ func (s *MySuite) TestContentTypePersists(c *C) {
 	err := driver.CreateBucket("bucket", "private")
 	c.Assert(err, IsNil)
 
-	client := http.Client{}
+	metadata := drivers.BucketMetadata{
+		Name:    "bucket",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once()
 	typedDriver.On("CreateObject", "bucket", "one", "", "", mock.Anything).Return(nil).Once()
 	request, err := http.NewRequest("PUT", testServer.URL+"/bucket/one", bytes.NewBufferString("hello world"))
 	delete(request.Header, "Content-Type")
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client := http.Client{}
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
@@ -782,25 +911,39 @@ func (s *MySuite) TestContentTypePersists(c *C) {
 		Md5:         "d41d8cd98f00b204e9800998ecf8427e",
 		Size:        0,
 	}
+	typedDriver.On("GetBucketMetadata", "bucket").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "one", "").Return(oneMetadata, nil).Once()
-	request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/one", bytes.NewBufferString(""))
+	request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/one", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream")
 
 	// test get object
 	typedDriver.SetGetObjectWriter("bucket", "once", []byte(""))
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Twice()
 	typedDriver.On("GetObjectMetadata", "bucket", "one", "").Return(oneMetadata, nil).Once()
 	typedDriver.On("GetObject", mock.Anything, "bucket", "one").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/one")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/one", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	client = http.Client{}
+	response, err = client.Do(request)
+	c.Assert(err, IsNil)
+	c.Assert(response.StatusCode, Equals, http.StatusOK)
 	c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream")
 
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once()
 	typedDriver.On("CreateObject", "bucket", "two", "", "", mock.Anything).Return(nil).Once()
 	request, err = http.NewRequest("PUT", testServer.URL+"/bucket/two", bytes.NewBufferString("hello world"))
 	delete(request.Header, "Content-Type")
 	request.Header.Add("Content-Type", "application/json")
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.StatusCode, Equals, http.StatusOK)
@@ -814,17 +957,26 @@ func (s *MySuite) TestContentTypePersists(c *C) {
 		Md5:  "d41d8cd98f00b204e9800998ecf8427e",
 		Size: 0,
 	}
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "bucket", "two", "").Return(twoMetadata, nil).Once()
-	request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/two", bytes.NewBufferString(""))
+	request, err = http.NewRequest("HEAD", testServer.URL+"/bucket/two", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream")
 
 	// test get object
+	typedDriver.On("GetBucketMetadata", "bucket").Return(metadata, nil).Twice()
 	typedDriver.On("GetObjectMetadata", "bucket", "two", "").Return(twoMetadata, nil).Once()
 	typedDriver.On("GetObject", mock.Anything, "bucket", "two").Return(int64(0), nil).Once()
-	response, err = http.Get(testServer.URL + "/bucket/two")
+	request, err = http.NewRequest("GET", testServer.URL+"/bucket/two", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	response, err = client.Do(request)
+	c.Assert(err, IsNil)
 	c.Assert(response.Header.Get("Content-Type"), Equals, "application/octet-stream")
 }
 
@@ -838,7 +990,7 @@ func (s *MySuite) TestPartialContent(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 
@@ -860,14 +1012,18 @@ func (s *MySuite) TestPartialContent(c *C) {
 
 	// prepare for GET on range request
 	typedDriver.SetGetObjectWriter("foo", "bar", []byte("hello world"))
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(metadata, nil).Once()
 	typedDriver.On("GetPartialObject", mock.Anything, "foo", "bar", int64(6), int64(2)).Return(int64(2), nil).Once()
 
 	// prepare request
-	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
 	request.Header.Add("Accept", "application/json")
 	request.Header.Add("Range", "bytes=6-7")
+	setAuthHeader(request)
+
 	client := http.Client{}
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
@@ -892,35 +1048,54 @@ func (s *MySuite) TestListObjectsHandlerErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BucketNotFound{}).Once()
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNameInvalid{}).Once()
-
+	request, err := http.NewRequest("GET", testServer.URL+"/foo", nil)
-	request, err := http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err := client.Do(request)
-	verifyError(c, response, "NoSuchBucket", "The specified bucket does not exist.", http.StatusNotFound)
-
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BucketNameInvalid{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
-	c.Assert(err, IsNil)
-	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InvalidBucketName", "The specified bucket is not valid.", http.StatusBadRequest)
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.ObjectNameInvalid{}).Once()
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNotFound{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
+	request, err = http.NewRequest("GET", testServer.URL+"/foo", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	response, err = client.Do(request)
+	verifyError(c, response, "NoSuchBucket", "The specified bucket does not exist.", http.StatusNotFound)
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once()
+	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.ObjectNameInvalid{}).Once()
+	request, err = http.NewRequest("GET", testServer.URL+"/foo", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once()
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
+	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.ObjectNotFound{}).Once()
+	request, err = http.NewRequest("GET", testServer.URL+"/foo", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
+	response, err = client.Do(request)
+	c.Assert(err, IsNil)
+	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BackendCorrupted{}).Once()
+	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once()
+	request, err = http.NewRequest("GET", testServer.URL+"/foo", nil)
+	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InternalError", "We encountered an internal error, please try again.", http.StatusInternalServerError)
@@ -940,14 +1115,24 @@ func (s *MySuite) TestListBucketsErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
 
-	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0), drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once()
+	metadata := drivers.BucketMetadata{
-	request, err := http.NewRequest("GET", testServer.URL+"/foo", bytes.NewBufferString(""))
+		Name:    "foo",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
+	typedDriver.On("ListObjects", "foo", mock.Anything).Return(make([]drivers.ObjectMetadata, 0),
+		drivers.BucketResourcesMetadata{}, drivers.BackendCorrupted{}).Once()
+	request, err := http.NewRequest("GET", testServer.URL+"/foo", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InternalError", "We encountered an internal error, please try again.", http.StatusInternalServerError)
@@ -967,7 +1152,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
@@ -976,6 +1161,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	request, err := http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
@@ -985,6 +1171,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	request, err = http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
@@ -994,6 +1181,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	request, err = http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "private")
+	setAuthHeader(request)
 
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
@@ -1003,6 +1191,7 @@ func (s *MySuite) TestPutBucketErrors(c *C) {
 	request, err = http.NewRequest("PUT", testServer.URL+"/foo", bytes.NewBufferString(""))
 	c.Assert(err, IsNil)
 	request.Header.Add("x-amz-acl", "unknown")
+	setAuthHeader(request)
 
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
@@ -1023,42 +1212,60 @@ func (s *MySuite) TestGetObjectErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
 
+	metadata := drivers.BucketMetadata{
+		Name:    "foo",
+		Created: time.Now(),
+		ACL:     drivers.BucketACL("private"),
+	}
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNotFound{}).Once()
-	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 
-	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.BucketNotFound{}).Once()
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNotFound{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "NoSuchBucket", "The specified bucket does not exist.", http.StatusNotFound)
 
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.ObjectNameInvalid{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "NoSuchKey", "The specified key does not exist.", http.StatusNotFound)
 
-	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.BucketNameInvalid{}).Once()
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, drivers.BucketNameInvalid{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InvalidBucketName", "The specified bucket is not valid.", http.StatusBadRequest)
 
+	typedDriver.On("GetBucketMetadata", "foo").Return(metadata, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(drivers.ObjectMetadata{}, drivers.BackendCorrupted{}).Once()
-	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err = http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err = client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InternalError", "We encountered an internal error, please try again.", http.StatusInternalServerError)
@@ -1078,7 +1285,7 @@ func (s *MySuite) TestGetObjectRangeErrors(c *C) {
 	driver := s.Driver
 	typedDriver := s.MockDriver
 
-	httpHandler := api.HTTPHandler("", driver)
+	httpHandler := HTTPHandler("", driver)
 	testServer := httptest.NewServer(httpHandler)
 	defer testServer.Close()
 	client := http.Client{}
@@ -1093,10 +1300,13 @@ func (s *MySuite) TestGetObjectRangeErrors(c *C) {
 		Size:        11,
 	}
 
+	typedDriver.On("GetBucketMetadata", "foo").Return(drivers.BucketMetadata{}, nil).Once()
 	typedDriver.On("GetObjectMetadata", "foo", "bar", "").Return(metadata, nil).Once()
-	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", bytes.NewBufferString(""))
+	request, err := http.NewRequest("GET", testServer.URL+"/foo/bar", nil)
 	request.Header.Add("Range", "bytes=7-6")
 	c.Assert(err, IsNil)
+	setAuthHeader(request)
+
 	response, err := client.Do(request)
 	c.Assert(err, IsNil)
 	verifyError(c, response, "InvalidRange", "The requested range cannot be satisfied.", http.StatusRequestedRangeNotSatisfiable)
@@ -1105,7 +1315,7 @@ func (s *MySuite) TestGetObjectRangeErrors(c *C) {
 func verifyError(c *C, response *http.Response, code, description string, statusCode int) {
 	data, err := ioutil.ReadAll(response.Body)
 	c.Assert(err, IsNil)
-	errorResponse := api.ErrorResponse{}
+	errorResponse := ErrorResponse{}
 	err = xml.Unmarshal(data, &errorResponse)
 	c.Assert(err, IsNil)
 	c.Assert(errorResponse.Code, Equals, code)

pkg/api/utils.go

@@ -6,6 +6,9 @@ import (
 )
 
 func isValidMD5(md5 string) bool {
+	if md5 == "" {
+		return true
+	}
 	_, err := base64.StdEncoding.DecodeString(strings.TrimSpace(md5))
 	if err != nil {
 		return false

pkg/storage/donut/objectstorage.go

@@ -44,9 +44,10 @@ func (d donut) GetBucketMetadata(bucket string) (map[string]string, error) {
 	if _, ok := d.buckets[bucket]; !ok {
 		return nil, iodine.New(errors.New("bucket does not exist"), nil)
 	}
+	// TODO get this, from whatever is written from SetBucketMetadata
 	metadata := make(map[string]string)
 	metadata["name"] = bucket
-	metadata["created"] = time.Now().Format(time.RFC3339Nano) // TODO get this, from whatever is written from SetBucketMetadata
+	metadata["created"] = time.Now().Format(time.RFC3339Nano)
 	metadata["acl"] = "private"
 	return metadata, nil
 }

pkg/storage/drivers/api_testsuite.go

@@ -26,6 +26,7 @@ import (
 	"time"
 
 	"github.com/minio-io/check"
+	"github.com/minio-io/minio/pkg/iodine"
 )
 
 // APITestSuite - collection of API tests
@@ -105,6 +106,7 @@ func testPaging(c *check.C, create func() Driver) {
 		key := "obj" + strconv.Itoa(i)
 		drivers.CreateObject("bucket", key, "", "", bytes.NewBufferString(key))
 		resources.Maxkeys = 5
+		resources.Prefix = ""
 		objects, resources, err = drivers.ListObjects("bucket", resources)
 		c.Assert(len(objects), check.Equals, i+1)
 		c.Assert(resources.IsTruncated, check.Equals, false)
@@ -115,6 +117,7 @@ func testPaging(c *check.C, create func() Driver) {
 		key := "obj" + strconv.Itoa(i)
 		drivers.CreateObject("bucket", key, "", "", bytes.NewBufferString(key))
 		resources.Maxkeys = 5
+		resources.Prefix = ""
 		objects, resources, err = drivers.ListObjects("bucket", resources)
 		c.Assert(len(objects), check.Equals, 5)
 		c.Assert(resources.IsTruncated, check.Equals, true)
@@ -329,7 +332,7 @@ func testNonExistantObjectInBucket(c *check.C, create func() Driver) {
 	c.Assert(length, check.Equals, int64(0))
 	c.Assert(err, check.Not(check.IsNil))
 	c.Assert(len(byteBuffer.Bytes()), check.Equals, 0)
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case ObjectNotFound:
 		{
 			c.Assert(err, check.ErrorMatches, "Object not Found: bucket#dir1")
@@ -352,7 +355,7 @@ func testGetDirectoryReturnsObjectNotFound(c *check.C, create func() Driver) {
 	var byteBuffer bytes.Buffer
 	length, err := drivers.GetObject(&byteBuffer, "bucket", "dir1")
 	c.Assert(length, check.Equals, int64(0))
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case ObjectNotFound:
 		{
 			c.Assert(err.Bucket, check.Equals, "bucket")
@@ -369,7 +372,7 @@ func testGetDirectoryReturnsObjectNotFound(c *check.C, create func() Driver) {
 	var byteBuffer2 bytes.Buffer
 	length, err = drivers.GetObject(&byteBuffer, "bucket", "dir1/")
 	c.Assert(length, check.Equals, int64(0))
-	switch err := err.(type) {
+	switch err := iodine.ToError(err).(type) {
 	case ObjectNotFound:
 		{
 			c.Assert(err.Bucket, check.Equals, "bucket")

pkg/storage/drivers/donut/donut.go

@@ -19,7 +19,6 @@ package donut
 import (
 	"encoding/base64"
 	"encoding/hex"
-	"errors"
 	"io"
 	"os"
 	"path"
@@ -136,7 +135,7 @@ func (d donutDriver) GetBucketMetadata(bucketName string) (drivers.BucketMetadat
 	}
 	metadata, err := d.donut.GetBucketMetadata(bucketName)
 	if err != nil {
-		return drivers.BucketMetadata{}, drivers.BucketNotFound{Bucket: bucketName}
+		return drivers.BucketMetadata{}, iodine.New(drivers.BucketNotFound{Bucket: bucketName}, nil)
 	}
 	created, err := time.Parse(time.RFC3339Nano, metadata["created"])
 	if err != nil {
@@ -156,25 +155,21 @@ func (d donutDriver) GetBucketMetadata(bucketName string) (drivers.BucketMetadat
 
 // GetObject retrieves an object and writes it to a writer
 func (d donutDriver) GetObject(target io.Writer, bucketName, objectName string) (int64, error) {
-	errParams := map[string]string{
+	if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") {
-		"bucketName": bucketName,
+		return 0, iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil)
-		"objectName": objectName,
 	}
-	if bucketName == "" || strings.TrimSpace(bucketName) == "" {
+	if !drivers.IsValidObject(objectName) || strings.TrimSpace(objectName) == "" {
-		return 0, iodine.New(errors.New("invalid argument"), errParams)
+		return 0, iodine.New(drivers.ObjectNameInvalid{Object: objectName}, nil)
-	}
-	if objectName == "" || strings.TrimSpace(objectName) == "" {
-		return 0, iodine.New(errors.New("invalid argument"), errParams)
 	}
 	reader, size, err := d.donut.GetObject(bucketName, objectName)
 	if err != nil {
-		return 0, drivers.ObjectNotFound{
+		return 0, iodine.New(drivers.ObjectNotFound{
 			Bucket: bucketName,
 			Object: objectName,
-		}
+		}, nil)
 	}
 	n, err := io.CopyN(target, reader, size)
-	return n, iodine.New(err, errParams)
+	return n, iodine.New(err, nil)
 }
 
 // GetPartialObject retrieves an object range and writes it to a writer
@@ -186,25 +181,31 @@ func (d donutDriver) GetPartialObject(w io.Writer, bucketName, objectName string
 		"start":      strconv.FormatInt(start, 10),
 		"length":     strconv.FormatInt(length, 10),
 	}
-	if bucketName == "" || strings.TrimSpace(bucketName) == "" {
+	if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") {
-		return 0, iodine.New(errors.New("invalid argument"), errParams)
+		return 0, iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, errParams)
 	}
-	if objectName == "" || strings.TrimSpace(objectName) == "" {
+	if !drivers.IsValidObject(objectName) || strings.TrimSpace(objectName) == "" {
-		return 0, iodine.New(errors.New("invalid argument"), errParams)
+		return 0, iodine.New(drivers.ObjectNameInvalid{Object: objectName}, errParams)
 	}
 	if start < 0 {
-		return 0, iodine.New(errors.New("invalid argument"), errParams)
+		return 0, iodine.New(drivers.InvalidRange{
+			Start:  start,
+			Length: length,
+		}, errParams)
 	}
 	reader, size, err := d.donut.GetObject(bucketName, objectName)
 	defer reader.Close()
 	if err != nil {
-		return 0, drivers.ObjectNotFound{
+		return 0, iodine.New(drivers.ObjectNotFound{
 			Bucket: bucketName,
 			Object: objectName,
-		}
+		}, nil)
 	}
 	if start > size || (start+length-1) > size {
-		return 0, iodine.New(errors.New("invalid range"), errParams)
+		return 0, iodine.New(drivers.InvalidRange{
+			Start:  start,
+			Length: length,
+		}, errParams)
 	}
 	_, err = io.CopyN(ioutil.Discard, reader, start)
 	if err != nil {
@@ -224,6 +225,12 @@ func (d donutDriver) GetObjectMetadata(bucketName, objectName, prefixName string
 		"objectName": objectName,
 		"prefixName": prefixName,
 	}
+	if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") {
+		return drivers.ObjectMetadata{}, iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil)
+	}
+	if !drivers.IsValidObject(objectName) || strings.TrimSpace(objectName) == "" {
+		return drivers.ObjectMetadata{}, iodine.New(drivers.ObjectNameInvalid{Object: objectName}, nil)
+	}
 	metadata, err := d.donut.GetObjectMetadata(bucketName, objectName)
 	if err != nil {
 		return drivers.ObjectMetadata{}, drivers.ObjectNotFound{
@@ -262,6 +269,12 @@ func (d donutDriver) ListObjects(bucketName string, resources drivers.BucketReso
 	errParams := map[string]string{
 		"bucketName": bucketName,
 	}
+	if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") {
+		return nil, drivers.BucketResourcesMetadata{}, iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil)
+	}
+	if !drivers.IsValidObject(resources.Prefix) {
+		return nil, drivers.BucketResourcesMetadata{}, iodine.New(drivers.ObjectNameInvalid{Object: resources.Prefix}, nil)
+	}
 	actualObjects, commonPrefixes, isTruncated, err := d.donut.ListObjects(bucketName,
 		resources.Prefix,
 		resources.Marker,
@@ -305,11 +318,11 @@ func (d donutDriver) CreateObject(bucketName, objectName, contentType, expectedM
 		"objectName":  objectName,
 		"contentType": contentType,
 	}
-	if bucketName == "" || strings.TrimSpace(bucketName) == "" {
+	if !drivers.IsValidBucket(bucketName) || strings.Contains(bucketName, ".") {
-		return iodine.New(errors.New("invalid argument"), errParams)
+		return iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil)
 	}
-	if objectName == "" || strings.TrimSpace(objectName) == "" {
+	if !drivers.IsValidObject(objectName) || strings.TrimSpace(objectName) == "" {
-		return iodine.New(errors.New("invalid argument"), errParams)
+		return iodine.New(drivers.ObjectNameInvalid{Object: objectName}, nil)
 	}
 	if strings.TrimSpace(contentType) == "" {
 		contentType = "application/octet-stream"
@@ -324,7 +337,6 @@ func (d donutDriver) CreateObject(bucketName, objectName, contentType, expectedM
 		}
 		expectedMD5Sum = hex.EncodeToString(expectedMD5SumBytes)
 	}
-
 	err := d.donut.PutObject(bucketName, objectName, expectedMD5Sum, ioutil.NopCloser(reader), metadata)
 	if err != nil {
 		return iodine.New(err, errParams)

pkg/storage/drivers/driver.go

@@ -19,6 +19,7 @@ package drivers
 import (
 	"io"
 	"regexp"
+	"strings"
 	"time"
 	"unicode/utf8"
 )
@@ -185,6 +186,9 @@ func IsValidBucket(bucket string) bool {
 // IsValidObject - verify object name in accordance with
 //   - http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html
 func IsValidObject(object string) bool {
+	if strings.TrimSpace(object) == "" {
+		return true
+	}
 	if len(object) > 1024 || len(object) == 0 {
 		return false
 	}

pkg/storage/drivers/errors.go

@@ -16,6 +16,8 @@
 
 package drivers
 
+import "fmt"
+
 // BackendError - generic disk backend error
 type BackendError struct {
 	Path string
@@ -164,3 +166,23 @@ func (e BadDigest) Error() string {
 func (e InvalidDigest) Error() string {
 	return "Md5 provided " + e.Md5 + " is invalid"
 }
+
+// OperationNotPermitted - operation not permitted
+type OperationNotPermitted struct {
+	Op     string
+	Reason string
+}
+
+func (e OperationNotPermitted) Error() string {
+	return "Operation " + e.Op + " not permitted for reason: " + e.Reason
+}
+
+// InvalidRange - invalid range
+type InvalidRange struct {
+	Start  int64
+	Length int64
+}
+
+func (e InvalidRange) Error() string {
+	return fmt.Sprintf("Invalid range start:%d length:%d", e.Start, e.Length)
+}

pkg/storage/drivers/memory/memory.go

@@ -25,14 +25,14 @@ import (
 	"sync"
 	"time"
 
-	"github.com/minio-io/minio/pkg/storage/drivers"
-
 	"crypto/md5"
 	"encoding/hex"
 
 	"io/ioutil"
 
 	"github.com/golang/groupcache/lru"
+	"github.com/minio-io/minio/pkg/iodine"
+	"github.com/minio-io/minio/pkg/storage/drivers"
 	"github.com/minio-io/minio/pkg/utils/log"
 )
 
@@ -91,8 +91,14 @@ func start(ctrlChannel <-chan string, errorChannel chan<- error) {
 func (memory *memoryDriver) GetObject(w io.Writer, bucket string, object string) (int64, error) {
 	memory.lock.RLock()
 	defer memory.lock.RUnlock()
+	if !drivers.IsValidBucket(bucket) {
+		return 0, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil)
+	}
+	if !drivers.IsValidObject(object) {
+		return 0, iodine.New(drivers.ObjectNameInvalid{Object: object}, nil)
+	}
 	if _, ok := memory.bucketMetadata[bucket]; ok == false {
-		return 0, drivers.BucketNotFound{Bucket: bucket}
+		return 0, iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil)
 	}
 	// get object
 	objectKey := bucket + "/" + object
@@ -101,10 +107,10 @@ func (memory *memoryDriver) GetObject(w io.Writer, bucket string, object string)
 			dataSlice := data.([]byte)
 			objectBuffer := bytes.NewBuffer(dataSlice)
 			written, err := io.Copy(w, objectBuffer)
-			return written, err
+			return written, iodine.New(err, nil)
 		}
 	}
-	return 0, drivers.ObjectNotFound{Bucket: bucket, Object: object}
+	return 0, iodine.New(drivers.ObjectNotFound{Bucket: bucket, Object: object}, nil)
 }
 
 // GetPartialObject - GET object from memory buffer range
@@ -112,11 +118,17 @@ func (memory *memoryDriver) GetPartialObject(w io.Writer, bucket, object string,
 	memory.lock.RLock()
 	defer memory.lock.RUnlock()
 	var sourceBuffer bytes.Buffer
+	if !drivers.IsValidBucket(bucket) {
+		return 0, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil)
+	}
+	if !drivers.IsValidObject(object) {
+		return 0, iodine.New(drivers.ObjectNameInvalid{Object: object}, nil)
+	}
 	if _, err := memory.GetObject(&sourceBuffer, bucket, object); err != nil {
-		return 0, err
+		return 0, iodine.New(err, nil)
 	}
 	if _, err := io.CopyN(ioutil.Discard, &sourceBuffer, start); err != nil {
-		return 0, err
+		return 0, iodine.New(err, nil)
 	}
 	return io.CopyN(w, &sourceBuffer, length)
 }
@@ -125,8 +137,11 @@ func (memory *memoryDriver) GetPartialObject(w io.Writer, bucket, object string,
 func (memory *memoryDriver) GetBucketMetadata(bucket string) (drivers.BucketMetadata, error) {
 	memory.lock.RLock()
 	defer memory.lock.RUnlock()
+	if !drivers.IsValidBucket(bucket) {
+		return drivers.BucketMetadata{}, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil)
+	}
 	if _, ok := memory.bucketMetadata[bucket]; ok == false {
-		return drivers.BucketMetadata{}, drivers.BucketNotFound{Bucket: bucket}
+		return drivers.BucketMetadata{}, iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil)
 	}
 	return memory.bucketMetadata[bucket].metadata, nil
 }
@@ -134,17 +149,22 @@ func (memory *memoryDriver) GetBucketMetadata(bucket string) (drivers.BucketMeta
 // CreateObject - PUT object to memory buffer
 func (memory *memoryDriver) CreateObject(bucket, key, contentType, md5sum string, data io.Reader) error {
 	memory.lock.RLock()
-
+	if !drivers.IsValidBucket(bucket) {
+		memory.lock.RUnlock()
+		return iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil)
+	}
+	if !drivers.IsValidObject(key) {
+		memory.lock.RUnlock()
+		return iodine.New(drivers.ObjectNameInvalid{Object: key}, nil)
+	}
 	if _, ok := memory.bucketMetadata[bucket]; ok == false {
 		memory.lock.RUnlock()
-		return drivers.BucketNotFound{Bucket: bucket}
+		return iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil)
 	}
-
 	objectKey := bucket + "/" + key
-
 	if _, ok := memory.objectMetadata[objectKey]; ok == true {
 		memory.lock.RUnlock()
-		return drivers.ObjectExists{Bucket: bucket, Object: key}
+		return iodine.New(drivers.ObjectExists{Bucket: bucket, Object: key}, nil)
 	}
 	memory.lock.RUnlock()
 
@@ -175,7 +195,7 @@ func (memory *memoryDriver) CreateObject(bucket, key, contentType, md5sum string
 	memory.lock.Lock()
 	if _, ok := memory.objectMetadata[objectKey]; ok == true {
 		memory.lock.Unlock()
-		return drivers.ObjectExists{Bucket: bucket, Object: key}
+		return iodine.New(drivers.ObjectExists{Bucket: bucket, Object: key}, nil)
 	}
 	memory.objectMetadata[objectKey] = newObject
 	memory.objects.Add(objectKey, dataSlice)
@@ -192,15 +212,15 @@ func (memory *memoryDriver) CreateBucket(bucketName, acl string) error {
 	memory.lock.RLock()
 	if !drivers.IsValidBucket(bucketName) {
 		memory.lock.RUnlock()
-		return drivers.BucketNameInvalid{Bucket: bucketName}
+		return iodine.New(drivers.BucketNameInvalid{Bucket: bucketName}, nil)
 	}
 	if !drivers.IsValidBucketACL(acl) {
 		memory.lock.RUnlock()
-		return drivers.InvalidACL{ACL: acl}
+		return iodine.New(drivers.InvalidACL{ACL: acl}, nil)
 	}
 	if _, ok := memory.bucketMetadata[bucketName]; ok == true {
 		memory.lock.RUnlock()
-		return drivers.BucketExists{Bucket: bucketName}
+		return iodine.New(drivers.BucketExists{Bucket: bucketName}, nil)
 	}
 	memory.lock.RUnlock()
 
@@ -247,18 +267,7 @@ func (memory *memoryDriver) filterDelimiterPrefix(keys []string, key, delimitedN
 	return resources, keys
 }
 
-// ListObjects - list objects from memory
+func (memory *memoryDriver) listObjectsInternal(keys []string, key string, resources drivers.BucketResourcesMetadata) ([]string, drivers.BucketResourcesMetadata) {
-func (memory *memoryDriver) ListObjects(bucket string, resources drivers.BucketResourcesMetadata) ([]drivers.ObjectMetadata, drivers.BucketResourcesMetadata, error) {
-	memory.lock.RLock()
-	defer memory.lock.RUnlock()
-	if _, ok := memory.bucketMetadata[bucket]; ok == false {
-		return []drivers.ObjectMetadata{}, drivers.BucketResourcesMetadata{IsTruncated: false}, drivers.BucketNotFound{Bucket: bucket}
-	}
-	var results []drivers.ObjectMetadata
-	var keys []string
-	for key := range memory.objectMetadata {
-		if strings.HasPrefix(key, bucket+"/") {
-			key = key[len(bucket)+1:]
 	switch true {
 	// Prefix absent, delimit object key based on delimiter
 	case resources.IsDelimiterSet():
@@ -283,6 +292,28 @@ func (memory *memoryDriver) ListObjects(bucket string, resources drivers.BucketR
 	case resources.IsDefault():
 		keys = appendUniq(keys, key)
 	}
+	return keys, resources
+}
+
+// ListObjects - list objects from memory
+func (memory *memoryDriver) ListObjects(bucket string, resources drivers.BucketResourcesMetadata) ([]drivers.ObjectMetadata, drivers.BucketResourcesMetadata, error) {
+	memory.lock.RLock()
+	defer memory.lock.RUnlock()
+	if !drivers.IsValidBucket(bucket) {
+		return nil, drivers.BucketResourcesMetadata{IsTruncated: false}, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil)
+	}
+	if !drivers.IsValidObject(resources.Prefix) {
+		return nil, drivers.BucketResourcesMetadata{IsTruncated: false}, iodine.New(drivers.ObjectNameInvalid{Object: resources.Prefix}, nil)
+	}
+	if _, ok := memory.bucketMetadata[bucket]; ok == false {
+		return nil, drivers.BucketResourcesMetadata{IsTruncated: false}, iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil)
+	}
+	var results []drivers.ObjectMetadata
+	var keys []string
+	for key := range memory.objectMetadata {
+		if strings.HasPrefix(key, bucket+"/") {
+			key = key[len(bucket)+1:]
+			keys, resources = memory.listObjectsInternal(keys, key, resources)
 		}
 	}
 	sort.Strings(keys)
@@ -327,21 +358,24 @@ func (memory *memoryDriver) GetObjectMetadata(bucket, key, prefix string) (drive
 	memory.lock.RLock()
 	defer memory.lock.RUnlock()
 	// check if bucket exists
-	if _, ok := memory.bucketMetadata[bucket]; ok == false {
+	if !drivers.IsValidBucket(bucket) {
-		return drivers.ObjectMetadata{}, drivers.BucketNotFound{Bucket: bucket}
+		return drivers.ObjectMetadata{}, iodine.New(drivers.BucketNameInvalid{Bucket: bucket}, nil)
+	}
+	if !drivers.IsValidObject(key) || !drivers.IsValidObject(prefix) {
+		return drivers.ObjectMetadata{}, iodine.New(drivers.ObjectNameInvalid{Object: key}, nil)
+	}
+	if _, ok := memory.bucketMetadata[bucket]; ok == false {
+		return drivers.ObjectMetadata{}, iodine.New(drivers.BucketNotFound{Bucket: bucket}, nil)
 	}
-
 	objectKey := bucket + "/" + key
-
 	if object, ok := memory.objectMetadata[objectKey]; ok == true {
 		return object.metadata, nil
 	}
-	return drivers.ObjectMetadata{}, drivers.ObjectNotFound{Bucket: bucket, Object: key}
+	return drivers.ObjectMetadata{}, iodine.New(drivers.ObjectNotFound{Bucket: bucket, Object: key}, nil)
 }
 
 func (memory *memoryDriver) evictObject(key lru.Key, value interface{}) {
 	k := key.(string)
-
 	memory.totalSize = memory.totalSize - memory.objectMetadata[k].metadata.Size
 	log.Println("evicting:", k)
 	delete(memory.objectMetadata, k)