rprintf(FCLIENT, "\n");
}
-NORETURN 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);
}
-NORETURN 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;
* 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++;
}
}
/* 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 set_path_only)
+int push_dir(const char *dir, int set_path_only)
{
static int initialised;
unsigned int len;
* 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 (!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. */