draw.c

操作系统SunOS 4.1.3版本的源码

	time = tm.tv_sec + tm.tv_usec/1000000.0;
	lock(k);
    again:
	for (i = 0; i < cnt; i++) {
		if (traf_absolute[k]) {
			ht = (*(unsigned *)&p[offset*i])/time;
			if (ht > maxabs[k]) {
				maxabs[k] = ((ht+INITMAXABS-1)/INITMAXABS)
				    *INITMAXABS;
				drawleftmargin(k);
				goto again;
			}
			ht = ht*curht[k]/maxabs[k];
		}
		else if (pkts == 0)
			ht = 0;
		else
			ht = (*(unsigned *)&p[offset*i]*curht[k])/pkts;
		j = prevbar[k][i];
		/* 
		 * left hand part of left bar
		 */
		if (j > ht)
			pw_replrop(pixwin[k], left+i*wd + BETWEEN,
			    TOPGAP + curht[k] - j,
			    OVERLAP, j - ht, PIX_SRC ^ PIX_DST,
			    proof_pr, left + i*wd + BETWEEN, curht[k] - j);
		else if (j < ht)
			pw_replrop(pixwin[k], left+i*wd + BETWEEN,
			    TOPGAP + curht[k] - ht,
			    OVERLAP, ht - j, PIX_SRC ^ PIX_DST,
			    proof_pr, left + i*wd + BETWEEN, curht[k] - ht);
		/* 
		 * overlap of 2 bars
		 */
		j1 = prevbar1[k][i];
		if (j >= j1) {
			if (j > ht)
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - j,
				    wd - 2*OVERLAP - BETWEEN, j-ht,
				    PIX_SRC ^ PIX_DST, proof_pr,
				    left + i*wd + BETWEEN+OVERLAP, curht[k]-j);
			else if (j < ht)
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - ht,
				    wd-2*OVERLAP - BETWEEN, ht-j,
				    PIX_SRC ^ PIX_DST, proof_pr,
				    left + i*wd+BETWEEN+OVERLAP, curht[k]-ht);
			if (ht < j1) {
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - j1,
				    wd - 2*OVERLAP-BETWEEN, j1-ht,
				    PIX_SRC ^ PIX_DST, proof_pr1,
				    left + i*wd + BETWEEN+OVERLAP,curht[k]-j1);
			}
		}
		else {
			if (ht < j) {
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - j,
				    wd - 2*OVERLAP - BETWEEN, j-ht,
				    PIX_SRC ^ PIX_DST, proof_pr,
				    left + i*wd + BETWEEN+OVERLAP, curht[k]-j);
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - j,
				    wd - 2*OVERLAP - BETWEEN, j-ht,
				    PIX_SRC ^ PIX_DST, proof_pr1,
				    left + i*wd + BETWEEN+OVERLAP, curht[k]-j);
			}
			else {
				z = min(ht - j, j1 - j);
				w = min(ht, j1);
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - w,
				    wd - 2*OVERLAP - BETWEEN, z,
				    PIX_SRC ^ PIX_DST, proof_pr1,
				    left + i*wd + BETWEEN+OVERLAP, curht[k]-w);
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - ht,
				    wd-2*OVERLAP - BETWEEN, ht-j,
				    PIX_SRC ^ PIX_DST, proof_pr,
				    left + i*wd+BETWEEN+OVERLAP, curht[k]-ht);
			}
		}
		prevbar[k][i] = ht;
	}
	unlock(k);
}

/* 
 * draws rightmost bar: assumes left bar has value
 * given by prevbar
 */
drawbars1(pkts, tm, k, p, offset, cnt)
	struct timeval tm;
	char p[];
{
	int wd, i, j, j1, ht1, z, left;
	float time;
	
	left = LEFTMARGIN*marginfontwd;
	wd = (tswrect[k].r_width - left)/cnt;
	time = tm.tv_sec + tm.tv_usec/1000000.0;
	lock(k);
   again:
	for (i = 0; i < cnt; i++) {
		if (traf_absolute[k]) {
			ht1 = (*(unsigned *)&p[offset*i])/time;
			if (ht1 > maxabs[k]) {
				maxabs[k] = ((ht1+INITMAXABS-1)/INITMAXABS)
				    *INITMAXABS;
				drawleftmargin(k);
				goto again;
			}
			ht1 = ht1*curht[k]/maxabs[k];
		}
		else if (pkts == 0)
			ht1 = 0;
		else
			ht1 = (*(unsigned *)&p[offset*i]*curht[k])/pkts;
		j = prevbar[k][i];
		j1 = prevbar1[k][i];
		/* 
		 * overlap of 2 bars
		 */
		if (j >= j1) {
			if (ht1 > j) {
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - ht1,
				    wd-2*OVERLAP-BETWEEN, ht1-j,
				    PIX_SRC ^ PIX_DST, proof_pr1,
				    left+i*wd + BETWEEN+OVERLAP, curht[k]-ht1);
			}
		}
		else {
			if (ht1 > j1) {
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - ht1,
				    wd-2*OVERLAP-BETWEEN, ht1-j1,
				    PIX_SRC ^ PIX_DST, proof_pr1,
				    left+i*wd + BETWEEN+OVERLAP, curht[k]-ht1);
			}
			else if (ht1 < j1) {
				z = min(j1 - ht1, j1 - j);
				pw_replrop(pixwin[k],left+i*wd+BETWEEN+OVERLAP,
				    TOPGAP + curht[k] - j1,
				    wd - 2*OVERLAP - BETWEEN, z,
				    PIX_SRC ^ PIX_DST, proof_pr1,
				    left+i*wd + BETWEEN+OVERLAP, curht[k]-j1);
			}
		}
		/* 
		 * right hand part of right bar
		 */
		if (j1 > ht1)
			pw_replrop(pixwin[k], left + (i+1)*wd - OVERLAP,
			    TOPGAP + curht[k] - j1,
			    OVERLAP, j1 - ht1, PIX_SRC^PIX_DST,
			    proof_pr1, left + (i+1)*wd-OVERLAP, curht[k] - j1);
		else if (j1 < ht1)
			pw_replrop(pixwin[k], left+(i+1)*wd-OVERLAP,
			    TOPGAP + curht[k] - ht1,
			    OVERLAP, ht1 - j1, PIX_SRC ^ PIX_DST,
			    proof_pr1, left + (i+1)*wd-OVERLAP, curht[k]-ht1);
		prevbar1[k][i] = ht1;
	}
	unlock(k);
}

/* 
 * load rank[] with values of ea.e_addrs - table
 * so that rank[] can be sorted
 */
loadrank(rk, table)
	struct rank rk[];
	struct etherhmem *table[];
{	
	int i, j, x;
	struct etherhmem *p, *q;
	
	j = 0;
	for (i = 0; i < HASHSIZE; i++) {
		for (p = ea.e_addrs[i]; p != NULL; p = p->ht_nxt) {
			x = p->ht_addr & 0xff;
			for (q = table[x]; q != NULL; q = q->ht_nxt) {
				if (q->ht_addr == p->ht_addr) {
					rk[j].cnt = p->ht_cnt - q->ht_cnt;
					rk[j].addr = p->ht_addr;
					goto nextround;
				}
			}
			/* first time seen */
			rk[j].cnt = p->ht_cnt;
			rk[j].addr = p->ht_addr;
		    nextround:;
			j++;
			if (j >= NSITES) {
				fprintf(stderr, "overflowed rank table\n");
				return (j-1);
			}
		}
	}
	return (j);
}

loadfromdelta(rk, table)
	struct rank rk[];
	struct etherhmem *table[];
{
	int i, x;
	struct etherhmem *p;

	for (i = 0; i < NUMNAMES; i++) {
		x = rk[i].addr;
		for (p = table[x & 0xff]; p != NULL; p = p->ht_nxt) {
			if (p->ht_addr == x) {
				rk[i].cnt = p->ht_cnt;
				break;
			}
		}
		if (p == NULL)
			rk[i].cnt = 0;
	}
}

/* 
 * load rank[].cnt with values of ea.e_addrs - table
 * but use only first NUMNAMES entries of rank[]
 * Also, update delta table for all entries
 */
loadrank1(rk, table, deltatable)
	struct rank rk[];
	struct etherhmem *table[];
	struct etherhmem *deltatable[];
{	
	int i, x;
	struct etherhmem *p, *q;
	
	for (i = 0; i < HASHSIZE; i++) {
		for (p = ea.e_addrs[i]; p != NULL; p = p->ht_nxt) {
			x = p->ht_addr;
			for (q = table[x & 0xff]; q != NULL; q = q->ht_nxt) {
				if (q->ht_addr == x) {
					addtohtable(p->ht_cnt - q->ht_cnt, x,
					    deltatable);
					break;
				}
			}
			if (q == NULL)	/* first time seen */
				addtohtable(p->ht_cnt, x, deltatable);
		}
	}
	for (i = 0; i < NUMNAMES; i++) {
		x = rk[i].addr;
		for (p = deltatable[x & 0xff]; p != NULL; p = p->ht_nxt) {
			if (p->ht_addr == x)
				rk[i].cnt = p->ht_cnt;
		}
	}
}

addtohtable(cnt, addr, table)
	struct etherhmem *table[];
{
	int x;
	struct etherhmem *q;

	x = addr & 0xff;
	for (q = table[x]; q != NULL; q = q->ht_nxt) {
		if (q->ht_addr == addr) {
			q->ht_cnt = cnt;
			return;
		}
	}
	q = (struct etherhmem *)malloc(sizeof(struct etherhmem));
	q->ht_addr = addr;
	q->ht_cnt = cnt;
	q->ht_nxt = table[x];
	table[x] = q;
}

updatetable(table)
	struct etherhmem *table[];
{	
	int i;
	struct etherhmem *p;
	
	for (i = 0; i < HASHSIZE; i++) {
		for (p = ea.e_addrs[i]; p != NULL; p = p->ht_nxt)
			addtohtable(p->ht_cnt, p->ht_addr, table);
	}
}

traf_clearstate(i)
{
	deltacnt[i] = 0;
	deltatime[i].tv_sec = 0;
	deltatime[i].tv_usec = 0;
	first[i] = 1;
	lasttm[i] = 0;
	oldbcast[i] = 0;
	maxabs[i] = INITMAXABS;
	pos[i] = LEFTMARGIN*marginfontwd;
	savepktcnt[i] = 0;
	savepktcnt1[i] = 0;
	savetime[i].tv_sec = 0;
	savetime[i].tv_usec = 0;
	savetime1[i].tv_sec = 0;
	savetime1[i].tv_usec = 0;

	bzero(bucket[i], sizeof(bucket[i]));
	bzero(bucket1[i], sizeof(bucket1[i]));
	bzero(dsthtable[i], sizeof(dsthtable[i]));
	bzero(dsthtable1[i], sizeof(dsthtable1[i]));
	bzero(prevbar[i], sizeof(prevbar[0]));
	bzero(prevbar1[i], sizeof(prevbar1[0]));
	bzero(prototable[i], sizeof(prototable[i]));
	bzero(prototable1[i], sizeof(prototable1[i]));
	bzero(srchtable[i], sizeof(srchtable[i]));
	bzero(srcdeltahtable[i], sizeof(srcdeltahtable[i]));
	bzero(srchtable1[i], sizeof(srchtable1[i]));
	zerooldaddrs(i);
}

/* 
 *  t1 - t2
 */
struct timeval
timersub(t1, t2)
	struct timeval t1, t2;
{
	if (t1.tv_usec < t2.tv_usec) {
		t1.tv_sec--;
		t1.tv_usec += 1000000;
	}
	t1.tv_sec -= t2.tv_sec;
	t1.tv_usec -= t2.tv_usec;
	return (t1);
}