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; } }