bucket_t * bucket_new(hash_t hashmask)
{
bucket_t *bucket;
assert(_mask > 0);
assert(hashmask >= 0);
assert(hashmask <= _mask);
assert(_buckets[hashmask] == NULL);
bucket = calloc(1, sizeof(bucket_t));
bucket->hashmask = hashmask;
bucket->level = -1;
assert(bucket->primary_node == NULL);
assert(bucket->secondary_node == NULL);
assert(bucket->backup_node == NULL);
assert(bucket->source_node == NULL);
assert(bucket->logging_node == NULL);
assert(bucket->transfer_event == NULL);
assert(bucket->shutdown_event == NULL);
assert(bucket->transfer_client == NULL);
assert(data_in_transit() == 0);
assert(bucket->oldbucket_event == NULL);
assert(bucket->transfer_mode_special == 0);
assert(bucket->promoting == NOT_PROMOTING);
bucket->data = data_new(_mask, hashmask);
return(bucket);
}
struct init_params* params_new(void)
{
struct init_params *params = (struct init_params *) malloc(sizeof(struct init_params));
bzero(params, sizeof(struct init_params));
params->client_buffer = data_new();
params->connections = connections_new();
params->packets_receive = packets_new();
params->packets_send = packets_new();
return params;
}
/* Append a live binary buffer that we should translate into the
* format configured earlier by the user for this script.
* Takes ownership of the malloc-allocated buffer and frees it.
*/
static void append_data(struct code_state *code, enum code_data_t data_type,
void *data_buffer, int data_len)
{
struct code_data *data = data_new();
data->buffer = data_buffer;
data->type = data_type;
data->len = data_len;
struct code_fragment *fragment = fragment_new();
fragment->type = FRAGMENT_DATA;
fragment->contents.data = data;
append_fragment(code, fragment);
}
int main(void)
{
void *data;
if (!eina_init())
{
printf ("Error during the initialization of eina_error module\n");
return EXIT_FAILURE;
}
MY_ERROR_NEGATIVE = eina_error_msg_static_register("Negative number");
MY_ERROR_NULL = eina_error_msg_static_register("NULL pointer");
data = data_new();
if (!data)
{
Eina_Error err;
err = eina_error_get();
if (err)
printf("Error during memory allocation: %s\n",
eina_error_msg_get(err));
}
if (!test(0))
{
Eina_Error err;
err = eina_error_get();
if (err)
printf("Error during test function: %s\n",
eina_error_msg_get(err));
}
if (!test(-1))
{
Eina_Error err;
err = eina_error_get();
if (err)
printf("Error during test function: %s\n",
eina_error_msg_get(err));
}
eina_shutdown();
return EXIT_SUCCESS;
}
void data_put(GList **config, char *name, void *data)
{
int i;
data_t *dp;
for (i=0; i<g_list_length(*config); i++) {
dp = g_list_nth_data(*config, i);
if(!strcmp(name, dp->name)) {
dp->data=data;
return;
}
}
dp = data_new();
dp->name = name;
dp->data = data;
(*config) = g_list_append((*config), dp);
}
static struct connection_data* init_connection_data(struct itun_packet *packet)
{
if (packet->header->length != sizeof(struct itun_packet_connect))
return NULL;
struct itun_packet_connect *ipc = (struct itun_packet_connect *) packet->data;
struct connection_data *data = malloc(sizeof(struct connection_data));
bzero(data, sizeof(struct connection_data));
data->client_buffer = data_new();
data->connid = packet->header->connid;
data->client_ip = packet->client_ip;
data->server_ip = ipc->ip;
data->server_port = ipc->port;
return data;
}
s_data_array* data_new(cstring name)
{
return data_new(name, k_maximum_count, sizeof(T));
}
