Example #1
0
static STSStatus compute_signature(char* buffer, uint32_t bufferSize,
                            char* paramsArray[], const uint32_t paramsCount,
                            const char* accessKeySecret)
{
    
    //////////////////////////////////////////////////////////////////////////
    // sign
    uint32_t canonLen = 0;

    char canonicalizedQueryString[2048 * 3];
    compose_canonicalized_query_string(canonicalizedQueryString, 2048 * 3, &canonLen,
                                       paramsArray, paramsCount);
    
    string_buffer(strToSign, 2048 * 3);
    string_buffer_initialize(strToSign);
    int fit;
    string_buffer_append(strToSign, "POST&%2F&", 9, fit);
    if (!fit) {
        return STSStatusUriTooLong;
    }
    
    string_buffer(percentTwice, 2048 * 3);
    string_buffer_initialize(percentTwice);
    percentEncode(percentTwice, canonicalizedQueryString, canonLen);
    string_buffer_append(strToSign, percentTwice, strlen(percentTwice), fit);

    //fprintf(stdout, "strToSign(%lu): %s\n", strlen(strToSign), strToSign); 
    
    // Generate an HMAC-SHA-1 of the strToSign
    size_t akSecretLen = strlen(accessKeySecret);
    char newAccessKeySecret[akSecretLen + 1];
    snprintf(newAccessKeySecret, akSecretLen+2, "%s&", accessKeySecret);
    
    unsigned char hmac[20];
    STS_HMAC_SHA1(hmac, (unsigned char *) newAccessKeySecret, strlen(newAccessKeySecret),
              (unsigned char *) strToSign, strlen(strToSign));
    
    // Now base-64 encode the results
    char b64[((20 + 1) * 4) / 3];
    int b64Len = base64Encode(hmac, 20, b64);

    char b64Encoded[256];
    if (!urlEncode(b64Encoded, b64, b64Len)) {
        return STSStatusUriTooLong;
    }
    
    snprintf(buffer, strlen(b64Encoded)+1, "%s", b64Encoded);
    
    return STSStatusOK;
    
}
Example #2
0
static void direntry_get_path_inner (direntry_t *de, string_buffer_t *path)
{
    direntry_t *parent;


    if ((parent = direntry_get_parent(de)))
    {
        direntry_get_path_inner(parent, path);
        direntry_delete(CALLER_INFO parent);
    }

    string_buffer_append(path, direntry_get_name(de));
    string_buffer_append(path, strdup("/"));
}
char *
str_replace (const char *haystack, const char *needle, const char *replacement)
{
    assert (haystack != NULL);
    assert (needle != NULL);
    assert (replacement != NULL);

    string_buffer_t *sb = string_buffer_create ();
    size_t haystack_len = strlen (haystack);
    size_t needle_len = strlen (needle);

    int pos = 0;
    while (pos < haystack_len) {
        if (needle_len > 0 && str_starts_with (&haystack[pos], needle)) {
            string_buffer_append_string (sb, replacement);
            pos += needle_len;
        }
        else {
            string_buffer_append (sb, haystack[pos]);
            pos++;
        }
    }
    if (needle_len == 0 && haystack_len == 0)
        string_buffer_append_string (sb, replacement);

    char *res = string_buffer_to_string (sb);
    string_buffer_destroy (sb);
    return res;
}
Example #4
0
static S3Status copyObjectXmlCallback(const char *elementPath,
                                      const char *data, int dataLen,
                                      void *callbackData)
{
    CopyObjectData *coData = (CopyObjectData *) callbackData;

    int fit;

    if (data) {
        if (!strcmp(elementPath, "CopyObjectResult/LastModified")) {
            string_buffer_append(coData->lastModified, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "CopyObjectResult/ETag")) {
            if (coData->eTagReturnSize && coData->eTagReturn) {
                coData->eTagReturnLen +=
                    snprintf(&(coData->eTagReturn[coData->eTagReturnLen]),
                             coData->eTagReturnSize -
                             coData->eTagReturnLen - 1,
                             "%.*s", dataLen, data);
                if (coData->eTagReturnLen >= coData->eTagReturnSize) {
                    return S3StatusXmlParseFailure;
                }
            }
        }
    }

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

    return S3StatusOK;
}
Example #5
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;
}
Example #6
0
static S3Status commitMultipartResponseXMLcallback(const char *elementPath, 
                                                   const char *data, 
                                                   int dataLen, 
                                                   void *callbackData)
{
    int fit;
    CommitMultiPartData *commit_data = (CommitMultiPartData *) callbackData;
    if (data) {
        if (!strcmp(elementPath, "CompleteMultipartUploadResult/Location")) {
            string_buffer_append(commit_data->location, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "CompleteMultipartUploadResult/ETag")) {
            string_buffer_append(commit_data->etag, data, dataLen, fit);
        }
    }
    (void) fit;
    
    return S3StatusOK;
}
static S3Status getBlsDataCallback(int bufferSize, const char *buffer,
                                   void *callbackData)
{
    GetBlsData *gsData = (GetBlsData *) callbackData;

    int fit;

    string_buffer_append(gsData->blsXmlDocument, buffer, bufferSize, fit);
    
    return fit ? S3StatusOK : S3StatusXmlDocumentTooLarge;
}
static void receive_advert(
    const int socket,
    struct sockaddr *sa,
    const socklen_t socklen_in,
    void * const addr_src,
    const size_t host_len,
    new_indexnode_event_t packet_received_cb,
    void *packet_received_ctxt
)
{
    char host[host_len];
    char buf[1024];
    char *port, *fs2protocol, *id;
    string_buffer_t *buffer = string_buffer_new();
    int recv_rc;
    socklen_t socklen;


    /* For UDP it is specified that recv*() will return the whole packet in one
     * go. It is not correct to keep calling recv*() to get more of the message;
     * this isn't a stream. If the message is too big for the buffer it's simply
     * truncated. Usually silently, but by passing in MSG_TRUNC one gets the
     * real length of the message back, even if it has to be truncated. This
     * allows us to assert that our buffer is big enough. We've had to take a
     * guess because advert packets are variable length, but it's an assertion
     * because 1024 really should be enough */

    errno = 0;
    recv_rc = recvfrom(socket, buf, sizeof(buf) - 1, MSG_TRUNC, sa, &socklen);
    assert(recv_rc <= (int)sizeof(buf) - 1);

    if (recv_rc >= 0)
    {
        assert(socklen == socklen_in);
        buf[recv_rc] = '\0';
        string_buffer_append(buffer, strdup(buf));

        if (!parse_advert_packet(string_buffer_peek(buffer), &port, &fs2protocol, &id) &&
            inet_ntop(AF_INET, addr_src, host, sizeof(host) - 1))
        {
            packet_received_cb(packet_received_ctxt, strdup(host), port, fs2protocol, id);
        }
    }
    else
    {
        trace_warn("failed to recvfrom() and indexnode advert packet: %s\n", strerror(errno));
    }


    string_buffer_delete(buffer);
}
Example #9
0
static S3Status initialMultipartXmlCallback(const char *elementPath,
                                            const char *data,
                                            int dataLen,
                                            void *callbackData)
{
    InitialMultipartData *mdata = (InitialMultipartData *) callbackData;
    int fit;
    if (data) {
        if (!strcmp(elementPath, "InitiateMultipartUploadResult/UploadId")) {
            string_buffer_append(mdata->upload_id,data, dataLen, fit);
        }
    }

    (void) fit;
    return S3StatusOK;
}
Example #10
0
static S3Status testBucketXmlCallback(const char *elementPath,
                                      const char *data, int dataLen,
                                      void *callbackData)
{
    TestBucketData *tbData = (TestBucketData *) callbackData;

    int fit;

    if (data && !strcmp(elementPath, "LocationConstraint")) {
        string_buffer_append(tbData->locationConstraint, data, dataLen, fit);
    }

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

    return S3StatusOK;
}
Example #11
0
/*
 * get the next match from the current position,
 *		throught the dictionary.
 *	this will return all the matchs.
 *
 * @return friso_array_t that contains all the matchs.
 */
__STATIC_API__ friso_array_t get_next_match( friso_t friso, friso_task_t task, uint_t idx ) {

	register uint_t t;
	string_buffer_t sb = new_string_buffer_with_string( task->buffer );

	//create a match dynamic array.
	friso_array_t match = new_array_list_with_opacity( friso->max_len );
	array_list_add( match, friso_dic_get( friso->dic, __LEX_CJK_WORDS__, task->buffer ) );

	for ( t = 1; t < friso->max_len
			&& ( task->bytes = read_next_word( task, &idx, task->buffer ) ) != 0; t++ ) {

		task->unicode = get_utf8_unicode( task->buffer );
		if ( utf8_whitespace( task->unicode ) ) 	break;
		if ( ! utf8_cjk_string( task->unicode ) ) break;

		//append the task->buffer to the buffer.
		string_buffer_append( sb, task->buffer );

		//check the CJK dictionary.
		if ( friso_dic_match( friso->dic, __LEX_CJK_WORDS__, sb->buffer ) ) {
			/*
			 * add the lex_entry_t insite.
			 * here is a key point:
			 *		we use friso_dic_get function to get the address of the lex_entry_cdt
			 *		that store in the dictionary, not create a new lex_entry_cdt.
			 * so :
			 *		1.we will not bother to the allocations of the newly created lex_entry_cdt.
			 *		2.more efficient of course.
			 */
			array_list_add( match, friso_dic_get( friso->dic, __LEX_CJK_WORDS__, sb->buffer ) );
		}
	}

	/*buffer allocations clear*/
	free_string_buffer( sb );
	//array_list_trim( match );
	
	return match;
}
Example #12
0
//get the next cjk word from the current position, with simple mode.
__STATIC_API__ friso_hits_t next_simple_cjk( friso_t friso, friso_task_t task ) {

	uint_t t, idx = task->idx, __length__;
	string_buffer_t sb = new_string_buffer_with_string( task->buffer );
	lex_entry_t e = friso_dic_get( friso->dic, __LEX_CJK_WORDS__, sb->buffer );
	/*
	 * here bak the e->length in the task->hits->type.
	 *		we will use it to count the task->idx.
	 * for the sake of use less variable.
	 */
	__length__ = e->length;

	for ( t = 1; 
		t < friso->max_len 
		&& ( task->bytes = read_next_word( task, &idx, task->buffer ) ) != 0; t++ ) {
		
		task->unicode = get_utf8_unicode( task->buffer );

		if ( utf8_whitespace( task->unicode ) ) break;
		if ( ! utf8_cjk_string( task->unicode ) ) break;

		string_buffer_append( sb, task->buffer );

		//check the existence of the word by search the dictionary.
		if ( friso_dic_match( friso->dic, __LEX_CJK_WORDS__, sb->buffer ) ) {
			e = friso_dic_get( friso->dic, __LEX_CJK_WORDS__, sb->buffer );
		}
	}

	//correct the offset of the segment.
	task->idx += ( e->length - __length__ );
	free_string_buffer( sb );							//free the buffer

	//reset the hits.
	task->hits->word = e->word;
	task->hits->type = __FRISO_SYS_WORDS__;

	return task->hits;
}
zarray_t *
str_split (const char *str, const char *delim)
{
    assert (str != NULL);
    assert (delim != NULL);

    zarray_t *parts = zarray_create (sizeof(char*));
    string_buffer_t *sb = string_buffer_create ();

    size_t delim_len = strlen (delim);
    size_t len = strlen (str);
    size_t pos = 0;

    while (pos < len) {
        if (str_starts_with (&str[pos], delim) && delim_len > 0) {
            pos += delim_len;
            // never add empty strings (repeated tokens)
            if (string_buffer_size (sb) > 0) {
                char *part = string_buffer_to_string (sb);
                zarray_add (parts, &part);
            }
            string_buffer_reset (sb);
        }
        else {
            string_buffer_append (sb, str[pos]);
            pos++;
        }
    }

    if (string_buffer_size(sb) > 0) {
        char *part = string_buffer_to_string (sb);
        zarray_add (parts, &part);
    }

    string_buffer_destroy (sb);
    return parts;
}
Example #14
0
static S3Status convertAclXmlCallback(const char *elementPath,
                                      const char *data, int dataLen,
                                      void *callbackData)
{
    ConvertAclData *caData = (ConvertAclData *) callbackData;

    int fit;

    if (data) {
        if (!strcmp(elementPath, "AccessControlPolicy/Owner/ID")) {
            caData->ownerIdLen += 
                snprintf(&(caData->ownerId[caData->ownerIdLen]),
                         S3_MAX_GRANTEE_USER_ID_SIZE - caData->ownerIdLen - 1,
                         "%.*s", dataLen, data);
            if (caData->ownerIdLen >= S3_MAX_GRANTEE_USER_ID_SIZE) {
                return S3StatusUserIdTooLong;
            }
        }
        else if (!strcmp(elementPath, "AccessControlPolicy/Owner/"
                         "DisplayName")) {
            caData->ownerDisplayNameLen += 
                snprintf(&(caData->ownerDisplayName
                           [caData->ownerDisplayNameLen]),
                         S3_MAX_GRANTEE_DISPLAY_NAME_SIZE -
                         caData->ownerDisplayNameLen - 1, 
                         "%.*s", dataLen, data);
            if (caData->ownerDisplayNameLen >= 
                S3_MAX_GRANTEE_DISPLAY_NAME_SIZE) {
                return S3StatusUserDisplayNameTooLong;
            }
        }
        else if (!strcmp(elementPath, 
                    "AccessControlPolicy/AccessControlList/Grant/"
                    "Grantee/EmailAddress")) {
            // AmazonCustomerByEmail
            string_buffer_append(caData->emailAddress, data, dataLen, fit);
            if (!fit) {
                return S3StatusEmailAddressTooLong;
            }
        }
        else if (!strcmp(elementPath,
                         "AccessControlPolicy/AccessControlList/Grant/"
                         "Grantee/ID")) {
            // CanonicalUser
            string_buffer_append(caData->userId, data, dataLen, fit);
            if (!fit) {
                return S3StatusUserIdTooLong;
            }
        }
        else if (!strcmp(elementPath,
                         "AccessControlPolicy/AccessControlList/Grant/"
                         "Grantee/DisplayName")) {
            // CanonicalUser
            string_buffer_append(caData->userDisplayName, data, dataLen, fit);
            if (!fit) {
                return S3StatusUserDisplayNameTooLong;
            }
        }
        else if (!strcmp(elementPath,
                         "AccessControlPolicy/AccessControlList/Grant/"
                         "Grantee/URI")) {
            // Group
            string_buffer_append(caData->groupUri, data, dataLen, fit);
            if (!fit) {
                return S3StatusGroupUriTooLong;
            }
        }
        else if (!strcmp(elementPath,
                         "AccessControlPolicy/AccessControlList/Grant/"
                         "Permission")) {
            // Permission
            string_buffer_append(caData->permission, data, dataLen, fit);
            if (!fit) {
                return S3StatusPermissionTooLong;
            }
        }
    }
    else {
        if (!strcmp(elementPath, "AccessControlPolicy/AccessControlList/"
                    "Grant")) {
            // A grant has just been completed; so add the next S3AclGrant
            // based on the values read
            if (*(caData->aclGrantCountReturn) == S3_MAX_ACL_GRANT_COUNT) {
                return S3StatusTooManyGrants;
            }

            S3AclGrant *grant = &(caData->aclGrants
                                  [*(caData->aclGrantCountReturn)]);

            if (caData->emailAddress[0]) {
                grant->granteeType = S3GranteeTypeAmazonCustomerByEmail;
                strcpy(grant->grantee.amazonCustomerByEmail.emailAddress,
                       caData->emailAddress);
            }
            else if (caData->userId[0] && caData->userDisplayName[0]) {
                grant->granteeType = S3GranteeTypeCanonicalUser;
                strcpy(grant->grantee.canonicalUser.id, caData->userId);
                strcpy(grant->grantee.canonicalUser.displayName, 
                       caData->userDisplayName);
            }
            else if (caData->groupUri[0]) {
                if (!strcmp(caData->groupUri,
                            ACS_GROUP_AWS_USERS)) {
                    grant->granteeType = S3GranteeTypeAllAwsUsers;
                }
                else if (!strcmp(caData->groupUri,
                            ACS_GROUP_ALL_USERS)) {
                    grant->granteeType = S3GranteeTypeAllUsers;
                }
                else if (!strcmp(caData->groupUri,
                                 ACS_GROUP_LOG_DELIVERY)) {
                    grant->granteeType = S3GranteeTypeLogDelivery;
                }
                else {
                    return S3StatusBadGrantee;
                }
            }
            else {
                return S3StatusBadGrantee;
            }

            if (!strcmp(caData->permission, "READ")) {
                grant->permission = S3PermissionRead;
            }
            else if (!strcmp(caData->permission, "WRITE")) {
                grant->permission = S3PermissionWrite;
            }
            else if (!strcmp(caData->permission, "READ_ACP")) {
                grant->permission = S3PermissionReadACP;
            }
            else if (!strcmp(caData->permission, "WRITE_ACP")) {
                grant->permission = S3PermissionWriteACP;
            }
            else if (!strcmp(caData->permission, "FULL_CONTROL")) {
                grant->permission = S3PermissionFullControl;
            }
            else {
                return S3StatusBadPermission;
            }

            (*(caData->aclGrantCountReturn))++;

            string_buffer_initialize(caData->emailAddress);
            string_buffer_initialize(caData->userId);
            string_buffer_initialize(caData->userDisplayName);
            string_buffer_initialize(caData->groupUri);
            string_buffer_initialize(caData->permission);
        }
    }

    return S3StatusOK;
}
Example #15
0
//get the next latin word from the current position.
__STATIC_API__ friso_hits_t next_basic_latin( friso_t friso, friso_task_t task ) {

	char __convert = 0, t = 0;
	string_buffer_t sb, temp;
	lex_entry_t e = NULL;

	//full-half width and upper-lower case exchange.
	task->unicode = get_utf8_unicode( task->buffer );
	___LATAIN_FULL_UPPER_CHECK___

	//creat a new string buffer and append the task->buffer insite.
	sb = new_string_buffer_with_string( task->buffer );


	//segmentation.
	while ( ( task->bytes = read_next_word( task, &task->idx, task->buffer ) ) != 0 ) {

		task->unicode = get_utf8_unicode( task->buffer );

		if ( utf8_whitespace( task->unicode ) ) break;
		if ( utf8_en_punctuation( task->unicode ) && ! utf8_keep_punctuation( task->buffer ) ) break; 
		if ( ! ( utf8_halfwidth_letter_digit( task->unicode ) || utf8_fullwidth_letter_digit( task->unicode ) ) ) {
			task->idx -= task->bytes;
			t = 1;
			break;
		}

		//full-half width and upper-lower case convert
		___LATAIN_FULL_UPPER_CHECK___

		//append the word the buffer.
		string_buffer_append( sb, task->buffer );
	}

	/*clear the useless english punctuation from
		the end of the buffer.*/
	for ( ; sb->length > 0 
			&& sb->buffer[ sb->length - 1 ] != '%' 
			&& is_en_punctuation( sb->buffer[ sb->length - 1 ] ); ) {
		sb->buffer[ --sb->length ] = '\0';
	}

	/*
	 * find the chinese or english mixed word.
	 * 		or single chinese units.*/
	if ( t == 1 ) {
		if ( utf8_cjk_string( task->unicode ) ) {
			//temp string buffer.
			temp = new_string_buffer_with_string( sb->buffer );

			for ( t = 0; 
				t < friso->mix_len 
				&& ( task->bytes = read_next_word( task , &task->idx, task->buffer ) ) != 0; t++ ) {
				
				task->unicode = get_utf8_unicode( task->buffer );

				if ( ! utf8_cjk_string( task->unicode ) ) {
					task->idx -= task->bytes;
					break;
				}

				string_buffer_append( temp, task->buffer );

				//check the mixed word dictionary.
				if ( friso_dic_match( friso->dic, __LEX_MIX_WORDS__, temp->buffer ) ) {
					__convert = 1;
					//get the lexicon entry from the dictionary.
					e = friso_dic_get( friso->dic, __LEX_MIX_WORDS__, temp->buffer );
				}
			}

			//correct the segmentation offset.
			task->idx -= ( temp->length - ( e == NULL ? sb->length : e->length ) );
			free_string_buffer( temp );

			//no match for mix word, try to find a single chinese unit.
			if ( __convert == 0 ) {
				//check if it is string made up with numeric
				if ( utf8_numeric_string( sb->buffer ) 
						&& ( task->bytes = read_next_word( task, &task->idx, task->buffer ) ) != 0 ) {

					//check the single chinese units dictionary.
					if ( friso_dic_match( friso->dic, __LEX_CJK_UNITS__, task->buffer ) ) {
						string_buffer_append( sb, task->buffer );
					} else {
						task->idx -= task->bytes;
					}
				}
			}	//end convert condition

		}
	}


	if ( __convert == 1 ) {
		free_string_buffer( sb );
		task->hits->word = e->word;
		task->hits->type = __FRISO_SYS_WORDS__;
	} else {
		/*
		 * adjust the string buffer.
		 *		here we do not trim the buffer cause its allocations will be free
		 *	after the call of friso_next - sooner or later it will be released.
		 *	if your memory almost run out, you should call string_buffer_trim.
		 *	or we save the time to do the allocations and copy the buffer insite.
		 */
		//string_buffer_trim( sb );
		task->hits->word = string_buffer_devote( sb );
		task->hits->type = __FRISO_NEW_WORDS__;
	}

	return task->hits;
}
Example #16
0
static S3Status listBucketXmlCallback(const char *elementPath,
                                      const char *data, int dataLen,
                                      void *callbackData)
{
    ListBucketData *lbData = (ListBucketData *) callbackData;

    int fit;

    if (data) {
        if (!strcmp(elementPath, "ListBucketResult/IsTruncated")) {
            string_buffer_append(lbData->isTruncated, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListBucketResult/NextMarker")) {
            string_buffer_append(lbData->nextMarker, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListBucketResult/Contents/Key")) {
            ListBucketContents *contents = 
                &(lbData->contents[lbData->contentsCount]);
            string_buffer_append(contents->key, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, 
                         "ListBucketResult/Contents/LastModified")) {
            ListBucketContents *contents = 
                &(lbData->contents[lbData->contentsCount]);
            string_buffer_append(contents->lastModified, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListBucketResult/Contents/ETag")) {
            ListBucketContents *contents = 
                &(lbData->contents[lbData->contentsCount]);
            string_buffer_append(contents->eTag, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListBucketResult/Contents/Size")) {
            ListBucketContents *contents = 
                &(lbData->contents[lbData->contentsCount]);
            string_buffer_append(contents->size, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListBucketResult/Contents/Owner/ID")) {
            ListBucketContents *contents = 
                &(lbData->contents[lbData->contentsCount]);
            string_buffer_append(contents->ownerId, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, 
                         "ListBucketResult/Contents/Owner/DisplayName")) {
            ListBucketContents *contents = 
                &(lbData->contents[lbData->contentsCount]);
            string_buffer_append
                (contents->ownerDisplayName, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, 
                         "ListBucketResult/CommonPrefixes/Prefix")) {
            int which = lbData->commonPrefixesCount;
            lbData->commonPrefixLens[which] +=
                snprintf(lbData->commonPrefixes[which],
                         sizeof(lbData->commonPrefixes[which]) -
                         lbData->commonPrefixLens[which] - 1,
                         "%.*s", dataLen, data);
            if (lbData->commonPrefixLens[which] >=
                (int) sizeof(lbData->commonPrefixes[which])) {
                return S3StatusXmlParseFailure;
            }
        }
    }
    else {
        if (!strcmp(elementPath, "ListBucketResult/Contents")) {
            // Finished a Contents
            lbData->contentsCount++;
            if (lbData->contentsCount == MAX_CONTENTS) {
                // Make the callback
                S3Status status = make_list_bucket_callback(lbData);
                if (status != S3StatusOK) {
                    return status;
                }
                initialize_list_bucket_data(lbData);
            }
            else {
                // Initialize the next one
                initialize_list_bucket_contents
                    (&(lbData->contents[lbData->contentsCount]));
            }
        }
        else if (!strcmp(elementPath,
                         "ListBucketResult/CommonPrefixes/Prefix")) {
            // Finished a Prefix
            lbData->commonPrefixesCount++;
            if (lbData->commonPrefixesCount == MAX_COMMON_PREFIXES) {
                // Make the callback
                S3Status status = make_list_bucket_callback(lbData);
                if (status != S3StatusOK) {
                    return status;
                }
                initialize_list_bucket_data(lbData);
            }
            else {
                // Initialize the next one
                lbData->commonPrefixes[lbData->commonPrefixesCount][0] = 0;
                lbData->commonPrefixLens[lbData->commonPrefixesCount] = 0;
            }
        }
    }

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

    return S3StatusOK;
}
Example #17
0
/*
 * load the lexicon configuration file.
 *        and load all the valid lexicon from the configuration file.
 *
 * @param friso        friso instance
 * @param    config    friso_config instance
 * @param _path        dictionary directory
 * @param _limitts    words length limit    
 */
FRISO_API void friso_dic_load_from_ifile( 
        friso_t friso, 
        friso_config_t config,
        fstring _path,
        uint_t _limits  ) 
{

    //1.parse the configuration file.
    FILE *__stream;
    char __chars__[1024], __key__[30], *__line__;
    uint_t __length__, i, t;
    friso_lex_t lex_t;
    string_buffer_t sb;

    //get the lexicon configruation file path
    sb = new_string_buffer();
    string_buffer_append( sb, _path );
    string_buffer_append( sb, __FRISO_LEX_IFILE__ );
    //printf("%s\n", sb->buffer);

    if ( ( __stream = fopen( sb->buffer, "rb" ) ) != NULL ) 
    {
        while ( ( __line__ = 
                    file_get_line( __chars__, __stream ) ) != NULL ) 
        {
            //comment filter.
            if ( __line__[0] == '#' ) continue;
            if ( __line__[0] == '\0' ) continue;

            __length__ = strlen( __line__ );
            //item start
            if ( __line__[ __length__ - 1 ] == '[' ) 
            {
                //get the type key
                for ( i = 0; i < __length__
                        && ( __line__[i] == ' ' || __line__[i] == '\t' ); i++ ); 
                for ( t = 0; i < __length__; i++,t++ ) {
                    if ( __line__[i] == ' ' 
                            || __line__[i] == '\t' || __line__[i] == ':' ) break;
                    __key__[t] = __line__[i];
                }
                __key__[t] = '\0';

                //get the lexicon type
                lex_t = get_lexicon_type_with_constant(__key__);
                if ( lex_t == -1 ) continue; 

                //printf("key=%s, type=%d\n", __key__, lex_t );
                while ( ( __line__ = file_get_line( __chars__, __stream ) ) != NULL ) 
                {
                    //comments filter.
                    if ( __line__[0] == '#' ) continue;
                    if ( __line__[0] == '\0' ) continue; 

                    __length__ = strlen( __line__ );
                    if ( __line__[ __length__ - 1 ] == ']' ) break;

                    for ( i = 0; i < __length__ 
                            && ( __line__[i] == ' ' || __line__[i] == '\t' ); i++ );
                    for ( t = 0; i < __length__; i++,t++ ) {
                        if ( __line__[i] == ' ' 
                                || __line__[i] == '\t' || __line__[i] == ';' ) break;
                        __key__[t] = __line__[i]; 
                    }
                    __key__[t] = '\0';

                    //load the lexicon item from the lexicon file.
                    string_buffer_clear( sb );
                    string_buffer_append( sb, _path );
                    string_buffer_append( sb, __key__ );
                    //printf("key=%s, type=%d\n", __key__, lex_t);
                    friso_dic_load( friso, config, lex_t, sb->buffer, _limits );
                }

            } 

        } //end while

        fclose( __stream );
    } else {
        printf("Warning: Fail to open the lexicon configuration file %s\n", sb->buffer);
    }

    free_string_buffer(sb);    
}
Example #18
0
static S3Status listPartsXmlCallback(const char *elementPath,
                                      const char *data, int dataLen,
                                      void *callbackData)
{
    ListPartsData *lpData = (ListPartsData *) callbackData;
    int fit;
    if (data) {
        if (!strcmp(elementPath, "ListPartsResult/IsTruncated")) {
            string_buffer_append(lpData->isTruncated, data, dataLen, fit);
        }
        else if (!strcmp(elementPath,
                         "ListPartsResult/NextPartNumberMarker")) {
            string_buffer_append(lpData->nextPartNumberMarker, data, dataLen,
                                 fit);
        }
        else if (!strcmp(elementPath, "ListPartsResult/StorageClass")) {
            string_buffer_append(lpData->storageClass, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListPartsResult/Initiator/ID")) {
            string_buffer_append(lpData->initiatorId, data, dataLen, fit);
        }
        else if (!strcmp(elementPath,
                         "ListPartsResult/Initiator/DisplayName")) {
            string_buffer_append(lpData->initiatorDisplayName, data, dataLen,
                                 fit);
        }
        else if (!strcmp(elementPath, "ListPartsResult/Owner/ID")) {
            string_buffer_append(lpData->ownerId, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListPartsResult/Owner/DisplayName")) {
            string_buffer_append(lpData->ownerDisplayName, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListPartsResult/Part/PartNumber")) {
            ListPart *parts = &(lpData->parts[lpData->partsCount]);
            string_buffer_append(parts->partNumber, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListPartsResult/Part/LastModified")) {
            ListPart *parts = &(lpData->parts[lpData->partsCount]);
            string_buffer_append(parts->lastModified, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListPartsResult/Part/ETag")) {
            ListPart *parts = &(lpData->parts[lpData->partsCount]);
            string_buffer_append(parts->eTag, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, "ListPartsResult/Part/Size")) {
            ListPart *parts = &(lpData->parts[lpData->partsCount]);
            string_buffer_append(parts->size, data, dataLen, fit);
        }       
    }
    else {
        if (!strcmp(elementPath, "ListPartsResult/Part")) {
            // Finished a Contents
            lpData->partsCount++;
            if (lpData->partsCount == MAX_PARTS) {
                // Make the callback
                S3Status status = make_list_parts_callback(lpData);
                if (status != S3StatusOK) {
                    return status;
                }
                lpData->handlePartsStart += lpData->partsCount;
                initialize_list_parts_data(lpData);
            }
            else {
                // Initialize the next one
                initialize_list_part(&(lpData->parts[lpData->partsCount]));
            }
        }       
    }

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

    return S3StatusOK;
}
Example #19
0
static S3Status listMultipartXmlCallback(const char *elementPath,
                                         const char *data, int dataLen,
                                         void *callbackData)
{
    ListMultipartData *lmData = (ListMultipartData *) callbackData;

    int fit;

    if (data) {
        if (!strcmp(elementPath, "ListMultipartUploadsResult/IsTruncated")) {
            string_buffer_append(lmData->isTruncated, data, dataLen, fit);
        }
        else if (!strcmp(elementPath,
                         "ListMultipartUploadsResult/NextKeyMarker")) {
            string_buffer_append(lmData->nextKeyMarker, data, dataLen, fit);
        }
        else if (!strcmp(elementPath,
                         "ListMultipartUploadsResult/NextUploadIdMarker")) {
            string_buffer_append(lmData->nextUploadIdMarker, data, dataLen,
                                 fit);
        }
        else if (!strcmp(elementPath,
                         "ListMultipartUploadsResult/Upload/Key")) {
            ListMultipartUpload *uploads = 
                &(lmData->uploads[lmData->uploadsCount]);
            string_buffer_append(uploads->key, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, 
                         "ListMultipartUploadsResult/Upload/Initiated")) {
            ListMultipartUpload *uploads = 
                &(lmData->uploads[lmData->uploadsCount]);
            string_buffer_append(uploads->initiated, data, dataLen, fit);
        }
        else if (!strcmp(elementPath,
                         "ListMultipartUploadsResult/Upload/UploadId")) {
            ListMultipartUpload *uploads = 
                &(lmData->uploads[lmData->uploadsCount]);
            string_buffer_append(uploads->uploadId, data, dataLen, fit);
        }
        else if (!strcmp(elementPath,
                         "ListMultipartUploadsResult/Upload/Initiator/ID")) {
            ListMultipartUpload *uploads = 
                &(lmData->uploads[lmData->uploadsCount]);
            string_buffer_append(uploads->initiatorId, data, dataLen, fit);
        }
        else if (!strcmp
                 (elementPath,
                  "ListMultipartUploadsResult/Upload/Initiator/DisplayName")) {
            ListMultipartUpload *uploads = 
                &(lmData->uploads[lmData->uploadsCount]);
            string_buffer_append(uploads->initiatorDisplayName, data, dataLen,
                                 fit);
        }
        else if (!strcmp(elementPath,
                         "ListMultipartUploadsResult/Upload/Owner/ID")) {
            ListMultipartUpload *uploads = 
                &(lmData->uploads[lmData->uploadsCount]);
            string_buffer_append(uploads->ownerId, data, dataLen, fit);
        }
        else if (!strcmp
                 (elementPath, 
                  "ListMultipartUploadsResult/Upload/Owner/DisplayName")) {
            ListMultipartUpload *uploads = 
                &(lmData->uploads[lmData->uploadsCount]);
            string_buffer_append
                (uploads->ownerDisplayName, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, 
                         "ListMultipartUploadsResult/Upload/StorageClass")) {
            ListMultipartUpload *uploads = 
                &(lmData->uploads[lmData->uploadsCount]);
            string_buffer_append(uploads->storageClass, data, dataLen, fit);
        }
        else if (!strcmp(elementPath, 
                         "ListMultipartUploadsResult/CommonPrefixes/Prefix")) {
            int which = lmData->commonPrefixesCount;
            lmData->commonPrefixLens[which] +=
                snprintf(lmData->commonPrefixes[which],
                         sizeof(lmData->commonPrefixes[which]) -
                         lmData->commonPrefixLens[which] - 1,
                         "%.*s", dataLen, data);
            if (lmData->commonPrefixLens[which] >=
                (int) sizeof(lmData->commonPrefixes[which])) {
                return S3StatusXmlParseFailure;
            }
        }
    }
    else {
        if (!strcmp(elementPath, "ListMultipartUploadsResult/Upload")) {
            // Finished a Contents
            lmData->uploadsCount++;
            if (lmData->uploadsCount == MAX_UPLOADS) {
                // Make the callback
                S3Status status = make_list_multipart_callback(lmData);
                if (status != S3StatusOK) {
                    return status;
                }
                initialize_list_multipart_data(lmData);
            }
            else {
                // Initialize the next one
                initialize_list_multipart_upload
                    (&(lmData->uploads[lmData->uploadsCount]));
            }
        }
        else if (!strcmp(elementPath,
                         "ListMultipartUploadsResult/CommonPrefixes/Prefix")) {
            // Finished a Prefix
            lmData->commonPrefixesCount++;
            if (lmData->commonPrefixesCount == MAX_COMMON_PREFIXES) {
                // Make the callback
                S3Status status = make_list_multipart_callback(lmData);
                if (status != S3StatusOK) {
                    return status;
                }
                initialize_list_multipart_data(lmData);
            }
            else {
                // Initialize the next one
                lmData->commonPrefixes[lmData->commonPrefixesCount][0] = 0;
                lmData->commonPrefixLens[lmData->commonPrefixesCount] = 0;
            }
        }
    }

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

    return S3StatusOK;
}