static int client(apr_pool_t *p, client_socket_mode_t socket_mode,
const char *host, int start_server)
{
apr_status_t rv, tmprv;
apr_socket_t *sock;
char buf[120];
apr_file_t *f = NULL;
apr_size_t len;
apr_size_t expected_len;
apr_off_t current_file_offset;
apr_hdtr_t hdtr;
struct iovec headers[3];
struct iovec trailers[3];
apr_size_t bytes_read;
apr_pollset_t *pset;
apr_int32_t nsocks;
int connect_tries = 1;
int i;
int family;
apr_sockaddr_t *destsa;
apr_proc_t server;
apr_interval_time_t connect_retry_interval = apr_time_from_msec(50);
if (start_server) {
spawn_server(p, &server);
connect_tries = 5; /* give it a chance to start up */
}
create_testfile(p, TESTFILE);
rv = apr_file_open(&f, TESTFILE, APR_FOPEN_READ, 0, p);
if (rv != APR_SUCCESS) {
aprerr("apr_file_open()", rv);
}
if (!host) {
host = "127.0.0.1";
}
family = APR_INET;
rv = apr_sockaddr_info_get(&destsa, host, family, TESTSF_PORT, 0, p);
if (rv != APR_SUCCESS) {
aprerr("apr_sockaddr_info_get()", rv);
}
while (connect_tries--) {
apr_setup(p, &sock, &family);
rv = apr_socket_connect(sock, destsa);
if (connect_tries && APR_STATUS_IS_ECONNREFUSED(rv)) {
apr_status_t tmprv = apr_socket_close(sock);
if (tmprv != APR_SUCCESS) {
aprerr("apr_socket_close()", tmprv);
}
apr_sleep(connect_retry_interval);
connect_retry_interval *= 2;
}
else {
break;
}
}
if (rv != APR_SUCCESS) {
aprerr("apr_socket_connect()", rv);
}
switch(socket_mode) {
case BLK:
/* leave it blocking */
break;
case NONBLK:
/* set it non-blocking */
rv = apr_socket_opt_set(sock, APR_SO_NONBLOCK, 1);
if (rv != APR_SUCCESS) {
aprerr("apr_socket_opt_set(APR_SO_NONBLOCK)", rv);
}
break;
case TIMEOUT:
/* set a timeout */
rv = apr_socket_timeout_set(sock, 100 * APR_USEC_PER_SEC);
if (rv != APR_SUCCESS) {
aprerr("apr_socket_opt_set(APR_SO_NONBLOCK)", rv);
exit(1);
}
break;
default:
assert(1 != 1);
}
printf("Sending the file...\n");
hdtr.headers = headers;
hdtr.numheaders = 3;
hdtr.headers[0].iov_base = HDR1;
hdtr.headers[0].iov_len = strlen(hdtr.headers[0].iov_base);
hdtr.headers[1].iov_base = HDR2;
hdtr.headers[1].iov_len = strlen(hdtr.headers[1].iov_base);
hdtr.headers[2].iov_base = malloc(HDR3_LEN);
assert(hdtr.headers[2].iov_base);
memset(hdtr.headers[2].iov_base, HDR3_CHAR, HDR3_LEN);
hdtr.headers[2].iov_len = HDR3_LEN;
hdtr.trailers = trailers;
hdtr.numtrailers = 3;
hdtr.trailers[0].iov_base = TRL1;
hdtr.trailers[0].iov_len = strlen(hdtr.trailers[0].iov_base);
hdtr.trailers[1].iov_base = TRL2;
hdtr.trailers[1].iov_len = strlen(hdtr.trailers[1].iov_base);
hdtr.trailers[2].iov_base = malloc(TRL3_LEN);
memset(hdtr.trailers[2].iov_base, TRL3_CHAR, TRL3_LEN);
assert(hdtr.trailers[2].iov_base);
hdtr.trailers[2].iov_len = TRL3_LEN;
expected_len =
strlen(HDR1) + strlen(HDR2) + HDR3_LEN +
strlen(TRL1) + strlen(TRL2) + TRL3_LEN +
FILE_LENGTH;
if (socket_mode == BLK) {
current_file_offset = 0;
len = FILE_LENGTH;
rv = apr_socket_sendfile(sock, f, &hdtr, ¤t_file_offset, &len, 0);
if (rv != APR_SUCCESS) {
aprerr("apr_socket_sendfile()", rv);
}
printf("apr_socket_sendfile() updated offset with %ld\n",
(long int)current_file_offset);
printf("apr_socket_sendfile() updated len with %ld\n",
(long int)len);
printf("bytes really sent: %" APR_SIZE_T_FMT "\n",
expected_len);
if (len != expected_len) {
fprintf(stderr, "apr_socket_sendfile() didn't report the correct "
"number of bytes sent!\n");
exit(1);
}
}
else {
/* non-blocking... wooooooo */
apr_size_t total_bytes_sent;
apr_pollfd_t pfd;
pset = NULL;
rv = apr_pollset_create(&pset, 1, p, 0);
assert(!rv);
pfd.p = p;
pfd.desc_type = APR_POLL_SOCKET;
pfd.reqevents = APR_POLLOUT;
pfd.rtnevents = 0;
pfd.desc.s = sock;
pfd.client_data = NULL;
rv = apr_pollset_add(pset, &pfd);
assert(!rv);
total_bytes_sent = 0;
current_file_offset = 0;
len = FILE_LENGTH;
do {
apr_size_t tmplen;
tmplen = len; /* bytes remaining to send from the file */
printf("Calling apr_socket_sendfile()...\n");
printf("Headers (%d):\n", hdtr.numheaders);
for (i = 0; i < hdtr.numheaders; i++) {
printf("\t%ld bytes (%c)\n",
(long)hdtr.headers[i].iov_len,
*(char *)hdtr.headers[i].iov_base);
}
printf("File: %ld bytes from offset %ld\n",
(long)tmplen, (long)current_file_offset);
printf("Trailers (%d):\n", hdtr.numtrailers);
for (i = 0; i < hdtr.numtrailers; i++) {
printf("\t%ld bytes\n",
(long)hdtr.trailers[i].iov_len);
}
rv = apr_socket_sendfile(sock, f, &hdtr, ¤t_file_offset, &tmplen, 0);
printf("apr_socket_sendfile()->%d, sent %ld bytes\n", rv, (long)tmplen);
if (rv) {
if (APR_STATUS_IS_EAGAIN(rv)) {
assert(tmplen == 0);
nsocks = 1;
tmprv = apr_pollset_poll(pset, -1, &nsocks, NULL);
assert(!tmprv);
assert(nsocks == 1);
/* continue; */
}
}
total_bytes_sent += tmplen;
/* Adjust hdtr to compensate for partially-written
* data.
*/
/* First, skip over any header data which might have
* been written.
*/
while (tmplen && hdtr.numheaders) {
if (tmplen >= hdtr.headers[0].iov_len) {
tmplen -= hdtr.headers[0].iov_len;
--hdtr.numheaders;
++hdtr.headers;
}
else {
hdtr.headers[0].iov_len -= tmplen;
hdtr.headers[0].iov_base =
(char*) hdtr.headers[0].iov_base + tmplen;
tmplen = 0;
}
}
/* Now, skip over any file data which might have been
* written.
*/
if (tmplen <= len) {
current_file_offset += tmplen;
len -= tmplen;
tmplen = 0;
}
else {
tmplen -= len;
len = 0;
current_file_offset = 0;
}
/* Last, skip over any trailer data which might have
* been written.
*/
while (tmplen && hdtr.numtrailers) {
if (tmplen >= hdtr.trailers[0].iov_len) {
tmplen -= hdtr.trailers[0].iov_len;
--hdtr.numtrailers;
++hdtr.trailers;
}
else {
hdtr.trailers[0].iov_len -= tmplen;
hdtr.trailers[0].iov_base =
(char *)hdtr.trailers[0].iov_base + tmplen;
tmplen = 0;
}
}
} while (total_bytes_sent < expected_len &&
(rv == APR_SUCCESS ||
(APR_STATUS_IS_EAGAIN(rv) && socket_mode != TIMEOUT)));
if (total_bytes_sent != expected_len) {
fprintf(stderr,
"client problem: sent %ld of %ld bytes\n",
(long)total_bytes_sent, (long)expected_len);
exit(1);
}
if (rv) {
fprintf(stderr,
"client problem: rv %d\n",
rv);
exit(1);
}
}
current_file_offset = 0;
rv = apr_file_seek(f, APR_CUR, ¤t_file_offset);
if (rv != APR_SUCCESS) {
aprerr("apr_file_seek()", rv);
}
printf("After apr_socket_sendfile(), the kernel file pointer is "
"at offset %ld.\n",
(long int)current_file_offset);
rv = apr_socket_shutdown(sock, APR_SHUTDOWN_WRITE);
if (rv != APR_SUCCESS) {
aprerr("apr_socket_shutdown()", rv);
}
/* in case this is the non-blocking test, set socket timeout;
* we're just waiting for EOF */
rv = apr_socket_timeout_set(sock, apr_time_from_sec(3));
if (rv != APR_SUCCESS) {
aprerr("apr_socket_timeout_set()", rv);
}
bytes_read = 1;
rv = apr_socket_recv(sock, buf, &bytes_read);
if (rv != APR_EOF) {
aprerr("apr_socket_recv() (expected APR_EOF)", rv);
}
if (bytes_read != 0) {
fprintf(stderr, "We expected to get 0 bytes read with APR_EOF\n"
"but instead we read %ld bytes.\n",
(long int)bytes_read);
exit(1);
}
printf("client: apr_socket_sendfile() worked as expected!\n");
rv = apr_file_remove(TESTFILE, p);
if (rv != APR_SUCCESS) {
aprerr("apr_file_remove()", rv);
}
if (start_server) {
apr_exit_why_e exitwhy;
apr_size_t nbytes;
char responsebuf[1024];
int exitcode;
rv = apr_file_pipe_timeout_set(server.out, apr_time_from_sec(2));
if (rv != APR_SUCCESS) {
aprerr("apr_file_pipe_timeout_set()", rv);
}
nbytes = sizeof(responsebuf);
rv = apr_file_read(server.out, responsebuf, &nbytes);
if (rv != APR_SUCCESS) {
aprerr("apr_file_read() messages from server", rv);
}
printf("%.*s", (int)nbytes, responsebuf);
rv = apr_proc_wait(&server, &exitcode, &exitwhy, APR_WAIT);
if (rv != APR_CHILD_DONE) {
aprerr("apr_proc_wait() (expected APR_CHILD_DONE)", rv);
}
if (exitcode != 0) {
fprintf(stderr, "sendfile server returned %d\n", exitcode);
exit(1);
}
}
return 0;
}
void status_to_name(lua_State *L, apr_status_t status)
{
/* Use a switch statement for fast number to string mapping: */
switch (status) {
# ifdef APR_ANONYMOUS
case APR_ANONYMOUS:
lua_pushliteral(L, "ANONYMOUS");
return;
# endif
# ifdef APR_BADARG
case APR_BADARG:
lua_pushliteral(L, "BADARG");
return;
# endif
# ifdef APR_BADCH
case APR_BADCH:
lua_pushliteral(L, "BADCH");
return;
# endif
# ifdef APR_DETACH
case APR_DETACH:
lua_pushliteral(L, "DETACH");
return;
# endif
# ifdef APR_EABOVEROOT
case APR_EABOVEROOT:
lua_pushliteral(L, "EABOVEROOT");
return;
# endif
# ifdef APR_EABSOLUTE
case APR_EABSOLUTE:
lua_pushliteral(L, "EABSOLUTE");
return;
# endif
# ifdef APR_EACCES
case APR_EACCES:
lua_pushliteral(L, "EACCES");
return;
# endif
# ifdef APR_EAFNOSUPPORT
case APR_EAFNOSUPPORT:
lua_pushliteral(L, "EAFNOSUPPORT");
return;
# endif
# ifdef APR_EAGAIN
case APR_EAGAIN:
lua_pushliteral(L, "EAGAIN");
return;
# endif
# ifdef APR_EBADDATE
case APR_EBADDATE:
lua_pushliteral(L, "EBADDATE");
return;
# endif
# ifdef APR_EBADF
case APR_EBADF:
lua_pushliteral(L, "EBADF");
return;
# endif
# ifdef APR_EBADIP
case APR_EBADIP:
lua_pushliteral(L, "EBADIP");
return;
# endif
# ifdef APR_EBADMASK
case APR_EBADMASK:
lua_pushliteral(L, "EBADMASK");
return;
# endif
# ifdef APR_EBADPATH
case APR_EBADPATH:
lua_pushliteral(L, "EBADPATH");
return;
# endif
# ifdef APR_EBUSY
case APR_EBUSY:
lua_pushliteral(L, "EBUSY");
return;
# endif
# ifdef APR_ECONNABORTED
case APR_ECONNABORTED:
lua_pushliteral(L, "ECONNABORTED");
return;
# endif
# ifdef APR_ECONNREFUSED
case APR_ECONNREFUSED:
lua_pushliteral(L, "ECONNREFUSED");
return;
# endif
# ifdef APR_ECONNRESET
case APR_ECONNRESET:
lua_pushliteral(L, "ECONNRESET");
return;
# endif
# ifdef APR_EDSOOPEN
case APR_EDSOOPEN:
lua_pushliteral(L, "EDSOOPEN");
return;
# endif
# ifdef APR_EEXIST
case APR_EEXIST:
lua_pushliteral(L, "EEXIST");
return;
# endif
# ifdef APR_EFTYPE
case APR_EFTYPE:
lua_pushliteral(L, "EFTYPE");
return;
# endif
# ifdef APR_EGENERAL
case APR_EGENERAL:
lua_pushliteral(L, "EGENERAL");
return;
# endif
# ifdef APR_EHOSTUNREACH
case APR_EHOSTUNREACH:
lua_pushliteral(L, "EHOSTUNREACH");
return;
# endif
# ifdef APR_EINCOMPLETE
case APR_EINCOMPLETE:
lua_pushliteral(L, "EINCOMPLETE");
return;
# endif
# ifdef APR_EINIT
case APR_EINIT:
lua_pushliteral(L, "EINIT");
return;
# endif
# ifdef APR_EINPROGRESS
case APR_EINPROGRESS:
lua_pushliteral(L, "EINPROGRESS");
return;
# endif
# ifdef APR_EINTR
case APR_EINTR:
lua_pushliteral(L, "EINTR");
return;
# endif
# ifdef APR_EINVAL
case APR_EINVAL:
lua_pushliteral(L, "EINVAL");
return;
# endif
# ifdef APR_EINVALSOCK
case APR_EINVALSOCK:
lua_pushliteral(L, "EINVALSOCK");
return;
# endif
# ifdef APR_EMFILE
case APR_EMFILE:
lua_pushliteral(L, "EMFILE");
return;
# endif
# ifdef APR_EMISMATCH
case APR_EMISMATCH:
lua_pushliteral(L, "EMISMATCH");
return;
# endif
# ifdef APR_ENAMETOOLONG
case APR_ENAMETOOLONG:
lua_pushliteral(L, "ENAMETOOLONG");
return;
# endif
# ifdef APR_ENETUNREACH
case APR_ENETUNREACH:
lua_pushliteral(L, "ENETUNREACH");
return;
# endif
# ifdef APR_ENFILE
case APR_ENFILE:
lua_pushliteral(L, "ENFILE");
return;
# endif
# ifdef APR_ENODIR
case APR_ENODIR:
lua_pushliteral(L, "ENODIR");
return;
# endif
# ifdef APR_ENOENT
case APR_ENOENT:
lua_pushliteral(L, "ENOENT");
return;
# endif
# ifdef APR_ENOLOCK
case APR_ENOLOCK:
lua_pushliteral(L, "ENOLOCK");
return;
# endif
# ifdef APR_ENOMEM
case APR_ENOMEM:
lua_pushliteral(L, "ENOMEM");
return;
# endif
# ifdef APR_ENOPOLL
case APR_ENOPOLL:
lua_pushliteral(L, "ENOPOLL");
return;
# endif
# ifdef APR_ENOPOOL
case APR_ENOPOOL:
lua_pushliteral(L, "ENOPOOL");
return;
# endif
# ifdef APR_ENOPROC
case APR_ENOPROC:
lua_pushliteral(L, "ENOPROC");
return;
# endif
# ifdef APR_ENOSHMAVAIL
case APR_ENOSHMAVAIL:
lua_pushliteral(L, "ENOSHMAVAIL");
return;
# endif
# ifdef APR_ENOSOCKET
case APR_ENOSOCKET:
lua_pushliteral(L, "ENOSOCKET");
return;
# endif
# ifdef APR_ENOSPC
case APR_ENOSPC:
lua_pushliteral(L, "ENOSPC");
return;
# endif
# ifdef APR_ENOSTAT
case APR_ENOSTAT:
lua_pushliteral(L, "ENOSTAT");
return;
# endif
# ifdef APR_ENOTDIR
case APR_ENOTDIR:
lua_pushliteral(L, "ENOTDIR");
return;
# endif
# ifdef APR_ENOTEMPTY
case APR_ENOTEMPTY:
lua_pushliteral(L, "ENOTEMPTY");
return;
# endif
# ifdef APR_ENOTENOUGHENTROPY
case APR_ENOTENOUGHENTROPY:
lua_pushliteral(L, "ENOTENOUGHENTROPY");
return;
# endif
# ifdef APR_ENOTHDKEY
case APR_ENOTHDKEY:
lua_pushliteral(L, "ENOTHDKEY");
return;
# endif
# ifdef APR_ENOTHREAD
case APR_ENOTHREAD:
lua_pushliteral(L, "ENOTHREAD");
return;
# endif
# ifdef APR_ENOTIME
case APR_ENOTIME:
lua_pushliteral(L, "ENOTIME");
return;
# endif
# ifdef APR_ENOTIMPL
case APR_ENOTIMPL:
lua_pushliteral(L, "ENOTIMPL");
return;
# endif
# ifdef APR_ENOTSOCK
case APR_ENOTSOCK:
lua_pushliteral(L, "ENOTSOCK");
return;
# endif
# ifdef APR_EOF
case APR_EOF:
lua_pushliteral(L, "EOF");
return;
# endif
# ifdef APR_EPATHWILD
case APR_EPATHWILD:
lua_pushliteral(L, "EPATHWILD");
return;
# endif
# ifdef APR_EPIPE
case APR_EPIPE:
lua_pushliteral(L, "EPIPE");
return;
# endif
# ifdef APR_EPROC_UNKNOWN
case APR_EPROC_UNKNOWN:
lua_pushliteral(L, "EPROC_UNKNOWN");
return;
# endif
# ifdef APR_ERELATIVE
case APR_ERELATIVE:
lua_pushliteral(L, "ERELATIVE");
return;
# endif
# ifdef APR_ESPIPE
case APR_ESPIPE:
lua_pushliteral(L, "ESPIPE");
return;
# endif
# ifdef APR_ESYMNOTFOUND
case APR_ESYMNOTFOUND:
lua_pushliteral(L, "ESYMNOTFOUND");
return;
# endif
# ifdef APR_ETIMEDOUT
case APR_ETIMEDOUT:
lua_pushliteral(L, "ETIMEDOUT");
return;
# endif
# ifdef APR_EXDEV
case APR_EXDEV:
lua_pushliteral(L, "EXDEV");
return;
# endif
# ifdef APR_FILEBASED
case APR_FILEBASED:
lua_pushliteral(L, "FILEBASED");
return;
# endif
# ifdef APR_INCHILD
case APR_INCHILD:
lua_pushliteral(L, "INCHILD");
return;
# endif
# ifdef APR_INCOMPLETE
case APR_INCOMPLETE:
lua_pushliteral(L, "INCOMPLETE");
return;
# endif
# ifdef APR_INPARENT
case APR_INPARENT:
lua_pushliteral(L, "INPARENT");
return;
# endif
# ifdef APR_KEYBASED
case APR_KEYBASED:
lua_pushliteral(L, "KEYBASED");
return;
# endif
# ifdef APR_NOTDETACH
case APR_NOTDETACH:
lua_pushliteral(L, "NOTDETACH");
return;
# endif
# ifdef APR_NOTFOUND
case APR_NOTFOUND:
lua_pushliteral(L, "NOTFOUND");
return;
# endif
# ifdef APR_SUCCESS
case APR_SUCCESS:
lua_pushliteral(L, "SUCCESS");
return;
# endif
# ifdef APR_TIMEUP
case APR_TIMEUP:
lua_pushliteral(L, "TIMEUP");
return;
# endif
}
/* If the switch statement fails we fall back to the following monstrosity :-) */
if (0) ;
# ifdef APR_STATUS_IS_ANONYMOUS
else if (APR_STATUS_IS_ANONYMOUS(status)) {
lua_pushliteral(L, "ANONYMOUS");
return;
}
# endif
# ifdef APR_STATUS_IS_BADARG
else if (APR_STATUS_IS_BADARG(status)) {
lua_pushliteral(L, "BADARG");
return;
}
# endif
# ifdef APR_STATUS_IS_BADCH
else if (APR_STATUS_IS_BADCH(status)) {
lua_pushliteral(L, "BADCH");
return;
}
# endif
# ifdef APR_STATUS_IS_DETACH
else if (APR_STATUS_IS_DETACH(status)) {
lua_pushliteral(L, "DETACH");
return;
}
# endif
# ifdef APR_STATUS_IS_EABOVEROOT
else if (APR_STATUS_IS_EABOVEROOT(status)) {
lua_pushliteral(L, "EABOVEROOT");
return;
}
# endif
# ifdef APR_STATUS_IS_EABSOLUTE
else if (APR_STATUS_IS_EABSOLUTE(status)) {
lua_pushliteral(L, "EABSOLUTE");
return;
}
# endif
# ifdef APR_STATUS_IS_EACCES
else if (APR_STATUS_IS_EACCES(status)) {
lua_pushliteral(L, "EACCES");
return;
}
# endif
# ifdef APR_STATUS_IS_EAFNOSUPPORT
else if (APR_STATUS_IS_EAFNOSUPPORT(status)) {
lua_pushliteral(L, "EAFNOSUPPORT");
return;
}
# endif
# ifdef APR_STATUS_IS_EAGAIN
else if (APR_STATUS_IS_EAGAIN(status)) {
lua_pushliteral(L, "EAGAIN");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADDATE
else if (APR_STATUS_IS_EBADDATE(status)) {
lua_pushliteral(L, "EBADDATE");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADF
else if (APR_STATUS_IS_EBADF(status)) {
lua_pushliteral(L, "EBADF");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADIP
else if (APR_STATUS_IS_EBADIP(status)) {
lua_pushliteral(L, "EBADIP");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADMASK
else if (APR_STATUS_IS_EBADMASK(status)) {
lua_pushliteral(L, "EBADMASK");
return;
}
# endif
# ifdef APR_STATUS_IS_EBADPATH
else if (APR_STATUS_IS_EBADPATH(status)) {
lua_pushliteral(L, "EBADPATH");
return;
}
# endif
# ifdef APR_STATUS_IS_EBUSY
else if (APR_STATUS_IS_EBUSY(status)) {
lua_pushliteral(L, "EBUSY");
return;
}
# endif
# ifdef APR_STATUS_IS_ECONNABORTED
else if (APR_STATUS_IS_ECONNABORTED(status)) {
lua_pushliteral(L, "ECONNABORTED");
return;
}
# endif
# ifdef APR_STATUS_IS_ECONNREFUSED
else if (APR_STATUS_IS_ECONNREFUSED(status)) {
lua_pushliteral(L, "ECONNREFUSED");
return;
}
# endif
# ifdef APR_STATUS_IS_ECONNRESET
else if (APR_STATUS_IS_ECONNRESET(status)) {
lua_pushliteral(L, "ECONNRESET");
return;
}
# endif
# ifdef APR_STATUS_IS_EDSOOPEN
else if (APR_STATUS_IS_EDSOOPEN(status)) {
lua_pushliteral(L, "EDSOOPEN");
return;
}
# endif
# ifdef APR_STATUS_IS_EEXIST
else if (APR_STATUS_IS_EEXIST(status)) {
lua_pushliteral(L, "EEXIST");
return;
}
# endif
# ifdef APR_STATUS_IS_EFTYPE
else if (APR_STATUS_IS_EFTYPE(status)) {
lua_pushliteral(L, "EFTYPE");
return;
}
# endif
# ifdef APR_STATUS_IS_EGENERAL
else if (APR_STATUS_IS_EGENERAL(status)) {
lua_pushliteral(L, "EGENERAL");
return;
}
# endif
# ifdef APR_STATUS_IS_EHOSTUNREACH
else if (APR_STATUS_IS_EHOSTUNREACH(status)) {
lua_pushliteral(L, "EHOSTUNREACH");
return;
}
# endif
# ifdef APR_STATUS_IS_EINCOMPLETE
else if (APR_STATUS_IS_EINCOMPLETE(status)) {
lua_pushliteral(L, "EINCOMPLETE");
return;
}
# endif
# ifdef APR_STATUS_IS_EINIT
else if (APR_STATUS_IS_EINIT(status)) {
lua_pushliteral(L, "EINIT");
return;
}
# endif
# ifdef APR_STATUS_IS_EINPROGRESS
else if (APR_STATUS_IS_EINPROGRESS(status)) {
lua_pushliteral(L, "EINPROGRESS");
return;
}
# endif
# ifdef APR_STATUS_IS_EINTR
else if (APR_STATUS_IS_EINTR(status)) {
lua_pushliteral(L, "EINTR");
return;
}
# endif
# ifdef APR_STATUS_IS_EINVAL
else if (APR_STATUS_IS_EINVAL(status)) {
lua_pushliteral(L, "EINVAL");
return;
}
# endif
# ifdef APR_STATUS_IS_EINVALSOCK
else if (APR_STATUS_IS_EINVALSOCK(status)) {
lua_pushliteral(L, "EINVALSOCK");
return;
}
# endif
# ifdef APR_STATUS_IS_EMFILE
else if (APR_STATUS_IS_EMFILE(status)) {
lua_pushliteral(L, "EMFILE");
return;
}
# endif
# ifdef APR_STATUS_IS_EMISMATCH
else if (APR_STATUS_IS_EMISMATCH(status)) {
lua_pushliteral(L, "EMISMATCH");
return;
}
# endif
# ifdef APR_STATUS_IS_ENAMETOOLONG
else if (APR_STATUS_IS_ENAMETOOLONG(status)) {
lua_pushliteral(L, "ENAMETOOLONG");
return;
}
# endif
# ifdef APR_STATUS_IS_ENETUNREACH
else if (APR_STATUS_IS_ENETUNREACH(status)) {
lua_pushliteral(L, "ENETUNREACH");
return;
}
# endif
# ifdef APR_STATUS_IS_ENFILE
else if (APR_STATUS_IS_ENFILE(status)) {
lua_pushliteral(L, "ENFILE");
return;
}
# endif
# ifdef APR_STATUS_IS_ENODIR
else if (APR_STATUS_IS_ENODIR(status)) {
lua_pushliteral(L, "ENODIR");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOENT
else if (APR_STATUS_IS_ENOENT(status)) {
lua_pushliteral(L, "ENOENT");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOLOCK
else if (APR_STATUS_IS_ENOLOCK(status)) {
lua_pushliteral(L, "ENOLOCK");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOMEM
else if (APR_STATUS_IS_ENOMEM(status)) {
lua_pushliteral(L, "ENOMEM");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOPOLL
else if (APR_STATUS_IS_ENOPOLL(status)) {
lua_pushliteral(L, "ENOPOLL");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOPOOL
else if (APR_STATUS_IS_ENOPOOL(status)) {
lua_pushliteral(L, "ENOPOOL");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOPROC
else if (APR_STATUS_IS_ENOPROC(status)) {
lua_pushliteral(L, "ENOPROC");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOSHMAVAIL
else if (APR_STATUS_IS_ENOSHMAVAIL(status)) {
lua_pushliteral(L, "ENOSHMAVAIL");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOSOCKET
else if (APR_STATUS_IS_ENOSOCKET(status)) {
lua_pushliteral(L, "ENOSOCKET");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOSPC
else if (APR_STATUS_IS_ENOSPC(status)) {
lua_pushliteral(L, "ENOSPC");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOSTAT
else if (APR_STATUS_IS_ENOSTAT(status)) {
lua_pushliteral(L, "ENOSTAT");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTDIR
else if (APR_STATUS_IS_ENOTDIR(status)) {
lua_pushliteral(L, "ENOTDIR");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTEMPTY
else if (APR_STATUS_IS_ENOTEMPTY(status)) {
lua_pushliteral(L, "ENOTEMPTY");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTENOUGHENTROPY
else if (APR_STATUS_IS_ENOTENOUGHENTROPY(status)) {
lua_pushliteral(L, "ENOTENOUGHENTROPY");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTHDKEY
else if (APR_STATUS_IS_ENOTHDKEY(status)) {
lua_pushliteral(L, "ENOTHDKEY");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTHREAD
else if (APR_STATUS_IS_ENOTHREAD(status)) {
lua_pushliteral(L, "ENOTHREAD");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTIME
else if (APR_STATUS_IS_ENOTIME(status)) {
lua_pushliteral(L, "ENOTIME");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTIMPL
else if (APR_STATUS_IS_ENOTIMPL(status)) {
lua_pushliteral(L, "ENOTIMPL");
return;
}
# endif
# ifdef APR_STATUS_IS_ENOTSOCK
else if (APR_STATUS_IS_ENOTSOCK(status)) {
lua_pushliteral(L, "ENOTSOCK");
return;
}
# endif
# ifdef APR_STATUS_IS_EOF
else if (APR_STATUS_IS_EOF(status)) {
lua_pushliteral(L, "EOF");
return;
}
# endif
# ifdef APR_STATUS_IS_EPATHWILD
else if (APR_STATUS_IS_EPATHWILD(status)) {
lua_pushliteral(L, "EPATHWILD");
return;
}
# endif
# ifdef APR_STATUS_IS_EPIPE
else if (APR_STATUS_IS_EPIPE(status)) {
lua_pushliteral(L, "EPIPE");
return;
}
# endif
# ifdef APR_STATUS_IS_EPROC_UNKNOWN
else if (APR_STATUS_IS_EPROC_UNKNOWN(status)) {
lua_pushliteral(L, "EPROC_UNKNOWN");
return;
}
# endif
# ifdef APR_STATUS_IS_ERELATIVE
else if (APR_STATUS_IS_ERELATIVE(status)) {
lua_pushliteral(L, "ERELATIVE");
return;
}
# endif
# ifdef APR_STATUS_IS_ESPIPE
else if (APR_STATUS_IS_ESPIPE(status)) {
lua_pushliteral(L, "ESPIPE");
return;
}
# endif
# ifdef APR_STATUS_IS_ESYMNOTFOUND
else if (APR_STATUS_IS_ESYMNOTFOUND(status)) {
lua_pushliteral(L, "ESYMNOTFOUND");
return;
}
# endif
# ifdef APR_STATUS_IS_ETIMEDOUT
else if (APR_STATUS_IS_ETIMEDOUT(status)) {
lua_pushliteral(L, "ETIMEDOUT");
return;
}
# endif
# ifdef APR_STATUS_IS_EXDEV
else if (APR_STATUS_IS_EXDEV(status)) {
lua_pushliteral(L, "EXDEV");
return;
}
# endif
# ifdef APR_STATUS_IS_FILEBASED
else if (APR_STATUS_IS_FILEBASED(status)) {
lua_pushliteral(L, "FILEBASED");
return;
}
# endif
# ifdef APR_STATUS_IS_INCHILD
else if (APR_STATUS_IS_INCHILD(status)) {
lua_pushliteral(L, "INCHILD");
return;
}
# endif
# ifdef APR_STATUS_IS_INCOMPLETE
else if (APR_STATUS_IS_INCOMPLETE(status)) {
lua_pushliteral(L, "INCOMPLETE");
return;
}
# endif
# ifdef APR_STATUS_IS_INPARENT
else if (APR_STATUS_IS_INPARENT(status)) {
lua_pushliteral(L, "INPARENT");
return;
}
# endif
# ifdef APR_STATUS_IS_KEYBASED
else if (APR_STATUS_IS_KEYBASED(status)) {
lua_pushliteral(L, "KEYBASED");
return;
}
# endif
# ifdef APR_STATUS_IS_NOTDETACH
else if (APR_STATUS_IS_NOTDETACH(status)) {
lua_pushliteral(L, "NOTDETACH");
return;
}
# endif
# ifdef APR_STATUS_IS_NOTFOUND
else if (APR_STATUS_IS_NOTFOUND(status)) {
lua_pushliteral(L, "NOTFOUND");
return;
}
# endif
# ifdef APR_STATUS_IS_TIMEUP
else if (APR_STATUS_IS_TIMEUP(status)) {
lua_pushliteral(L, "TIMEUP");
return;
}
# endif
lua_pushinteger(L, status);
}
static void im_tcp_read(nx_module_t *module, nx_event_t *event)
{
nx_im_tcp_conf_t *imconf;
nx_logdata_t *logdata;
boolean volatile got_eof = FALSE;
apr_socket_t *sock;
nx_module_input_t *input;
apr_sockaddr_t *sa;
char *ipstr;
apr_status_t rv;
nx_exception_t e;
ASSERT(event != NULL);
ASSERT(module != NULL);
log_debug("im_tcp_read");
if ( nx_module_get_status(module) != NX_MODULE_STATUS_RUNNING )
{
log_debug("module %s not running, not reading any more data", module->name);
return;
}
imconf = (nx_im_tcp_conf_t *) module->config;
sock = (apr_socket_t *) event->data;
ASSERT(imconf->listensock != NULL);
if ( sock == imconf->listensock )
{
im_tcp_accept(module);
return;
}
//else we have data from a client connection
CHECKERR_MSG(apr_socket_data_get((void **) &input, "input", sock),
"couldn't get input data from socket");
ASSERT(input != NULL); // if this is null there is a race/double free in event handling
if ( (rv = nx_module_input_fill_buffer_from_socket(input)) != APR_SUCCESS )
{
if ( APR_STATUS_IS_ECONNREFUSED(rv) ||
APR_STATUS_IS_ECONNABORTED(rv) ||
APR_STATUS_IS_ECONNRESET(rv) ||
APR_STATUS_IS_ETIMEDOUT(rv) ||
APR_STATUS_IS_TIMEUP(rv) ||
APR_STATUS_IS_EHOSTUNREACH(rv) ||
APR_STATUS_IS_ENETUNREACH(rv) ||
APR_STATUS_IS_EOF(rv) )
{
got_eof = TRUE;
}
else if ( APR_STATUS_IS_EAGAIN(rv) )
{
nx_module_add_poll_event(module);
}
else
{
im_tcp_free_input(input);
throw(rv, "Module %s couldn't read from socket", input->module->name);
}
}
try
{
while ( (logdata = input->inputfunc->func(input, input->inputfunc->data)) != NULL )
{
//log_debug("read %d bytes: [%s]", (int) logdata->datalen, logdata->data);
ipstr = nx_module_input_data_get(input, "recv_from_str");
nx_logdata_set_string(logdata, "MessageSourceAddress", ipstr);
nx_module_add_logdata_input(module, input, logdata);
}
}
catch(e)
{
im_tcp_free_input(input);
rethrow_msg(e, "Module %s couldn't read the input", input->module->name);
}
if ( got_eof == TRUE )
{
CHECKERR_MSG(apr_socket_addr_get(&sa, APR_REMOTE, input->desc.s),
"couldn't get info on accepted socket");
CHECKERR_MSG(apr_sockaddr_ip_get(&ipstr, sa),
"couldn't get IP of accepted socket");
log_aprwarn(rv, "TCP connection closed from %s:%u", ipstr, sa->port);
im_tcp_free_input(input);
}
}
