--- /dev/null
+/** **************************************************************************
+ * libs3.h
+ *
+ * Copyright 2008 Bryan Ischo <bryan@ischo.com>
+ *
+ * This file is part of libs3.
+ *
+ * libs3 is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, version 3 of the License.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of this library and its programs with the
+ * OpenSSL library, and distribute linked combinations including the two.
+ *
+ * libs3 is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with libs3, in a file named COPYING. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ ************************************************************************** **/
+
+#ifndef LIBS3_H
+#define LIBS3_H
+
+#include <stdint.h>
+#include <sys/select.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** **************************************************************************
+ * Overview
+ * --------
+ *
+ * This library provides an API for using Amazon's S3 service (see
+ * http://s3.amazonaws.com). Its design goals are:
+ *
+ * - To provide a simple and straightforward API for accessing all of S3's
+ * functionality
+ * - To not require the developer using libs3 to need to know anything about:
+ * - HTTP
+ * - XML
+ * - SSL
+ * In other words, this API is meant to stand on its own, without requiring
+ * any implicit knowledge of how S3 services are accessed using HTTP
+ * protocols.
+ * - To be usable from multithreaded code
+ * - To be usable by code which wants to process multiple S3 requests
+ * simultaneously from a single thread
+ * - To be usable in the simple, straightforward way using sequentialized
+ * blocking requests
+ *
+ * The general usage pattern of libs3 is:
+ *
+ * - Initialize libs3 once per program by calling S3_initialize() at program
+ * start up time
+ * - Make any number of requests to S3 for getting, putting, or listing
+ * S3 buckets or objects, or modifying the ACLs associated with buckets
+ * or objects, using one of three general approaches:
+ * 1. Simple blocking requests, one at a time
+ * 2. Multiple threads each making simple blocking requests
+ * 3. From a single thread, managing multiple S3 requests simultaneously
+ * using file descriptors and a select()/poll() loop
+ * - Shut down libs3 at program exit time by calling S3_deinitialize()
+ *
+ * All functions which send requests to S3 return their results via a set of
+ * callback functions which must be supplied to libs3 at the time that the
+ * request is initiated. libs3 will call these functions back in the thread
+ * calling the libs3 function if blocking requests are made (i.e., if the
+ * S3RequestContext for the function invocation is passed in as NULL).
+ * If an S3RequestContext is used to drive multiple S3 requests
+ * simultaneously, then the callbacks will be made from the thread which
+ * calls S3_runall_request_context() or S3_runonce_request_context(), or
+ * possibly from the thread which calls S3_destroy_request_context(), if
+ * S3 requests are in progress at the time that this function is called.
+ *
+ * NOTE: Response headers from Amazon S3 are limited to 4K (2K of metas is all
+ * that Amazon supports, and libs3 allows Amazon an additional 2K of headers).
+ *
+ * NOTE: Because HTTP and the S3 REST protocol are highly under-specified,
+ * libs3 must make some assumptions about the maximum length of certain HTTP
+ * elements (such as headers) that it will accept. While efforts have been
+ * made to enforce maximums which are beyond that expected to be needed by any
+ * user of S3, it is always possible that these maximums may be too low in
+ * some rare circumstances. Bug reports should this unlikely situation occur
+ * would be most appreciated.
+ *
+ * Threading Rules
+ * ---------------
+ *
+ * 1. All arguments passed to any function must not be modified directly until
+ * the function returns.
+ * 2. All S3RequestContext and S3Request arguments passed to all functions may
+ * not be passed to any other libs3 function by any other thread until the
+ * function returns.
+ * 3. All functions may be called simultaneously by multiple threads as long
+ * as (1) and (2) are observed, EXCEPT for S3_initialize(), which must be
+ * called from one thread at a time only.
+ * 4. All callbacks will be made in the thread of the caller of the function
+ * which invoked them, so the caller of all libs3 functions should not hold
+ * locks that it would try to re-acquire in a callback, as this may
+ * deadlock.
+ ************************************************************************** **/
+
+
+/** **************************************************************************
+ * Constants
+ ************************************************************************** **/
+
+/**
+ * This is the hostname that all S3 requests will go through; virtual-host
+ * style requests will prepend the bucket name to this host name, and
+ * path-style requests will use this hostname directly
+ **/
+#define S3_HOSTNAME "s3.amazonaws.com"
+
+
+/**
+ * S3_MAX_BUCKET_NAME_SIZE is the maximum size of a bucket name.
+ **/
+
+#define S3_MAX_BUCKET_NAME_SIZE 255
+
+/**
+ * S3_MAX_KEY_SIZE is the maximum size of keys that Amazon S3 supports.
+ **/
+#define S3_MAX_KEY_SIZE 1024
+
+
+/**
+ * S3_MAX_METADATA_SIZE is the maximum number of bytes allowed for
+ * x-amz-meta header names and values in any request passed to Amazon S3
+ **/
+#define S3_MAX_METADATA_SIZE 2048
+
+
+/**
+ * S3_METADATA_HEADER_NAME_PREFIX is the prefix of an S3 "meta header"
+ **/
+#define S3_METADATA_HEADER_NAME_PREFIX "x-amz-meta-"
+
+
+/**
+ * S3_MAX_METADATA_COUNT is the maximum number of x-amz-meta- headers that
+ * could be included in a request to S3. The smallest meta header is
+ * "x-amz-meta-n: v". Since S3 doesn't count the ": " against the total, the
+ * smallest amount of data to count for a header would be the length of
+ * "x-amz-meta-nv".
+ **/
+#define S3_MAX_METADATA_COUNT \
+ (S3_MAX_METADATA_SIZE / (sizeof(S3_METADATA_HEADER_NAME_PREFIX "nv") - 1))
+
+
+/**
+ * S3_MAX_ACL_GRANT_COUNT is the maximum number of ACL grants that may be
+ * set on a bucket or object at one time. It is also the maximum number of
+ * ACL grants that the XML ACL parsing routine will parse.
+ **/
+#define S3_MAX_ACL_GRANT_COUNT 100
+
+
+/**
+ * This is the maximum number of characters (including terminating \0) that
+ * libs3 supports in an ACL grantee email address.
+ **/
+#define S3_MAX_GRANTEE_EMAIL_ADDRESS_SIZE 128
+
+
+/**
+ * This is the maximum number of characters (including terminating \0) that
+ * libs3 supports in an ACL grantee user id.
+ **/
+#define S3_MAX_GRANTEE_USER_ID_SIZE 128
+
+
+/**
+ * This is the maximum number of characters (including terminating \0) that
+ * libs3 supports in an ACL grantee user display name.
+ **/
+#define S3_MAX_GRANTEE_DISPLAY_NAME_SIZE 128
+
+
+/**
+ * This is the maximum number of characters that will be stored in the
+ * return buffer for the utility function which computes an HTTP authenticated
+ * query string
+ **/
+#define S3_MAX_AUTHENTICATED_QUERY_STRING_SIZE \
+ (sizeof("https://" S3_HOSTNAME "/") + (S3_MAX_KEY_SIZE * 3) + \
+ sizeof("?AWSAccessKeyId=") + 32 + sizeof("&Expires=") + 32 + \
+ sizeof("&Signature=") + 28 + 1)
+
+
+/**
+ * This constant is used by the S3_initialize() function, to specify that
+ * the winsock library should be initialized by libs3; only relevent on
+ * Microsoft Windows platforms.
+ **/
+#define S3_INIT_WINSOCK 1
+
+
+/**
+ * This convenience constant is used by the S3_initialize() function to
+ * indicate that all libraries required by libs3 should be initialized.
+ **/
+#define S3_INIT_ALL (S3_INIT_WINSOCK)
+
+
+/** **************************************************************************
+ * Enumerations
+ ************************************************************************** **/
+
+/**
+ * S3Status is a status code as returned by a libs3 function. The meaning of
+ * each status code is defined in the comments for each function which returns
+ * that status.
+ **/
+typedef enum
+{
+ S3StatusOK ,
+
+ /**
+ * Errors that prevent the S3 request from being issued or response from
+ * being read
+ **/
+ S3StatusInternalError ,
+ S3StatusOutOfMemory ,
+ S3StatusInterrupted ,
+ S3StatusInvalidBucketNameTooLong ,
+ S3StatusInvalidBucketNameFirstCharacter ,
+ S3StatusInvalidBucketNameCharacter ,
+ S3StatusInvalidBucketNameCharacterSequence ,
+ S3StatusInvalidBucketNameTooShort ,
+ S3StatusInvalidBucketNameDotQuadNotation ,
+ S3StatusQueryParamsTooLong ,
+ S3StatusFailedToInitializeRequest ,
+ S3StatusMetaDataHeadersTooLong ,
+ S3StatusBadMetaData ,
+ S3StatusBadContentType ,
+ S3StatusContentTypeTooLong ,
+ S3StatusBadMD5 ,
+ S3StatusMD5TooLong ,
+ S3StatusBadCacheControl ,
+ S3StatusCacheControlTooLong ,
+ S3StatusBadContentDispositionFilename ,
+ S3StatusContentDispositionFilenameTooLong ,
+ S3StatusBadContentEncoding ,
+ S3StatusContentEncodingTooLong ,
+ S3StatusBadIfMatchETag ,
+ S3StatusIfMatchETagTooLong ,
+ S3StatusBadIfNotMatchETag ,
+ S3StatusIfNotMatchETagTooLong ,
+ S3StatusHeadersTooLong ,
+ S3StatusKeyTooLong ,
+ S3StatusUriTooLong ,
+ S3StatusXmlParseFailure ,
+ S3StatusEmailAddressTooLong ,
+ S3StatusUserIdTooLong ,
+ S3StatusUserDisplayNameTooLong ,
+ S3StatusGroupUriTooLong ,
+ S3StatusPermissionTooLong ,
+ S3StatusTargetBucketTooLong ,
+ S3StatusTargetPrefixTooLong ,
+ S3StatusTooManyGrants ,
+ S3StatusBadGrantee ,
+ S3StatusBadPermission ,
+ S3StatusXmlDocumentTooLarge ,
+ S3StatusNameLookupError ,
+ S3StatusFailedToConnect ,
+ S3StatusServerFailedVerification ,
+ S3StatusConnectionFailed ,
+ S3StatusAbortedByCallback ,
+
+ /**
+ * Errors from the S3 service
+ **/
+ S3StatusErrorAccessDenied ,
+ S3StatusErrorAccountProblem ,
+ S3StatusErrorAmbiguousGrantByEmailAddress ,
+ S3StatusErrorBadDigest ,
+ S3StatusErrorBucketAlreadyExists ,
+ S3StatusErrorBucketAlreadyOwnedByYou ,
+ S3StatusErrorBucketNotEmpty ,
+ S3StatusErrorCredentialsNotSupported ,
+ S3StatusErrorCrossLocationLoggingProhibited ,
+ S3StatusErrorEntityTooSmall ,
+ S3StatusErrorEntityTooLarge ,
+ S3StatusErrorExpiredToken ,
+ S3StatusErrorIncompleteBody ,
+ S3StatusErrorIncorrectNumberOfFilesInPostRequest ,
+ S3StatusErrorInlineDataTooLarge ,
+ S3StatusErrorInternalError ,
+ S3StatusErrorInvalidAccessKeyId ,
+ S3StatusErrorInvalidAddressingHeader ,
+ S3StatusErrorInvalidArgument ,
+ S3StatusErrorInvalidBucketName ,
+ S3StatusErrorInvalidDigest ,
+ S3StatusErrorInvalidLocationConstraint ,
+ S3StatusErrorInvalidPayer ,
+ S3StatusErrorInvalidPolicyDocument ,
+ S3StatusErrorInvalidRange ,
+ S3StatusErrorInvalidSecurity ,
+ S3StatusErrorInvalidSOAPRequest ,
+ S3StatusErrorInvalidStorageClass ,
+ S3StatusErrorInvalidTargetBucketForLogging ,
+ S3StatusErrorInvalidToken ,
+ S3StatusErrorInvalidURI ,
+ S3StatusErrorKeyTooLong ,
+ S3StatusErrorMalformedACLError ,
+ S3StatusErrorMalformedXML ,
+ S3StatusErrorMaxMessageLengthExceeded ,
+ S3StatusErrorMaxPostPreDataLengthExceededError ,
+ S3StatusErrorMetadataTooLarge ,
+ S3StatusErrorMethodNotAllowed ,
+ S3StatusErrorMissingAttachment ,
+ S3StatusErrorMissingContentLength ,
+ S3StatusErrorMissingSecurityElement ,
+ S3StatusErrorMissingSecurityHeader ,
+ S3StatusErrorNoLoggingStatusForKey ,
+ S3StatusErrorNoSuchBucket ,
+ S3StatusErrorNoSuchKey ,
+ S3StatusErrorNotImplemented ,
+ S3StatusErrorNotSignedUp ,
+ S3StatusErrorOperationAborted ,
+ S3StatusErrorPermanentRedirect ,
+ S3StatusErrorPreconditionFailed ,
+ S3StatusErrorRedirect ,
+ S3StatusErrorRequestIsNotMultiPartContent ,
+ S3StatusErrorRequestTimeout ,
+ S3StatusErrorRequestTimeTooSkewed ,
+ S3StatusErrorRequestTorrentOfBucketError ,
+ S3StatusErrorSignatureDoesNotMatch ,
+ S3StatusErrorSlowDown ,
+ S3StatusErrorTemporaryRedirect ,
+ S3StatusErrorTokenRefreshRequired ,
+ S3StatusErrorTooManyBuckets ,
+ S3StatusErrorUnexpectedContent ,
+ S3StatusErrorUnresolvableGrantByEmailAddress ,
+ S3StatusErrorUserKeyMustBeSpecified ,
+ S3StatusErrorUnknown ,
+
+ /**
+ * The following are HTTP errors returned by S3 without enough detail to
+ * distinguish any of the above S3StatusError conditions
+ **/
+ S3StatusHttpErrorMovedTemporarily ,
+ S3StatusHttpErrorBadRequest ,
+ S3StatusHttpErrorForbidden ,
+ S3StatusHttpErrorNotFound ,
+ S3StatusHttpErrorConflict ,
+ S3StatusHttpErrorUnknown
+} S3Status;
+
+
+/**
+ * S3Protocol represents a protocol that may be used for communicating a
+ * request to the Amazon S3 service.
+ *
+ * In general, HTTPS is greatly preferred (and should be the default of any
+ * application using libs3) because it protects any data being sent to or
+ * from S3 using strong encryption. However, HTTPS is much more CPU intensive
+ * than HTTP, and if the caller is absolutely certain that it is OK for the
+ * data to be viewable by anyone in transit, then HTTP can be used.
+ **/
+typedef enum
+{
+ S3ProtocolHTTPS = 0,
+ S3ProtocolHTTP = 1
+} S3Protocol;
+
+
+/**
+ * S3UriStyle defines the form that an Amazon S3 URI identifying a bucket or
+ * object can take. They are of these forms:
+ *
+ * Virtual Host: ${protocol}://${bucket}.s3.amazonaws.com/[${key}]
+ * Path: ${protocol}://s3.amazonaws.com/${bucket}/[${key}]
+ *
+ * It is generally better to use the Virual Host URI form, because it ensures
+ * that the bucket name used is compatible with normal HTTP GETs and POSTs of
+ * data to/from the bucket. However, if DNS lookups for the bucket are too
+ * slow or unreliable for some reason, Path URI form may be used.
+ **/
+typedef enum
+{
+ S3UriStyleVirtualHost = 0,
+ S3UriStylePath = 1
+} S3UriStyle;
+
+
+/**
+ * S3GranteeType defines the type of Grantee used in an S3 ACL Grant.
+ * Amazon Customer By Email - identifies the Grantee using their Amazon S3
+ * account email address
+ * Canonical User - identifies the Grantee by S3 User ID and Display Name,
+ * which can only be obtained by making requests to S3, for example, by
+ * listing owned buckets
+ * All AWS Users - identifies all authenticated AWS users
+ * All Users - identifies all users
+ * Log Delivery - identifies the Amazon group responsible for writing
+ * server access logs into buckets
+ **/
+typedef enum
+{
+ S3GranteeTypeAmazonCustomerByEmail = 0,
+ S3GranteeTypeCanonicalUser = 1,
+ S3GranteeTypeAllAwsUsers = 2,
+ S3GranteeTypeAllUsers = 3,
+ S3GranteeTypeLogDelivery = 4
+} S3GranteeType;
+
+
+/**
+ * This is an individual permission granted to a grantee in an S3 ACL Grant.
+ * Read permission gives the Grantee the permission to list the bucket, or
+ * read the object or its metadata
+ * Write permission gives the Grantee the permission to create, overwrite, or
+ * delete any object in the bucket, and is not supported for objects
+ * ReadACP permission gives the Grantee the permission to read the ACP for
+ * the bucket or object; the owner of the bucket or object always has
+ * this permission implicitly
+ * WriteACP permission gives the Grantee the permission to overwrite the ACP
+ * for the bucket or object; the owner of the bucket or object always has
+ * this permission implicitly
+ * FullControl permission gives the Grantee all permissions specified by the
+ * Read, Write, ReadACP, and WriteACP permissions
+ **/
+typedef enum
+{
+ S3PermissionRead = 0,
+ S3PermissionWrite = 1,
+ S3PermissionReadACP = 2,
+ S3PermissionWriteACP = 3,
+ S3PermissionFullControl = 4
+} S3Permission;
+
+
+/**
+ * S3CannedAcl is an ACL that can be specified when an object is created or
+ * updated. Each canned ACL has a predefined value when expanded to a full
+ * set of S3 ACL Grants.
+ * Private canned ACL gives the owner FULL_CONTROL and no other permissions
+ * are issued
+ * Public Read canned ACL gives the owner FULL_CONTROL and all users Read
+ * permission
+ * Public Read Write canned ACL gives the owner FULL_CONTROL and all users
+ * Read and Write permission
+ * AuthenticatedRead canned ACL gives the owner FULL_CONTROL and authenticated
+ * S3 users Read permission
+ **/
+typedef enum
+{
+ S3CannedAclPrivate = 0, /* private */
+ S3CannedAclPublicRead = 1, /* public-read */
+ S3CannedAclPublicReadWrite = 2, /* public-read-write */
+ S3CannedAclAuthenticatedRead = 3 /* authenticated-read */
+} S3CannedAcl;
+
+
+/** **************************************************************************
+ * Data Types
+ ************************************************************************** **/
+
+/**
+ * An S3RequestContext manages multiple S3 requests simultaneously; see the
+ * S3_XXX_request_context functions below for details
+ **/
+typedef struct S3RequestContext S3RequestContext;
+
+
+/**
+ * S3NameValue represents a single Name - Value pair, used to represent either
+ * S3 metadata associated with a key, or S3 error details.
+ **/
+typedef struct S3NameValue
+{
+ /**
+ * The name part of the Name - Value pair
+ **/
+ const char *name;
+
+ /**
+ * The value part of the Name - Value pair
+ **/
+ const char *value;
+} S3NameValue;
+
+
+/**
+ * S3ResponseProperties is passed to the properties callback function which is
+ * called when the complete response properties have been received. Some of
+ * the fields of this structure are optional and may not be provided in the
+ * response, and some will always be provided in the response.
+ **/
+typedef struct S3ResponseProperties
+{
+ /**
+ * This optional field identifies the request ID and may be used when
+ * reporting problems to Amazon.
+ **/
+ const char *requestId;
+
+ /**
+ * This optional field identifies the request ID and may be used when
+ * reporting problems to Amazon.
+ **/
+ const char *requestId2;
+
+ /**
+ * This optional field is the content type of the data which is returned
+ * by the request. If not provided, the default can be assumed to be
+ * "binary/octet-stream".
+ **/
+ const char *contentType;
+
+ /**
+ * This optional field is the content length of the data which is returned
+ * in the response. A negative value means that this value was not
+ * provided in the response. A value of 0 means that there is no content
+ * provided. A positive value gives the number of bytes in the content of
+ * the response.
+ **/
+ uint64_t contentLength;
+
+ /**
+ * This optional field names the server which serviced the request.
+ **/
+ const char *server;
+
+ /**
+ * This optional field provides a string identifying the unique contents
+ * of the resource identified by the request, such that the contents can
+ * be assumed not to be changed if the same eTag is returned at a later
+ * time decribing the same resource. This is an MD5 sum of the contents.
+ **/
+ const char *eTag;
+
+ /**
+ * This optional field provides the last modified time, relative to the
+ * Unix epoch, of the contents. If this value is < 0, then the last
+ * modified time was not provided in the response. If this value is >= 0,
+ * then the last modified date of the contents are available as a number
+ * of seconds since the UNIX epoch.
+ *
+ **/
+ int64_t lastModified;
+
+ /**
+ * This is the number of user-provided meta data associated with the
+ * resource.
+ **/
+ int metaDataCount;
+
+ /**
+ * These are the meta data associated with the resource. In each case,
+ * the name will not include any S3-specific header prefixes
+ * (i.e. x-amz-meta- will have been removed from the beginning), and
+ * leading and trailing whitespace will have been stripped from the value.
+ **/
+ const S3NameValue *metaData;
+} S3ResponseProperties;
+
+
+/**
+ * S3AclGrant identifies a single grant in the ACL for a bucket or object. An
+ * ACL is composed of any number of grants, which specify a grantee and the
+ * permissions given to that grantee. S3 does not normalize ACLs in any way,
+ * so a redundant ACL specification will lead to a redundant ACL stored in S3.
+ **/
+typedef struct S3AclGrant
+{
+ /**
+ * The granteeType gives the type of grantee specified by this grant.
+ **/
+ S3GranteeType granteeType;
+ /**
+ * The identifier of the grantee that is set is determined by the
+ * granteeType:
+ *
+ * S3GranteeTypeAmazonCustomerByEmail - amazonCustomerByEmail.emailAddress
+ * S3GranteeTypeCanonicalUser - canonicalUser.id, canonicalUser.displayName
+ * S3GranteeTypeAllAwsUsers - none
+ * S3GranteeTypeAllUsers - none
+ **/
+ union
+ {
+ /**
+ * This structure is used iff the granteeType is
+ * S3GranteeTypeAmazonCustomerByEmail.
+ **/
+ struct
+ {
+ /**
+ * This is the email address of the Amazon Customer being granted
+ * permissions by this S3AclGrant.
+ **/
+ char emailAddress[S3_MAX_GRANTEE_EMAIL_ADDRESS_SIZE];
+ } amazonCustomerByEmail;
+ /**
+ * This structure is used iff the granteeType is
+ * S3GranteeTypeCanonicalUser.
+ **/
+ struct
+ {
+ /**
+ * This is the CanonicalUser ID of the grantee
+ **/
+ char id[S3_MAX_GRANTEE_USER_ID_SIZE];
+ /**
+ * This is the display name of the grantee
+ **/
+ char displayName[S3_MAX_GRANTEE_DISPLAY_NAME_SIZE];
+ } canonicalUser;
+ } grantee;
+ /**
+ * This is the S3Permission to be granted to the grantee
+ **/
+ S3Permission permission;
+} S3AclGrant;
+
+
+/**
+ * A context for working with objects within a bucket. A bucket context holds
+ * all information necessary for working with a bucket, and may be used
+ * repeatedly over many consecutive (or simultaneous) calls into libs3 bucket
+ * operation functions.
+ **/
+typedef struct S3BucketContext
+{
+ /**
+ * The name of the bucket to use in the bucket context
+ **/
+ const char *bucketName;
+
+ /**
+ * The protocol to use when accessing the bucket
+ **/
+ S3Protocol protocol;
+
+ /**
+ * The URI style to use for all URIs sent to Amazon S3 while working with
+ * this bucket context
+ **/
+ S3UriStyle uriStyle;
+
+ /**
+ * The Amazon Access Key ID to use for access to the bucket
+ **/
+ const char *accessKeyId;
+
+ /**
+ * The Amazon Secret Access Key to use for access to the bucket
+ **/
+ const char *secretAccessKey;
+} S3BucketContext;
+
+
+/**
+ * This is a single entry supplied to the list bucket callback by a call to
+ * S3_list_bucket. It identifies a single matching key from the list
+ * operation.
+ **/
+typedef struct S3ListBucketContent
+{
+ /**
+ * This is the next key in the list bucket results.
+ **/
+ const char *key;
+
+ /**
+ * This is the number of seconds since UNIX epoch of the last modified
+ * date of the object identified by the key.
+ **/
+ int64_t lastModified;
+
+ /**
+ * This gives a tag which gives a signature of the contents of the object,
+ * which is the MD5 of the contents of the object.
+ **/
+ const char *eTag;
+
+ /**
+ * This is the size of the object in bytes.
+ **/
+ uint64_t size;
+
+ /**
+ * This is the ID of the owner of the key; it is present only if access
+ * permissions allow it to be viewed.
+ **/
+ const char *ownerId;
+
+ /**
+ * This is the display name of the owner of the key; it is present only if
+ * access permissions allow it to be viewed.
+ **/
+ const char *ownerDisplayName;
+} S3ListBucketContent;
+
+
+/**
+ * S3PutProperties is the set of properties that may optionally be set by the
+ * user when putting objects to S3. Each field of this structure is optional
+ * and may or may not be present.
+ **/
+typedef struct S3PutProperties
+{
+ /**
+ * If present, this is the Content-Type that should be associated with the
+ * object. If not provided, S3 defaults to "binary/octet-stream".
+ **/
+ const char *contentType;
+
+ /**
+ * If present, this provides the MD5 signature of the contents, and is
+ * used to validate the contents. This is highly recommended by Amazon
+ * but not required. Its format is as a base64-encoded MD5 sum.
+ **/
+ const char *md5;
+
+ /**
+ * If present, this gives a Cache-Control header string to be supplied to
+ * HTTP clients which download this
+ **/
+ const char *cacheControl;
+
+ /**
+ * If present, this gives the filename to save the downloaded file to,
+ * whenever the object is downloaded via a web browser. This is only
+ * relevent for objects which are intended to be shared to users via web
+ * browsers and which is additionally intended to be downloaded rather
+ * than viewed.
+ **/
+ const char *contentDispositionFilename;
+
+ /**
+ * If present, this identifies the content encoding of the object. This
+ * is only applicable to encoded (usually, compressed) content, and only
+ * relevent if the object is intended to be downloaded via a browser.
+ **/
+ const char *contentEncoding;
+
+ /**
+ * If >= 0, this gives an expiration date for the content. This
+ * information is typically only delivered to users who download the
+ * content via a web browser.
+ **/
+ int64_t expires;
+
+ /**
+ * This identifies the "canned ACL" that should be used for this object.
+ * The default (0) gives only the owner of the object access to it.
+ **/
+ S3CannedAcl cannedAcl;
+
+ /**
+ * This is the number of values in the metaData field.
+ **/
+ int metaDataCount;
+
+ /**
+ * These are the meta data to pass to S3. In each case, the name part of
+ * the Name - Value pair should not include any special S3 HTTP header
+ * prefix (i.e., should be of the form 'foo', NOT 'x-amz-meta-foo').
+ **/
+ const S3NameValue *metaData;
+} S3PutProperties;
+
+
+/**
+ * S3GetConditions is used for the get_object operation, and specifies
+ * conditions which the object must meet in order to be successfully returned.
+ **/
+typedef struct S3GetConditions
+{
+ /**
+ * The request will be processed if the Last-Modification header of the
+ * object is greater than or equal to this value, specified as a number of
+ * seconds since Unix epoch. If this value is less than zero, it will not
+ * be used in the conditional.
+ **/
+ int64_t ifModifiedSince;
+
+ /**
+ * The request will be processed if the Last-Modification header of the
+ * object is less than this value, specified as a number of seconds since
+ * Unix epoch. If this value is less than zero, it will not be used in
+ * the conditional.
+ **/
+ int64_t ifNotModifiedSince;
+
+ /**
+ * If non-NULL, this gives an eTag header value which the object must
+ * match in order to be returned. Note that altough the eTag is simply an
+ * MD5, this must be presented in the S3 eTag form, which typically
+ * includes double-quotes.
+ **/
+ const char *ifMatchETag;
+
+ /**
+ * If non-NULL, this gives an eTag header value which the object must not
+ * match in order to be returned. Note that altough the eTag is simply an
+ * MD5, this must be presented in the S3 eTag form, which typically
+ * includes double-quotes.
+ **/
+ const char *ifNotMatchETag;
+} S3GetConditions;
+
+
+/**
+ * S3ErrorDetails provides detailed information describing an S3 error. This
+ * is only presented when the error is an S3-generated error (i.e. one of the
+ * S3StatusErrorXXX values).
+ **/
+typedef struct S3ErrorDetails
+{
+ /**
+ * This is the human-readable message that Amazon supplied describing the
+ * error
+ **/
+ const char *message;
+
+ /**
+ * This identifies the resource for which the error occurred
+ **/
+ const char *resource;
+
+ /**
+ * This gives human-readable further details describing the specifics of
+ * this error
+ **/
+ const char *furtherDetails;
+
+ /**
+ * This gives the number of S3NameValue pairs present in the extraDetails
+ * array
+ **/
+ int extraDetailsCount;
+
+ /**
+ * S3 can provide extra details in a freeform Name - Value pair format.
+ * Each error can have any number of these, and this array provides these
+ * additional extra details.
+ **/
+ S3NameValue *extraDetails;
+} S3ErrorDetails;
+
+
+/** **************************************************************************
+ * Callback Signatures
+ ************************************************************************** **/
+
+/**
+ * This callback is made whenever the response properties become available for
+ * any request.
+ *
+ * @param properties are the properties that are available from the response
+ * @param callbackData is the callback data as specified when the request
+ * was issued.
+ * @return S3StatusOK to continue processing the request, anything else to
+ * immediately abort the request with a status which will be
+ * passed to the S3ResponseCompleteCallback for this request.
+ * Typically, this will return either S3StatusOK or
+ * S3StatusAbortedByCallback.
+ **/
+typedef S3Status (S3ResponsePropertiesCallback)
+ (const S3ResponseProperties *properties, void *callbackData);
+
+
+/**
+ * This callback is made when the response has been completely received, or an
+ * error has occurred which has prematurely aborted the request, or one of the
+ * other user-supplied callbacks returned a value intended to abort the
+ * request. This callback is always made for every request, as the very last
+ * callback made for that request.
+ *
+ * @param status gives the overall status of the response, indicating success
+ * or failure; use S3_status_is_retryable() as a simple way to detect
+ * whether or not the status indicates that the request failed but may
+ * be retried.
+ * @param errorDetails if non-NULL, gives details as returned by the S3
+ * service, describing the error
+ * @param callbackData is the callback data as specified when the request
+ * was issued.
+ **/
+typedef void (S3ResponseCompleteCallback)(S3Status status,
+ const S3ErrorDetails *errorDetails,
+ void *callbackData);
+
+
+/**
+ * This callback is made for each bucket resulting from a list service
+ * operation.
+ *
+ * @param ownerId is the ID of the owner of the bucket
+ * @param ownerDisplayName is the owner display name of the owner of the bucket
+ * @param bucketName is the name of the bucket
+ * @param creationDateSeconds if < 0 indicates that no creation date was
+ * supplied for the bucket; if >= 0 indicates the number of seconds
+ * since UNIX Epoch of the creation date of the bucket
+ * @param callbackData is the callback data as specified when the request
+ * was issued.
+ * @return S3StatusOK to continue processing the request, anything else to
+ * immediately abort the request with a status which will be
+ * passed to the S3ResponseCompleteCallback for this request.
+ * Typically, this will return either S3StatusOK or
+ * S3StatusAbortedByCallback.
+ **/
+typedef S3Status (S3ListServiceCallback)(const char *ownerId,
+ const char *ownerDisplayName,
+ const char *bucketName,
+ int64_t creationDateSeconds,
+ void *callbackData);
+
+
+/**
+ * This callback is made repeatedly as a list bucket operation progresses.
+ * The contents reported via this callback are only reported once per list
+ * bucket operation, but multiple calls to this callback may be necessary to
+ * report all items resulting from the list bucket operation.
+ *
+ * @param isTruncated is true if the list bucket request was truncated by the
+ * S3 service, in which case the remainder of the list may be obtained
+ * by querying again using the Marker parameter to start the query
+ * after this set of results
+ * @param nextMarker if present, gives the largest (alphabetically) key
+ * returned in the response, which, if isTruncated is true, may be used
+ * as the marker in a subsequent list buckets operation to continue
+ * listing
+ * @param contentsCount is the number of ListBucketContent structures in the
+ * contents parameter
+ * @param contents is an array of ListBucketContent structures, each one
+ * describing an object in the bucket
+ * @param commonPrefixesCount is the number of common prefixes strings in the
+ * commonPrefixes parameter
+ * @param commonPrefixes is an array of strings, each specifing one of the
+ * common prefixes as returned by S3
+ * @param callbackData is the callback data as specified when the request
+ * was issued.
+ * @return S3StatusOK to continue processing the request, anything else to
+ * immediately abort the request with a status which will be
+ * passed to the S3ResponseCompleteCallback for this request.
+ * Typically, this will return either S3StatusOK or
+ * S3StatusAbortedByCallback.
+ **/
+typedef S3Status (S3ListBucketCallback)(int isTruncated,
+ const char *nextMarker,
+ int contentsCount,
+ const S3ListBucketContent *contents,
+ int commonPrefixesCount,
+ const char **commonPrefixes,
+ void *callbackData);
+
+
+/**
+ * This callback is made during a put object operation, to obtain the next
+ * chunk of data to put to the S3 service as the contents of the object. This
+ * callback is made repeatedly, each time acquiring the next chunk of data to
+ * write to the service, until a negative or 0 value is returned.
+ *
+ * @param bufferSize gives the maximum number of bytes that may be written
+ * into the buffer parameter by this callback
+ * @param buffer gives the buffer to fill with at most bufferSize bytes of
+ * data as the next chunk of data to send to S3 as the contents of this
+ * object
+ * @param callbackData is the callback data as specified when the request
+ * was issued.
+ * @return < 0 to abort the request with the S3StatusAbortedByCallback, which
+ * will be pased to the response complete callback for this request, or
+ * 0 to indicate the end of data, or > 0 to identify the number of
+ * bytes that were written into the buffer by this callback
+ **/
+typedef int (S3PutObjectDataCallback)(int bufferSize, char *buffer,
+ void *callbackData);
+
+
+/**
+ * This callback is made during a get object operation, to provide the next
+ * chunk of data available from the S3 service constituting the contents of
+ * the object being fetched. This callback is made repeatedly, each time
+ * providing the next chunk of data read, until the complete object contents
+ * have been passed through the callback in this way, or the callback
+ * returns an error status.
+ *
+ * @param bufferSize gives the number of bytes in buffer
+ * @param buffer is the data being passed into the callback
+ * @param callbackData is the callback data as specified when the request
+ * was issued.
+ * @return S3StatusOK to continue processing the request, anything else to
+ * immediately abort the request with a status which will be
+ * passed to the S3ResponseCompleteCallback for this request.
+ * Typically, this will return either S3StatusOK or
+ * S3StatusAbortedByCallback.
+ **/
+typedef S3Status (S3GetObjectDataCallback)(int bufferSize, const char *buffer,
+ void *callbackData);
+
+
+/** **************************************************************************
+ * Callback Structures
+ ************************************************************************** **/
+
+
+/**
+ * An S3ResponseHandler defines the callbacks which are made for any
+ * request.
+ **/
+typedef struct S3ResponseHandler
+{
+ /**
+ * The propertiesCallback is made when the response properties have
+ * successfully been returned from S3. This function may not be called
+ * if the response properties were not successfully returned from S3.
+ **/
+ S3ResponsePropertiesCallback *propertiesCallback;
+
+ /**
+ * The completeCallback is always called for every request made to S3,
+ * regardless of the outcome of the request. It provides the status of
+ * the request upon its completion, as well as extra error details in the
+ * event of an S3 error.
+ **/
+ S3ResponseCompleteCallback *completeCallback;
+} S3ResponseHandler;
+
+
+/**
+ * An S3ListServiceHandler defines the callbacks which are made for
+ * list_service requests.
+ **/
+typedef struct S3ListServiceHandler
+{
+ /**
+ * responseHandler provides the properties and complete callback
+ **/
+ S3ResponseHandler responseHandler;
+
+ /**
+ * The listServiceCallback is called as items are reported back from S3 as
+ * responses to the request
+ **/
+ S3ListServiceCallback *listServiceCallback;
+} S3ListServiceHandler;
+
+
+/**
+ * An S3ListBucketHandler defines the callbacks which are made for
+ * list_bucket requests.
+ **/
+typedef struct S3ListBucketHandler
+{
+ /**
+ * responseHandler provides the properties and complete callback
+ **/
+ S3ResponseHandler responseHandler;
+
+ /**
+ * The listBucketCallback is called as items are reported back from S3 as
+ * responses to the request. This may be called more than one time per
+ * list bucket request, each time providing more items from the list
+ * operation.
+ **/
+ S3ListBucketCallback *listBucketCallback;
+} S3ListBucketHandler;
+
+
+/**
+ * An S3PutObjectHandler defines the callbacks which are made for
+ * put_object requests.
+ **/
+typedef struct S3PutObjectHandler
+{
+ /**
+ * responseHandler provides the properties and complete callback
+ **/
+ S3ResponseHandler responseHandler;
+
+ /**
+ * The putObjectDataCallback is called to acquire data to send to S3 as
+ * the contents of the put_object request. It is made repeatedly until it
+ * returns a negative number (indicating that the request should be
+ * aborted), or 0 (indicating that all data has been supplied).
+ **/
+ S3PutObjectDataCallback *putObjectDataCallback;
+} S3PutObjectHandler;
+
+
+/**
+ * An S3GetObjectHandler defines the callbacks which are made for
+ * get_object requests.
+ **/
+typedef struct S3GetObjectHandler
+{
+ /**
+ * responseHandler provides the properties and complete callback
+ **/
+ S3ResponseHandler responseHandler;
+
+ /**
+ * The getObjectDataCallback is called as data is read from S3 as the
+ * contents of the object being read in the get_object request. It is
+ * called repeatedly until there is no more data provided in the request,
+ * or until the callback returns an error status indicating that the
+ * request should be aborted.
+ **/
+ S3GetObjectDataCallback *getObjectDataCallback;
+} S3GetObjectHandler;
+
+
+/** **************************************************************************
+ * General Library Functions
+ ************************************************************************** **/
+
+/**
+ * Initializes libs3 for use. This function must be called before any other
+ * libs3 function is called. It may be called multiple times, with the same
+ * effect as calling it once, as long as S3_deinitialize() is called an
+ * equal number of times when the program has finished. This function is NOT
+ * thread-safe and must only be called by one thread at a time.
+ *
+ * @param userAgentInfo is a string that will be included in the User-Agent
+ * header of every request made to the S3 service. You may provide
+ * NULL or the empty string if you don't care about this. The value
+ * will not be copied by this function and must remain unaltered by the
+ * caller until S3_deinitialize() is called.
+ * @param flags is a bitmask of some combination of S3_INIT_XXX flag, or
+ * S3_INIT_ALL, indicating which of the libraries that libs3 depends
+ * upon should be initialized by S3_initialize(). Only if your program
+ * initializes one of these dependency libraries itself should anything
+ * other than S3_INIT_ALL be passed in for this bitmask.
+ *
+ * You should pass S3_INIT_WINSOCK if and only if your application does
+ * not initialize winsock elsewhere. On non-Microsoft Windows
+ * platforms it has no effect.
+ *
+ * As a convenience, the macro S3_INIT_ALL is provided, which will do
+ * all necessary initialization; however, be warned that things may
+ * break if your application re-initializes the dependent libraries
+ * later.
+ * @return One of:
+ * S3StatusOK on success
+ * S3StatusInternalError if dependent libraries could not be
+ * initialized
+ * S3StatusOutOfMemory on failure due to out of memory
+ **/
+S3Status S3_initialize(const char *userAgentInfo, int flags);
+
+
+/**
+ * Must be called once per program for each call to libs3_initialize(). After
+ * this call is complete, no libs3 function may be called except
+ * S3_initialize().
+ **/
+void S3_deinitialize();
+
+
+/**
+ * Returns a string with the textual name of an S3Status code
+ *
+ * @param status is S3Status code for which the textual name will be returned
+ * @return a string with the textual name of an S3Status code
+ **/
+const char *S3_get_status_name(S3Status status);
+
+
+/**
+ * This function may be used to validate an S3 bucket name as being in the
+ * correct form for use with the S3 service. Amazon S3 limits the allowed
+ * characters in S3 bucket names, as well as imposing some additional rules on
+ * the length of bucket names and their structure. There are actually two
+ * limits; one for bucket names used only in path-style URIs, and a more
+ * strict limit used for bucket names used in virtual-host-style URIs. It is
+ * advisable to use only bucket names which meet the more strict requirements
+ * regardless of how the bucket expected to be used.
+ *
+ * This method does NOT validate that the bucket is available for use in the
+ * S3 service, so the return value of this function cannot be used to decide
+ * whether or not a bucket with the give name already exists in Amazon S3 or
+ * is accessible by the caller. It merely validates that the bucket name is
+ * valid for use with S3.
+ *
+ * @param bucketName is the bucket name to validate
+ * @param uriStyle gives the URI style to validate the bucket name against.
+ * It is advisable to always use S3UriStyleVirtuallHost.
+ * @return One of:
+ * S3StatusOK if the bucket name was validates successfully
+ * S3StatusInvalidBucketNameTooLong if the bucket name exceeded the
+ * length limitation for the URI style, which is 255 bytes for
+ * path style URIs and 63 bytes for virtual host type URIs
+ * S3StatusInvalidBucketNameTooShort if the bucket name is less than
+ * 3 characters
+ * S3StatusInvalidBucketNameFirstCharacter if the bucket name as an
+ * invalid first character, which is anything other than
+ * an alphanumeric character
+ * S3StatusInvalidBucketNameCharacterSequence if the bucket name
+ * includes an invalid character sequence, which for virtual host
+ * style buckets is ".-" or "-."
+ * S3StatusInvalidBucketNameCharacter if the bucket name includes an
+ * invalid character, which is anything other than alphanumeric,
+ * '-', '.', or for path style URIs only, '_'.
+ * S3StatusInvalidBucketNameDotQuadNotation if the bucket name is in
+ * dot-quad notation, i.e. the form of an IP address, which is
+ * not allowed by Amazon S3.
+ **/
+S3Status S3_validate_bucket_name(const char *bucketName, S3UriStyle uriStyle);
+
+
+/**
+ * Converts an XML representation of an ACL to a libs3 structured
+ * representation. This method is not strictly necessary for working with
+ * ACLs using libs3, but may be convenient for users of the library who read
+ * ACLs from elsewhere in XML format and need to use these ACLs with libs3.
+ *
+ * @param aclXml is the XML representation of the ACL. This must be a
+ * zero-terminated character string.
+ * @param ownerId will be filled in with the Owner ID specified in the XML.
+ * At most MAX_GRANTEE_USER_ID_SIZE bytes will be stored at this
+ * location.
+ * @param ownerDisplayName will be filled in with the Owner Display Name
+ * specified in the XML. At most MAX_GRANTEE_DISPLAY_NAME_SIZE bytes
+ * will be stored at this location.
+ * @param aclGrantCountReturn returns the number of S3AclGrant structures
+ * returned in the aclGrantsReturned array
+ * @param aclGrants must be passed in as an array of at least S3_ACL_MAXCOUNT
+ * structures, and on return from this function, the first
+ * aclGrantCountReturn structures will be filled in with the ACLs
+ * represented by the input XML.
+ * @return One of:
+ * S3StatusOK on successful conversion of the ACL
+ * S3StatusInternalError on internal error representing a bug in the
+ * libs3 library
+ * S3StatusXmlParseFailure if the XML document was malformed
+ **/
+S3Status S3_convert_acl(char *aclXml, char *ownerId, char *ownerDisplayName,
+ int *aclGrantCountReturn, S3AclGrant *aclGrants);
+
+
+/**
+ * Returns nonzero if the status indicates that the request should be
+ * immediately retried, because the status indicates an error of a nature that
+ * is likely due to transient conditions on the local system or S3, such as
+ * network failures, or internal retryable errors reported by S3. Returns
+ * zero otherwise.
+ *
+ * @param status is the status to evaluate
+ * @return nonzero if the status indicates a retryable error, 0 otherwise
+ **/
+int S3_status_is_retryable(S3Status status);
+
+
+/** **************************************************************************
+ * Request Context Management Functions
+ ************************************************************************** **/
+
+/**
+ * An S3RequestContext allows muliple requests to be serviced by the same
+ * thread simultaneously. It is an optional parameter to all libs3 request
+ * functions, and if provided, the request is managed by the S3RequestContext;
+ * if not, the request is handled synchronously and is complete when the libs3
+ * request function has returned.
+ *
+ * @param requestContextReturn returns the newly-created S3RequestContext
+ * structure, which if successfully returned, must be destroyed via a
+ * call to S3_destroy_request_context when it is no longer needed. If
+ * an error status is returned from this function, then
+ * requestContextReturn will not have been filled in, and
+ * S3_destroy_request_context should not be called on it
+ * @return One of:
+ * S3StatusOK if the request context was successfully created
+ * S3StatusOutOfMemory if the request context could not be created due
+ * to an out of memory error
+ **/
+S3Status S3_create_request_context(S3RequestContext **requestContextReturn);
+
+
+/**
+ * Destroys an S3RequestContext which was created with
+ * S3_create_request_context. Any requests which are currently being
+ * processed by the S3RequestContext will immediately be aborted and their
+ * request completed callbacks made with the status S3StatusInterrupted.
+ *
+ * @param requestContext is the S3RequestContext to destroy
+ **/
+void S3_destroy_request_context(S3RequestContext *requestContext);
+
+
+/**
+ * Runs the S3RequestContext until all requests within it have completed,
+ * or until an error occurs.
+ *
+ * @param requestContext is the S3RequestContext to run until all requests
+ * within it have completed or until an error occurs
+ * @return One of:
+ * S3Status if all requests were successfully run to completion
+ * S3StatusInternalError if an internal error prevented the
+ * S3RequestContext from running one or more requests
+ * S3StatusOutOfMemory if requests could not be run to completion
+ * due to an out of memory error
+ **/
+S3Status S3_runall_request_context(S3RequestContext *requestContext);
+
+
+/**
+ * Does some processing of requests within the S3RequestContext. One or more
+ * requests may have callbacks made on them and may complete. This function
+ * processes any requests which have immediately available I/O, and will not
+ * block waiting for I/O on any request. This function would normally be used
+ * with S3_get_request_context_fdsets.
+ *
+ * @param requestContext is the S3RequestContext to process
+ * @param requestsRemainingReturn returns the number of requests remaining
+ * and not yet completed within the S3RequestContext after this
+ * function returns.
+ * @return One of:
+ * S3StatusOK if request processing proceeded without error
+ * S3StatusInternalError if an internal error prevented the
+ * S3RequestContext from running one or more requests
+ * S3StatusOutOfMemory if requests could not be processed due to
+ * an out of memory error
+ **/
+S3Status S3_runonce_request_context(S3RequestContext *requestContext,
+ int *requestsRemainingReturn);
+
+
+/**
+ * This function, in conjunction allows callers to manually manage a set of
+ * requests using an S3RequestContext. This function returns the set of file
+ * descriptors which the caller can watch (typically using select()), along
+ * with any other file descriptors of interest to the caller, and using
+ * whatever timeout (if any) the caller wishes, until one or more file
+ * descriptors in the returned sets become ready for I/O, at which point
+ * S3_runonce_request_context can be called to process requests with available
+ * I/O.
+ *
+ * @param requestContext is the S3RequestContext to get fd_sets from
+ * @param readFdSet is a pointer to an fd_set which will have all file
+ * descriptors to watch for read events for the requests in the
+ * S3RequestContext set into it upon return. Should be zero'd out
+ * (using FD_ZERO) before being passed into this function.
+ * @param writeFdSet is a pointer to an fd_set which will have all file
+ * descriptors to watch for write events for the requests in the
+ * S3RequestContext set into it upon return. Should be zero'd out
+ * (using FD_ZERO) before being passed into this function.
+ * @param exceptFdSet is a pointer to an fd_set which will have all file
+ * descriptors to watch for exception events for the requests in the
+ * S3RequestContext set into it upon return. Should be zero'd out
+ * (using FD_ZERO) before being passed into this function.
+ * @param maxFd returns the highest file descriptor set into any of the
+ * fd_sets, or -1 if no file descriptors were set
+ * @return One of:
+ * S3StatusOK if all fd_sets were successfully set
+ * S3StatusInternalError if an internal error prevented this function
+ * from completing successfully
+ **/
+S3Status S3_get_request_context_fdsets(S3RequestContext *requestContext,
+ fd_set *readFdSet, fd_set *writeFdSet,
+ fd_set *exceptFdSet, int *maxFd);
+
+
+/**
+ * This function returns the maximum number of milliseconds that the caller of
+ * S3_runonce_request_context should wait on the fdsets obtained via a call to
+ * S3_get_request_context_fdsets. In other words, this is essentially the
+ * select() timeout that needs to be used (shorter values are OK, but no
+ * longer than this) to ensure that internal timeout code of libs3 can work
+ * properly. This function should be called right before select() each time
+ * select() on the request_context fdsets are to be performed by the libs3
+ * user.
+ *
+ * @param requestContext is the S3RequestContext to get the timeout from
+ * @return the maximum number of milliseconds to select() on fdsets. Callers
+ * could wait a shorter time if they wish, but not longer.
+ **/
+int64_t S3_get_request_context_timeout(S3RequestContext *requestContext);
+
+
+/** **************************************************************************
+ * S3 Utility Functions
+ ************************************************************************** **/
+
+/**
+ * Generates an HTTP authenticated query string, which may then be used by
+ * a browser (or other web client) to issue the request. The request is
+ * implicitly a GET request; Amazon S3 is documented to only support this type
+ * of authenticated query string request.
+ *
+ * @param buffer is the output buffer for the authenticated query string.
+ * It must be at least S3_MAX_AUTHENTICATED_QUERY_STRING_SIZE bytes in
+ * length.
+ * @param bucketContext gives the bucket and associated parameters for the
+ * request to generate.
+ * @param key gives the key which the authenticated request will GET.
+ * @param expires gives the number of seconds since Unix epoch for the
+ * expiration date of the request; after this time, the request will
+ * no longer be valid. If this value is negative, the largest
+ * expiration date possible is used (currently, Jan 19, 2038).
+ * @param resource gives a sub-resource to be fetched for the request, or NULL
+ * for none. This should be of the form "?<resource>", i.e.
+ * "?torrent".
+ * @return One of:
+ * S3StatusUriTooLong if, due to an internal error, the generated URI
+ * is longer than S3_MAX_AUTHENTICATED_QUERY_STRING_SIZE bytes in
+ * length and thus will not fit into the supplied buffer
+ * S3StatusOK on success
+ **/
+S3Status S3_generate_authenticated_query_string
+ (char *buffer, const S3BucketContext *bucketContext,
+ const char *key, int64_t expires, const char *resource);
+
+
+/** **************************************************************************
+ * Service Functions
+ ************************************************************************** **/
+
+/**
+ * Lists all S3 buckets belonging to the access key id.
+ *
+ * @param protocol gives the protocol to use for this request
+ * @param accessKeyId gives the Amazon Access Key ID for which to list owned
+ * buckets
+ * @param secretAccessKey gives the Amazon Secret Access Key for which to list
+ * owned buckets
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_list_service(S3Protocol protocol, const char *accessKeyId,
+ const char *secretAccessKey,
+ S3RequestContext *requestContext,
+ const S3ListServiceHandler *handler,
+ void *callbackData);
+
+
+/** **************************************************************************
+ * Bucket Functions
+ ************************************************************************** **/
+
+/**
+ * Tests the existence of an S3 bucket, additionally returning the bucket's
+ * location if it exists and is accessible.
+ *
+ * @param protocol gives the protocol to use for this request
+ * @param uriStyle gives the URI style to use for this request
+ * @param accessKeyId gives the Amazon Access Key ID for which to list owned
+ * buckets
+ * @param secretAccessKey gives the Amazon Secret Access Key for which to list
+ * owned buckets
+ * @param bucketName is the bucket name to test
+ * @param locationConstraintReturnSize gives the number of bytes in the
+ * locationConstraintReturn parameter
+ * @param locationConstraintReturn provides the location into which to write
+ * the name of the location constraint naming the geographic location
+ * of the S3 bucket. This must have at least as many characters in it
+ * as specified by locationConstraintReturn, and should start out
+ * NULL-terminated. On successful completion of this request, this
+ * will be set to the name of the geographic location of S3 bucket, or
+ * will be left as a zero-length string if no location was available.
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_test_bucket(S3Protocol protocol, S3UriStyle uriStyle,
+ const char *accessKeyId, const char *secretAccessKey,
+ const char *bucketName, int locationConstraintReturnSize,
+ char *locationConstraintReturn,
+ S3RequestContext *requestContext,
+ const S3ResponseHandler *handler, void *callbackData);
+
+
+/**
+ * Creates a new bucket.
+ *
+ * @param protocol gives the protocol to use for this request
+ * @param accessKeyId gives the Amazon Access Key ID for which to list owned
+ * buckets
+ * @param secretAccessKey gives the Amazon Secret Access Key for which to list
+ * owned buckets
+ * @param bucketName is the name of the bucket to be created
+ * @param cannedAcl gives the "REST canned ACL" to use for the created bucket
+ * @param locationConstraint if non-NULL, gives the geographic location for
+ * the bucket to create.
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_create_bucket(S3Protocol protocol, const char *accessKeyId,
+ const char *secretAccessKey, const char *bucketName,
+ S3CannedAcl cannedAcl, const char *locationConstraint,
+ S3RequestContext *requestContext,
+ const S3ResponseHandler *handler, void *callbackData);
+
+
+/**
+ * Deletes a bucket. The bucket must be empty, or the status
+ * S3StatusErrorBucketNotEmpty will result.
+ *
+ * @param protocol gives the protocol to use for this request
+ * @param uriStyle gives the URI style to use for this request
+ * @param accessKeyId gives the Amazon Access Key ID for which to list owned
+ * buckets
+ * @param secretAccessKey gives the Amazon Secret Access Key for which to list
+ * owned buckets
+ * @param bucketName is the name of the bucket to be deleted
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_delete_bucket(S3Protocol protocol, S3UriStyle uriStyle,
+ const char *accessKeyId, const char *secretAccessKey,
+ const char *bucketName, S3RequestContext *requestContext,
+ const S3ResponseHandler *handler, void *callbackData);
+
+
+/**
+ * Lists keys within a bucket.
+ *
+ * @param bucketContext gives the bucket and associated parameters for this
+ * request
+ * @param prefix if present, gives a prefix for matching keys
+ * @param marker if present, only keys occuring after this value will be
+ * listed
+ * @param delimiter if present, causes keys that contain the same string
+ * between the prefix and the first occurrence of the delimiter to be
+ * rolled up into a single result element
+ * @param maxkeys is the maximum number of keys to return
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_list_bucket(const S3BucketContext *bucketContext,
+ const char *prefix, const char *marker,
+ const char *delimiter, int maxkeys,
+ S3RequestContext *requestContext,
+ const S3ListBucketHandler *handler, void *callbackData);
+
+
+/** **************************************************************************
+ * Object Functions
+ ************************************************************************** **/
+
+/**
+ * Puts object data to S3. This overwrites any existing object at that key;
+ * note that S3 currently only supports full-object upload. The data to
+ * upload will be acquired by calling the handler's putObjectDataCallback.
+ *
+ * @param bucketContext gives the bucket and associated parameters for this
+ * request
+ * @param key is the key of the object to put to
+ * @param contentLength is required and gives the total number of bytes that
+ * will be put
+ * @param putProperties optionally provides additional properties to apply to
+ * the object that is being put to
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_put_object(const S3BucketContext *bucketContext, const char *key,
+ uint64_t contentLength,
+ const S3PutProperties *putProperties,
+ S3RequestContext *requestContext,
+ const S3PutObjectHandler *handler, void *callbackData);
+
+
+/**
+ * Copies an object from one location to another. The object may be copied
+ * back to itself, which is useful for replacing metadata without changing
+ * the object.
+ *
+ * @param bucketContext gives the source bucket and associated parameters for
+ * this request
+ * @param key is the source key
+ * @param destinationBucket gives the destination bucket into which to copy
+ * the object. If NULL, the source bucket will be used.
+ * @param destinationKey gives the destination key into which to copy the
+ * object. If NULL, the source key will be used.
+ * @param putProperties optionally provides properties to apply to the object
+ * that is being put to. If not supplied (i.e. NULL is passed in),
+ * then the copied object will retain the metadata of the copied
+ * object.
+ * @param lastModifiedReturn returns the last modified date of the copied
+ * object
+ * @param eTagReturnSize specifies the number of bytes provided in the
+ * eTagReturn buffer
+ * @param eTagReturn is a buffer into which the resulting eTag of the copied
+ * object will be written
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_copy_object(const S3BucketContext *bucketContext,
+ const char *key, const char *destinationBucket,
+ const char *destinationKey,
+ const S3PutProperties *putProperties,
+ int64_t *lastModifiedReturn, int eTagReturnSize,
+ char *eTagReturn, S3RequestContext *requestContext,
+ const S3ResponseHandler *handler, void *callbackData);
+
+
+/**
+ * Gets an object from S3. The contents of the object are returned in the
+ * handler's getObjectDataCallback.
+ *
+ * @param bucketContext gives the bucket and associated parameters for this
+ * request
+ * @param key is the key of the object to get
+ * @param getConditions if non-NULL, gives a set of conditions which must be
+ * met in order for the request to succeed
+ * @param startByte gives the start byte for the byte range of the contents
+ * to be returned
+ * @param byteCount gives the number of bytes to return; a value of 0
+ * indicates that the contents up to the end should be returned
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_get_object(const S3BucketContext *bucketContext, const char *key,
+ const S3GetConditions *getConditions,
+ uint64_t startByte, uint64_t byteCount,
+ S3RequestContext *requestContext,
+ const S3GetObjectHandler *handler, void *callbackData);
+
+
+/**
+ * Gets the response properties for the object, but not the object contents.
+ *
+ * @param bucketContext gives the bucket and associated parameters for this
+ * request
+ * @param key is the key of the object to get the properties of
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_head_object(const S3BucketContext *bucketContext, const char *key,
+ S3RequestContext *requestContext,
+ const S3ResponseHandler *handler, void *callbackData);
+
+/**
+ * Deletes an object from S3.
+ *
+ * @param bucketContext gives the bucket and associated parameters for this
+ * request
+ * @param key is the key of the object to delete
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_delete_object(const S3BucketContext *bucketContext, const char *key,
+ S3RequestContext *requestContext,
+ const S3ResponseHandler *handler, void *callbackData);
+
+
+/** **************************************************************************
+ * Access Control List Functions
+ ************************************************************************** **/
+
+/**
+ * Gets the ACL for the given bucket or object.
+ *
+ * @param bucketContext gives the bucket and associated parameters for this
+ * request
+ * @param key is the key of the object to get the ACL of; or NULL to get the
+ * ACL of the bucket
+ * @param ownerId must be supplied as a buffer of at least
+ * S3_MAX_GRANTEE_USER_ID_SIZE bytes, and will be filled in with the
+ * owner ID of the object/bucket
+ * @param ownerDisplayName must be supplied as a buffer of at least
+ * S3_MAX_GRANTEE_DISPLAY_NAME_SIZE bytes, and will be filled in with
+ * the display name of the object/bucket
+ * @param aclGrantCountReturn returns the number of S3AclGrant structures
+ * returned in the aclGrants parameter
+ * @param aclGrants must be passed in as an array of at least
+ * S3_MAX_ACL_GRANT_COUNT S3AclGrant structures, which will be filled
+ * in with the grant information for the ACL
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_get_acl(const S3BucketContext *bucketContext, const char *key,
+ char *ownerId, char *ownerDisplayName,
+ int *aclGrantCountReturn, S3AclGrant *aclGrants,
+ S3RequestContext *requestContext,
+ const S3ResponseHandler *handler, void *callbackData);
+
+
+/**
+ * Sets the ACL for the given bucket or object.
+ *
+ * @param bucketContext gives the bucket and associated parameters for this
+ * request
+ * @param key is the key of the object to set the ACL for; or NULL to set the
+ * ACL for the bucket
+ * @param ownerId is the owner ID of the object/bucket. Unfortunately, S3
+ * requires this to be valid and thus it must have been fetched by a
+ * previous S3 request, such as a list_buckets request.
+ * @param ownerDisplayName is the owner display name of the object/bucket.
+ * Unfortunately, S3 requires this to be valid and thus it must have
+ * been fetched by a previous S3 request, such as a list_buckets
+ * request.
+ * @param aclGrantCount is the number of ACL grants to set for the
+ * object/bucket
+ * @param aclGrants are the ACL grants to set for the object/bucket
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_set_acl(const S3BucketContext *bucketContext, const char *key,
+ const char *ownerId, const char *ownerDisplayName,
+ int aclGrantCount, const S3AclGrant *aclGrants,
+ S3RequestContext *requestContext,
+ const S3ResponseHandler *handler, void *callbackData);
+
+
+/** **************************************************************************
+ * Server Access Log Functions
+ ************************************************************************** **/
+
+/**
+ * Gets the service access logging settings for a bucket. The service access
+ * logging settings specify whether or not the S3 service will write service
+ * access logs for requests made for the given bucket, and if so, several
+ * settings controlling how these logs will be written.
+ *
+ * @param bucketContext gives the bucket and associated parameters for this
+ * request; this is the bucket for which service access logging is
+ * being requested
+ * @param targetBucketReturn must be passed in as a buffer of at least
+ * (S3_MAX_BUCKET_NAME_SIZE + 1) bytes in length, and will be filled
+ * in with the target bucket name for access logging for the given
+ * bucket, which is the bucket into which access logs for the specified
+ * bucket will be written. This is returned as an empty string if
+ * service access logging is not enabled for the given bucket.
+ * @param targetPrefixReturn must be passed in as a buffer of at least
+ * (S3_MAX_KEY_SIZE + 1) bytes in length, and will be filled in
+ * with the key prefix for server access logs for the given bucket,
+ * or the empty string if no such prefix is specified.
+ * @param aclGrantCountReturn returns the number of ACL grants that are
+ * associated with the server access logging for the given bucket.
+ * @param aclGrants must be passed in as an array of at least
+ * S3_MAX_ACL_GRANT_COUNT S3AclGrant structures, and these will be
+ * filled in with the target grants associated with the server access
+ * logging for the given bucket, whose number is returned in the
+ * aclGrantCountReturn parameter. These grants will be applied to the
+ * ACL of any server access logging log files generated by the S3
+ * service for the given bucket.
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_get_server_access_logging(const S3BucketContext *bucketContext,
+ char *targetBucketReturn,
+ char *targetPrefixReturn,
+ int *aclGrantCountReturn,
+ S3AclGrant *aclGrants,
+ S3RequestContext *requestContext,
+ const S3ResponseHandler *handler,
+ void *callbackData);
+
+
+/**
+ * Sets the service access logging settings for a bucket. The service access
+ * logging settings specify whether or not the S3 service will write service
+ * access logs for requests made for the given bucket, and if so, several
+ * settings controlling how these logs will be written.
+ *
+ * @param bucketContext gives the bucket and associated parameters for this
+ * request; this is the bucket for which service access logging is
+ * being set
+ * @param targetBucket gives the target bucket name for access logging for the
+ * given bucket, which is the bucket into which access logs for the
+ * specified bucket will be written.
+ * @param targetPrefix is an option parameter which specifies the key prefix
+ * for server access logs for the given bucket, or NULL if no such
+ * prefix is to be used.
+ * @param aclGrantCount specifies the number of ACL grants that are to be
+ * associated with the server access logging for the given bucket.
+ * @param aclGrants is as an array of S3AclGrant structures, whose number is
+ * given by the aclGrantCount parameter. These grants will be applied
+ * to the ACL of any server access logging log files generated by the
+ * S3 service for the given bucket.
+ * @param requestContext if non-NULL, gives the S3RequestContext to add this
+ * request to, and does not perform the request immediately. If NULL,
+ * performs the request immediately and synchronously.
+ * @param handler gives the callbacks to call as the request is processed and
+ * completed
+ * @param callbackData will be passed in as the callbackData parameter to
+ * all callbacks for this request
+ **/
+void S3_set_server_access_logging(const S3BucketContext *bucketContext,
+ const char *targetBucket,
+ const char *targetPrefix, int aclGrantCount,
+ const S3AclGrant *aclGrants,
+ S3RequestContext *requestContext,
+ const S3ResponseHandler *handler,
+ void *callbackData);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBS3_H */
projects / bluesky.git / commitdiff