char *
read_stdin(int *stdin_size) {
struct stat stat;
fstat(0, &stat);
char *result = malloc(stat.st_size);
do {
fgets_unlocked(result, stat.st_size, stdin);
} while (strncmp(result, ">THREE", 6));
int read = 0;
while (fgets_unlocked(result + read, stat.st_size - read, stdin)) {
int len = strlen(result + read);
if (len == 0 || result[read] == '>') {
break;
}
read += len;
if (result[read - 1] == '\n') {
read--;
}
}
result[read++] = '>';
result = realloc(result, read);
*stdin_size = read;
return result;
}
/* Hack around the fact that fgets only accepts int sizes. */
static get_contents_ret
get_contents (char *linebuf, size_t len, FILE *stream)
{
size_t remaining_len = len;
char *curbuf = linebuf;
do
{
int curlen = ((remaining_len > (size_t) INT_MAX) ? INT_MAX
: remaining_len);
char *p = fgets_unlocked (curbuf, curlen, stream);
((unsigned char *) curbuf)[curlen - 1] = 0xff;
/* EOF or read error. */
if (p == NULL)
return gcr_error;
/* Done reading in the line. */
if (((unsigned char *) curbuf)[curlen - 1] == 0xff)
return gcr_ok;
/* Drop the terminating '\0'. */
remaining_len -= curlen - 1;
curbuf += curlen - 1;
}
/* fgets copies one less than the input length. Our last iteration is of
REMAINING_LEN and once that is done, REMAINING_LEN is decremented by
REMAINING_LEN - 1, leaving the result as 1. */
while (remaining_len > 1);
/* This means that the current buffer was not large enough. */
return gcr_overflow;
}
static char *get_line(FILE *f, char *buf, unsigned size, int *lineno,
const char *file)
{
int too_long = 0;
while (fgets_unlocked(buf, size, f)) {
/* remove newline */
char *ptr = strchr(buf, 0x0a);
if (ptr) {
if (!too_long) {
*ptr = 0;
return buf;
}
// Reset and start with the next line
too_long = 0;
*lineno = *lineno + 1;
} else {
// If a line is too long skip it.
// Only output 1 warning
if (!too_long)
audit_msg(LOG_ERR,
"Skipping line %d in %s: too long",
*lineno, file);
too_long = 1;
}
}
return NULL;
}
/* General function to get information about memory status from proc
filesystem. */
static long int
internal_function
phys_pages_info (const char *format)
{
char buffer[8192];
long int result = -1;
/* If we haven't found an appropriate entry return 1. */
FILE *fp = fopen ("/proc/meminfo", "rc");
if (fp != NULL)
{
/* No threads use this stream. */
__fsetlocking (fp, FSETLOCKING_BYCALLER);
result = 0;
/* Read all lines and count the lines starting with the
string "processor". We don't have to fear extremely long
lines since the kernel will not generate them. 8192
bytes are really enough. */
while (fgets_unlocked (buffer, sizeof buffer, fp) != NULL)
if (sscanf (buffer, format, &result) == 1)
{
result /= (__getpagesize () / 1024);
break;
}
fclose (fp);
}
if (result == -1)
/* We cannot get the needed value: signal an error. */
__set_errno (ENOSYS);
return result;
}
char *
read_stdin(int *stdin_size) {
int input_size;
char *temp = NULL;
#ifdef ARRAYFILE
input_size = fasta_output_len;
#else
struct stat stat;
fstat(0, &stat);
input_size = stat.st_size;
#endif
char *result = allocate_mem(input_size);
do {
assert(fgets_unlocked(result, input_size, stdin));
} while (strncmp(result, ">THREE", 6));
int read = 0;
while (fgets_unlocked(result + read, input_size - read, stdin)) {
int len = strlen(result + read);
if (len == 0 || result[read] == '>') {
break;
}
read += len;
if (result[read - 1] == '\n') {
read--;
}
}
result[read++] = '>';
//result = realloc(result, read);
temp = allocate_mem(read);
if(!temp) {
return NULL;
}
memcpy(temp,result, read);
nv_free(result);
result = temp;
*stdin_size = read;
return result;
}
struct selabel_sub *selabel_subs_init(const char *path, struct selabel_sub *list)
{
char buf[1024];
FILE *cfg = fopen(path, "r");
struct selabel_sub *sub;
if (!cfg)
return list;
while (fgets_unlocked(buf, sizeof(buf) - 1, cfg)) {
char *ptr = NULL;
char *src = buf;
char *dst = NULL;
while (*src && isspace(*src))
src++;
if (src[0] == '#') continue;
ptr = src;
while (*ptr && ! isspace(*ptr))
ptr++;
*ptr++ = '\0';
if (! *src) continue;
dst = ptr;
while (*dst && isspace(*dst))
dst++;
ptr=dst;
while (*ptr && ! isspace(*ptr))
ptr++;
*ptr='\0';
if (! *dst)
continue;
sub = malloc(sizeof(*sub));
if (! sub)
goto err;
memset(sub, 0, sizeof(*sub));
sub->src=strdup(src);
if (! sub->src)
goto err;
sub->dst=strdup(dst);
if (! sub->dst)
goto err;
sub->slen = strlen(src);
sub->next = list;
list = sub;
}
out:
fclose(cfg);
return list;
err:
if (sub)
free(sub->src);
free(sub);
goto out;
}
int main (void) {
int sum = 0;
char line[MAXLINELEN];
while (fgets_unlocked (line, MAXLINELEN, stdin))
sum += strtol (line, NULL, 0);
printf ("%d\n", sum);
return 0;
}
static char *get_line(FILE *f, char *buf)
{
if (fgets_unlocked(buf, 128, f)) {
/* remove newline */
char *ptr = strchr(buf, 0x0a);
if (ptr)
*ptr = 0;
return buf;
}
return NULL;
}
static enum nss_status
search (const char *netname, char *result, int *errnop, int secret)
{
FILE *stream = fopen (DATAFILE, "rce");
if (stream == NULL)
return errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
for (;;)
{
char buffer[HEXKEYBYTES * 2 + KEYCHECKSUMSIZE + MAXNETNAMELEN + 17];
char *p;
char *save_ptr;
buffer[sizeof (buffer) - 1] = '\xff';
p = fgets_unlocked (buffer, sizeof (buffer), stream);
if (p == NULL)
{
/* End of file or read error. */
*errnop = errno;
fclose (stream);
return NSS_STATUS_NOTFOUND;
}
else if (buffer[sizeof (buffer) - 1] != '\xff')
{
/* Invalid line in file? Skip remainder of line. */
if (buffer[sizeof (buffer) - 2] != '\0')
while (getc_unlocked (stream) != '\n')
continue;
continue;
}
/* Parse line. */
p = __strtok_r (buffer, "# \t:\n", &save_ptr);
if (p == NULL) /* Skip empty and comment lines. */
continue;
if (strcmp (p, netname) != 0)
continue;
/* A hit! Find the field we want and return. */
p = __strtok_r (NULL, ":\n", &save_ptr);
if (p == NULL) /* malformed line? */
continue;
if (secret)
p = __strtok_r (NULL, ":\n", &save_ptr);
if (p == NULL) /* malformed line? */
continue;
fclose (stream);
strcpy (result, p);
return NSS_STATUS_SUCCESS;
}
}
static int get_failsafe_context(const char *user, security_context_t * newcon)
{
FILE *fp;
char buf[255], *ptr;
size_t plen, nlen;
int rc;
fp = fopen(selinux_failsafe_context_path(), "r");
if (!fp)
return -1;
ptr = fgets_unlocked(buf, sizeof buf, fp);
fclose(fp);
if (!ptr)
return -1;
plen = strlen(ptr);
if (buf[plen - 1] == '\n')
buf[plen - 1] = 0;
retry:
nlen = strlen(user) + 1 + plen + 1;
*newcon = malloc(nlen);
if (!(*newcon))
return -1;
rc = snprintf(*newcon, nlen, "%s:%s", user, ptr);
if (rc < 0 || (size_t) rc >= nlen) {
free(*newcon);
*newcon = 0;
return -1;
}
/* If possible, check the context to catch
errors early rather than waiting until the
caller tries to use setexeccon on the context.
But this may not always be possible, e.g. if
selinuxfs isn't mounted. */
if (security_check_context(*newcon) && errno != ENOENT) {
free(*newcon);
*newcon = 0;
if (strcmp(user, SELINUX_DEFAULTUSER)) {
user = SELINUX_DEFAULTUSER;
goto retry;
}
return -1;
}
return 0;
}
int main(int argc, char *argv[])
{
char tmp[MAX_AUDIT_MESSAGE_LENGTH+1];
struct sigaction sa;
/* Register sighandlers */
sa.sa_flags = 0;
sigemptyset(&sa.sa_mask);
/* Set handler for the ones we care about */
sa.sa_handler = term_handler;
sigaction(SIGTERM, &sa, NULL);
sa.sa_handler = hup_handler;
sigaction(SIGHUP, &sa, NULL);
/* Initialize the auparse library */
au = auparse_init(AUSOURCE_FEED, 0);
if (au == NULL) {
printf("audisp-example is exiting due to auparse init errors");
return -1;
}
auparse_add_callback(au, handle_event, NULL, NULL);
do {
/* Load configuration */
if (hup) {
reload_config();
}
/* Now the event loop */
while (fgets_unlocked(tmp, MAX_AUDIT_MESSAGE_LENGTH, stdin) &&
hup==0 && stop==0) {
auparse_feed(au, tmp, strnlen(tmp,
MAX_AUDIT_MESSAGE_LENGTH));
}
if (feof(stdin))
break;
} while (stop == 0);
/* Flush any accumulated events from queue */
auparse_flush_feed(au);
auparse_destroy(au);
if (stop)
printf("audisp-example is exiting on stop request\n");
else
printf("audisp-example is exiting on stdin EOF\n");
return 0;
}
/*
* This function returns a malloc'd buffer of the next record in the audit
* logs. It returns 0 on success, 1 on eof, -1 on error.
*/
static int get_record(llist **l)
{
char *rc;
char *buff = NULL;
*l = get_ready_event(&lo);
if (*l)
return 0;
while (1) {
if (!buff) {
buff = malloc(MAX_AUDIT_MESSAGE_LENGTH);
if (!buff)
return -1;
}
rc = fgets_unlocked(buff, MAX_AUDIT_MESSAGE_LENGTH,
log_fd);
if (rc) {
if (lol_add_record(&lo, buff)) {
*l = get_ready_event(&lo);
if (*l)
break;
}
} else {
free(buff);
if (feof_unlocked(log_fd)) {
// Only mark all events complete if this is
// the last file.
if (files_to_process == 0) {
terminate_all_events(&lo);
}
*l = get_ready_event(&lo);
if (*l)
return 0;
else
return 1;
} else
return -1;
}
}
free(buff);
return 0;
}
/* Read one shadow entry from the given stream. */
int
__fgetsgent_r (FILE *stream, struct sgrp *resbuf, char *buffer, size_t buflen,
struct sgrp **result)
{
char *p;
_IO_flockfile (stream);
do
{
buffer[buflen - 1] = '\xff';
p = fgets_unlocked (buffer, buflen, stream);
if (p == NULL && feof_unlocked (stream))
{
_IO_funlockfile (stream);
*result = NULL;
__set_errno (ENOENT);
return errno;
}
if (p == NULL || buffer[buflen - 1] != '\xff')
{
_IO_funlockfile (stream);
*result = NULL;
__set_errno (ERANGE);
return errno;
}
/* Skip leading blanks. */
while (isspace (*p))
++p;
} while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */
/* Parse the line. If it is invalid, loop to
get the next line of the file to parse. */
! parse_line (buffer, (void *) resbuf, (void *) buffer, buflen,
&errno));
_IO_funlockfile (stream);
*result = resbuf;
return 0;
}
static int find_default_type(FILE * fp, const char *role, char **type)
{
char buf[250];
char *ptr = "", *end, *t;
size_t len;
int found = 0;
len = strlen(role);
while (!feof_unlocked(fp)) {
if (!fgets_unlocked(buf, sizeof buf, fp))
return -1;
if (buf[strlen(buf) - 1])
buf[strlen(buf) - 1] = 0;
ptr = buf;
while (*ptr && isspace(*ptr))
ptr++;
if (!(*ptr))
continue;
if (!strncmp(role, ptr, len)) {
end = ptr + len;
if (*end == ':') {
found = 1;
ptr = ++end;
break;
}
}
}
if (!found)
return -1;
t = malloc(strlen(buf) - len);
if (!t)
return -1;
strcpy(t, ptr);
*type = t;
return 0;
}
/*
* This function returns a malloc'd buffer of the next record in the audit
* logs. It returns 0 on success, 1 on eof, -1 on error.
*/
static int get_record(llist **l)
{
char *rc;
char *buff = NULL;
*l = get_ready_event(&lo);
if (*l)
return 0;
while (1) {
if (!buff) {
buff = malloc(MAX_AUDIT_MESSAGE_LENGTH);
if (!buff)
return -1;
}
rc = fgets_unlocked(buff, MAX_AUDIT_MESSAGE_LENGTH,
log_fd);
if (rc) {
if (lol_add_record(&lo, buff)) {
*l = get_ready_event(&lo);
if (*l)
break;
}
} else {
free(buff);
if (feof_unlocked(log_fd)) {
terminate_all_events(&lo);
*l = get_ready_event(&lo);
if (*l)
return 0;
else
return 1;
} else
return -1;
}
}
free(buff);
return 0;
}
int
__get_nprocs ()
{
char buffer[8192];
int result = 1;
/* XXX Here will come a test for the new system call. */
/* The /proc/stat format is more uniform, use it by default. */
FILE *fp = fopen ("/proc/stat", "rc");
if (fp != NULL)
{
/* No threads use this stream. */
__fsetlocking (fp, FSETLOCKING_BYCALLER);
result = 0;
while (fgets_unlocked (buffer, sizeof (buffer), fp) != NULL)
if (strncmp (buffer, "cpu", 3) == 0 && isdigit (buffer[3]))
++result;
fclose (fp);
}
else
{
fp = fopen ("/proc/cpuinfo", "rc");
if (fp != NULL)
{
/* No threads use this stream. */
__fsetlocking (fp, FSETLOCKING_BYCALLER);
GET_NPROCS_PARSER (fp, buffer, result);
fclose (fp);
}
}
return result;
}
/*
* Copyright (c) 2011, 2012, 2014 Jonas 'Sortie' Termansen.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, 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 SOFTWARE.
*
* stdio/fgets.c
* Reads a string from a FILE.
*/
#include <stdio.h>
char* fgets(char* restrict dest, int size, FILE* restrict fp)
{
flockfile(fp);
char* result = fgets_unlocked(dest, size, fp);
funlockfile(fp);
return result;
}
static enum nss_status
internal_getgrent_r (ent_t *ent, char *buffer, size_t buflen, const char *user,
gid_t group, long int *start, long int *size,
gid_t **groupsp, long int limit, int *errnop)
{
struct parser_data *data = (void *) buffer;
struct group grpbuf;
if (!ent->files)
return getgrent_next_nss (ent, buffer, buflen, user, group,
start, size, groupsp, limit, errnop);
while (1)
{
fpos_t pos;
int parse_res = 0;
char *p;
do
{
/* We need at least 3 characters for one line. */
if (__builtin_expect (buflen < 3, 0))
{
erange:
*errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
}
fgetpos (ent->stream, &pos);
buffer[buflen - 1] = '\xff';
p = fgets_unlocked (buffer, buflen, ent->stream);
if (p == NULL && feof_unlocked (ent->stream))
return NSS_STATUS_NOTFOUND;
if (p == NULL || __builtin_expect (buffer[buflen - 1] != '\xff', 0))
{
erange_reset:
fsetpos (ent->stream, &pos);
goto erange;
}
/* Terminate the line for any case. */
buffer[buflen - 1] = '\0';
/* Skip leading blanks. */
while (isspace (*p))
++p;
}
while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */
/* Parse the line. If it is invalid, loop to
get the next line of the file to parse. */
!(parse_res = _nss_files_parse_grent (p, &grpbuf, data, buflen,
errnop)));
if (__builtin_expect (parse_res == -1, 0))
/* The parser ran out of space. */
goto erange_reset;
if (grpbuf.gr_name[0] != '+' && grpbuf.gr_name[0] != '-')
/* This is a real entry. */
break;
/* -group */
if (grpbuf.gr_name[0] == '-' && grpbuf.gr_name[1] != '\0'
&& grpbuf.gr_name[1] != '@')
{
blacklist_store_name (&grpbuf.gr_name[1], ent);
continue;
}
/* +group */
if (grpbuf.gr_name[0] == '+' && grpbuf.gr_name[1] != '\0'
&& grpbuf.gr_name[1] != '@')
{
if (in_blacklist (&grpbuf.gr_name[1],
strlen (&grpbuf.gr_name[1]), ent))
continue;
/* Store the group in the blacklist for the "+" at the end of
/etc/group */
blacklist_store_name (&grpbuf.gr_name[1], ent);
if (nss_getgrnam_r == NULL)
return NSS_STATUS_UNAVAIL;
else if (nss_getgrnam_r (&grpbuf.gr_name[1], &grpbuf, buffer,
buflen, errnop) != NSS_STATUS_SUCCESS)
continue;
check_and_add_group (user, group, start, size, groupsp,
limit, &grpbuf);
return NSS_STATUS_SUCCESS;
}
/* +:... */
if (grpbuf.gr_name[0] == '+' && grpbuf.gr_name[1] == '\0')
{
ent->files = FALSE;
return getgrent_next_nss (ent, buffer, buflen, user, group,
start, size, groupsp, limit, errnop);
}
}
check_and_add_group (user, group, start, size, groupsp, limit, &grpbuf);
return NSS_STATUS_SUCCESS;
}
size_t read_alias_file( unsigned char *fname, int fname_len )
{
int ecx;
FILE *fp;
size_t added;
*(int*)(mempcpy( mem_alloc( fname_len + 14 ), &fname[0], fname_len )) = 0x636f6c2f;
*(int*)(mempcpy( mem_alloc( fname_len + 14 ), &fname[0], fname_len ) + 4) = 0x2e656c61;
*(int*)(mempcpy( mem_alloc( fname_len + 14 ), &fname[0], fname_len ) + 8) = 0x61696c61;
*(short*)(mempcpy( mem_alloc( fname_len + 14 ), &fname[0], fname_len ) + 12) = 115;
fp = fopen64( *ebp_16472, "rb" );
mem_free( *ebp_16472 );
added = 0;
if ( fp[0]._flags )
{
while ( !( ( fp->_flags/*.1_1of4*/ & 16 ) & 255 ) && fgets_unlocked( buf, 8192, &fp[0] ) )
{
if ( strchr( buf, 10 ) == 0 )
{
do
{
}
while ( !fgets_unlocked( ebp_16412, 8192, &fp[0] ) || strchr( ebp_16412, 10 ) );
}
{
unsigned char altbuf[8192];
cp[0] = buf[0];
if ( cp[0] == '#' || ( cp[0] & 255 ) == 0 )
continue;
else
{
cp[0] = cp[0] + 1;
if ( cp[1] )
{
cp[0] = 0;
cp[0] = cp[1];
}
else
cp[0] = cp[0];
if ( ( cp[0] & 255 ) == 0 )
continue;
else
{
size_t alias_len;
size_t value_len;
if ( cp[1] )
{
if ( cp[1] == 10 )
{
cp[1] = 0;
cp[1] = 10;
}
else
cp[1] = 0;
}
if ( maxmap <= nmap )
{
if ( realloc( map, 800 ? 800 << 4 : 800 ) )
{
map = (struct sgml_node_info*)realloc( map, 800 ? 800 << 4 : 800 );
maxmap = edx;
}
}
alias_len = strlen( &cp[0] ) + 1;
value_len = strlen( &cp[0] ) + 1;
if ( string_space_act + value_len + alias_len <= string_space_max )
{
}
else
{
size_t new_size = new_pool[ (unsigned char)( ( value_len + alias_len < 1024 ) ^ 1 ) ? 1024 : value_len + alias_len ];
unsigned char *new_pool = (unsigned char*)realloc( string_space, new_pool[ (unsigned char)( ( value_len + alias_len < 1024 ) ^ 1 ) ? 1024 : value_len + alias_len ] );
if ( new_pool )
{
if ( string_space == new_pool )
{
}
else
{
size_t i;
if ( nmap )
{
string_space[0] = new_pool - string_space;
i = 0;
do
{
map->string.length += new_pool - string_space;
map->string.string += new_pool - string_space;
i++;
}
while ( i + 1 < nmap );
}
else
{
}
}
string_space_max = new_size;
string_space = new_pool;
}
}
map->string.length = memcpy( string_space + added, &cp[0] );
string_space_act += ebp_16444;
map->string.string = (unsigned char*)memcpy( &string_space[ ebp_16444 + string_space_act ], &cp[0] );
string_space_act += ebp_16440;
nmap++;
added++;
}
}
}
}
fclose( &fp[0] );
if ( added )
qsort( map, nmap, 8, &alias_compare );
}
if ( 0 ^ 0 )
{
__stack_chk_fail( );
}
return added;
}
/* Read one mount table entry from STREAM. Returns a pointer to storage
reused on the next call, or null for EOF or error (use feof/ferror to
check). */
struct mntent *
__getmntent_r (FILE *stream, struct mntent *mp, char *buffer, int bufsiz)
{
char *cp;
char *head;
#ifndef __WIN32__
flockfile (stream);
do
{
char *end_ptr;
if (fgets_unlocked (buffer, bufsiz, stream) == NULL)
{
funlockfile (stream);
return NULL;
}
end_ptr = strchr (buffer, '\n');
if (end_ptr != NULL) /* chop newline */
*end_ptr = '\0';
else
{
/* Not the whole line was read. Do it now but forget it. */
char tmp[1024];
while (fgets_unlocked (tmp, sizeof tmp, stream) != NULL)
if (strchr (tmp, '\n') != NULL)
break;
}
head = buffer + strspn (buffer, " \t");
/* skip empty lines and comment lines: */
}
while (head[0] == '\0' || head[0] == '#');
#else /* __WIN32__ */
struct statfsx64 buf;
if (!strcmp(rootlist, NotSet)) {
// fprintf(stderr, "rootlist0\n");
rootlist = getrootdirs(rootlist);
}
/* skip the rootdirs that are not mounted */
while ( (statfsx64 (rootlist, &buf) < 0)) { //(access (rootlist, F_OK) < 0) ||
// fprintf(stderr, "rootlist < 0: %s\n", rootlist);
if (rootlist[0] == 0)
return NULL;
else
rootlist = strchr (rootlist, 0) + 1;
}
// fprintf(stderr, "rootlist: %s\n", rootlist);
// fprintf(stderr, "buf.f_mntonname: %s\n", buf.f_mntonname);
// fprintf(stderr, "buf.f_mntfromname: %s\n", buf.f_mntfromname);
// fprintf(stderr, "buf.f_mntfromname: %s\n", buf.f_mntfromname);
// fprintf(stderr, "buf.f_fstypename: %s\n", buf.f_fstypename);
mp->mnt_fsname = buf.f_mntonname;
mp->mnt_dir = buf.f_mntfromname;
mp->mnt_type = buf.f_fstypename;
mp->mnt_opts = MNTOPT_RW;
__addmntentstr(buffer, mp);
// fprintf(stderr, "mp->mnt_fsname: %s\n", mp->mnt_fsname);
// fprintf(stderr, "mp->mnt_dir: %s\n", mp->mnt_dir);
// fprintf(stderr, "mp->mnt_type: %s\n", mp->mnt_type);
// fprintf(stderr, "mp->mnt_opts: %s\n", mp->mnt_opts);
head = buffer + strspn (buffer, " \t");
rootlist = strchr (rootlist, 0) + 1;
#endif /* __WIN32 */
cp = __strsep (&head, " \t");
mp->mnt_fsname = cp != NULL ? decode_name (cp) : (char *) "";
if (head)
head += strspn (head, " \t");
cp = __strsep (&head, " \t");
mp->mnt_dir = cp != NULL ? decode_name (cp) : (char *) "";
if (head)
head += strspn (head, " \t");
cp = __strsep (&head, " \t");
mp->mnt_type = cp != NULL ? decode_name (cp) : (char *) "";
if (head)
head += strspn (head, " \t");
cp = __strsep (&head, " \t");
mp->mnt_opts = cp != NULL ? decode_name (cp) : (char *) "";
switch (head ? sscanf (head, " %d %d ", &mp->mnt_freq, &mp->mnt_passno) : 0)
{
case 0:
mp->mnt_freq = 0;
case 1:
mp->mnt_passno = 0;
case 2:
break;
}
funlockfile (stream);
return mp;
}
static int
init_iosys (void)
{
char systype[256];
int i, n;
static int iobase_name[] = { CTL_BUS, BUS_ISA, BUS_ISA_PORT_BASE };
static int ioshift_name[] = { CTL_BUS, BUS_ISA, BUS_ISA_PORT_SHIFT };
size_t len = sizeof(io.base);
if (! __sysctl (iobase_name, 3, &io.io_base, &len, NULL, 0)
&& ! __sysctl (ioshift_name, 3, &io.shift, &len, NULL, 0))
{
io.initdone = 1;
return 0;
}
n = __readlink (PATH_ARM_SYSTYPE, systype, sizeof (systype) - 1);
if (n > 0)
{
systype[n] = '\0';
if (isdigit (systype[0]))
{
if (sscanf (systype, "%li,%i", &io.io_base, &io.shift) == 2)
{
io.initdone = 1;
return 0;
}
/* else we're likely going to fail with the system match below */
}
}
else
{
FILE * fp;
fp = fopen (PATH_CPUINFO, "rce");
if (! fp)
return -1;
while ((n = fscanf (fp, "Hardware\t: %256[^\n]\n", systype))
!= EOF)
{
if (n == 1)
break;
else
fgets_unlocked (systype, 256, fp);
}
fclose (fp);
if (n == EOF)
{
/* this can happen if the format of /proc/cpuinfo changes... */
fprintf (stderr,
"ioperm: Unable to determine system type.\n"
"\t(May need " PATH_ARM_SYSTYPE " symlink?)\n");
__set_errno (ENODEV);
return -1;
}
}
/* translate systype name into i/o system: */
for (i = 0; i < sizeof (platform) / sizeof (platform[0]); ++i)
{
if (strcmp (platform[i].name, systype) == 0)
{
io.shift = platform[i].shift;
io.io_base = platform[i].io_base;
io.initdone = 1;
return 0;
}
}
/* systype is not a known platform name... */
__set_errno (ENODEV);
return -1;
}
int main(int argc, char *argv[])
{
char tmp[MAX_AUDIT_MESSAGE_LENGTH+1];
struct sigaction sa;
/* Register sighandlers */
sa.sa_flags = 0;
sigemptyset(&sa.sa_mask);
/* Set handler for the ones we care about */
sa.sa_handler = term_handler;
sigaction(SIGTERM, &sa, NULL);
sa.sa_handler = hup_handler;
sigaction(SIGHUP, &sa, NULL);
/* Initialize the auparse library */
au = auparse_init(AUSOURCE_FEED, 0);
if (au == NULL) {
printf("audisp-example is exiting due to auparse init errors");
return -1;
}
auparse_add_callback(au, handle_event, NULL, NULL);
do {
fd_set read_mask;
struct timeval tv;
int retval;
/* Load configuration */
if (hup) {
reload_config();
}
do {
tv.tv_sec = 5;
tv.tv_usec = 0;
FD_ZERO(&read_mask);
FD_SET(0, &read_mask);
if (auparse_feed_has_data(au))
retval= select(1, &read_mask, NULL, NULL, &tv);
else
retval= select(1, &read_mask, NULL, NULL, NULL);
} while (retval == -1 && errno == EINTR && !hup && !stop);
/* Now the event loop */
if (!stop && !hup && retval > 0) {
if (fgets_unlocked(tmp, MAX_AUDIT_MESSAGE_LENGTH,
stdin)) {
auparse_feed(au, tmp, strnlen(tmp,
MAX_AUDIT_MESSAGE_LENGTH));
}
} else if (retval == 0)
auparse_flush_feed(au);
if (feof(stdin))
break;
} while (stop == 0);
/* Flush any accumulated events from queue */
auparse_flush_feed(au);
auparse_destroy(au);
if (stop)
printf("audisp-example is exiting on stop request\n");
else
printf("audisp-example is exiting on stdin EOF\n");
return 0;
}
static int
do_test (void)
{
struct sigaction sa;
sa.sa_handler = handler;
sa.sa_flags = 0;
sigemptyset (&sa.sa_mask);
sigaction (SIGABRT, &sa, NULL);
/* Avoid all the buffer overflow messages on stderr. */
int fd = open (_PATH_DEVNULL, O_WRONLY);
if (fd == -1)
close (STDERR_FILENO);
else
{
dup2 (fd, STDERR_FILENO);
close (fd);
}
setenv ("LIBC_FATAL_STDERR_", "1", 1);
struct A { char buf1[9]; char buf2[1]; } a;
struct wA { wchar_t buf1[9]; wchar_t buf2[1]; } wa;
printf ("Test checking routines at fortify level %d\n",
#ifdef __USE_FORTIFY_LEVEL
(int) __USE_FORTIFY_LEVEL
#else
0
#endif
);
/* These ops can be done without runtime checking of object size. */
memcpy (buf, "abcdefghij", 10);
memmove (buf + 1, buf, 9);
if (memcmp (buf, "aabcdefghi", 10))
FAIL ();
if (mempcpy (buf + 5, "abcde", 5) != buf + 10
|| memcmp (buf, "aabcdabcde", 10))
FAIL ();
memset (buf + 8, 'j', 2);
if (memcmp (buf, "aabcdabcjj", 10))
FAIL ();
strcpy (buf + 4, "EDCBA");
if (memcmp (buf, "aabcEDCBA", 10))
FAIL ();
if (stpcpy (buf + 8, "F") != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
FAIL ();
strncpy (buf + 6, "X", 4);
if (memcmp (buf, "aabcEDX\0\0", 10))
FAIL ();
if (sprintf (buf + 7, "%s", "67") != 2 || memcmp (buf, "aabcEDX67", 10))
FAIL ();
if (snprintf (buf + 7, 3, "%s", "987654") != 6
|| memcmp (buf, "aabcEDX98", 10))
FAIL ();
/* These ops need runtime checking, but shouldn't __chk_fail. */
memcpy (buf, "abcdefghij", l0 + 10);
memmove (buf + 1, buf, l0 + 9);
if (memcmp (buf, "aabcdefghi", 10))
FAIL ();
if (mempcpy (buf + 5, "abcde", l0 + 5) != buf + 10
|| memcmp (buf, "aabcdabcde", 10))
FAIL ();
memset (buf + 8, 'j', l0 + 2);
if (memcmp (buf, "aabcdabcjj", 10))
FAIL ();
strcpy (buf + 4, str1 + 5);
if (memcmp (buf, "aabcEDCBA", 10))
FAIL ();
if (stpcpy (buf + 8, str2) != buf + 9 || memcmp (buf, "aabcEDCBF", 10))
FAIL ();
strncpy (buf + 6, "X", l0 + 4);
if (memcmp (buf, "aabcEDX\0\0", 10))
FAIL ();
if (stpncpy (buf + 5, "cd", l0 + 5) != buf + 7
|| memcmp (buf, "aabcEcd\0\0", 10))
FAIL ();
if (sprintf (buf + 7, "%d", num1) != 2 || memcmp (buf, "aabcEcd67", 10))
FAIL ();
if (snprintf (buf + 7, 3, "%d", num2) != 6 || memcmp (buf, "aabcEcd98", 10))
FAIL ();
buf[l0 + 8] = '\0';
strcat (buf, "A");
if (memcmp (buf, "aabcEcd9A", 10))
FAIL ();
buf[l0 + 7] = '\0';
strncat (buf, "ZYXWV", l0 + 2);
if (memcmp (buf, "aabcEcdZY", 10))
FAIL ();
memcpy (a.buf1, "abcdefghij", l0 + 10);
memmove (a.buf1 + 1, a.buf1, l0 + 9);
if (memcmp (a.buf1, "aabcdefghi", 10))
FAIL ();
if (mempcpy (a.buf1 + 5, "abcde", l0 + 5) != a.buf1 + 10
|| memcmp (a.buf1, "aabcdabcde", 10))
FAIL ();
memset (a.buf1 + 8, 'j', l0 + 2);
if (memcmp (a.buf1, "aabcdabcjj", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL < 2
/* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
and sufficient GCC support, as the string operations overflow
from a.buf1 into a.buf2. */
strcpy (a.buf1 + 4, str1 + 5);
if (memcmp (a.buf1, "aabcEDCBA", 10))
FAIL ();
if (stpcpy (a.buf1 + 8, str2) != a.buf1 + 9
|| memcmp (a.buf1, "aabcEDCBF", 10))
FAIL ();
strncpy (a.buf1 + 6, "X", l0 + 4);
if (memcmp (a.buf1, "aabcEDX\0\0", 10))
FAIL ();
if (sprintf (a.buf1 + 7, "%d", num1) != 2
|| memcmp (a.buf1, "aabcEDX67", 10))
FAIL ();
if (snprintf (a.buf1 + 7, 3, "%d", num2) != 6
|| memcmp (a.buf1, "aabcEDX98", 10))
FAIL ();
a.buf1[l0 + 8] = '\0';
strcat (a.buf1, "A");
if (memcmp (a.buf1, "aabcEDX9A", 10))
FAIL ();
a.buf1[l0 + 7] = '\0';
strncat (a.buf1, "ZYXWV", l0 + 2);
if (memcmp (a.buf1, "aabcEDXZY", 10))
FAIL ();
#endif
#if __USE_FORTIFY_LEVEL >= 1
/* Now check if all buffer overflows are caught at runtime. */
CHK_FAIL_START
memcpy (buf + 1, "abcdefghij", l0 + 10);
CHK_FAIL_END
CHK_FAIL_START
memmove (buf + 2, buf + 1, l0 + 9);
CHK_FAIL_END
CHK_FAIL_START
p = mempcpy (buf + 6, "abcde", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
memset (buf + 9, 'j', l0 + 2);
CHK_FAIL_END
CHK_FAIL_START
strcpy (buf + 5, str1 + 5);
CHK_FAIL_END
CHK_FAIL_START
p = stpcpy (buf + 9, str2);
CHK_FAIL_END
CHK_FAIL_START
strncpy (buf + 7, "X", l0 + 4);
CHK_FAIL_END
CHK_FAIL_START
stpncpy (buf + 6, "cd", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
sprintf (buf + 8, "%d", num1);
CHK_FAIL_END
CHK_FAIL_START
snprintf (buf + 8, l0 + 3, "%d", num2);
CHK_FAIL_END
memcpy (buf, str1 + 2, l0 + 9);
CHK_FAIL_START
strcat (buf, "AB");
CHK_FAIL_END
memcpy (buf, str1 + 3, l0 + 8);
CHK_FAIL_START
strncat (buf, "ZYXWV", l0 + 3);
CHK_FAIL_END
CHK_FAIL_START
memcpy (a.buf1 + 1, "abcdefghij", l0 + 10);
CHK_FAIL_END
CHK_FAIL_START
memmove (a.buf1 + 2, a.buf1 + 1, l0 + 9);
CHK_FAIL_END
CHK_FAIL_START
p = mempcpy (a.buf1 + 6, "abcde", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
memset (a.buf1 + 9, 'j', l0 + 2);
CHK_FAIL_END
#if __USE_FORTIFY_LEVEL >= 2
# define O 0
#else
# define O 1
#endif
CHK_FAIL_START
strcpy (a.buf1 + (O + 4), str1 + 5);
CHK_FAIL_END
CHK_FAIL_START
p = stpcpy (a.buf1 + (O + 8), str2);
CHK_FAIL_END
CHK_FAIL_START
strncpy (a.buf1 + (O + 6), "X", l0 + 4);
CHK_FAIL_END
CHK_FAIL_START
sprintf (a.buf1 + (O + 7), "%d", num1);
CHK_FAIL_END
CHK_FAIL_START
snprintf (a.buf1 + (O + 7), l0 + 3, "%d", num2);
CHK_FAIL_END
memcpy (a.buf1, str1 + (3 - O), l0 + 8 + O);
CHK_FAIL_START
strcat (a.buf1, "AB");
CHK_FAIL_END
memcpy (a.buf1, str1 + (4 - O), l0 + 7 + O);
CHK_FAIL_START
strncat (a.buf1, "ZYXWV", l0 + 3);
CHK_FAIL_END
#endif
/* These ops can be done without runtime checking of object size. */
wmemcpy (wbuf, L"abcdefghij", 10);
wmemmove (wbuf + 1, wbuf, 9);
if (wmemcmp (wbuf, L"aabcdefghi", 10))
FAIL ();
if (wmempcpy (wbuf + 5, L"abcde", 5) != wbuf + 10
|| wmemcmp (wbuf, L"aabcdabcde", 10))
FAIL ();
wmemset (wbuf + 8, L'j', 2);
if (wmemcmp (wbuf, L"aabcdabcjj", 10))
FAIL ();
wcscpy (wbuf + 4, L"EDCBA");
if (wmemcmp (wbuf, L"aabcEDCBA", 10))
FAIL ();
if (wcpcpy (wbuf + 8, L"F") != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
FAIL ();
wcsncpy (wbuf + 6, L"X", 4);
if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
FAIL ();
if (swprintf (wbuf + 7, 3, L"%ls", L"987654") >= 0
|| wmemcmp (wbuf, L"aabcEDX98", 10))
FAIL ();
if (swprintf (wbuf + 7, 3, L"64") != 2
|| wmemcmp (wbuf, L"aabcEDX64", 10))
FAIL ();
/* These ops need runtime checking, but shouldn't __chk_fail. */
wmemcpy (wbuf, L"abcdefghij", l0 + 10);
wmemmove (wbuf + 1, wbuf, l0 + 9);
if (wmemcmp (wbuf, L"aabcdefghi", 10))
FAIL ();
if (wmempcpy (wbuf + 5, L"abcde", l0 + 5) != wbuf + 10
|| wmemcmp (wbuf, L"aabcdabcde", 10))
FAIL ();
wmemset (wbuf + 8, L'j', l0 + 2);
if (wmemcmp (wbuf, L"aabcdabcjj", 10))
FAIL ();
wcscpy (wbuf + 4, wstr1 + 5);
if (wmemcmp (wbuf, L"aabcEDCBA", 10))
FAIL ();
if (wcpcpy (wbuf + 8, wstr2) != wbuf + 9 || wmemcmp (wbuf, L"aabcEDCBF", 10))
FAIL ();
wcsncpy (wbuf + 6, L"X", l0 + 4);
if (wmemcmp (wbuf, L"aabcEDX\0\0", 10))
FAIL ();
if (wcpncpy (wbuf + 5, L"cd", l0 + 5) != wbuf + 7
|| wmemcmp (wbuf, L"aabcEcd\0\0", 10))
FAIL ();
if (swprintf (wbuf + 7, 3, L"%d", num2) >= 0
|| wmemcmp (wbuf, L"aabcEcd98", 10))
FAIL ();
wbuf[l0 + 8] = L'\0';
wcscat (wbuf, L"A");
if (wmemcmp (wbuf, L"aabcEcd9A", 10))
FAIL ();
wbuf[l0 + 7] = L'\0';
wcsncat (wbuf, L"ZYXWV", l0 + 2);
if (wmemcmp (wbuf, L"aabcEcdZY", 10))
FAIL ();
wmemcpy (wa.buf1, L"abcdefghij", l0 + 10);
wmemmove (wa.buf1 + 1, wa.buf1, l0 + 9);
if (wmemcmp (wa.buf1, L"aabcdefghi", 10))
FAIL ();
if (wmempcpy (wa.buf1 + 5, L"abcde", l0 + 5) != wa.buf1 + 10
|| wmemcmp (wa.buf1, L"aabcdabcde", 10))
FAIL ();
wmemset (wa.buf1 + 8, L'j', l0 + 2);
if (wmemcmp (wa.buf1, L"aabcdabcjj", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL < 2
/* The following tests are supposed to crash with -D_FORTIFY_SOURCE=2
and sufficient GCC support, as the string operations overflow
from a.buf1 into a.buf2. */
wcscpy (wa.buf1 + 4, wstr1 + 5);
if (wmemcmp (wa.buf1, L"aabcEDCBA", 10))
FAIL ();
if (wcpcpy (wa.buf1 + 8, wstr2) != wa.buf1 + 9
|| wmemcmp (wa.buf1, L"aabcEDCBF", 10))
FAIL ();
wcsncpy (wa.buf1 + 6, L"X", l0 + 4);
if (wmemcmp (wa.buf1, L"aabcEDX\0\0", 10))
FAIL ();
if (swprintf (wa.buf1 + 7, 3, L"%d", num2) >= 0
|| wmemcmp (wa.buf1, L"aabcEDX98", 10))
FAIL ();
wa.buf1[l0 + 8] = L'\0';
wcscat (wa.buf1, L"A");
if (wmemcmp (wa.buf1, L"aabcEDX9A", 10))
FAIL ();
wa.buf1[l0 + 7] = L'\0';
wcsncat (wa.buf1, L"ZYXWV", l0 + 2);
if (wmemcmp (wa.buf1, L"aabcEDXZY", 10))
FAIL ();
#endif
#if __USE_FORTIFY_LEVEL >= 1
/* Now check if all buffer overflows are caught at runtime. */
CHK_FAIL_START
wmemcpy (wbuf + 1, L"abcdefghij", l0 + 10);
CHK_FAIL_END
CHK_FAIL_START
wmemmove (wbuf + 2, wbuf + 1, l0 + 9);
CHK_FAIL_END
CHK_FAIL_START
wp = wmempcpy (wbuf + 6, L"abcde", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
wmemset (wbuf + 9, L'j', l0 + 2);
CHK_FAIL_END
CHK_FAIL_START
wcscpy (wbuf + 5, wstr1 + 5);
CHK_FAIL_END
CHK_FAIL_START
wp = wcpcpy (wbuf + 9, wstr2);
CHK_FAIL_END
CHK_FAIL_START
wcsncpy (wbuf + 7, L"X", l0 + 4);
CHK_FAIL_END
CHK_FAIL_START
wcpncpy (wbuf + 6, L"cd", l0 + 5);
CHK_FAIL_END
wmemcpy (wbuf, wstr1 + 2, l0 + 9);
CHK_FAIL_START
wcscat (wbuf, L"AB");
CHK_FAIL_END
wmemcpy (wbuf, wstr1 + 3, l0 + 8);
CHK_FAIL_START
wcsncat (wbuf, L"ZYXWV", l0 + 3);
CHK_FAIL_END
CHK_FAIL_START
wmemcpy (wa.buf1 + 1, L"abcdefghij", l0 + 10);
CHK_FAIL_END
CHK_FAIL_START
wmemmove (wa.buf1 + 2, wa.buf1 + 1, l0 + 9);
CHK_FAIL_END
CHK_FAIL_START
wp = wmempcpy (wa.buf1 + 6, L"abcde", l0 + 5);
CHK_FAIL_END
CHK_FAIL_START
wmemset (wa.buf1 + 9, L'j', l0 + 2);
CHK_FAIL_END
#if __USE_FORTIFY_LEVEL >= 2
# define O 0
#else
# define O 1
#endif
CHK_FAIL_START
wcscpy (wa.buf1 + (O + 4), wstr1 + 5);
CHK_FAIL_END
CHK_FAIL_START
wp = wcpcpy (wa.buf1 + (O + 8), wstr2);
CHK_FAIL_END
CHK_FAIL_START
wcsncpy (wa.buf1 + (O + 6), L"X", l0 + 4);
CHK_FAIL_END
wmemcpy (wa.buf1, wstr1 + (3 - O), l0 + 8 + O);
CHK_FAIL_START
wcscat (wa.buf1, L"AB");
CHK_FAIL_END
wmemcpy (wa.buf1, wstr1 + (4 - O), l0 + 7 + O);
CHK_FAIL_START
wcsncat (wa.buf1, L"ZYXWV", l0 + 3);
CHK_FAIL_END
#endif
/* Now checks for %n protection. */
/* Constant literals passed directly are always ok
(even with warnings about possible bugs from GCC). */
int n1, n2;
if (sprintf (buf, "%s%n%s%n", str2, &n1, str2, &n2) != 2
|| n1 != 1 || n2 != 2)
FAIL ();
/* In this case the format string is not known at compile time,
but resides in read-only memory, so is ok. */
if (snprintf (buf, 4, str3, str2, &n1, str2, &n2) != 2
|| n1 != 1 || n2 != 2)
FAIL ();
strcpy (buf2 + 2, "%n%s%n");
/* When the format string is writable and contains %n,
with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
CHK_FAIL2_START
if (sprintf (buf, buf2, str2, &n1, str2, &n1) != 2)
FAIL ();
CHK_FAIL2_END
CHK_FAIL2_START
if (snprintf (buf, 3, buf2, str2, &n1, str2, &n1) != 2)
FAIL ();
CHK_FAIL2_END
/* But if there is no %n, even writable format string
should work. */
buf2[6] = '\0';
if (sprintf (buf, buf2 + 4, str2) != 1)
FAIL ();
/* Constant literals passed directly are always ok
(even with warnings about possible bugs from GCC). */
if (printf ("%s%n%s%n", str4, &n1, str5, &n2) != 14
|| n1 != 7 || n2 != 14)
FAIL ();
/* In this case the format string is not known at compile time,
but resides in read-only memory, so is ok. */
if (printf (str3, str4, &n1, str5, &n2) != 14
|| n1 != 7 || n2 != 14)
FAIL ();
strcpy (buf2 + 2, "%n%s%n");
/* When the format string is writable and contains %n,
with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
CHK_FAIL2_START
if (printf (buf2, str4, &n1, str5, &n1) != 14)
FAIL ();
CHK_FAIL2_END
/* But if there is no %n, even writable format string
should work. */
buf2[6] = '\0';
if (printf (buf2 + 4, str5) != 7)
FAIL ();
FILE *fp = stdout;
/* Constant literals passed directly are always ok
(even with warnings about possible bugs from GCC). */
if (fprintf (fp, "%s%n%s%n", str4, &n1, str5, &n2) != 14
|| n1 != 7 || n2 != 14)
FAIL ();
/* In this case the format string is not known at compile time,
but resides in read-only memory, so is ok. */
if (fprintf (fp, str3, str4, &n1, str5, &n2) != 14
|| n1 != 7 || n2 != 14)
FAIL ();
strcpy (buf2 + 2, "%n%s%n");
/* When the format string is writable and contains %n,
with -D_FORTIFY_SOURCE=2 it causes __chk_fail. */
CHK_FAIL2_START
if (fprintf (fp, buf2, str4, &n1, str5, &n1) != 14)
FAIL ();
CHK_FAIL2_END
/* But if there is no %n, even writable format string
should work. */
buf2[6] = '\0';
if (fprintf (fp, buf2 + 4, str5) != 7)
FAIL ();
if (freopen (temp_filename, "r", stdin) == NULL)
{
puts ("could not open temporary file");
exit (1);
}
if (gets (buf) != buf || memcmp (buf, "abcdefgh", 9))
FAIL ();
if (gets (buf) != buf || memcmp (buf, "ABCDEFGHI", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (gets (buf) != buf)
FAIL ();
CHK_FAIL_END
#endif
rewind (stdin);
if (fgets (buf, sizeof (buf), stdin) != buf
|| memcmp (buf, "abcdefgh\n", 10))
FAIL ();
if (fgets (buf, sizeof (buf), stdin) != buf || memcmp (buf, "ABCDEFGHI", 10))
FAIL ();
rewind (stdin);
if (fgets (buf, l0 + sizeof (buf), stdin) != buf
|| memcmp (buf, "abcdefgh\n", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (fgets (buf, sizeof (buf) + 1, stdin) != buf)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (fgets (buf, l0 + sizeof (buf) + 1, stdin) != buf)
FAIL ();
CHK_FAIL_END
#endif
rewind (stdin);
if (fgets_unlocked (buf, sizeof (buf), stdin) != buf
|| memcmp (buf, "abcdefgh\n", 10))
FAIL ();
if (fgets_unlocked (buf, sizeof (buf), stdin) != buf
|| memcmp (buf, "ABCDEFGHI", 10))
FAIL ();
rewind (stdin);
if (fgets_unlocked (buf, l0 + sizeof (buf), stdin) != buf
|| memcmp (buf, "abcdefgh\n", 10))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (fgets_unlocked (buf, sizeof (buf) + 1, stdin) != buf)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (fgets_unlocked (buf, l0 + sizeof (buf) + 1, stdin) != buf)
FAIL ();
CHK_FAIL_END
#endif
lseek (fileno (stdin), 0, SEEK_SET);
if (read (fileno (stdin), buf, sizeof (buf) - 1) != sizeof (buf) - 1
|| memcmp (buf, "abcdefgh\n", 9))
FAIL ();
if (read (fileno (stdin), buf, sizeof (buf) - 1) != sizeof (buf) - 1
|| memcmp (buf, "ABCDEFGHI", 9))
FAIL ();
lseek (fileno (stdin), 0, SEEK_SET);
if (read (fileno (stdin), buf, l0 + sizeof (buf) - 1) != sizeof (buf) - 1
|| memcmp (buf, "abcdefgh\n", 9))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (read (fileno (stdin), buf, sizeof (buf) + 1) != sizeof (buf) + 1)
FAIL ();
CHK_FAIL_END
#endif
if (pread (fileno (stdin), buf, sizeof (buf) - 1, sizeof (buf) - 2)
!= sizeof (buf) - 1
|| memcmp (buf, "\nABCDEFGH", 9))
FAIL ();
if (pread (fileno (stdin), buf, sizeof (buf) - 1, 0) != sizeof (buf) - 1
|| memcmp (buf, "abcdefgh\n", 9))
FAIL ();
if (pread (fileno (stdin), buf, l0 + sizeof (buf) - 1, sizeof (buf) - 3)
!= sizeof (buf) - 1
|| memcmp (buf, "h\nABCDEFG", 9))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (pread (fileno (stdin), buf, sizeof (buf) + 1, 2 * sizeof (buf))
!= sizeof (buf) + 1)
FAIL ();
CHK_FAIL_END
#endif
if (pread64 (fileno (stdin), buf, sizeof (buf) - 1, sizeof (buf) - 2)
!= sizeof (buf) - 1
|| memcmp (buf, "\nABCDEFGH", 9))
FAIL ();
if (pread64 (fileno (stdin), buf, sizeof (buf) - 1, 0) != sizeof (buf) - 1
|| memcmp (buf, "abcdefgh\n", 9))
FAIL ();
if (pread64 (fileno (stdin), buf, l0 + sizeof (buf) - 1, sizeof (buf) - 3)
!= sizeof (buf) - 1
|| memcmp (buf, "h\nABCDEFG", 9))
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (pread64 (fileno (stdin), buf, sizeof (buf) + 1, 2 * sizeof (buf))
!= sizeof (buf) + 1)
FAIL ();
CHK_FAIL_END
#endif
if (freopen (temp_filename, "r", stdin) == NULL)
{
puts ("could not open temporary file");
exit (1);
}
if (fseek (stdin, 9 + 10 + 11, SEEK_SET))
{
puts ("could not seek in test file");
exit (1);
}
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (gets (buf) != buf)
FAIL ();
CHK_FAIL_END
#endif
/* Check whether missing N$ formats are detected. */
CHK_FAIL2_START
printf ("%3$d\n", 1, 2, 3, 4);
CHK_FAIL2_END
CHK_FAIL2_START
fprintf (stdout, "%3$d\n", 1, 2, 3, 4);
CHK_FAIL2_END
CHK_FAIL2_START
sprintf (buf, "%3$d\n", 1, 2, 3, 4);
CHK_FAIL2_END
CHK_FAIL2_START
snprintf (buf, sizeof (buf), "%3$d\n", 1, 2, 3, 4);
CHK_FAIL2_END
int sp[2];
if (socketpair (PF_UNIX, SOCK_STREAM, 0, sp))
FAIL ();
else
{
const char *sendstr = "abcdefgh\nABCDEFGH\n0123456789\n";
if (send (sp[0], sendstr, strlen (sendstr), 0) != strlen (sendstr))
FAIL ();
char recvbuf[12];
if (recv (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK)
!= sizeof recvbuf
|| memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
FAIL ();
if (recv (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK)
!= sizeof recvbuf - 7
|| memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (recv (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK)
!= sizeof recvbuf)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (recv (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK)
!= sizeof recvbuf - 3)
FAIL ();
CHK_FAIL_END
#endif
socklen_t sl;
struct sockaddr_un sa_un;
sl = sizeof (sa_un);
if (recvfrom (sp[1], recvbuf, sizeof recvbuf, MSG_PEEK, &sa_un, &sl)
!= sizeof recvbuf
|| memcmp (recvbuf, sendstr, sizeof recvbuf) != 0)
FAIL ();
sl = sizeof (sa_un);
if (recvfrom (sp[1], recvbuf + 6, l0 + sizeof recvbuf - 7, MSG_PEEK,
&sa_un, &sl) != sizeof recvbuf - 7
|| memcmp (recvbuf + 6, sendstr, sizeof recvbuf - 7) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
sl = sizeof (sa_un);
if (recvfrom (sp[1], recvbuf + 1, sizeof recvbuf, MSG_PEEK, &sa_un, &sl)
!= sizeof recvbuf)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
sl = sizeof (sa_un);
if (recvfrom (sp[1], recvbuf + 4, l0 + sizeof recvbuf - 3, MSG_PEEK,
&sa_un, &sl) != sizeof recvbuf - 3)
FAIL ();
CHK_FAIL_END
#endif
close (sp[0]);
close (sp[1]);
}
char fname[] = "/tmp/tst-chk1-dir-XXXXXX\0foo";
char *enddir = strchr (fname, '\0');
if (mkdtemp (fname) == NULL)
{
printf ("mkdtemp failed: %m\n");
return 1;
}
*enddir = '/';
if (symlink ("bar", fname) != 0)
FAIL ();
char readlinkbuf[4];
if (readlink (fname, readlinkbuf, 4) != 3
|| memcmp (readlinkbuf, "bar", 3) != 0)
FAIL ();
if (readlink (fname, readlinkbuf + 1, l0 + 3) != 3
|| memcmp (readlinkbuf, "bbar", 4) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (readlink (fname, readlinkbuf + 2, l0 + 3) != 3)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (readlink (fname, readlinkbuf + 3, 4) != 3)
FAIL ();
CHK_FAIL_END
#endif
char *cwd1 = getcwd (NULL, 0);
if (cwd1 == NULL)
FAIL ();
char *cwd2 = getcwd (NULL, 250);
if (cwd2 == NULL)
FAIL ();
if (cwd1 && cwd2)
{
if (strcmp (cwd1, cwd2) != 0)
FAIL ();
*enddir = '\0';
if (chdir (fname))
FAIL ();
char *cwd3 = getcwd (NULL, 0);
if (cwd3 == NULL)
FAIL ();
if (strcmp (fname, cwd3) != 0)
printf ("getcwd after chdir is '%s' != '%s',"
"get{c,}wd tests skipped\n", cwd3, fname);
else
{
char getcwdbuf[sizeof fname - 3];
char *cwd4 = getcwd (getcwdbuf, sizeof getcwdbuf);
if (cwd4 != getcwdbuf
|| strcmp (getcwdbuf, fname) != 0)
FAIL ();
cwd4 = getcwd (getcwdbuf + 1, l0 + sizeof getcwdbuf - 1);
if (cwd4 != getcwdbuf + 1
|| getcwdbuf[0] != fname[0]
|| strcmp (getcwdbuf + 1, fname) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (getcwd (getcwdbuf + 2, l0 + sizeof getcwdbuf)
!= getcwdbuf + 2)
FAIL ();
CHK_FAIL_END
CHK_FAIL_START
if (getcwd (getcwdbuf + 2, sizeof getcwdbuf)
!= getcwdbuf + 2)
FAIL ();
CHK_FAIL_END
#endif
if (getwd (getcwdbuf) != getcwdbuf
|| strcmp (getcwdbuf, fname) != 0)
FAIL ();
if (getwd (getcwdbuf + 1) != getcwdbuf + 1
|| strcmp (getcwdbuf + 1, fname) != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
if (getwd (getcwdbuf + 2) != getcwdbuf + 2)
FAIL ();
CHK_FAIL_END
#endif
}
if (chdir (cwd1) != 0)
FAIL ();
free (cwd3);
}
free (cwd1);
free (cwd2);
*enddir = '/';
if (unlink (fname) != 0)
FAIL ();
*enddir = '\0';
if (rmdir (fname) != 0)
FAIL ();
#if PATH_MAX > 0
char largebuf[PATH_MAX];
char *realres = realpath (".", largebuf);
if (realres != largebuf)
FAIL ();
# if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
char realbuf[1];
realres = realpath (".", realbuf);
if (realres != realbuf)
FAIL ();
CHK_FAIL_END
# endif
#endif
if (setlocale (LC_ALL, "de_DE.UTF-8") != NULL)
{
assert (MB_CUR_MAX <= 10);
/* First a simple test. */
char enough[10];
if (wctomb (enough, L'A') != 1)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
/* We know the wchar_t encoding is ISO 10646. So pick a
character which has a multibyte representation which does not
fit. */
CHK_FAIL_START
char smallbuf[2];
if (wctomb (smallbuf, L'\x100') != 2)
FAIL ();
CHK_FAIL_END
#endif
mbstate_t s;
memset (&s, '\0', sizeof (s));
if (wcrtomb (enough, L'D', &s) != 1 || enough[0] != 'D')
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
/* We know the wchar_t encoding is ISO 10646. So pick a
character which has a multibyte representation which does not
fit. */
CHK_FAIL_START
char smallbuf[2];
if (wcrtomb (smallbuf, L'\x100', &s) != 2)
FAIL ();
CHK_FAIL_END
#endif
wchar_t wenough[10];
memset (&s, '\0', sizeof (s));
const char *cp = "A";
if (mbsrtowcs (wenough, &cp, 10, &s) != 1
|| wcscmp (wenough, L"A") != 0)
FAIL ();
cp = "BC";
if (mbsrtowcs (wenough, &cp, l0 + 10, &s) != 2
|| wcscmp (wenough, L"BC") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
wchar_t wsmallbuf[2];
cp = "ABC";
mbsrtowcs (wsmallbuf, &cp, 10, &s);
CHK_FAIL_END
#endif
cp = "A";
if (mbstowcs (wenough, cp, 10) != 1
|| wcscmp (wenough, L"A") != 0)
FAIL ();
cp = "DEF";
if (mbstowcs (wenough, cp, l0 + 10) != 3
|| wcscmp (wenough, L"DEF") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
wchar_t wsmallbuf[2];
cp = "ABC";
mbstowcs (wsmallbuf, cp, 10);
CHK_FAIL_END
#endif
memset (&s, '\0', sizeof (s));
cp = "ABC";
wcscpy (wenough, L"DEF");
if (mbsnrtowcs (wenough, &cp, 1, 10, &s) != 1
|| wcscmp (wenough, L"AEF") != 0)
FAIL ();
cp = "IJ";
if (mbsnrtowcs (wenough, &cp, 1, l0 + 10, &s) != 1
|| wcscmp (wenough, L"IEF") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
wchar_t wsmallbuf[2];
cp = "ABC";
mbsnrtowcs (wsmallbuf, &cp, 3, 10, &s);
CHK_FAIL_END
#endif
memset (&s, '\0', sizeof (s));
const wchar_t *wcp = L"A";
if (wcsrtombs (enough, &wcp, 10, &s) != 1
|| strcmp (enough, "A") != 0)
FAIL ();
wcp = L"BC";
if (wcsrtombs (enough, &wcp, l0 + 10, &s) != 2
|| strcmp (enough, "BC") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
char smallbuf[2];
wcp = L"ABC";
wcsrtombs (smallbuf, &wcp, 10, &s);
CHK_FAIL_END
#endif
memset (enough, 'Z', sizeof (enough));
wcp = L"EF";
if (wcstombs (enough, wcp, 10) != 2
|| strcmp (enough, "EF") != 0)
FAIL ();
wcp = L"G";
if (wcstombs (enough, wcp, l0 + 10) != 1
|| strcmp (enough, "G") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
char smallbuf[2];
wcp = L"ABC";
wcstombs (smallbuf, wcp, 10);
CHK_FAIL_END
#endif
memset (&s, '\0', sizeof (s));
wcp = L"AB";
if (wcsnrtombs (enough, &wcp, 1, 10, &s) != 1
|| strcmp (enough, "A") != 0)
FAIL ();
wcp = L"BCD";
if (wcsnrtombs (enough, &wcp, 1, l0 + 10, &s) != 1
|| strcmp (enough, "B") != 0)
FAIL ();
#if __USE_FORTIFY_LEVEL >= 1
CHK_FAIL_START
char smallbuf[2];
wcp = L"ABC";
wcsnrtombs (smallbuf, &wcp, 3, 10, &s);
CHK_FAIL_END
#endif
}
int
main(void) {
setvbuf(stdin, 0, _IOFBF, 1024*1024);
long stdin_size = get_file_size(stdin);
uint8_t *buffer = calloc(stdin_size + LINE_LENGTH, 1);
assert(buffer);
lookup_t lookup;
pthread_mutex_t mutex;
job_t *job = 0;
init_lookup(
(const uint8_t *)"acbdghkmnsrutwvy",
(const uint8_t *)"TGVHCDMKNSYAAWBR",
&lookup);
pthread_mutex_init(&mutex, 0);
uint8_t *current = buffer;
uint8_t *end = buffer + stdin_size;
uint8_t *header_begin = 0;
uint8_t *header_end = 0;
uint8_t *body_begin = 0;
while (fgets_unlocked((char *)current, end - current, stdin)) {
if (current[0] == '>') {
if (body_begin != 0) {
job = do_process_block(
header_begin, header_end,
body_begin, current,
&lookup,
&mutex,
job);
}
size_t len = strlen((const char *)current);
header_begin = current;
header_end = current + len;
current += len;
body_begin = current;
} else {
if (current[LINE_LENGTH] == '\n') {
current += LINE_LENGTH;
} else {
size_t len = strlen((const char *)current);
if (current[len - 1] == '\n') {
--len;
}
current += len;
}
}
}
if (body_begin != 0) {
job = do_process_block(
header_begin, header_end,
body_begin, current,
&lookup,
&mutex,
job);
}
while (job) {
pthread_join(job->thread, 0);
if (job->free_buffer) {
free(job->buffer);
}
job = job->prev_job;
}
free(buffer);
return 0;
}
/* Read one mount table entry from STREAM. Returns a pointer to storage
reused on the next call, or null for EOF or error (use feof/ferror to
check). */
struct mntent *
__getmntent_r (FILE *stream, struct mntent *mp, char *buffer, int bufsiz)
{
char *cp;
char *head;
flockfile (stream);
do
{
char *end_ptr;
if (fgets_unlocked (buffer, bufsiz, stream) == NULL)
{
funlockfile (stream);
return NULL;
}
end_ptr = strchr (buffer, '\n');
if (end_ptr != NULL) /* chop newline */
*end_ptr = '\0';
else
{
/* Not the whole line was read. Do it now but forget it. */
char tmp[1024];
while (fgets_unlocked (tmp, sizeof tmp, stream) != NULL)
if (strchr (tmp, '\n') != NULL)
break;
}
head = buffer + strspn (buffer, " \t");
/* skip empty lines and comment lines: */
}
while (head[0] == '\0' || head[0] == '#');
cp = __strsep (&head, " \t");
mp->mnt_fsname = cp != NULL ? decode_name (cp) : (char *) "";
if (head)
head += strspn (head, " \t");
cp = __strsep (&head, " \t");
mp->mnt_dir = cp != NULL ? decode_name (cp) : (char *) "";
if (head)
head += strspn (head, " \t");
cp = __strsep (&head, " \t");
mp->mnt_type = cp != NULL ? decode_name (cp) : (char *) "";
if (head)
head += strspn (head, " \t");
cp = __strsep (&head, " \t");
mp->mnt_opts = cp != NULL ? decode_name (cp) : (char *) "";
switch (head ? sscanf (head, " %d %d ", &mp->mnt_freq, &mp->mnt_passno) : 0)
{
case 0:
mp->mnt_freq = 0;
case 1:
mp->mnt_passno = 0;
case 2:
break;
}
funlockfile (stream);
return mp;
}
/* This function has to be reachable by res_data.c but not publically. */
int
__res_vinit(res_state statp, int preinit) {
register FILE *fp;
register char *cp, **pp;
register int n;
char buf[BUFSIZ];
int nserv = 0; /* number of nameserver records read from file */
#ifdef _LIBC
int nservall = 0; /* number of NS records read, nserv IPv4 only */
#endif
int haveenv = 0;
int havesearch = 0;
#ifdef RESOLVSORT
int nsort = 0;
char *net;
#endif
#ifndef RFC1535
int dots;
#endif
if (!preinit) {
statp->retrans = RES_TIMEOUT;
statp->retry = RES_DFLRETRY;
statp->options = RES_DEFAULT;
statp->id = res_randomid();
}
#ifdef USELOOPBACK
statp->nsaddr.sin_addr = inet_makeaddr(IN_LOOPBACKNET, 1);
#else
statp->nsaddr.sin_addr.s_addr = INADDR_ANY;
#endif
statp->nsaddr.sin_family = AF_INET;
statp->nsaddr.sin_port = htons(NAMESERVER_PORT);
statp->nscount = 1;
statp->ndots = 1;
statp->pfcode = 0;
statp->_vcsock = -1;
statp->_flags = 0;
statp->qhook = NULL;
statp->rhook = NULL;
statp->_u._ext.nsinit = 0;
statp->_u._ext.nscount = 0;
#ifdef _LIBC
statp->_u._ext.nscount6 = 0;
for (n = 0; n < MAXNS; n++)
statp->_u._ext.nsaddrs[n] = NULL;
#endif
/* Allow user to override the local domain definition */
if ((cp = getenv("LOCALDOMAIN")) != NULL) {
(void)strncpy(statp->defdname, cp, sizeof(statp->defdname) - 1);
statp->defdname[sizeof(statp->defdname) - 1] = '\0';
haveenv++;
/*
* Set search list to be blank-separated strings
* from rest of env value. Permits users of LOCALDOMAIN
* to still have a search list, and anyone to set the
* one that they want to use as an individual (even more
* important now that the rfc1535 stuff restricts searches)
*/
cp = statp->defdname;
pp = statp->dnsrch;
*pp++ = cp;
for (n = 0; *cp && pp < statp->dnsrch + MAXDNSRCH; cp++) {
if (*cp == '\n') /* silly backwards compat */
break;
else if (*cp == ' ' || *cp == '\t') {
*cp = 0;
n = 1;
} else if (n) {
*pp++ = cp;
n = 0;
havesearch = 1;
}
}
/* null terminate last domain if there are excess */
while (*cp != '\0' && *cp != ' ' && *cp != '\t' && *cp != '\n')
cp++;
*cp = '\0';
*pp++ = 0;
}
#define MATCH(line, name) \
(!strncmp(line, name, sizeof(name) - 1) && \
(line[sizeof(name) - 1] == ' ' || \
line[sizeof(name) - 1] == '\t'))
if ((fp = fopen(_PATH_RESCONF, "r")) != NULL) {
/* No threads use this stream. */
__fsetlocking (fp, FSETLOCKING_BYCALLER);
/* read the config file */
while (fgets_unlocked(buf, sizeof(buf), fp) != NULL) {
/* skip comments */
if (*buf == ';' || *buf == '#')
continue;
/* read default domain name */
if (MATCH(buf, "domain")) {
if (haveenv) /* skip if have from environ */
continue;
cp = buf + sizeof("domain") - 1;
while (*cp == ' ' || *cp == '\t')
cp++;
if ((*cp == '\0') || (*cp == '\n'))
continue;
strncpy(statp->defdname, cp, sizeof(statp->defdname) - 1);
statp->defdname[sizeof(statp->defdname) - 1] = '\0';
if ((cp = strpbrk(statp->defdname, " \t\n")) != NULL)
*cp = '\0';
havesearch = 0;
continue;
}
/* set search list */
if (MATCH(buf, "search")) {
if (haveenv) /* skip if have from environ */
continue;
cp = buf + sizeof("search") - 1;
while (*cp == ' ' || *cp == '\t')
cp++;
if ((*cp == '\0') || (*cp == '\n'))
continue;
strncpy(statp->defdname, cp, sizeof(statp->defdname) - 1);
statp->defdname[sizeof(statp->defdname) - 1] = '\0';
if ((cp = strchr(statp->defdname, '\n')) != NULL)
*cp = '\0';
/*
* Set search list to be blank-separated strings
* on rest of line.
*/
cp = statp->defdname;
pp = statp->dnsrch;
*pp++ = cp;
for (n = 0; *cp && pp < statp->dnsrch + MAXDNSRCH; cp++) {
if (*cp == ' ' || *cp == '\t') {
*cp = 0;
n = 1;
} else if (n) {
*pp++ = cp;
n = 0;
}
}
/* null terminate last domain if there are excess */
while (*cp != '\0' && *cp != ' ' && *cp != '\t')
cp++;
*cp = '\0';
*pp++ = 0;
havesearch = 1;
continue;
}
/* read nameservers to query */
#ifdef _LIBC
if (MATCH(buf, "nameserver") && nservall < MAXNS) {
#else
if (MATCH(buf, "nameserver") && nserv < MAXNS) {
#endif
struct in_addr a;
cp = buf + sizeof("nameserver") - 1;
while (*cp == ' ' || *cp == '\t')
cp++;
if ((*cp != '\0') && (*cp != '\n')
&& __inet_aton(cp, &a)) {
statp->nsaddr_list[nserv].sin_addr = a;
statp->nsaddr_list[nserv].sin_family = AF_INET;
statp->nsaddr_list[nserv].sin_port =
htons(NAMESERVER_PORT);
nserv++;
#ifdef _LIBC
nservall++;
} else {
struct in6_addr a6;
char *el;
if ((el = strchr(cp, '\n')) != NULL)
*el = '\0';
if ((*cp != '\0') &&
(inet_pton(AF_INET6, cp, &a6) > 0)) {
struct sockaddr_in6 *sa6;
sa6 = malloc(sizeof(*sa6));
if (sa6 != NULL) {
sa6->sin6_addr = a6;
sa6->sin6_family = AF_INET6;
sa6->sin6_port = htons(NAMESERVER_PORT);
statp->_u._ext.nsaddrs[nservall] = sa6;
statp->_u._ext.nstimes[nservall] = RES_MAXTIME;
statp->_u._ext.nssocks[nservall] = -1;
nservall++;
}
}
#endif
}
continue;
}
#ifdef RESOLVSORT
if (MATCH(buf, "sortlist")) {
struct in_addr a;
cp = buf + sizeof("sortlist") - 1;
while (nsort < MAXRESOLVSORT) {
while (*cp == ' ' || *cp == '\t')
cp++;
if (*cp == '\0' || *cp == '\n' || *cp == ';')
break;
net = cp;
while (*cp && !ISSORTMASK(*cp) && *cp != ';' &&
isascii(*cp) && !isspace(*cp))
cp++;
n = *cp;
*cp = 0;
if (__inet_aton(net, &a)) {
statp->sort_list[nsort].addr = a;
if (ISSORTMASK(n)) {
*cp++ = n;
net = cp;
while (*cp && *cp != ';' &&
isascii(*cp) && !isspace(*cp))
cp++;
n = *cp;
*cp = 0;
if (__inet_aton(net, &a)) {
statp->sort_list[nsort].mask = a.s_addr;
} else {
statp->sort_list[nsort].mask =
net_mask(statp->sort_list[nsort].addr);
}
} else {
statp->sort_list[nsort].mask =
net_mask(statp->sort_list[nsort].addr);
}
nsort++;
}
*cp = n;
}
continue;
}
#endif
if (MATCH(buf, "options")) {
res_setoptions(statp, buf + sizeof("options") - 1, "conf");
continue;
}
}
if (nserv > 1)
statp->nscount = nserv;
#ifdef _LIBC
if (nservall - nserv > 0)
statp->_u._ext.nscount6 = nservall - nserv;
#endif
#ifdef RESOLVSORT
statp->nsort = nsort;
#endif
(void) fclose(fp);
}
if (statp->defdname[0] == 0 &&
__gethostname(buf, sizeof(statp->defdname) - 1) == 0 &&
(cp = strchr(buf, '.')) != NULL)
strcpy(statp->defdname, cp + 1);
/* find components of local domain that might be searched */
if (havesearch == 0) {
pp = statp->dnsrch;
*pp++ = statp->defdname;
*pp = NULL;
#ifndef RFC1535
dots = 0;
for (cp = statp->defdname; *cp; cp++)
dots += (*cp == '.');
cp = statp->defdname;
while (pp < statp->dnsrch + MAXDFLSRCH) {
if (dots < LOCALDOMAINPARTS)
break;
cp = __rawmemchr(cp, '.') + 1; /* we know there is one */
*pp++ = cp;
dots--;
}
*pp = NULL;
#ifdef DEBUG
if (statp->options & RES_DEBUG) {
printf(";; res_init()... default dnsrch list:\n");
for (pp = statp->dnsrch; *pp; pp++)
printf(";;\t%s\n", *pp);
printf(";;\t..END..\n");
}
#endif
#endif /* !RFC1535 */
}
if ((cp = getenv("RES_OPTIONS")) != NULL)
res_setoptions(statp, cp, "env");
statp->options |= RES_INIT;
return (0);
}
static void
internal_function
res_setoptions(res_state statp, const char *options, const char *source) {
const char *cp = options;
int i;
#ifdef DEBUG
if (statp->options & RES_DEBUG)
printf(";; res_setoptions(\"%s\", \"%s\")...\n",
options, source);
#endif
while (*cp) {
/* skip leading and inner runs of spaces */
while (*cp == ' ' || *cp == '\t')
cp++;
/* search for and process individual options */
if (!strncmp(cp, "ndots:", sizeof("ndots:") - 1)) {
i = atoi(cp + sizeof("ndots:") - 1);
if (i <= RES_MAXNDOTS)
statp->ndots = i;
else
statp->ndots = RES_MAXNDOTS;
#ifdef DEBUG
if (statp->options & RES_DEBUG)
printf(";;\tndots=%d\n", statp->ndots);
#endif
} else if (!strncmp(cp, "timeout:", sizeof("timeout:") - 1)) {
i = atoi(cp + sizeof("timeout:") - 1);
if (i <= RES_MAXRETRANS)
statp->retrans = i;
else
statp->retrans = RES_MAXRETRANS;
} else if (!strncmp(cp, "attempts:", sizeof("attempts:") - 1)){
i = atoi(cp + sizeof("attempts:") - 1);
if (i <= RES_MAXRETRY)
statp->retry = i;
else
statp->retry = RES_MAXRETRY;
} else if (!strncmp(cp, "debug", sizeof("debug") - 1)) {
#ifdef DEBUG
if (!(statp->options & RES_DEBUG)) {
printf(";; res_setoptions(\"%s\", \"%s\")..\n",
options, source);
statp->options |= RES_DEBUG;
}
printf(";;\tdebug\n");
#endif
} else if (!strncmp(cp, "inet6", sizeof("inet6") - 1)) {
statp->options |= RES_USE_INET6;
} else if (!strncmp(cp, "rotate", sizeof("rotate") - 1)) {
statp->options |= RES_ROTATE;
} else if (!strncmp(cp, "no-check-names",
sizeof("no-check-names") - 1)) {
statp->options |= RES_NOCHECKNAME;
} else {
/* XXX - print a warning here? */
}
/* skip to next run of spaces */
while (*cp && *cp != ' ' && *cp != '\t')
cp++;
}
}
#ifdef RESOLVSORT
/* XXX - should really support CIDR which means explicit masks always. */
static u_int32_t
net_mask(in) /* XXX - should really use system's version of this */
struct in_addr in;
{
register u_int32_t i = ntohl(in.s_addr);
if (IN_CLASSA(i))
return (htonl(IN_CLASSA_NET));
else if (IN_CLASSB(i))
return (htonl(IN_CLASSB_NET));
return (htonl(IN_CLASSC_NET));
}
#endif
u_int
res_randomid(void) {
struct timeval now;
__gettimeofday(&now, NULL);
return (0xffff & (now.tv_sec ^ now.tv_usec ^ __getpid()));
}
/*
* This routine is for closing the socket if a virtual circuit is used and
* the program wants to close it. This provides support for endhostent()
* which expects to close the socket.
*
* This routine is not expected to be user visible.
*/
void
res_nclose(res_state statp) {
int ns;
if (statp->_vcsock >= 0) {
(void) __close(statp->_vcsock);
statp->_vcsock = -1;
statp->_flags &= ~(RES_F_VC | RES_F_CONN);
}
#ifdef _LIBC
for (ns = 0; ns < statp->_u._ext.nscount + statp->_u._ext.nscount6;
ns++)
#else
for (ns = 0; ns < statp->_u._ext.nscount; ns++)
#endif
{
if (statp->_u._ext.nssocks[ns] != -1) {
(void) __close(statp->_u._ext.nssocks[ns]);
statp->_u._ext.nssocks[ns] = -1;
}
}
statp->_u._ext.nsinit = 0;
}
