static void pr_do(FILE *stream, const char *label, const char *fmt, va_list ap) { char fmtbuf[1024]; vsnprintf(fmtbuf, sizeof(fmtbuf), fmt, ap); fprintf(stream, "%s:%s: %s\n", _getprogname(), label, fmtbuf); }
void vwarnx(const char *fmt, va_list ap) { if (err_file == 0) err_set_file(NULL); fprintf(err_file, "%s: ", _getprogname()); if (fmt != NULL) vfprintf(err_file, fmt, ap); fprintf(err_file, "\n"); }
void vwarnc(int code, const char *fmt, va_list ap) { if (err_file == 0) err_set_file(NULL); fprintf(err_file, "%s: ", _getprogname()); if (fmt != NULL) { vfprintf(err_file, fmt, ap); fprintf(err_file, ": "); } fprintf(err_file, "%s\n", strerror(code)); }
void verrx(int eval, const char *fmt, va_list ap) { if (err_file == 0) err_set_file(NULL); fprintf(err_file, "%s: ", _getprogname()); if (fmt != NULL) vfprintf(err_file, fmt, ap); fprintf(err_file, "\n"); if (err_exit) err_exit(eval); exit(eval); }
void verrc(int eval, int code, const char *fmt, va_list ap) { if (err_file == NULL) err_set_file(NULL); fprintf(err_file, "%s: ", _getprogname()); if (fmt != NULL) { vfprintf(err_file, fmt, ap); fprintf(err_file, ": "); } fprintf(err_file, "%s\n", strerror(code)); if (err_exit) err_exit(eval); exit(eval); }
void __collate_err(int ex, const char* f) { const char* s; int serrno = errno; s = _getprogname(); _write(STDERR_FILENO, s, strlen(s)); _write(STDERR_FILENO, ": ", 2); s = f; _write(STDERR_FILENO, s, strlen(s)); _write(STDERR_FILENO, ": ", 2); s = strerror(serrno); _write(STDERR_FILENO, s, strlen(s)); _write(STDERR_FILENO, "\n", 1); exit(ex); }
void __collate_err(int ex, const char *f) { const char *progname; int serrno = errno; progname = _getprogname(); _write(STDERR_FILENO, progname, strlen(progname)); _write(STDERR_FILENO, ": ", 2); _write(STDERR_FILENO, f, strlen(f)); _write(STDERR_FILENO, ": ", 2); f = strerror(serrno); _write(STDERR_FILENO, f, strlen(f)); _write(STDERR_FILENO, "\n", 1); exit(ex); }
void __collate_err(int ex, const char *f) { #if 0 const char *s; int serrno = errno; s = _getprogname(); _write(STDERR_FILENO, s, strlen(s)); _write(STDERR_FILENO, ": ", 2); s = f; _write(STDERR_FILENO, s, strlen(s)); _write(STDERR_FILENO, ": ", 2); s = strerror(serrno); _write(STDERR_FILENO, s, strlen(s)); _write(STDERR_FILENO, "\n", 1); exit(ex); #endif printf("Warning: __collate_err() stubbed out!\n"); exit(ex); abort(); }
static void vsyslog1(int pri, const char *fmt, va_list ap) { struct timeval now; struct tm tm; char ch, *p; long tz_offset; int cnt, fd, saved_errno; char hostname[MAXHOSTNAMELEN], *stdp, tbuf[2048], fmt_cpy[1024], errstr[64], tz_sign; FILE *fp, *fmt_fp; struct bufcookie tbuf_cookie; struct bufcookie fmt_cookie; #define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID /* Check for invalid bits. */ if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) { syslog(INTERNALLOG, "syslog: unknown facility/priority: %x", pri); pri &= LOG_PRIMASK|LOG_FACMASK; } saved_errno = errno; /* Check priority against setlogmask values. */ if (!(LOG_MASK(LOG_PRI(pri)) & LogMask)) return; /* Set default facility if none specified. */ if ((pri & LOG_FACMASK) == 0) pri |= LogFacility; /* Create the primary stdio hook */ tbuf_cookie.base = tbuf; tbuf_cookie.left = sizeof(tbuf); fp = fwopen(&tbuf_cookie, writehook); if (fp == NULL) return; /* Build the message according to RFC 5424. Tag and version. */ (void)fprintf(fp, "<%d>1 ", pri); /* Timestamp similar to RFC 3339. */ if (gettimeofday(&now, NULL) == 0 && localtime_r(&now.tv_sec, &tm) != NULL) { if (tm.tm_gmtoff < 0) { tz_sign = '-'; tz_offset = -tm.tm_gmtoff; } else { tz_sign = '+'; tz_offset = tm.tm_gmtoff; } (void)fprintf(fp, "%04d-%02d-%02d" /* Date. */ "T%02d:%02d:%02d.%06ld" /* Time. */ "%c%02ld:%02ld ", /* Time zone offset. */ tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, now.tv_usec, tz_sign, tz_offset / 3600, (tz_offset % 3600) / 60); } else (void)fprintf(fp, "- "); /* Hostname. */ (void)gethostname(hostname, sizeof(hostname)); (void)fprintf(fp, "%s ", hostname); if (LogStat & LOG_PERROR) { /* Transfer to string buffer */ (void)fflush(fp); stdp = tbuf + (sizeof(tbuf) - tbuf_cookie.left); } /* * Application name, process ID, message ID and structured data. * Provide the process ID regardless of whether LOG_PID has been * specified, as it provides valuable information. Many * applications tend not to use this, even though they should. */ if (LogTag == NULL) LogTag = _getprogname(); (void)fprintf(fp, "%s %d - - ", LogTag == NULL ? "-" : LogTag, getpid()); /* Check to see if we can skip expanding the %m */ if (strstr(fmt, "%m")) { /* Create the second stdio hook */ fmt_cookie.base = fmt_cpy; fmt_cookie.left = sizeof(fmt_cpy) - 1; fmt_fp = fwopen(&fmt_cookie, writehook); if (fmt_fp == NULL) { fclose(fp); return; } /* * Substitute error message for %m. Be careful not to * molest an escaped percent "%%m". We want to pass it * on untouched as the format is later parsed by vfprintf. */ for ( ; (ch = *fmt); ++fmt) { if (ch == '%' && fmt[1] == 'm') { ++fmt; strerror_r(saved_errno, errstr, sizeof(errstr)); fputs(errstr, fmt_fp); } else if (ch == '%' && fmt[1] == '%') { ++fmt; fputc(ch, fmt_fp); fputc(ch, fmt_fp); } else { fputc(ch, fmt_fp); } } /* Null terminate if room */ fputc(0, fmt_fp); fclose(fmt_fp); /* Guarantee null termination */ fmt_cpy[sizeof(fmt_cpy) - 1] = '\0'; fmt = fmt_cpy; } (void)vfprintf(fp, fmt, ap); (void)fclose(fp); cnt = sizeof(tbuf) - tbuf_cookie.left; /* Remove a trailing newline */ if (tbuf[cnt - 1] == '\n') cnt--; /* Output to stderr if requested. */ if (LogStat & LOG_PERROR) { struct iovec iov[2]; struct iovec *v = iov; v->iov_base = stdp; v->iov_len = cnt - (stdp - tbuf); ++v; v->iov_base = "\n"; v->iov_len = 1; (void)_writev(STDERR_FILENO, iov, 2); } /* Get connected, output the message to the local logger. */ if (!opened) openlog_unlocked(LogTag, LogStat | LOG_NDELAY, 0); connectlog(); /* * If the send() fails, there are two likely scenarios: * 1) syslogd was restarted * 2) /var/run/log is out of socket buffer space, which * in most cases means local DoS. * If the error does not indicate a full buffer, we address * case #1 by attempting to reconnect to /var/run/log[priv] * and resending the message once. * * If we are working with a privileged socket, the retry * attempts end there, because we don't want to freeze a * critical application like su(1) or sshd(8). * * Otherwise, we address case #2 by repeatedly retrying the * send() to give syslogd a chance to empty its socket buffer. */ if (send(LogFile, tbuf, cnt, 0) < 0) { if (errno != ENOBUFS) { /* * Scenario 1: syslogd was restarted * reconnect and resend once */ disconnectlog(); connectlog(); if (send(LogFile, tbuf, cnt, 0) >= 0) return; /* * if the resend failed, fall through to * possible scenario 2 */ } while (errno == ENOBUFS) { /* * Scenario 2: out of socket buffer space * possible DoS, fail fast on a privileged * socket */ if (status == CONNPRIV) break; _usleep(1); if (send(LogFile, tbuf, cnt, 0) >= 0) return; } } else return; /* * Output the message to the console; try not to block * as a blocking console should not stop other processes. * Make sure the error reported is the one from the syslogd failure. */ if (LogStat & LOG_CONS && (fd = _open(_PATH_CONSOLE, O_WRONLY|O_NONBLOCK|O_CLOEXEC, 0)) >= 0) { struct iovec iov[2]; struct iovec *v = iov; p = strchr(tbuf, '>') + 3; v->iov_base = p; v->iov_len = cnt - (p - tbuf); ++v; v->iov_base = "\r\n"; v->iov_len = 2; (void)_writev(fd, iov, 2); (void)_close(fd); } }
void vsyslog(int pri, const char *fmt, va_list ap) { int cnt; char ch, *p; time_t now; int fd, saved_errno; char *stdp, tbuf[2048], fmt_cpy[1024], timbuf[26], errstr[64]; FILE *fp, *fmt_fp; struct bufcookie tbuf_cookie; struct bufcookie fmt_cookie; #define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID /* Check for invalid bits. */ if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) { syslog(INTERNALLOG, "syslog: unknown facility/priority: %x", pri); pri &= LOG_PRIMASK|LOG_FACMASK; } saved_errno = errno; THREAD_LOCK(); /* Check priority against setlogmask values. */ if (!(LOG_MASK(LOG_PRI(pri)) & LogMask)) { THREAD_UNLOCK(); return; } /* Set default facility if none specified. */ if ((pri & LOG_FACMASK) == 0) pri |= LogFacility; /* Create the primary stdio hook */ tbuf_cookie.base = tbuf; tbuf_cookie.left = sizeof(tbuf); fp = fwopen(&tbuf_cookie, writehook); if (fp == NULL) { THREAD_UNLOCK(); return; } /* Build the message. */ (void)time(&now); (void)fprintf(fp, "<%d>", pri); (void)fprintf(fp, "%.15s ", ctime_r(&now, timbuf) + 4); if (LogStat & LOG_PERROR) { /* Transfer to string buffer */ (void)fflush(fp); stdp = tbuf + (sizeof(tbuf) - tbuf_cookie.left); } if (LogTag == NULL) LogTag = _getprogname(); if (LogTag != NULL) (void)fprintf(fp, "%s", LogTag); if (LogStat & LOG_PID) (void)fprintf(fp, "[%d]", getpid()); if (LogTag != NULL) { (void)fprintf(fp, ": "); } /* Check to see if we can skip expanding the %m */ if (strstr(fmt, "%m")) { /* Create the second stdio hook */ fmt_cookie.base = fmt_cpy; fmt_cookie.left = sizeof(fmt_cpy) - 1; fmt_fp = fwopen(&fmt_cookie, writehook); if (fmt_fp == NULL) { fclose(fp); THREAD_UNLOCK(); return; } /* * Substitute error message for %m. Be careful not to * molest an escaped percent "%%m". We want to pass it * on untouched as the format is later parsed by vfprintf. */ for ( ; (ch = *fmt); ++fmt) { if (ch == '%' && fmt[1] == 'm') { ++fmt; strerror_r(saved_errno, errstr, sizeof(errstr)); fputs(errstr, fmt_fp); } else if (ch == '%' && fmt[1] == '%') { ++fmt; fputc(ch, fmt_fp); fputc(ch, fmt_fp); } else { fputc(ch, fmt_fp); } } /* Null terminate if room */ fputc(0, fmt_fp); fclose(fmt_fp); /* Guarantee null termination */ fmt_cpy[sizeof(fmt_cpy) - 1] = '\0'; fmt = fmt_cpy; } (void)vfprintf(fp, fmt, ap); (void)fclose(fp); cnt = sizeof(tbuf) - tbuf_cookie.left; /* Remove a trailing newline */ if (tbuf[cnt - 1] == '\n') cnt--; /* Output to stderr if requested. */ if (LogStat & LOG_PERROR) { struct iovec iov[2]; struct iovec *v = iov; v->iov_base = stdp; v->iov_len = cnt - (stdp - tbuf); ++v; v->iov_base = "\n"; v->iov_len = 1; (void)_writev(STDERR_FILENO, iov, 2); } /* Get connected, output the message to the local logger. */ if (!opened) openlog_unlocked(LogTag, LogStat | LOG_NDELAY, 0); connectlog(); /* * If the send() failed, there are two likely scenarios: * 1) syslogd was restarted * 2) /var/run/log is out of socket buffer space, which * in most cases means local DoS. * We attempt to reconnect to /var/run/log to take care of * case #1 and keep send()ing data to cover case #2 * to give syslogd a chance to empty its socket buffer. * * If we are working with a priveleged socket, then take * only one attempt, because we don't want to freeze a * critical application like su(1) or sshd(8). * */ if (send(LogFile, tbuf, cnt, 0) < 0) { if (errno != ENOBUFS) { disconnectlog(); connectlog(); } do { _usleep(1); if (send(LogFile, tbuf, cnt, 0) >= 0) { THREAD_UNLOCK(); return; } if (status == CONNPRIV) break; } while (errno == ENOBUFS); } else { THREAD_UNLOCK(); return; } /* * Output the message to the console; try not to block * as a blocking console should not stop other processes. * Make sure the error reported is the one from the syslogd failure. */ if (LogStat & LOG_CONS && (fd = _open(_PATH_CONSOLE, O_WRONLY|O_NONBLOCK, 0)) >= 0) { struct iovec iov[2]; struct iovec *v = iov; p = strchr(tbuf, '>') + 1; v->iov_base = p; v->iov_len = cnt - (p - tbuf); ++v; v->iov_base = "\r\n"; v->iov_len = 2; (void)_writev(fd, iov, 2); (void)_close(fd); } THREAD_UNLOCK(); }
void _mcleanup(void) { int fd; int fromindex; int endfrom; u_long frompc; int toindex; struct rawarc rawarc; struct gmonparam *p = &_gmonparam; struct gmonhdr gmonhdr, *hdr; struct clockinfo clockinfo; char outname[128]; int mib[2]; size_t size; #ifdef DEBUG int log, len; char buf[200]; #endif if (p->state == GMON_PROF_ERROR) ERR("_mcleanup: tos overflow\n"); size = sizeof(clockinfo); mib[0] = CTL_KERN; mib[1] = KERN_CLOCKRATE; if (sysctl(mib, 2, &clockinfo, &size, NULL, 0) < 0) { /* * Best guess */ clockinfo.profhz = hertz(); } else if (clockinfo.profhz == 0) { if (clockinfo.hz != 0) clockinfo.profhz = clockinfo.hz; else clockinfo.profhz = hertz(); } moncontrol(0); if (getenv("PROFIL_USE_PID")) snprintf(outname, sizeof(outname), "%s.%d.gmon", _getprogname(), getpid()); else snprintf(outname, sizeof(outname), "%s.gmon", _getprogname()); fd = _open(outname, O_CREAT|O_TRUNC|O_WRONLY|O_CLOEXEC, 0666); if (fd < 0) { _warn("_mcleanup: %s", outname); return; } #ifdef DEBUG log = _open("gmon.log", O_CREAT|O_TRUNC|O_WRONLY|O_CLOEXEC, 0664); if (log < 0) { _warn("_mcleanup: gmon.log"); return; } len = sprintf(buf, "[mcleanup1] kcount 0x%p ssiz %lu\n", p->kcount, p->kcountsize); _write(log, buf, len); #endif hdr = (struct gmonhdr *)&gmonhdr; bzero(hdr, sizeof(*hdr)); hdr->lpc = p->lowpc; hdr->hpc = p->highpc; hdr->ncnt = p->kcountsize + sizeof(gmonhdr); hdr->version = GMONVERSION; hdr->profrate = clockinfo.profhz; _write(fd, (char *)hdr, sizeof *hdr); _write(fd, p->kcount, p->kcountsize); endfrom = p->fromssize / sizeof(*p->froms); for (fromindex = 0; fromindex < endfrom; fromindex++) { if (p->froms[fromindex] == 0) continue; frompc = p->lowpc; frompc += fromindex * p->hashfraction * sizeof(*p->froms); for (toindex = p->froms[fromindex]; toindex != 0; toindex = p->tos[toindex].link) { #ifdef DEBUG len = sprintf(buf, "[mcleanup2] frompc 0x%lx selfpc 0x%lx count %lu\n" , frompc, p->tos[toindex].selfpc, p->tos[toindex].count); _write(log, buf, len); #endif rawarc.raw_frompc = frompc; rawarc.raw_selfpc = p->tos[toindex].selfpc; rawarc.raw_count = p->tos[toindex].count; _write(fd, &rawarc, sizeof rawarc); } } _close(fd); }
/* * getopt -- * Parse argc/argv argument vector. */ int getopt(int nargc,char * const nargv[],const char *ostr) { static char *place = EMSG; /* option letter processing */ char *oli; /* option letter list index */ if (optreset || *place == 0) { /* update scanning pointer */ optreset = 0; place = nargv[optind]; if (optind >= nargc || *place++ != '-') { /* Argument is absent or is not an option */ place = EMSG; return (-1); } optopt = *place++; if (optopt == '-' && *place == 0) { /* "--" => end of options */ ++optind; place = EMSG; return (-1); } if (optopt == 0) { /* Solitary '-', treat as a '-' option if the program (eg su) is looking for it. */ place = EMSG; if (strchr(ostr, '-') == NULL) return (-1); optopt = '-'; } } else optopt = *place++; /* See if option letter is one the caller wanted... */ if (optopt == ':' || (oli = (char*)strchr(ostr, optopt)) == NULL) { if (*place == 0) ++optind; if (opterr && *ostr != ':') (void)fprintf(stderr, "%s: illegal option -- %c\n", _getprogname(), optopt); return (BADCH); } /* Does this option need an argument? */ if (oli[1] != ':') { /* don't need argument */ optarg = NULL; if (*place == 0) ++optind; } else { /* Option-argument is either the rest of this argument or the entire next argument. */ if (*place) optarg = place; else if (nargc > ++optind) optarg = nargv[optind]; else { /* option-argument absent */ place = EMSG; if (*ostr == ':') return (BADARG); if (opterr) (void)fprintf(stderr, "%s: option requires an argument -- %c\n", _getprogname(), optopt); return (BADCH); } place = EMSG; ++optind; } return (optopt); /* return option letter */ }
void setproctitle(const char *fmt, ...) { #ifndef __CHERI_PURE_CAPABILITY__ static struct ps_strings *ps_strings; #endif static char *buf = NULL; static char *obuf = NULL; static char **oargv, *kbuf; static int oargc = -1; static char *nargv[2] = { NULL, NULL }; char **nargvp; int nargc; #ifndef __CHERI_PURE_CAPABILITY__ int i; #endif va_list ap; size_t len; #ifndef __CHERI_PURE_CAPABILITY__ unsigned long ul_ps_strings; #endif int oid[4]; if (buf == NULL) { buf = malloc(SPT_BUFSIZE); if (buf == NULL) return; nargv[0] = buf; } if (obuf == NULL ) { obuf = malloc(SPT_BUFSIZE); if (obuf == NULL) return; *obuf = '\0'; } va_start(ap, fmt); if (fmt) { buf[SPT_BUFSIZE - 1] = '\0'; if (fmt[0] == '-') { /* skip program name prefix */ fmt++; len = 0; } else { /* print program name heading for grep */ (void)snprintf(buf, SPT_BUFSIZE, "%s: ", _getprogname()); len = strlen(buf); } /* print the argument string */ (void) vsnprintf(buf + len, SPT_BUFSIZE - len, fmt, ap); nargvp = nargv; nargc = 1; kbuf = buf; } else if (*obuf != '\0') { /* Idea from NetBSD - reset the title on fmt == NULL */ nargvp = oargv; nargc = oargc; kbuf = obuf; } else /* Nothing to restore */ return; va_end(ap); /* Set the title into the kernel cached command line */ oid[0] = CTL_KERN; oid[1] = KERN_PROC; oid[2] = KERN_PROC_ARGS; oid[3] = getpid(); sysctl(oid, 4, 0, 0, kbuf, strlen(kbuf) + 1); #ifndef __CHERI_PURE_CAPABILITY__ if (ps_strings == NULL) { len = sizeof(ul_ps_strings); if (sysctlbyname("kern.ps_strings", &ul_ps_strings, &len, NULL, 0) == -1) return; ps_strings = (struct ps_strings *)ul_ps_strings; } /* * PS_STRINGS points to zeroed memory on a style #2 kernel. * Should not happen. */ if (ps_strings->ps_argvstr == NULL) return; /* style #3 */ if (oargc == -1) { /* Record our original args */ oargc = ps_strings->ps_nargvstr; oargv = ps_strings->ps_argvstr; for (i = len = 0; i < oargc; i++) { /* * The program may have scribbled into its * argv array, e.g., to remove some arguments. * If that has happened, break out before * trying to call strlen on a NULL pointer. */ if (oargv[i] == NULL) { oargc = i; break; } snprintf(obuf + len, SPT_BUFSIZE - len, "%s%s", len != 0 ? " " : "", oargv[i]); if (len != 0) len++; len += strlen(oargv[i]); if (len >= SPT_BUFSIZE) break; } } ps_strings->ps_nargvstr = nargc; ps_strings->ps_argvstr = nargvp; #endif /* !__CHERI_PURE_CAPABILITY__ */ }
/* * Lock a location for the running thread. Yield to allow other * threads to run if this thread is blocked because the lock is * not available. Note that this function does not sleep. It * assumes that the lock will be available very soon. * * This function checks if the running thread has already locked the * location, warns if this occurs and creates a thread dump before * returning. */ void _spinlock_debug(spinlock_t *lck, char *fname, int lineno) { struct pthread *curthread = _get_curthread(); int cnt = 0; /* * Try to grab the lock and loop if another thread grabs * it before we do. */ while(_atomic_lock(&lck->access_lock)) { cnt++; if (cnt > 100) { char str[256]; snprintf(str, sizeof(str), "%s - Warning: Thread %p attempted to lock %p from %s (%d) was left locked from %s (%d)\n", _getprogname(), curthread, lck, fname, lineno, lck->fname, lck->lineno); __sys_extpwrite(2, str, strlen(str), O_FBLOCKING, -1); __sleep(1); cnt = 0; } /* Block the thread until the lock. */ curthread->data.spinlock = lck; _thread_kern_sched_state(PS_SPINBLOCK, fname, lineno); } /* The running thread now owns the lock: */ lck->lock_owner = (long) curthread; lck->fname = fname; lck->lineno = lineno; }