static int
utx_log_add(const struct futx *fu)
{
struct iovec vec[2];
int error, fd;
uint16_t l;
/*
* Append an entry to the log file. We only need to append
* records to this file, so to conserve space, trim any trailing
* zero-bytes. Prepend a length field, indicating the length of
* the record, excluding the length field itself.
*/
for (l = sizeof(*fu); l > 0 && ((const char *)fu)[l - 1] == '\0'; l--) ;
vec[0].iov_base = &l;
vec[0].iov_len = sizeof(l);
vec[1].iov_base = __DECONST(void *, fu);
vec[1].iov_len = l;
l = htobe16(l);
fd = _open(_PATH_UTX_LOG, O_CREAT|O_WRONLY|O_APPEND, 0644);
if (fd < 0)
return (-1);
if (_writev(fd, vec, 2) == -1)
error = errno;
else
error = 0;
_close(fd);
errno = error;
return (error == 0 ? 0 : 1);
}
void
perror(const char *s)
{
char msgbuf[NL_TEXTMAX];
struct iovec *v;
struct iovec iov[4];
v = iov;
if (s != NULL && *s != '\0') {
v->iov_base = (char *)s;
v->iov_len = strlen(s);
v++;
v->iov_base = ": ";
v->iov_len = 2;
v++;
}
strerror_r(errno, msgbuf, sizeof(msgbuf));
v->iov_base = msgbuf;
v->iov_len = strlen(v->iov_base);
v++;
v->iov_base = "\n";
v->iov_len = 1;
FLOCKFILE(stderr);
__sflush(stderr);
(void)_writev(stderr->_file, iov, (v - iov) + 1);
stderr->_flags &= ~__SOFF;
FUNLOCKFILE(stderr);
}
ssize_t
writev(int fd, const struct iovec *iov, int iovcnt)
{
ssize_t ret;
_thread_enter_cancellation_point();
ret = _writev(fd, iov, iovcnt);
_thread_leave_cancellation_point();
return ret;
}
int
bc_writev(int fd, struct iovec *iov, int iovcnt)
{
int ret, off;
int nsize, total = 0;
char *nbuf;
int i;
if (fd_get(fd) != -1) {
for (i = 0; i < iovcnt; i++) {
nsize = getmodsize(iov[i].iov_len,
sizeof (struct compat_utmp),
sizeof (struct utmpx));
if ((nbuf = (void *)malloc(nsize)) == NULL) {
fprintf(stderr, "writev: malloc failed\n");
exit(-1);
}
(void) memset(nbuf, 0, nsize);
ret = conv2utmpx(nbuf, iov[i].iov_base, iov[i].iov_len);
if ((ret = _write(fd, nbuf, ret)) == -1) {
free(nbuf);
return (-1);
}
free(nbuf);
ret = getmodsize(ret, sizeof (struct utmpx),
sizeof (struct compat_utmp));
total += ret;
}
return (total);
}
return (_writev(fd, iov, iovcnt));
}
JNIEXPORT jlong JNICALL Java_io_netty_channel_unix_FileDescriptor_writev(JNIEnv* env, jclass clazz, jint fd, jobjectArray buffers, jint offset, jint length) {
struct iovec iov[length];
int iovidx = 0;
int i;
int num = offset + length;
for (i = offset; i < num; i++) {
jobject bufObj = (*env)->GetObjectArrayElement(env, buffers, i);
jint pos;
// Get the current position using the (*env)->GetIntField if possible and fallback
// to slower (*env)->CallIntMethod(...) if needed
if (posFieldId == NULL) {
pos = (*env)->CallIntMethod(env, bufObj, posId, NULL);
} else {
pos = (*env)->GetIntField(env, bufObj, posFieldId);
}
jint limit;
// Get the current limit using the (*env)->GetIntField if possible and fallback
// to slower (*env)->CallIntMethod(...) if needed
if (limitFieldId == NULL) {
limit = (*env)->CallIntMethod(env, bufObj, limitId, NULL);
} else {
limit = (*env)->GetIntField(env, bufObj, limitFieldId);
}
void* buffer = (*env)->GetDirectBufferAddress(env, bufObj);
// We check that GetDirectBufferAddress will not return NULL in OnLoad
iov[iovidx].iov_base = buffer + pos;
iov[iovidx].iov_len = (size_t) (limit - pos);
iovidx++;
// Explicit delete local reference as otherwise the local references will only be released once the native method returns.
// Also there may be a lot of these and JNI specification only specify that 16 must be able to be created.
//
// See https://github.com/netty/netty/issues/2623
(*env)->DeleteLocalRef(env, bufObj);
}
return _writev(env, clazz, fd, iov, length);
}
/*%
* herror --
* print the error indicated by the h_errno value.
*/
void
herror(const char *s) {
struct iovec iov[4], *v = iov;
char *t;
if (s != NULL && *s != '\0') {
DE_CONST(s, t);
v->iov_base = t;
v->iov_len = strlen(t);
v++;
DE_CONST(": ", t);
v->iov_base = t;
v->iov_len = 2;
v++;
}
DE_CONST(hstrerror(*__h_errno()), t);
v->iov_base = t;
v->iov_len = strlen(v->iov_base);
v++;
DE_CONST("\n", t);
v->iov_base = t;
v->iov_len = 1;
_writev(STDERR_FILENO, iov, (v - iov) + 1);
}
/*
* __REC_SYNC -- sync the recno tree to disk.
*
* Parameters:
* dbp: pointer to access method
*
* Returns:
* RET_SUCCESS, RET_ERROR.
*/
int
__rec_sync(const DB *dbp, u_int flags)
{
struct iovec iov[2];
BTREE *t;
DBT data, key;
off_t off;
recno_t scursor, trec;
int status;
t = dbp->internal;
/* Toss any page pinned across calls. */
if (t->bt_pinned != NULL) {
mpool_put(t->bt_mp, t->bt_pinned, 0);
t->bt_pinned = NULL;
}
if (flags == R_RECNOSYNC)
return (__bt_sync(dbp, 0));
if (F_ISSET(t, R_RDONLY | R_INMEM) || !F_ISSET(t, R_MODIFIED))
return (RET_SUCCESS);
/* Read any remaining records into the tree. */
if (!F_ISSET(t, R_EOF) && t->bt_irec(t, MAX_REC_NUMBER) == RET_ERROR)
return (RET_ERROR);
/* Rewind the file descriptor. */
if (lseek(t->bt_rfd, (off_t)0, SEEK_SET) != 0)
return (RET_ERROR);
/* Save the cursor. */
scursor = t->bt_cursor.rcursor;
key.size = sizeof(recno_t);
key.data = &trec;
if (F_ISSET(t, R_FIXLEN)) {
/*
* We assume that fixed length records are all fixed length.
* Any that aren't are either EINVAL'd or corrected by the
* record put code.
*/
status = (dbp->seq)(dbp, &key, &data, R_FIRST);
while (status == RET_SUCCESS) {
if (_write(t->bt_rfd, data.data, data.size) !=
(ssize_t)data.size)
return (RET_ERROR);
status = (dbp->seq)(dbp, &key, &data, R_NEXT);
}
} else {
iov[1].iov_base = &t->bt_bval;
iov[1].iov_len = 1;
status = (dbp->seq)(dbp, &key, &data, R_FIRST);
while (status == RET_SUCCESS) {
iov[0].iov_base = data.data;
iov[0].iov_len = data.size;
if (_writev(t->bt_rfd, iov, 2) != (ssize_t)(data.size + 1))
return (RET_ERROR);
status = (dbp->seq)(dbp, &key, &data, R_NEXT);
}
}
/* Restore the cursor. */
t->bt_cursor.rcursor = scursor;
if (status == RET_ERROR)
return (RET_ERROR);
if ((off = lseek(t->bt_rfd, (off_t)0, SEEK_CUR)) == -1)
return (RET_ERROR);
if (ftruncate(t->bt_rfd, off))
return (RET_ERROR);
F_CLR(t, R_MODIFIED);
return (RET_SUCCESS);
}
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();
}
JNIEXPORT jlong JNICALL Java_io_netty_channel_unix_FileDescriptor_writevAddresses(JNIEnv* env, jclass clazz, jint fd, jlong memoryAddress, jint length) {
struct iovec* iov = (struct iovec*) (intptr_t) memoryAddress;
return _writev(env, clazz, fd, iov, length);
}
void OutputFileFITS::write64fv(int ncol, std::vector< std::vector<double> >& buff, long frow, long lrow)
{
_writev(ncol, buff, TDOUBLE, frow, lrow);
}
void OutputFileFITS::write32fv(int ncol, std::vector< std::vector<float> >& buff, long frow, long lrow)
{
_writev(ncol, buff, TFLOAT, frow, lrow);
}
void OutputFileFITS::write64iv(int ncol, std::vector< std::vector<int64_t> >& buff, long frow, long lrow)
{
_writev(ncol, buff, TLONG, frow, lrow);
}
void OutputFileFITS::write32iv(int ncol, std::vector< std::vector<int32_t> >& buff, long frow, long lrow)
{
_writev(ncol, buff, TINT, frow, lrow);
}
void OutputFileFITS::write16iv(int ncol, std::vector< std::vector<int16_t> >& buff, long frow, long lrow)
{
_writev(ncol, buff, TSHORT, frow, lrow);
}
void OutputFileFITS::writeu8iv(int ncol, std::vector< std::vector<uint8_t> >& buff, long frow, long lrow)
{
_writev(ncol, buff, TBYTE, frow, lrow);
}