{
int val;
- if ((val = fcntl(fd, F_GETFL, 0)) == -1)
+ if ((val = fcntl(fd, F_GETFL)) == -1)
return;
if (!(val & NONBLOCK_FLAG)) {
val |= NONBLOCK_FLAG;
{
int val;
- if ((val = fcntl(fd, F_GETFL, 0)) == -1)
+ if ((val = fcntl(fd, F_GETFL)) == -1)
return;
if (val & NONBLOCK_FLAG) {
val &= ~NONBLOCK_FLAG;
rprintf(FCLIENT, "\n");
}
-void out_of_memory(char *str)
+NORETURN void out_of_memory(const char *str)
{
rprintf(FERROR, "ERROR: out of memory in %s [%s]\n", str, who_am_i());
exit_cleanup(RERR_MALLOC);
}
-void overflow_exit(char *str)
+NORETURN void overflow_exit(const char *str)
{
rprintf(FERROR, "ERROR: buffer overflow in %s [%s]\n", str, who_am_i());
exit_cleanup(RERR_MALLOC);
}
-int set_modtime(char *fname, time_t modtime, mode_t mode)
+int set_modtime(const char *fname, time_t modtime, mode_t mode)
{
#if !defined HAVE_LUTIMES || !defined HAVE_UTIMES
if (S_ISLNK(mode))
t[1].tv_sec = modtime;
t[1].tv_usec = 0;
# ifdef HAVE_LUTIMES
- if (S_ISLNK(mode))
- return lutimes(fname, t);
+ if (S_ISLNK(mode)) {
+ lutimes(fname, t);
+ return 0; /* ignore errors */
+ }
# endif
return utimes(fname, t);
#elif defined HAVE_UTIMBUF
*
* Derived from GNU C's cccp.c.
*/
-int full_write(int desc, char *ptr, size_t len)
+int full_write(int desc, const char *ptr, size_t len)
{
int total_written;
/* start where the last one left off to reduce chance of clashes */
start = counter;
do {
- sprintf(&path[pos], "%03d", counter);
+ snprintf(&path[pos], MAX_RENAMES_DIGITS+1, "%03d", counter);
if (++counter >= MAX_RENAMES)
counter = 1;
} while ((rc = access(path, 0)) == 0 && counter != start);
* across filesystems, -2 if copy_file() failed, and -1 on other errors.
* If partialptr is not NULL and we need to do a copy, copy the file into
* the active partial-dir instead of over the destination file. */
-int robust_rename(char *from, char *to, char *partialptr,
+int robust_rename(const char *from, const char *to, const char *partialptr,
int mode)
{
int tries = 4;
}
/** Turn a user name into a uid */
-int name_to_uid(char *name, uid_t *uid)
+int name_to_uid(const char *name, uid_t *uid)
{
struct passwd *pass;
if (!name || !*name)
}
/** Turn a group name into a gid */
-int name_to_gid(char *name, gid_t *gid)
+int name_to_gid(const char *name, gid_t *gid)
{
struct group *grp;
if (!name || !*name)
void strlower(char *s)
{
while (*s) {
- if (isupper(*(unsigned char *)s))
- *s = tolower(*(unsigned char *)s);
+ if (isUpper(s))
+ *s = toLower(s);
s++;
}
}
return dest;
}
-/* If sanitize_paths is not set, this works exactly the same as do_stat().
- * Otherwise, we verify that no symlink takes us outside the module path.
- * If we encounter an escape attempt, we return a symlink's stat info! */
-int safe_stat(const char *fname, STRUCT_STAT *stp)
-{
-#ifdef SUPPORT_LINKS
- char tmpbuf[MAXPATHLEN], linkbuf[MAXPATHLEN], *mod_path;
- int i, llen, mod_path_len;
-
- if (!sanitize_paths)
- return do_stat(fname, stp);
-
- mod_path = lp_path(module_id);
- mod_path_len = strlen(mod_path);
-
- for (i = 0; i < 16; i++) {
-#ifdef DEBUG
- if (*fname == '/')
- assert(strncmp(fname, mod_path, mod_path_len) == 0 && fname[mod_path_len] == '/');
-#endif
- if (do_lstat(fname, stp) < 0)
- return -1;
- if (!S_ISLNK(stp->st_mode))
- return 0;
- if ((llen = readlink(fname, linkbuf, sizeof linkbuf - 1)) < 0)
- return -1;
- linkbuf[llen] = '\0';
- if (*fname == '/')
- fname += mod_path_len;
- if (!(fname = sanitize_path(tmpbuf, fname, mod_path, curr_dir_depth, linkbuf)))
- break;
- }
-
- return 0; /* Leave *stp set to the last symlink. */
-#else
- return do_stat(fname, stp);
-#endif
-}
-
-void die_on_unsafe_path(char *path, int strip_filename)
-{
-#ifdef SUPPORT_LINKS
- char *final_slash, *p;
- STRUCT_STAT st;
-
- if (!path)
- return;
- if (strip_filename) {
- if (!(final_slash = strrchr(path, '/')))
- return;
- *final_slash = '\0';
- } else
- final_slash = NULL;
-
- p = path;
- if (*p == '/')
- p += module_dirlen + 1;
- while (*p) {
- if ((p = strchr(p, '/')) != NULL)
- *p = '\0';
- if (safe_stat(path, &st) < 0) {
- *p++ = '/';
- goto done;
- }
- if (S_ISLNK(st.st_mode)) {
- rprintf(FERROR, "Unsafe path: %s\n", path);
- exit_cleanup(RERR_SYNTAX);
- }
- if (!p)
- break;
- *p++ = '/';
- }
-
- done:
- if (final_slash)
- *final_slash = '/';
-#endif
-}
-
/* Like chdir(), but it keeps track of the current directory (in the
* global "curr_dir"), and ensures that the path size doesn't overflow.
* Also cleans the path using the clean_fname() function. */
-int push_dir(char *dir)
+int push_dir(const char *dir, int set_path_only)
{
static int initialised;
unsigned int len;
if ((*dir == '/' ? len : curr_dir_len + 1 + len) >= sizeof curr_dir)
return 0;
- if (chdir(dir))
+ if (!set_path_only && chdir(dir))
return 0;
if (*dir == '/') {
* Reverse a push_dir() call. You must pass in an absolute path
* that was copied from a prior value of "curr_dir".
**/
-int pop_dir(char *dir)
+int pop_dir(const char *dir)
{
if (chdir(dir))
return 0;
if (create) {
STRUCT_STAT st;
int statret = do_lstat(dir, &st);
- if (sanitize_paths && *partial_dir != '/')
- die_on_unsafe_path(dir, 1); /* lstat handles last element */
if (statret == 0 && !S_ISDIR(st.st_mode)) {
if (do_unlink(dir) < 0)
return 0;
units = 'K';
}
if (units) {
- sprintf(bufs[n], "%.2f%c", dnum, units);
+ snprintf(bufs[n], sizeof bufs[0], "%.2f%c", dnum, units);
return bufs[n];
}
}
if (!num)
*--s = '0';
while (num) {
- *--s = (num % 10) + '0';
+ *--s = (char)(num % 10) + '0';
num /= 10;
}
return s;
{
char *buf = human_num(dnum);
int len = strlen(buf);
- if (isdigit(*(uchar*)(buf+len-1))) {
+ if (isDigit(buf + len - 1)) {
/* There's extra room in buf prior to the start of the num. */
buf -= decimal_digits + 1;
snprintf(buf, len + decimal_digits + 2, "%.*f", decimal_digits, dnum);
return buf;
}
-/**
- * Return the date and time as a string
- **/
+/* Return the date and time as a string. Some callers tweak returned buf. */
char *timestring(time_t t)
{
static char TimeBuf[200];
{
if (num >= MALLOC_MAX/size)
return NULL;
- /* No realloc should need this, but just in case... */
if (!ptr)
return malloc(size * num);
return realloc(ptr, size * num);
if (strcmp(s+1, "orig") == 0)
continue;
} else if (s_len > 2 && had_tilde
- && s[1] == '~' && isdigit(*(uchar*)(s+2)))
+ && s[1] == '~' && isDigit(s + 2))
continue;
*len_ptr = s_len;
suf = s;
break;
/* Determine if the suffix is all digits. */
for (s++, s_len--; s_len > 0; s++, s_len--) {
- if (!isdigit(*(uchar*)s))
+ if (!isDigit(s))
return suf;
}
/* An all-digit suffix may not be that signficant. */