util/src/properties.c - axis-axis2-c-core - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <axutil_properties.h>
 #include <axutil_string.h>
 #include <axutil_utils.h>


 #define MAX_SIZE 1024
 #define MAX_ALLOC (MAX_SIZE * 64)

 axis2_char_t*
 axutil_properties_read(FILE* input,
     const axutil_env_t* env);

 axis2_char_t*
 axutil_properties_read_next(axis2_char_t* cur);

 axis2_char_t*
 axutil_properties_trunk_and_dup(axis2_char_t* start,
     axis2_char_t* end,
     const axutil_env_t* env);

 struct axutil_properties
 {
     axutil_hash_t *prop_hash;
 };

 AXIS2_EXTERN axutil_properties_t *AXIS2_CALL
 axutil_properties_create(const axutil_env_t *env)
 {
     axutil_properties_t *properties = NULL;

     AXIS2_ENV_CHECK(env, NULL);

     properties= (axutil_properties_t *) AXIS2_MALLOC(env->allocator,
         sizeof(axutil_properties_t));

     if (!properties)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
         return NULL;
     }
     properties->prop_hash = axutil_hash_make(env);

     return properties;
 }

 AXIS2_EXTERN void AXIS2_CALL
 axutil_properties_free(axutil_properties_t *properties,
     const axutil_env_t *env)
 {
     axis2_char_t *key = NULL;
     axis2_char_t *value = NULL;
     axutil_hash_index_t *hi = NULL;

     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);

     if (properties->prop_hash)
     {
         for (hi = axutil_hash_first(properties->prop_hash, env);
             hi; hi = axutil_hash_next(env, hi))
         {
             axutil_hash_this(hi, (void*)&key, NULL, (void*)&value);
             if (key)
 	    {
                 AXIS2_FREE(env-> allocator, key);
 	    }
             if (value)
 	    {
                 AXIS2_FREE(env-> allocator, value);
 	    }
         }
         axutil_hash_free(properties->prop_hash, env);
     }

     if (properties)
     {
         AXIS2_FREE(env->allocator, properties);
     }
     return;
 }

 AXIS2_EXTERN axis2_char_t* AXIS2_CALL
 axutil_properties_get_property(axutil_properties_t *properties,
     const axutil_env_t *env,
     axis2_char_t *key)
 {
     AXIS2_PARAM_CHECK(env-> error, key, NULL);

     return axutil_hash_get(properties-> prop_hash,
         key, AXIS2_HASH_KEY_STRING);
 }

 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axutil_properties_set_property(axutil_properties_t *properties,
     const axutil_env_t *env,
     axis2_char_t *key,
     axis2_char_t *value)
 {
     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env-> error, key, AXIS2_FAILURE);

     axutil_hash_set(properties-> prop_hash, key,
         AXIS2_HASH_KEY_STRING, value);
     return AXIS2_SUCCESS;
 }

 AXIS2_EXTERN axutil_hash_t* AXIS2_CALL
 axutil_properties_get_all(axutil_properties_t *properties,
     const axutil_env_t *env)
 {
     return properties-> prop_hash;
 }

 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axutil_properties_store(axutil_properties_t *properties,
     const axutil_env_t *env,
     FILE *output)
 {
     axutil_hash_index_t *hi = NULL;
     axis2_char_t *key = NULL;
     axis2_char_t *value = NULL;

     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env-> error, output, AXIS2_FAILURE);

     if (properties->prop_hash)
     {
         for (hi = axutil_hash_first(properties->prop_hash, env);
             hi; hi = axutil_hash_next(env, hi))
         {
             axutil_hash_this(hi, (void*)&key, NULL, (void*)&value);
             if (key)
             {
                 if (!value)
                 {
                     value = axutil_strdup(env, "");
                 }
                 fprintf(output, "%s=%s\n", key, value);
             }
         }
     }
     return AXIS2_SUCCESS;
 }

 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axutil_properties_load(axutil_properties_t *properties,
     const axutil_env_t *env,
     axis2_char_t *input_filename)
 {
     FILE *input = NULL;
     axis2_char_t *cur = NULL;
     axis2_char_t *tag = NULL;
     const int LINE_STARTED = -1;
     const int LINE_MIDWAY = 0;
     const int EQUAL_FOUND = 1;
     const int LINE_HALFWAY = 2;
     int status = LINE_STARTED;

     axis2_char_t *key = NULL;
     axutil_hash_t *prop_hash = NULL;
     axis2_char_t *buffer = NULL;
     axis2_char_t loginfo[1024];

     AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
     AXIS2_PARAM_CHECK(env-> error, input_filename, AXIS2_FAILURE);

     prop_hash = properties-> prop_hash;

     input = fopen(input_filename, "r+");
     if(!input)
     {
         return AXIS2_FAILURE;
     }
     buffer = axutil_properties_read(input, env);

     if (!buffer)
     {
         sprintf(loginfo, "error in reading file\n");
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
             loginfo);
         AXIS2_FREE(env-> allocator, buffer);
         return AXIS2_FAILURE;
     }


     for (cur = axutil_properties_read_next(buffer); *cur ;
         cur = axutil_properties_read_next(++cur))
     {
         if (*cur == '\r')
         {
             *cur = '\0';
         }
         else if (*cur != '\0' && *cur != '\n' && status == LINE_STARTED)
         {
             tag = cur;
             status = LINE_MIDWAY;
         }
         /* equal found just create a property */
         else if (*cur == '=' &&  status == LINE_MIDWAY)
         {
             *cur = '\0';
             if (status != LINE_MIDWAY)
             {
                 sprintf(loginfo, "equal apear in wrong place around %s\n", tag);
                 AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                     loginfo);
                 AXIS2_FREE(env-> allocator, buffer);
                 return AXIS2_FAILURE;
             }
             status = EQUAL_FOUND;
             key =  axutil_properties_trunk_and_dup(tag, cur, env);
         }
         /* right next to the equal found */
         else if (status == EQUAL_FOUND)
         {
             tag = cur;
             status = LINE_HALFWAY;
         }

         else if (*cur == '\n')
         {
             *cur = '\0';
             if (status == LINE_HALFWAY)
             {
                 tag =  axutil_properties_trunk_and_dup(tag, cur, env);
                 axutil_hash_set(prop_hash,
                     key, AXIS2_HASH_KEY_STRING, tag);
             }
             status = LINE_STARTED;
         }
     }
     if (status == LINE_HALFWAY)
     {
         *cur = '\0';
         tag =  axutil_properties_trunk_and_dup(tag, cur, env);
         axutil_hash_set(prop_hash,
             key, AXIS2_HASH_KEY_STRING, tag);
         status = LINE_STARTED;
     }
     if (status != LINE_STARTED)
     {
         sprintf(loginfo, "error parsing properties\n");
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
             loginfo);
         AXIS2_FREE(env-> allocator, buffer);
         return AXIS2_FAILURE;
     }
 	if(input)
 	{
 	    fclose(input);
 	}
     AXIS2_FREE(env-> allocator, buffer);
     return AXIS2_SUCCESS;
 }


 axis2_char_t*
 axutil_properties_read_next(axis2_char_t* cur)
 {
     /* ignore comment */
     if (*cur == '#')
     {
         for (;*cur != '\n' && *cur != '\0'; cur ++);
     }
     /* check '\\''\n' case */
     if (*cur == '\\' && *(cur + 1) == '\n')
     {
         /* ignore two axis2_char_ts */
         *(cur++) = ' ';
         *(cur++) = ' ';
     }
     return cur;
 }

 axis2_char_t*
 axutil_properties_trunk_and_dup(axis2_char_t* start,
     axis2_char_t* end,
     const axutil_env_t* env)
 {
     for (; *start == ' '; start ++); /* remove front spaces */
     for (end --; *end == ' '; end --); /* remove rear spaces */
     *(++end) = '\0';
     start = (axis2_char_t*)axutil_strdup(env, start);
     return start;
 }

 axis2_char_t*
 axutil_properties_read(FILE* input,
     const axutil_env_t* env)
 {
     size_t nread = 0;
     axis2_char_t* out_stream = NULL;
     size_t ncount = 0;
     size_t curr_alloc = MAX_SIZE * 2;
     size_t total_alloc = curr_alloc;

     out_stream = (axis2_char_t*) AXIS2_MALLOC(env-> allocator,
         sizeof(axis2_char_t) * curr_alloc);
     if (!out_stream)
     {
         return NULL;
     }

     do
     {
         nread = fread(out_stream + ncount, sizeof(axis2_char_t), MAX_SIZE,
             input);
         ncount += nread;

         if (ncount + MAX_SIZE > total_alloc)
         {
             axis2_char_t *new_stream = NULL;
             if (curr_alloc < MAX_ALLOC)
             {
                 curr_alloc *= 2;
             }

             total_alloc += curr_alloc;
             new_stream = AXIS2_MALLOC(env->allocator,
                 sizeof(axis2_char_t) * total_alloc);
             if (!new_stream)
             {
                 return NULL;
             }

             memcpy(new_stream, out_stream, sizeof(axis2_char_t) * ncount);
             out_stream = new_stream;
         }
     }
     while (nread == MAX_SIZE);

     out_stream[ncount] = '\0';
     return out_stream;
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <axutil_properties.h>
	#include <axutil_string.h>
	#include <axutil_utils.h>


	#define MAX_SIZE 1024
	#define MAX_ALLOC (MAX_SIZE * 64)

	axis2_char_t*
	axutil_properties_read(FILE* input,
	const axutil_env_t* env);

	axis2_char_t*
	axutil_properties_read_next(axis2_char_t* cur);

	axis2_char_t*
	axutil_properties_trunk_and_dup(axis2_char_t* start,
	axis2_char_t* end,
	const axutil_env_t* env);

	struct axutil_properties
	{
	axutil_hash_t *prop_hash;
	};

	AXIS2_EXTERN axutil_properties_t *AXIS2_CALL
	axutil_properties_create(const axutil_env_t *env)
	{
	axutil_properties_t *properties = NULL;

	AXIS2_ENV_CHECK(env, NULL);

	properties= (axutil_properties_t *) AXIS2_MALLOC(env->allocator,
	sizeof(axutil_properties_t));

	if (!properties)
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
	return NULL;
	}
	properties->prop_hash = axutil_hash_make(env);

	return properties;
	}

	AXIS2_EXTERN void AXIS2_CALL
	axutil_properties_free(axutil_properties_t *properties,
	const axutil_env_t *env)
	{
	axis2_char_t *key = NULL;
	axis2_char_t *value = NULL;
	axutil_hash_index_t *hi = NULL;

	AXIS2_ENV_CHECK(env, AXIS2_FAILURE);

	if (properties->prop_hash)
	{
	for (hi = axutil_hash_first(properties->prop_hash, env);
	hi; hi = axutil_hash_next(env, hi))
	{
	axutil_hash_this(hi, (void)&key, NULL, (void)&value);
	if (key)
	{
	AXIS2_FREE(env-> allocator, key);
	}
	if (value)
	{
	AXIS2_FREE(env-> allocator, value);
	}
	}
	axutil_hash_free(properties->prop_hash, env);
	}

	if (properties)
	{
	AXIS2_FREE(env->allocator, properties);
	}
	return;
	}

	AXIS2_EXTERN axis2_char_t* AXIS2_CALL
	axutil_properties_get_property(axutil_properties_t *properties,
	const axutil_env_t *env,
	axis2_char_t *key)
	{
	AXIS2_PARAM_CHECK(env-> error, key, NULL);

	return axutil_hash_get(properties-> prop_hash,
	key, AXIS2_HASH_KEY_STRING);
	}

	AXIS2_EXTERN axis2_status_t AXIS2_CALL
	axutil_properties_set_property(axutil_properties_t *properties,
	const axutil_env_t *env,
	axis2_char_t *key,
	axis2_char_t *value)
	{
	AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
	AXIS2_PARAM_CHECK(env-> error, key, AXIS2_FAILURE);

	axutil_hash_set(properties-> prop_hash, key,
	AXIS2_HASH_KEY_STRING, value);
	return AXIS2_SUCCESS;
	}

	AXIS2_EXTERN axutil_hash_t* AXIS2_CALL
	axutil_properties_get_all(axutil_properties_t *properties,
	const axutil_env_t *env)
	{
	return properties-> prop_hash;
	}

	AXIS2_EXTERN axis2_status_t AXIS2_CALL
	axutil_properties_store(axutil_properties_t *properties,
	const axutil_env_t *env,
	FILE *output)
	{
	axutil_hash_index_t *hi = NULL;
	axis2_char_t *key = NULL;
	axis2_char_t *value = NULL;

	AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
	AXIS2_PARAM_CHECK(env-> error, output, AXIS2_FAILURE);

	if (properties->prop_hash)
	{
	for (hi = axutil_hash_first(properties->prop_hash, env);
	hi; hi = axutil_hash_next(env, hi))
	{
	axutil_hash_this(hi, (void)&key, NULL, (void)&value);
	if (key)
	{
	if (!value)
	{
	value = axutil_strdup(env, "");
	}
	fprintf(output, "%s=%s\n", key, value);
	}
	}
	}
	return AXIS2_SUCCESS;
	}

	AXIS2_EXTERN axis2_status_t AXIS2_CALL
	axutil_properties_load(axutil_properties_t *properties,
	const axutil_env_t *env,
	axis2_char_t *input_filename)
	{
	FILE *input = NULL;
	axis2_char_t *cur = NULL;
	axis2_char_t *tag = NULL;
	const int LINE_STARTED = -1;
	const int LINE_MIDWAY = 0;
	const int EQUAL_FOUND = 1;
	const int LINE_HALFWAY = 2;
	int status = LINE_STARTED;

	axis2_char_t *key = NULL;
	axutil_hash_t *prop_hash = NULL;
	axis2_char_t *buffer = NULL;
	axis2_char_t loginfo[1024];

	AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
	AXIS2_PARAM_CHECK(env-> error, input_filename, AXIS2_FAILURE);

	prop_hash = properties-> prop_hash;

	input = fopen(input_filename, "r+");
	if(!input)
	{
	return AXIS2_FAILURE;
	}
	buffer = axutil_properties_read(input, env);

	if (!buffer)
	{
	sprintf(loginfo, "error in reading file\n");
	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
	loginfo);
	AXIS2_FREE(env-> allocator, buffer);
	return AXIS2_FAILURE;
	}



	for (cur = axutil_properties_read_next(buffer); *cur ;
	cur = axutil_properties_read_next(++cur))
	{
	if (*cur == '\r')
	{
	*cur = '\0';
	}
	else if (cur != '\0' && cur != '\n' && status == LINE_STARTED)
	{
	tag = cur;
	status = LINE_MIDWAY;
	}
	/* equal found just create a property */
	else if (*cur == '=' && status == LINE_MIDWAY)
	{
	*cur = '\0';
	if (status != LINE_MIDWAY)
	{
	sprintf(loginfo, "equal apear in wrong place around %s\n", tag);
	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
	loginfo);
	AXIS2_FREE(env-> allocator, buffer);
	return AXIS2_FAILURE;
	}
	status = EQUAL_FOUND;
	key = axutil_properties_trunk_and_dup(tag, cur, env);
	}
	/* right next to the equal found */
	else if (status == EQUAL_FOUND)
	{
	tag = cur;
	status = LINE_HALFWAY;
	}

	else if (*cur == '\n')
	{
	*cur = '\0';
	if (status == LINE_HALFWAY)
	{
	tag = axutil_properties_trunk_and_dup(tag, cur, env);
	axutil_hash_set(prop_hash,
	key, AXIS2_HASH_KEY_STRING, tag);
	}
	status = LINE_STARTED;
	}
	}
	if (status == LINE_HALFWAY)
	{
	*cur = '\0';
	tag = axutil_properties_trunk_and_dup(tag, cur, env);
	axutil_hash_set(prop_hash,
	key, AXIS2_HASH_KEY_STRING, tag);
	status = LINE_STARTED;
	}
	if (status != LINE_STARTED)
	{
	sprintf(loginfo, "error parsing properties\n");
	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
	loginfo);
	AXIS2_FREE(env-> allocator, buffer);
	return AXIS2_FAILURE;
	}
	if(input)
	{
	fclose(input);
	}
	AXIS2_FREE(env-> allocator, buffer);
	return AXIS2_SUCCESS;
	}


	axis2_char_t*
	axutil_properties_read_next(axis2_char_t* cur)
	{
	/* ignore comment */
	if (*cur == '#')
	{
	for (;cur != '\n' && cur != '\0'; cur ++);
	}
	/* check '\\''\n' case */
	if (cur == '\\' && (cur + 1) == '\n')
	{
	/* ignore two axis2_char_ts */
	*(cur++) = ' ';
	*(cur++) = ' ';
	}
	return cur;
	}

	axis2_char_t*
	axutil_properties_trunk_and_dup(axis2_char_t* start,
	axis2_char_t* end,
	const axutil_env_t* env)
	{
	for (; start == ' '; start ++); / remove front spaces */
	for (end --; end == ' '; end --); / remove rear spaces */
	*(++end) = '\0';
	start = (axis2_char_t*)axutil_strdup(env, start);
	return start;
	}

	axis2_char_t*
	axutil_properties_read(FILE* input,
	const axutil_env_t* env)
	{
	size_t nread = 0;
	axis2_char_t* out_stream = NULL;
	size_t ncount = 0;
	size_t curr_alloc = MAX_SIZE * 2;
	size_t total_alloc = curr_alloc;

	out_stream = (axis2_char_t*) AXIS2_MALLOC(env-> allocator,
	sizeof(axis2_char_t) * curr_alloc);
	if (!out_stream)
	{
	return NULL;
	}

	do
	{
	nread = fread(out_stream + ncount, sizeof(axis2_char_t), MAX_SIZE,
	input);
	ncount += nread;

	if (ncount + MAX_SIZE > total_alloc)
	{
	axis2_char_t *new_stream = NULL;
	if (curr_alloc < MAX_ALLOC)
	{
	curr_alloc *= 2;
	}

	total_alloc += curr_alloc;
	new_stream = AXIS2_MALLOC(env->allocator,
	sizeof(axis2_char_t) * total_alloc);
	if (!new_stream)
	{
	return NULL;
	}

	memcpy(new_stream, out_stream, sizeof(axis2_char_t) * ncount);
	out_stream = new_stream;
	}
	}
	while (nread == MAX_SIZE);

	out_stream[ncount] = '\0';
	return out_stream;
	}