char *
numtohost(
u_int32 netnum
)
{
char *bp;
struct hostent *hp;
/*
* This is really gross, but saves lots of hanging looking for
* hostnames for the radio clocks. Don't bother looking up
* addresses on the loopback network except for the loopback
* host itself.
*/
if ((((ntohl(netnum) & LOOPBACKNETMASK) == LOOPBACKNET)
&& (ntohl(netnum) != LOOPBACKHOST))
|| ((hp = gethostbyaddr((char *)&netnum, sizeof netnum, AF_INET))
== 0))
return numtoa(netnum);
LIB_GETBUF(bp);
bp[LIB_BUFLENGTH-1] = '\0';
(void) strncpy(bp, hp->h_name, LIB_BUFLENGTH-1);
return bp;
}
TEST_F(numtoaTest, Netmask) {
// 255.255.255.0
u_int32 hostOrder = 255UL*256UL*256UL*256UL + 255UL*256UL*256UL + 255UL*256UL;
u_int32 input = htonl(hostOrder);
EXPECT_STREQ("255.255.255.0", numtoa(input));
}
TEST(numtoa, Netmask) {
// 255.255.255.0
u_int32_t hostOrder = 255UL*256UL*256UL*256UL + 255UL*256UL*256UL + 255UL*256UL;
u_int32_t input = htonl(hostOrder);
TEST_ASSERT_EQUAL_STRING("255.255.255.0", numtoa(input));
}
void
test_Netmask(void) {
// 255.255.255.0
const u_int32 hostOrder = 255UL*256UL*256UL*256UL + 255UL*256UL*256UL + 255UL*256UL;
const u_int32 input = htonl(hostOrder);
TEST_ASSERT_EQUAL_STRING("255.255.255.0", numtoa(input));
}
PROC
mvcur(int y, int x)
{
static char gt[30];
if (y == -1)
y = curpos.y;
else
curpos.y = y;
if (y >= LINES)
y = LINES-1;
if (x == -1)
x = curpos.x;
else
curpos.x = x;
if (x >= COLS)
x = COLS-1;
#if ZTERM
zgoto(x,y);
#endif
#if ANSI
{ register char *p = gt; /* make a ansi gotoXY string */
*p++ = 033;
*p++ = '[';
numtoa(p,1+y); p += strlen(p);
*p++ = ';';
numtoa(p,1+x); p += strlen(p);
*p++ = 'H';
WRITE_TEXT(1, gt, (p-gt));
}
#endif
#if VT52
CM[2] = y+32;
CM[3] = x+32;
strput(CM);
#endif
#if TERMCAP
tgoto(gt,y,x);
strput(gt);
#endif
}
PROC
printi(int num)
{
char nb[10];
register int size;
numtoa(nb,num);
size = min(strlen(nb),COLS-curpos.x);
if (size > 0) {
zwrite(nb, size);
curpos.x += size;
}
}
PROC
macrocommand(void)
{
if (count > 1)
numtoa(gcb,count);
else
gcb[0] = 0;
switch (ch) { /* which macro? */
case 'x': /* x out characters */
strcat(gcb,"dl"); break;
case 'X': /* ... backwards */
strcat(gcb,"dh"); break;
case 's': /* substitute over chars */
strcat(gcb,"cl"); break;
case 'D': /* delete to end of line */
strcat(gcb,"d$"); break;
case 'C': /* change ... */
strcat(gcb,"c$"); break;
case 'Y': /* yank ... */
strcat(gcb,"y$"); break;
case 0x06: /* ^F */ /* scroll up one page */
strcpy(gcb,"22\x04"); break; /* 22^D */
case 0x02: /* ^B */ /* ... down one page */
strcpy(gcb,"22\x15"); break; /* 22^U */
case 0x05: /* ^E */ /* scroll up one line */
strcpy(gcb,"1\x04"); break; /* 1^D */
case 0x19: /* ^Y */ /* ... down one line */
strcpy(gcb,"1\x15"); break; /* 1^U */
default:
error();
return 0;
break;
}
if (macro<0)
zerostack(&undo);
insertmacro(gcb, 1);
}
void
test_Address(void) {
const u_int32 input = htonl(3221225472UL + 512UL + 1UL); // 192.0.2.1
TEST_ASSERT_EQUAL_STRING("192.0.2.1", numtoa(input));
}
TEST(numtoa, Address) {
u_int32_t input = htonl(3221225472UL+512UL+1UL); // 192.0.2.1
TEST_ASSERT_EQUAL_STRING("192.0.2.1", numtoa(input));
}
/*
* restrictions - return restrictions for this host
*/
int
restrictions(
struct sockaddr_in *srcadr
)
{
register struct restrictlist *rl;
register struct restrictlist *match;
register u_int32 hostaddr;
register int isntpport;
res_calls++;
/*
* We need the host address in host order. Also need to know
* whether this is from the ntp port or not.
*/
hostaddr = SRCADR(srcadr);
isntpport = (SRCPORT(srcadr) == NTP_PORT);
/*
* Ignore any packets with a multicast source address
* (this should be done early in the receive process, later!)
*/
if (IN_CLASSD(ntohl(srcadr->sin_addr.s_addr)))
return (int)RES_IGNORE;
/*
* Set match to first entry, which is default entry. Work our
* way down from there.
*/
match = restrictlist;
for (rl = match->next; rl != 0 && rl->addr <= hostaddr; rl = rl->next)
if ((hostaddr & rl->mask) == rl->addr) {
if ((rl->mflags & RESM_NTPONLY) && !isntpport)
continue;
match = rl;
}
match->count++;
if (match == restrictlist)
res_not_found++;
else
res_found++;
/*
* The following implements limiting the number of clients
* accepted from a given network. The notion of "same network"
* is determined by the mask and addr fields of the restrict
* list entry. The monitor mechanism has to be enabled for
* collecting info on current clients.
*
* The policy is as follows:
* - take the list of clients recorded
* from the given "network" seen within the last
* client_limit_period seconds
* - if there are at most client_limit entries:
* --> access allowed
* - otherwise sort by time first seen
* - current client among the first client_limit seen
* hosts?
* if yes: access allowed
* else: eccess denied
*/
if (match->flags & RES_LIMITED) {
int lcnt;
struct mon_data *md, *this_client;
#ifdef DEBUG
if (debug > 2)
printf("limited clients check: %ld clients, period %ld seconds, net is 0x%lX\n",
client_limit, client_limit_period,
(u_long)netof(hostaddr));
#endif /*DEBUG*/
if (mon_enabled == MON_OFF) {
#ifdef DEBUG
if (debug > 4)
printf("no limit - monitoring is off\n");
#endif
return (int)(match->flags & ~RES_LIMITED);
}
/*
* How nice, MRU list provides our current client as the
* first entry in the list.
* Monitoring was verified to be active above, thus we
* know an entry for our client must exist, or some
* brain dead set the memory limit for mon entries to ZERO!!!
*/
this_client = mon_mru_list.mru_next;
for (md = mon_fifo_list.fifo_next,lcnt = 0;
md != &mon_fifo_list;
md = md->fifo_next) {
if ((current_time - md->lasttime)
> client_limit_period) {
#ifdef DEBUG
if (debug > 5)
printf("checking: %s: ignore: too old: %ld\n",
numtoa(md->rmtadr),
current_time - md->lasttime);
#endif
continue;
}
if (md->mode == MODE_BROADCAST ||
md->mode == MODE_CONTROL ||
md->mode == MODE_PRIVATE) {
#ifdef DEBUG
if (debug > 5)
printf("checking: %s: ignore mode %d\n",
numtoa(md->rmtadr),
md->mode);
#endif
continue;
}
if (netof(md->rmtadr) !=
netof(hostaddr)) {
#ifdef DEBUG
if (debug > 5)
printf("checking: %s: different net 0x%lX\n",
numtoa(md->rmtadr),
(u_long)netof(md->rmtadr));
#endif
continue;
}
lcnt++;
if (lcnt > (int) client_limit ||
md->rmtadr == hostaddr) {
#ifdef DEBUG
if (debug > 5)
printf("considering %s: found host\n",
numtoa(md->rmtadr));
#endif
break;
}
#ifdef DEBUG
else {
if (debug > 5)
printf("considering %s: same net\n",
numtoa(md->rmtadr));
}
#endif
}
#ifdef DEBUG
if (debug > 4)
printf("this one is rank %d in list, limit is %lu: %s\n",
lcnt, client_limit,
(lcnt <= (int) client_limit) ? "ALLOW" : "REJECT");
#endif
if (lcnt <= (int) client_limit) {
this_client->lastdrop = 0;
return (int)(match->flags & ~RES_LIMITED);
} else {
this_client->lastdrop = current_time;
}
}
return (int)match->flags;
}
PROC
docommand(cmdtype cmd)
{
cmdtype movecmd; /* movement command for y, d, c */
char cmdch;
int oldc; /* old count */
int endp; /* end position before change */
extern bool s_wrapped;
resetX(); /* un-derange the cursor */
oldc = newc = -1;
endY = yp;
newend = disp = curr;
ok = TRUE; /* so far everything is working */
cmdch = ch;
if (cmd != UNDO_C && cmd != YANK_C) {
if (macro<0)
zerostack(&undo);
if (redoing != TRUE) {
rcp = rcb; /* point at start of redo buffer */
if (count > 1) { /* put in a count? */
numtoa(rcb,count);
rcp += strlen(rcb);
}
*rcp++ = cmdch; /* the command char goes in... */
xerox = TRUE; /* hoist the magical flags */
}
}
if (cmd <= YANK_C) {
readchar();
if (ch >= '0' && ch <= '9') {
oldc = count;
gcount(); /* get a new count */
if (cmd == ADJUST_C) /* special for >>,<< wierdness */
swap(&count, &oldc); /* reverse sw & count */
else
count = count*max(oldc,1); /* combine them */
}
if (ch == cmdch) { /* diddle lines */
yank.lines = TRUE;
endp = nextline(TRUE, curr, count);
curr = bseekeol(curr);
disp = curr;
}
else { /* diddle 'things' */
yank.lines = FALSE;
movecmd = movemap[ch];
if (ok = (findCP(curr,&endp,movecmd) == LEGALMOVE)) {
if (curr > endp) {
swap(&curr,&endp);
ok = (cmd != CHANGE_C);
}
if (adjcurr[movecmd])
curr++;
if (adjendp[movecmd])
endp++;
}
if (!ok) {
if (ch != ESC)
error();
goto killredo;
}
}
endY = setY(endp);
newend = curr;
disp = curr;
switch (cmd) {
case DELETE_C:
ok = deletion(curr, endp);
break;
case ADJUST_C:
adjuster((cmdch == '<'), endp-1, oldc);
break;
case CHANGE_C:
if (endp <= pend+1) {
mvcur(setY(endp-1), setX(endp-1));
printch('$');
mvcur(yp, xp);
}
if (deletion(curr, endp))
ok = ((newend = insertion(1, 0, &disp, &endY, TRUE)) >= 0);
else
ok = FALSE;
break;
case YANK_C:
if (!doyank(curr, endp))
error();
return 0; /* xerox will not be true, nor will redoing */
}
}
else {
endp = curr;
endY = yp;
switch (cmd) {
case I_AT_NONWHITE:
case A_AT_END:
case APPEND_C:
case INSERT_C: /* variations on insert */
if (cmd != INSERT_C) {
if (cmd == APPEND_C)
curr = min(curr+1, lend);
else if (cmd == A_AT_END)
curr = lend;
else /* if (cmd == I_AT_NONWHITE) */
curr = skipws(lstart);
xp = setX(curr);
mvcur(yp,xp);
}
newend = insertion(count, 0, &disp, &endY, TRUE);
ok = (newend >= 0);
break;
case OPEN_C:
case OPENUP_C:
newend = insertion(1,setstep[ (cmd==OPENUP_C)&1 ],
&disp,&endY,TRUE)-1;
ok = (newend >= 0);
break;
case REPLACE_C:
case TWIDDLE_C:
if (cmd == REPLACE_C) {
if ((cmdch = readchar()) == ESC)
goto killredo;
}
if (findCP(curr, &endp, GO_RIGHT) == LEGALMOVE)
squiggle(endp-1, cmdch, (cmd==REPLACE_C));
break;
case PUT_BEFORE:
case PUT_AFTER:
ok = put(cmd==PUT_AFTER);
break;
case BIG_REPL_C:
bigreplace();
break;
case RESUBST_C:
ok = FALSE;
if (dst[0] != 0) {
newend = chop(curr, &lend, TRUE, &ok);
if (newend >= 0) {
endY = setY(newend+strlen(dst));
ok = TRUE;
}
}
break;
case JOIN_C:
join(count); /* join lines */
break;
case UNDO_C: /* undo last modification */
ok = fixcore(&newend) >= 0;
disp = newend;
endY = MAGICNUMBER;
break;
}
}
if (ok) {
setpos((newc<0)?newend:newc);
setend();
if (curr < ptop || curr > pend) {
yp = settop(12);
redisplay(TRUE);
}
else {
yp = setY(curr);
if (endY != setY(newend)) /* shuffled lines */
refresh(setY(disp), setX(disp), disp, pend, TRUE);
else /* refresh to end position */
refresh(setY(disp), setX(disp), disp, newend, FALSE);
}
if (curr >= bufmax && bufmax > 0) { /* adjust off end of buffer */
setpos(bufmax-1);
yp = setY(curr);
}
if (s_wrapped) {
prompt(FALSE, "search wrapped around end of buffer");
s_wrapped = 0;
}
else
clrprompt();
modified = TRUE;
}
else {
error();
killredo:
rcb[0] = 0;
}
mvcur(yp, xp);
if (xerox)
*rcp = 0; /* terminate the redo */
redoing = FALSE;
xerox = FALSE;
core[bufmax] = EOL;
}
TEST_F(numtoaTest, Address) {
u_int32 input = htonl(3221225472UL+512UL+1UL); // 192.0.2.1
EXPECT_STREQ("192.0.2.1", numtoa(input));
}