自学教程：C++ zassert函数代码示例

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