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