int __s3fs_remove_object(const char *bucketName, const char *key) {
S3_init();
S3BucketContext bucketContext =
{
0,
bucketName,
protocolG,
uriStyleG,
accessKeyIdG,
secretAccessKeyG
};
S3ResponseHandler responseHandler =
{
0,
&responseCompleteCallback
};
do {
S3_delete_object(&bucketContext, key, 0, &responseHandler, 0);
} while (S3_status_is_retryable(statusG) && should_retry());
int result = statusG == S3StatusOK ? 0 : -1;
if ((statusG != S3StatusOK) &&
(statusG != S3StatusErrorPreconditionFailed)) {
printError();
}
S3_deinitialize();
return result;
}
ssize_t __s3fs_get_object(const char *bucketName, const char *key, uint8_t **buf,
ssize_t start_byte, ssize_t byte_count) {
int64_t ifModifiedSince = -1, ifNotModifiedSince = -1;
const char *ifMatch = 0, *ifNotMatch = 0;
uint64_t startByte = start_byte, byteCount = byte_count;
S3_init();
struct get_callback_data get_context;
get_context.buf = NULL;
get_context.bytes_read = 0;
S3BucketContext bucketContext =
{
0,
bucketName,
protocolG,
uriStyleG,
accessKeyIdG,
secretAccessKeyG
};
S3GetConditions getConditions =
{
ifModifiedSince,
ifNotModifiedSince,
ifMatch,
ifNotMatch
};
S3GetObjectHandler getObjectHandler =
{
{ &responsePropertiesCallback, &responseCompleteCallback },
&getObjectDataCallback
};
do {
S3_get_object(&bucketContext, key, &getConditions, startByte,
byteCount, 0, &getObjectHandler, &get_context);
} while (S3_status_is_retryable(statusG) && should_retry());
ssize_t status = get_context.bytes_read;
if (statusG != S3StatusOK) {
status = -1;
if (get_context.buf) {
free (get_context.buf);
}
printError();
} else {
*buf = get_context.buf;
}
S3_deinitialize();
return status;
}
int main(int argc, char** argv)
{
if (2 > argc){
usage();
return 1;
}
char *slash = argv[1];
while (*slash && (*slash != '/')) {
slash++;
}
*slash++ = 0;
const char *bucketName = argv[1];
const char *key = slash;
S3Protocol protocolG = S3ProtocolHTTP;
const char* accessKeyIdG = getenv("S3_ACCESS_KEY_ID");
const char* secretAccessKeyG = getenv("S3_SECRET_ACCESS_KEY");
S3Status status;
const char* hostname = getenv("S3_HOSTNAME");
if ((status = S3_initialize("s3", S3_INIT_ALL, hostname)) != S3StatusOK)
{
fprintf(stdout, "Failed to initialize libs3: %s\n", S3_get_status_name(status));
exit(-1);
}
S3BucketContext bucketContext =
{
0,
bucketName,
protocolG,
S3UriStylePath,
accessKeyIdG,
secretAccessKeyG,
0
};
S3ResponseHandler responseHandler =
{
0,
&responseCompleteCallback
};
//----------------------create bucket-----------------//
S3_delete_object(&bucketContext, key, 0, &responseHandler, 0);
S3_deinitialize();
return 0;
}
static int ct_s3_cleanup(void)
{
int rc = 0;
rc = ct_cleanup();
if (rc == 0) {
S3_deinitialize();
}
return rc;
}
void list_bucket(const char *bucketName, const char *prefix,
const char *marker, const char *delimiter,
int maxkeys, const char* ak, const char* sk)
{
S3_init();
savedCommonPrefixes.clear();
savedContents.clear();
savedKeys.clear();
S3BucketContext bucketContext =
{
0,
bucketName,
S3ProtocolHTTPS,
S3UriStyleVirtualHost,
ak,
sk
};
S3ListBucketHandler listBucketHandler =
{
{ &responsePropertiesCallback, &responseCompleteCallback },
&listBucketCallback
};
list_bucket_callback_data data;
snprintf(data.nextMarker, sizeof(data.nextMarker), "%s", marker);
data.keyCount = 0;
data.allDetails = 0;
do {
data.isTruncated = 0;
do {
S3_list_bucket(&bucketContext, prefix, data.nextMarker,
delimiter, maxkeys, 0, &listBucketHandler, &data);
} while (S3_status_is_retryable((S3Status)statusG) && should_retry());
if (statusG != S3StatusOK) {
break;
}
} while (data.isTruncated && (!maxkeys || (data.keyCount < maxkeys)));
if (statusG == S3StatusOK) {
// if (!data.keyCount) {
// printListBucketHeader(allDetails);
// }
}
else {
printError();
}
S3_deinitialize();
}
int main(int argc, char** args)
{
if (3 > argc){
usage();
return 1;
}
const char* bucketName = args[1];
const char* key = args[2];
S3Protocol protocolG = S3ProtocolHTTP;
const char* accessKeyIdG = getenv("S3_ACCESS_KEY_ID");
const char* secretAccessKeyG = getenv("S3_SECRET_ACCESS_KEY");
S3Status status;
const char* hostname = getenv("S3_HOSTNAME");
if ((status = S3_initialize("s3", S3_INIT_ALL, hostname)) != S3StatusOK)
{
fprintf(stdout, "Failed to initialize libs3: %s\n", S3_get_status_name(status));
exit(-1);
}
S3BucketContext bucketContext =
{
0,
bucketName,
protocolG,
S3UriStylePath,
accessKeyIdG,
secretAccessKeyG,
0
};
S3ResponseHandler responseHandler = { &responsePropertiesCallback,
&responseCompleteCallback
};
//----------------------check whether object is exist-----------------//
S3_head_object(&bucketContext, key, 0, &responseHandler, 0);
S3_deinitialize();
return 0;
}
int __s3fs_test_bucket(const char *bucketName)
{
S3_init();
S3ResponseHandler responseHandler =
{
&responsePropertiesCallback, &responseCompleteCallback
};
char locationConstraint[64];
do {
S3_test_bucket(protocolG, uriStyleG, accessKeyIdG, secretAccessKeyG,
0, bucketName, sizeof(locationConstraint),
locationConstraint, 0, &responseHandler, 0);
} while (S3_status_is_retryable(statusG) && should_retry());
const char *reason = "Unknown";
int result = statusG == S3StatusOK ? 1 : 0;
switch (statusG) {
case S3StatusOK:
// bucket exists
reason = locationConstraint[0] ? locationConstraint : "USA";
break;
case S3StatusErrorNoSuchBucket:
reason = "Does Not Exist";
break;
case S3StatusErrorAccessDenied:
reason = "Access Denied";
break;
default:
break;
}
fprintf(stderr, "S3 test_bucket: %s\n", reason);
S3_deinitialize();
return result;
}
static int bucket_exists(char *bname){
s3_init();
if (! load_settings()){
printf("Configure your ~/.webdir-settings file!\n");
exit(1);
}
char skey[STR];
get_secret_key(skey);
char akey[STR];
get_access_key(akey);
char hostname[STR];
get_host(hostname);
S3ResponseHandler res_handler = {
&res_properties, &res_complete/* Can properties be null?*/
};
char loc_constraint[STR];
do {
S3_test_bucket(S3ProtocolHTTPS,
S3UriStylePath,
akey,
skey,
hostname,
bname,
sizeof(loc_constraint),
loc_constraint,
0,
&res_handler,
0);
} while (S3_status_is_retryable(RequestStatus) && should_retry());
S3_deinitialize();
return RequestStatus == S3StatusOK; // Bucket exists
}
ssize_t __s3fs_put_object(const char *bucketName, const char *key, const uint8_t *buf, ssize_t contentLength)
{
const char *cacheControl = 0, *contentType = 0, *md5 = 0;
const char *contentDispositionFilename = 0, *contentEncoding = 0;
int64_t expires = -1;
S3CannedAcl cannedAcl = S3CannedAclPrivate;
int metaPropertiesCount = 0;
S3NameValue metaProperties[S3_MAX_METADATA_COUNT];
int noStatus = 0;
put_object_callback_data data;
memset(&data, 0, sizeof(put_object_callback_data));
data.data = buf;
// data.gb = 0;
data.noStatus = noStatus;
data.contentLength = data.originalContentLength = contentLength;
S3_init();
S3BucketContext bucketContext =
{
0,
bucketName,
protocolG,
uriStyleG,
accessKeyIdG,
secretAccessKeyG
};
S3PutProperties putProperties =
{
contentType,
md5,
cacheControl,
contentDispositionFilename,
contentEncoding,
expires,
cannedAcl,
metaPropertiesCount,
metaProperties
};
S3PutObjectHandler putObjectHandler =
{
{ &responsePropertiesCallback, &responseCompleteCallback },
&putObjectDataCallback
};
do {
S3_put_object(&bucketContext, key, contentLength, &putProperties, 0,
&putObjectHandler, &data);
} while (S3_status_is_retryable(statusG) && should_retry());
int result = data.written;
if (statusG != S3StatusOK) {
printError();
result = -1;
}
else if (data.contentLength) {
fprintf(stderr, "\nERROR: Failed to read remaining %llu bytes from "
"input\n", (unsigned long long) data.contentLength);
}
S3_deinitialize();
return result;
}
int __s3fs_clear_bucket(const char *bucketName) {
S3_init();
const char *prefix = 0, *marker = 0, *delimiter = 0;
int maxkeys = 0, allDetails = 0;
S3BucketContext bucketContext =
{
0,
bucketName,
protocolG,
uriStyleG,
accessKeyIdG,
secretAccessKeyG
};
S3ListBucketHandler listBucketHandler =
{
{ &responsePropertiesCallback, &responseCompleteCallback },
&traverseBucketCallback
};
traverse_bucket_callback_data data;
snprintf(data.nextMarker, sizeof(data.nextMarker), "%s", marker);
data.keyCount = 0;
data.keylist = NULL;
data.allDetails = allDetails;
do {
data.isTruncated = 0;
do {
S3_list_bucket(&bucketContext, prefix, data.nextMarker,
delimiter, maxkeys, 0, &listBucketHandler, &data);
} while (S3_status_is_retryable(statusG) && should_retry());
if (statusG != S3StatusOK) {
break;
}
} while (data.isTruncated && (!maxkeys || (data.keyCount < maxkeys)));
int rv = statusG == S3StatusOK ? 0 : -1;
S3_deinitialize();
struct node *klist = data.keylist;
// try to remove objects
if (rv == 0) {
while (klist) {
struct node *el = klist;
int thisrv = __s3fs_remove_object(bucketName, el->key);
if (thisrv < 0) {
rv = -1;
}
klist = klist->next;
}
}
// free keylist
klist = data.keylist;
while (klist) {
struct node *el = klist;
klist = klist->next;
free(el->key);
free(el);
}
return rv;
}
int putFileIntoS3(char *fileName, char *s3ObjName)
{
S3Status status;
char *key;
struct stat statBuf;
uint64_t fileSize;
FILE *fd;
char *accessKeyId;
char *secretAccessKey;
put_object_callback_data data;
accessKeyId = getenv("S3_ACCESS_KEY_ID");
if (accessKeyId == NULL) {
printf("S3_ACCESS_KEY_ID environment variable is undefined");
return(-1);
}
secretAccessKey = getenv("S3_SECRET_ACCESS_KEY");
if (secretAccessKey == NULL) {
printf("S3_SECRET_ACCESS_KEY environment variable is undefined");
return(-1);
}
key = (char *) strchr(s3ObjName, '/');
if (key == NULL) {
printf("S3 Key for the Object Not defined\n");
return(-1);
}
*key = '\0';
key++;
if (stat(fileName, &statBuf) == -1) {
printf("Unknown input file");
return(-1);
}
fileSize = statBuf.st_size;
fd = fopen(fileName, "r" );
if (fd == NULL) {
printf("Unable to open input file");
return(-1);
}
data.infile = fd;
S3BucketContext bucketContext =
{s3ObjName, 1, 0, accessKeyId, secretAccessKey};
S3PutObjectHandler putObjectHandler =
{
{ &responsePropertiesCallback, &responseCompleteCallback },
&putObjectDataCallback
};
if ((status = S3_initialize("s3", S3_INIT_ALL))
!= S3StatusOK) {
printf("Failed to initialize libs3: %s\n",S3_get_status_name(status));
return(-1);
}
S3_put_object(&bucketContext, key, fileSize, NULL, 0,
&putObjectHandler, &data);
if (statusG != S3StatusOK) {
printf("Put failed: %i\n", statusG);
S3_deinitialize();
return(-1);
}
S3_deinitialize();
fclose(fd);
return(0);
}
void cloud_destroy() {
S3_deinitialize();
}
int main(int argc, char** argv)
{
if (3 > argc){
usage();
return 1;
}
char *slash = argv[1];
while (*slash && (*slash != '/')) {
slash++;
}
if (!*slash || !*(slash + 1)) {
fprintf(stderr, "\nERROR: Invalid bucket/key name: %s\n",
argv[1]);
usage();
exit(-1);
}
*slash++ = 0;
const char* bucketName = argv[1];
const char *key = slash;
const char *uploadId = 0;
const char *filename = argv[2];
uint64_t contentLength = 0;
const char *cacheControl = 0, *contentType = 0, *md5 = 0;
const char *contentDispositionFilename = 0, *contentEncoding = 0;
int64_t expires = -1;
S3CannedAcl cannedAcl = S3CannedAclPrivate;
int metaPropertiesCount = 0;
S3NameValue metaProperties[S3_MAX_METADATA_COUNT];
char useServerSideEncryption = 0;
int noStatus = 0;
put_object_callback_data data;
data.infile = 0;
data.gb = 0;
data.noStatus = noStatus;
if (filename) {
if (!contentLength) {
struct stat statbuf;
// Stat the file to get its length
if (stat(filename, &statbuf) == -1) {
fprintf(stderr, "\nERROR: Failed to stat file %s: ",
filename);
perror(0);
exit(-1);
}
contentLength = statbuf.st_size;
}
// Open the file
if (!(data.infile = fopen(filename, "r" FOPEN_EXTRA_FLAGS))) {
fprintf(stderr, "\nERROR: Failed to open input file %s: ",
filename);
perror(0);
exit(-1);
}
}
else{
usage();
}
data.contentLength = data.originalContentLength = contentLength;
S3Protocol protocolG = S3ProtocolHTTP;
const char* accessKeyIdG = getenv("S3_ACCESS_KEY_ID");
const char* secretAccessKeyG = getenv("S3_SECRET_ACCESS_KEY");
S3Status status;
const char* hostname = getenv("S3_HOSTNAME");
if ((status = S3_initialize("s3", S3_INIT_ALL, hostname)) != S3StatusOK)
{
fprintf(stdout, "Failed to initialize libs3: %s\n", S3_get_status_name(status));
exit(-1);
}
S3BucketContext bucketContext =
{
0,
bucketName,
protocolG,
S3UriStylePath,
accessKeyIdG,
secretAccessKeyG,
0
};
S3PutProperties putProperties =
{
contentType,
md5,
cacheControl,
contentDispositionFilename,
contentEncoding,
expires,
cannedAcl,
metaPropertiesCount,
metaProperties,
useServerSideEncryption
};
S3PutObjectHandler putObjectHandler =
{
{ &responsePropertiesCallback, &responseCompleteCallback },
&putObjectDataCallback
};
//----------------------create bucket-----------------//
S3_put_object(&bucketContext, key, contentLength, &putProperties, 0,
&putObjectHandler, &data);
S3_deinitialize();
return 0;
}
