imp_interface* imp_interface_find(int family, if_type type)
{
    imp_interface    *p_if = imp_interface_first();

    for(; p_if; p_if = LIST_NEXT(p_if, link)){

        if(p_if->if_addr.ss.ss_family == family &&
            p_if->type == type)
            return p_if;
    }
    return NULL;

}

/*
 * allocate one address from address pool
 * if successful, returns pointer to struct of allocated address
 * if fails, returns 0
 *
 * caller must do LIST_INSERT_HEAD(&child_sa->lease_list, addr, link_sa)
 */
struct rcf_address *
rc_addrpool_alloc_any(struct rcf_addresspool *conf, int af)
{
	size_t addrsize;
	struct rcf_address_pool_item	*i;
	uint8_t	addr[MAX_ADDRESS_LENGTH];
	struct rcf_address	*a;

	if (!conf) {
		plog(PLOG_INTERR, PLOGLOC, NULL,
		     "no address pool specified\n");
		return 0;
	}

	addrsize = af_addrsize(af);
	if (addrsize == 0) 
		return 0;

	/*
	 * for each range of address pool
	 */
	for (i = LIST_FIRST(&conf->pool_list); i != NULL; i = LIST_NEXT(i, link)) {
		if (af != i->af)
			continue;

		/*
		 * try if it's possible to assign one
		 * XXX need better algorithm 
		 */
		for (memcpy(addr, &i->start, addrsize);
		     memcmp(addr, &i->end, addrsize) <= 0;
		     addrbits_incr(af, addr)) {

			if (addrpool_check(i, addr) != 0)
				continue;

			/*
			 * OK.  Assign it.
			 */
			a = rc_address_new(af, addr, IPV6_ADDRESS_PREFIX_LEN,
					   0, &i->lease_list);
			if (!a)
				return 0;
			return a;
		}
		/* all address in use.  try next range */
	}
	/* No address available for use */

	return 0;
}

/*
 * Synch buffers associated with a block device
 */
int
spec_fsync(void *v)
{
	struct vop_fsync_args *ap = v;
	struct vnode *vp = ap->a_vp;
	struct buf *bp;
	struct buf *nbp;
	int s;

	if (vp->v_type == VCHR)
		return (0);

#ifdef WAPBL
	if (vp->v_type == VBLK &&
	    vp->v_specmountpoint != NULL &&
	    vp->v_specmountpoint->mnt_wapbl != NULL)
		return (ffs_wapbl_fsync_vfs(vp, ap->a_waitfor));
#endif

	/*
	 * Flush all dirty buffers associated with a block device.
	 */
loop:
	s = splbio();
	for (bp = LIST_FIRST(&vp->v_dirtyblkhd);
	    bp != LIST_END(&vp->v_dirtyblkhd); bp = nbp) {
		nbp = LIST_NEXT(bp, b_vnbufs);
		if ((bp->b_flags & B_BUSY))
			continue;
		if ((bp->b_flags & B_DELWRI) == 0)
			panic("spec_fsync: not dirty");
		bremfree(bp);
		buf_acquire(bp);
		splx(s);
		bawrite(bp);
		goto loop;
	}
	if (ap->a_waitfor == MNT_WAIT) {
		vwaitforio (vp, 0, "spec_fsync", 0);

#ifdef DIAGNOSTIC
		if (!LIST_EMPTY(&vp->v_dirtyblkhd)) {
			splx(s);
			vprint("spec_fsync: dirty", vp);
			goto loop;
		}
#endif
	}
	splx(s);
	return (0);
}

/* Delete a POSIX realtime timer */
int
sys_timer_delete(struct lwp *l, const struct sys_timer_delete_args *uap,
    register_t *retval)
{
	/* {
		syscallarg(timer_t) timerid;
	} */
	struct proc *p = l->l_proc;
	timer_t timerid;
	struct ptimers *pts;
	struct ptimer *pt, *ptn;

	timerid = SCARG(uap, timerid);
	pts = p->p_timers;
	
	if (pts == NULL || timerid < 2 || timerid >= TIMER_MAX)
		return (EINVAL);

	mutex_spin_enter(&timer_lock);
	if ((pt = pts->pts_timers[timerid]) == NULL) {
		mutex_spin_exit(&timer_lock);
		return (EINVAL);
	}
	if (CLOCK_VIRTUAL_P(pt->pt_type)) {
		if (pt->pt_active) {
			ptn = LIST_NEXT(pt, pt_list);
			LIST_REMOVE(pt, pt_list);
			for ( ; ptn; ptn = LIST_NEXT(ptn, pt_list))
				timespecadd(&pt->pt_time.it_value,
				    &ptn->pt_time.it_value,
				    &ptn->pt_time.it_value);
			pt->pt_active = 0;
		}
	}
	itimerfree(pts, timerid);

	return (0);
}

static imp_interface* mcast_if_get_by_addr(pi_addr *p_pia)
{
    imp_interface *p_if = imp_interface_first();

    while(p_if) {

       if (memcmp(&p_if->if_addr, p_pia, sizeof(pi_addr)) == 0)
            return p_if;

        p_if = LIST_NEXT(p_if, link);
    }

    return NULL;
}

static void
hcirawpr(kvm_t *kvmd, u_long addr)
{
	ng_btsocket_hci_raw_pcb_p	this = NULL, next = NULL;
	ng_btsocket_hci_raw_pcb_t	pcb;
	struct socket			so;
	int				first = 1;

	if (addr == 0)
		return;

        if (kread(kvmd, addr, (char *) &this, sizeof(this)) < 0)
		return;

	for ( ; this != NULL; this = next) {
		if (kread(kvmd, (u_long) this, (char *) &pcb, sizeof(pcb)) < 0)
			return;
		if (kread(kvmd, (u_long) pcb.so, (char *) &so, sizeof(so)) < 0)
			return;

		next = LIST_NEXT(&pcb, next);

		if (first) {
			first = 0;
			fprintf(stdout,
"Active raw HCI sockets\n" \
"%-8.8s %-8.8s %-6.6s %-6.6s %-6.6s %-16.16s\n",
				"Socket",
				"PCB",
				"Flags",
				"Recv-Q",
				"Send-Q",
				"Local address");
		}

		if (pcb.addr.hci_node[0] == 0) {
			pcb.addr.hci_node[0] = '*';
			pcb.addr.hci_node[1] = 0;
		}

		fprintf(stdout,
"%-8lx %-8lx %-6.6x %6d %6d %-16.16s\n",
			(unsigned long) pcb.so,
			(unsigned long) this,
			pcb.flags,
			so.so_rcv.sb_ccc,
			so.so_snd.sb_ccc,
			pcb.addr.hci_node);
	}
} /* hcirawpr */

void
bio_unregister(struct device *dev)
{
	struct bio_mapping *bm, *next;

	for (bm = LIST_FIRST(&bios); bm != NULL; bm = next) {
		next = LIST_NEXT(bm, bm_link);

		if (dev == bm->bm_dev) {
			LIST_REMOVE(bm, bm_link);
			free(bm, M_DEVBUF, sizeof(*bm));
		}
	}
}

usbd_status
usb_allocmem(usbd_bus_handle bus, size_t size, size_t align, usb_dma_t *p)
{
	bus_dma_tag_t tag = bus->dmatag;
	usbd_status err;
	struct usb_frag_dma *f;
	usb_dma_block_t *b;
	int i;
	int s;

	/* If the request is large then just use a full block. */
	if (size > USB_MEM_SMALL || align > USB_MEM_SMALL) {
		DPRINTFN(1, ("usb_allocmem: large alloc %d\n", (int)size));
		size = (size + USB_MEM_BLOCK - 1) & ~(USB_MEM_BLOCK - 1);
		err = usb_block_allocmem(tag, size, align, &p->block);
		if (!err) {
			p->block->fullblock = 1;
			p->offs = 0;
		}
		return (err);
	}

	s = splusb();
	/* Check for free fragments. */
	for (f = LIST_FIRST(&usb_frag_freelist); f; f = LIST_NEXT(f, next))
		if (f->block->tag == tag)
			break;
	if (f == NULL) {
		DPRINTFN(1, ("usb_allocmem: adding fragments\n"));
		err = usb_block_allocmem(tag, USB_MEM_BLOCK, USB_MEM_SMALL,&b);
		if (err) {
			splx(s);
			return (err);
		}
		b->fullblock = 0;
		for (i = 0; i < USB_MEM_BLOCK; i += USB_MEM_SMALL) {
			f = (struct usb_frag_dma *)(b->kaddr + i);
			f->block = b;
			f->offs = i;
			LIST_INSERT_HEAD(&usb_frag_freelist, f, next);
		}
		f = LIST_FIRST(&usb_frag_freelist);
	}
	p->block = f->block;
	p->offs = f->offs;
	LIST_REMOVE(f, next);
	splx(s);
	DPRINTFN(5, ("usb_allocmem: use frag=%p size=%d\n", f, (int)size));
	return (USBD_NORMAL_COMPLETION);
}

imp_source* imp_source_find_scheduled(imp_group *p_gp, int sflag)
{
    imp_source  *p_is = NULL;

    for (p_is = LIST_FIRST(&p_gp->src_list); p_is ;
            p_is = LIST_NEXT(p_is, link)) {

        if (imp_source_is_scheduled(p_is, sflag) != 0)
            return p_is;;

    }
    return NULL;

}

/*-----------------------------------------------------------------------
 * Name         : imp_source_exist_allow
 *
 * Brief        : check if there exsit source which is allowed in group
 * Params       : [in] p_gp -- struct imp_group
 * Return       : 1:exsit 0:not exsit
*------------------------------------------------------------------------
*/
int imp_source_exist_allow(imp_group *p_gp)
{
    imp_source  *p_is = NULL;

    for (p_is = LIST_FIRST(&p_gp->src_list); p_is ;
            p_is = LIST_NEXT(p_is, link)) {

        if(!TIMEVAL_ISZERO(p_is->timer->tm))
            return 1;

    }
    return 0;

}

static void next_battle_turn(
    BATTLE *battle
)
{
    BATTLE_ACTOR *ba;

    for (ba = (BATTLE_ACTOR *) LIST_HEAD(&battle->battleList);
            ba != NULL;
            ba = (BATTLE_ACTOR *) LIST_NEXT(&ba->listNode) ) {

        set_battle_state(battle, ba, BATTLE_STATE_IDLE, NULL);

    }
}

static void draw_battle_field(
    BATTLE *battle
)
{
    BATTLE_ACTOR *ba;

    for (ba = (BATTLE_ACTOR *) LIST_HEAD(&battle->battleList);
            ba != NULL;
            ba = (BATTLE_ACTOR *) LIST_NEXT(&ba->listNode) ) {

        draw_player(ba->player, battle->world);

    }
}

/**
 * @brief Cancel mass ad cache from a user
 * @param u User to flush out
 * @param rcv -1 = cancel all, or cancel where ad->rcvd_by == rcv
 */
aMassAd *
find_ad(UserList * u, int rcv)
{
	aMassAd *search;

	if ((search = LIST_FIRST(&masslist)) == NULL)
		return NULL;
	while (search) {
		if (search->sender == u && (search->rcvd_by == rcv || rcv == -1))
			return search;
		search = LIST_NEXT(search, ma_lst);
	}
	return NULL;
}

/*
 * pfil_head_get() returns the pfil_head for a given key/dlt.
 */
struct pfil_head *
pfil_head_get(int type, u_long val)
{
	struct pfil_head *ph;

	for (ph = LIST_FIRST(&pfil_head_list); ph != NULL;
	     ph = LIST_NEXT(ph, ph_list)) {
		if (ph->ph_type == type &&
		    ph->ph_un.phu_val == val)
			break;
	}

	return (ph);
}

__private_extern__ uint32_t
inpcb_count_opportunistic(unsigned int ifindex, struct inpcbinfo *pcbinfo,
    u_int32_t flags)
{
	uint32_t opportunistic = 0;
	struct inpcb *inp;
	inp_gen_t gencnt;

	lck_rw_lock_shared(pcbinfo->ipi_lock);
	gencnt = pcbinfo->ipi_gencnt;
	for (inp = LIST_FIRST(pcbinfo->ipi_listhead);
	    inp != NULL; inp = LIST_NEXT(inp, inp_list)) {
		if (inp->inp_gencnt <= gencnt &&
		    inp->inp_state != INPCB_STATE_DEAD &&
		    inp->inp_socket != NULL &&
		    so_get_opportunistic(inp->inp_socket) &&
		    inp->inp_last_outifp != NULL &&
		    ifindex == inp->inp_last_outifp->if_index) {
			opportunistic++;
			struct socket *so = inp->inp_socket;
			if ((flags & INPCB_OPPORTUNISTIC_SETCMD) &&
			    (so->so_state & SS_ISCONNECTED)) {
				socket_lock(so, 1);
				if (flags & INPCB_OPPORTUNISTIC_THROTTLEON) {
					so->so_flags |= SOF_SUSPENDED;
					soevent(so,
					    (SO_FILT_HINT_LOCKED |
					    SO_FILT_HINT_SUSPEND));
				} else {
					so->so_flags &= ~(SOF_SUSPENDED);
					soevent(so,
					    (SO_FILT_HINT_LOCKED |
					    SO_FILT_HINT_RESUME));
				}
				SOTHROTTLELOG(("throttle[%d]: so 0x%llx "
				    "[%d,%d] %s\n", so->last_pid,
				    (uint64_t)VM_KERNEL_ADDRPERM(so),
				    SOCK_DOM(so), SOCK_TYPE(so),
				    (so->so_flags & SOF_SUSPENDED) ?
				    "SUSPENDED" : "RESUMED"));
				socket_unlock(so, 1);
			}
		}
	}

	lck_rw_done(pcbinfo->ipi_lock);

	return (opportunistic);
}

/**
 * write a room structure to disk, if it is not dirty (dirty_fl).
 */
static int room_save(struct room *r) {
	struct attr_entry *curr;
	struct fdb_write_handle *h;
	char numbuf[22]; /* big enough for a signed 64-bit decimal */

	assert(r != NULL);
	if(!r->dirty_fl) return 1; /* already saved - don't do it again. */

	/* refuse to save room 0. */
	if(!r->id) {
		b_log(B_LOG_ERROR, "room", "attempted to save room \"%u\", but it is reserved", r->id);
		return 0;
	}

	snprintf(numbuf, sizeof numbuf, "%u", r->id);

	h=fdb.write_begin("rooms", numbuf);
	if(!h) {
		b_log(B_LOG_ERROR, "room", "could not save room \"%s\"", numbuf);
		return 0; /* failure */
	}

	fdb.write_format(h, "id", "%u", r->id);
	if(r->name.short_str)
		fdb.write_pair(h, "name.short", r->name.short_str);
	if(r->name.long_str)
		fdb.write_pair(h, "name.long", r->name.long_str);
	if(r->desc.short_str)
		fdb.write_pair(h, "desc.short", r->desc.short_str);
	if(r->desc.long_str)
		fdb.write_pair(h, "desc.long", r->desc.long_str);
	if(r->owner)
		fdb.write_pair(h, "owner", r->owner);
	if(r->creator)
		fdb.write_pair(h, "creator", r->creator);

	for(curr=LIST_TOP(r->extra_values);curr;curr=LIST_NEXT(curr, list)) {
		fdb.write_pair(h, curr->name, curr->value);
	}

	if(!fdb.write_end(h)) {
		b_log(B_LOG_ERROR, "room", "could not save room \"%s\"", numbuf);
		return 0; /* failure */
	}

	r->dirty_fl=0;
	b_log(B_LOG_INFO, "room", "saved room \"%s\"", numbuf);
	return 1;
}

void
exit_daemon(void)
{
	struct session *s, *next;

	for (s = LIST_FIRST(&sessions); s != LIST_END(&sessions); s = next) {
		next = LIST_NEXT(s, entry);
		end_session(s);
	}

	if (daemonize)
		closelog();

	exit(0);
}

void deinit_battle(
    BATTLE *battle
)
{
    BATTLE_ACTOR *ba;

    for (ba = (BATTLE_ACTOR *) LIST_HEAD(&battle->battleList);
            ba != NULL;
            ba = (BATTLE_ACTOR *) LIST_NEXT(&ba->listNode))  {
        set_battle_state(battle, ba, BATTLE_STATE_DONE, NULL);
        /* TODO: Free each battle actor */
    }

    /* TODO: Free all nodes */
    listInit(&battle->battleList);
}

struct atom *builtin_atom(struct atom *expr, struct env *env)
{
    struct list *list = expr->list;
    struct atom *op = LIST_FIRST(list);
    struct atom *a = LIST_NEXT(op, entries);

    (void) env;

    if (!a)
        return &nil_atom;

    if (IS_LIST(a))
        return &false_atom;
    else
        return &true_atom;
}

/*
 * insert a new element in an existing list that the ID's (size in struct
 * pci_memreg) are sorted.
 */
static void
insert_into_list(PCI_MEMREG *head, struct pci_memreg *elem)
{
    struct pci_memreg *p, *q;

    p = LIST_FIRST(head);
    q = NULL;

    for (; p != NULL && p->size < elem->size; q = p, p = LIST_NEXT(p, link));

    if (q == NULL) {
	LIST_INSERT_HEAD(head, elem, link);
    } else {
	LIST_INSERT_AFTER(q, elem, link);
    }
}