int main(void)
{
slist a, b;
snode *x, *y;
siterator i, j;
s_init_list(&a);
s_init_list(&b);
x = xmalloc(sizeof(*x));
s_add_tail(&a, x);
x = xmalloc(sizeof(*x));
s_add_tail(&a, x);
x = xmalloc(sizeof(*x));
s_add_tail(&a, x);
dump("1", &a);
s_init(&i, &a);
s_init(&j, &a);
dump("2", &a);
x = s_get(&i);
printf("Got %p\n", x);
dump("3", &a);
s_put(&i, x->next);
dump("4", &a);
y = s_get(&j);
while (y)
{
s_put(&j, y);
dump("5*", &a);
y = s_get(&j)->next;
}
dump("5 done", &a);
s_rem_node(a.head->next);
dump("6 (deletion)", &a);
s_put(&i, s_get(&i)->next);
dump("6 (relink)", &a);
x = xmalloc(sizeof(*x));
s_add_tail(&b, x);
dump("7 (second list)", &b);
s_add_tail_list(&b, &a);
dump("8 (after merge)", &b);
return 0;
}
int main(int argc, char **argv)
{
HC_DEF_S(s);
s_catz(s, "hello world of possibilities!");
HC_SAFE_CSTR(s);
fprintf(stdout, "[%i][%i][%s]\n", s->len, s->a, s->s);
s->len = 0; /* truncate string */
s_catn(s, "hi ", 3);
fwrite(s->s, s->len, 1, stdout);
s_copyc(s, 'f');
s_catz(s, "olk");
s_catc(s, 's');
s_catc(s, '!');
s_catc(s, '\n');
fwrite(s->s, s->len, 1, stdout);
s_upper(s);
fwrite(s->s, s->len, 1, stdout);
s_lower(s);
fwrite(s->s, s->len, 1, stdout);
s_copyz(s, "aa");
assert(sdiff("aa", "aa") == 0);
assert(s_diffz(s, "aa") == 0);
assert(s_diffn(s, "aa", slen("aa")) == 0);
assert(sdiff("aa", "aaz") < 0);
assert(s_diffz(s, "aaz") < 0);
assert(s_diffn(s, "aaz", slen("aaz")) < 0);
assert(sdiff("aa", "a0z") > 0);
assert(s_diffz(s, "a0z") > 0);
assert(s_diffn(s, "a0z", slen("a0z")) > 0);
assert(sdiff("aa", "0") > 0);
assert(s_diffz(s, "0") > 0);
assert(s_diffn(s, "0", slen("0")) > 0);
assert(sdiff("aa", "0zz") > 0);
assert(s_diffz(s, "0zz") > 0);
assert(s_diffn(s, "0zz", slen("0zz")) > 0);
assert(sdiff("aa", "a") > 0);
assert(s_diffz(s, "a") > 0);
assert(s_diffn(s, "a", slen("a")) > 0);
assert(sdiff("aa", "a0") > 0);
assert(s_diffz(s, "a0") > 0);
assert(s_diffn(s, "a0", slen("a0")) > 0);
s_free(s);
/*
*/
assert(s_cat_u4_hex(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_hex(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_u4_hex(s, 0xffffffff) == 8);
assert(s_diffz(s, "ffffffff") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_hex(s, (int32_t)0xffffffff) == 2);
assert(s_diffz(s, "-1") == 0);
print_s("[", s, "]\n");
s_free(s);
/*
*/
assert(s_cat_u4_dec(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_dec(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_u4_dec(s, 0xffffffff) == 10);
assert(s_diffz(s, "4294967295") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_dec(s, (int32_t)0xffffffff) == 2);
assert(s_diffz(s, "-1") == 0);
print_s("[", s, "]\n");
s_free(s);
/*
*/
assert(s_cat_u4_base36(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_base36(s, 0) == 1);
assert(s_diffz(s, "0") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_u4_base36(s, 0xffffffff) == 7);
assert(s_diffz(s, "1z141z3") == 0);
print_s("[", s, "]\n");
s->len = 0;
assert(s_cat_i4_base36(s, (int32_t)0xffffffff) == 2);
assert(s_diffz(s, "-1") == 0);
print_s("[", s, "]\n");
s_free(s);
/*
*/
{
void *out;
int putlen;
HC_DEF_S(t);
s_copyz(s, "hello world of possibilities!");
putlen = s_putlen(s);
HC_ALLOC(out, putlen);
assert(s_put(s, out) == putlen);
assert(s_get(t, out) == putlen);
assert(s_diff(s, t) == 0);
s->len = 0;
s_reprn(s, out, putlen);
print_s("[", s, "]\n");
HC_FREE(out);
s_free(t);
}
/*
*/
s_free(s);
return 0;
}
static void
ospf_prepare_dbdes(struct ospf_proto *p, struct ospf_neighbor *n)
{
struct ospf_iface *ifa = n->ifa;
struct ospf_packet *pkt;
uint length;
u16 iface_mtu = (ifa->type == OSPF_IT_VLINK) ? 0 : ifa->iface->mtu;
/* Update DBDES buffer */
if (n->ldd_bsize != ifa->tx_length)
{
mb_free(n->ldd_buffer);
n->ldd_buffer = mb_allocz(n->pool, ifa->tx_length);
n->ldd_bsize = ifa->tx_length;
}
pkt = n->ldd_buffer;
ospf_pkt_fill_hdr(ifa, pkt, DBDES_P);
if (ospf_is_v2(p))
{
struct ospf_dbdes2_packet *ps = (void *) pkt;
ps->iface_mtu = htons(iface_mtu);
ps->options = ifa->oa->options;
ps->imms = 0; /* Will be set later */
ps->ddseq = htonl(n->dds);
length = sizeof(struct ospf_dbdes2_packet);
}
else /* OSPFv3 */
{
struct ospf_dbdes3_packet *ps = (void *) pkt;
ps->options = htonl(ifa->oa->options);
ps->iface_mtu = htons(iface_mtu);
ps->padding = 0;
ps->imms = 0; /* Will be set later */
ps->ddseq = htonl(n->dds);
length = sizeof(struct ospf_dbdes3_packet);
}
/* Prepare DBDES body */
if (!(n->myimms & DBDES_I) && (n->myimms & DBDES_M))
{
struct ospf_lsa_header *lsas;
struct top_hash_entry *en;
uint i = 0, lsa_max;
ospf_dbdes_body(p, pkt, &lsas, &lsa_max);
en = (void *) s_get(&(n->dbsi));
while (i < lsa_max)
{
if (!SNODE_VALID(en))
{
n->myimms &= ~DBDES_M; /* Unset More bit */
break;
}
if ((en->lsa.age < LSA_MAXAGE) &&
lsa_flooding_allowed(en->lsa_type, en->domain, ifa))
{
lsa_hton_hdr(&(en->lsa), lsas + i);
i++;
}
en = SNODE_NEXT(en);
}
s_put(&(n->dbsi), SNODE en);
length += i * sizeof(struct ospf_lsa_header);
}
if (ospf_is_v2(p))
((struct ospf_dbdes2_packet *) pkt)->imms = n->myimms;
else
((struct ospf_dbdes3_packet *) pkt)->imms = n->myimms;
pkt->length = htons(length);
}
rt_private EIF_BOOLEAN rdeepiso(EIF_REFERENCE target,EIF_REFERENCE source)
{
/* Recursive isomorphism test.
* Return a boolean.
*/
RT_GET_CONTEXT
union overhead *zone = HEADER(target); /* Target header */
uint32 flags; /* Target flags */
EIF_REFERENCE s_ref, t_ref, t_field, s_field;
EIF_INTEGER count, elem_size;
flags = zone->ov_flags;
/* Check if the object has already been inspected */
if (s_put(eif_equality_table, target) == EIF_SEARCH_CONFLICT)
return EIF_TRUE;
/* Isomorphism test between `source' and `target'.
* Two cases: either a normal object or a special object.
*/
if (flags & EO_SPEC) {
/* Special or tuple objects */
if (!spiso(target, source))
return EIF_FALSE;
if (!(flags & EO_REF))
/* No reference to inspect */
return EIF_TRUE;
/* Evaluation of the count of the target special object */
count = RT_SPECIAL_COUNT(target);
if (flags & EO_TUPLE) {
EIF_TYPED_VALUE * l_source = (EIF_TYPED_VALUE *) source;
EIF_TYPED_VALUE * l_target = (EIF_TYPED_VALUE *) target;
/* Don't forget that first element of TUPLE is the BOOLEAN
* `object_comparison' attribute. */
for (; count > 0; count--, l_source++, l_target++) {
if
(eif_is_reference_tuple_item(l_source) &&
eif_is_reference_tuple_item(l_target))
{
s_field = eif_reference_tuple_item (l_source);
t_field = eif_reference_tuple_item (l_target);
if ((s_field == NULL) && (t_field == NULL)) {
continue;
} else if ((s_field) && (t_field)) {
if (!rdeepiso(t_field, s_field)) {
return EIF_FALSE;
}
} else {
return EIF_FALSE;
}
}
}
return EIF_TRUE;
} else if (!(flags & EO_COMP)) {
CHECK("Special of reference", flags & EO_REF);
/* Specials filled with references: we have to iterate on fields
* two by two.
*/
/* Evaluation of the count of the target special object */
for(
s_ref = (EIF_REFERENCE)source, t_ref = (EIF_REFERENCE) target;
count > 0;
count --,
s_ref = (EIF_REFERENCE) ((EIF_REFERENCE *) s_ref + 1),
t_ref = (EIF_REFERENCE) ((EIF_REFERENCE *) t_ref + 1)
) {
/* Evaluation of two references */
s_field = *(EIF_REFERENCE *) s_ref;
t_field = *(EIF_REFERENCE *) t_ref;
if ((((EIF_REFERENCE) 0) == s_field) && (((EIF_REFERENCE) 0) == t_field))
/* Two void references */
continue;
else if ((EIF_REFERENCE) 0 != s_field && (EIF_REFERENCE) 0 != t_field) {
/* Recursion on references of the special object */
if (!rdeepiso(t_field, s_field))
return EIF_FALSE;
} else
return EIF_FALSE;
}
return EIF_TRUE;
} else {
CHECK("Special of expanded with references", flags & EO_REF);
/* Special objects filled with (non-special) expanded objects.
* we call then standard isomorphism test on normal objects.
*/
elem_size = RT_SPECIAL_ELEM_SIZE(target);
for (
s_ref = source+OVERHEAD, t_ref = target+OVERHEAD;
count > 0;
count--, s_ref += elem_size, t_ref += elem_size
) {
/* Iteration on expanded elements which cannot be special
* objects
*/
if (!(rdeepiter(t_ref, s_ref)))
return EIF_FALSE;
}
return EIF_TRUE;
}
} else {
/* Normal object */
if (!eiso(target, source))
return EIF_FALSE;
/* Iteration on references */
return rdeepiter(target, source);
}
/* NOTREACHED */
return EIF_FALSE;
}
/**
* ospf_dbdes_send - transmit database description packet
* @n: neighbor
* @next: whether to send a next packet in a sequence (1) or to retransmit the old one (0)
*
* Sending of a database description packet is described in 10.8 of RFC 2328.
* Reception of each packet is acknowledged in the sequence number of another.
* When I send a packet to a neighbor I keep a copy in a buffer. If the neighbor
* does not reply, I don't create a new packet but just send the content
* of the buffer.
*/
void
ospf_dbdes_send(struct ospf_neighbor *n, int next)
{
struct ospf_dbdes_packet *pkt;
struct ospf_packet *op;
struct ospf_iface *ifa = n->ifa;
struct ospf_area *oa = ifa->oa;
struct proto_ospf *po = oa->po;
struct proto *p = &po->proto;
u16 length, i, j;
/* FIXME ??? */
if ((oa->rt == NULL) || (EMPTY_LIST(po->lsal)))
update_rt_lsa(oa);
switch (n->state)
{
case NEIGHBOR_EXSTART: /* Send empty packets */
n->myimms.bit.i = 1;
pkt = ospf_tx_buffer(ifa);
op = &pkt->ospf_packet;
ospf_pkt_fill_hdr(ifa, pkt, DBDES_P);
pkt->iface_mtu = (ifa->type == OSPF_IT_VLINK) ? 0 : htons(ifa->iface->mtu);
pkt->options = hton_opt(oa->options);
pkt->imms = n->myimms;
pkt->ddseq = htonl(n->dds);
length = sizeof(struct ospf_dbdes_packet);
op->length = htons(length);
OSPF_PACKET(ospf_dump_dbdes, pkt, "DBDES packet sent to %I via %s", n->ip, ifa->iface->name);
ospf_send_to(ifa, n->ip);
break;
case NEIGHBOR_EXCHANGE:
n->myimms.bit.i = 0;
if (next)
{
snode *sn;
struct ospf_lsa_header *lsa;
pkt = n->ldbdes;
op = (struct ospf_packet *) pkt;
ospf_pkt_fill_hdr(ifa, pkt, DBDES_P);
pkt->iface_mtu = (ifa->type == OSPF_IT_VLINK) ? 0 : htons(ifa->iface->mtu);
pkt->ddseq = htonl(n->dds);
pkt->options = hton_opt(oa->options);
j = i = (ospf_pkt_maxsize(ifa) - sizeof(struct ospf_dbdes_packet)) / sizeof(struct ospf_lsa_header); /* Number of possible lsaheaders to send */
lsa = (n->ldbdes + sizeof(struct ospf_dbdes_packet));
if (n->myimms.bit.m)
{
sn = s_get(&(n->dbsi));
DBG("Number of LSA: %d\n", j);
for (; i > 0; i--)
{
struct top_hash_entry *en= (struct top_hash_entry *) sn;
if (ospf_lsa_flooding_allowed(&en->lsa, en->domain, ifa))
{
htonlsah(&(en->lsa), lsa);
DBG("Working on: %d\n", i);
DBG("\tX%01x %-1R %-1R %p\n", en->lsa.type, en->lsa.id, en->lsa.rt, en->lsa_body);
lsa++;
}
else i++; /* No lsa added */
if (sn == STAIL(po->lsal))
{
i--;
break;
}
sn = sn->next;
}
if (sn == STAIL(po->lsal))
{
DBG("Number of LSA NOT sent: %d\n", i);
DBG("M bit unset.\n");
n->myimms.bit.m = 0; /* Unset more bit */
}
s_put(&(n->dbsi), sn);
}
pkt->imms.byte = n->myimms.byte;
length = (j - i) * sizeof(struct ospf_lsa_header) +
sizeof(struct ospf_dbdes_packet);
op->length = htons(length);
DBG("%s: DB_DES (M) prepared for %I.\n", p->name, n->ip);
}
case NEIGHBOR_LOADING:
case NEIGHBOR_FULL:
length = ntohs(((struct ospf_packet *) n->ldbdes)->length);
if (!length)
{
OSPF_TRACE(D_PACKETS, "No packet in my buffer for repeating");
ospf_neigh_sm(n, INM_KILLNBR);
return;
}
/* Copy last sent packet again */
pkt = ospf_tx_buffer(ifa);
memcpy(pkt, n->ldbdes, length);
OSPF_PACKET(ospf_dump_dbdes, pkt, "DBDES packet sent to %I via %s", n->ip, ifa->iface->name);
ospf_send_to(ifa, n->ip);
if(n->myimms.bit.ms) tm_start(n->rxmt_timer, n->ifa->rxmtint); /* Restart timer */
if (!n->myimms.bit.ms)
{
if ((n->myimms.bit.m == 0) && (n->imms.bit.m == 0) &&
(n->state == NEIGHBOR_EXCHANGE))
{
ospf_neigh_sm(n, INM_EXDONE);
}
}
break;
default: /* Ignore it */
break;
}
}
