/* get name functions */
static inline str* __get_avp_name(int id, map_t m)
{
map_iterator_t it;
int **idp;
if (map_first(m, &it) < 0) {
LM_ERR("map doesn't exist\n");
return NULL;
}
for (;;) {
if (!iterator_is_valid(&it))
return NULL;
idp = (int**)iterator_val(&it);
if (!idp) {
LM_ERR("[BUG] while getting avp name\n");
return NULL;
}
if (p2int(*idp) == id)
return iterator_key(&it);
if (iterator_next(&it) < 0)
return NULL;
}
}
static void clean_profiles(unsigned int ticks, void *param)
{
map_iterator_t it, del;
unsigned int count;
struct dlg_profile_table *profile;
prof_value_info_t *rp;
void **dst;
int i;
for (profile = profiles; profile; profile = profile->next) {
if (!profile->has_value || profile->repl_type != REPL_PROTOBIN)
continue;
for (i = 0; i < profile->size; i++) {
lock_set_get(profile->locks, i);
if (map_first(profile->entries[i], &it) < 0) {
LM_ERR("map does not exist\n");
goto next_entry;
}
while (iterator_is_valid(&it)) {
dst = iterator_val(&it);
if (!dst || !*dst) {
LM_ERR("[BUG] bogus map[%d] state\n", i);
goto next_val;
}
count = prof_val_get_count(dst);
if (!count) {
del = it;
if (iterator_next(&it) < 0)
LM_DBG("cannot find next iterator\n");
rp = (prof_value_info_t *) iterator_delete(&del);
if (rp) {
free_profile_val_t(rp);
/*if (rp->noval)
shm_free(rp->noval);
shm_free(rp);*/
}
continue;
}
next_val:
if (iterator_next(&it) < 0)
break;
}
next_entry:
lock_set_release(profile->locks, i);
}
}
}
static void
rem(gd_t gd)
{
uuid_t uuid;
map_t m;
struct gpt_hdr *hdr;
struct gpt_ent *ent;
unsigned int i;
if ((hdr = gpt_gethdr(gd)) == NULL)
return;
/* Remove all matching entries in the map. */
for (m = map_first(gd); m != NULL; m = m->map_next) {
if (m->map_type != MAP_TYPE_GPT_PART || m->map_index < 1)
continue;
if (entry > 0 && entry != m->map_index)
continue;
if (block > 0 && block != m->map_start)
continue;
if (size > 0 && size != m->map_size)
continue;
i = m->map_index - 1;
hdr = gd->gpt->map_data;
ent = (void*)((char*)gd->tbl->map_data + i *
le32toh(hdr->hdr_entsz));
uuid_dec_le(&ent->ent_type, &uuid);
if (!uuid_is_nil(&type, NULL) &&
!uuid_equal(&type, &uuid, NULL))
continue;
/* Remove the primary entry by clearing the partition type. */
uuid_create_nil(&uuid, NULL);
uuid_enc_le(&ent->ent_type, &uuid);
hdr->hdr_crc_table = htole32(crc32(gd->tbl->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(gd, gd->gpt);
gpt_write(gd, gd->tbl);
hdr = gd->tpg->map_data;
ent = (void*)((char*)gd->lbt->map_data + i *
le32toh(hdr->hdr_entsz));
/* Remove the secondary entry. */
uuid_enc_le(&ent->ent_type, &uuid);
hdr->hdr_crc_table = htole32(crc32(gd->lbt->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(gd, gd->lbt);
gpt_write(gd, gd->tpg);
gpt_status(gd, m->map_index, "removed");
}
}
static void
show(int fd __unused)
{
uuid_t type;
off_t start;
map_t *m, *p;
struct mbr *mbr;
struct gpt_ent *ent;
unsigned int i;
printf(" %*s", lbawidth, "start");
printf(" %*s", lbawidth, "size");
printf(" index contents\n");
m = map_first();
while (m != NULL) {
printf(" %*llu", lbawidth, (long long)m->map_start);
printf(" %*llu", lbawidth, (long long)m->map_size);
putchar(' ');
putchar(' ');
if (m->map_index > 0)
printf("%5d", m->map_index);
else
printf(" ");
putchar(' ');
putchar(' ');
switch (m->map_type) {
case MAP_TYPE_MBR:
if (m->map_start != 0)
printf("Extended ");
printf("MBR");
break;
case MAP_TYPE_PRI_GPT_HDR:
printf("Pri GPT header");
break;
case MAP_TYPE_SEC_GPT_HDR:
printf("Sec GPT header");
break;
case MAP_TYPE_PRI_GPT_TBL:
printf("Pri GPT table");
break;
case MAP_TYPE_SEC_GPT_TBL:
printf("Sec GPT table");
break;
case MAP_TYPE_MBR_PART:
p = m->map_data;
if (p->map_start != 0)
printf("Extended ");
printf("MBR part ");
mbr = p->map_data;
for (i = 0; i < 4; i++) {
start = le16toh(mbr->mbr_part[i].part_start_hi);
start = (start << 16) +
le16toh(mbr->mbr_part[i].part_start_lo);
if (m->map_start == p->map_start + start)
break;
}
printf("%d", mbr->mbr_part[i].part_typ);
break;
case MAP_TYPE_GPT_PART:
printf("GPT part ");
ent = m->map_data;
if (show_label) {
printf("- \"%s\"",
utf16_to_utf8(ent->ent_name));
} else {
le_uuid_dec(&ent->ent_type, &type);
printf("- %s", friendly(&type));
}
break;
case MAP_TYPE_PMBR:
printf("PMBR");
break;
}
putchar('\n');
m = m->map_next;
}
}
static void broadcast_profiles(utime_t ticks, void *param)
{
#define REPL_PROF_TRYSEND() \
do { \
nr++; \
if (ret > repl_prof_buffer_th) { \
/* send the buffer */ \
if (nr) \
dlg_replicate_profiles(&packet); \
bin_reset_back_pointer(&packet); \
nr = 0; \
} \
} while (0)
struct dlg_profile_table *profile;
map_iterator_t it;
unsigned int count;
int i;
int nr = 0;
int ret;
void **dst;
str *value;
bin_packet_t packet;
if (bin_init(&packet, &prof_repl_cap, REPLICATION_DLG_PROFILE, BIN_VERSION, 0) < 0) {
LM_ERR("cannot initiate bin buffer\n");
return;
}
for (profile = profiles; profile; profile = profile->next) {
if (!(profile->repl_type&REPL_PROTOBIN))
continue;
count = 0;
if (!profile->has_value) {
count = noval_get_local_count(profile);
if ((ret = repl_prof_add(&packet, &profile->name, 0, NULL, count)) < 0)
goto error;
/* check if the profile should be sent */
REPL_PROF_TRYSEND();
} else {
for (i = 0; i < profile->size; i++) {
lock_set_get(profile->locks, i);
if (map_first(profile->entries[i], &it) < 0) {
LM_ERR("map does not exist\n");
goto next_entry;
}
while (iterator_is_valid(&it)) {
dst = iterator_val(&it);
if (!dst || !*dst) {
LM_ERR("[BUG] bogus map[%d] state\n", i);
goto next_val;
}
value = iterator_key(&it);
if (!value) {
LM_ERR("cannot retrieve profile's key\n");
goto next_val;
}
count = prof_val_get_local_count(dst);
if ((ret = repl_prof_add(&packet, &profile->name, 1, value, count)) < 0)
goto error;
/* check if the profile should be sent */
REPL_PROF_TRYSEND();
next_val:
if (iterator_next(&it) < 0)
break;
}
next_entry:
lock_set_release(profile->locks, i);
}
}
}
goto done;
error:
LM_ERR("cannot add any more profiles in buffer\n");
bin_free_packet(&packet);
done:
/* check if there is anything else left to replicate */
if (nr)
dlg_replicate_profiles(&packet);
bin_free_packet(&packet);
#undef REPL_PROF_TRYSEND
}
void rl_timer_repl(utime_t ticks, void *param)
{
static str module_name = str_init("ratelimit");
unsigned int i = 0;
map_iterator_t it;
rl_pipe_t **pipe;
str *key;
int nr = 0;
int ret;
if (bin_init(&module_name, RL_PIPE_COUNTER) < 0) {
LM_ERR("cannot initiate bin buffer\n");
return;
}
/* iterate through each map */
for (i = 0; i < rl_htable.size; i++) {
RL_GET_LOCK(i);
/* iterate through all the entries */
if (map_first(rl_htable.maps[i], &it) < 0) {
LM_ERR("map doesn't exist\n");
goto next_map;
}
for (; iterator_is_valid(&it);) {
pipe = (rl_pipe_t **)iterator_val(&it);
if (!pipe || !*pipe) {
LM_ERR("[BUG] bogus map[%d] state\n", i);
goto next_pipe;
}
/* ignore cachedb replicated stuff */
if (RL_USE_CDB(*pipe))
goto next_pipe;
key = iterator_key(&it);
if (!key) {
LM_ERR("cannot retrieve pipe key\n");
goto next_pipe;
}
if (bin_push_str(key) < 0)
goto error;
if (bin_push_int((*pipe)->algo) < 0)
goto error;
if (bin_push_int((*pipe)->limit) < 0)
goto error;
if ((ret = bin_push_int((*pipe)->counter)) < 0)
goto error;
nr++;
if (ret > rl_buffer_th) {
/* send the buffer */
if (nr)
rl_replicate();
if (bin_init(&module_name, RL_PIPE_COUNTER) < 0) {
LM_ERR("cannot initiate bin buffer\n");
RL_RELEASE_LOCK(i);
return;
}
nr = 0;
}
next_pipe:
if (iterator_next(&it) < 0)
break;
}
next_map:
RL_RELEASE_LOCK(i);
}
/* if there is anything else to send, do it now */
if (nr)
rl_replicate();
return;
error:
LM_ERR("cannot add pipe info in buffer\n");
RL_RELEASE_LOCK(i);
if (nr)
rl_replicate();
}
/* timer housekeeping, invoked each timer interval to reset counters */
void rl_timer(unsigned int ticks, void *param)
{
unsigned int i = 0;
map_iterator_t it, del;
rl_pipe_t **pipe;
str *key;
void *value;
unsigned long now = time(0);
/* get CPU load */
if (get_cpuload() < 0) {
LM_ERR("cannot update CPU load\n");
i = 1;
}
lock_get(rl_lock);
/* if CPU was successfully loaded */
if (!i)
do_update_load();
/* update network if needed */
if (*rl_network_count)
*rl_network_load = get_total_bytes_waiting(PROTO_NONE);
lock_release(rl_lock);
/* iterate through each map */
for (i = 0; i < rl_htable.size; i++) {
RL_GET_LOCK(i);
/* iterate through all the entries */
if (map_first(rl_htable.maps[i], &it) < 0) {
LM_ERR("map doesn't exist\n");
goto next_map;
}
for (; iterator_is_valid(&it);) {
pipe = (rl_pipe_t **)iterator_val(&it);
if (!pipe || !*pipe) {
LM_ERR("[BUG] bogus map[%d] state\n", i);
goto next_pipe;
}
key = iterator_key(&it);
if (!key) {
LM_ERR("cannot retrieve pipe key\n");
goto next_pipe;
}
/* check to see if it is expired */
if ((*pipe)->last_used + rl_expire_time < now) {
/* this pipe is engaged in a transaction */
del = it;
if (iterator_next(&it) < 0)
LM_DBG("cannot find next iterator\n");
if ((*pipe)->algo == PIPE_ALGO_NETWORK) {
lock_get(rl_lock);
(*rl_network_count)--;
lock_release(rl_lock);
}
LM_DBG("Deleting ratelimit pipe key \"%.*s\"\n",
key->len, key->s);
value = iterator_delete(&del);
/* free resources */
if (value)
shm_free(value);
continue;
} else {
/* leave the lock if a cachedb query should be done*/
if (RL_USE_CDB(*pipe)) {
if (rl_get_counter(key, *pipe) < 0) {
LM_ERR("cannot get pipe counter\n");
goto next_pipe;
}
}
switch ((*pipe)->algo) {
case PIPE_ALGO_NETWORK:
/* handle network algo */
(*pipe)->load =
(*rl_network_load > (*pipe)->limit) ? -1 : 1;
break;
case PIPE_ALGO_RED:
if ((*pipe)->limit && rl_timer_interval)
(*pipe)->load = (*pipe)->counter /
((*pipe)->limit * rl_timer_interval);
break;
default:
break;
}
(*pipe)->last_counter = rl_get_all_counters(*pipe);
if (RL_USE_CDB(*pipe)) {
if (rl_change_counter(key, *pipe, 0) < 0) {
LM_ERR("cannot reset counter\n");
}
} else {
(*pipe)->counter = 0;
}
}
next_pipe:
if (iterator_next(&it) < 0)
break;
}
next_map:
RL_RELEASE_LOCK(i);
}
}
static void
rem(int fd)
{
uuid_t uuid;
map_t *gpt, *tpg;
map_t *tbl, *lbt;
map_t *m;
struct gpt_hdr *hdr;
struct gpt_ent *ent;
unsigned int i;
gpt = map_find(MAP_TYPE_PRI_GPT_HDR);
if (gpt == NULL) {
warnx("%s: error: no primary GPT header; run create or recover",
device_name);
return;
}
tpg = map_find(MAP_TYPE_SEC_GPT_HDR);
if (tpg == NULL) {
warnx("%s: error: no secondary GPT header; run recover",
device_name);
return;
}
tbl = map_find(MAP_TYPE_PRI_GPT_TBL);
lbt = map_find(MAP_TYPE_SEC_GPT_TBL);
if (tbl == NULL || lbt == NULL) {
warnx("%s: error: run recover -- trust me", device_name);
return;
}
/* Remove all matching entries in the map. */
for (m = map_first(); m != NULL; m = m->map_next) {
if (m->map_type != MAP_TYPE_GPT_PART || m->map_index == NOENTRY)
continue;
if (entry != NOENTRY && entry != m->map_index)
continue;
if (block > 0 && block != m->map_start)
continue;
if (size > 0 && size != m->map_size)
continue;
i = m->map_index;
hdr = gpt->map_data;
ent = (void*)((char*)tbl->map_data + i *
le32toh(hdr->hdr_entsz));
le_uuid_dec(&ent->ent_type, &uuid);
if (!uuid_is_nil(&type, NULL) &&
!uuid_equal(&type, &uuid, NULL))
continue;
/* Remove the primary entry by clearing the partition type. */
uuid_create_nil(&ent->ent_type, NULL);
hdr->hdr_crc_table = htole32(crc32(tbl->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, gpt);
gpt_write(fd, tbl);
hdr = tpg->map_data;
ent = (void*)((char*)lbt->map_data + i *
le32toh(hdr->hdr_entsz));
/* Remove the secundary entry. */
uuid_create_nil(&ent->ent_type, NULL);
hdr->hdr_crc_table = htole32(crc32(lbt->map_data,
le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));
hdr->hdr_crc_self = 0;
hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
gpt_write(fd, lbt);
gpt_write(fd, tpg);
printf("%ss%u removed\n", device_name, m->map_index);
}
}
static void repl_prof_utimer_f(utime_t ticks, void *param)
{
#define REPL_PROF_TRYSEND() \
do { \
nr++; \
if (ret > repl_prof_buffer_th) { \
/* send the buffer */ \
if (nr) { \
dlg_replicate_profiles(); \
LM_DBG("sent %d records\n", nr); \
} \
if (bin_init(&module_name, REPLICATION_DLG_PROFILE, BIN_VERSION) < 0) { \
LM_ERR("cannot initiate bin buffer\n"); \
return; \
} \
nr = 0; \
} \
} while (0)
struct dlg_profile_table *profile;
static str module_name = str_init("dialog");
map_iterator_t it;
unsigned int count;
int i;
int nr = 0;
int ret;
void **dst;
str *value;
if (bin_init(&module_name, REPLICATION_DLG_PROFILE, BIN_VERSION) < 0) {
LM_ERR("cannot initiate bin buffer\n");
return;
}
for (profile = profiles; profile; profile = profile->next) {
count = 0;
if (!profile->has_value) {
for (i = 0; i < profile->size; i++) {
lock_set_get(profile->locks, i);
count += profile->counts[i];
lock_set_release(profile->locks, i);
}
if ((ret = repl_prof_add(&profile->name, 0, NULL, count)) < 0)
goto error;
/* check if the profile should be sent */
REPL_PROF_TRYSEND();
} else {
for (i = 0; i < profile->size; i++) {
lock_set_get(profile->locks, i);
if (map_first(profile->entries[i], &it) < 0) {
LM_ERR("map does not exist\n");
goto next_entry;
}
while (iterator_is_valid(&it)) {
dst = iterator_val(&it);
if (!dst || !*dst) {
LM_ERR("[BUG] bogus map[%d] state\n", i);
goto next_val;
}
value = iterator_key(&it);
if (!value) {
LM_ERR("cannot retrieve profile's key\n");
goto next_val;
}
count = repl_prof_get(dst);
if ((ret = repl_prof_add(&profile->name, 1, value, count)) < 0)
goto error;
/* check if the profile should be sent */
REPL_PROF_TRYSEND();
next_val:
if (iterator_next(&it) < 0)
break;
}
next_entry:
lock_set_release(profile->locks, i);
}
}
}
goto done;
error:
LM_ERR("cannot add any more profiles in buffer\n");
done:
/* check if there is anything else left to replicate */
LM_DBG("sent %d records\n", nr);
if (nr)
dlg_replicate_profiles();
#undef REPL_PROF_TRYSEND
}
static int
resize(gpt_t gpt, u_int entry, off_t alignment, off_t sectors, off_t size)
{
map_t map;
struct gpt_hdr *hdr;
struct gpt_ent *ent;
unsigned int i;
off_t alignsecs, newsize;
uint64_t end;
if ((hdr = gpt_hdr(gpt)) == NULL)
return -1;
i = entry - 1;
ent = gpt_ent_primary(gpt, i);
if (gpt_uuid_is_nil(ent->ent_type)) {
gpt_warnx(gpt, "Entry at index %u is unused", entry);
return -1;
}
alignsecs = alignment / gpt->secsz;
for (map = map_first(gpt); map != NULL; map = map->map_next) {
if (entry == map->map_index)
break;
}
if (map == NULL) {
gpt_warnx(gpt, "Could not find map entry corresponding "
"to index");
return -1;
}
if (sectors > 0 && sectors == map->map_size)
if (alignment == 0 ||
(alignment > 0 && sectors % alignsecs == 0)) {
/* nothing to do */
gpt_warnx(gpt, "partition does not need resizing");
return 0;
}
newsize = map_resize(gpt, map, sectors, alignsecs);
if (newsize == -1)
return -1;
end = htole64((uint64_t)(map->map_start + newsize - 1LL));
ent->ent_lba_end = end;
if (gpt_write_primary(gpt) == -1)
return -1;
ent = gpt_ent(gpt->gpt, gpt->lbt, i);
ent->ent_lba_end = end;
if (gpt_write_backup(gpt) == -1)
return -1;
gpt_msg(gpt, "Partition %d resized: %" PRIu64 " %" PRIu64, entry,
map->map_start, newsize);
return 0;
}
void rl_timer_repl(utime_t ticks, void *param)
{
unsigned int i = 0;
map_iterator_t it;
rl_pipe_t **pipe;
str *key;
int nr = 0;
int ret;
bin_packet_t packet;
if (bin_init(&packet, &pipe_repl_cap, RL_PIPE_COUNTER, BIN_VERSION, 0) < 0) {
LM_ERR("cannot initiate bin buffer\n");
return;
}
/* iterate through each map */
for (i = 0; i < rl_htable.size; i++) {
RL_GET_LOCK(i);
/* iterate through all the entries */
if (map_first(rl_htable.maps[i], &it) < 0) {
LM_ERR("map doesn't exist\n");
goto next_map;
}
for (; iterator_is_valid(&it);) {
pipe = (rl_pipe_t **) iterator_val(&it);
if (!pipe || !*pipe) {
LM_ERR("[BUG] bogus map[%d] state\n", i);
goto next_pipe;
}
/* ignore cachedb replicated stuff */
if (RL_USE_CDB(*pipe))
goto next_pipe;
key = iterator_key(&it);
if (!key) {
LM_ERR("cannot retrieve pipe key\n");
goto next_pipe;
}
if (bin_push_str(&packet, key) < 0)
goto error;
if (bin_push_int(&packet, (*pipe)->algo) < 0)
goto error;
if (bin_push_int(&packet, (*pipe)->limit) < 0)
goto error;
/*
* for the SBT algorithm it is safe to replicate the current
* counter, since it is always updating according to the window
*/
if ((ret = bin_push_int(&packet,
((*pipe)->algo == PIPE_ALGO_HISTORY ?
(*pipe)->counter : (*pipe)->my_last_counter))) < 0)
goto error;
nr++;
if (ret > rl_buffer_th) {
/* send the buffer */
if (nr)
rl_replicate(&packet);
bin_reset_back_pointer(&packet);
nr = 0;
}
next_pipe:
if (iterator_next(&it) < 0)
break;
}
next_map:
RL_RELEASE_LOCK(i);
}
/* if there is anything else to send, do it now */
if (nr)
rl_replicate(&packet);
bin_free_packet(&packet);
return;
error:
LM_ERR("cannot add pipe info in buffer\n");
RL_RELEASE_LOCK(i);
if (nr)
rl_replicate(&packet);
bin_free_packet(&packet);
}
static int receive_sync_request(int node_id)
{
bin_packet_t *sync_packet;
dlist_t *dl;
udomain_t *dom;
map_iterator_t it;
struct urecord *r;
ucontact_t* c;
str st;
void **p;
int i;
for (dl = root; dl; dl = dl->next) {
dom = dl->d;
for(i = 0; i < dom->size; i++) {
lock_ulslot(dom, i);
for (map_first(dom->table[i].records, &it);
iterator_is_valid(&it);
iterator_next(&it)) {
p = iterator_val(&it);
if (p == NULL)
goto error_unlock;
r = (urecord_t *)*p;
sync_packet = clusterer_api.sync_chunk_start(&contact_repl_cap,
location_cluster, node_id);
if (!sync_packet)
goto error_unlock;
/* urecord in this chunk */
bin_push_int(sync_packet, 0);
bin_push_str(sync_packet, r->domain);
bin_push_str(sync_packet, &r->aor);
for (c = r->contacts; c; c = c->next) {
sync_packet = clusterer_api.sync_chunk_start(&contact_repl_cap,
location_cluster, node_id);
if (!sync_packet)
goto error_unlock;
/* contact in this chunk */
bin_push_int(sync_packet, 1);
bin_push_str(sync_packet, r->domain);
bin_push_str(sync_packet, &r->aor);
bin_push_str(sync_packet, &c->c);
bin_push_str(sync_packet, &c->callid);
bin_push_str(sync_packet, &c->user_agent);
bin_push_str(sync_packet, &c->path);
bin_push_str(sync_packet, &c->attr);
bin_push_str(sync_packet, &c->received);
bin_push_str(sync_packet, &c->instance);
st.s = (char *)&c->expires;
st.len = sizeof c->expires;
bin_push_str(sync_packet, &st);
st.s = (char *)&c->q;
st.len = sizeof c->q;
bin_push_str(sync_packet, &st);
bin_push_str(sync_packet, c->sock?&c->sock->sock_str:NULL);
bin_push_int(sync_packet, c->cseq);
bin_push_int(sync_packet, c->flags);
bin_push_int(sync_packet, c->cflags);
bin_push_int(sync_packet, c->methods);
st.s = (char *)&c->last_modified;
st.len = sizeof c->last_modified;
bin_push_str(sync_packet, &st);
}
}
unlock_ulslot(dom, i);
}
}
return 0;
error_unlock:
unlock_ulslot(dom, i);
return -1;
}
static int
biosboot(gpt_t gpt, daddr_t start, uint64_t size, u_int entry, uint8_t *label,
const char *bootpath)
{
map_t mbrmap, m;
struct mbr *mbr, *bootcode;
unsigned int i;
struct gpt_ent *ent;
uint8_t utfbuf[__arraycount(ent->ent_name) * 3 + 1];
/*
* Parse and validate partition maps
*/
if (gpt_hdr(gpt) == NULL)
return -1;
mbrmap = map_find(gpt, MAP_TYPE_PMBR);
if (mbrmap == NULL || mbrmap->map_start != 0) {
gpt_warnx(gpt, "No valid Protective MBR found");
return -1;
}
mbr = mbrmap->map_data;
/*
* Update the boot code
*/
if ((bootcode = read_boot(gpt, bootpath)) == NULL) {
gpt_warnx(gpt, "Error reading bootcode");
return -1;
}
(void)memcpy(&mbr->mbr_code, &bootcode->mbr_code,
sizeof(mbr->mbr_code));
free(bootcode);
/*
* Walk through the GPT and see where we can boot from
*/
for (m = map_first(gpt); m != NULL; m = m->map_next) {
if (m->map_type != MAP_TYPE_GPT_PART || m->map_index < 1)
continue;
ent = m->map_data;
/* first, prefer user selection */
if (entry > 0 && m->map_index == entry)
break;
if (label != NULL) {
utf16_to_utf8(ent->ent_name, utfbuf, sizeof(utfbuf));
if (strcmp((char *)label, (char *)utfbuf) == 0)
break;
}
/* next, partition as could be specified by wedge */
if (entry < 1 && label == NULL && size > 0 &&
m->map_start == start && m->map_size == (off_t)size)
break;
}
if (m == NULL) {
gpt_warnx(gpt, "No bootable partition");
return -1;
}
i = m->map_index - 1;
if (set_bootable(gpt, gpt->gpt, gpt->tbl, i) == -1)
return -1;
if (set_bootable(gpt, gpt->tpg, gpt->lbt, i) == -1)
return -1;
if (gpt_write(gpt, mbrmap) == -1) {
gpt_warnx(gpt, "Cannot update Protective MBR");
return -1;
}
gpt_msg(gpt, "Partition %d marked as bootable", i + 1);
return 0;
}
/// clear all entries out of a Map.
void map_clear(Map *m) {
if (root(m) != NULL) {
map_visit(m,map_first(m),(MapCallback)dispose_map_entries,1);
root(m) = NULL;
}
}
int main(int argc, char *argv[]) {
const char *key = "404";
const int values[3] = { 0, 1, 2 };
plan_no_plan();
Map *map = map_new();
ok(map && map_empty(map), "Creation");
ok(map_first(map, &key) == NULL && strcmp(key, "404") == 0, "First on empty map");
ok(map_empty(map_prefix(map, "404")), "Empty prefix map");
ok(!map_get(map, "404"), "Get non-existing key");
ok(!map_contains(map, "404"), "Contains non-existing key");
ok(!map_closest(map, "404") && errno == ENOENT, "Closest non-existing key");
ok(!map_put(map, "a", NULL) && errno == EINVAL && map_empty(map) && !map_get(map, "a"), "Put NULL value");
ok(map_put(map, "a", &values[0]) && !map_empty(map) && get(map, "a", &values[0]), "Put 1");
ok(map_first(map, &key) == &values[0] && strcmp(key, "a") == 0, "First on map with 1 value");
key = NULL;
ok(map_first(map_prefix(map, "a"), &key) == &values[0] && strcmp(key, "a") == 0, "First on prefix map");
ok(map_contains(map, "a"), "Contains existing key");
ok(map_closest(map, "a") == &values[0], "Closest match existing key");
ok(!map_put(map, "a", &values[1]) && errno == EEXIST && get(map, "a", &values[0]), "Put duplicate");
ok(map_put(map, "cafebabe", &values[2]) && get(map, "cafebabe", &values[2]), "Put 2");
ok(map_put(map, "cafe", &values[1]) && get(map, "cafe", &values[1]), "Put 3");
key = NULL;
ok(map_first(map_prefix(map, "cafe"), &key) == &values[1] && strcmp(key, "cafe") == 0, "First on prefix map with multiple suffixes");
Map *copy = map_new();
ok(map_copy(copy, map), "Copy");
ok(!map_empty(copy), "Not empty after copying");
map_iterate(copy, compare, map);
map_iterate(map, compare, copy);
int counter = 0;
map_iterate(copy, once, &counter);
ok(counter == 1, "Iterate stop condition");
ok(!map_get(map, "ca") && !map_closest(map, "ca") && errno == 0, "Closest ambigious");
int visited[] = { 0, 0, 0 };
map_iterate(map, visit, &visited);
ok(visited[0] == 1 && visited[1] == 1 && visited[2] == 1, "Iterate map");
memset(visited, 0, sizeof visited);
order_counter = 0;
map_iterate(map, order, &visited);
ok(visited[0] == 1 && visited[1] == 2 && visited[2] == 3, "Ordered iteration");
memset(visited, 0, sizeof visited);
map_iterate(map_prefix(map, "ca"), visit, &visited);
ok(visited[0] == 0 && visited[1] == 1 && visited[2] == 1, "Iterate sub map");
memset(visited, 0, sizeof visited);
order_counter = 0;
map_iterate(map_prefix(map, "ca"), order, &visited);
ok(visited[0] == 0 && visited[1] == 1 && visited[2] == 2, "Ordered sub map iteration");
ok(map_empty(map_prefix(map, "404")), "Empty map for non-existing prefix");
ok(!map_delete(map, "404"), "Delete non-existing key");
ok(map_delete(map, "cafe") == &values[1] && !map_get(map, "cafe"), "Delete existing key");
ok(map_closest(map, "cafe") == &values[2], "Closest unambigious");
ok(map_put(map, "cafe", &values[1]) && get(map, "cafe", &values[1]), "Put 3 again");
map_clear(map);
ok(map_empty(map), "Empty after clean");
map_free(map);
map_free(copy);
return exit_status();
}
static inline int get_all_mem_ucontacts(void *buf, int len, unsigned int flags,
unsigned int part_idx, unsigned int part_max)
{
dlist_t *p;
urecord_t *r;
ucontact_t *c;
void *cp;
void **dest;
map_iterator_t it;
int shortage;
int needed;
int count;
int i = 0;
cp = buf;
shortage = 0;
/* Reserve space for terminating 0000 */
len -= sizeof(c->c.len);
for (p = root; p != NULL; p = p->next) {
for(i=0; i<p->d->size; i++) {
if ( (i % part_max) != part_idx )
continue;
lock_ulslot( p->d, i);
count = map_size(p->d->table[i].records);
if( count <= 0 )
{
unlock_ulslot(p->d, i);
continue;
}
for ( map_first( p->d->table[i].records, &it);
iterator_is_valid(&it);
iterator_next(&it) ) {
dest = iterator_val(&it);
if( dest == NULL ) {
unlock_ulslot(p->d, i);
return -1;
}
r =( urecord_t * ) *dest;
for (c = r->contacts; c != NULL; c = c->next) {
if (c->c.len <= 0)
continue;
/*
* List only contacts that have all requested
* flags set
*/
if ((c->cflags & flags) != flags)
continue;
if (c->received.s) {
needed = (int)(sizeof(c->received.len)
+ c->received.len + sizeof(c->sock)
+ sizeof(c->cflags) + sizeof(c->path.len)
+ c->path.len);
if (len >= needed) {
memcpy(cp,&c->received.len,sizeof(c->received.len));
cp = (char*)cp + sizeof(c->received.len);
memcpy(cp, c->received.s, c->received.len);
cp = (char*)cp + c->received.len;
memcpy(cp, &c->sock, sizeof(c->sock));
cp = (char*)cp + sizeof(c->sock);
memcpy(cp, &c->cflags, sizeof(c->cflags));
cp = (char*)cp + sizeof(c->cflags);
memcpy(cp, &c->path.len, sizeof(c->path.len));
cp = (char*)cp + sizeof(c->path.len);
memcpy(cp, c->path.s, c->path.len);
cp = (char*)cp + c->path.len;
len -= needed;
} else {
shortage += needed;
}
} else {
needed = (int)(sizeof(c->c.len) + c->c.len +
sizeof(c->sock) + sizeof(c->cflags) +
sizeof(c->path.len) + c->path.len);
if (len >= needed) {
memcpy(cp, &c->c.len, sizeof(c->c.len));
cp = (char*)cp + sizeof(c->c.len);
memcpy(cp, c->c.s, c->c.len);
cp = (char*)cp + c->c.len;
memcpy(cp, &c->sock, sizeof(c->sock));
cp = (char*)cp + sizeof(c->sock);
memcpy(cp, &c->cflags, sizeof(c->cflags));
cp = (char*)cp + sizeof(c->cflags);
memcpy(cp, &c->path.len, sizeof(c->path.len));
cp = (char*)cp + sizeof(c->path.len);
memcpy(cp, c->path.s, c->path.len);
cp = (char*)cp + c->path.len;
len -= needed;
} else {
shortage += needed;
}
}
}
}
unlock_ulslot(p->d, i);
}
}
/* len < 0 is possible, if size of the buffer < sizeof(c->c.len) */
if (len >= 0)
memset(cp, 0, sizeof(c->c.len));
/* Shouldn't happen */
if (shortage > 0 && len > shortage) {
abort();
}
shortage -= len;
return shortage > 0 ? shortage : 0;
}
