static vnet_config_feature_t *
duplicate_feature_vector (vnet_config_feature_t * feature_vector)
{
vnet_config_feature_t * result, * f;
result = vec_dup (feature_vector);
vec_foreach (f, result)
f->feature_config = vec_dup (f->feature_config);
return result;
}
ray *ray_dup(ray *r)
{
ray* newr = malloc(sizeof(ray));
if(newr == NULL) {
printf("ray_dup: Cannot allocate\n");
exit (1);
}
newr->origin = vec_dup(r->origin);
newr->direction = vec_dup(r->direction);
return newr;
}
camera* camera_dup(camera* c){
//Deep Copy Implementation
camera* new_camera = malloc(sizeof(camera));
new_camera ->loc = vec_dup(c->loc);
new_camera->h = c->h;
new_camera->w = c->w;
return new_camera;
}
/**
* Clone a material struct.
**/
static void
state_material_clone(struct material *material)
{
size_t i;
material->uniforms = vec_dup(material->uniforms,
material->num_uniforms);
for (i = 0; i < material->num_uniforms; i++)
uniform_grab(material->uniforms[i]);
}
sphere *sphere_dup(sphere *s)
{
sphere* news = malloc(sizeof(sphere));
if(news == NULL) {
printf("shpere_dup: Cannot allocate\n");
exit (1);
}
news->center = vec_dup(s->center);
news->radius = s->radius;
news->color = rgb_dup(s->color);
return news;
}
sphere *sphere_new(vec *center, double radius, rgb *color)
{
sphere* news = malloc(sizeof(sphere));
if(news == NULL) {
printf("shpere_new: Cannot allocate\n");
exit (1);
}
news->center = vec_dup(center);
news->radius = radius;
news->color = rgb_dup(color);
return news;
}
void
dhcp6_pd_send_client_message (vlib_main_t * vm, u32 sw_if_index, u8 stop,
dhcp6_pd_send_client_message_params_t * params)
{
dhcp6_pd_client_main_t *cm = &dhcp6_pd_client_main;
dhcp6_pd_client_state_t *client_state = 0;
dhcp6_pd_client_state_t empty_state = {
0,
};
ASSERT (~0 != sw_if_index);
vec_validate_init_empty (cm->client_state_by_sw_if_index, sw_if_index,
empty_state);
client_state = &cm->client_state_by_sw_if_index[sw_if_index];
if (!client_state->entry_valid)
{
client_state->entry_valid = 1;
client_state->adj_index = ~0;
}
stop_sending_client_message (vm, client_state);
if (!stop)
{
client_state->keep_sending_client_message = 1;
vec_free (client_state->params.prefixes);
client_state->params = *params;
client_state->params.prefixes = vec_dup (params->prefixes);
client_state->n_left = params->mrc;
client_state->start_time = vlib_time_now (vm);
client_state->sleep_interval =
(1 + random_f64_from_to (-0.1, 0.1)) * params->irt;
client_state->due_time = 0; /* send first packet ASAP */
client_state->transaction_id = random_u32 (&cm->seed) & 0x00ffffff;
client_state->buffer =
create_buffer_for_client_message (vm, sw_if_index, client_state,
params->msg_type);
if (!client_state->buffer)
client_state->keep_sending_client_message = 0;
else
vlib_process_signal_event (vm,
send_dhcp6_pd_client_message_process_node.index,
1, 0);
}
}
/* allocates a new camera on the heap */
camera *camera_dup(camera *c)
{
if (c == NULL)
{
fprintf(stderr, "%s\n", "camera_dup: parameter is NULL");
exit(1);
}
camera *cdup = malloc(sizeof(camera));
if (cdup == NULL)
{
fprintf(stderr, "%s\n", "camera_dup: allocation failed.");
exit(1);
}
cdup->loc = vec_dup(c->loc);
cdup->h = c->h;
cdup->w = c->w;
return cdup;
}
/**
* Create a new state with the same properties as an existing state.
**/
state_t *
state_clone(state_t *in)
{
state_t *state = xmalloc(sizeof(state_t));
size_t i;
memcpy(state, in, sizeof(state_t));
state_sync_mat_backlog(in);
state->material_gen = material_backlog_subscribe();
if (state->colorbuf)
colorbuf_grab(state->colorbuf);
state->materials = vec_dup(in->materials, in->num_materials);
for (i = 0; i < state->num_materials; i++)
state_material_clone(&state->materials[i]);
refcount_init(&state->refcount);
refcount_add_destructor(&state->refcount, state_destructor, state);
return state;
}
static void
vl_msg_api_process_file (vlib_main_t * vm, u8 * filename,
u32 first_index, u32 last_index,
vl_api_replay_t which)
{
vl_api_trace_file_header_t *hp;
int i, fd;
struct stat statb;
size_t file_size;
u8 *msg;
u8 endian_swap_needed = 0;
api_main_t *am = &api_main;
static u8 *tmpbuf;
u32 nitems;
void **saved_print_handlers = 0;
fd = open ((char *) filename, O_RDONLY);
if (fd < 0)
{
vlib_cli_output (vm, "Couldn't open %s\n", filename);
return;
}
if (fstat (fd, &statb) < 0)
{
vlib_cli_output (vm, "Couldn't stat %s\n", filename);
return;
}
if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp)))
{
vlib_cli_output (vm, "File not plausible: %s\n", filename);
close(fd);
return;
}
file_size = statb.st_size;
file_size = (file_size + 4095) & ~(4096);
hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (hp == (vl_api_trace_file_header_t *) MAP_FAILED)
{
vlib_cli_output (vm, "mmap failed: %s\n", filename);
close (fd);
return;
}
close (fd);
if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
|| (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
endian_swap_needed = 1;
if (endian_swap_needed)
nitems = ntohl (hp->nitems);
else
nitems = hp->nitems;
if (last_index == (u32) ~ 0)
{
last_index = nitems - 1;
}
if (first_index >= nitems || last_index >= nitems)
{
vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
first_index, last_index, nitems - 1);
munmap (hp, file_size);
return;
}
if (hp->wrapped)
vlib_cli_output (vm,
"Note: wrapped/incomplete trace, results may vary\n");
if (which == CUSTOM_DUMP)
{
saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
vl_msg_api_custom_dump_configure (am);
}
msg = (u8 *) (hp + 1);
for (i = 0; i < first_index; i++)
{
trace_cfg_t *cfgp;
int size;
u16 msg_id;
if (clib_arch_is_little_endian)
msg_id = ntohs (*((u16 *) msg));
else
msg_id = *((u16 *) msg);
cfgp = am->api_trace_cfg + msg_id;
if (!cfgp)
{
vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
return;
}
size = cfgp->size;
msg += size;
}
for (; i <= last_index; i++)
{
trace_cfg_t *cfgp;
u16 *msg_idp;
u16 msg_id;
int size;
if (which == DUMP)
vlib_cli_output (vm, "---------- trace %d -----------\n", i);
if (clib_arch_is_little_endian)
msg_id = ntohs (*((u16 *) msg));
else
msg_id = *((u16 *) msg);
cfgp = am->api_trace_cfg + msg_id;
if (!cfgp)
{
vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
return;
}
size = cfgp->size;
/* Copy the buffer (from the read-only mmap'ed file) */
vec_validate (tmpbuf, size - 1 + sizeof (uword));
clib_memcpy (tmpbuf + sizeof (uword), msg, size);
memset (tmpbuf, 0xf, sizeof (uword));
/*
* Endian swap if needed. All msg data is supposed to be
* in network byte order. All msg handlers are supposed to
* know that. The generic message dumpers don't know that.
* One could fix apigen, I suppose.
*/
if ((which == DUMP && clib_arch_is_little_endian) || endian_swap_needed)
{
void (*endian_fp) (void *);
if (msg_id >= vec_len (am->msg_endian_handlers)
|| (am->msg_endian_handlers[msg_id] == 0))
{
vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
return;
}
endian_fp = am->msg_endian_handlers[msg_id];
(*endian_fp) (tmpbuf + sizeof (uword));
}
/* msg_id always in network byte order */
if (clib_arch_is_little_endian)
{
msg_idp = (u16 *) (tmpbuf + sizeof (uword));
*msg_idp = msg_id;
}
switch (which)
{
case CUSTOM_DUMP:
case DUMP:
if (msg_id < vec_len (am->msg_print_handlers) &&
am->msg_print_handlers[msg_id])
{
u8 *(*print_fp) (void *, void *);
print_fp = (void *) am->msg_print_handlers[msg_id];
(*print_fp) (tmpbuf + sizeof (uword), vm);
}
else
{
vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
msg_id);
break;
}
break;
case INITIALIZERS:
if (msg_id < vec_len (am->msg_print_handlers) &&
am->msg_print_handlers[msg_id])
{
u8 *s;
int j;
u8 *(*print_fp) (void *, void *);
print_fp = (void *) am->msg_print_handlers[msg_id];
vlib_cli_output (vm, "/*");
(*print_fp) (tmpbuf + sizeof (uword), vm);
vlib_cli_output (vm, "*/\n");
s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
am->msg_names[msg_id], i,
am->api_trace_cfg[msg_id].size);
for (j = 0; j < am->api_trace_cfg[msg_id].size; j++)
{
if ((j & 7) == 0)
s = format (s, "\n ");
s = format (s, "0x%02x,", tmpbuf[sizeof (uword) + j]);
}
s = format (s, "\n};\n%c", 0);
vlib_cli_output (vm, (char *) s);
vec_free (s);
}
break;
case REPLAY:
if (msg_id < vec_len (am->msg_print_handlers) &&
am->msg_print_handlers[msg_id] && cfgp->replay_enable)
{
void (*handler) (void *);
handler = (void *) am->msg_handlers[msg_id];
if (!am->is_mp_safe[msg_id])
vl_msg_api_barrier_sync ();
(*handler) (tmpbuf + sizeof (uword));
if (!am->is_mp_safe[msg_id])
vl_msg_api_barrier_release ();
}
else
{
if (cfgp->replay_enable)
vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
msg_id);
break;
}
break;
}
_vec_len (tmpbuf) = 0;
msg += size;
}
if (saved_print_handlers)
{
clib_memcpy (am->msg_print_handlers, saved_print_handlers,
vec_len (am->msg_print_handlers) * sizeof (void *));
vec_free (saved_print_handlers);
}
munmap (hp, file_size);
}
