Beispiel #1
0
static S3Status make_list_parts_callback(ListPartsData *lpData)
{
    int i;

    // Convert IsTruncated
    int isTruncated = (!strcmp(lpData->isTruncated, "true") ||
                       !strcmp(lpData->isTruncated, "1")) ? 1 : 0;

    // Convert the contents
    S3ListPart Parts[lpData->partsCount];
    int partsCount = lpData->partsCount;
    for (i = 0; i < partsCount; i++) {
        S3ListPart *partDest = &(Parts[i]);
        ListPart *partSrc = &(lpData->parts[i]);
        partDest->eTag = partSrc->eTag;
        partDest->partNumber = parseUnsignedInt(partSrc->partNumber);       
        partDest->size = parseUnsignedInt(partSrc->size);   
        partDest->lastModified = parseIso8601Time(partSrc->lastModified);
    }
    
    return (*(lpData->listPartsCallback))
        (isTruncated, lpData->nextPartNumberMarker, lpData->initiatorId,
         lpData->initiatorDisplayName, lpData->ownerId,
         lpData->ownerDisplayName, lpData->storageClass, partsCount,
         lpData->handlePartsStart, Parts, lpData->callbackData);
}
Beispiel #2
0
static S3Status make_list_bucket_callback(ListBucketData *lbData)
{
    int i;

    // Convert IsTruncated
    int isTruncated = (!strcmp(lbData->isTruncated, "true") ||
                       !strcmp(lbData->isTruncated, "1")) ? 1 : 0;

    // Convert the contents
#ifdef MSVC_NO_C99
	S3ListBucketContent *contents = (S3ListBucketContent *) malloc(sizeof(S3ListBucketContent) * lbData->contentsCount);
#else
	S3ListBucketContent contents[lbData->contentsCount];
#endif

    int contentsCount = lbData->contentsCount;
    for (i = 0; i < contentsCount; i++) {
        S3ListBucketContent *contentDest = &(contents[i]);
        ListBucketContents *contentSrc = &(lbData->contents[i]);
        contentDest->key = contentSrc->key;
        contentDest->lastModified = 
            parseIso8601Time(contentSrc->lastModified);
        contentDest->eTag = contentSrc->eTag;
        contentDest->size = parseUnsignedInt(contentSrc->size);
        contentDest->ownerId =
            contentSrc->ownerId[0] ?contentSrc->ownerId : 0;
        contentDest->ownerDisplayName = (contentSrc->ownerDisplayName[0] ?
                                         contentSrc->ownerDisplayName : 0);
    }

    // Make the common prefixes array
    int commonPrefixesCount = lbData->commonPrefixesCount;
#ifdef MSVC_NO_C99
	char **commonPrefixes = (char **)malloc(sizeof(char*) * commonPrefixesCount);
#else
	char *commonPrefixes[commonPrefixesCount];
#endif
    for (i = 0; i < commonPrefixesCount; i++) {
        commonPrefixes[i] = lbData->commonPrefixes[i];
    }

	S3Status result = (*(lbData->listBucketCallback))
        (isTruncated, lbData->nextMarker,
         contentsCount, contents, commonPrefixesCount, 
         (const char **) commonPrefixes, lbData->callbackData);

#ifdef MSVC_NO_C99
	free(contents);
	free(commonPrefixes);
#endif
	return result;
}
Beispiel #3
0
static S3Status xmlCallback(const char *elementPath, const char *data,
                            int dataLen, void *callbackData)
{
    XmlCallbackData *cbData = (XmlCallbackData *) callbackData;

    int fit;

    if (data) {
        if (!strcmp(elementPath, "ListAllMyBucketsResult/Owner/ID")) {
            string_buffer_append(cbData->ownerId, data, dataLen, fit);
        }
        else if (!strcmp(elementPath,
                         "ListAllMyBucketsResult/Owner/DisplayName")) {
            string_buffer_append(cbData->ownerDisplayName, data, dataLen, fit);
        }
        else if (!strcmp(elementPath,
                         "ListAllMyBucketsResult/Buckets/Bucket/Name")) {
            string_buffer_append(cbData->bucketName, data, dataLen, fit);
        }
        else if (!strcmp
                 (elementPath,
                  "ListAllMyBucketsResult/Buckets/Bucket/CreationDate")) {
            string_buffer_append(cbData->creationDate, data, dataLen, fit);
        }
    }
    else {
        if (!strcmp(elementPath, "ListAllMyBucketsResult/Buckets/Bucket")) {
            // Parse date.  Assume ISO-8601 date format.
            time_t creationDate = parseIso8601Time(cbData->creationDate);

            // Make the callback - a bucket just finished
            S3Status status = (*(cbData->listServiceCallback))
                (cbData->ownerId, cbData->ownerDisplayName,
                 cbData->bucketName, creationDate, cbData->callbackData);

            string_buffer_initialize(cbData->bucketName);
            string_buffer_initialize(cbData->creationDate);

            return status;
        }
    }

    /* Avoid compiler error about variable set but not used */
    (void) fit;

    return S3StatusOK;
}
Beispiel #4
0
static void copyObjectCompleteCallback(S3Status requestStatus,
                                       const S3ErrorDetails *s3ErrorDetails,
                                       void *callbackData)
{
    CopyObjectData *coData = (CopyObjectData *) callbackData;

    if (coData->lastModifiedReturn) {
        time_t lastModified = -1;
        if (coData->lastModifiedLen) {
            lastModified = parseIso8601Time(coData->lastModified);
        }

        *(coData->lastModifiedReturn) = lastModified;
    }

    (*(coData->responseCompleteCallback))
    (requestStatus, s3ErrorDetails, coData->callbackData);

    simplexml_deinitialize(&(coData->simpleXml));

    free(coData);
}
Beispiel #5
0
static S3Status make_list_multipart_callback(ListMultipartData *lmData)
{
    int i;

    // Convert IsTruncated
    int isTruncated = (!strcmp(lmData->isTruncated, "true") ||
                       !strcmp(lmData->isTruncated, "1")) ? 1 : 0;

    // Convert the contents
    S3ListMultipartUpload uploads[lmData->uploadsCount];

    int uploadsCount = lmData->uploadsCount;
    for (i = 0; i < uploadsCount; i++) {
        S3ListMultipartUpload *uploadDest = &(uploads[i]);
        ListMultipartUpload *uploadSrc = &(lmData->uploads[i]);
        uploadDest->key = uploadSrc->key;
        uploadDest->uploadId = uploadSrc->uploadId;
        uploadDest->initiatorId = uploadSrc->initiatorId;
        uploadDest->initiatorDisplayName = uploadSrc->initiatorDisplayName;
        uploadDest->ownerId =
            uploadSrc->ownerId[0] ?uploadSrc->ownerId : 0;
        uploadDest->ownerDisplayName = (uploadSrc->ownerDisplayName[0] ?
                                        uploadSrc->ownerDisplayName : 0);
        uploadDest->storageClass = uploadSrc->storageClass;
        uploadDest->initiated = parseIso8601Time(uploadSrc->initiated);
    }

    // Make the common prefixes array
    int commonPrefixesCount = lmData->commonPrefixesCount;
    char *commonPrefixes[commonPrefixesCount];
    for (i = 0; i < commonPrefixesCount; i++) {
        commonPrefixes[i] = lmData->commonPrefixes[i];
    }

    return (*(lmData->listMultipartCallback))
        (isTruncated, lmData->nextKeyMarker, lmData->nextUploadIdMarker,
         uploadsCount, uploads, commonPrefixesCount,
         (const char **) commonPrefixes, lmData->callbackData);
}
Beispiel #6
0
static S3Status make_list_bucket_callback(ListBucketData *lbData)
{
    int i;

    // Convert IsTruncated
    int isTruncated = (!strcmp(lbData->isTruncated, "true") ||
                       !strcmp(lbData->isTruncated, "1")) ? 1 : 0;

    // Convert the contents
    S3ListBucketContent contents[lbData->contentsCount];

    int contentsCount = lbData->contentsCount;
    for (i = 0; i < contentsCount; i++) {
        S3ListBucketContent *contentDest = &(contents[i]);
        ListBucketContents *contentSrc = &(lbData->contents[i]);
        contentDest->key = contentSrc->key;
        contentDest->lastModified = 
            parseIso8601Time(contentSrc->lastModified);
        contentDest->eTag = contentSrc->eTag;
        contentDest->size = parseUnsignedInt(contentSrc->size);
        contentDest->ownerId =
            contentSrc->ownerId[0] ?contentSrc->ownerId : 0;
        contentDest->ownerDisplayName = (contentSrc->ownerDisplayName[0] ?
                                         contentSrc->ownerDisplayName : 0);
    }

    // Make the common prefixes array
    int commonPrefixesCount = lbData->commonPrefixesCount;
    char *commonPrefixes[commonPrefixesCount];
    for (i = 0; i < commonPrefixesCount; i++) {
        commonPrefixes[i] = lbData->commonPrefixes[i];
    }

    return (*(lbData->listBucketCallback))
        (isTruncated, lbData->nextMarker,
         contentsCount, contents, commonPrefixesCount, 
         (const char **) commonPrefixes, lbData->callbackData);
}