inline JSON_STATUS ngx_http_req_stat_get_json_status(ngx_http_request_t *r)
{
if(r->out != NULL && r->out->buf != NULL){
ngx_buf_t* buf = r->out->buf;
if(ngx_buf_size(buf)> 5 && ngx_buf_in_memory_only(buf)){
return ngx_http_req_stat_find_ok_status(buf->pos, buf->end-buf->pos);
}else{
//printf("#######ngx_buf_size(buf)> 5 && ngx_buf_in_memory_only(buf)###\n");
return NOJSON;
}
}else{
//printf("r->out != NULL && r->out->buf != NULL\n");
return NORESP;
}
}
inline ngx_str_t ngx_http_req_stat_get_json_reason(ngx_http_request_t *r)
{
static ngx_str_t empty_reason = ngx_string("-");
if(r->out != NULL && r->out->buf != NULL && ngx_buf_size(r->out->buf)> 8){
ngx_buf_t* buf = r->out->buf;
if(ngx_buf_in_memory_only(buf)){
return ngx_http_req_stat_find_reason(buf->pos, buf->end-buf->pos);
}else{
return empty_reason;
}
}else{
return empty_reason;
}
}
static void ngx_http_push_copy_preallocated_buffer(ngx_buf_t *buf, ngx_buf_t *cbuf) {
if (cbuf!=NULL) {
ngx_memcpy(cbuf, buf, sizeof(*buf)); //overkill?
if(buf->temporary || buf->memory) { //we don't want to copy mmpapped memory, so no ngx_buf_in_momory(buf)
cbuf->pos = (u_char *) (cbuf+1);
cbuf->last = cbuf->pos + ngx_buf_size(buf);
cbuf->start=cbuf->pos;
cbuf->end = cbuf->start + ngx_buf_size(buf);
ngx_memcpy(cbuf->pos, buf->pos, ngx_buf_size(buf));
cbuf->memory=ngx_buf_in_memory_only(buf) ? 1 : 0;
}
if (buf->file!=NULL) {
cbuf->file = (ngx_file_t *) (cbuf+1) + ((buf->temporary || buf->memory) ? ngx_buf_size(buf) : 0);
cbuf->file->fd=buf->file->fd; //used to be set to NGX_INVALID_FILE
cbuf->file->log=NULL;
cbuf->file->offset=buf->file->offset;
cbuf->file->sys_offset=buf->file->sys_offset;
cbuf->file->name.len=buf->file->name.len;
cbuf->file->name.data=(u_char *) (cbuf->file+1);
ngx_memcpy(cbuf->file->name.data, buf->file->name.data, buf->file->name.len);
}
}
}
ngx_chain_t *
ngx_freebsd_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int rc, flags;
u_char *prev;
off_t size, send, prev_send, aligned, sent, fprev;
size_t header_size, file_size;
ngx_uint_t eintr, eagain, complete;
ngx_err_t err;
ngx_buf_t *file;
ngx_array_t header, trailer;
ngx_event_t *wev;
ngx_chain_t *cl;
struct sf_hdtr hdtr;
struct iovec *iov, headers[NGX_HEADERS], trailers[NGX_TRAILERS];
wev = c->write;
if (!wev->ready) {
return in;
}
#if (NGX_HAVE_KQUEUE)
if ((ngx_event_flags & NGX_USE_KQUEUE_EVENT) && wev->pending_eof) {
(void) ngx_connection_error(c, wev->kq_errno,
"kevent() reported about an closed connection");
wev->error = 1;
return NGX_CHAIN_ERROR;
}
#endif
/* the maximum limit size is the maximum size_t value - the page size */
if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
}
send = 0;
eagain = 0;
flags = 0;
header.elts = headers;
header.size = sizeof(struct iovec);
header.nalloc = NGX_HEADERS;
header.pool = c->pool;
trailer.elts = trailers;
trailer.size = sizeof(struct iovec);
trailer.nalloc = NGX_TRAILERS;
trailer.pool = c->pool;
for ( ;; ) {
file = NULL;
file_size = 0;
header_size = 0;
eintr = 0;
complete = 0;
prev_send = send;
header.nelts = 0;
trailer.nelts = 0;
/* create the header iovec and coalesce the neighbouring bufs */
prev = NULL;
iov = NULL;
for (cl = in; cl && send < limit; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (!ngx_buf_in_memory_only(cl->buf)) {
break;
}
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
iov->iov_len += (size_t) size;
} else {
if (header.nelts >= IOV_MAX){
break;
}
iov = ngx_array_push(&header);
if (iov == NULL) {
return NGX_CHAIN_ERROR;
}
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
header_size += (size_t) size;
send += size;
}
if (cl && cl->buf->in_file && send < limit) {
file = cl->buf;
/* coalesce the neighbouring file bufs */
do {
size = cl->buf->file_last - cl->buf->file_pos;
if (send + size > limit) {
size = limit - send;
aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
& ~((off_t) ngx_pagesize - 1);
if (aligned <= cl->buf->file_last) {
size = aligned - cl->buf->file_pos;
}
}
file_size += (size_t) size;
send += size;
fprev = cl->buf->file_pos + size;
cl = cl->next;
} while (cl
&& cl->buf->in_file
&& send < limit
&& file->file->fd == cl->buf->file->fd
&& fprev == cl->buf->file_pos);
}
if (file) {
/* create the trailer iovec and coalesce the neighbouring bufs */
prev = NULL;
iov = NULL;
while (cl && send < limit) {
if (ngx_buf_special(cl->buf)) {
cl = cl->next;
continue;
}
if (!ngx_buf_in_memory_only(cl->buf)) {
break;
}
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
iov->iov_len += (size_t) size;
} else {
if (trailer.nelts >= IOV_MAX){
break;
}
iov = ngx_array_push(&trailer);
if (iov == NULL) {
return NGX_CHAIN_ERROR;
}
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
send += size;
cl = cl->next;
}
}
if (file) {
if (ngx_freebsd_use_tcp_nopush
&& c->tcp_nopush == NGX_TCP_NOPUSH_UNSET)
{
if (ngx_tcp_nopush(c->fd) == NGX_ERROR) {
err = ngx_socket_errno;
/*
* there is a tiny chance to be interrupted, however,
* we continue a processing without the TCP_NOPUSH
*/
if (err != NGX_EINTR) {
wev->error = 1;
(void) ngx_connection_error(c, err,
ngx_tcp_nopush_n " failed");
return NGX_CHAIN_ERROR;
}
} else {
c->tcp_nopush = NGX_TCP_NOPUSH_SET;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
"tcp_nopush");
}
}
/*
* sendfile() does unneeded work if sf_hdtr's count is 0,
* but corresponding pointer is not NULL
*/
hdtr.headers = header.nelts ? (struct iovec *) header.elts: NULL;
hdtr.hdr_cnt = header.nelts;
hdtr.trailers = trailer.nelts ? (struct iovec *) trailer.elts: NULL;
hdtr.trl_cnt = trailer.nelts;
/*
* the "nbytes bug" of the old sendfile() syscall:
* http://bugs.freebsd.org/33771
*/
if (!ngx_freebsd_sendfile_nbytes_bug) {
header_size = 0;
}
sent = 0;
#if (NGX_HAVE_AIO_SENDFILE)
flags = c->aio_sendfile ? SF_NODISKIO : 0;
#endif
rc = sendfile(file->file->fd, c->fd, file->file_pos,
file_size + header_size, &hdtr, &sent, flags);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
eagain = 1;
break;
case NGX_EINTR:
eintr = 1;
break;
#if (NGX_HAVE_AIO_SENDFILE)
case NGX_EBUSY:
c->busy_sendfile = file;
break;
#endif
default:
wev->error = 1;
(void) ngx_connection_error(c, err, "sendfile() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfile() sent only %O bytes", sent);
/*
* sendfile() in FreeBSD 3.x-4.x may return value >= 0
* on success, although only 0 is documented
*/
} else if (rc >= 0 && sent == 0) {
/*
* if rc is OK and sent equal to zero, then someone
* has truncated the file, so the offset became beyond
* the end of the file
*/
ngx_log_error(NGX_LOG_ALERT, c->log, 0,
"sendfile() reported that \"%s\" was truncated at %O",
file->file->name.data, file->file_pos);
return NGX_CHAIN_ERROR;
}
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: %d, @%O %O:%uz",
rc, file->file_pos, sent, file_size + header_size);
} else {
rc = writev(c->fd, header.elts, header.nelts);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"writev: %d of %uz", rc, header_size);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
ngx_connection_error(c, err, "writev() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"writev() not ready");
}
sent = rc > 0 ? rc : 0;
}
if (send - prev_send == sent) {
complete = 1;
}
c->sent += sent;
for ( /* void */ ; in; in = in->next) {
if (ngx_buf_special(in->buf)) {
continue;
}
if (sent == 0) {
break;
}
size = ngx_buf_size(in->buf);
if (sent >= size) {
sent -= size;
if (ngx_buf_in_memory(in->buf)) {
in->buf->pos = in->buf->last;
}
if (in->buf->in_file) {
in->buf->file_pos = in->buf->file_last;
}
continue;
}
if (ngx_buf_in_memory(in->buf)) {
in->buf->pos += (size_t) sent;
}
if (in->buf->in_file) {
in->buf->file_pos += sent;
}
break;
}
#if (NGX_HAVE_AIO_SENDFILE)
if (c->busy_sendfile) {
return in;
}
#endif
if (eagain) {
/*
* sendfile() may return EAGAIN, even if it has sent a whole file
* part, it indicates that the successive sendfile() call would
* return EAGAIN right away and would not send anything.
* We use it as a hint.
*/
wev->ready = 0;
return in;
}
if (eintr) {
continue;
}
if (!complete) {
wev->ready = 0;
return in;
}
if (send >= limit || in == NULL) {
return in;
}
}
}
ngx_chain_t *
ngx_linux_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int rc, tcp_nodelay;
off_t size, send, prev_send, aligned, sent, fprev;
u_char *prev;
size_t file_size;
ngx_err_t err;
ngx_buf_t *file;
ngx_uint_t eintr, complete;
ngx_array_t header;
ngx_event_t *wev;
ngx_chain_t *cl;
struct iovec *iov, headers[NGX_HEADERS];
#if (NGX_HAVE_SENDFILE64)
off_t offset;
#else
int32_t offset;
#endif
wev = c->write;
if (!wev->ready) {
return in;
}
/* the maximum limit size is 2G-1 - the page size */
if (limit == 0 || limit > (off_t) (NGX_SENDFILE_LIMIT - ngx_pagesize)) {
limit = NGX_SENDFILE_LIMIT - ngx_pagesize;
}
send = 0;
header.elts = headers;
header.size = sizeof(struct iovec);
header.nalloc = NGX_HEADERS;
header.pool = c->pool;
for ( ;; ) {
file = NULL;
file_size = 0;
eintr = 0;
complete = 0;
prev_send = send;
header.nelts = 0;
prev = NULL;
iov = NULL;
/* create the iovec and coalesce the neighbouring bufs */
for (cl = in;
cl && header.nelts < IOV_MAX && send < limit;
cl = cl->next)
{
if (ngx_buf_special(cl->buf)) {
continue;
}
#if 1
if (!ngx_buf_in_memory(cl->buf) && !cl->buf->in_file) {
ngx_log_error(NGX_LOG_ALERT, c->log, 0,
"zero size buf in sendfile "
"t:%d r:%d f:%d %p %p-%p %p %O-%O",
cl->buf->temporary,
cl->buf->recycled,
cl->buf->in_file,
cl->buf->start,
cl->buf->pos,
cl->buf->last,
cl->buf->file,
cl->buf->file_pos,
cl->buf->file_last);
ngx_debug_point();
return NGX_CHAIN_ERROR;
}
#endif
if (!ngx_buf_in_memory_only(cl->buf)) {
break;
}
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
iov->iov_len += (size_t) size;
} else {
iov = ngx_array_push(&header);
if (iov == NULL) {
return NGX_CHAIN_ERROR;
}
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
send += size;
}
/* set TCP_CORK if there is a header before a file */
if (c->tcp_nopush == NGX_TCP_NOPUSH_UNSET
&& header.nelts != 0
&& cl
&& cl->buf->in_file)
{
/* the TCP_CORK and TCP_NODELAY are mutually exclusive */
if (c->tcp_nodelay == NGX_TCP_NODELAY_SET) {
tcp_nodelay = 0;
if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY,
(const void *) &tcp_nodelay, sizeof(int)) == -1)
{
err = ngx_errno;
/*
* there is a tiny chance to be interrupted, however,
* we continue a processing with the TCP_NODELAY
* and without the TCP_CORK
*/
if (err != NGX_EINTR) {
wev->error = 1;
ngx_connection_error(c, err,
"setsockopt(TCP_NODELAY) failed");
return NGX_CHAIN_ERROR;
}
} else {
c->tcp_nodelay = NGX_TCP_NODELAY_UNSET;
ngx_log_debug0(NGX_LOG_DEBUG_HTTP, c->log, 0,
"no tcp_nodelay");
}
}
if (c->tcp_nodelay == NGX_TCP_NODELAY_UNSET) {
if (ngx_tcp_nopush(c->fd) == NGX_ERROR) {
err = ngx_errno;
/*
* there is a tiny chance to be interrupted, however,
* we continue a processing without the TCP_CORK
*/
if (err != NGX_EINTR) {
wev->error = 1;
ngx_connection_error(c, err,
ngx_tcp_nopush_n " failed");
return NGX_CHAIN_ERROR;
}
} else {
c->tcp_nopush = NGX_TCP_NOPUSH_SET;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
"tcp_nopush");
}
}
}
/* get the file buf */
if (header.nelts == 0 && cl && cl->buf->in_file && send < limit) {
file = cl->buf;
/* coalesce the neighbouring file bufs */
do {
size = cl->buf->file_last - cl->buf->file_pos;
if (send + size > limit) {
size = limit - send;
aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
& ~((off_t) ngx_pagesize - 1);
if (aligned <= cl->buf->file_last) {
size = aligned - cl->buf->file_pos;
}
}
file_size += (size_t) size;
send += size;
fprev = cl->buf->file_pos + size;
cl = cl->next;
} while (cl
&& cl->buf->in_file
&& send < limit
&& file->file->fd == cl->buf->file->fd
&& fprev == cl->buf->file_pos);
}
if (file) {
#if 1
if (file_size == 0) {
ngx_debug_point();
return NGX_CHAIN_ERROR;
}
#endif
#if (NGX_HAVE_SENDFILE64)
offset = file->file_pos;
#else
offset = (int32_t) file->file_pos;
#endif
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: @%O %uz", file->file_pos, file_size);
rc = sendfile(c->fd, file->file->fd, &offset, file_size);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
ngx_connection_error(c, err, "sendfile() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfile() is not ready");
}
sent = rc > 0 ? rc : 0;
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: %d, @%O %O:%uz",
rc, file->file_pos, sent, file_size);
} else {
rc = writev(c->fd, header.elts, header.nelts);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
ngx_connection_error(c, err, "writev() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"writev() not ready");
}
sent = rc > 0 ? rc : 0;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "writev: %O", sent);
}
if (send - prev_send == sent) {
complete = 1;
}
c->sent += sent;
for (cl = in; cl; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (sent == 0) {
break;
}
size = ngx_buf_size(cl->buf);
if (sent >= size) {
sent -= size;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos = cl->buf->last;
}
if (cl->buf->in_file) {
cl->buf->file_pos = cl->buf->file_last;
}
continue;
}
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos += (size_t) sent;
}
if (cl->buf->in_file) {
cl->buf->file_pos += sent;
}
break;
}
if (eintr) {
continue;
}
if (!complete) {
wev->ready = 0;
return cl;
}
if (send >= limit || cl == NULL) {
return cl;
}
in = cl;
}
}
ngx_chain_t *
ngx_solaris_sendfilev_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int fd;
u_char *prev;
off_t size, send, prev_send, aligned, fprev;
size_t sent;
ssize_t n;
ngx_int_t eintr;
ngx_err_t err;
ngx_uint_t nsfv;
sendfilevec_t *sfv, sfvs[NGX_SENDFILEVECS];
ngx_event_t *wev;
ngx_chain_t *cl;
wev = c->write;
if (!wev->ready) {
return in;
}
if (!c->sendfile) {
return ngx_writev_chain(c, in, limit);
}
/* the maximum limit size is the maximum size_t value - the page size */
if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
}
send = 0;
for ( ;; ) {
fd = SFV_FD_SELF;
prev = NULL;
fprev = 0;
sfv = NULL;
eintr = 0;
sent = 0;
prev_send = send;
nsfv = 0;
/* create the sendfilevec and coalesce the neighbouring bufs */
for (cl = in; cl && send < limit; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (ngx_buf_in_memory_only(cl->buf)) {
fd = SFV_FD_SELF;
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
sfv->sfv_len += (size_t) size;
} else {
if (nsfv == NGX_SENDFILEVECS) {
break;
}
sfv = &sfvs[nsfv++];
sfv->sfv_fd = SFV_FD_SELF;
sfv->sfv_flag = 0;
sfv->sfv_off = (off_t) (uintptr_t) cl->buf->pos;
sfv->sfv_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
send += size;
} else {
prev = NULL;
size = cl->buf->file_last - cl->buf->file_pos;
if (send + size > limit) {
size = limit - send;
aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
& ~((off_t) ngx_pagesize - 1);
if (aligned <= cl->buf->file_last) {
size = aligned - cl->buf->file_pos;
}
}
if (fd == cl->buf->file->fd && fprev == cl->buf->file_pos) {
sfv->sfv_len += (size_t) size;
} else {
if (nsfv == NGX_SENDFILEVECS) {
break;
}
sfv = &sfvs[nsfv++];
fd = cl->buf->file->fd;
sfv->sfv_fd = fd;
sfv->sfv_flag = 0;
sfv->sfv_off = cl->buf->file_pos;
sfv->sfv_len = (size_t) size;
}
fprev = cl->buf->file_pos + size;
send += size;
}
}
n = sendfilev(c->fd, sfvs, nsfv, &sent);
if (n == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
ngx_connection_error(c, err, "sendfilev() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfilev() sent only %uz bytes", sent);
}
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfilev: %z %z", n, sent);
c->sent += sent;
in = ngx_chain_update_sent(in, sent);
if (eintr) {
send = prev_send + sent;
continue;
}
if (send - prev_send != (off_t) sent) {
wev->ready = 0;
return in;
}
if (send >= limit || in == NULL) {
return in;
}
}
}
bool memoryonly() const
{
return ngx_buf_in_memory_only(get());
}
ngx_chain_t *
ngx_transmitpackets_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int rc;
u_char *prev;
off_t size, send, aligned, sent, fprev;
ngx_fd_t fd;
ngx_err_t err;
ngx_array_t vec;
ngx_event_t *wev;
ngx_chain_t *cl;
WSAOVERLAPPED *ovlp;
TRANSMIT_PACKETS_ELEMENT *tpe, tpes[NGX_IOVS];
if (!c->sendfile || !(ngx_event_flags & NGX_USE_IOCP_EVENT)) {
return ngx_writev_chain(c, in, limit);
}
wev = c->write;
if (wev->closed) {
return NULL;
}
if (wev->error) {
return NGX_CHAIN_ERROR;
}
sent = wev->available;
if (wev->ready && sent > 0) {
wev->available = 0;
c->sent += sent;
for (cl = in; cl; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (sent == 0) {
break;
}
size = ngx_buf_size(cl->buf);
if (sent >= size) {
sent -= size;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos = cl->buf->last;
}
if (cl->buf->in_file) {
cl->buf->file_pos = cl->buf->file_last;
}
continue;
}
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos += sent;
}
if (cl->buf->in_file) {
cl->buf->file_pos += sent;
}
break;
}
return cl;
}
/* the maximum limit size is the maximum size_t value - the page size */
if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
limit = NGX_MAX_SIZE_T_VALUE - (off_t) ngx_pagesize;
}
send = 0;
vec.nelts = 0;
vec.elts = tpes;
vec.size = sizeof(TRANSMIT_PACKETS_ELEMENT);
vec.nalloc = NGX_IOVS;
vec.pool = c->pool;
/*
* create the TRANSMIT_PACKETS_ELEMENT and
* coalesce the neighbouring bufs
*/
fd = INVALID_HANDLE_VALUE;
prev = NULL;
fprev = 0;
for (cl = in; cl && vec.nelts < NGX_IOVS && send < limit;
cl = cl->next)
{
if (ngx_buf_special(cl->buf)) {
continue;
}
if (ngx_buf_in_memory_only(cl->buf)) {
fd = INVALID_HANDLE_VALUE;
fprev = 0;
size = (off_t) (cl->buf->last - cl->buf->pos);
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
tpe->cLength += (ULONG) size;
} else {
tpe = ngx_array_push(&vec);
if (tpe == NULL) {
return NGX_CHAIN_ERROR;
}
tpe->dwElFlags = TP_ELEMENT_MEMORY;
tpe->pBuffer = cl->buf->pos;
tpe->cLength = (ULONG) size;
}
prev = cl->buf->pos + size;
} else {
prev = NULL;
size = cl->buf->file_last - cl->buf->file_pos;
if (send + size > limit) {
size = limit - send;
aligned = ngx_align(cl->buf->file_pos + size,
(off_t) ngx_pagesize);
if (aligned <= cl->buf->file_last) {
size = aligned - cl->buf->file_pos;
}
}
if (fd == cl->buf->file->fd && fprev == cl->buf->file_pos) {
tpe->cLength += (ULONG) size;
} else {
tpe = ngx_array_push(&vec);
if (tpe == NULL) {
return NGX_CHAIN_ERROR;
}
/*
* caching performance is improved by opening this handle
* with FILE_FLAG_SEQUENTIAL_SCAN
*/
fd = cl->buf->file->fd;
tpe->dwElFlags = TP_ELEMENT_FILE;
tpe->hFile = fd;
tpe->nFileOffset.QuadPart = cl->buf->file_pos;
tpe->cLength = (ULONG) size;
}
fprev = cl->buf->file_pos + size;
}
send += size;
}
wev->ovlp.event = wev;
ovlp = (WSAOVERLAPPED *) &wev->ovlp;
ngx_memzero(ovlp, sizeof(WSAOVERLAPPED));
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
"TransmitPackets: %O", send);
/*
* nSendSize and dwFlags parameter of TransmitPackets
*
* Set nSendSize to zero to let the sockets layer select a default
* send size. But when using the TP_ELEMENT_EOP flag in the
* TRANSMIT_PACKETS_ELEMENT, You should setting nSendSize to 0xFFFFFFF.
*
* dwFlags:
* TP_DISCONNECT、TP_REUSE_SOCKET、TP_USE_DEFAULT_WORKER、
* TP_USE_SYSTEM_THREAD、TP_USE_KERNEL_APC.
*/
rc = ngx_transmit_packets(c->fd, vec.elts, (DWORD) vec.nelts, 0, ovlp, 0);
err = ngx_socket_errno;
if (rc != 0) {
wev->ready = 0;
return in;
}
if (err == ERROR_IO_PENDING) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"TransmitPackets() not ready");
wev->ready = 0;
return in;
}
ngx_connection_error(c, err, "TransmitPackets() failed");
wev->error = 1;
return NGX_CHAIN_ERROR;
}
ngx_chain_t *
ngx_transmit_buffer(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int rc;
off_t size, send;
u_char *prev;
WSABUF *buf, bufs[NGX_IOVS];
ssize_t n;
ngx_err_t err;
ngx_array_t vec;
ngx_chain_t *cl;
ngx_event_t *wev;
WSAOVERLAPPED *ovlp;
wev = c->write;
if (wev->closed) {
return NULL;
}
if (wev->error) {
return NGX_CHAIN_ERROR;
}
retry:
vec.nelts = 0;
vec.elts = bufs;
vec.size = sizeof(WSABUF);
vec.nalloc = NGX_IOVS;
vec.pool = c->pool;
if (ngx_event_flags & NGX_USE_IOCP_EVENT && !wev->ovlp.posted_zero_byte) {
ovlp = (WSAOVERLAPPED *) &wev->ovlp;
/* overlapped io */
buf = ngx_array_push(&vec);
if (buf == NULL) {
return NGX_CHAIN_ERROR;
}
buf->buf = NULL;
buf->len = 0;
} else {
ovlp = NULL;
/* non-blocking io */
/* the maximum limit size is the maximum size_t value - the page size */
if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize))
{
limit = NGX_MAX_SIZE_T_VALUE - (off_t) ngx_pagesize;
}
/* create the WSABUF and coalesce the neighbouring bufs */
prev = NULL;
buf = NULL;
send = 0;
for (cl = in; cl && vec.nelts < NGX_IOVS && send < limit; cl = cl->next)
{
if (ngx_buf_special(cl->buf)) {
continue;
}
if (!ngx_buf_in_memory_only(cl->buf)) {
break;
}
size = (off_t) (cl->buf->last - cl->buf->pos);
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
buf->len += (ULONG) size;
} else {
buf = ngx_array_push(&vec);
if (buf == NULL) {
return NGX_CHAIN_ERROR;
}
buf->buf = (CHAR *) cl->buf->pos;
buf->len = (ULONG) size;
}
send += size;
prev = cl->buf->pos + size;
}
}
n = 0;
rc = WSASend(c->fd, vec.elts, (DWORD) vec.nelts, (DWORD *) &n, 0, ovlp,
NULL);
err = ngx_socket_errno;
if (rc == 0) {
if (ovlp != NULL) {
wev->ovlp.posted_zero_byte = 1;
wev->ready = 0;
return in;
}
#if 0
if (n < send) {
wev->ready = 0;
}
#endif
c->sent += (off_t) n;
for (cl = in; cl; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (n == 0) {
break;
}
size = (off_t) (cl->buf->last - cl->buf->pos);
if (n >= size) {
n -= (ssize_t) size;
cl->buf->pos = cl->buf->last;
continue;
}
cl->buf->pos += n;
break;
}
wev->ovlp.posted_zero_byte = 0;
return ngx_transmitpackets_chain(c, cl, limit);
}
if (err == WSA_IO_PENDING) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err, "WSASend() not ready");
wev->ovlp.posted_zero_byte = 1;
wev->ready = 0;
return in;
}
if (err == WSAEWOULDBLOCK) {
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err, "WSASend() not ready");
if ((ngx_event_flags & NGX_USE_IOCP_EVENT) == 0) {
wev->ready = 0;
return in;
}
/* post another overlapped-io WSASend() */
wev->ovlp.posted_zero_byte = 0;
goto retry;
}
ngx_connection_error(c, err, "WSASend() failed");
wev->ready = 0;
wev->error = 1;
return NGX_CHAIN_ERROR;
}
ngx_chain_t *
ngx_darwin_sendfile_chain(ngx_connection_t *c, ngx_chain_t *in, off_t limit)
{
int rc;
u_char *prev;
off_t size, send, prev_send, aligned, sent, fprev;
off_t header_size, file_size;
ngx_uint_t eintr, complete;
ngx_err_t err;
ngx_buf_t *file;
ngx_array_t header, trailer;
ngx_event_t *wev;
ngx_chain_t *cl;
struct sf_hdtr hdtr;
struct iovec *iov, headers[NGX_HEADERS], trailers[NGX_TRAILERS];
wev = c->write;
if (!wev->ready) {
return in;
}
#if (NGX_HAVE_KQUEUE)
if ((ngx_event_flags & NGX_USE_KQUEUE_EVENT) && wev->pending_eof) {
(void) ngx_connection_error(c, wev->kq_errno,
"kevent() reported about an closed connection");
wev->error = 1;
return NGX_CHAIN_ERROR;
}
#endif
/* the maximum limit size is the maximum size_t value - the page size */
if (limit == 0 || limit > (off_t) (NGX_MAX_SIZE_T_VALUE - ngx_pagesize)) {
limit = NGX_MAX_SIZE_T_VALUE - ngx_pagesize;
}
send = 0;
header.elts = headers;
header.size = sizeof(struct iovec);
header.nalloc = NGX_HEADERS;
header.pool = c->pool;
trailer.elts = trailers;
trailer.size = sizeof(struct iovec);
trailer.nalloc = NGX_TRAILERS;
trailer.pool = c->pool;
for ( ;; ) {
file = NULL;
file_size = 0;
header_size = 0;
eintr = 0;
complete = 0;
prev_send = send;
header.nelts = 0;
trailer.nelts = 0;
/* create the header iovec and coalesce the neighbouring bufs */
prev = NULL;
iov = NULL;
for (cl = in;
cl && header.nelts < IOV_MAX && send < limit;
cl = cl->next)
{
if (ngx_buf_special(cl->buf)) {
continue;
}
if (!ngx_buf_in_memory_only(cl->buf)) {
break;
}
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
iov->iov_len += (size_t) size;
} else {
iov = ngx_array_push(&header);
if (iov == NULL) {
return NGX_CHAIN_ERROR;
}
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
header_size += size;
send += size;
}
if (cl && cl->buf->in_file && send < limit) {
file = cl->buf;
/* coalesce the neighbouring file bufs */
do {
size = cl->buf->file_last - cl->buf->file_pos;
if (send + size > limit) {
size = limit - send;
aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
& ~((off_t) ngx_pagesize - 1);
if (aligned <= cl->buf->file_last) {
size = aligned - cl->buf->file_pos;
}
}
file_size += size;
send += size;
fprev = cl->buf->file_pos + size;
cl = cl->next;
} while (cl
&& cl->buf->in_file
&& send < limit
&& file->file->fd == cl->buf->file->fd
&& fprev == cl->buf->file_pos);
}
if (file && header.nelts == 0) {
/* create the tailer iovec and coalesce the neighbouring bufs */
prev = NULL;
iov = NULL;
while (cl && header.nelts < IOV_MAX && send < limit) {
if (ngx_buf_special(cl->buf)) {
cl = cl->next;
continue;
}
if (!ngx_buf_in_memory_only(cl->buf)) {
break;
}
size = cl->buf->last - cl->buf->pos;
if (send + size > limit) {
size = limit - send;
}
if (prev == cl->buf->pos) {
iov->iov_len += (size_t) size;
} else {
iov = ngx_array_push(&trailer);
if (iov == NULL) {
return NGX_CHAIN_ERROR;
}
iov->iov_base = (void *) cl->buf->pos;
iov->iov_len = (size_t) size;
}
prev = cl->buf->pos + (size_t) size;
send += size;
cl = cl->next;
}
}
if (file) {
/*
* sendfile() returns EINVAL if sf_hdtr's count is 0,
* but corresponding pointer is not NULL
*/
hdtr.headers = header.nelts ? (struct iovec *) header.elts: NULL;
hdtr.hdr_cnt = header.nelts;
hdtr.trailers = trailer.nelts ? (struct iovec *) trailer.elts: NULL;
hdtr.trl_cnt = trailer.nelts;
sent = header_size + file_size;
ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: @%O %O h:%O",
file->file_pos, sent, header_size);
rc = sendfile(file->file->fd, c->fd, file->file_pos,
&sent, &hdtr, 0);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
(void) ngx_connection_error(c, err, "sendfile() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, err,
"sendfile() sent only %O bytes", sent);
}
if (rc == 0 && sent == 0) {
/*
* if rc and sent equal to zero, then someone
* has truncated the file, so the offset became beyond
* the end of the file
*/
ngx_log_error(NGX_LOG_ALERT, c->log, 0,
"sendfile() reported that \"%s\" was truncated",
file->file->name.data);
return NGX_CHAIN_ERROR;
}
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, c->log, 0,
"sendfile: %d, @%O %O:%O",
rc, file->file_pos, sent, file_size + header_size);
} else {
rc = writev(c->fd, header.elts, header.nelts);
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
"writev: %d of %uz", rc, send);
if (rc == -1) {
err = ngx_errno;
switch (err) {
case NGX_EAGAIN:
break;
case NGX_EINTR:
eintr = 1;
break;
default:
wev->error = 1;
ngx_connection_error(c, err, "writev() failed");
return NGX_CHAIN_ERROR;
}
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
"writev() not ready");
}
sent = rc > 0 ? rc : 0;
}
if (send - prev_send == sent) {
complete = 1;
}
c->sent += sent;
for (cl = in; cl; cl = cl->next) {
if (ngx_buf_special(cl->buf)) {
continue;
}
if (sent == 0) {
break;
}
size = ngx_buf_size(cl->buf);
if (sent >= size) {
sent -= size;
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos = cl->buf->last;
}
if (cl->buf->in_file) {
cl->buf->file_pos = cl->buf->file_last;
}
continue;
}
if (ngx_buf_in_memory(cl->buf)) {
cl->buf->pos += (size_t) sent;
}
if (cl->buf->in_file) {
cl->buf->file_pos += sent;
}
break;
}
if (eintr) {
continue;
}
if (!complete) {
wev->ready = 0;
return cl;
}
if (send >= limit || cl == NULL) {
return cl;
}
in = cl;
}
}
