/usr/src/usr.bin/rsync/rules.c

Bug Summary

File:	src/usr.bin/rsync/rules.c
Warning:	line 430, column 9 Null pointer passed as 1st argument to string comparison function

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name rules.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/rsync/obj -resource-dir /usr/local/lib/clang/13.0.0 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/rsync/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.bin/rsync/rules.c

1/*	$OpenBSD: rules.c,v 1.4 2021/11/03 14:42:12 deraadt Exp $ */
2/*
* Copyright (c) 2021 Claudio Jeker <claudio@openbsd.org>
*
* 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.
*/
17#include <err.h>
18#include <stdlib.h>
19#include <stdio.h>
20#include <string.h>

22#include "extern.h"

24struct rule {
char			*pattern;
enum rule_type		 type;
27#ifdef NOTYET
unsigned int		 modifiers;
29#endif
short			 numseg;
unsigned char		 anchored;
unsigned char		 fileonly;
unsigned char		 nowild;
unsigned char		 onlydir;
unsigned char		 leadingdir;
36};

38static struct rule	*rules;
39static size_t		 numrules;	/* number of rules */
40static size_t		 rulesz;	/* available size */

42/* up to protocol 29 filter rules only support - + ! and no modifiers */

44const struct command {
enum rule_type		type;
char			sopt;
const char		*lopt;
48} commands[] = {
{ RULE_EXCLUDE,		'-',	"exclude" },
{ RULE_INCLUDE,		'+',	"include" },
{ RULE_CLEAR,		'!',	"clear" },
52#ifdef NOTYET
{ RULE_MERGE,		'.',	"merge" },
{ RULE_DIR_MERGE,	':',	"dir-merge" },
{ RULE_SHOW,		'S',	"show" },
{ RULE_HIDE,		'H',	"hide" },
{ RULE_PROTECT,		'P',	"protect" },
{ RULE_RISK,		'R',	"risk" },
59#endif
{ 0 }
61};

63#ifdef NOTYET
64#define MOD_ABSOLUTE			0x0001
65#define MOD_NEGATE			0x0002
66#define MOD_CVSEXCLUDE			0x0004
67#define MOD_SENDING			0x0008
68#define MOD_RECEIVING			0x0010
69#define MOD_PERISHABLE			0x0020
70#define MOD_XATTR			0x0040
71#define MOD_MERGE_EXCLUDE		0x0080
72#define MOD_MERGE_INCLUDE		0x0100
73#define MOD_MERGE_CVSCOMPAT		0x0200
74#define MOD_MERGE_EXCLUDE_FILE		0x0400
75#define MOD_MERGE_NO_INHERIT		0x0800
76#define MOD_MERGE_WORDSPLIT		0x1000

78/* maybe support absolute and negate */
79const struct modifier {
unsigned int		modifier;
char			sopt;
82} modifiers[] = {
{ MOD_ABSOLUTE,			'/' },
{ MOD_NEGATE,			'!' },
{ MOD_CVSEXCLUDE,		'C' },
{ MOD_SENDING,			's' },
{ MOD_RECEIVING,		'r' },
{ MOD_PERISHABLE,		'p' },
{ MOD_XATTR,			'x' },
/* for '.' and ':' types */
{ MOD_MERGE_EXCLUDE,		'-' },
{ MOD_MERGE_INCLUDE,		'+' },
{ MOD_MERGE_CVSCOMPAT,		'C' },
{ MOD_MERGE_EXCLUDE_FILE,	'e' },
{ MOD_MERGE_NO_INHERIT,		'n' },
{ MOD_MERGE_WORDSPLIT,		'w' },
{ 0 }
98}
99#endif

101static struct rule *
102get_next_rule(void)
103{
struct rule *new;
size_t newsz;

if (++numrules > rulesz) {
if (rulesz == 0)
	newsz = 16;
else
	newsz = rulesz * 2;

new = recallocarray(rules, rulesz, newsz, sizeof(*rules));
if (new == NULL((void *)0))
	err(ERR_NOMEM22, NULL((void *)0));

rules = new;
rulesz = newsz;
}

return rules + numrules - 1;
122}

124static enum rule_type
125parse_command(const char *command, size_t len)
126{
const char *mod;
size_t	i;

mod = memchr(command, ',', len);
if (mod != NULL((void *)0)) {
/* XXX modifiers not yet implemented */
return RULE_NONE;
}

for (i = 0; commands[i].type != RULE_NONE; i++) {
if (strncmp(commands[i].lopt, command, len) == 0)
	return commands[i].type;
if (len == 1 && commands[i].sopt == *command)
	return commands[i].type;
}

return RULE_NONE;
144}

146static void
147parse_pattern(struct rule *r, char *pattern)
148{
size_t plen;
char *p;
short nseg = 1;

/*
* check for / at start and end of pattern both are special and
* can bypass full path matching.
*/
if (*pattern == '/') {
pattern++;
r->anchored = 1;
}
plen = strlen(pattern);
/*
* check for patterns ending in '/' and '/'+'***' and handle them
* specially. Because of this and the check above pattern will never
* start or end with a '/'.
*/
if (plen > 1 && pattern[plen - 1] == '/') {
r->onlydir = 1;
pattern[plen - 1] = '\0';
}
if (plen > 4 && strcmp(pattern + plen - 4, "/***") == 0) {
r->leadingdir = 1;
pattern[plen - 4] = '\0';
}

/* count how many segments the pattern has. */
for (p = pattern; *p != '\0'; p++)
if (*p == '/')
	nseg++;
r->numseg = nseg;

/* check if this pattern only matches against the basename */
if (nseg == 1 && !r->anchored)
r->fileonly = 1;

if (strpbrk(pattern, "*?[") == NULL((void *)0)) {
/* no wildchar matching */
r->nowild = 1;
} else {
/* requires wildchar matching */
if (strstr(pattern, "**") != NULL((void *)0))
	r->numseg = -1;
}

r->pattern = strdup(pattern);
if (r->pattern == NULL((void *)0))
err(ERR_NOMEM22, NULL((void *)0));
198}

200int
201parse_rule(char *line, enum rule_type def)
202{
enum rule_type type;
struct rule *r;
char *pattern;
size_t len;

switch (*line) {
case '#':
case ';':
/* comment */
return 0;
case '\0':
/* ingore empty lines */
return 0;
default:
len = strcspn(line, " _");
type = parse_command(line, len);
if (type == RULE_NONE) {
	if (def == RULE_NONE)
		return -1;
	type = def;
	pattern = line;
} else
	pattern = line + len + 1;

if (*pattern == '\0' && type != RULE_CLEAR)
	return -1;
if (*pattern != '\0' && type == RULE_CLEAR)
	return -1;
break;
}

r = get_next_rule();
r->type = type;
parse_pattern(r, pattern);

return 0;
239}

241void
242parse_file(const char *file, enum rule_type def)
243{
FILE *fp;
char *line = NULL((void *)0);
size_t linesize = 0, linenum = 0;
ssize_t linelen;

if ((fp = fopen(file, "r")) == NULL((void *)0))
err(ERR_SYNTAX1, "open: %s", file);

while ((linelen = getline(&line, &linesize, fp)) != -1) {
linenum++;
line[linelen - 1] = '\0';
if (parse_rule(line, def) == -1)
	errx(ERR_SYNTAX1, "syntax error in %s at entry %zu",
	    file, linenum);
}

free(line);
if (ferror(fp)(!__isthreaded ? (((fp)->_flags & 0x0040) != 0) : (ferror
)(fp)))
err(ERR_SYNTAX1, "failed to parse file %s", file);
fclose(fp);
264}

266static const char *
267send_command(struct rule *r)
268{
static char buf[16];
char *b = buf;
char *ep = buf + sizeof(buf);

switch (r->type) {
case RULE_EXCLUDE:
*b++ = '-';
break;
case RULE_INCLUDE:
*b++ = '+';
break;
case RULE_CLEAR:
*b++ = '!';
break;
283#ifdef NOTYET
case RULE_MERGE:
*b++ = '.';
break;
case RULE_DIR_MERGE:
*b++ = ':';
break;
case RULE_SHOW:
*b++ = 'S';
break;
case RULE_HIDE:
*b++ = 'H';
break;
case RULE_PROTECT:
*b++ = 'P';
break;
case RULE_RISK:
*b++ = 'R';
break;
302#endif
default:
err(ERR_SYNTAX1, "unknown rule type %d", r->type);
}

307#ifdef NOTYET
for (i = 0; modifiers[i].modifier != 0; i++) {
if (rule->modifiers & modifiers[i].modifier)
	*b++ = modifiers[i].sopt;
if (b >= ep - 3)
	err(ERR_SYNTAX1, "rule modifiers overflow");
}
314#endif
if (b >= ep - 3)
err(ERR_SYNTAX1, "rule prefix overflow");
*b++ = ' ';

/* include the stripped root '/' for anchored patterns */
if (r->anchored)
*b++ = '/';
*b++ = '\0';
return buf;
324}

326static const char *
327postfix_command(struct rule *r)
328{
static char buf[8];

buf[0] = '\0';
if (r->onlydir)
strlcpy(buf, "/", sizeof(buf));
if (r->leadingdir)
strlcpy(buf, "/***", sizeof(buf));

return buf;
338}

340void
341send_rules(struct sess *sess, int fd)
342{
const char *cmd;
const char *postfix;
struct rule *r;
size_t cmdlen, len, postlen, i;

for (i = 0; i < numrules; i++) {
r = &rules[i];
cmd = send_command(r);
if (cmd == NULL((void *)0))
	err(ERR_PROTOCOL2,
	    "rules are incompatible with remote rsync");
postfix = postfix_command(r);
cmdlen = strlen(cmd);
len = strlen(r->pattern);
postlen = strlen(postfix);

if (!io_write_int(sess, fd, cmdlen + len + postlen))
	err(ERR_SOCK_IO10, "send rules");
if (!io_write_buf(sess, fd, cmd, cmdlen))
	err(ERR_SOCK_IO10, "send rules");
if (!io_write_buf(sess, fd, r->pattern, len))
	err(ERR_SOCK_IO10, "send rules");
/* include the '/' stripped by onlydir */
if (postlen > 0)
	if (!io_write_buf(sess, fd, postfix, postlen))
		err(ERR_SOCK_IO10, "send rules");
}

if (!io_write_int(sess, fd, 0))
err(ERR_SOCK_IO10, "send rules");
373}

375void
376recv_rules(struct sess *sess, int fd)
377{
char line[8192];
size_t len;

do {
if (!io_read_size(sess, fd, &len))
	err(ERR_SOCK_IO10, "receive rules");

if (len == 0)
	return;
if (len >= sizeof(line) - 1)
	errx(ERR_SOCK_IO10, "received rule too long");
if (!io_read_buf(sess, fd, line, len))
	err(ERR_SOCK_IO10, "receive rules");
line[len] = '\0';
if (parse_rule(line, RULE_NONE) == -1)
	errx(ERR_PROTOCOL2, "syntax error in received rules");
} while (1);
395}

397static inline int
398rule_matched(struct rule *r)
399{
/* TODO apply negation once modifiers are added */

if (r->type == RULE_EXCLUDE)
return -1;
else
return 1;
406}

408int
409rules_match(const char *path, int isdir)
410{
const char *basename, *p = NULL((void *)0);
struct rule *r;
size_t i;

basename = strrchr(path, '/');
if (basename != NULL((void *)0))
1
Assuming 'basename' is equal to NULL→
2
←
Taking false branch→
basename += 1;
else
basename = path;
3
←
Value assigned to 'basename'→

for (i = 0; i < numrules; i++) {
4
←
Assuming 'i' is < 'numrules'→
5
←
Loop condition is true.  Entering loop body→
13
←
Assuming 'i' is < 'numrules'→
14
←
Loop condition is true.  Entering loop body→
r = &rules[i];

if (r->onlydir && !isdir)
6
←
Assuming field 'onlydir' is 0→
15
←
Assuming field 'onlydir' is 0→
	continue;

if (r->nowild) {
7
←
Assuming field 'nowild' is 0→
8
←
Taking false branch→
16
←
Assuming field 'nowild' is not equal to 0→
17
←
Taking true branch→
	/* fileonly and anchored are mutually exclusive */
	if (r->fileonly) {
18
←
Assuming field 'fileonly' is not equal to 0→
19
←
Taking true branch→
		if (strcmp(basename, r->pattern) == 0)
20
←
Null pointer passed as 1st argument to string comparison function
			return rule_matched(r);
	} else if (r->anchored) {
		/*
		 * assumes that neither path nor pattern
		 * start with a '/'.
		 */
		if (strcmp(path, r->pattern) == 0)
			return rule_matched(r);
	} else if (r->leadingdir) {
		size_t plen = strlen(r->pattern);

		p = strstr(path, r->pattern);
		/*
		 * match from start or dir boundary also
		 * match to end or to dir boundary
		 */
		if (p != NULL((void *)0) && (p == path || p[-1] == '/') &&
		    (p[plen] == '\0' || p[plen] == '/'))
			return rule_matched(r);
	} else {
		size_t len = strlen(path);
		size_t plen = strlen(r->pattern);

		if (len >= plen && strcmp(path + len - plen,
		    r->pattern) == 0) {
			/* match all or start on dir boundary */
			if (len == plen ||
			    path[len - plen - 1] == '/')
				return rule_matched(r);
		}
	}
} else {
	if (r->fileonly) {
9
←
Assuming field 'fileonly' is not equal to 0→
10
←
Taking true branch→
		p = basename;
	} else if (r->anchored || r->numseg == -1) {
		/* full path matching */
		p = path;
	} else {
		short nseg = 1;

		/* match against the last numseg elements */
		for (p = path; *p != '\0'; p++)
			if (*p == '/')
				nseg++;
		if (nseg < r->numseg) {
			p = NULL((void *)0);
		} else {
			nseg -= r->numseg;
			for (p = path; *p != '\0' && nseg > 0;
			    p++) {
				if (*p == '/')
					nseg--;
			}
		}
	}

	if (p != NULL((void *)0)) {
11
←
Assuming 'p' is equal to NULL→
12
←
Taking false branch→
		if (rmatch(r->pattern, p, r->leadingdir) == 0)
			return rule_matched(r);
	}
}
}

return 0;
495}