From bd4909a899a4663c3f51ea80d3c75db80c0cf30f Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 05:30:43 +0200 Subject: Adding upstream version 4.9.1. Signed-off-by: Daniel Baumann --- misc.c | 722 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 722 insertions(+) create mode 100644 misc.c (limited to 'misc.c') diff --git a/misc.c b/misc.c new file mode 100644 index 0000000..95093a9 --- /dev/null +++ b/misc.c @@ -0,0 +1,722 @@ +/* Copyright (c) 2008, 2009 + * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de) + * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de) + * Micah Cowan (micah@cowan.name) + * Sadrul Habib Chowdhury (sadrul@users.sourceforge.net) + * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007 + * Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de) + * Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de) + * Copyright (c) 1987 Oliver Laumann + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program (see the file COPYING); if not, see + * https://www.gnu.org/licenses/, or contact Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA + * + **************************************************************** + */ + +#include +#include +#include /* mkdir() declaration */ +#include + +#include "config.h" +#include "screen.h" +#include "extern.h" + +#ifdef SVR4 +# include +#endif + +extern struct layer *flayer; + +extern int eff_uid, real_uid; +extern int eff_gid, real_gid; +extern struct mline mline_old; +extern struct mchar mchar_blank; +extern unsigned char *null, *blank; + +#ifdef HAVE_FDWALK +static int close_func __P((void *, int)); +#endif + +char * +SaveStr(register const char *str) +{ + register char *cp; + + if (str == NULL) + Panic(0, "SaveStr() received NULL - possibly failed crypt()"); + if ((cp = malloc(strlen(str) + 1)) == NULL) + Panic(0, "%s", strnomem); + else + strcpy(cp, str); + return cp; +} + +char * +SaveStrn(register const char *str, int n) +{ + register char *cp; + + if ((cp = malloc(n + 1)) == NULL) + Panic(0, "%s", strnomem); + else { + bcopy((char *)str, cp, n); + cp[n] = 0; + } + return cp; +} + +/* cheap strstr replacement */ +char * +InStr(char *str, const char *pat) +{ + int npat = strlen(pat); + for (; *str; str++) + if (!strncmp(str, pat, npat)) + return str; + return 0; +} + +#ifndef HAVE_STRERROR +char * +strerror(int err) +{ + extern int sys_nerr; + extern char *sys_errlist[]; + + static char er[20]; + if (err > 0 && err < sys_nerr) + return sys_errlist[err]; + sprintf(er, "Error %d", err); + return er; +} +#endif + +void +centerline(char *str, int y) +{ + int l, n; + + ASSERT(flayer); + n = strlen(str); + if (n > flayer->l_width - 1) + n = flayer->l_width - 1; + l = (flayer->l_width - 1 - n) / 2; + LPutStr(flayer, str, n, &mchar_blank, l, y); +} + +void +leftline(char *str, int y, struct mchar *rend) +{ + int l, n; + struct mchar mchar_dol; + + mchar_dol = mchar_blank; + mchar_dol.image = '$'; + + ASSERT(flayer); + l = n = strlen(str); + if (n > flayer->l_width - 1) + n = flayer->l_width - 1; + LPutStr(flayer, str, n, rend ? rend : &mchar_blank, 0, y); + if (n != l) + LPutChar(flayer, &mchar_dol, n, y); +} + +char * +Filename(char *s) +{ + register char *p = s; + + if (p) + while (*p) + if (*p++ == '/') + s = p; + return s; +} + +char * +stripdev(char *nam) +{ +#ifdef apollo + char *p; + + if (nam == NULL) + return NULL; +# ifdef SVR4 + /* unixware has /dev/pts012 as synonym for /dev/pts/12 */ + if (!strncmp(nam, "/dev/pts", 8) && nam[8] >= '0' && nam[8] <= '9') { + static char b[13]; + sprintf(b, "pts/%d", atoi(nam + 8)); + return b; + } +# endif /* SVR4 */ + if (p = strstr(nam, "/dev/")) + return p + 5; +#else /* apollo */ + if (nam == NULL) + return NULL; + if (strncmp(nam, "/dev/", 5) == 0) + return nam + 5; +#endif /* apollo */ + return nam; +} + +/* + * Signal handling + */ + +#ifdef POSIX +sigret_t (*xsignal(sig, func)) +# ifndef __APPLE__ + __P(SIGPROTOARG) +# else +() +# endif +int sig; +sigret_t (*func) __P(SIGPROTOARG); +{ + struct sigaction osa, sa; + sa.sa_handler = func; + (void)sigemptyset(&sa.sa_mask); +#ifdef SA_RESTART + sa.sa_flags = (sig == SIGCHLD ? SA_RESTART : 0); +#else + sa.sa_flags = 0; +#endif + if (sigaction(sig, &sa, &osa)) + return (sigret_t (*)__P(SIGPROTOARG))-1; + return osa.sa_handler; +} + +#else +# ifdef hpux +/* + * hpux has berkeley signal semantics if we use sigvector, + * but not, if we use signal, so we define our own signal() routine. + */ +void (*xsignal(sig, func)) __P(SIGPROTOARG) +int sig; +void (*func) __P(SIGPROTOARG); +{ + struct sigvec osv, sv; + + sv.sv_handler = func; + sv.sv_mask = sigmask(sig); + sv.sv_flags = SV_BSDSIG; + if (sigvector(sig, &sv, &osv) < 0) + return (void (*)__P(SIGPROTOARG))(BADSIG); + return osv.sv_handler; +} +# endif /* hpux */ +#endif /* POSIX */ + +/* + * uid/gid handling + */ + +#ifdef HAVE_SETEUID + +void +xseteuid(int euid) +{ + if (seteuid(euid) == 0) + return; + seteuid(0); + if (seteuid(euid)) + Panic(errno, "seteuid"); +} + +void +xsetegid(int egid) +{ + if (setegid(egid)) + Panic(errno, "setegid"); +} + +#else /* HAVE_SETEUID */ +# ifdef HAVE_SETREUID + +void +xseteuid(int euid) +{ + int oeuid; + + oeuid = geteuid(); + if (oeuid == euid) + return; + if ((int)getuid() != euid) + oeuid = getuid(); + if (setreuid(oeuid, euid)) + Panic(errno, "setreuid"); +} + +void +xsetegid(int egid) +{ + int oegid; + + oegid = getegid(); + if (oegid == egid) + return; + if ((int)getgid() != egid) + oegid = getgid(); + if (setregid(oegid, egid)) + Panic(errno, "setregid"); +} + +# endif /* HAVE_SETREUID */ +#endif /* HAVE_SETEUID */ + +#ifdef NEED_OWN_BCOPY +void +xbcopy(register char *s1, register char *s2, register int len) +{ + if (s1 < s2 && s2 < s1 + len) { + s1 += len; + s2 += len; + while (len-- > 0) + *--s2 = *--s1; + } else + while (len-- > 0) + *s2++ = *s1++; +} +#endif /* NEED_OWN_BCOPY */ + +void +bclear(char *p, int n) +{ + bcopy((char *)blank, p, n); +} + +void +Kill(int pid, int sig) +{ + if (pid < 2) + return; + (void)kill(pid, sig); +} + +#ifdef HAVE_FDWALK +/* + * Modern versions of Solaris include fdwalk(3c) which allows efficient + * implementation of closing open descriptors; this is helpful because + * the default file descriptor limit has risen to 65k. + */ +static int +close_func(void *cb_data, int fd) +{ + int except = *(int *)cb_data; + if (fd > 2 && fd != except) + (void)close(fd); + return (0); +} + +void +closeallfiles(int except) +{ + (void)fdwalk(close_func, &except); +} + +#else /* HAVE_FDWALK */ + +void +closeallfiles(int except) +{ + int f; +#ifdef SVR4 + struct rlimit rl; + + if ((getrlimit(RLIMIT_NOFILE, &rl) == 0) && + rl.rlim_max != RLIM_INFINITY) + f = rl.rlim_max; + else +#endif /* SVR4 */ +#if defined(SYSV) && defined(NOFILE) && !defined(ISC) + f = NOFILE; + while (--f > 2) + if (f != except) + close(f); +#else /* SYSV && !ISC */ + { + struct pollfd pfd[1024]; + int maxfd, i, ret, z; + + i = 3; /* skip stdin, stdout and stderr */ + maxfd = getdtablesize(); + + while (i < maxfd) { + memset(pfd, 0, sizeof(pfd)); + + z = 0; + for (f = i; f < maxfd && f < i + 1024; f++) + pfd[z++].fd = f; + + ret = poll(pfd, f - i, 0); + if (ret < 0) + Panic(errno, "poll"); + + z = 0; + for (f = i; f < maxfd && f < i + 1024; f++) + if (!(pfd[z++].revents & POLLNVAL) && + f != except) + close(f); + + i = f; + } + } +#endif /* SYSV && !ISC */ +} + +#endif /* HAVE_FDWALK */ + +/* + * Security - switch to real uid + */ + +#ifndef USE_SETEUID +static int UserPID; +static sigret_t (*Usersigcld) __P(SIGPROTOARG); +#endif +static int UserSTAT; + +int +UserContext() +{ +#ifndef USE_SETEUID + if (eff_uid == real_uid && eff_gid == real_gid) + return 1; + Usersigcld = signal(SIGCHLD, SIG_DFL); + debug("UserContext: forking.\n"); + switch (UserPID = fork()) { + case -1: + Msg(errno, "fork"); + return -1; + case 0: + signal(SIGHUP, SIG_DFL); + signal(SIGINT, SIG_IGN); + signal(SIGQUIT, SIG_DFL); + signal(SIGTERM, SIG_DFL); +# ifdef BSDJOBS + signal(SIGTTIN, SIG_DFL); + signal(SIGTTOU, SIG_DFL); +# endif + setuid(real_uid); + setgid(real_gid); + return 1; + default: + return 0; + } +#else + xseteuid(real_uid); + xsetegid(real_gid); + return 1; +#endif +} + +void +UserReturn(int val) +{ +#ifndef USE_SETEUID + if (eff_uid == real_uid && eff_gid == real_gid) + UserSTAT = val; + else + _exit(val); +#else + xseteuid(eff_uid); + xsetegid(eff_gid); + UserSTAT = val; +#endif +} + +int +UserStatus() +{ +#ifndef USE_SETEUID + int i; +# ifdef BSDWAIT + union wait wstat; +# else + int wstat; +# endif + + if (eff_uid == real_uid && eff_gid == real_gid) + return UserSTAT; + if (UserPID < 0) + return -1; + while ((errno = 0, i = wait(&wstat)) != UserPID) + if (i < 0 && errno != EINTR) + break; + (void)signal(SIGCHLD, Usersigcld); + if (i == -1) + return -1; + return WEXITSTATUS(wstat); +#else + return UserSTAT; +#endif +} + +#ifndef HAVE_RENAME +int +rename(char *old, char *new) +{ + if (link(old, new) < 0) + return -1; + return unlink(old); +} +#endif + +int +AddXChar(char *buf, int ch) +{ + char *p = buf; + + if (ch < ' ' || ch == 0x7f) { + *p++ = '^'; + *p++ = ch ^ 0x40; + } else if (ch >= 0x80) { + *p++ = '\\'; + *p++ = (ch >> 6 & 7) + '0'; + *p++ = (ch >> 3 & 7) + '0'; + *p++ = (ch >> 0 & 7) + '0'; + } else + *p++ = ch; + return p - buf; +} + +int +AddXChars(char *buf, int len, char *str) +{ + char *p; + + if (str == 0) { + *buf = 0; + return 0; + } + len -= 4; /* longest sequence produced by AddXChar() */ + for (p = buf; p < buf + len && *str; str++) { + if (*str == ' ') + *p++ = *str; + else + p += AddXChar(p, *str); + } + *p = 0; + return p - buf; +} + +#ifdef DEBUG +void +opendebug(int new, int shout) +{ + char buf[256]; + +#ifdef _MODE_T + mode_t oumask = umask(0); +#else + int oumask = umask(0); +#endif + + ASSERT(!dfp); + + (void)mkdir(DEBUGDIR, 0777); + sprintf(buf, shout ? + "%s/SCREEN.%d" : "%s/screen.%d", DEBUGDIR, getpid()); + if (!(dfp = fopen(buf, new ? "w" : "a"))) + dfp = stderr; + else + (void)chmod(buf, 0666); + + (void)umask(oumask); + debug("opendebug: done.\n"); +} +#endif /* DEBUG */ + +void +sleep1000(int msec) +{ + struct timeval t; + + t.tv_sec = (long)(msec / 1000); + t.tv_usec = (long)((msec % 1000) * 1000); + select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &t); +} + +/* + * This uses either setenv() or putenv(). If it is putenv() we cannot dare + * to free the buffer after putenv(), unless it it the one found in putenv.c + */ +void +xsetenv(char *var, char *value) +{ +#ifndef USESETENV + char *buf; + int l; + + if ((buf = (char *)malloc((l = strlen(var)) + + strlen(value) + 2)) == NULL) { + Msg(0, strnomem); + return; + } + strcpy(buf, var); + buf[l] = '='; + strcpy(buf + l + 1, value); + putenv(buf); +# ifdef NEEDPUTENV + /* + * we use our own putenv(), knowing that it does a malloc() + * the string space, we can free our buf now. + */ + free(buf); +# else /* NEEDPUTENV */ + /* + * For all sysv-ish systems that link a standard putenv() + * the string-space buf is added to the environment and must not + * be freed, or modified. + * We are sorry to say that memory is lost here, when setting + * the same variable again and again. + */ +# endif /* NEEDPUTENV */ +#else /* USESETENV */ +# if HAVE_SETENV_3 + setenv(var, value, 1); +# else + setenv(var, value); +# endif /* HAVE_SETENV_3 */ +#endif /* USESETENV */ +} + +#ifdef TERMINFO +/* + * This is a replacement for the buggy _delay function from the termcap + * emulation of libcurses, which ignores ospeed. + */ +int +_delay(register int delay, int (*outc) __P((int))) +{ + int pad; + extern short ospeed; + static short osp2pad[] = { + 0,2000,1333,909,743,666,500,333,166,83,55,41,20,10,5,2,1,1 + }; + + if (ospeed <= 0 || ospeed >= (int)(sizeof(osp2pad)/sizeof(*osp2pad))) + return 0; + pad =osp2pad[ospeed]; + delay = (delay + pad / 2) / pad; + while (delay-- > 0) + (*outc)(0); + return 0; +} + +#endif /* TERMINFO */ + +#ifndef USEVARARGS + +# define xva_arg(s, t, tn) (*(t *)(s += xsnoff(tn, 0, 0), s - xsnoff(tn, 0, 0))) +# define xva_list char * + +static int +xsnoff(int a, char *b, int c) +{ + return a ? (char *)&c - (char *)&b : (char *)&b - (char *)&a; +} + +int +xsnprintf(char *s, int n, char *fmt, unsigned long p1, p2, p3, p4, p5, p6) +{ + int xvsnprintf __P((char *, int, char *, xva_list)); + return xvsnprintf(s, n, fmt, (char *)&fmt + xsnoff(1, 0, 0)); +} + +#else + +# define xva_arg(s, t, tn) va_arg(s, t) +# define xva_list va_list + +#endif + +#if !defined(USEVARARGS) || !defined(HAVE_VSNPRINTF) + +int +xvsnprintf(char *s, int n, char *fmt, xva_list stack) +{ + char *f, *sf = 0; + int i, on, argl = 0; + char myf[10], buf[20]; + char *arg, *myfp; + + on = n; + f = fmt; + arg = 0; + while (arg || (sf = index(f, '%')) || (sf = f + strlen(f))) { + if (arg == 0) { + arg = f; + argl = sf - f; + } + if (argl) { + i = argl > n - 1 ? n - 1 : argl; + strncpy(s, arg, i); + s += i; + n -= i; + if (i < argl) { + *s = 0; + return on; + } + } + arg = 0; + if (sf == 0) + continue; + f = sf; + sf = 0; + if (!*f) + break; + myfp = myf; + *myfp++ = *f++; + while (((*f >= '0' && *f <= '9') || *f == '#') && + myfp - myf < 8) + *myfp++ = *f++; + *myfp++ = *f; + *myfp = 0; + if (!*f++) + break; + switch (f[-1]) { + case '%': + arg = "%"; + break; + case 'c': + case 'o': + case 'd': + case 'x': + i = xva_arg(stack, int, 0); + sprintf(buf, myf, i); + arg = buf; + break; + case 's': + arg = xva_arg(stack, char *, 1); + if (arg == 0) + arg = "NULL"; + break; + default: + arg = ""; + break; + } + argl = strlen(arg); + } + *s = 0; + return on - n; +} + +#endif -- cgit v1.2.3