void* job_pool_new(uint32_t jobs) {
int fd[2];
uint32_t i;
jobpool* jp;
if (pipe(fd)<0) {
return NULL;
}
jp=malloc(sizeof(jobpool));
passert(jp);
// syslog(LOG_WARNING,"new pool of workers (%p:%"PRIu8")",(void*)jp,workers);
jp->rpipe = fd[0];
jp->wpipe = fd[1];
jp->workers_avail = 0;
jp->workers_total = 0;
jp->workers_term_waiting = 0;
zassert(pthread_cond_init(&(jp->worker_term_cond),NULL));
zassert(pthread_mutex_init(&(jp->pipelock),NULL));
zassert(pthread_mutex_init(&(jp->jobslock),NULL));
jp->jobqueue = queue_new(jobs);
// syslog(LOG_WARNING,"new jobqueue: %p",jp->jobqueue);
jp->statusqueue = queue_new(0);
for (i=0 ; i<JHASHSIZE ; i++) {
jp->jobhash[i]=NULL;
}
jp->nextjobid = 1;
zassert(pthread_mutex_lock(&(jp->jobslock)));
job_spawn_worker(jp);
zassert(pthread_mutex_unlock(&(jp->jobslock)));
return jp;
}
static RSA*
rsa_genkey(u32 size)
{
zassert(size >= DNSSEC_MINIMUM_KEY_SIZE && size <= DNSSEC_MAXIMUM_KEY_SIZE);
BN_CTX *ctx;
BIGNUM *e;
RSA* rsa;
ctx = BN_CTX_new();
zassert(ctx != NULL);
e = BN_new();
BN_set_word(e, 0x10001);
zassert(e != NULL);
rsa = RSA_new();
zassert(rsa != NULL);
int err = RSA_generate_key_ex(rsa, size, e, NULL); /* no callback */
if(err == 0)
{
RSA_free(rsa);
rsa = NULL;
}
BN_free(e);
BN_CTX_free(ctx);
return rsa;
}
/*
See also pim_upstream_evaluate_join_desired() above.
*/
void pim_upstream_update_join_desired(struct pim_upstream *up)
{
int was_join_desired; /* boolean */
int is_join_desired; /* boolean */
was_join_desired = PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED(up->flags);
is_join_desired = pim_upstream_evaluate_join_desired(up);
if (is_join_desired)
PIM_UPSTREAM_FLAG_SET_DR_JOIN_DESIRED(up->flags);
else
PIM_UPSTREAM_FLAG_UNSET_DR_JOIN_DESIRED(up->flags);
/* switched from false to true */
if (is_join_desired && !was_join_desired) {
zassert(up->join_state == PIM_UPSTREAM_NOTJOINED);
pim_upstream_switch(up, PIM_UPSTREAM_JOINED);
return;
}
/* switched from true to false */
if (!is_join_desired && was_join_desired) {
zassert(up->join_state == PIM_UPSTREAM_JOINED);
pim_upstream_switch(up, PIM_UPSTREAM_NOTJOINED);
return;
}
}
int main_minthread_create(pthread_t *th,uint8_t detached,void *(*fn)(void *),void *arg) {
static pthread_attr_t *thattr = NULL;
static uint8_t thattr_detached;
if (thattr == NULL) {
size_t mystacksize;
thattr = malloc(sizeof(pthread_attr_t));
passert(thattr);
zassert(pthread_attr_init(thattr));
#ifdef PTHREAD_STACK_MIN
mystacksize = PTHREAD_STACK_MIN;
if (mystacksize < 0x100000) {
mystacksize = 0x100000;
}
#else
mystacksize = 0x100000;
#endif
zassert(pthread_attr_setstacksize(thattr,mystacksize));
thattr_detached = detached + 1; // make it different
}
if (detached != thattr_detached) {
if (detached) {
zassert(pthread_attr_setdetachstate(thattr,PTHREAD_CREATE_DETACHED));
} else {
zassert(pthread_attr_setdetachstate(thattr,PTHREAD_CREATE_JOINABLE));
}
thattr_detached = detached;
}
return main_thread_create(th,thattr,fn,arg);
}
void igmp_group_delete_empty_include(struct igmp_group *group)
{
zassert(!group->group_filtermode_isexcl);
zassert(!listcount(group->group_source_list));
igmp_group_delete(group);
}
static int pim_igmp_other_querier_expire(struct thread *t)
{
struct igmp_sock *igmp;
zassert(t);
igmp = THREAD_ARG(t);
zassert(igmp);
zassert(igmp->t_other_querier_timer);
zassert(!igmp->t_igmp_query_timer);
if (PIM_DEBUG_IGMP_TRACE) {
char ifaddr_str[100];
pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
zlog_debug("%s: Querier %s resuming",
__PRETTY_FUNCTION__,
ifaddr_str);
}
igmp->t_other_querier_timer = 0;
/*
We are the current querier, then
re-start sending general queries.
*/
pim_igmp_general_query_on(igmp);
return 0;
}
void* groups_cleanup_thread(void* arg) {
static uint32_t h = 0;
uint32_t i;
double t;
groups *g,*gn;
int ka = 1;
while (ka) {
zassert(pthread_mutex_lock(&glock));
t = monotonic_seconds();
for (i=0 ; i<16 ; i++) {
for (g = groups_hashtab[h] ; g!=NULL ; g = gn) {
gn = g->next;
if (g->time + to < t && g->locked==0 && g->lcnt==0) {
groups_remove(g);
}
}
h++;
h%=HASHSIZE;
}
ka = keep_alive;
zassert(pthread_mutex_unlock(&glock));
portable_usleep(10000);
}
return arg;
}
static void pim_assert_timer_set(struct pim_ifchannel *ch,
int interval)
{
struct interface *ifp;
zassert(ch);
ifp = ch->interface;
zassert(ifp);
assert_timer_off(ch);
if (PIM_DEBUG_PIM_TRACE) {
char src_str[100];
char grp_str[100];
pim_inet4_dump("<src?>", ch->source_addr, src_str, sizeof(src_str));
pim_inet4_dump("<grp?>", ch->group_addr, grp_str, sizeof(grp_str));
zlog_debug("%s: (S,G)=(%s,%s) starting %u sec timer on interface %s",
__PRETTY_FUNCTION__,
src_str, grp_str, interval, ifp->name);
}
THREAD_TIMER_ON(master, ch->t_ifassert_timer,
on_assert_timer,
ch, interval);
}
void groups_rel(groups* g) {
zassert(pthread_mutex_lock(&glock));
if (g->lcnt>0) {
g->lcnt--;
}
zassert(pthread_mutex_unlock(&glock));
}
static int on_neighbor_timer(struct thread *t)
{
struct pim_neighbor *neigh;
struct interface *ifp;
char msg[100];
zassert(t);
neigh = THREAD_ARG(t);
zassert(neigh);
ifp = neigh->interface;
if (PIM_DEBUG_PIM_TRACE) {
char src_str[100];
pim_inet4_dump("<src?>", neigh->source_addr, src_str, sizeof(src_str));
zlog_debug("Expired %d sec holdtime for neighbor %s on interface %s",
neigh->holdtime, src_str, ifp->name);
}
neigh->t_expire_timer = 0;
snprintf(msg, sizeof(msg), "%d-sec holdtime expired", neigh->holdtime);
pim_neighbor_delete(ifp, neigh, msg);
/*
RFC 4601: 4.3.2. DR Election
A router's idea of the current DR on an interface can change when a
PIM Hello message is received, when a neighbor times out, or when a
router's own DR Priority changes.
*/
pim_if_dr_election(ifp); // neighbor times out
return 0;
}
int queue_tryput(void *que,uint32_t id,uint32_t op,uint8_t *data,uint32_t leng) {
queue *q = (queue*)que;
qentry *qe;
zassert(pthread_mutex_lock(&(q->lock)));
if (q->maxsize) {
if (leng>q->maxsize) {
zassert(pthread_mutex_unlock(&(q->lock)));
errno = EDEADLK;
return -1;
}
if (q->size+leng>q->maxsize) {
zassert(pthread_mutex_unlock(&(q->lock)));
errno = EBUSY;
return -1;
}
}
qe = malloc(sizeof(qentry));
passert(qe);
qe->id = id;
qe->op = op;
qe->data = data;
qe->leng = leng;
qe->next = NULL;
q->elements++;
q->size += leng;
*(q->tail) = qe;
q->tail = &(qe->next);
if (q->freewaiting>0) {
zassert(pthread_cond_signal(&(q->waitfree)));
q->freewaiting--;
}
zassert(pthread_mutex_unlock(&(q->lock)));
return 0;
}
static int hello_send(struct interface *ifp,
uint16_t holdtime)
{
uint8_t pim_msg[PIM_PIM_BUFSIZE_WRITE];
struct pim_interface *pim_ifp;
int pim_tlv_size;
int pim_msg_size;
pim_ifp = ifp->info;
if (PIM_DEBUG_PIM_HELLO) {
char dst_str[100];
pim_inet4_dump("<dst?>", qpim_all_pim_routers_addr, dst_str, sizeof(dst_str));
zlog_debug("%s: to %s on %s: holdt=%u prop_d=%u overr_i=%u dis_join_supp=%d dr_prio=%u gen_id=%08x addrs=%d",
__PRETTY_FUNCTION__,
dst_str, ifp->name,
holdtime,
pim_ifp->pim_propagation_delay_msec, pim_ifp->pim_override_interval_msec,
PIM_IF_TEST_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options),
pim_ifp->pim_dr_priority, pim_ifp->pim_generation_id,
listcount(ifp->connected));
}
pim_tlv_size = pim_hello_build_tlv(ifp->name,
pim_msg + PIM_PIM_MIN_LEN,
sizeof(pim_msg) - PIM_PIM_MIN_LEN,
holdtime,
pim_ifp->pim_dr_priority,
pim_ifp->pim_generation_id,
pim_ifp->pim_propagation_delay_msec,
pim_ifp->pim_override_interval_msec,
PIM_IF_TEST_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options),
ifp->connected);
if (pim_tlv_size < 0) {
return -1;
}
pim_msg_size = pim_tlv_size + PIM_PIM_MIN_LEN;
zassert(pim_msg_size >= PIM_PIM_MIN_LEN);
zassert(pim_msg_size <= PIM_PIM_BUFSIZE_WRITE);
pim_msg_build_header(pim_msg, pim_msg_size,
PIM_MSG_TYPE_HELLO);
if (pim_msg_send(pim_ifp->pim_sock_fd,
qpim_all_pim_routers_addr,
pim_msg,
pim_msg_size,
ifp->name)) {
if (PIM_DEBUG_PIM_HELLO) {
zlog_debug("%s: could not send PIM message on interface %s",
__PRETTY_FUNCTION__, ifp->name);
}
return -2;
}
return 0;
}
void pim_zebra_init (struct thread_master *master, char *zebra_sock_path)
{
int i;
if (zebra_sock_path)
zclient_serv_path_set(zebra_sock_path);
#ifdef HAVE_TCP_ZEBRA
zlog_notice("zclient update contacting ZEBRA daemon at socket TCP %s,%d", "127.0.0.1", ZEBRA_PORT);
#else
zlog_notice("zclient update contacting ZEBRA daemon at socket UNIX %s", zclient_serv_path_get());
#endif
/* Socket for receiving updates from Zebra daemon */
qpim_zclient_update = zclient_new (master);
qpim_zclient_update->zebra_connected = pim_zebra_connected;
qpim_zclient_update->router_id_update = pim_router_id_update_zebra;
qpim_zclient_update->interface_add = pim_zebra_if_add;
qpim_zclient_update->interface_delete = pim_zebra_if_del;
qpim_zclient_update->interface_up = pim_zebra_if_state_up;
qpim_zclient_update->interface_down = pim_zebra_if_state_down;
qpim_zclient_update->interface_address_add = pim_zebra_if_address_add;
qpim_zclient_update->interface_address_delete = pim_zebra_if_address_del;
qpim_zclient_update->ipv4_route_add = redist_read_ipv4_route;
qpim_zclient_update->ipv4_route_delete = redist_read_ipv4_route;
zclient_init(qpim_zclient_update, ZEBRA_ROUTE_PIM);
if (PIM_DEBUG_PIM_TRACE) {
zlog_info("zclient_init cleared redistribution request");
}
zassert(qpim_zclient_update->redist_default == ZEBRA_ROUTE_PIM);
/* Request all redistribution */
for (i = 0; i < ZEBRA_ROUTE_MAX; i++) {
if (i == qpim_zclient_update->redist_default)
continue;
vrf_bitmap_set(qpim_zclient_update->redist[i], VRF_DEFAULT);
if (PIM_DEBUG_PIM_TRACE) {
zlog_debug("%s: requesting redistribution for %s (%i)",
__PRETTY_FUNCTION__, zebra_route_string(i), i);
}
}
/* Request default information */
vrf_bitmap_set(qpim_zclient_update->default_information, VRF_DEFAULT);
if (PIM_DEBUG_PIM_TRACE) {
zlog_info("%s: requesting default information redistribution",
__PRETTY_FUNCTION__);
zlog_notice("%s: zclient update socket initialized",
__PRETTY_FUNCTION__);
}
zassert(!qpim_zclient_lookup);
qpim_zclient_lookup = zclient_lookup_new();
zassert(qpim_zclient_lookup);
}
void dcache_invalidate_attr(uint32_t inode) {
dircache *d;
zassert(pthread_mutex_lock(&glock));
for (d=head ; d ; d=d->next) {
dcache_inodehash_invalidate_attr(d,inode);
}
zassert(pthread_mutex_unlock(&glock));
}
void dcache_setattr(uint32_t inode,const uint8_t attr[35]) {
dircache *d;
zassert(pthread_mutex_lock(&glock));
for (d=head ; d ; d=d->next) {
dcache_inodehash_set(d,inode,attr);
}
zassert(pthread_mutex_unlock(&glock));
}
int queue_isfull(void *que) {
queue *q = (queue*)que;
int r;
zassert(pthread_mutex_lock(&(q->lock)));
r = (q->maxsize>0 && q->maxsize<=q->size)?1:0;
zassert(pthread_mutex_unlock(&(q->lock)));
return r;
}
uint32_t queue_elements(void *que) {
queue *q = (queue*)que;
uint32_t r;
zassert(pthread_mutex_lock(&(q->lock)));
r=q->elements;
zassert(pthread_mutex_unlock(&(q->lock)));
return r;
}
int queue_isempty(void *que) {
queue *q = (queue*)que;
int r;
zassert(pthread_mutex_lock(&(q->lock)));
r=(q->elements==0)?1:0;
zassert(pthread_mutex_unlock(&(q->lock)));
return r;
}
uint32_t job_pool_jobs_count(void) {
jobpool* jp = globalpool;
uint32_t res;
zassert(pthread_mutex_lock(&(jp->jobslock)));
res = (jp->workers_total - jp->workers_avail) + queue_elements(jp->jobqueue);
zassert(pthread_mutex_unlock(&(jp->jobslock)));
return res;
}
/* Issue IGMP general query */
static int pim_igmp_general_query(struct thread *t)
{
char query_buf[PIM_IGMP_BUFSIZE_WRITE];
struct igmp_sock *igmp;
struct in_addr dst_addr;
struct in_addr group_addr;
struct pim_interface *pim_ifp;
zassert(t);
igmp = THREAD_ARG(t);
zassert(igmp);
zassert(igmp->interface);
zassert(igmp->interface->info);
pim_ifp = igmp->interface->info;
/*
RFC3376: 4.1.12. IP Destination Addresses for Queries
In IGMPv3, General Queries are sent with an IP destination address
of 224.0.0.1, the all-systems multicast address. Group-Specific
and Group-and-Source-Specific Queries are sent with an IP
destination address equal to the multicast address of interest.
*/
dst_addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
group_addr.s_addr = PIM_NET_INADDR_ANY;
if (PIM_DEBUG_IGMP_TRACE) {
char querier_str[100];
char dst_str[100];
pim_inet4_dump("<querier?>", igmp->ifaddr, querier_str,
sizeof(querier_str));
pim_inet4_dump("<dst?>", dst_addr, dst_str, sizeof(dst_str));
zlog_debug("Querier %s issuing IGMP general query to %s on %s",
querier_str, dst_str, igmp->interface->name);
}
pim_igmp_send_membership_query(0 /* igmp_group */,
igmp->fd,
igmp->interface->name,
query_buf,
sizeof(query_buf),
0 /* num_sources */,
dst_addr,
group_addr,
pim_ifp->igmp_query_max_response_time_dsec,
1 /* s_flag: always set for general queries */,
igmp->querier_robustness_variable,
igmp->querier_query_interval);
pim_igmp_general_query_on(igmp);
return 0;
}
static inline void mainserv_bytesin(uint64_t bytes) {
#ifdef HAVE___SYNC_FETCH_AND_OP
__sync_fetch_and_add(&stats_bytesin,bytes);
#else
zassert(pthread_mutex_lock(&statslock));
stats_bytesin += bytes;
zassert(pthread_mutex_unlock(&statslock));
#endif
}
static inline void job_send_status(jobpool *jp,uint32_t jobid,uint8_t status) {
zassert(pthread_mutex_lock(&(jp->pipelock)));
if (queue_isempty(jp->statusqueue)) { // first status
eassert(write(jp->wpipe,&status,1)==1); // write anything to wake up select
}
queue_put(jp->statusqueue,jobid,status,NULL,1);
zassert(pthread_mutex_unlock(&(jp->pipelock)));
return;
}
void ep_init(void) {
ep_head = NULL;
ep_tail = &(ep_head);
ep_unused = NULL;
ep_unused_cnt = 0;
zassert(pthread_mutex_init(&ep_lock,NULL));
zassert(pthread_cond_init(&ep_cond,NULL));
lwt_minthread_create(&ep_worker,0,ep_thread,NULL);
}
void pim_ssmpingd_init()
{
int result;
zassert(!qpim_ssmpingd_list);
result = inet_pton(AF_INET, PIM_SSMPINGD_REPLY_GROUP, &qpim_ssmpingd_group_addr);
zassert(result > 0);
}
int pim_if_lan_delay_enabled(struct interface *ifp)
{
struct pim_interface *pim_ifp;
pim_ifp = ifp->info;
zassert(pim_ifp);
zassert(pim_ifp->pim_number_of_nonlandelay_neighbors >= 0);
return pim_ifp->pim_number_of_nonlandelay_neighbors == 0;
}
void ep_fleng_has_changed(uint32_t inode,uint64_t fleng) {
extra_packets *ep;
zassert(pthread_mutex_lock(&ep_lock));
ep = ep_get_packet();
ep->cmd = FLENG_CHANGED;
ep->inode = inode;
ep->fleng = fleng;
ep_append_packet(ep);
zassert(pthread_mutex_unlock(&ep_lock));
}
void dcache_invalidate_name(const struct fuse_ctx *ctx,uint32_t parent,uint8_t nleng,const uint8_t *name) {
dircache *d;
zassert(pthread_mutex_lock(&glock));
for (d=head ; d ; d=d->next) {
if (parent==d->parent && ctx->pid==d->ctx.pid && ctx->uid==d->ctx.uid && ctx->gid==d->ctx.gid) {
dcache_namehash_invalidate(d,nleng,name);
}
}
zassert(pthread_mutex_unlock(&glock));
}
void pim_if_delete(struct interface *ifp)
{
struct pim_interface *pim_ifp;
zassert(ifp);
pim_ifp = ifp->info;
zassert(pim_ifp);
if (pim_ifp->igmp_join_list) {
pim_if_igmp_join_del_all(ifp);
}
zassert(!pim_ifp->igmp_join_list);
zassert(pim_ifp->igmp_socket_list);
zassert(!listcount(pim_ifp->igmp_socket_list));
zassert(pim_ifp->pim_neighbor_list);
zassert(!listcount(pim_ifp->pim_neighbor_list));
zassert(pim_ifp->pim_ifchannel_list);
zassert(!listcount(pim_ifp->pim_ifchannel_list));
if (PIM_MROUTE_IS_ENABLED) {
pim_if_del_vif(ifp);
}
list_delete(pim_ifp->igmp_socket_list);
list_delete(pim_ifp->pim_neighbor_list);
list_delete(pim_ifp->pim_ifchannel_list);
XFREE(MTYPE_PIM_INTERFACE, pim_ifp);
ifp->info = 0;
}
void igmp_anysource_forward_start(struct igmp_group *group)
{
/* Any source (*,G) is forwarded only if mode is EXCLUDE {empty} */
zassert(group->group_filtermode_isexcl);
zassert(listcount(group->group_source_list) < 1);
if (PIM_DEBUG_IGMP_TRACE) {
zlog_debug("%s %s: UNIMPLEMENTED",
__FILE__, __PRETTY_FUNCTION__);
}
}
void pim_ssmpingd_init(struct pim_instance *pim)
{
int result;
zassert(!pim->ssmpingd_list);
result = inet_pton(AF_INET, PIM_SSMPINGD_REPLY_GROUP,
&pim->ssmpingd_group_addr);
zassert(result > 0);
}
