sql_fetch(int cursorn, char *bf, int colen[], int *tcolen, int *descn)
{
REQ rq;
FETCH_REQ frq;
RES res;
FETCH_REP rep;
int rn,i;
rq.req=htonl(NET_FETCH);
rq.len=htonl(sizeof(FETCH_REQ));
netwrite(&rq,sizeof(rq));
frq.cursorn=htonl(cursorn);
netwrite(&frq,sizeof(frq));
netread(&res,sizeof(res));
res.res=ntohl(res.res);
if (!res.res) {
printf("fetch error %d %s\n", res.res, neterr());
return res.res;
}
netread(&rep,sizeof(rep));
*descn=rep.descn=ntohl(rep.descn);
*tcolen=rep.tcolen=ntohl(rep.tcolen);
netread(colen,sizeof(int)*rep.descn);
for(i=0;i<rep.descn;i++)
colen[i]=ntohl(colen[i]);
rn=netread(bf,rep.tcolen);
}
char *neterr()
{
static char tt[4096];
int errlen;
netread(&errlen,4);
netread(tt,errlen);
return tt;
}
blocking_pipe_header *
receive_blocking_req_internal(
blocking_child * c
)
{
blocking_pipe_header hdr;
blocking_pipe_header * req;
int rc;
long octets;
DEBUG_REQUIRE(-1 != c->req_read_pipe);
req = NULL;
do {
rc = netread(c->req_read_pipe, &hdr, sizeof(hdr));
} while (rc < 0 && EINTR == errno);
if (rc < 0) {
msyslog(LOG_ERR,
"receive_blocking_req_internal: pipe read %m");
} else if (0 == rc) {
TRACE(4, ("parent closed request pipe, child %d terminating\n",
c->pid));
} else if (rc != sizeof(hdr)) {
msyslog(LOG_ERR,
"receive_blocking_req_internal: short header read %d of %lu",
rc, (u_long)sizeof(hdr));
} else {
INSIST(sizeof(hdr) < hdr.octets && hdr.octets < 4 * 1024);
req = emalloc(hdr.octets);
memcpy(req, &hdr, sizeof(*req));
octets = hdr.octets - sizeof(hdr);
rc = netread(c->req_read_pipe, (char *)req + sizeof(*req),
octets);
if (rc < 0)
msyslog(LOG_ERR,
"receive_blocking_req_internal: pipe data read %m");
else if (rc != octets)
msyslog(LOG_ERR,
"receive_blocking_req_internal: short read %d of %ld",
rc, octets);
else if (BLOCKING_REQ_MAGIC != req->magic_sig)
msyslog(LOG_ERR,
"receive_blocking_req_internal: packet header mismatch (0x%x)",
req->magic_sig);
else
return req;
}
if (req != NULL)
free(req);
return NULL;
}
blocking_pipe_header *
receive_blocking_resp_internal(
blocking_child * c
)
{
blocking_pipe_header hdr;
blocking_pipe_header * resp;
int rc;
long octets;
DEBUG_REQUIRE(c->resp_read_pipe != -1);
resp = NULL;
rc = netread(c->resp_read_pipe, &hdr, sizeof(hdr));
if (rc < 0) {
TRACE(1, ("receive_blocking_resp_internal: pipe read %m\n"));
} else if (0 == rc) {
/* this is the normal child exited indication */
} else if (rc != sizeof(hdr)) {
TRACE(1, ("receive_blocking_resp_internal: short header read %d of %lu\n",
rc, (u_long)sizeof(hdr)));
} else if (BLOCKING_RESP_MAGIC != hdr.magic_sig) {
TRACE(1, ("receive_blocking_resp_internal: header mismatch (0x%x)\n",
hdr.magic_sig));
} else {
INSIST(sizeof(hdr) < hdr.octets &&
hdr.octets < 16 * 1024);
resp = emalloc(hdr.octets);
memcpy(resp, &hdr, sizeof(*resp));
octets = hdr.octets - sizeof(hdr);
rc = netread(c->resp_read_pipe,
(char *)resp + sizeof(*resp),
octets);
if (rc < 0)
TRACE(1, ("receive_blocking_resp_internal: pipe data read %m\n"));
else if (rc < octets)
TRACE(1, ("receive_blocking_resp_internal: short read %d of %ld\n",
rc, octets));
else
return resp;
}
cleanup_after_child(c);
if (resp != NULL)
free(resp);
return NULL;
}
int TimeoutRead(int fd, char *pcBuf, int iBufLen, int iTimeout_InMinSec)
{
struct timeval tv;
fd_set fdsRead;
FD_ZERO(&fdsRead);
FD_SET(fd, &fdsRead);
tv.tv_sec = iTimeout_InMinSec / 1000;
tv.tv_usec = (iTimeout_InMinSec - tv.tv_sec * 1000) * 1000;
//printf("&fdsRead:%x\n",&fdsRead);
#ifndef WLAN
if (netselect(fd+1, &fdsRead, NULL, NULL, &tv,g_Host_Buf ,HOST_BUFFER_LEN ) >= 0)
#else
if (select(fd+1, &fdsRead, NULL, NULL, &tv ) > 0)
#endif
{
if (FD_ISSET(fd, &fdsRead))
{
int rt;
//printf("&rt:%x\n",&rt);
#ifndef WLAN
rt = netread(fd, pcBuf, iBufLen,g_Host_Buf ,HOST_BUFFER_LEN );
#else
rt = read(fd, pcBuf, iBufLen);
#endif
//printf("iBufLen:%d,rt:%d\n",iBufLen,rt);
return rt;
}
}
return -1;
}
static int kftp_get_response(knetFile *ftp)
{
#ifndef _WIN32
unsigned char c;
#else
char c;
#endif
int n = 0;
char *p;
if (socket_wait(ftp->ctrl_fd, 1) <= 0) return 0;
while (netread(ftp->ctrl_fd, &c, 1)) { // FIXME: this is *VERY BAD* for unbuffered I/O
//fputc(c, stderr);
if (n >= ftp->max_response) {
ftp->max_response = ftp->max_response? ftp->max_response<<1 : 256;
ftp->response = (char*)realloc(ftp->response, ftp->max_response);
}
ftp->response[n++] = c;
if (c == '\n') {
if (n >= 4 && isdigit(ftp->response[0]) && isdigit(ftp->response[1]) && isdigit(ftp->response[2])
&& ftp->response[3] != '-') break;
n = 0;
continue;
}
}
if (n < 2) return -1;
ftp->response[n-2] = 0;
return strtol(ftp->response, &p, 0);
}
void * netPoller(void * data)
{
int size, t;
char buf[4096];
while(1){
if (netread){
size = netread(netfd, buf, 4096);
if (size==0) continue;
if (size<0){
perror("netread");
/* FIXME: network closed? */
break;
}
}else {
setPNG(1);
usleep(10000);
continue;
}
if (size<0) break;
t=Hik_PlayM4_InputData(0, buf, size);
while (t<0){
if (Hik_PlayM4_GetLastErrorCode()==M4PErr_BufOverflow) {
usleep(10000);
t=Hik_PlayM4_InputData(0, buf, size);
} else {
size=0;
break;
}
}
}
}
/*
* Ftp_Read - read from a data connection
*/
int Ftp_Read(void *buf, int max, netbuf *nData)
{
if (nData->dir != FTP_READ)
return 0;
if (nData->buf)
return readline(buf, max, nData);
return netread(nData->handle, buf, max, 0);
}
sql_prepare(char *s, int *cursorn, int *descn)
{
REQ rq;
RES res;
PREPARE_REP rep;
int len=strlen(s)+1;
rq.req=htonl(NET_PREPARE);
rq.len=htonl(len);
netwrite(&rq,sizeof(rq));
netwrite(s,strlen(s)+1);
netread(&res,sizeof(res));
res.res=ntohl(res.res);
if (!res.res) printf("prepare error %s", neterr());
netread(&rep,sizeof(rep));
*cursorn=ntohl(rep.cursorn);
*descn=ntohl(rep.descn);
}
int khttp_connect_file(knetFile *fp)
{
int ret, l = 0;
char *buf, *p;
if (fp->fd != -1) netclose(fp->fd);
fp->fd = socket_connect(fp->host, fp->port);
buf = (char*)calloc(0x10000, 1); // FIXME: I am lazy... But in principle, 64KB should be large enough.
l += sprintf(buf + l, "GET %s HTTP/1.0\r\nHost: %s\r\n", fp->path, fp->http_host);
l += sprintf(buf + l, "Range: bytes=%lld-\r\n", (long long)fp->offset);
l += sprintf(buf + l, "\r\n");
if ( netwrite(fp->fd, buf, l) != l ) { free(buf); return -1; }
l = 0;
while (netread(fp->fd, buf + l, 1)) { // read HTTP header; FIXME: bad efficiency
if (buf[l] == '\n' && l >= 3)
if (strncmp(buf + l - 3, "\r\n\r\n", 4) == 0) break;
++l;
}
buf[l] = 0;
if (l < 14) { // prematured header
free(buf);
netclose(fp->fd);
fp->fd = -1;
return -1;
}
ret = strtol(buf + 8, &p, 0); // HTTP return code
if (ret == 200 && fp->offset>0) { // 200 (complete result); then skip beginning of the file
off_t rest = fp->offset;
while (rest) {
off_t l = rest < 0x10000? rest : 0x10000;
rest -= my_netread(fp->fd, buf, l);
}
} else if (ret != 206 && ret != 200) {
// failed to open file
free(buf);
netclose(fp->fd);
switch (ret) {
case 401: errno = EPERM; break;
case 403: errno = EACCES; break;
case 404: errno = ENOENT; break;
case 407: errno = EPERM; break;
case 408: errno = ETIMEDOUT; break;
case 410: errno = ENOENT; break;
case 503: errno = EAGAIN; break;
case 504: errno = ETIMEDOUT; break;
default: errno = (ret >= 400 && ret < 500)? EINVAL : EIO; break;
}
fp->fd = -1;
return -1;
}
free(buf);
fp->is_ready = 1;
return 0;
}
int khttp_connect_file(knetFile *fp)
{
int ret, l = 0;
char *buf, *p;
ssize_t byteswritten;
if (fp->fd != -1) netclose(fp->fd);
fp->fd = socket_connect(fp->host, fp->port);
buf = calloc(0x10000, 1); /* FIXME: I am lazy... But in principle, 64KB should be large enough. */
l += sprintf(buf + l, "GET %s HTTP/1.0\r\nHost: %s\r\n", fp->path, fp->http_host);
l += sprintf(buf + l, "Range: bytes=%" PRId64 "-\r\n", fp->offset);
l += sprintf(buf + l, "\r\n");
byteswritten = netwrite(fp->fd, buf, l); /* @ubw fixed unused result warning */
if( 0 >= byteswritten ) /* do sth with the result */
{
PRINT_ERROR( "[khttp_connect_file] no (%d) bytes written in GET request!\n", byteswritten);
/* return -1; */ /* cppcheck : [dev/src/tabix/knetfile.c:440]: (error) Memory leak: buf ||| free(buf) the buf=calloc() from line 432 ! */
free( buf );
return -1;
}
l = 0;
while (netread(fp->fd, buf + l, 1)) { /* read HTTP header; FIXME: bad efficiency */
if (buf[l] == '\n' && l >= 3)
if (strncmp(buf + l - 3, "\r\n\r\n", 4) == 0) break;
++l;
}
buf[l] = 0;
if (l < 14) { /* prematured header */
netclose(fp->fd);
fp->fd = -1;
return -1;
}
ret = strtol(buf + 8, &p, 0); /* HTTP return code */
if (ret == 200 && fp->offset>0) { /* 200 (complete result); then skip beginning of the file */
off_t rest = fp->offset;
while (rest) {
off_t l = rest < 0x10000? rest : 0x10000;
rest -= my_netread(fp->fd, buf, l);
}
} else if (ret != 206 && ret != 200) {
free(buf);
PRINT_ERROR( "[khttp_connect_file] fail to open file (HTTP code: %d).\n", ret);
netclose(fp->fd);
fp->fd = -1;
return -1;
}
free(buf);
fp->is_ready = 1;
return 0;
}
select_db(char *s)
{
REQ rq;
RES res;
init_tcp();
rq.req=htonl(NET_CONNECTDB);
rq.len=htonl(strlen(s)+1);
netwrite(&rq,sizeof(rq));
netwrite(s,strlen(s)+1);
netread(&res,sizeof(res));
res.res=ntohl(res.res);
if (!res.res) printf("error:%s %s\n", neterr());
return res.res;
}
static off_t my_netread(int fd, void *buf, off_t len)
{
off_t rest = len, curr, l = 0;
/* recv() and read() may not read the required length of data with
* one call. They have to be called repeatedly. */
while (rest) {
if (socket_wait(fd, 1) <= 0) break; // socket is not ready for reading
curr = netread(fd, (void*)((char*)buf + l), rest);
/* According to the glibc manual, section 13.2, a zero returned
* value indicates end-of-file (EOF), which should mean that
* read() will not return zero if EOF has not been met but data
* are not immediately available. */
if (curr == 0) break;
l += curr; rest -= curr;
}
return l;
}
int khttp_connect_file(knetFile *fp)
{
int ret, l = 0;
char *buf, *p;
if (fp->fd != -1) netclose(fp->fd);
fp->fd = socket_connect(fp->host, fp->port);
buf = (char*)calloc(0x10000, 1); // FIXME: I am lazy... But in principle, 64KB should be large enough.
l += sprintf(buf + l, "GET %s HTTP/1.0\r\nHost: %s\r\n", fp->path, fp->http_host);
l += sprintf(buf + l, "Range: bytes=%lld-\r\n", (long long)fp->offset);
l += sprintf(buf + l, "\r\n");
if(netwrite(fp->fd, buf, l) != l)
{
}
l = 0;
while (netread(fp->fd, buf + l, 1)) { // read HTTP header; FIXME: bad efficiency
if (buf[l] == '\n' && l >= 3)
if (strncmp(buf + l - 3, "\r\n\r\n", 4) == 0) break;
++l;
}
buf[l] = 0;
if (l < 14) { // prematured header
netclose(fp->fd);
fp->fd = -1;
return -1;
}
ret = strtol(buf + 8, &p, 0); // HTTP return code
if (ret == 200 && fp->offset>0) { // 200 (complete result); then skip beginning of the file
off_t rest = fp->offset;
while (rest) {
off_t l = rest < 0x10000? rest : 0x10000;
rest -= my_netread(fp->fd, buf, l);
}
} else if (ret != 206 && ret != 200) {
free(buf);
if(!knetsilent)
{
fprintf(stderr, "[khttp_connect_file] fail to open file (HTTP code: %d).\n", ret);
}
netclose(fp->fd);
fp->fd = -1;
return -1;
}
free(buf);
fp->is_ready = 1;
return 0;
}
int main()
{
unsigned int pos;
char header[12];
char qtype[2];
char qclass[2];
const char *x;
droproot(FATAL);
dns_random_init(seed);
axfr = env_get("AXFR");
x = env_get("TCPREMOTEIP");
if (x && ip6_scan(x,ip))
;
else
byte_zero(ip,16);
x = env_get("TCPREMOTEPORT");
if (!x) x = "0";
scan_ulong(x,&port);
for (;;) {
netread(tcpheader,2);
uint16_unpack_big(tcpheader,&len);
if (len > 512) strerr_die2x(111,FATAL,"excessively large request");
netread(buf,len);
pos = dns_packet_copy(buf,len,0,header,12); if (!pos) die_truncated();
if (header[2] & 254) strerr_die2x(111,FATAL,"bogus query");
if (header[4] || (header[5] != 1)) strerr_die2x(111,FATAL,"bogus query");
pos = dns_packet_getname(buf,len,pos,&zone); if (!pos) die_truncated();
zonelen = dns_domain_length(zone);
pos = dns_packet_copy(buf,len,pos,qtype,2); if (!pos) die_truncated();
pos = dns_packet_copy(buf,len,pos,qclass,2); if (!pos) die_truncated();
if (byte_diff(qclass,2,DNS_C_IN) && byte_diff(qclass,2,DNS_C_ANY))
strerr_die2x(111,FATAL,"bogus query: bad class");
pos = check_edns0(header, buf, len, pos);
if (!pos) die_truncated();
qlog(ip,port,header,zone,qtype," ");
if (byte_equal(qtype,2,DNS_T_AXFR)) {
case_lowerb(zone,zonelen);
fdcdb = open_read("data.cdb");
if (fdcdb == -1) die_cdbread();
doaxfr(header);
close(fdcdb);
}
else {
if (!response_query(zone,qtype,qclass)) nomem();
response[2] |= 4;
case_lowerb(zone,zonelen);
response_id(header);
response[3] &= ~128;
if (!(header[2] & 1)) response[2] &= ~1;
if (!respond(zone,qtype,ip)) die_outside();
print(response,response_len);
}
}
}
void simple_tcpserver(cyg_addrword_t pnetdata)
{
int s, new_s, i, len;
char *msg;
struct sockaddr_in sa, r_sa;
int r_sa_l = sizeof(r_sa);
struct hostent *hp;
struct sockaddr_in peername;
int socklen;
int threadid;
int localcount = 0;
int port = ((NET_DATA_T*)pnetdata)->iport;
char *pbuf = ((NET_DATA_T*)pnetdata)->pbuf;
//s = ((NET_DATA_T*)pnetdata)->fd;
threadid = cyg_thread_self();
msg = malloc(BUFSIZE);
if(msg == NULL)
{
printf("simple_tcpserver(%d): malloc error\n", threadid);
cyg_thread_exit();
}
printf("simple_tcpserver(%d): to gethostbyname\n", threadid);
if((hp = gethostbyname(TEST_REMOTEFUNC_HOSTNAME, pbuf, RNT_BUFFER_LEN)) == NULL)
{
printf("simple_tcpserver(%d): gethostbyname error!!!!!!\n", threadid);
cyg_thread_exit();
}
printf("simple_tcpserver(%d): gethostbyname ok\n", threadid);
//memcpy(&(r_sa.sin_addr), hp->h_addr_list0, hp->h_length);
r_sa.sin_addr.s_addr = inet_addr("10.132.11.10", pbuf, RNT_BUFFER_LEN);
printf("simple_tcpserver(%d): final addr=%s\n", threadid, inet_ntoa(r_sa.sin_addr, pbuf, RNT_BUFFER_LEN));
r_sa.sin_family = AF_INET;
r_sa.sin_port = htons(IPPORT_USERRESERVED + port);
printf("simple_tcpserver(%d): receive from port %d\n", threadid, ntohs(r_sa.sin_port));
if((s = socket(AF_INET, SOCK_STREAM, PF_UNSPEC, pbuf, RNT_BUFFER_LEN)) == -1)
{
printf("simple_tcpserver(%d): socket error!!!!!!\n", threadid);
cyg_thread_exit();
}
printf("simple_tcpserver(%d): create socket success...\n", threadid);
printf("simple_tcpserver(%d): socket=%d\n", threadid, s);
/* Test for netfcntl & setsockopt */
/*
{
int sock_opt = 1;
// server socket is nonblocking
if (netfcntl(s, F_SETFL, O_NONBLOCK, pbuf, RNT_BUFFER_LEN) == -1)
{
printf("netfcntl error\n");
netclose(s, pbuf, RNT_BUFFER_LEN);
return -1;
}
if ((setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (void *) &sock_opt,
sizeof(sock_opt), pbuf, RNT_BUFFER_LEN)) == -1)
{
printf("setsockopt error\n");
netclose(s, pbuf, RNT_BUFFER_LEN);
return -1;
}
}
*/
if(bind(s, (struct sockaddr*)&r_sa, sizeof(r_sa), pbuf, RNT_BUFFER_LEN) == -1)
{
printf("simple_tcpserver(%d): bind error!!!!!!\n", threadid);
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
printf("simple_tcpserver(%d): bind success...\n", threadid);
/*
{
struct sockaddr_in sockname;
int socklen;
if(getsockname(s, (struct sockaddr*)&sockname, &socklen, pbuf, RNT_BUFFER_LEN) != -1)
{
printf("simple_tcpserver(%d): getsockname:sin_family=%d sin_port=%d sin_addr=%s socklen=%d\n", threadid,
sockname.sin_family, sockname.sin_port, inet_ntoa(sockname.sin_addr, pbuf, RNT_BUFFER_LEN), socklen);
}
else
{
printf("simple_tcpserver(%d): getsockname error\n", threadid);
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
}
*/
if(listen(s, 10, pbuf, RNT_BUFFER_LEN) == -1)
{
printf("simple_tcpserver(%d): listen error\n", threadid);
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
printf("simple_tcpserver(%d): listen success...\n", threadid);
while(1)
{
if((new_s = accept(s, (struct sockaddr*)&sa, (size_t*)&r_sa_l, pbuf, RNT_BUFFER_LEN)) == -1)
{
printf("simple_tcpserver(%d): accept error\n", threadid);
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
printf("simple_tcpserver(%d): accept success...\n", threadid);
{
int val, vallen;
vallen = sizeof(val);
if(getsockopt(new_s, SOL_SOCKET, SO_RCVBUF, &val, &vallen, pbuf, RNT_BUFFER_LEN) < 0)
{
printf("get rcvbuf size error!!!!!!\n");
}
printf("recv window size = %d\n", val);
vallen = sizeof(val);
if(getsockopt(new_s, SOL_SOCKET, SO_SNDBUF, &val, &vallen, pbuf, RNT_BUFFER_LEN) < 0)
{
printf("get sndbuf size error!!!!!!\n");
}
printf("send window size = %d\n", val);
vallen = sizeof(val);
val = 50000;
if(setsockopt(new_s, SOL_SOCKET, SO_RCVBUF, &val, vallen, pbuf, RNT_BUFFER_LEN) < 0)
{
printf("set rcvbuf size error!!!!!!\n");
}
if(setsockopt(new_s, SOL_SOCKET, SO_SNDBUF, &val, vallen, pbuf, RNT_BUFFER_LEN) < 0)
{
printf("set sndbuf size error!!!!!!\n");
}
vallen = sizeof(val);
if(getsockopt(new_s, SOL_SOCKET, SO_RCVBUF, &val, &vallen, pbuf, RNT_BUFFER_LEN) < 0)
{
printf("get rcvbuf size error!!!!!!\n");
}
printf("new recv window size = %d\n", val);
vallen = sizeof(val);
if(getsockopt(new_s, SOL_SOCKET, SO_SNDBUF, &val, &vallen, pbuf, RNT_BUFFER_LEN) < 0)
{
printf("get sndbuf size error!!!!!!\n");
}
printf("new send window size = %d\n", val);
}
/*
{
if(getpeername(new_s, (struct sockaddr*)&peername, &socklen, pbuf, RNT_BUFFER_LEN) != -1)
{
printf("simple_tcpserver(%d): getpeername:sin_family=%d sin_port=%d sin_addr=%s socklen=%d\n", threadid,
peername.sin_family, peername.sin_port, inet_ntoa(peername.sin_addr, pbuf, RNT_BUFFER_LEN), socklen);
}
else
{
printf("simple_tcpserver(%d): getpeername error\n", threadid);
netclose(new_s, pbuf, RNT_BUFFER_LEN);
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
}
*/
i = 0;
while(1)
{
/* Test recvmsg & sendmsg method */
/*
{
struct msghdr msghdr_msg;
struct iovec *piov;
int j, n, copylen;
int perIov_len;
perIov_len = BUFSIZE/4;
piov = malloc(4*sizeof(struct iovec));
for(j = 0; j < 4; j++)
{
piov[j].iov_base = malloc(perIov_len);
piov[j].iov_len = perIov_len;
}
msghdr_msg.msg_name = NULL;
msghdr_msg.msg_namelen = 0;
msghdr_msg.msg_iov = piov;
msghdr_msg.msg_iovlen = 4;
msghdr_msg.msg_control = NULL;
msghdr_msg.msg_controllen = 0;
msghdr_msg.msg_flags = 0;
if((len = recvmsg(new_s, &msghdr_msg, 0, pbuf, RNT_BUFFER_LEN)) == -1)
{
printf("simple_tcpserver(%d): recvmsg error\n", threadid);
break;
}
if(len == 0)
{
printf("simple_tcpserver(%d): recvmsg 0, connection broken!!!!!\n", threadid);
break;
}
n = 0;
for(j = 0; j < 4; j++)
{
//printf("simple_tcpserver(%d): recvmsg piov[%d].iovlen=%d\n", threadid, j, piov[j].iov_len);
copylen = piov[j].iov_len < (len - n) ? piov[j].iov_len : (len - n);
memcpy(&msg[n], piov[j].iov_base, copylen);
n += copylen;
if(n >= len) break;
}
msg[len] = '\0';
//printf("simple_tcpserver(%d): recvmsg: %s\n", threadid, msg);
len = 17408;
memcpy(msg, g_LargeData, len);
//len = sprintf(msg, "ack%d", i);
n = 0;
for(j = 0; j < 4; j++)
{
copylen = piov[j].iov_len < (len - n) ? piov[j].iov_len : (len - n);
memcpy(piov[j].iov_base, &msg[n], copylen);
piov[j].iov_len = copylen;
//printf("simple_tcpserver(%d): sendmsg piov[%d].iov_len=%d\n", threadid, j, piov[j].iov_len);
n += copylen;
if(n >= len) break;
}
j++;
for(; j < 4; j++) piov[j].iov_len = 0;
if((len = sendmsg(new_s, &msghdr_msg, 0, pbuf, RNT_BUFFER_LEN)) == -1)
{
printf("simple_tcpserver(%d): sendmsg error\n", threadid);
break;
}
if(len == 0)
{
printf("simple_tcpserver(%d): sendmsg 0, connection broken!!!!!\n", threadid);
break;
}
for(j = 0; j < 4; j++)
{
free(piov[j].iov_base);
}
free(piov);
i++;
}
*/
/* Test recv & send method and fdset operation */
/*
{
fd_set readset, exceptset;
int maxfd;
int written_bytes;
int bytes_left;
int reconnect;
FD_ZERO(&readset);
FD_SET(new_s, &readset);
FD_ZERO(&exceptset);
FD_SET(new_s, &exceptset);
maxfd = new_s + 1;
if(netselect(maxfd, &readset, NULL, &exceptset, NULL, pbuf, RNT_BUFFER_LEN) == -1)
{
printf("simple_tcpserver(%d): netselect error\n", threadid);
continue;
}
if(FD_ISSET(new_s, &readset))
{
//printf("simple_tcpserver(%d): readset get\n", threadid);
}
else if(FD_ISSET(new_s, &exceptset))
{
printf("simple_tcpserver(%d): exceptset get\n", threadid);
break;
}
if((len = recv(new_s, msg, BUFSIZE, 0, pbuf, RNT_BUFFER_LEN)) == -1)
{
printf("simple_tcpserver(%d): recv error\n", threadid);
break;
}
if(len == 0)
{
printf("simple_tcpserver(%d): recv 0, connection broken!!!!!\n", threadid);
break;
}
//printf("simple_tcpserver(%d): recv: %s\n", threadid, msg);
//len = sprintf(msg, "ack%d", i);
len = 40000;
memcpy(msg, g_LargeData, len);
bytes_left = len;
reconnect = 0;
while(bytes_left > 0)
{
written_bytes = send(new_s, msg+(len-bytes_left), bytes_left, 0, pbuf, RNT_BUFFER_LEN);
if(written_bytes <= 0)
{
if(errno == EINTR)
{
written_bytes = 0;
}
else
{
printf("simple_tcpserver(%d): netwrite error, reconnect!!!!!\n", threadid);
reconnect = 1;
break;
}
}
bytes_left -= written_bytes;
}
if(reconnect == 1) break;
i++;
}
*/
/* Test for netread & netwrite method */
{
int written_bytes;
int bytes_left;
int reconnect;
if((len = netread(new_s, msg, BUFSIZE, pbuf, RNT_BUFFER_LEN)) == -1)
{
printf("simple_tcpserver(%d): netread error %d\n", threadid, errno);
break;
}
if(len == 0)
{
printf("simple_tcpserver(%d): netread 0, connection broken, errno=%d!!!!!\n", threadid, errno);
break;
}
msg[len] = '\0';
//printf("simple_tcpserver(%d): len %d, netread %s\n", threadid, len, msg);
//printf("simple_tcpserver(%d): len %d\n", threadid, len);
//len = sprintf(msg, "ack%d", i);
len = 40000;
memcpy(msg, g_LargeData, len);
bytes_left = len;
reconnect = 0;
while(bytes_left > 0)
{
written_bytes = netwrite(new_s, msg+(len-bytes_left), bytes_left, pbuf, RNT_BUFFER_LEN);
if(written_bytes <= 0)
{
printf("errno=%d\n", errno);
if(errno == EINTR)
{
written_bytes = 0;
}
else
{
printf("simple_tcpserver(%d): netwrite error, reconnect!!!!!\n", threadid);
reconnect = 1;
break;
}
}
//printf("simple_tcpserver(%d): write %d\n", threadid, written_bytes);
bytes_left -= written_bytes;
if(bytes_left > 0)
{
printf("write %d < %d left %d\n", written_bytes, bytes_left+written_bytes, bytes_left);
}
}
if(reconnect == 1) break;
i++;
}
totallen += len;
icount++;
if((icount>=2000) && (icount%2000==0))
{
tend = cyg_current_time();
printf("rate=%d rate1=%03fk\n", (int)(icount/((tend-tbegin)/100)), (float)(totallen/((tend-tbegin)/100)/1024));
}
localcount++;
if(localcount > 100 && localcount % 100 == 0)
{
printf("simple_tcpserver: %d\n", port);
}
}
printf("simple_tcpserver(%d): to close %d with 0x%x\n", threadid, new_s, pbuf);
netclose(new_s, pbuf, RNT_BUFFER_LEN);
printf("simple_tcpserver(%d): close connection ok\n", threadid);
}
netclose(s, pbuf, RNT_BUFFER_LEN);
free(msg);
cyg_thread_exit();
}
int
main (int argc, char *argv[])
{
int n = 0;
time_t t = 0;
struct sigaction sa;
char qtype[2];
char qclass[2];
char header[12];
const char *x = NULL;
unsigned int pos = 0;
unsigned long long qnum = 0;
sa.sa_handler = handle_term;
sigaction (SIGINT, &sa, NULL);
sigaction (SIGTERM, &sa, NULL);
sa.sa_handler = SIG_IGN;
sigaction (SIGPIPE, &sa, NULL);
prog = strdup ((x = strrchr (argv[0], '/')) != NULL ? x + 1 : argv[0]);
n = check_option (argc, argv);
argc -= n;
argv += n;
if (mode & DAEMON)
/* redirect stderr to a log file */
redirect_to_log (logfile, STDERR_FILENO);
time (&t);
memset (seed, 0, sizeof (seed));
strftime (seed, sizeof (seed), "%b-%d %Y %T %Z", localtime (&t));
warnx ("version %s: starting %s\n", VERSION, seed);
set_timezone ();
if (debug_level)
warnx ("TIMEZONE: %s", env_get ("TZ"));
read_conf (cfgfile);
if (!debug_level)
if ((x = env_get ("DEBUG_LEVEL")))
debug_level = atol (x);
warnx ("DEBUG_LEVEL set to `%d'", debug_level);
dns_random_init (seed);
axfr = env_get ("AXFR");
if (debug_level)
warnx ("AXFR set to `%s'", axfr);
x = env_get ("TCPREMOTEIP");
if (debug_level)
warnx ("TCPREMOTEIP set to `%s'", x);
if (x)
ip4_scan (x, ip);
else
byte_zero (ip, 4);
x = env_get ("TCPREMOTEPORT");
if (debug_level)
warnx ("TCPREMOTEPORT set to `%s'", x);
if (!x)
x = "0";
scan_ulong (x, &port);
droproot ();
for (;;)
{
netread (tcpheader, 2);
uint16_unpack_big (tcpheader, &len);
if (len > 512)
errx (-1, "excessively large request");
netread (buf, len);
pos = dns_packet_copy (buf, len, 0, header, 12);
if (!pos)
errx (-1, "truncated request");
if (header[2] & 254)
errx (-1, "bogus query");
if (header[4] || (header[5] != 1))
errx (-1, "bogus query");
pos = dns_packet_getname (buf, len, pos, &zone);
if (!pos)
errx (-1, "truncated request");
zonelen = dns_domain_length (zone);
pos = dns_packet_copy (buf, len, pos, qtype, 2);
if (!pos)
errx (-1, "truncated request");
pos = dns_packet_copy (buf, len, pos, qclass, 2);
if (!pos)
errx (-1, "truncated request");
if (byte_diff(qclass, 2, DNS_C_IN) && byte_diff(qclass, 2, DNS_C_ANY))
errx (-1, "bogus query: bad class");
log_query (++qnum, ip, port, header, zone, qtype);
if (byte_equal(qtype,2,DNS_T_AXFR))
{
case_lowerb (zone, zonelen);
fdcdb = open_read ("data.cdb");
if (fdcdb == -1)
errx (-1, "could not read from file `data.cdb'");
doaxfr (header);
close (fdcdb);
}
else
{
if (!response_query (zone, qtype, qclass))
err (-1, "could not allocate enough memory");
response[2] |= 4;
case_lowerb (zone, zonelen);
response_id (header);
response[3] &= ~128;
if (!(header[2] & 1))
response[2] &= ~1;
if (!respond (zone, qtype, ip))
errx (-1, "could not find information in file `data.cdb'");
print (response, response_len);
}
}
}
void test_tcp_socket_client(cyg_addrword_t pnetdata)
{
int s, i, len;
char msg;
struct sockaddr_in sa, r_sa;
struct hostent *hp;
int threadid;
int port = ((TEST_TCP_SOCKET_DATA_T*)pnetdata)->iport;
char *pbuf = ((TEST_TCP_SOCKET_DATA_T*)pnetdata)->pbuf;
threadid = cyg_thread_self();
if((hp = gethostbyname(TEST_REMOTEFUNC_HOSTNAME, pbuf, RNT_BUFFER_LEN)) == NULL)
{
test_printf_error("test_tcp_socket_client");
cyg_thread_exit();
}
memcpy(&(r_sa.sin_addr), hp->h_addr_list0, hp->h_length);
r_sa.sin_family = AF_INET;
r_sa.sin_port = htons(IPPORT_USERRESERVED + port);
memcpy(&(sa.sin_addr), hp->h_addr_list0, hp->h_length);
sa.sin_family = AF_INET;
sa.sin_port = htons(IPPORT_USERRESERVED + port - TEST_TCP_SOCKET_SERVER_NUM);
for(i = 0; i < TEST_TCP_ACCEPT_SOCKET_TIMES; i++)
{
if((s = socket(AF_INET, SOCK_STREAM, PF_UNSPEC, pbuf, RNT_BUFFER_LEN)) == -1)
{
test_printf_error("test_tcp_socket_client");
cyg_thread_exit();
}
if(set_reuseaddr(s, pbuf, RNT_BUFFER_LEN) == -1)
{
test_printf_error("test_tcp_socket_client");
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
if(bind(s, (struct sockaddr*)&r_sa, sizeof(r_sa), pbuf, RNT_BUFFER_LEN) == -1)
{
test_printf_error("test_tcp_socket_client");
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
while(connect(s, (struct sockaddr*)&sa, sizeof(sa), pbuf, RNT_BUFFER_LEN) == -1) NULL;
if((len = netread(s, &msg, sizeof(msg), pbuf, RNT_BUFFER_LEN)) == -1)
{
test_printf_error("test_tcp_socket_client");
break;
}
if(len == 0)
{
netclose(s, pbuf, RNT_BUFFER_LEN);
continue;
}
}
test_printf_success("test_tcp_socket_client");
cyg_thread_exit();
}
void test_netselect_server(cyg_addrword_t pnetdata)
{
int s, new_s, readlen;
struct sockaddr_in sa, r_sa;
int r_sa_l = sizeof(r_sa);
struct hostent *hp;
int ierr = 0;
fd_set readset;
int threadid;
int port = ((TEST_NETSELECT_DATA_T*)pnetdata)->iport;
char *pbuf = ((TEST_NETSELECT_DATA_T*)pnetdata)->pbuf;
char *preadbuf = ((TEST_NETSELECT_DATA_T*)pnetdata)->pnetselectbuf;
threadid = cyg_thread_self();
if((hp = gethostbyname(TEST_REMOTEFUNC_HOSTNAME, pbuf, RNT_BUFFER_LEN)) == NULL)
{
test_printf_error("test_netselect_server");
cyg_thread_exit();
}
memcpy(&(r_sa.sin_addr), hp->h_addr_list0, hp->h_length);
r_sa.sin_family = AF_INET;
r_sa.sin_port = htons(IPPORT_USERRESERVED + port);
if((s = socket(AF_INET, SOCK_STREAM, PF_UNSPEC, pbuf, RNT_BUFFER_LEN)) == -1)
{
test_printf_error("test_netselect_server");
cyg_thread_exit();
}
if(set_reuseaddr(s, pbuf, RNT_BUFFER_LEN) == -1)
{
test_printf_error("test_netselect_server");
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
if(bind(s, (struct sockaddr*)&r_sa, sizeof(r_sa), pbuf, RNT_BUFFER_LEN) == -1)
{
test_printf_error("test_netselect_server");
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
if(listen(s, 10, pbuf, RNT_BUFFER_LEN) == -1)
{
test_printf_error("test_netselect_server");
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
if((new_s = accept(s, (struct sockaddr*)&sa, (size_t*)&r_sa_l, pbuf, RNT_BUFFER_LEN)) == -1)
{
test_printf_error("test_netselect_server");
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
while(1)
{
FD_ZERO(&readset);
FD_SET(new_s, &readset);
if(netselect(new_s + 1, &readset, NULL, NULL, NULL, pbuf, RNT_BUFFER_LEN) == -1)
{
test_printf_error("test_netselect_server");
ierr = 1;
break;
}
if(FD_ISSET(new_s, &readset))
{
readlen = netread(new_s, preadbuf, TEST_NETSELECT_MSG_LEN, pbuf, RNT_BUFFER_LEN);
if(readlen < 0)
{
test_printf_error("test_netselect_server");
ierr = 1;
break;
}
if(readlen == 0)
{
break;
}
if(readlen > 0)
{
if(strcmp(preadbuf, TEST_NETSELECT_MSG) != 0)
{
ierr = 1;
test_printf_error("test_netselect_server");
break;
}
}
}
}
if(ierr == 0)
test_printf_success("test_netselect_server");
netclose(new_s, pbuf, RNT_BUFFER_LEN);
netclose(s, pbuf, RNT_BUFFER_LEN);
cyg_thread_exit();
}
