void test_next_nonEmptyList(void) {
list_t* lista = list_init();
addElement(lista, (void*)a);
addElement(lista, (void*)b);
addElement(lista, (void*)c);
iterator_t* i=iterator_init(lista);
payload_t * corrente = next(i);
CU_ASSERT_PTR_NOT_NULL(corrente);
CU_ASSERT_PTR_EQUAL(corrente, lista->head->payload);
corrente = next(i);
CU_ASSERT_PTR_NOT_NULL(corrente);
CU_ASSERT_PTR_EQUAL(corrente, lista->head->next->payload);
corrente = next(i);
CU_ASSERT_PTR_NOT_NULL(corrente);
CU_ASSERT_PTR_EQUAL(corrente, lista->tail->payload);
corrente = next(i);
CU_ASSERT_PTR_NULL(corrente);
iterator_destroy(i);
list_destroy(lista);
}
iterator iterator_create(id host, id first,
iterator_has_next_t has_next,
iterator_next_t next) {
iterator ret = (iterator) malloc(sizeof (iterator_t));
iterator_init(ret, host, first, has_next, next);
return ret;
}
/** constructor(). */
void stack_link_iter_init(struct stack_link_iter *stack_link_iter, struct stack_link *stack_link)
{
_MY_TRACE_STR("stack_link_iter_init()\n");
memset(stack_link_iter, sizeof(*stack_link_iter), 0);
iterator_init(&stack_link_iter->iterator);
CLASS_OPS_INIT(stack_link_iter->iterator.ops, iterator_ops);
stack_link_iter->_stack_link = stack_link;
}
void test_next_emptyList(void) {
list_t* lista = list_init();
iterator_t* it=iterator_init(lista);
CU_ASSERT_PTR_NULL(next(it));
CU_ASSERT_PTR_NULL(it->currentNode);
iterator_destroy(it);
list_destroy(lista);
}
void test_hasNext_emptyList(void) {
list_t* lista = list_init();
iterator_t* i=iterator_init(lista);
CU_ASSERT_EQUAL(hasNext(i), 0);
iterator_destroy(i);
list_destroy(lista);
}
/**
* Iterate on a NULL terminated array of pointers
*
* @note the avantage of this iterator is that it doesn't need (allocate)
* any additionnal memory for its use. (but keep calling iterator_close for
* one of this kind)
*
* @param it the iterator to initialize
* @param array the array to iterate on
*/
void null_terminated_ptr_array_to_iterator(Iterator *it, void **array)
{
iterator_init(
it, array, NULL,
null_terminated_ptr_array_iterator_first, NULL,
null_terminated_ptr_array_iterator_current,
null_terminated_ptr_array_iterator_next, NULL,
null_terminated_ptr_array_iterator_is_valid,
NULL
);
}
void test_hasNext_nonEmptyList(void) {
list_t* lista = list_init();
addElement(lista, (void*)single);
iterator_t* i=iterator_init(lista);
CU_ASSERT_NOT_EQUAL(hasNext(i), 0);
CU_ASSERT_PTR_EQUAL(i->currentNode, lista->head);
iterator_destroy(i);
list_destroy(lista);
}
void test_iterator_init_destroy(void) {
list_t* list = list_init();
iterator_t* i=iterator_init(list);
CU_ASSERT_PTR_NOT_NULL(i);
CU_ASSERT_PTR_EQUAL(i->list, list);
CU_ASSERT_PTR_EQUAL(i->currentNode, list->head);
iterator_destroy(i);
list_destroy(list);
}
//controla se un messaggio e' presente nella lista
int containsValue(list_t* lista, char* name){
int test = 0;
iterator_t* iterator = iterator_init(lista);
while(hasNext(iterator) && !test){
reader_t* reader =((reader_t*)(iterator->currentNode->payload));
if(strcmp(reader->name, name) == 0)
test = 1;
next(iterator);
}
iterator_destroy(iterator);
return test;
}
void ASSERT_ALL_BUFFER_EQUAL(list_t* list) {
iterator_t* iterator= iterator_init(list);
int dim=size(list);
int i=0;
reader_t* readers[dim];
while(hasNext(iterator)&&i<dim) {
readers[i]=(reader_t*)next(iterator);
i++;
}
for (i=0; i<(dim-1); i++) {
ASSERT_TWO_BUFFER_EQUAL(readers[i]->buffer->read_buffer,readers[i+1]->buffer->read_buffer);
}
}
void test_iterator_init_destroy(){
Vector* vec = vector_init(1);
int *a = NULL, *b = NULL, *c = NULL;
vector_push_back(vec, a);
vector_push_back(vec, b);
vector_push_back(vec, c);
Iterator* it = iterator_init(vec);
assert(it->container == vec);
assert(it->curent == vec->array);
assert(*(it->curent) == a);
iterator_destroy(it);
vector_destroy(vec);
}
int
crack_outguess(char *filename, char *word, void *obj)
{
static u_char oword[57]; /* version 3 marker */
static int init;
static struct arc4_stream as;
static iterator it;
char *buf;
int buflen;
struct arc4_stream tas;
iterator tit;
struct ogobj *ogob = obj;
int changed = 0;
if (strcmp(word, oword)) {
strlcpy(oword, word, sizeof(oword));
changed = 1;
init = 0;
}
if (!init || changed) {
arc4_initkey(&as, word, strlen(word));
iterator_init(&it, &as);
init = 1;
}
tas = as;
tit = it;
if (break_outguess(ogob, &tas, &tit, &buf, &buflen)) {
int i;
extern int noprint;
fprintf(stdout, "%s : outguess[v0.13b](%s)[",
filename, word);
noprint = 0;
file_process(buf, buflen);
noprint = 1;
fprintf(stdout, "][");
for (i = 0; i < 16; i++)
fprintf(stdout, "%c",
isprint(buf[i]) ? buf[i] : '.');
fprintf(stdout, "]\n");
return (1);
}
return (0);
}
/**
* Iterate on an array of struct (or union) where one of its field is sentineled
* by a NULL pointer.
*
* @param it the iterator to initialize
* @param array the array to iterate on
* @param element_size the size of an element of this array
* @param field_offset the offset of the member to test against NULL
* (use offsetof to define it)
*/
void null_sentineled_field_terminated_array_to_iterator(Iterator *it, void *array, size_t element_size, size_t field_offset)
{
nsftas_t *s;
s = malloc(sizeof(*s));
s->ptr = CHAR_P(array);
s->element_size = element_size;
s->field_offset = field_offset;
iterator_init(
it, array, s,
null_sentineled_field_terminated_array_iterator_first, NULL,
null_sentineled_field_terminated_array_iterator_current,
null_sentineled_field_terminated_array_iterator_next, NULL,
null_sentineled_field_terminated_array_iterator_is_valid,
free
);
}
/**
* Iterate on an array of struct (or union) where one of its field is sentineled
* by a NULL pointer.
*
* @param it the iterator to initialize
* @param array the array to iterate on
* @param element_size the size of an element of this array
* @param element_count the number of elements in the array
*/
void array_to_iterator(Iterator *it, void *array, size_t element_size, size_t element_count)
{
as_t *s;
s = malloc(sizeof(*s));
s->ptr = CHAR_P(array);
s->element_size = element_size;
s->element_count = element_count;
iterator_init(
it, array, s,
array_iterator_first, array_iterator_last,
array_iterator_current,
array_iterator_next, array_iterator_prev,
array_iterator_is_valid,
free
);
}
void test_iterator_end(){
Vector* vec = vector_init(1);
int a = 1, b = 2, c = 3, d = 4;
vector_push_back(vec, &a);
vector_push_back(vec, &b);
vector_push_back(vec, &c);
vector_push_back(vec, &d);
Iterator* it = iterator_init(vec);
assert(iterator_element(it) == &a);
iterator_end(it);
assert(iterator_element(it) == &d);
iterator_destroy(it);
vector_destroy(vec);
}
void test_iterator_valid(){
Vector* vec = vector_init(1);
int a = 1, b = 2, c = 3, d = 4;
vector_push_back(vec, &a);
vector_push_back(vec, &b);
vector_push_back(vec, &c);
vector_push_back(vec, &d);
Iterator* it = iterator_init(vec);
assert(iterator_valid(it) == 1);
iterator_before(it);
assert(iterator_valid(it) == 0);
iterator_end(it);
assert(iterator_valid(it) == 1);
iterator_next(it);
assert(iterator_valid(it) == 0);
iterator_destroy(it);
vector_destroy(vec);
}
// global sender initialize (not thread specific)
iterator_t* send_init(void)
{
// generate a new primitive root and starting position
iterator_t *it;
it = iterator_init(zconf.senders, zconf.shard_num, zconf.total_shards);
// process the dotted-notation addresses passed to ZMAP and determine
// the source addresses from which we'll send packets;
srcip_first = inet_addr(zconf.source_ip_first);
if (srcip_first == INADDR_NONE) {
log_fatal("send", "invalid begin source ip address: `%s'",
zconf.source_ip_first);
}
srcip_last = inet_addr(zconf.source_ip_last);
if (srcip_last == INADDR_NONE) {
log_fatal("send", "invalid end source ip address: `%s'",
zconf.source_ip_last);
}
log_debug("send", "srcip_first: %u", srcip_first);
log_debug("send", "srcip_last: %u", srcip_last);
if (srcip_first == srcip_last) {
srcip_offset = 0;
num_src_addrs = 1;
} else {
uint32_t ip_first = ntohl(srcip_first);
uint32_t ip_last = ntohl(srcip_last);
assert(ip_first && ip_last);
assert(ip_last > ip_first);
uint32_t offset = (uint32_t) (aesrand_getword(zconf.aes) & 0xFFFFFFFF);
srcip_offset = offset % (srcip_last - srcip_first);
num_src_addrs = ip_last - ip_first + 1;
}
// process the source port range that ZMap is allowed to use
num_src_ports = zconf.source_port_last - zconf.source_port_first + 1;
log_debug("send", "will send from %i address%s on %u source ports",
num_src_addrs, ((num_src_addrs ==1 ) ? "":"es"),
num_src_ports);
// global initialization for send module
assert(zconf.probe_module);
if (zconf.probe_module->global_initialize) {
zconf.probe_module->global_initialize(&zconf);
}
// concert specified bandwidth to packet rate
if (zconf.bandwidth > 0) {
int pkt_len = zconf.probe_module->packet_length;
pkt_len *= 8;
pkt_len += 8*24; // 7 byte MAC preamble, 1 byte Start frame,
// 4 byte CRC, 12 byte inter-frame gap
if (pkt_len < 84*8) {
pkt_len = 84*8;
}
if (zconf.bandwidth / pkt_len > 0xFFFFFFFF) {
zconf.rate = 0;
} else {
zconf.rate = zconf.bandwidth / pkt_len;
if (zconf.rate == 0) {
log_warn("send", "bandwidth %lu bit/s is slower than 1 pkt/s, "
"setting rate to 1 pkt/s", zconf.bandwidth);
zconf.rate = 1;
}
}
log_debug("send", "using bandwidth %lu bits/s, rate set to %d pkt/s",
zconf.bandwidth, zconf.rate);
}
// Get the source hardware address, and give it to the probe
// module
if (!zconf.hw_mac_set) {
if (get_iface_hw_addr(zconf.iface, zconf.hw_mac)) {
log_fatal("send", "could not retrieve hardware address for "
"interface: %s", zconf.iface);
return NULL;
}
log_debug("send", "no source MAC provided. "
"automatically detected %02x:%02x:%02x:%02x:%02x:%02x as hw "
"interface for %s",
zconf.hw_mac[0], zconf.hw_mac[1], zconf.hw_mac[2],
zconf.hw_mac[3], zconf.hw_mac[4], zconf.hw_mac[5],
zconf.iface);
}
log_debug("send", "source MAC address %02x:%02x:%02x:%02x:%02x:%02x",
zconf.hw_mac[0], zconf.hw_mac[1], zconf.hw_mac[2],
zconf.hw_mac[3], zconf.hw_mac[4], zconf.hw_mac[5]);
if (zconf.dryrun) {
log_info("send", "dryrun mode -- won't actually send packets");
}
// initialize random validation key
validate_init();
zsend.start = now();
return it;
}
