/************************************************************************
Copyright 1988, 1991 by Carnegie Mellon University
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted, provided
that the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation, and that the name of Carnegie Mellon University not be used
in advertising or publicity pertaining to distribution of the software
without specific, written prior permission.
CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
IN NO EVENT SHALL CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
************************************************************************/
static char rcsid
[] = "$Header: /b/source/CVS/othersrc/bootpd/readfile.c,v 1.2 1993/08/28 01:55:33 brezak Exp $";
* bootpd configuration file reading code.
* The routines in this file deal with reading, interpreting, and storing
* the information found in the bootpd configuration file (usually
#define E_END_OF_ENTRY (-1)
#define E_SYNTAX_ERROR (-2)
#define E_UNKNOWN_SYMBOL (-3)
#define E_BAD_IPADDR (-4)
#define E_BAD_TIMEOFF (-7)
#define E_BAD_VM_COOKIE (-8)
#define E_BAD_BOOTSIZE (-10)
#define E_BAD_BOOT_SERVER (-11)
#define E_BAD_HOMEDIR (-12)
#define E_BAD_TFTPDIR (-13)
#define E_BAD_SWAP_SERVER (-14)
#define SYM_COOKIE_SERVER 2
#define SYM_DOMAIN_SERVER 3
#define SYM_IMPRESS_SERVER 8
#define SYM_LOG_SERVER 10
#define SYM_LPR_SERVER 11
#define SYM_NAME_SERVER 12
#define SYM_RLP_SERVER 13
#define SYM_SUBNET_MASK 14
#define SYM_TIME_OFFSET 15
#define SYM_TIME_SERVER 16
#define SYM_VENDOR_MAGIC 17
#define SYM_SIMILAR_ENTRY 18
#define SYM_NAME_SWITCH 19
#define SYM_BOOT_SERVER 22
#define SYM_DOMAIN_NAME 25
#define SYM_SWAP_SERVER 26
#define OP_ADDITION 1 /* Operations on tags */
#define MAXINADDRS 16 /* Max size of an IP address list */
#define MAXBUFLEN 64 /* Max temp buffer space */
#define MAXENTRYLEN 2048 /* Max size of an entire entry */
* Structure used to map a configuration-file symbol (such as "ds") to a
PRIVATE
int nhosts
; /* Number of hosts (/w hw or IP address) */
PRIVATE
int nentries
; /* Total number of entries */
PRIVATE
long modtime
= 0; /* Last modification time of bootptab */
* List of symbolic names used in the bootptab file. The order and actual
* values of the symbol codes (SYM_. . .) are unimportant, but they must
PRIVATE
struct symbolmap symbol_list
[] = {
{ "cs", SYM_COOKIE_SERVER
},
{ "dn", SYM_DOMAIN_NAME
},
{ "ds", SYM_DOMAIN_SERVER
},
{ "hn", SYM_NAME_SWITCH
},
{ "im", SYM_IMPRESS_SERVER
},
{ "lg", SYM_LOG_SERVER
},
{ "lp", SYM_LPR_SERVER
},
{ "ns", SYM_NAME_SERVER
},
{ "rl", SYM_RLP_SERVER
},
{ "sa", SYM_BOOT_SERVER
},
{ "sm", SYM_SUBNET_MASK
},
{ "sw", SYM_SWAP_SERVER
},
{ "tc", SYM_SIMILAR_ENTRY
},
{ "to", SYM_TIME_OFFSET
},
{ "ts", SYM_TIME_SERVER
},
{ "vm", SYM_VENDOR_MAGIC
},
* List of symbolic names for hardware types. Name translates into
* hardware type code listed with it. Names must begin with a letter
* and must be all lowercase. This is searched linearly, so put
* commonly-used entries near the beginning.
PRIVATE
struct htypename htnamemap
[] = {
{ "ethernet", HTYPE_ETHERNET
},
{ "ethernet3", HTYPE_EXP_ETHERNET
},
{ "ether", HTYPE_ETHERNET
},
{ "ether3", HTYPE_EXP_ETHERNET
},
{ "ieee802", HTYPE_IEEE802
},
{ "token-ring", HTYPE_IEEE802
},
{ "pronet", HTYPE_PRONET
},
{ "chaos", HTYPE_CHAOS
},
{ "arcnet", HTYPE_ARCNET
},
{ "direct", HTYPE_DIRECT
},
{ "serial", HTYPE_DIRECT
},
{ "slip", HTYPE_DIRECT
},
* Externals and forward declarations.
extern boolean
iplookcmp();
PRIVATE
void fill_defaults();
PRIVATE
void del_string();
PRIVATE
void del_bindata();
PRIVATE
void del_iplist();
PRIVATE
void free_host();
PRIVATE u_long
get_u_long();
PRIVATE
void process_generic();
PRIVATE
char *get_string();
PRIVATE
struct shared_string
*get_shared_string();
PRIVATE
void read_entry();
PRIVATE boolean
nullcmp();
PRIVATE boolean
hwinscmp();
PRIVATE
void eat_whitespace();
PRIVATE
void makelower();
PRIVATE
struct in_addr_list
*get_addresses();
PRIVATE byte
*prs_haddr();
* Read bootptab database file. Avoid rereading the file if the
* write date hasn't changed since the last time we read it.
unsigned hashcode
, buflen
;
static char buffer
[MAXENTRYLEN
];
* Check the last modification time.
if (stat(bootptab
, &st
) < 0) {
report(LOG_ERR
, "stat on \"%s\": %s\n", bootptab
, get_errmsg());
strcpy(timestr
, ctime(&(st
.st_mtime
)));
report(LOG_INFO
, "bootptab mtime is %s",
if (st
.st_mtime
== modtime
&& st
.st_nlink
) {
* hasn't been modified or deleted yet.
report(LOG_INFO
, "reading %s\"%s\"\n",
(modtime
!= 0L) ? "new " : "",
if ((fp
= fopen(bootptab
, "r")) == NULL
) {
report(LOG_ERR
, "error opening \"%s\": %s\n", bootptab
, get_errmsg());
* Record file modification time.
if (fstat(fileno(fp
), &st
) < 0) {
report(LOG_ERR
, "fstat: %s\n", get_errmsg());
* Entirely erase all hash tables.
hash_Reset(hwhashtable
, free_host
);
hash_Reset(iphashtable
, free_host
);
hash_Reset(nmhashtable
, free_host
);
read_entry(fp
, buffer
, &buflen
);
if (buflen
== 0) { /* More entries? */
hp
= (struct host
*) smalloc(sizeof(struct host
));
hp
->flags
.vm_auto
= TRUE
;
bcopy(vm_rfc1048
, hp
->vm_cookie
, 4);
if (process_entry(hp
, buffer
) < 0) {
if ((hp
->flags
.htype
&& hp
->flags
.haddr
) || hp
->flags
.iaddr
) {
if (hp
->flags
.htype
&& hp
->flags
.haddr
) {
hashcode
= hash_HashFunction(hp
->haddr
, haddrlength(hp
->htype
));
if (hash_Insert(hwhashtable
, hashcode
, hwinscmp
, hp
, hp
) < 0) {
report(LOG_WARNING
, "duplicate %s address: %s\n",
haddrtoa(hp
->haddr
, hp
->htype
));
hashcode
= hash_HashFunction(&(hp
->iaddr
.s_addr
), 4);
if (hash_Insert(iphashtable
, hashcode
, nullcmp
, hp
, hp
) < 0) {
"hash_Insert() failed on IP address insertion\n");
hashcode
= hash_HashFunction(hp
->hostname
->string
,
strlen(hp
->hostname
->string
));
if (hash_Insert(nmhashtable
, hashcode
, nullcmp
, hp
->hostname
->string
, hp
) < 0) {
"hash_Insert() failed on insertion of hostname: \"%s\"\n",
report(LOG_INFO
, "read %d entries (%d hosts) from \"%s\"\n",
nentries
, nhosts
, bootptab
);
* Read an entire host entry from the file pointed to by "fp" and insert it
* into the memory pointed to by "buffer". Leading whitespace and comments
* starting with "#" are ignored (removed). Backslashes (\) always quote
* the next character except that newlines preceeded by a backslash cause
* line-continuation onto the next line. The entry is terminated by a
* newline character which is not preceeded by a backslash. Sequences
* surrounded by double quotes are taken literally (including newlines, but
* The "bufsiz" parameter points to an unsigned int which specifies the
* maximum permitted buffer size. Upon return, this value will be replaced
* with the actual length of the entry (not including the null terminator).
* This code is a little scary. . . . I don't like using gotos in C
* either, but I first wrote this as an FSM diagram and gotos seemed like
* the easiest way to implement it. Maybe later I'll clean it up.
PRIVATE
void read_entry(fp
, buffer
, bufsiz
)
* Eat whitespace, blank lines, and comment lines.
goto done
; /* Exit if end-of-file */
goto top
; /* Skip over whitespace */
while (TRUE
) { /* Eat comments after # */
goto done
; /* Exit if end-of-file */
goto top
; /* Try to read the next line */
ungetc(c
, fp
); /* Other character, push it back to reprocess it */
* Now we're actually reading a data entry. Get each character and
* assemble it into the data buffer, processing special characters like
* double quotes (") and backslashes (\).
goto done
; /* Exit on EOF or newline */
c
= fgetc(fp
); /* Backslash, read a new character */
goto done
; /* Exit on EOF */
*buffer
++ = c
; /* Store the literal character */
if (length
< *bufsiz
- 1) {
*buffer
++ = '"'; /* Store double-quote */
if (length
>= *bufsiz
- 1) {
while (TRUE
) { /* Special quote processing loop */
goto done
; /* Exit on EOF . . . */
*buffer
++ = '"'; /* Store matching quote */
if (length
< *bufsiz
- 1) {
goto mainloop
; /* And continue main loop */
if ((c
= fgetc(fp
)) < 0) { /* Backslash */
goto done
; /* EOF. . . .*/
} /* else fall through */
*buffer
++ = c
; /* Other character, store it */
if (length
>= *bufsiz
- 1) {
*buffer
++ = c
; /* Store colons */
if (length
>= *bufsiz
- 1) {
do { /* But remove whitespace after them */
if ((c
< 0) || (c
== '\n')) {
} while (isspace(c
)); /* Skip whitespace */
if (c
== '\\') { /* Backslash quotes next character */
goto top
; /* Backslash-newline continuation */
/* fall through if "other" character */
*buffer
++ = c
; /* Store other characters */
if (length
>= *bufsiz
- 1) {
goto mainloop
; /* Keep going */
*buffer
= '\0'; /* Terminate string */
*bufsiz
= length
; /* Tell the caller its length */
* Parse out all the various tags and parameters in the host entry pointed
* to by "src". Stuff all the data into the appropriate fields of the
* host structure pointed to by "host". If there is any problem with the
* entry, an error message is reported via report(), no further processing
* is done, and -1 is returned. Successful calls return 0.
* (Some errors probably shouldn't be so completely fatal. . . .)
PRIVATE
int process_entry(host
, src
)
if (!host
|| *src
== '\0') {
host
->hostname
= get_shared_string(&src
);
if (!goodname(host
->hostname
->string
)) {
report(LOG_ERR
, "bad hostname: \"%s\"\n", host
->hostname
->string
);
del_string(host
->hostname
);
retval
= eval_symbol(&src
, host
);
report(LOG_ERR
, "syntax error in entry for host \"%s\"\n",
report(LOG_ERR
, "unknown symbol in entry for host \"%s\"\n",
report(LOG_ERR
, "bad IP address for host \"%s\"\n",
report(LOG_ERR
, "bad hardware address for host \"%s\"\n",
report(LOG_ERR
, "bad subnet mask for host \"%s\"\n",
report(LOG_ERR
, "bad time offset for host \"%s\"\n",
report(LOG_ERR
, "bad vendor magic cookie for host \"%s\"\n",
report(LOG_ERR
, "bad home directory for host \"%s\"\n",
report(LOG_ERR
, "bad TFTP directory for host \"%s\"\n",
report(LOG_ERR
, "bad boot server IP address for host \"%s\"\n",
report(LOG_ERR
, "bad swap server IP address for host \"%s\"\n",
* For now, don't try to make-up a subnet mask if one
* This algorithm is also not entirely correct.
if (!(hp
->flags
.subnet_mask
)) {
* Try to deduce the subnet mask from the network class
value
= (ntohl(value
) >> 30) & 0x03;
hp
->subnet_mask
.s_addr
= htonl(0xFF000000L
);
hp
->subnet_mask
.s_addr
= htonl(0xFFFF0000L
);
hp
->subnet_mask
.s_addr
= htonl(0xFFFFFF00L
);
hp
->flags
.subnet_mask
= TRUE
;
* And now we're done with this entry
* Evaluate the two-character tag symbol pointed to by "symbol" and place
* the data in the structure pointed to by "hp". The pointer pointed to
* by "symbol" is updated to point past the source string (but may not
* point to the next tag entry).
* Obviously, this need a few more comments. . . .
PRIVATE
eval_symbol(symbol
, hp
)
char tmpstr
[MAXSTRINGLEN
];
struct shared_string
*ss
;
struct symbolmap
*symbolptr
;
int optype
; /* Indicates boolean, addition, or deletion */
if ((*symbol
)[0] == '\0') {
if ((*symbol
)[0] == ':') {
if ((*symbol
)[0] == 'T') { /* generic symbol */
value
= get_u_long(symbol
);
if ((*symbol
)[0] != '=') {
hp
->generic
= (struct shared_bindata
*)
smalloc(sizeof(struct shared_bindata
));
process_generic(symbol
, &(hp
->generic
), (byte
) (value
& 0xFF));
hp
->flags
.generic
= TRUE
;
* Determine the type of operation to be done on this symbol
numsymbols
= sizeof(symbol_list
) / sizeof(struct symbolmap
);
for (i
= 0; i
< numsymbols
; i
++) {
if (((symbolptr
->symbol
)[0] == (*symbol
)[0]) &&
((symbolptr
->symbol
)[1] == (*symbol
)[1])) {
* Skip past the = or @ character (to point to the data) if this
* isn't a boolean operation. For boolean operations, just skip
* over the two-character tag symbol (and nothing else. . . .).
(*symbol
) += (optype
== OP_BOOLEAN
) ? 2 : 3;
switch (symbolptr
->symbolcode
) {
if (ss
= get_shared_string(symbol
)) {
del_string(hp
->bootfile
);
hp
->flags
.bootfile
= TRUE
;
del_string(hp
->bootfile
);
hp
->flags
.bootfile
= FALSE
;
if (hp
->flags
.cookie_server
&& hp
->cookie_server
) {
del_iplist(hp
->cookie_server
);
hp
->cookie_server
= get_addresses(symbol
);
hp
->flags
.cookie_server
= TRUE
;
if (hp
->flags
.cookie_server
&& hp
->cookie_server
) {
del_iplist(hp
->cookie_server
);
hp
->cookie_server
= NULL
;
hp
->flags
.cookie_server
= FALSE
;
if (hp
->flags
.domain_server
&& hp
->domain_server
) {
del_iplist(hp
->domain_server
);
hp
->domain_server
= get_addresses(symbol
);
hp
->flags
.domain_server
= TRUE
;
if (hp
->flags
.domain_server
&& hp
->domain_server
) {
del_iplist(hp
->domain_server
);
hp
->domain_server
= NULL
;
hp
->flags
.domain_server
= FALSE
;
if (hp
->flags
.gateway
&& hp
->gateway
) {
hp
->gateway
= get_addresses(symbol
);
hp
->flags
.gateway
= TRUE
;
if (hp
->flags
.gateway
&& hp
->gateway
) {
hp
->flags
.gateway
= FALSE
;
if (hp
->flags
.htype
&& hp
->htype
&&
(tmphaddr
= prs_haddr(symbol
, hp
->htype
))) {
bcopy(tmphaddr
, hp
->haddr
, haddrlength(hp
->htype
));
if (ss
= get_shared_string(symbol
)) {
if ((ss
->string
)[0] == '/') {
hp
->flags
.homedir
= TRUE
;
hp
->flags
.homedir
= FALSE
;
value
= 0L; /* Assume an illegal value */
value
= get_u_long(symbol
);
(void) get_string(symbol
, tmpstr
, &len
);
numsymbols
= sizeof(htnamemap
) /
sizeof(struct htypename
);
for (i
= 0; i
< numsymbols
; i
++) {
if (!strcmp(htnamemap
[i
].name
, tmpstr
)) {
value
= htnamemap
[i
].htype
;
if ((value
< 0) || (value
> MAXHTYPES
)) {
hp
->htype
= (byte
) (value
& 0xFF);
if (hp
->flags
.impress_server
&& hp
->impress_server
) {
del_iplist(hp
->impress_server
);
hp
->impress_server
= get_addresses(symbol
);
hp
->flags
.impress_server
= TRUE
;
if (hp
->flags
.impress_server
&& hp
->impress_server
) {
del_iplist(hp
->impress_server
);
hp
->impress_server
= NULL
;
hp
->flags
.impress_server
= FALSE
;
if (prs_inetaddr(symbol
, &value
) < 0) {
hp
->iaddr
.s_addr
= value
;
if (hp
->flags
.log_server
&& hp
->log_server
) {
del_iplist(hp
->log_server
);
hp
->log_server
= get_addresses(symbol
);
hp
->flags
.log_server
= TRUE
;
if (hp
->flags
.log_server
&& hp
->log_server
) {
del_iplist(hp
->log_server
);
hp
->flags
.log_server
= FALSE
;
if (hp
->flags
.lpr_server
&& hp
->lpr_server
) {
del_iplist(hp
->lpr_server
);
hp
->lpr_server
= get_addresses(symbol
);
hp
->flags
.lpr_server
= TRUE
;
if (hp
->flags
.lpr_server
&& hp
->lpr_server
) {
del_iplist(hp
->lpr_server
);
hp
->flags
.lpr_server
= FALSE
;
if (hp
->flags
.name_server
&& hp
->name_server
) {
del_iplist(hp
->name_server
);
hp
->name_server
= get_addresses(symbol
);
hp
->flags
.name_server
= TRUE
;
if (hp
->flags
.name_server
&& hp
->name_server
) {
del_iplist(hp
->name_server
);
hp
->flags
.name_server
= FALSE
;
if (hp
->flags
.rlp_server
&& hp
->rlp_server
) {
del_iplist(hp
->rlp_server
);
hp
->rlp_server
= get_addresses(symbol
);
hp
->flags
.rlp_server
= TRUE
;
if (hp
->flags
.rlp_server
&& hp
->rlp_server
) {
del_iplist(hp
->rlp_server
);
hp
->flags
.rlp_server
= FALSE
;
if (prs_inetaddr(symbol
, &value
) < 0) {
hp
->subnet_mask
.s_addr
= value
;
hp
->flags
.subnet_mask
= TRUE
;
hp
->flags
.subnet_mask
= FALSE
;
(void) get_string(symbol
, tmpstr
, &len
);
if (!strncmp(tmpstr
, "auto", 4)) {
hp
->flags
.timeoff_auto
= TRUE
;
hp
->flags
.time_offset
= TRUE
;
if (sscanf(tmpstr
, "%ld", &timeoff
) != 1) {
hp
->time_offset
= timeoff
;
hp
->flags
.timeoff_auto
= FALSE
;
hp
->flags
.time_offset
= TRUE
;
hp
->flags
.time_offset
= FALSE
;
if (hp
->flags
.time_server
&& hp
->time_server
) {
del_iplist(hp
->time_server
);
hp
->time_server
= get_addresses(symbol
);
hp
->flags
.time_server
= TRUE
;
if (hp
->flags
.time_server
&& hp
->time_server
) {
del_iplist(hp
->time_server
);
hp
->flags
.time_server
= FALSE
;
if (!strncmp(*symbol
, "auto", 4)) {
hp
->flags
.vm_auto
= TRUE
; /* Make it auto */
} else if (!strncmp(*symbol
, "rfc1048", 7) ||
!strncmp(*symbol
, "rfc1084", 7)) {
hp
->flags
.vm_auto
= FALSE
; /* Make it manual */
bcopy(vm_rfc1048
, hp
->vm_cookie
, 4);
} else if (!strncmp(*symbol
, "cmu", 3)) {
hp
->flags
.vm_auto
= FALSE
; /* Make it manual */
bcopy(vm_cmu
, hp
->vm_cookie
, 4);
if (prs_inetaddr(symbol
, &value
) < 0) {
hp
->flags
.vm_auto
= FALSE
; /* Make it manual */
insert_u_long(value
, &ustr
);
hp
->flags
.vendor_magic
= TRUE
;
hp
->flags
.vendor_magic
= FALSE
;
hp
->flags
.vm_auto
= TRUE
;
hp
->flags
.vendor_magic
= TRUE
;
fill_defaults(hp
, symbol
);
hp
->flags
.send_name
= FALSE
;
hp
->flags
.name_switch
= FALSE
;
hp
->flags
.send_name
= TRUE
;
hp
->flags
.name_switch
= TRUE
;
if (!strncmp(*symbol
, "auto", 4)) {
hp
->flags
.bootsize
= TRUE
;
hp
->flags
.bootsize_auto
= TRUE
;
hp
->bootsize
= (unsigned int) get_u_long(symbol
);
hp
->flags
.bootsize
= TRUE
;
hp
->flags
.bootsize_auto
= FALSE
;
hp
->flags
.bootsize
= FALSE
;
hp
->flags
.bootsize
= TRUE
;
hp
->flags
.bootsize_auto
= TRUE
;
if (prs_inetaddr(symbol
, &value
) < 0) {
return E_BAD_BOOT_SERVER
;
hp
->bootserver
.s_addr
= value
;
hp
->flags
.bootserver
= TRUE
;
hp
->flags
.bootserver
= FALSE
;
if (ss
= get_shared_string(symbol
)) {
if ((ss
->string
)[0] == '/') {
hp
->flags
.tftpdir
= TRUE
;
hp
->flags
.tftpdir
= FALSE
;
if (ss
= get_shared_string(symbol
)) {
del_string(hp
->dumpfile
);
hp
->flags
.dumpfile
= TRUE
;
del_string(hp
->dumpfile
);
hp
->flags
.dumpfile
= FALSE
;
if (ss
= get_shared_string(symbol
)) {
del_string(hp
->domainname
);
hp
->flags
.domainname
= TRUE
;
del_string(hp
->domainname
);
hp
->flags
.domainname
= FALSE
;
if (ss
= get_shared_string(symbol
)) {
del_string(hp
->rootpath
);
hp
->flags
.rootpath
= TRUE
;
del_string(hp
->rootpath
);
hp
->flags
.rootpath
= FALSE
;
if (prs_inetaddr(symbol
, &value
) < 0) {
return E_BAD_SWAP_SERVER
;
hp
->swapserver
.s_addr
= value
;
hp
->flags
.swap_server
= TRUE
;
hp
->flags
.swap_server
= FALSE
;
* Read a string from the buffer indirectly pointed to through "src" and
* move it into the buffer pointed to by "dest". A pointer to the maximum
* allowable length of the string (including null-terminator) is passed as
* "length". The actual length of the string which was read is returned in
* the unsigned integer pointed to by "length". This value is the same as
* that which would be returned by applying the strlen() function on the
* destination string (i.e the terminating null is not counted as a
* character). Trailing whitespace is removed from the string. For
* convenience, the function returns the new value of "dest".
* The string is read until the maximum number of characters, an unquoted
* colon (:), or a null character is read. The return string in "dest" is
PRIVATE
char *get_string(src
, dest
, length
)
while ((n
< len
) && (**src
)) {
if (!quoteflag
&& (**src
== ':')) {
* Remove that troublesome trailing whitespace. . .
while ((n
> 0) && isspace(dest
[-1])) {
* Read the string indirectly pointed to by "src", update the caller's
* pointer, and return a pointer to a malloc'ed shared_string structure
* The string is read using the same rules as get_string() above.
PRIVATE
struct shared_string
*get_shared_string(src
)
char retstring
[MAXSTRINGLEN
];
length
= sizeof(retstring
);
(void) get_string(src
, retstring
, &length
);
s
= (struct shared_string
*) smalloc(sizeof(struct shared_string
)
strcpy(s
->string
, retstring
);
* Load RFC1048 generic information directly into a memory buffer.
* "src" indirectly points to the ASCII representation of the generic data.
* "dest" points to a string structure which is updated to point to a new
* string with the new data appended to the old string. The old string is
* The given tag value is inserted with the new data.
* The data may be represented as either a stream of hexadecimal numbers
* representing bytes (any or all bytes may optionally start with '0x' and
* be separated with periods ".") or as a quoted string of ASCII
* characters (the quotes are required).
PRIVATE
void process_generic(src
, dest
, tagvalue
)
struct shared_bindata
**dest
;
struct shared_bindata
*bdata
;
int newlength
, oldlength
;
*str
++ = tagvalue
; /* Store tag value */
str
++; /* Skip over length field */
if ((*src
)[0] == '"') { /* ASCII data */
newlength
= sizeof(tmpbuf
) - 2; /* Set maximum allowed length */
(void) get_string(src
, str
, &newlength
);
} else { /* Numeric data */
while (newlength
< sizeof(tmpbuf
) - 2) {
if (interp_byte(src
, str
++) < 0) {
tmpbuf
[1] = (byte
) (newlength
& 0xFF);
oldlength
= ((*dest
)->length
);
bdata
= (struct shared_bindata
*) smalloc(sizeof(struct shared_bindata
)
+ oldlength
+ newlength
+ 1);
bcopy((*dest
)->data
, bdata
->data
, oldlength
);
bcopy(tmpbuf
, bdata
->data
+ oldlength
, newlength
+ 2);
bdata
->length
= oldlength
+ newlength
+ 2;
* Verify that the given string makes sense as a hostname (according to
* Appendix 1, page 29 of RFC882).
* Return TRUE for good names, FALSE otherwise.
PRIVATE boolean
goodname(hostname
)
if (!isalpha(*hostname
++)) { /* First character must be a letter */
while (isalnum(*hostname
) || (*hostname
== '-')) {
hostname
++; /* Alphanumeric or a hyphen */
if (!isalnum(hostname
[-1])) { /* Last must be alphanumeric */
if (*hostname
== '\0') { /* Done? */
} while (*hostname
++ == '.'); /* Dot, loop for next label */
return FALSE
; /* If it's not a dot, lose */
* Null compare function -- always returns FALSE so an element is always
* inserted into a hash table (i.e. there is never a collision with an
PRIVATE boolean
nullcmp(host1
, host2
)
struct host
*host1
, *host2
;
* Function for comparing a string with the hostname field of a host
PRIVATE boolean
nmcmp(name
, hp
)
return !strcmp(name
, hp
->hostname
->string
);
* Compare function to determine whether two hardware addresses are
* equivalent. Returns TRUE if "host1" and "host2" are equivalent, FALSE
* If the hardware addresses of "host1" and "host2" are identical, but
* they are on different IP subnets, this function returns FALSE.
* This function is used when inserting elements into the hardware address
PRIVATE boolean
hwinscmp(host1
, host2
)
struct host
*host1
, *host2
;
if (host1
->htype
!= host2
->htype
) {
if (bcmp(host1
->haddr
, host2
->haddr
, haddrlength(host1
->htype
))) {
if ((host1
->subnet_mask
.s_addr
) == (host2
->subnet_mask
.s_addr
)) {
if (((host1
->iaddr
.s_addr
) & (host1
->subnet_mask
.s_addr
)) !=
((host2
->iaddr
.s_addr
) & (host2
->subnet_mask
.s_addr
))) {
* Process the "similar entry" symbol.
* The host specified as the value of the "tc" symbol is used as a template
* for the current host entry. Symbol values not explicitly set in the
* current host entry are inferred from the template entry.
PRIVATE
void fill_defaults(hp
, src
)
char tstring
[MAXSTRINGLEN
];
(void) get_string(src
, tstring
, &tlen
);
hashcode
= hash_HashFunction(tstring
, tlen
);
hp2
= (struct host
*) hash_Lookup(nmhashtable
, hashcode
, nmcmp
,
thp
.iaddr
.s_addr
= inet_addr(tstring
);
hashcode
= hash_HashFunction(&(thp
.iaddr
.s_addr
), 4);
hp2
= (struct host
*) hash_Lookup(iphashtable
, hashcode
, iplookcmp
,
report(LOG_ERR
, "can't find tc=\"%s\"\n", tstring
);
* Assignments inside "if" conditionals are intended here.
if (!hp
->flags
.cookie_server
) {
if (hp
->flags
.cookie_server
= hp2
->flags
.cookie_server
) {
hp
->cookie_server
= hp2
->cookie_server
;
(hp
->cookie_server
->linkcount
)++;
if (!hp
->flags
.domain_server
) {
if (hp
->flags
.domain_server
= hp2
->flags
.domain_server
) {
hp
->domain_server
= hp2
->domain_server
;
(hp
->domain_server
->linkcount
)++;
if (!hp
->flags
.gateway
) {
if (hp
->flags
.gateway
= hp2
->flags
.gateway
) {
hp
->gateway
= hp2
->gateway
;
(hp
->gateway
->linkcount
)++;
if (!hp
->flags
.impress_server
) {
if (hp
->flags
.impress_server
= hp2
->flags
.impress_server
) {
hp
->impress_server
= hp2
->impress_server
;
(hp
->impress_server
->linkcount
)++;
if (!hp
->flags
.log_server
) {
if (hp
->flags
.log_server
= hp2
->flags
.log_server
) {
hp
->log_server
= hp2
->log_server
;
(hp
->log_server
->linkcount
)++;
if (!hp
->flags
.lpr_server
) {
if (hp
->flags
.lpr_server
= hp2
->flags
.lpr_server
) {
hp
->lpr_server
= hp2
->lpr_server
;
(hp
->lpr_server
->linkcount
)++;
if (!hp
->flags
.name_server
) {
if (hp
->flags
.name_server
= hp2
->flags
.name_server
) {
hp
->name_server
= hp2
->name_server
;
(hp
->name_server
->linkcount
)++;
if (!hp
->flags
.rlp_server
) {
if (hp
->flags
.rlp_server
= hp2
->flags
.rlp_server
) {
hp
->rlp_server
= hp2
->rlp_server
;
(hp
->rlp_server
->linkcount
)++;
if (!hp
->flags
.time_server
) {
if (hp
->flags
.time_server
= hp2
->flags
.time_server
) {
hp
->time_server
= hp2
->time_server
;
(hp
->time_server
->linkcount
)++;
if (!hp
->flags
.homedir
) {
if (hp
->flags
.homedir
= hp2
->flags
.homedir
) {
hp
->homedir
= hp2
->homedir
;
(hp
->homedir
->linkcount
)++;
if (!hp
->flags
.bootfile
) {
if (hp
->flags
.bootfile
= hp2
->flags
.bootfile
) {
hp
->bootfile
= hp2
->bootfile
;
(hp
->bootfile
->linkcount
)++;
if (!hp
->flags
.generic
) {
if (hp
->flags
.generic
= hp2
->flags
.generic
) {
hp
->generic
= hp2
->generic
;
(hp
->generic
->linkcount
)++;
if (!hp
->flags
.vendor_magic
) {
hp
->flags
.vm_auto
= hp2
->flags
.vm_auto
;
if (hp
->flags
.vendor_magic
= hp2
->flags
.vendor_magic
) {
bcopy(hp2
->vm_cookie
, hp
->vm_cookie
, 4);
if (!hp
->flags
.name_switch
) {
if (hp
->flags
.name_switch
= hp2
->flags
.name_switch
) {
hp
->flags
.send_name
= hp2
->flags
.send_name
;
if (hp
->flags
.htype
= hp2
->flags
.htype
) {
if (!hp
->flags
.time_offset
) {
if (hp
->flags
.time_offset
= hp2
->flags
.time_offset
) {
hp
->flags
.timeoff_auto
= hp2
->flags
.timeoff_auto
;
hp
->time_offset
= hp2
->time_offset
;
if (!hp
->flags
.subnet_mask
) {
if (hp
->flags
.subnet_mask
= hp2
->flags
.subnet_mask
) {
hp
->subnet_mask
.s_addr
= hp2
->subnet_mask
.s_addr
;
if (!hp
->flags
.swap_server
) {
if (hp
->flags
.swap_server
= hp2
->flags
.swap_server
) {
hp
->swapserver
.s_addr
= hp2
->swapserver
.s_addr
;
if (!hp
->flags
.bootsize
) {
if (hp
->flags
.bootsize
= hp2
->flags
.bootsize
) {
hp
->flags
.bootsize_auto
= hp2
->flags
.bootsize_auto
;
hp
->bootsize
= hp2
->bootsize
;
if (!hp
->flags
.tftpdir
) {
if (hp
->flags
.tftpdir
= hp2
->flags
.tftpdir
) {
hp
->tftpdir
= hp2
->tftpdir
;
(hp
->tftpdir
->linkcount
)++;
if (!hp
->flags
.rootpath
) {
if (hp
->flags
.rootpath
= hp2
->flags
.rootpath
) {
hp
->rootpath
= hp2
->rootpath
;
(hp
->rootpath
->linkcount
)++;
if (!hp
->flags
.domainname
) {
if (hp
->flags
.domainname
= hp2
->flags
.domainname
) {
hp
->domainname
= hp2
->domainname
;
(hp
->domainname
->linkcount
)++;
if (!hp
->flags
.dumpfile
) {
if (hp
->flags
.dumpfile
= hp2
->flags
.dumpfile
) {
hp
->dumpfile
= hp2
->dumpfile
;
(hp
->dumpfile
->linkcount
)++;
* This function adjusts the caller's pointer to point just past the
* first-encountered colon. If it runs into a null character, it leaves
* the pointer pointing to it.
while (*t
&& (*t
!= ':')) {
* This function adjusts the caller's pointer to point to the first
* non-whitespace character. If it runs into a null character, it leaves
* the pointer pointing to it.
PRIVATE
void eat_whitespace(s
)
while (*t
&& isspace(*t
)) {
* This function converts the given string to all lowercase.
PRIVATE
void makelower(s
)
* In many of the functions which follow, a parameter such as "src" or
* "symbol" is passed as a pointer to a pointer to something. This is
* done for the purpose of letting the called function update the
* caller's copy of the parameter (i.e. to effect call-by-reference
* parameter passing). The value of the actual parameter is only used
* to locate the real parameter of interest and then update this indirect
* I'm sure somebody out there won't like this. . . .
* "src" points to a character pointer which points to an ASCII string of
* whitespace-separated IP addresses. A pointer to an in_addr_list
* structure containing the list of addresses is returned. NULL is
* returned if no addresses were found at all. The pointer pointed to by
* "src" is updated to point to the first non-address (illegal) character.
PRIVATE
struct in_addr_list
*get_addresses(src
)
struct in_addr tmpaddrlist
[MAXINADDRS
];
struct in_addr
*address1
, *address2
;
struct in_addr_list
*result
;
unsigned addrcount
, totalsize
;
for (addrcount
= 0; addrcount
< MAXINADDRS
; addrcount
++) {
while (**src
&& isspace(**src
)) { /* Skip whitespace */
if (! **src
) { /* Quit if nothing more */
if (prs_inetaddr(src
, &(address1
->s_addr
)) < 0) {
address1
++; /* Point to next address slot */
totalsize
= sizeof(struct in_addr_list
)
+ (addrcount
- 1) * sizeof(struct in_addr
);
result
= (struct in_addr_list
*) smalloc(totalsize
);
result
->addrcount
= addrcount
;
for (; addrcount
> 0; addrcount
--) {
address2
->s_addr
= address1
->s_addr
;
* prs_inetaddr(src, result)
* "src" is a value-result parameter; the pointer it points to is updated
* to point to the next data position. "result" points to an unsigned long
* in which an address is returned.
* This function parses the IP address string in ASCII "dot notation" pointed
* to by (*src) and places the result (in network byte order) in the unsigned
* long pointed to by "result". For malformed addresses, -1 is returned,
* (*src) points to the first illegal character, and the unsigned long pointed
* to by "result" is unchanged. Successful calls return 0.
PRIVATE
prs_inetaddr(src
, result
)
u_long parts
[4], *pp
= parts
;
* a.b.c (with c treated as 16-bits)
* a.b (with b treated as 24 bits)
* Check for trailing characters.
if (**src
&& !(isspace(**src
) || (**src
== ':'))) {
* Construct the address according to
* the number of parts specified.
case 1: /* a -- 32 bits */
case 2: /* a.b -- 8.24 bits */
value
= (parts
[0] << 24) | (parts
[1] & 0xFFFFFF);
case 3: /* a.b.c -- 8.8.16 bits */
value
= (parts
[0] << 24) | ((parts
[1] & 0xFF) << 16) |
case 4: /* a.b.c.d -- 8.8.8.8 bits */
value
= (parts
[0] << 24) | ((parts
[1] & 0xFF) << 16) |
((parts
[2] & 0xFF) << 8) | (parts
[3] & 0xFF);
* "src" points to a pointer which in turn points to a hexadecimal ASCII
* string. This string is interpreted as a hardware address and returned
* as a pointer to the actual hardware address, represented as an array of
* The ASCII string must have the proper number of digits for the specified
* hardware type (e.g. twelve digits for a 48-bit Ethernet address).
* Two-digit sequences (bytes) may be separated with periods (.) and/or
* prefixed with '0x' for readability, but this is not required.
* For bad addresses, the pointer which "src" points to is updated to point
* to the start of the first two-digit sequence which was bad, and the
* function returns a NULL pointer.
PRIVATE byte
*prs_haddr(src
, htype
)
static byte haddr
[MAXHADDRLEN
];
hlen
= haddrlength(htype
); /* Get length of this address type */
while (hptr
< haddr
+ hlen
) {
if (interp_byte(src
, hptr
++) < 0) {
* "src" is a pointer to a character pointer which in turn points to a
* hexadecimal ASCII representation of a byte. This byte is read, the
* character pointer is updated, and the result is deposited into the
* byte pointed to by "retbyte".
* The usual '0x' notation is allowed but not required. The number must be
* a two digit hexadecimal number. If the number is invalid, "src" and
* "retbyte" are left untouched and -1 is returned as the function value.
* Successful calls return 0.
PRIVATE
int interp_byte(src
, retbyte
)
if ((*src
)[0] == '0' && (*src
)[1] == 'x' || (*src
)[1] == 'X') {
(*src
) += 2; /* allow 0x for hex, but don't require it */
if (!isxdigit((*src
)[0]) || !isxdigit((*src
)[1])) {
if (sscanf(*src
, "%2x", &v
) != 1) {
*retbyte
= (byte
) (v
& 0xFF);
* The parameter "src" points to a character pointer which points to an
* ASCII string representation of an unsigned number. The number is
* returned as an unsigned long and the character pointer is updated to
* point to the first illegal character.
PRIVATE u_long
get_u_long(src
)
register u_long value
, base
;
* Collect number up to first illegal character. Values are specified
* as for C: 0x=hex, 0=octal, other=decimal.
if (**src
== 'x' || **src
== 'X') {
value
= (value
* base
) + (c
- '0');
if (base
== 16 && isxdigit(c
)) {
value
= (value
<< 4) + ((c
& ~32) + 10 - 'A');
* Routines for deletion of data associated with the main data structure.
* Frees the entire host data structure given. Does nothing if the passed
PRIVATE
void free_host(hostptr
)
del_iplist(hostptr
->cookie_server
);
del_iplist(hostptr
->domain_server
);
del_iplist(hostptr
->gateway
);
del_iplist(hostptr
->impress_server
);
del_iplist(hostptr
->log_server
);
del_iplist(hostptr
->lpr_server
);
del_iplist(hostptr
->name_server
);
del_iplist(hostptr
->rlp_server
);
del_iplist(hostptr
->time_server
);
del_string(hostptr
->hostname
);
del_string(hostptr
->homedir
);
del_string(hostptr
->bootfile
);
del_string(hostptr
->tftpdir
);
del_string(hostptr
->rootpath
);
del_string(hostptr
->domainname
);
del_string(hostptr
->dumpfile
);
del_bindata(hostptr
->generic
);
* Decrements the linkcount on the given IP address data structure. If the
* linkcount goes to zero, the memory associated with the data is freed.
PRIVATE
void del_iplist(iplist
)
struct in_addr_list
*iplist
;
if (! (--(iplist
->linkcount
))) {
* Decrements the linkcount on a string data structure. If the count
* goes to zero, the memory associated with the string is freed. Does
* nothing if the passed pointer is NULL.
PRIVATE
void del_string(stringptr
)
struct shared_string
*stringptr
;
if (! (--(stringptr
->linkcount
))) {
free((char *) stringptr
);
* Decrements the linkcount on a shared_bindata data structure. If the
* count goes to zero, the memory associated with the data is freed. Does
* nothing if the passed pointer is NULL.
PRIVATE
void del_bindata(dataptr
)
struct shared_bindata
*dataptr
;
if (! (--(dataptr
->linkcount
))) {
/* smalloc() -- safe malloc()
* Always returns a valid pointer (if it returns at all). The allocated
* memory is initialized to all zeros. If malloc() returns an error, a
* message is printed using the report() function and the program aborts
PRIVATE
char *smalloc(nbytes
)
retvalue
= malloc(nbytes
);
report(LOG_ERR
, "malloc() failure -- exiting\n");