diff --recurs m:\bind494rel/BSD/named-xfer/Makefile m:\bind/BSD/named-xfer/Makefile
1c1
< # $Id: Makefile,v 8.3 1996/01/09 20:23:48 vixie Exp $
---
> # $Id: Makefile,v 8.3 1995/12/31 23:28:01 vixie Exp $
Only in m:\bind494rel: INSTALL
Only in m:\bind: MIRRORS
Only in m:\bind: bind-4.9.3-BETA26.tar.gz
Only in m:\bind: bind-4.9.3-BETA27.tar.gz
Only in m:\bind: bind-4.9.3-BETA29.tar.gz
Only in m:\bind: bind-4.9.3-BETA30.tar.gz
Only in m:\bind: bind-4.9.3-BETA31.tar.gz
Only in m:\bind: bind-4.9.3-BETA32.tar.gz
Only in m:\bind: bind-4.9.3-REL.tar.gz
Only in m:\bind494rel: bind-4.9.4-REL.tar
Only in m:\bind: bind-4.9.4-REL.tar.gz
Only in m:\bind: bind-4.9.4-T3B.tar.gz
Only in m:\bind: bind-4.9.4-T4B.tar.gz
Only in m:\bind: bind-4.9.4-T5B.tar.gz
Only in m:\bind: bs
Only in m:\bind: bs..000170
Only in m:\bind: bs.c
Only in m:\bind: buildallnt.bat
diff --recurs m:\bind494rel/compat/include/sys/cdefs.h m:\bind/compat/include/sys/cdefs.h
100,109c100,111
< #ifndef __GNUC__
< #define	__const				/* delete pseudo-ANSI C keywords */
< #define	__inline
< #define	__signed
< #define	__volatile
< /*
<  * In non-ANSI C environments, new programs will want ANSI-only C keywords
<  * deleted from the program and old programs will want them left alone.
<  * When using a compiler other than gcc, programs using the ANSI C keywords
<  * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
---
> #ifndef WINNT
> #ifndef __GNUC__
> #define	__const				/* delete pseudo-ANSI C keywords */
> #define	__inline
> #define	__signed
> #define	__volatile
> #endif
> /*
>  * In non-ANSI C environments, new programs will want ANSI-only C keywords
>  * deleted from the program and old programs will want them left alone.
>  * When using a compiler other than gcc, programs using the ANSI C keywords
>  * const, inline etc. as normal identifiers should define -DNO_ANSI_KEYWORDS.
113c115
< #ifndef	NO_ANSI_KEYWORDS
---
> #ifndef NO_ANSI_KEYWORDS
118c120
< #endif
---
> #endif /* WINNT */
Only in m:\bind/compat/lib: MSG00001.bin
Only in m:\bind/compat/lib: WinRel
diff --recurs m:\bind494rel/compat/lib/ftruncate.c m:\bind/compat/lib/ftruncate.c
44,53c44,56
< 
< 	/* maybe shorten... */
< 	if (wantsize < cursize) {
< 		struct flock fl;
< 
< 		fl.l_whence = 0;
< 		fl.l_len = 0;
< 		fl.l_start = wantsize;
< 		fl.l_type = F_WRLCK;
< 		return (fcntl(fd, F_FREESP, &fl));
---
> 	/* maybe shorten... */
> 	if (wantsize < cursize) {
> #ifndef WINNT
> 		struct flock fl;
> 
> 		fl.l_whence = 0;
> 		fl.l_len = 0;
> 		fl.l_start = wantsize;
> 		fl.l_type = F_WRLCK;
> 		return (fcntl(fd, F_FREESP, &fl));
> #else
> 		return (lseek(fd, wantsize, 0) && SetEndOfFile((HANDLE)fd));
> #endif
diff --recurs m:\bind494rel/compat/lib/gettimeofday.c m:\bind/compat/lib/gettimeofday.c
15,21c15,22
< 	time_t clock, time __P((time_t *));
< 
< 	if (time(&clock) == (time_t) -1)
< 		return (-1);
< 	if (tvp) {
< 		tvp->tv_sec = clock;
< 		tvp->tv_usec = 0;
---
> #ifndef WINNT
> 	time_t clock, time __P((time_t *));
> 
> 	if (time(&clock) == (time_t) -1)
> 		return (-1);
> 	if (tvp) {
> 		tvp->tv_sec = clock;
> 		tvp->tv_usec = 0;
23,24c24,25
< 	if (tzp) {
< 		tzp->tz_minuteswest = 0;
---
> 	if (tzp) {
> 		tzp->tz_minuteswest = 0;
26a28,33
> #else
> 	struct _timeb timebuffer;
> 	_ftime(&timebuffer);
> 	tvp->tv_sec = (long) timebuffer.time;
> 	tvp->tv_usec = (long) (1000 * (timebuffer.millitm));
> #endif
Only in m:\bind/compat/lib: lib44bsd.mak
Only in m:\bind/compat/lib: lib44bsd.mdp
Only in m:\bind/compat/lib: lib44bsd.ncb
Only in m:\bind/compat/lib: lib44bsd.vcp
Only in m:\bind/compat/lib: lib44bsd95.mak
Only in m:\bind/compat/lib: lib44bsd95.mdp
Only in m:\bind/compat/lib: lib44bsd95.ncb
Only in m:\bind/compat/lib: log.c
Only in m:\bind/compat/lib: log.h
Only in m:\bind/compat/lib: makemc.bat
Only in m:\bind/compat/lib: messages.aps
Only in m:\bind/compat/lib: messages.h
Only in m:\bind/compat/lib: messages.mc
Only in m:\bind/compat/lib: messages.rc
diff --recurs m:\bind494rel/compat/lib/mktemp.c m:\bind/compat/lib/mktemp.c
101,104c101,106
< 	extern int errno;
< 	register char *start, *trv;
< 	struct stat sbuf;
< 	u_int pid;
---
> #ifndef WINNT
> 	extern int errno;
> #endif
> 	register char *start, *trv;
> 	struct stat sbuf;
> 	u_int pid;
106,110c108,112
< 	pid = getpid();
< 	for (trv = path; *trv; ++trv);		/* extra X's get set to 0's */
< 	while (*--trv == 'X') {
< 		*trv = (pid % 10) + '0';
< 		pid /= 10;
---
> 	pid = getpid();
> 	for (trv = path; *trv; ++trv);		/* extra X's get set to 0's */
> 	while (*--trv == 'X') {
> 		*trv = (pid % 10) + '0';
> 		pid /= 10;
124a127
> #ifndef WINNT
125a129,131
> #else
> 				WSASetLastError(ENOTDIR);
> #endif
Only in m:\bind/compat/lib: ntmisc.c
diff --recurs m:\bind494rel/compat/lib/strcasecmp.c m:\bind/compat/lib/strcasecmp.c
61,65c61,67
< #include <sys/param.h>
< #include <sys/types.h>
< #include <sys/cdefs.h>
< #if (!defined(BSD)) || (BSD < 199306)
< #include "../../conf/portability.h"
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/types.h>
> #include <sys/cdefs.h>
> #endif
> #if (!defined(BSD)) || (BSD < 199306)
> #include "../../conf/portability.h"
67,68c69,70
< #include <string.h>
< #endif
---
> #include <string.h>
> #endif
70c72
< #ifndef NEED_STRCASECMP
---
> #ifndef NEED_STRCASECMP
116c118
< 	const char  *s1, *s2;
---
> 	const char *s1, *s2;
diff --recurs m:\bind494rel/compat/lib/strerror.c m:\bind/compat/lib/strerror.c
61c61,63
< #include <sys/param.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #endif
Only in m:\bind/compat/lib: strip.bat
diff --recurs m:\bind494rel/compat/lib/strpbrk.c m:\bind/compat/lib/strpbrk.c
61c61,63
< #include <sys/param.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #endif
diff --recurs m:\bind494rel/compat/lib/strtoul.c m:\bind/compat/lib/strtoul.c
64c64,66
< #include <sys/param.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #endif
diff --recurs m:\bind494rel/compat/lib/writev.c m:\bind/compat/lib/writev.c
9c9,10
<  */
---
>  *  WindowsNT
>  */
11c12
< #if defined(_CRAY)
---
> #if defined(_CRAY)
15,16c16,17
< #include <sys/stat.h>
< #include <sys/socket.h>
---
> #include <sys/stat.h>
> #include <sys/socket.h>
84a86,160
> 
> #ifdef WINNT
> #define OWN_WRITEV
> #define TIMEOUT_SEC 120
> #include <stdarg.h>
> #include "../../conf/portability.h"
> 
> 
> /*
>  * writev --
>  * simplistic writev implementation for WindowsNT using the WriteFile WIN32API.
>  */	
> /* lgk win95 does not support overlapped/async file operations so change it to
>    synchronous */
> #ifndef WIN95
>  
> int
> writev(fd, iov, iovcnt)
> 	int fd;
> 	struct iovec *iov;
> 	int iovcnt;
> {
> 	int i;
> 	char *base;
> 	DWORD BytesWritten, TotalBytesWritten = 0, len, dwWait;
> 	extern HANDLE hReadWriteEvent;
> 	OVERLAPPED overlap;
> 	BOOL ret; 
> 
> 	for (i=0; i<iovcnt; i++) {
> 		base = iov[i].iov_base;
> 		len = (DWORD)iov[i].iov_len;
> 		overlap.Offset = overlap.OffsetHigh = (DWORD)0;
> 		overlap.hEvent = hReadWriteEvent;
> 		ret = WriteFile((HANDLE)fd, (char *)base, len,
> 		              (LPDWORD)&BytesWritten, (LPOVERLAPPED)&overlap);
> 		if ((ret == FALSE) && (errno != ERROR_IO_PENDING)) {
> 				return (-1);
> 		}
> 		dwWait = WaitForSingleObject((HANDLE)hReadWriteEvent, (DWORD)TIMEOUT_SEC * 1000);
> 		if ((dwWait == WAIT_FAILED) || (dwWait == WAIT_TIMEOUT)){
> 			return (-1);
> 		}
> 		TotalBytesWritten += BytesWritten;
> 	}
> 	return((int)TotalBytesWritten);
> }
> 
> #else // is win95 ... no async overlapped io
>  
> int
> writev(fd, iov, iovcnt)
> 	int fd;
> 	struct iovec *iov;
> 	int iovcnt;
> {
> 	int i;
> 	char *base;
> 	DWORD BytesWritten, TotalBytesWritten = 0, len, dwWait;
> 	BOOL ret; 
> 
> 	for (i=0; i<iovcnt; i++) {
> 		base = iov[i].iov_base;
> 		len = (DWORD)iov[i].iov_len;
> 		ret = WriteFile((HANDLE)fd, (char *)base, len,
> 		              (LPDWORD)&BytesWritten, NULL);
> 		if (ret == FALSE)
> 		   return (-1);
> 		TotalBytesWritten += BytesWritten;
> 	}
> 	return((int)TotalBytesWritten);
> }
> 
> #endif // win95 or not
> #endif // winnt
diff --recurs m:\bind494rel/conf/options.h m:\bind/conf/options.h
118c118,120
< #define RENICE  	/* named-xfer should run at normal priority */
---
> #ifndef WINNT
> #define RENICE  	/* named-xfer should run at normal priority */
> #endif
diff --recurs m:\bind494rel/conf/portability.h m:\bind/conf/portability.h
67,71c67,104
< #include <sys/param.h>
< #ifndef TIME_H_INCLUDED
< # include <sys/time.h>
< # define TIME_H_INCLUDED
< #endif
---
> #ifndef WINNT
> #include <sys/param.h>
> #ifndef TIME_H_INCLUDED
> # include <sys/time.h>
> # define TIME_H_INCLUDED
> #endif
> #endif /* WINNT */
> 
> #ifdef WINNT
> #ifndef _PORTABILITY_H
> #define _PORTABILITY_H
> #include <stdio.h>
> #ifdef BUFSIZ
> #undef BUFSIZ
> #endif
> #define BUFSIZ 1024  /* GMS - added since Unix used 1K and NT 512B */
> #include <string.h>
> #include <process.h>
> #include <sys/timeb.h>
> #include <time.h>
> #include <io.h>
> #include <stdlib.h>
> #define FD_SETSIZE 512
> #include <winsock.h>
> #include <windows.h>
> 
> #define NOWAIT
> #define HAVE_SETVBUF
> #define NEED_GETTIMEOFDAY
> #define USE_MEMCPY
> #undef IP_OPTIONS
> #define PATH_MAX MAX_PATH
> #define ETIMEDOUT WSAETIMEDOUT
> #define ECONNRESET WSAECONNRESET
> #define ECONNREFUSED WSAECONNREFUSED
> #define EADDRINUSE WSAEADDRINUSE
> #define PORT_WOULDBLK WSAEWOULDBLOCK
> #define _TIMEZONE timezoneBSD
73,74c106,159
< #ifdef ISC
< # ifndef _POSIX_SOURCE
---
> struct timezoneBSD {
> 	int tz_minuteswest;
> 	int tz_dsttime;
> };
> struct iovec {
> 	char *  iov_base;
> 	int 	iov_len;
> };
> typedef char *	caddr_t;
> typedef long pid_t;
> #define sleep(t) Sleep(t*1000)
> #ifdef errno
> #undef errno
> #endif
> #define errno WSAGetLastError()
> /* #define close(s) closesocket(s) */
> #define chdir(path) SetCurrentDirectory(path)
> #define dup2(s1, s2) DuplicateHandle(GetCurrentProcess(), (HANDLE)(s1), \
> 					GetCurrentProcess(), (LPHANDLE)&(s2), \
> 					0, FALSE, DUPLICATE_SAME_ACCESS);
> #define strcasecmp(x, y) stricmp(x, y)
> #define strncasecmp(x, y, z) strnicmp(x, y, z)
> 
> void  	service_main(DWORD, LPTSTR *);
> void  	service_ctrl(DWORD);
> void    worker_thread(void *);
> void syslog(int, char *, ...);
> void expand_paths(void);
> int writev(int, struct iovec *, int);
> int mkstemp(char *);
> 
> #define MAXALIASES 35
> #define LOG_EMERG       0       /* system is unusable */
> #define LOG_ALERT       1       /* action must be taken immediately */
> #define LOG_CRIT        2       /* critical conditions */
> #define LOG_ERR         3       /* error conditions */
> #define LOG_WARNING     4       /* warning conditions */
> #define LOG_NOTICE      5       /* normal but signification condition */
> #define LOG_INFO        6       /* informational */
> #define LOG_DEBUG       7       /* debug-level messages */
> /* control codes that the service will accept */
> #define SERVICE_CONTROL_DUMPDB  128
> #define SERVICE_CONTROL_RELOAD  129
> #define SERVICE_CONTROL_STATS   130
> #define SERVICE_CONTROL_TRACE   131
> #define SERVICE_CONTROL_NOTRACE 132
> #define SERVICE_CONTROL_QRYLOG  133
> #define SERVICE_CONTROL_CHKPT   134
> #define SERVICE_CONTROL_EXIT    135
> #endif /* _PORTABILITY_H */
> #endif /* WINNT */
> 
> #ifdef ISC
> # ifndef _POSIX_SOURCE
189c274
< # if !defined(NeXT)
---
> # if !defined(NeXT)	&& !defined(WINNT)
256c341
< # ifndef NeXT
---
> # if !defined(NeXT) && !defined(WINNT)
260a346
> #ifndef WINNT
261a348
> #endif
263c350
< # if !defined(DMALLOC) && !defined(NeXT)
---
> # if !defined(DMALLOC) && !defined(NeXT) && !defined(WINNT)
309c396
< #if !defined(__STDC__) && !defined(const)
---
> #if !defined(__STDC__) && !defined(const) && !defined(WINNT)
319a407
> 	!defined(WINNT) && \
332c420
< # if defined(USE_POSIX) || \
---
> # if defined(USE_POSIX) || defined(WINNT) ||\
334c422
< 	  && !defined(M_UNIX))
---
>  	  && !defined(M_UNIX))
356c444
< 	&& !defined(M_UNIX)
---
> 	&& !defined(M_UNIX)	&& !defined(WINNT)
373c461
< # if !defined(__ultrix) && !defined(apollo)
---
> # if !defined(__ultrix) && !defined(apollo) && !defined(WINNT)
422a511
> #if !defined(WINNT)
425a515
> #endif
435c525
< #if !defined(USE_POSIX)
---
> #if !defined(USE_POSIX) && !defined(WINNT)
450a541
> #ifndef WINNT
462a554
> #endif
495c587
< 	(defined(__ultrix) || defined(__osf__) || defined(NeXT))
---
> 	(defined(__ultrix) || defined(__osf__) || defined(NeXT) || defined(WINNT))
554c646
< #if !defined(HAVE_FCHMOD)
---
> #if !defined(HAVE_FCHMOD) && !defined(WINNT)
594a687,692
> #endif
> 
> #ifdef WINNT /* l kahn new definitions needed for vc++4.0 */
> #define fstat _fstat
> #define stat _stat
> #define fileno _fileno
Only in m:\bind/contrib/decwrl: gethost
Only in m:\bind/contrib/decwrl: gethost.o
Only in m:\bind/contrib/nutshell: ch09.check_del.c~
diff --recurs m:\bind494rel/contrib/old/nstest.c m:\bind/contrib/old/nstest.c
68,75c68,82
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
< #include <stdio.h>
< #include <resolv.h>
< #include "../conf/portability.h"
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
> #include <stdio.h>
> #include <resolv.h>
> #include "../../conf/portability.h"
> 
> #ifdef WINNT
> void usage();
> HANDLE hReadWriteEvent;
> #endif
77c84
< char *progname;
---
> char *progname;
97d103
< 	_res.options |= RES_DEBUG|RES_RECURSE;
98a105
> 	_res.options |= RES_DEBUG|RES_RECURSE;
131c138,139
< 	_res.nsaddr.sin_addr = inet_makeaddr(IN_LOOPBACKNET, 1);
---
> //	_res.nsaddr.sin_addr = inet_makeaddr(IN_LOOPBACKNET, 1);
> 	_res.nsaddr.sin_addr.s_addr = inet_addr("132.233.186.51");
318a327
> 					_res.options |= RES_DEBUG|RES_RECURSE;
420a430
> void
Only in m:\bind/contrib: winnt-dist
Only in m:\bind: cpl
Only in m:\bind: creadme.bat
Only in m:\bind: csums.bat
Only in m:\bind: diffs.ksh
Only in m:\bind: diffs493relP1tont_context.txt
Only in m:\bind: diffs493relP1tont_nocontext.txt
Only in m:\bind: diffs493relP2tont_context.txt
Only in m:\bind: diffs493relP2tont_nocontext.txt
Only in m:\bind: diffs493reltont_nocontext.txt
Only in m:\bind: diffs494areltont_context.txt
Only in m:\bind: diffs494areltont_nocontext.txt
Only in m:\bind: diffs494reltont_context.txt
Only in m:\bind: diffs494reltont_nocontext.txt
Only in m:\bind: diffs494t4atot4b_context.txt
Only in m:\bind: diffs494t4atot4b_nocontext.txt
Only in m:\bind: diffs494t5b_to_494rel_context.txt
Only in m:\bind: diffs494t5btont_context.txt
Only in m:\bind: diffs494t5btont_nocontext.txt
Only in m:\bind/doc/info: Linux-ELF
Only in m:\bind/doc/info: Linux-again
Only in m:\bind/doc/info: Linux-and-more
Only in m:\bind/doc/info: Linux-more
Only in m:\bind/doc/info: Linux-still-more
Only in m:\bind494rel/doc/info: Solaris
Only in m:\bind/doc/info: solaris
Only in m:\bind/doc/info: sunshlib.3
Only in m:\bind/doc/misc: notify.txt
Only in m:\bind494rel/doc/rfc: rfc1713
Only in m:\bind: eventlib.zip
diff --recurs m:\bind494rel/include/arpa/inet.h m:\bind/include/arpa/inet.h
66,75c66,83
< #include <sys/param.h>
< #if (!defined(BSD)) || (BSD < 199306)
< # include <sys/bitypes.h>
< #else
< # include <sys/types.h>
< #endif
< #include <sys/cdefs.h>
< 
< __BEGIN_DECLS
< unsigned long	 inet_addr __P((const char *));
---
> 
> #ifndef WINNT
> #include <sys/param.h>
> #if (!defined(BSD)) || (BSD < 199306)
> #include <sys/bitypes.h>
> #else
> #include <sys/types.h>
> #endif
> #else
> #define FD_SETSIZE 512
> #include <winsock.h>
> #endif /* WINNT */
> #include <sys/cdefs.h>
>  
> __BEGIN_DECLS
> #ifndef WINNT
> unsigned long	 inet_addr __P((const char *));
> #endif
80a89
> #ifndef WINNT
85a95
> #endif 
diff --recurs m:\bind494rel/include/arpa/nameser.h m:\bind/include/arpa/nameser.h
64,66c64,68
< #include <sys/param.h>
< #if (!defined(BSD)) || (BSD < 199306)
< # include <sys/bitypes.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #endif
> #if (!defined(BSD)) || (BSD < 199306)
> # include <sys/bitypes.h>
68c70
< # include <sys/types.h>
---
> # include <sys/types.h>
70c72
< #include <sys/cdefs.h>
---
> #include <sys/cdefs.h>
72,73c74,75
< #ifdef _AUX_SOURCE
< #include <sys/types.h>			/* ech for A/UX */
---
> #ifdef _AUX_SOURCE
> #include <sys/types.h>			/* ech for A/UX */
129a132
> #if !(defined(WINNT) && defined(NOERROR))
130a134
> #endif
331,332c335,336
< 	*t_cp++ = t_s >> 8; \
< 	*t_cp   = t_s; \
---
> 	*t_cp++ = (char) (t_s >> 8); \
> 	*t_cp   = (char) t_s; \
diff --recurs m:\bind494rel/include/netdb.h m:\bind/include/netdb.h
64,73c64,76
< #include <sys/param.h>
< #if (!defined(BSD)) || (BSD < 199306)
< # include <sys/bitypes.h>
< #endif
< #include <sys/cdefs.h>
< 
< #define	_PATH_HEQUIV	"/etc/hosts.equiv"
< #define	_PATH_HOSTS	"/etc/hosts"
< #define	_PATH_NETWORKS	"/etc/networks"
< #define	_PATH_PROTOCOLS	"/etc/protocols"
---
> #ifndef WINNT
> #include <sys/param.h>
> #endif /* WINNT */
> #if (!defined(BSD)) || (BSD < 199306)
> # include <sys/bitypes.h>
> #endif
> #include <sys/cdefs.h>
> 
> #ifndef WINNT
> #define	_PATH_HEQUIV	"/etc/hosts.equiv"
> #define	_PATH_HOSTS	"/etc/hosts"
> #define	_PATH_NETWORKS	"/etc/networks"
> #define	_PATH_PROTOCOLS	"/etc/protocols"
76a80,85
> #else /* WINNT */
> #define	_PATH_HOSTS	"%windir%\\SYSTEM32\\DRIVERS\\ETC\\HOSTS"
> #define	_PATH_NETWORKS	"%windir%\\SYSTEM32\\DRIVERS\\ETC\\NETWORKS"
> #define	_PATH_PROTOCOL	"%windir%\\SYSTEM32\\DRIVERS\\ETC\\PROTOCOL"
> #define	_PATH_SERVICES	"%windir%\\SYSTEM32\\DRIVERS\\ETC\\SERVICES"
> #endif /* WINNT */
77a87
> #ifndef WINNT
114a125
> #endif /* WINNT */
122a134
> #ifndef WINNT
127a140
> #endif /* WINNT */
133a147
> #ifndef WINNT
138c152,159
< struct netent	*getnetbyaddr __P((unsigned long, int));
---
> struct netent	*getnetbyaddr __P((unsigned long, int)); /* u_long? */
> struct netent	*getnetbyname __P((const char *));
> #else
> struct hostent	*gethostbyaddr_nt __P((const char *, int, int));
> struct hostent	*gethostbyname_nt __P((const char *));
> struct hostent	*gethostbyname2 __P((const char *, int));
> struct hostent	*gethostent __P((void));
> struct netent	*getnetbyaddr __P((unsigned long, int)); /* u_long? */
139a161,162
> #endif
> 
140a164
> #ifndef WINNT
142a167
> #endif
143a169
> #ifndef WINNT
145a172
> #endif
diff --recurs m:\bind494rel/include/resolv.h m:\bind/include/resolv.h
64,71c64,77
< #include <sys/param.h>
< #if (!defined(BSD)) || (BSD < 199306)
< # include <sys/bitypes.h>
< #else
< # include <sys/types.h>
< #endif
< #include <sys/cdefs.h>
< #include <stdio.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #endif
> #if (!defined(BSD)) || (BSD < 199306)
> # include <sys/bitypes.h>
> #else
> # include <sys/types.h>
> #endif
> #include <sys/cdefs.h>
> #include <stdio.h>
> #ifdef WINNT
> #define FD_SETSIZE 512
> #include <winsock.h>
> #endif
89a96
> #ifndef WINNT
90a98,101
> #else
> #define _PATH_RESCONF		 "%windir%\\RESOLV.CONF"
> #define _ALT_PATH_RESCONF	 "%windir%\\RESOLV.INI"
> #endif /* WINNT */
Only in m:\bind: install
Only in m:\bind: install.txt
Only in m:\bind/man: bs
Only in m:\bind: mk2.bat
Only in m:\bind: mkdist.bat
Only in m:\bind: mksrc.bat
Only in m:\bind: mktxt.bat
Only in m:\bind/named: TAGS
Only in m:\bind494rel/named: Version.c
Only in m:\bind/named: WinRel
Only in m:\bind/named: bindtray.ico
diff --recurs m:\bind494rel/named/db_defs.h m:\bind/named/db_defs.h
79c79,83
< 	u_int32_t	d_ttl;		/* time to live */
---
> #ifndef WINNT
> 	u_int32_t	d_ttl;		/* time to live */
> #else
> 	int32_t	        d_ttl;		/* time to live */
> #endif
diff --recurs m:\bind494rel/named/db_dump.c m:\bind/named/db_dump.c
61,70c61,74
< #include <sys/param.h>
< #include <sys/stat.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <netdb.h>
< #include <stdio.h>
< #include <syslog.h>
< #include <resolv.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/stat.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <netdb.h>
> #include <stdio.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
> #include <resolv.h>
81a86,88
> char * inet_nsap_ntoa();
> const char * inet_ntop();
> 
425c432
< 			    dp->d_ttl != zones[dp->d_zone].z_minimum)
---
> 			    (u_int32_t)dp->d_ttl != zones[dp->d_zone].z_minimum)
591c598
< 					n = -2;		/* XXX - hack */
---
> 					n = (u_int32_t) -2;		/* XXX - hack */
diff --recurs m:\bind494rel/named/db_glue.c m:\bind/named/db_glue.c
62,71c62,75
< #include <sys/uio.h>
< #include <sys/param.h>
< #include <sys/stat.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
< #include <stdio.h>
< #include <syslog.h>
< #include <ctype.h>
< #include <netdb.h>
---
> #ifndef WINNT
> #include <sys/uio.h>
> #include <sys/param.h>
> #include <sys/stat.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
> #include <stdio.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
> #include <ctype.h>
> #include <netdb.h>
124a129
> #ifndef WINNT
126a132,137
> #else
>   	/* under Windows, abort() does not call raise(SIGABRT)
>   	 * or flush stream buffers
>   	 */
>   	 exit(3);
>   #endif
142,144c153,155
< 		if (!slp)
< 			panic(errno, "malloc(servent)");
< 		slp->name = savestr(sp->s_name);
---
>  		if (!slp)
>   			panic(errno, "malloc(servent)");
>  		slp->name  = savestr(sp->s_name);
146,148c157,159
< 		slp->port = ntohs((u_int16_t)sp->s_port);  /* host byt order */
< 		slp->next = servicelist;
< 		slp->prev = NULL;
---
> 		slp->port = ntohs((u_int16_t)sp->s_port); /* host byte order */
> 		slp->next  = servicelist;
> 		slp->prev  = NULL;
370a382
> #ifndef WINNT
371a384,387
> #else
> 		WSASetLastError(0);
> #endif
> #ifndef WINNT
373a390,393
> #else
> 		s = closesocket(fd);
> 	} while (s < 0 && errno == WSAEINTR);
> #endif
374a395
> #ifndef WINNT
375a397,399
> #else
> 	if (s < 0 && errno != WSAEBADF)
> #endif
792a817
> #ifndef WINNT
835a861
> #endif /* WINNT */
diff --recurs m:\bind494rel/named/db_load.c m:\bind/named/db_load.c
65,74c65,81
< #include <sys/param.h>
< #include <sys/stat.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <stdio.h>
< #include <syslog.h>
< #include <ctype.h>
< #include <netdb.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/stat.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <stdio.h>
> #ifndef WINNT
> #include <syslog.h>
> #else
> #include <sys/types.h>
> #include <sys/stat.h>
> #endif
> #include <ctype.h>
> #include <netdb.h>
92a100,101
> u_int inet_nsap_addr();
> int inet_pton();
202a212
> #ifndef WINNT
203a214,216
> #else
> 	struct _stat sb;
> #endif
242c255
< 		dprintf(1, (ddt, "db_load: error opening file %s\n",
---
> 		dprintf(1, (ddt, "db_load: error opening file %s \n",
258a272
> #ifndef WINNT
259a274,276
> #else
> 	if (_fstat(fileno(fp), &sb) < 0) {
> #endif
328c345
< 				    if (n > (INT_MAX - (*cp - '0')) / 10) {
---
> 				    if (n > (((u_int32_t)INT_MAX - (u_int32_t)(*cp - '0')) / (u_int32_t)10)) {
341c358
< 				    if (n > max_cache_ttl)
---
> 				    if (n > (u_int32_t)max_cache_ttl)
579a597
> #ifndef WINNT
580a599,601
> #else
> 				if ((u_int32_t)zp->z_expire < zp->z_refresh ) {
> #endif
726c747
< 				    *cp++ = 255;
---
> 				    *cp++ = (char)255;
diff --recurs m:\bind494rel/named/db_lookup.c m:\bind/named/db_lookup.c
65,68c65,70
< #include <syslog.h>
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
---
> #ifndef WINNT
> #include <syslog.h>
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
diff --recurs m:\bind494rel/named/db_reload.c m:\bind/named/db_reload.c
61,66c61,70
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <stdio.h>
< #include <syslog.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <stdio.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
diff --recurs m:\bind494rel/named/db_save.c m:\bind/named/db_save.c
65,69c65,73
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <syslog.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
diff --recurs m:\bind494rel/named/db_secure.c m:\bind/named/db_secure.c
9,14c9,19
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <syslog.h>
< #include <errno.h>
---
> #ifndef WINNT
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #ifndef WINNT
> #include <syslog.h>
> #include <errno.h>
> 
> #endif
diff --recurs m:\bind494rel/named/db_update.c m:\bind/named/db_update.c
62,66c62,67
< #include <syslog.h>
< 
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
---
> #ifndef WINNT
> #include <syslog.h>
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
Only in m:\bind/named: icon1.ico
Only in m:\bind/named: ipaddr.mak
Only in m:\bind/named: ipaddr.mdp
Only in m:\bind/named: ipaddr.ncb
Only in m:\bind/named: ipaddr.vcp
Only in m:\bind/named: ipaddr95.mak
Only in m:\bind/named: ipaddr95.mdp
Only in m:\bind/named: ipaddr95.ncb
Only in m:\bind/named: ipadr.c
Only in m:\bind/named: ipadr95.c
diff --recurs m:\bind494rel/named/named-xfer.c m:\bind/named/named-xfer.c
76,84c76,84
< #include <sys/param.h>
< #include <sys/file.h>
< #include <sys/stat.h>
< #include <sys/socket.h>
< 
< #include <netinet/in.h>
< #if defined(__osf__)
< # include <sys/mbuf.h>
< # include <net/route.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/file.h>
> #include <sys/stat.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #if defined(__osf__)
> # include <sys/mbuf.h>
> # include <net/route.h>
90a91,95
> 
> #else
> #include <sys/stat.h>
> #include <limits.h>
> #endif /* WINNT */
94d98
< 
97a102
> #ifndef WINNT
98a104,106
> #else
> #include <stdlib.h>
> #endif
100c108
< # include <math.h>
---
> #include <math.h>
112a121,126
> #ifdef WINNT
> #define exit(x) ExitProcess(x);
> HANDLE hReadWriteEvent = NULL;
> char pathtmpxfer[MAX_PATH], pathtmpdir[MAX_PATH];
> #endif
> 
113a128,129
> char * inet_nsap_ntoa();
> const char * inet_ntop();
114a131
> #ifndef WINNT
116a134,136
> #else
> static char	*ddtfile = pathtmpxfer,
> #endif
133a154
> #ifndef WINNT
134a156
> #endif
148c170,173
< 	int dbfd, ddtd, result, c, fd, closed = 0;
---
> 	int dbfd, ddtd, result, c, closed = 0;
> #ifndef WINNT
> 	int fd;
> #endif
158a184,195
> #ifdef WINNT
>  	WORD wVersionRequested;
> 	WSADATA wsaData;
> 
> 	wVersionRequested = MAKEWORD(1,1);
> 	if (WSAStartup(wVersionRequested, &wsaData)) {
> 		syslog(LOG_ERR, "No useable winsock.dll: %m");
> 		exit(XFER_FAIL); 
> 	}
> 
> #endif
> 
165a203
> #ifndef WINNT
168a207
> #endif
174a214,222
> #ifdef WINNT
> 	(void) SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
> 	if (!GetTempPath(MAX_PATH, pathtmpdir))
> 		syslog(LOG_ERR, "GetTempPath() failed: %m");
> 	else {
> 		strcpy(pathtmpxfer, pathtmpdir);
> 		strcat(pathtmpxfer, _PATH_TMPXFER);
> 	}
> #endif
175a224
> #ifndef WINNT
180a230
> #endif /* WINNT */
327a378
> #ifndef WINNT
347a399
> #endif /* WINNT */
353,354c405,406
< 	buildservicelist();
< 	buildprotolist();
---
> 	  buildservicelist();
> 	  buildprotolist();
381c433,443
< 			hp = gethostbyname(tm);
---
> /*#ifndef WINNT
> 		   hp = gethostbyname(tm);
> #else
> 		   hp = gethostbyname_nt(tm);
> #endif
> */
> /* lgk we may want the above code someday but for now use gethostbyname under nt
> (not the new version which will not resolve locahost or names in the host file ..
> this means ip6 will not work with xfer for now */
> 
>             hp = gethostbyname(tm);
385c447,448
< 				       tm, zp->z_origin);
---
> 				       tm, zp->z_origin); 
> 
388c451
< 			bcopy(hp->h_addr,
---
>                   bcopy(hp->h_addr,
391a455
> 
410a475,481
> 
>     /* lgk add code to close ddtfile here */
> #ifdef DEBUG
> 	if (debug)
>       (void) my_fclose(ddt);
> #endif
> 
412a484,487
> #ifdef WIN95
> BOOL moveok;
> #endif
> 
413a489
> #ifndef WINNT
414a491,510
> #else /* lgk get rid of the ddt file if txfer ok in debug mode */
> #ifdef DEBUG
>         if (debug)
>           (void) unlink(ddtfile);
> #endif
> 
> /* lgk movefileex doesn't work on win95 so replace it */
> #ifndef WIN95
> 		/* C run time rename function under NT does not overwrite */
> 		if(!MoveFileEx(tmpname, dbfile, MOVEFILE_REPLACE_EXISTING)) {
> #else
> 		moveok = CopyFile(tmpname, dbfile, FALSE);
>                 if (moveok)
>                   moveok = DeleteFile(tmpname);
>                 if (!moveok) {
>                     
> #endif /* winnt or 95 versions */
> 
> #endif
> 
422a519
> /* lgk add code to get rid of the ddt files if not in debug mode.. */
424a522,525
> #ifdef DEBUG
>         if (debug)
>           (void) unlink(ddtfile);
> #endif
431c532
< 		    (void) unlink(tmpname);
---
> 		(void) unlink(tmpname);
438,439c539,540
< #endif
< 		    (void) unlink(tmpname);
---
> #endif      
> 		(void) unlink(tmpname);
478c579,580
< int	minimum_ttl = 0, got_soa = 0;
---
> u_int32_t	minimum_ttl = 0;
> int	got_soa = 0;
501a604
> #ifndef WINNT
507c610,612
< 	int qdcount, ancount, aucount, class, type;
---
> #endif
> 	u_short qdcount, ancount, aucount;
> 	int class, type;
509a615,620
> #ifdef WINNT
> /* lgk moved startup to beginning.. */
> 
> 	hReadWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
> #endif /* WINNT */
> 
524a636,637
> 
> #ifndef WINNT
538a652
> #endif /* WINNT */
554c668
< 				syslog(LOG_INFO, "malloc(%u) failed",
---
> 				syslog(LOG_WARNING, "malloc(%u) failed",
560a675
> 
566c681
< 			syslog(LOG_INFO, "socket: %m");
---
> 			syslog(LOG_WARNING, "socket: %m");
569c684
< 		}	
---
> 		}
575c690
< 				syslog(LOG_INFO,
---
> 				syslog(LOG_WARNING,
592a708
> #ifndef WINNT
597a714
> #endif /* WINNT */
604c721
< 			syslog(LOG_INFO, "writemsg: %m");
---
> 			syslog(LOG_WARNING, "writemsg: %m");
623c740
< 				syslog(LOG_INFO,
---
> 				syslog(LOG_WARNING,
645,647c762,764
< 		qdcount = ntohs(hp->qdcount);
< 		ancount = ntohs(hp->ancount);
< 		aucount = ntohs(hp->nscount);
---
> 		qdcount = ntohs( (u_short) hp->qdcount);
> 		ancount = ntohs( (u_short) hp->ancount);
> 		aucount = ntohs( (u_short) hp->nscount);
665c782
< 			syslog(LOG_NOTICE,
---
> 			syslog(LOG_WARNING,
681c798
< 			syslog(LOG_INFO,
---
> 			syslog(LOG_WARNING,
705c822
< 			syslog(LOG_INFO,
---
> 			syslog(LOG_WARNING,
721c838
< 			syslog(LOG_INFO,
---
> 			syslog(LOG_WARNING,
782c899
< 							syslog(LOG_INFO,
---
> 							syslog(LOG_WARNING,
789c906
< 							syslog(LOG_INFO,
---
> 							syslog(LOG_WARNING,
793a911
> #ifndef WINNT
800a919
> #endif /* WINNT */
807c926
< 						syslog(LOG_INFO,
---
> 						syslog(LOG_WARNING,
842c961
< 					syslog(LOG_INFO,
---
> 					syslog(LOG_WARNING,
861,862c980,981
< 				ancount = ntohs(hp->ancount);
< 				for (cnt = 0 ; cnt < ancount ; cnt++) {
---
> 				ancount = ntohs( (u_short) hp->ancount);
> 				for (cnt = 0 ; cnt < (u_int) ancount ; cnt++) {
869,870c988,989
< 					ancount = ntohs(hp->nscount);
< 					for (cnt = 0 ; cnt < ancount ; cnt++) {
---
> 					ancount = ntohs( (u_short) hp->nscount);
> 					for (cnt = 0 ; cnt < (u_int) ancount ; cnt++) {
875,876c994,995
< 				ancount = ntohs(hp->arcount);
< 				for (cnt = 0 ; cnt < ancount ; cnt ++) {
---
> 				ancount = ntohs( (u_short) hp->arcount);
> 				for (cnt = 0 ; cnt < (u_int) ancount ; cnt ++) {
881c1000
< 					syslog(LOG_INFO,
---
> 					syslog(LOG_WARNING,
890c1009
< 				ancount = ntohs(hp->ancount);
---
> 				ancount = ntohs((u_short)hp->ancount);
896c1015
< 					syslog(LOG_INFO,
---
> 					syslog(LOG_WARNING,
916c1035
< 						syslog(LOG_INFO,
---
> 						syslog(LOG_WARNING,
955c1074
< 					syslog(LOG_INFO,
---
> 					syslog(LOG_WARNING,
980a1100
> #ifndef WINNT
981a1102,1105
> #else
> 					if (fseek(dbfp, 0L, SEEK_SET) || 
> 						!SetEndOfFile((HANDLE)fileno(dbfp))) {
> #endif
983c1107
< 						    syslog(LOG_INFO,
---
> 						    syslog(LOG_ERR,
1000a1125
> #ifndef WINNT
1006a1132
> #endif /* WINNT */
1019c1145
< 		    syslog(LOG_NOTICE,
---
> 		    syslog(LOG_WARNING,
1025a1152
> #ifndef WINNT
1030a1158
> #endif /* WINNT */
1052c1180,1182
< {
---
> 
> {		int counter = 0;
> 
1054d1183
< 	struct itimerval ival, zeroival;
1058a1188,1189
> #ifndef WINNT
> 	struct itimerval ival, zeroival;
1062a1194,1198
> #else
> 	int ret;
> 	struct timeval tvout;
> 	fd_set fdset;	
> #endif
1063a1200
> #ifndef WINNT
1068a1206
> 		
1075c1213
< 			syslog(LOG_INFO, "premature EOF, fetching \"%s\"",
---
> 			syslog(LOG_WARNING, "premature EOF, fetching \"%s\"",
1099a1238,1293
> #else /* WINNT */
> 		/* our socket is kept nonblocking due to timeout considerations
> 		 * there are two ways to ensure that a recv on the nonblocking
> 		 * socket will not return prematurely:
> 		 * 1) use select() to wait (with timeout) for the socket to be ready
> 		 * 2) use the ReadFile() win32 API to do asynchronous I/O using
> 		 *    signalled events (as has been done in writev() implementation
> 		 * The first is being used here because it will work for Unix
> 		 * systems also, and some day the setitimer() alarms may be 
> 		 * replaced by select() to create a single scheme for both
> 		 * Unix and NT
> 		 */
> 		 tvout.tv_sec = timeout;
> 		 tvout.tv_usec = 0;
> 		 FD_ZERO(&fdset);
> 		 FD_SET(fd, &fdset);
> 		 ret = select(fd+1, &fdset, (fd_set *)0, (fd_set *)0, &tvout);
> 		 ++counter;
> 		 if ((ret != SOCKET_ERROR) && (ret > 0)) 
> 		    {
> 		 	n = recv(fd, buf, len, 0);	 
> 
> 			if (n == SOCKET_ERROR)
> 			  {
> 				if (WSAGetLastError() == WSAEWOULDBLOCK)
> 					continue;
> 				else 
> 				   {
> 					syslog(LOG_ERR, "recv (in xfer) (len=%d): %m", len);
> 					return (-1);
> 				   }
> 		       
> 		       }
> 		    else if (n == 0)
> 			 {
> 			   syslog(LOG_WARNING,"recv (in xfer) (connection closed by remote) : %m");
> 			   return(-1);
> 			 }
> 		   }
> 	        else /* error case on select */ 
> 				{
> 				  if (ret == SOCKET_ERROR)
> 				  {
> 					  syslog(LOG_ERR,"select (in xfer) error: %m");
> 					  return(-1);
> 				  }
> 
> 		 	      if (ret == 0) 
> 				    { 
> 				     WSASetLastError(WSAETIMEDOUT);
> 			             syslog(LOG_WARNING, "select (in xfer timed out) error: %m");
> 			             return (-1);
> 				    }
> 				 }
> 
> #endif /* WINNT */
1102a1297
> #ifndef WINNT
1106a1302
> #endif
1305c1501
< 		syslog(LOG_INFO, "\"%s %s %s\" - unknown type (%d)",
---
> 		syslog(LOG_WARNING, "\"%s %s %s\" - unknown type (%d)",
Only in m:\bind/named: named.aps
Only in m:\bind/named: named.mak
Only in m:\bind/named: named.mdp
Only in m:\bind/named: named.ncb
Only in m:\bind/named: named.rc
Only in m:\bind/named: named.vcp
Only in m:\bind/named: named95.mak
Only in m:\bind/named: named95.mdp
Only in m:\bind/named: named95.ncb
Only in m:\bind/named: ndc.c
Only in m:\bind/named: ndc.mak
Only in m:\bind/named: ndc.mdp
Only in m:\bind/named: ndc.ncb
Only in m:\bind/named: ndc.vcp
Only in m:\bind/named: ndc95.c
Only in m:\bind/named: ndc95.mak
Only in m:\bind/named: ndc95.mdp
Only in m:\bind/named: ndc95.ncb
diff --recurs m:\bind494rel/named/ns_defs.h m:\bind/named/ns_defs.h
122,131c122,136
< 	u_int32_t	z_expire;	/* expiration time for cached info */
< 	u_int32_t	z_minimum;	/* minimum TTL value */
< 	u_int32_t	z_serial;	/* changes if zone modified */
< 	char		*z_source;	/* source location of data */
< 	time_t		z_ftime;	/* modification time of source file */
< 	struct in_addr	z_xaddr;	/* override server for next xfer */
< 	struct in_addr	z_addr[NSMAX];	/* list of master servers for zone */
< 	u_char		z_addrcnt;	/* number of entries in z_addr[] */
< 	u_char		z_type;		/* type of zone; see below */
< 	u_int16_t	z_flags;	/* state bits; see below */
---
> #ifndef WINNT
> 	u_int32_t	z_expire;	/* expiration time for cached info */
> #else
> 	int32_t	z_expire;	/* expiration time for cached info */
> #endif
> 	u_int32_t	z_minimum;	/* minimum TTL value Changes */
> 	u_int32_t	z_serial;	/* changes if zone modified */
> 	char		*z_source;	/* source location of data */
> 	time_t		z_ftime;	/* modification time of source file */
> 	struct in_addr	z_xaddr;	/* override server for next xfer */
> 	struct in_addr	z_addr[NSMAX];	/* list of master servers for zone */
> 	u_char		z_addrcnt;	/* number of entries in z_addr[] */
> 	u_char		z_type;		/* type of zone; see below */
> 	u_int16_t	z_flags;	/* state bits; see below */
> #ifndef WINNT
132a138,140
> #else
> 	HANDLE		z_xferpid;	/* handle for thread doing xfer */
> #endif
182a191,193
> #ifdef WINNT
> #define XFER_KILLED 	4
> #endif
183a195
> #ifndef WINNT
184a197
> #endif
257a271
> #ifndef WINNT
258a273,275
> #else
> 	SOCKET	s_rfd;
> #endif
272a290
> #ifndef WINNT
273a292,294
> #else
> 	u_int		dq_dfd;		/* datagram file descriptor */
> #endif
diff --recurs m:\bind494rel/named/ns_forw.c m:\bind/named/ns_forw.c
61,65c61,67
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
67,70c69,77
< #include <syslog.h>
< #include <resolv.h>
< #include <stdio.h>
< #include <errno.h>
---
> #ifndef WINNT
> #include <syslog.h>
> #else
> #include <stdlib.h>
> #include <search.h>
> #endif
> #include <resolv.h>
> #include <stdio.h>
> #include <errno.h>
73a81,84
> #ifdef WINNT
> int qcomp(const void *, const void *);
> #endif
> 
377c388
< 	register int n;
---
> 	register unsigned int n;
657a669
> #ifndef WINNT
659a672,674
> #else
> 		qsort((char *)qp->q_addr, n, sizeof(struct qserv), qcomp);
> #endif
diff --recurs m:\bind494rel/named/ns_func.h m:\bind/named/ns_func.h
108,111c108,115
< extern void		holdsigchld __P((void));
< extern void		releasesigchld __P((void));
< extern SIG_FN		reapchild __P(());
< extern void		endxfer __P((void));
---
> #ifndef WINNT
> extern void		holdsigchld __P((void));
> extern void		releasesigchld __P((void));
> extern SIG_FN		reapchild __P(());
> extern void		endxfer __P((void));
> #else
> extern	void		endxfer __P((DWORD));
> #endif
diff --recurs m:\bind494rel/named/ns_glob.h m:\bind/named/ns_glob.h
89,90c89,93
< DECL	int			vs		INIT(-1);
< 
---
> #ifndef WINNT
> DECL	int			vs		INIT(-1);
> #else
> DECL	int			vs		INIT(INVALID_SOCKET);
> #endif
diff --recurs m:\bind494rel/named/ns_init.c m:\bind/named/ns_init.c
61,70c61,74
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <sys/stat.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <syslog.h>
< #include <resolv.h>
< #include <stdio.h>
< #include <errno.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <sys/stat.h>
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
> #include <resolv.h>
> #include <stdio.h>
> #include <errno.h>
106,109c110,113
< {
< 	u_long refresh = (zp->z_refresh > 0) ? zp->z_refresh : INIT_REFRESH;
< 	time_t half = (refresh + 1) / 2;
< 
---
>    {
>   	u_long refresh = (zp->z_refresh > 0) ? zp->z_refresh : INIT_REFRESH;
>   	time_t half = (refresh + 1) / 2;
>  
244a249,251
> #ifdef WINNT
> 	extern char *pathtmpdir;
> #endif
246a254,262
> 	
> #if defined(WINNT) && defined(REGISTRY_PATHS)
> 	/* software.com specific 
> 	   PIW:  change to the temp dir that we got from the registry */
> 	if (chdir(pathtmpdir) != TRUE)
> 	{
> 		syslog(LOG_CRIT, "Can't chdir to %s: %m\n",buf);
> 		exit(1);
> 	}
247a264
> #endif
268a286
> #ifndef WINNT
270,271c288,302
< 				syslog(LOG_CRIT, "directory %s: %m\n",
< 					buf);
---
> #else
> #ifdef REGISTRY_PATHS
>             /* software.com specific 
> 		       PIW Software.com: ignore the directory, we got it from
> 			   the registry already in ns_main.c, and it is stored
> 			   in the global 'pathtmpdir'. */
> 
> 			syslog(LOG_INFO,"Ignoring directory entry in startup\n");
> 
> 			if (chdir(pathtmpdir) != TRUE) {
> #else
> 			if (chdir(buf) != TRUE) {
> #endif /* registry paths */
> #endif /* winnt */
> 				syslog(LOG_CRIT, "directory %s: %m\n",buf);
589a621
> #ifndef WINNT
590a623,625
> #else
> 				sprintf(buf, "%sNsTmp%ld.%d", pathtmpdir,
> #endif
diff --recurs m:\bind494rel/named/ns_main.c m:\bind/named/ns_main.c
9,10c9,10
<  * Copyright (c) 1986, 1989, 1990
<  *    The Regents of the University of California.  All rights reserved.
---
>  * Copyright (c) 1986,  1989, 1990
>  *    The Regents of the University of California.  All rights reserved.
12,18c12,18
<  * Redistribution and use in source and binary forms, with or without
<  * modification, are permitted provided that the following conditions
<  * are met:
<  * 1. Redistributions of source code must retain the above copyright
<  *    notice, this list of conditions and the following disclaimer.
<  * 2. Redistributions in binary form must reproduce the above copyright
<  *    notice, this list of conditions and the following disclaimer in the
---
>  * Redistribution and use in source and binary forms, with or without
>  * modification, are permitted provided that the following conditions
>  * are met:
>  * 1. Redistributions of source code must retain the above copyright
>  *    notice, this list of conditions and the following disclaimer.
>  * 2. Redistributions in binary form must reproduce the above copyright
>  *    notice, this list of conditions and the following disclaimer in the
72a73
> #ifndef WINNT
74a76
> #endif
83a86
> #ifndef WINNT
86a90
> #endif
94a99
> #ifndef WINNT
95a101,103
> #else
> #include "ntif.h" /* hacked version for nt only */
> #endif
99a108
> #ifndef WINNT
100a110
> #endif
114a125,129
> #ifdef WINNT
> #include <process.h> 
> #include "../compat/lib/log.h"
> #endif
> 
126a142,179
> #ifdef WINNT
> 
> #ifdef WIN95
> void ndc_thread(void *);
> #endif
> 
>     	/* handles for various threads, process, and objects */
> 	HANDLE hReadWriteEvent = NULL, hServDoneEvent = NULL, hWorkerThread = NULL, hNDCThread = NULL;
> 	/* variables used to inform the Service Control Manager of our current state */
>         volatile int doterminate = 0;
> 	SERVICE_STATUS ServiceStatus;
> 	SERVICE_STATUS_HANDLE   hServiceStatus;
> 	OVERLAPPED overlap; 
> 	int was_stopped = 0;
> 	char *pathboot, *pathxfer, *pathdebug,
> 	 	 *pathdumpfile, *pathpidfile, *pathstats,
> 	 	 *pathxfertrace, *pathxferddt, *pathtmpdir, *pathsysdir;
>     CRITICAL_SECTION protected_zp;
>     CRITICAL_SECTION maint_section;
>     /* critical section used to synchronize the named xfers */
> #define exit(x) { if (hServDoneEvent != NULL) \
> 						SetEvent(hServDoneEvent);\
> 				  ExitThread(x); \
> 				}
> char szMsgPath[255];
> #ifdef NOWAIT
> 	char loopbuf[] = "";
> 	struct sockaddr_in loopback;
> #endif
> 	
> #ifdef REGISTRY_PATHS
> 	/* software.com specific
> 	   PIW Software.com change to get path from registry */
> 	static int GetRegistryPath(int max_len, char *directory);
> #endif /* registry paths */
> #endif /* WINNT */
> 
> 
135a189
> #ifndef WINNT
149a204
> #endif /* WINNT */
165,166c220,225
< 	register int n, udpcnt;
< 	register char *arg;
---
>   	register int n;
> 	register char *arg;	
> 	const int on = 1;
> 
> #ifndef WINNT
>     register int udpcnt;
171d229
< 	const int on = 1;
181c239
< #endif
---
> #endif 
186c244,247
< 	struct timeval t, *tp;
---
> 	struct timeval *tp;
> #endif /* WINNT */
> 
> 	struct timeval t;
198a260,284
> #ifdef WINNT
>  	WORD wVersionRequested;
> 	WSADATA wsaData;
> 
> 	/* initialize the winsock dll version needed */
> 	wVersionRequested = MAKEWORD(1,1);
> 	if (WSAStartup(wVersionRequested, &wsaData)) {
> 		syslog(LOG_ERR, "No useable winsock.dll: %m");
> 		return;
> 	}
> 
>     /* initialize the critical section */
>    InitializeCriticalSection(&protected_zp);
>    InitializeCriticalSection(&maint_section);
>    /* initialize all pathnames */
>    expand_paths();
> 
>        /* lgk add startup code here */
>          /* Set the Event-ID message-file name. */
>           GetCurrentDirectory(sizeof(szMsgPath), szMsgPath);
>           strcat(szMsgPath, "\\named.exe");
>           addSourceToRegistry("DNS", szMsgPath);
> 
> #endif /* WINNT */
> 
307a394
> #ifndef WINNT
312a400
> #endif /* WINNT */
345a434
> #ifndef WINNT
346a436,438
> #else
> 		if ((vs = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
> #endif
388a481
> #ifndef WINNT
400a494
> #endif /* WINNT */
425a520
> #ifndef WINNT
449a545
> #endif /* WINNT */
458a555
> #ifndef WINNT
536a634,837
> 
> #else /* WINNT */
> 
> #ifndef WIN95
> 
> #ifdef DEBUG
> 	if (!debug)
> #endif
> 
> 	{
> 		SERVICE_TABLE_ENTRY dispatchTable[] = {
>         	{ TEXT("DomainNameService"), (LPSERVICE_MAIN_FUNCTION)service_main },
>         	{ NULL, NULL }
>     	};
> 
> 	/* daemonize */
>     	if (!StartServiceCtrlDispatcher(dispatchTable)) {
> 			if (!was_stopped) {
> 				syslog(LOG_ERR, "StartServiceCtrlDispatcher: %m");
> 				ExitProcess(2);
> 			} else {
> 				syslog(LOG_INFO, "StartServiceCtrlDispatcher: service stopped");
> 				ExitProcess(0);
> 			}
> 		}
> 	}
> 
> 
> #ifdef DEBUG
> 	else
> 	   service_main(argc, argv);
> #endif /* DEBUG */
> 
> #else /* is win95 version */
> 	   service_main(argc, argv);
> #endif /* win95 version */
> } /* end main */
> 
> /*
>  * If this runs as a service under NT, the main thread will block at StartServiceCtrlDispatcher()
>  * and another thread will be started by the Service Control Dispatcher which will begin execution 
>  * at the routine specified in that call (viz. service_main) 
>  */
> void
> service_main(argc, argv)
> 	DWORD argc;
> 	LPTSTR *argv;
> {
> 
> #ifndef WIN95
>      DWORD dwWait;
> #endif;
> 
> 
> 
> #ifdef NOWAIT
> 	loopback.sin_family = AF_INET;
> 	loopback.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
> 	loopback.sin_port = local_ns_port;
> #endif
> 
> 	/* lgk if win95 don't do this stuff */
> #ifndef WIN95
> 
> #ifdef DEBUG
> 	if(!debug) {
> #endif /* DEBUG */
> 
>     	/* register our service control handler */
> 		if (!(hServiceStatus = RegisterServiceCtrlHandler( TEXT("DomainNameService"),
>                         			(LPHANDLER_FUNCTION)service_ctrl))) {
> 			syslog(LOG_ERR, "RegisterServiceCtrlHandler() failed: %m");
> 			return;
> 		}
> 
> 		/* report pending status to Service Control Manager */
> 		ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
> 		ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
> 		ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
> 		ServiceStatus.dwWin32ExitCode = NO_ERROR;
>     	        ServiceStatus.dwServiceSpecificExitCode = 0;
> 		ServiceStatus.dwCheckPoint = 1;
> 		ServiceStatus.dwWaitHint = 5000;
> 		if (!SetServiceStatus(hServiceStatus, &ServiceStatus)) {
> 			syslog(LOG_ERR, "SetServiceStatus(): %m");
>         	ServiceStatus.dwCurrentState = SERVICE_STOPPED;
> 			SetServiceStatus(hServiceStatus, &ServiceStatus);
> 			return;
>     	}
> 
> 		/* create an event object that the control handler function
> 	 	* will signal when it receives the "stop" control code */
> 		if (!(hServDoneEvent = CreateEvent(
>         				NULL,    /* no security attributes */
>         				FALSE,   /* auto-reset event */
>         				FALSE,   /* not-signalled */
>         				NULL))){ /* no name */
> 				syslog(LOG_ERR, "CreateEvent() failed: %m");
>         		ServiceStatus.dwCurrentState = SERVICE_STOPPED;
> 				SetServiceStatus(hServiceStatus, &ServiceStatus);
> 				return;
>     	}
> 
> 	/* 
> 	 * the service_main() thread will have to wait for start/stop/pause/continue requests
> 	 * from the services icon in the Control Panel or from any WIN32 application
>      * start a new thread to perform all the work of the NTP service 
>      */
>         if (!(hWorkerThread = (HANDLE)_beginthread(
>                     worker_thread,
>                     0,       /* stack size			*/
>                     NULL))){    /* argument to thread	*/
> 			syslog(LOG_ERR, "_beginthread: %m");
> 			if (hServDoneEvent != NULL)
> 				CloseHandle(hServDoneEvent);
>         	ServiceStatus.dwCurrentState = SERVICE_STOPPED;
> 			SetServiceStatus(hServiceStatus, &ServiceStatus);
> 			return;
> 		}
> 
>     	/* report to the service control manager that the service is running */
> 		ServiceStatus.dwCurrentState = SERVICE_RUNNING;
> 		ServiceStatus.dwWin32ExitCode = NO_ERROR;
> 		if (!SetServiceStatus(hServiceStatus, &ServiceStatus)) {
> 			syslog(LOG_ERR, "SetServiceStatus(): %m");
> 			if (hServDoneEvent != NULL)
> 				CloseHandle(hServDoneEvent);
>         	ServiceStatus.dwCurrentState = SERVICE_STOPPED;
> 			SetServiceStatus(hServiceStatus, &ServiceStatus);
> 			return;
> 		}
> 
> 
>     	/* wait indefinitely until hServDoneEvent is signaled */
>     	dwWait = WaitForSingleObject(hServDoneEvent,INFINITE);
> 		if (hServDoneEvent != NULL)
> 			CloseHandle(hServDoneEvent);
> 		if (hWorkerThread != NULL)
> 	        CloseHandle(hWorkerThread);
> 
>     	ServiceStatus.dwCurrentState = SERVICE_STOPPED;
> 		SetServiceStatus(hServiceStatus, &ServiceStatus);
> 	return;
> 	}
> #ifdef DEBUG
> 	else 
> 	    worker_thread(NULL);
> 
> #endif /* DEBUG */
> 
> #else /* it is win95 so... no services */
> 
> 
>             /* still start up ndc thread even in win95 mode */
>             /* lgk new code now start up the ndc_named socket thread */
>             if (!(hNDCThread = (HANDLE)_beginthread(
>                     ndc_thread,
>                     0,       /* stack size			*/
>                     NULL))){    /* argument to thread	*/
> 			syslog(LOG_ERR, "_beginthread: %m");
> 			if (hServDoneEvent != NULL)
> 			  CloseHandle(hServDoneEvent);
> 			return;
> 		}
> 
> worker_thread(NULL);
> 
> #endif /* win95 */
> 
> } /* end service_main() */
> 
> 
> /*
>  * worker_thread - perform all remaining functions after initialization and and becoming a service
>  */
> void
> worker_thread(notUsed)
> 	void *notUsed;
> {
> #ifdef WANT_PIDFILE
> 	FILE *fp;
> #endif
> 	register int n, udpcnt;
> 	register struct qstream *sp;
> 	register struct qdatagram *dqp;
> 	struct qstream *nextsp;
> 	int nfds;
> 	const int on = 1;
> 	int size;
> 	SOCKET rfd;
> 	time_t lasttime, maxctime;
> 	u_char buf[BUFSIZ];
> 	struct timeval t, *tp;
> 	fd_set tmpmask;
> 	struct qstream *candidate = QSTREAM_NULL;
>      /* would like to wait on the terminate even here. .but cannot find a way to declare
>         it volatile and it does not work .. so use the stupid doterminate flag */
> 
> 	hReadWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
> 	overlap.Offset = overlap.OffsetHigh = (DWORD)0;
> 	overlap.hEvent = hReadWriteEvent;
> 
> #endif /* WINNT */
> 
585a887,897
> 
> #ifdef WIN95 /* lgk need exit code for win95 since we don't stop the service to exit */
>     	/* test the terminate event and terminate if necessary */
> if (doterminate)
>           {
>  	    CloseHandle(hServDoneEvent);
>  	    syslog(LOG_INFO, "named95: service stopped");
> 	    ExitProcess(0);
> 	 }
> #endif
> 			  
593a906,908
> /* this should never be called from nt as the needendxfer is only set
>  * vai a call to reapchild in ns_maint.c through a signal
>  */
594a910
> #ifndef WINNT
597a914,917
> #else
>                 needendxfer = 0;
> 		syslog(LOG_ERR, "Needendxfer was Set under Windows NT... Shouldn't happen!");
> #endif
598a919,920
> 
> #ifndef WINNT 
599a922
> #endif
640a964
> #ifndef WINNT
641a966,968
> #else
> 		if (n < 0 && errno != WSAEINTR) {
> #endif
669a997,1004
> #if defined(WINNT) && defined(NOWAIT)
> 				if ((n ==1) && !strcmp(buf, "")) {
> 				/* dummy packet intended to terminate select
> 				 * because a control code has been received or
> 				 * needmaint flag has been set by the timer thread */
> 					break;
> 				}
> #endif
700a1036
> #ifndef WINNT
701a1038,1040
> #else
> 			if (rfd == INVALID_SOCKET && WSAGetLastError() == WSAEINTR)
> #endif
702a1042
> #ifndef WINNT
703a1044,1046
> #else
> 			if (rfd == INVALID_SOCKET && WSAGetLastError() == WSAEMFILE && streamq) {
> #endif
722a1066
> #ifndef WINNT
723a1068,1070
> #else
> 			if (rfd == INVALID_SOCKET) {
> #endif
726a1074
> #ifndef WINNT 
736a1085,1091
> #else
> 			if(ioctlsocket(rfd, FIONBIO, (u_long *)&on) == SOCKET_ERROR) {
> 				syslog(LOG_INFO, "ioctlsocket(rfd, NONBLOCK): %m");
> 				(void) my_close(rfd);
> 				continue;
> 			}
> #endif
815a1171
> #ifndef WINNT
816a1173,1176
> #else
>  			           (n = recv(sp->s_rfd, sp->s_bufp, size, 0)) >0
> 
> #endif
859a1220
> #ifndef WINNT
863a1225,1230
> #else
> 				  (n = recv(sp->s_rfd,
> 					sp->s_bufp,
> 					sp->s_size, 0)
> 			       ) > 0
> #endif
888a1256
> #ifndef WINNT
889a1258,1260
> #else
> 			if ((n == SOCKET_ERROR) && (errno == PORT_WOULDBLK))
> #endif
933a1305
> #ifndef WINNT /* nt dos not have this functionality so call our new fx */
937a1310,1321
> #else
> #ifndef WIN95
>         if (get_winnt_interfaces(&ifc) < 0)
> #else
>         if (get_win95_interfaces(&ifc) < 0)
> #endif
>          {
> 	   syslog(LOG_ERR, "get interface configuration: %m - exiting");
> 	   exit(1);
> 	}
> #endif
> 
947a1332
> #ifndef WINNT
948a1334,1337
> #else
>              
> 	     cp += sizeof (ifr->ifr_name) + my_size(ifr->ifr_addr) + sizeof(ifr->ifr_mask)) {
> #endif
950c1339
< 		ifr = (struct ifreq *)cp;
---
> 		 ifr = (struct ifreq *)cp;
961c1350
< #if !defined(BSD) || (BSD < 199103)
---
> #if (!defined(BSD) || (BSD < 199103)) && !defined(WINNT)
968c1357
< 			    inet_ntoa(((struct sockaddr_in *)
---
> 			    inet_ntoa(((struct sockaddr_in *)   
969a1359
> 
1025a1416
> #ifndef WINNT				
1036a1428,1433
> #else /* nt masks are supported */
>                    ntp->mask = inet_addr(ifreq.ifr_mask);
> #endif
> 
> #ifndef WINNT /* no interface flags on NT */
> 
1040a1438,1439
> #endif
> 
1056,1065d1454
< 		} else if ((ifreq.ifr_flags & IFF_POINTOPOINT)) {
< 			if (ioctl(vs, SIOCGIFDSTADDR, (char *)&ifreq) < 0) {
< 				syslog(LOG_NOTICE, "get dst addr: %m");
< 				continue;
< 			}
< 			ntp->mask = 0xffffffff;
< 			ntp->addr = ((struct sockaddr_in *)
< 				     &ifreq.ifr_addr)->sin_addr.s_addr;
< 		} else {
< 			ntp->addr = ntp->mask & ntp->my_addr.s_addr;
1066a1456,1474
> #ifndef WINNT /* no interface flags on NT */
>                      else if ((ifreq.ifr_flags & IFF_POINTOPOINT))
>                             {
> 			      if (ioctl(vs, SIOCGIFDSTADDR, (char *)&ifreq) < 0)
>                                 {
> 			    	   syslog(LOG_NOTICE, "get dst addr: %m");
> 				    continue;
> 			        }
> 			      ntp->mask = 0xffffffff;
> 		  	      ntp->addr = ((struct sockaddr_in *)
> 			   	          &ifreq.ifr_addr)->sin_addr.s_addr;
> 			    } else
>                             {
> 			     ntp->addr = ntp->mask & ntp->my_addr.s_addr;
> 			    }
> #else
> 			     ntp->addr = ntp->mask & ntp->my_addr.s_addr;
> 
> #endif
1127a1536,1542
> 	/* don't know how to get interface information on multihomed NT
> 	 * machines. I'm told that gethostbyname(gethostname()) should
> 	 * return all IP addresses of the local machine (except 127.0.0.1)
> 	 * but there still remains the question of netmasks and flags etc
> 	 * This whole issue needs to be addressed more thoroughly.
> 	 * Implications of this???
> 	 */
1173a1589
> #ifndef WINNT
1174a1591,1594
> #else
> 	if ((dqp->dq_dfd = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
> #endif
> 	 
1194a1615
> #ifndef WINNT
1201a1623,1627
> #else
> 	if(ioctlsocket(dqp->dq_dfd, FIONBIO, (u_long *)&on) == SOCKET_ERROR) {
> 		syslog(LOG_NOTICE, "ioctlsocket(dqp->dq_dfd, nonblocking): %m");
> 	}
> #endif
1220a1647
> #ifndef WINNT
1299a1727
> #endif /* WINNT */
1302c1730
< ** Turn on or off debuging by open or closeing the debug file
---
> ** Turn on or off debuging by open or closing the debug file
1314a1743
> #ifndef WINNT
1315a1745
> #endif
1327a1758
> #ifndef WINNT
1333a1765
> #endif /* WINNT */
1340a1773
> #ifndef WINNT
1444a1878,1879
> #endif /* WINNT */
> 
1547c1982
< 		FD_CLR(this->dq_dfd, &mask);
---
>  		FD_CLR(this->dq_dfd, &mask);
1668a2104,3108
> 
> 
> #ifdef WINNT
> /* service_ctrl - control handler for NTP service
>  * signals the service_main routine of start/stop requests
>  * from the control panel or other applications making
>  * win32API calls
>  */
> void
> service_ctrl(dwCtrlCode)
> 	DWORD dwCtrlCode;
> {
>     DWORD  dwState = SERVICE_RUNNING;
> 	int len;
> 
>     /* Handle the requested control code */
>     switch(dwCtrlCode) {
> 
>         case SERVICE_CONTROL_PAUSE:
> 		/* see no reason to support this */
> 		break;
> 
>         case SERVICE_CONTROL_CONTINUE:
>  		/* see no reason to support this */
>   		break;
> 
>         case SERVICE_CONTROL_STOP:
>             dwState = SERVICE_STOP_PENDING;
>             /* Report the status, specifying the checkpoint and waithint,
>              *  before setting the termination event.
>              */
> 			ServiceStatus.dwCurrentState = dwState;
> 			ServiceStatus.dwWin32ExitCode = NO_ERROR;
> 			ServiceStatus.dwWaitHint = 1000;
> 			if (!SetServiceStatus(hServiceStatus, &ServiceStatus)) {
> 				syslog(LOG_ERR, "SetServiceStatus(): %m");
> 			}
> 			was_stopped = 1;
>             SetEvent(hServDoneEvent);
>             return;
> 
>         case SERVICE_CONTROL_INTERROGATE:
>             	/* Update the service status */
> 			break;
> 
>         case SERVICE_CONTROL_DUMPDB:
>             needToDoadump = 1;
> 			break;
> 
>         case SERVICE_CONTROL_RELOAD:
> 			needreload = 1;
> 			break;
> 
>         case SERVICE_CONTROL_STATS:
> 			needStatsDump = 1;
> 			break;
> 
>         case SERVICE_CONTROL_TRACE:
> 			debug++;
> 			if (debug == 1)
> 				setdebug(1);
> 			fprintf(ddt, "Debug turned ON, Level %d\n", debug);
> 			break;
> 
>         case SERVICE_CONTROL_NOTRACE:
> 			setdebug(0);
> 			break;
> 
>         case SERVICE_CONTROL_QRYLOG:
> 			qrylog = !qrylog;
> 			syslog(LOG_NOTICE, "querylog %s\n", qrylog ? "on":"off");
> 			break;
> 
>         case SERVICE_CONTROL_CHKPT:
> 			needToChkpt = 1;
> 			break;
> 
>         case SERVICE_CONTROL_EXIT:
>  #ifdef XSTATS
>             needToExit = 1;
>  #endif
>         	was_stopped = 1;	
>             break;
> 
>         default:
>         	/* invalid control code */
> 			syslog(LOG_ERR, "invalid control code: %d", dwCtrlCode);
>             break;
> 
>     }
> 
> #ifdef NOWAIT
> 	if((len = sendto(datagramq->dq_dfd, (const char *)loopbuf, 1, 0,  (struct sockaddr *)&loopback,
> 	          sizeof(struct sockaddr_in))) == SOCKET_ERROR)
> 		syslog(LOG_ERR, "failed to send the control code immediately: %m");
>  
> #endif
> 
> 	ServiceStatus.dwCurrentState = dwState;
> 	ServiceStatus.dwWin32ExitCode = NO_ERROR;
> 	if (!SetServiceStatus(hServiceStatus, &ServiceStatus)) {
> 		syslog(LOG_ERR, "SetServiceStatus(): %m");
> 	}
> }
> 
> 
> /* Expand environmental variables in file pathnames */
> void expand_paths(void)
> {
>   FILE *fp;
> 
>         /* change name back to named.boot but for backwards compat. this fails go back to the
>            alternate name named.ini... unfort. since bootfile is passed a few layers down it
>            would be a pain to changeall these calls in the stock bind so attempt to open the
>            file here and decide which name to use */
>            
> 	pathtmpdir = (char *)malloc(MAX_PATH);
> 	pathsysdir = (char *)malloc(MAX_PATH);
> 
> #ifdef REGISTRY_PATHS
>     /* software.com specific */
> 	if (GetRegistryPath(MAX_PATH, pathtmpdir))
> 	  {
> 	    syslog(LOG_ERR, "GetRegistryPath() failed: %m");
> 	  }
> #else
> 	if (!GetTempPath(MAX_PATH, pathtmpdir))
> 		syslog(LOG_ERR, "GetTempPath() failed: %m");
> 
> 	if (!GetSystemDirectory((LPSTR)pathsysdir,MAX_PATH))
> 		syslog(LOG_ERR, "GetSystemDirectory() failed: %m");
>     strcat(pathsysdir,"\\");
> 
> #endif
> 
> #ifdef REGISTRY_PATHS
> 	}
>       	else
> 		syslog(LOG_INFO,"Get registry info okay: %s",pathtmpdir);
> 	/* software.com specific
> 	    PIW:  use the directory we found from the registry for ALL files
> 	          relating to the DNS:  */
> 	pathboot = (char *)malloc(MAX_PATH);
> 	strcpy(pathboot,pathtmpdir);
> 	strcat(pathboot,"NAMED.BOOT");
>     bootfile = pathboot;
> 
> 	pathpidfile = (char *)malloc(MAX_PATH);
> 	strcpy(pathpidfile,pathtmpdir);
> 	strcat(pathpidfile,"NAMED.PID");
> 
> 	pathxfer = (char *)malloc(MAX_PATH);
> 	strcpy(pathxfer,pathtmpdir);
> 	strcat(pathxfer,"NAMED.XFER");
> 
> #else /* don't use registry paths */
> 
> 	pathboot = (char *)malloc(MAX_PATH);
> 	if (!ExpandEnvironmentStrings(_PATH_BOOT, pathboot, MAX_PATH)) {
> 		syslog(LOG_ERR, "ExpandEnvironmentStrings(_PATH_BOOT) failed: %m\n");
> 	} else
>            {
> 	     if ((fp = fopen(pathboot, "r")) == NULL)
> 	       {
>                  /* try alternate name */
> 
> 	         if (!ExpandEnvironmentStrings(_ALT_PATH_BOOT, pathboot, MAX_PATH))
>                    {
> 		   syslog(LOG_ERR, "ExpandEnvironmentStrings(_ALT_PATH_BOOT) failed: %m\n");
> 	           }
>                   else bootfile = pathboot;
> 	       } /* else it opened ok so close it */
> 	      else
>                {
>                  fclose(fp);
>                  bootfile = pathboot;
>                }
>            }
>                
> 	pathpidfile = (char *)malloc(MAX_PATH);
> 	if (!ExpandEnvironmentStrings(_PATH_PIDFILE, pathpidfile, MAX_PATH))
>           {
> 	       syslog(LOG_ERR, "ExpandEnvironmentStrings(_PATH_PIDFILE) failed: %m\n");
> 	      } else PidFile = pathpidfile;
> 		 
> 	pathxfer = (char *)malloc(MAX_PATH);
> 	if (!ExpandEnvironmentStrings(_PATH_XFER, pathxfer, MAX_PATH))
>           {
> 	       syslog(LOG_ERR, "ExpandEnvironmentStrings(_PATH_XFER) failed: %m\n");
> 	      }
> #endif 
> 
> 	pathdebug = (char *)malloc(MAX_PATH);
> 	strcpy(pathdebug, pathsysdir);
> 	debugfile = strcat(pathdebug, _PATH_DEBUG);
> 	
> 	pathdumpfile = (char *)malloc(MAX_PATH);
> 	strcpy(pathdumpfile, pathsysdir);
> 	dumpfile = strcat(pathdumpfile, _PATH_DUMPFILE);
> 	 
> 	pathstats = (char *)malloc(MAX_PATH);
> 	strcpy(pathstats, pathsysdir);
> 	statsfile = strcat(pathstats, _PATH_STATS);
> 	 
> 	pathxfertrace = (char *)malloc(MAX_PATH);
> 	strcpy(pathxfertrace, pathtmpdir);
>     strcat(pathxfertrace, _PATH_XFERTRACE);
> 	
> 	pathxferddt = (char *)malloc(MAX_PATH);
> 	strcpy(pathxferddt, pathtmpdir);
> 	strcat(pathxferddt, _PATH_XFERDDT);
> }
> 
> /* software.com specific */
> #ifdef REGISTRY_PATHS
> 
> /*----------------------------------------------------------------------------------------
> /
> /	Function:		GetRegistryPath
> /
> /	Description:	given a char buffer to fill (and a max length allowed) look in the
> /					NT registry for the directory entry under Software.Com/DNS.
> /
> /	Returns:		0 means it worked, -1 if it didn't
> /
> /	History:		Paul W.		11/24/95	Created
> /
> /---------------------------------------------------------------------------------------*/
> static int GetRegistryPath(int max_len, char *directory)
> {
> 	HKEY hk;
> 	int bSuccess;
> 	DWORD dw_maxlen = max_len;
> 
>     /* get key for our application */
>     bSuccess = RegOpenKey(HKEY_LOCAL_MACHINE,"SOFTWARE\\ISC\\DomainNameService",&hk);
>     if (bSuccess != ERROR_SUCCESS)
>       {
>     	syslog(LOG_ERR, "Cannot open the default directory registry key: %m");
>     	return -1;
>       }
> 
>     bSuccess = RegQueryValueEx(hk,
>          "Directory",
>           NULL,
>           NULL,
>           (LPBYTE) directory,
>           &dw_maxlen);
>     if (bSuccess != ERROR_SUCCESS)
>       {
> 	    syslog(LOG_ERR, "Error in RegQueryValueEx fetching service name parameter: %m");
> 	    RegCloseKey(hk);
> 	    return -1;
>       }
> 
> 	if (directory[dw_maxlen-1] != '\\')	/* if the directory does NOT have a trailing backslash */
>  	  {  
> 		directory[dw_maxlen] = '\\';	/* put one on, and terminate a little longer */
> 		directory[dw_maxlen+1] = '\0';	/* terminate at given length plus slash-space */
> 	  }
> 	else
> 		directory[dw_maxlen] = '\0';	/* terminate at given length, already has slash */
> 		
>     RegCloseKey(hk);
> 	return 0;
> }
> #endif
> 
> #ifndef WIN95
> 
> /* ------------------------------------------------------------------------------------------------------------------ */
> /* written by l. kahn */
> /* modified with suggestions from Kevin Dunlap so we only pick out netcards bound to tcpip */
>   int get_winnt_interfaces(ifc)
> 
>     struct ifconf *ifc;
>     
> 
>   {
>         char *ifc_buffer = ifc->ifc_buf;
> 
>     	   struct ifreq *ifr;
>         HKEY hk, hksub;                      /* registry key handle */
>         BOOL bSuccess;
>         char newkey[200];
> 
>         char servicename[50];
>         DWORD sizeofservicename = 50;
>         int Done = 0;
>         
>         /* these need to be big as they are multi_sz in type and hold all ip addresses and subnet mask for a
>            given interface */
>         char IpAddresses[10000];
>         char *ipptr = IpAddresses;
>         DWORD sizeofipaddresses = 10000;
>         char SubNetMasks[10000];
>         char *subptr = SubNetMasks;
>         DWORD sizeofsubnetmasks = 10000;
>         char bindservicenames[1000];
>         DWORD sizeofbindnames = 1000;
> 
>        char oneIpAddress[16];
>        char oneSubNetMask[16];
>        int count = 0;
>        char *onenetcard;
> 
>     /* now get all the netcard values which are bound to tcpip */ 
> 
>     strcpy(newkey,"SYSTEM\\Currentcontrolset\\Services\\");
>     strcat(newkey,"tcpip\\linkage");
>        
>     bSuccess = RegOpenKey(HKEY_LOCAL_MACHINE,newkey,&hk);
>     if(bSuccess != ERROR_SUCCESS)
>     {
>         syslog(LOG_ERR, "failed to Open TCP/IP Linkage Registry key: %m");
>         dprintf(1, (ddt, "Cannot get TCP/IP Linkage from registery.\n"));
>         return -1;
>     }
> 
>     /* now get the bind value */
>         sizeofbindnames = 1000;
>         bSuccess = RegQueryValueEx(hk,     /* subkey handle         */
>         "Bind",                            /* value name            */
>         NULL,                              /* must be zero          */
>         NULL,                              /* value type          not required  */
>         (LPBYTE) &bindservicenames,        /* address of value data */
>         &sizeofbindnames);                 /* length of value data  */
>         if(bSuccess != ERROR_SUCCESS)
>         {
>             syslog(LOG_ERR, "Error in RegQueryValueEx fetching Bind Service names parameter: %m");
>             RegCloseKey(hk);
>             return -1;
>         }
> 
> 
>     /* now loop through and get all the values which are bound to tcpip */ 
>     /* we can also close the key here as we have the values now */
>     RegCloseKey(hk);
>     onenetcard = bindservicenames;
>     while(1)
>     {
> 
>        onenetcard = onenetcard + 8;
>        if  ((onenetcard < (bindservicenames + sizeofbindnames)) &&
>            (sscanf(onenetcard,"%s",servicename) != EOF))
>          {
>             onenetcard+= strlen(servicename) + 1;
>          }
>         else { /* no more */
>                break;
>              }
> 
>         /* skip services that are NDISWAN... since these are temporary interfaces like ras and if we bind to these
>            we would have to check if the socket is still ok everytime before using it as when the link goes down
>            and comes back up the socket is no longer any good... and the server eventually crashes if we don't check
>            this.. and to check it entails a lot of overhead... shouldn't be a problem with machines with only a RAS
>            interface anyway as we can bind to the loopback or 0.0.0.0 */
> 
>         if ((strlen(servicename) >= 7) && (strncmp(strupr(servicename),"NDISWAN",7) == 0))
>           {
>             /* skip it */
> 	    dprintf(1, (ddt, "Skippping temporary interface [%s]\n",servicename));
>           }
>         else {
>   
>            /* if opening this key fails we can assume it is not a network card ie digiboard and go on.. */
>            /* ok now that we have the service name parameter close the key and go get the ipaddress and subnet mask */
> 
>            strcpy(newkey,"SYSTEM\\Currentcontrolset\\Services\\");
>            strcat(newkey,servicename);
>            strcat(newkey,"\\parameters\\tcpip");
> 
>            bSuccess = RegOpenKey(HKEY_LOCAL_MACHINE,newkey,&hksub);
>            if(bSuccess != ERROR_SUCCESS)
>             {
>               dprintf(1, (ddt, "Skipping interface [%s] ... It is not a network card.\n",servicename));
>             }
> 
>            else { /* ok it is a network card */            
>            /* ok now get the ipaddress and subnetmask */
>            sizeofipaddresses = 10000;
>            bSuccess = RegQueryValueEx(hksub,  /* subkey handle         */
>            "IpAddress",                       /* value name            */
>             NULL,                             /* must be zero          */
>             NULL,                             /* value type          not required  */
>             (LPBYTE) &IpAddresses,               /* address of value data */
>             &sizeofipaddresses);                /* length of value data  */
>             if(bSuccess != ERROR_SUCCESS)
>               {
>                syslog(LOG_ERR, "Error in RegQueryValueEx fetching IpAddress parameter: %m");
>                RegCloseKey(hksub);
>                return -1;
>               }
>            /* ok now get the ipaddress and subnetmask */
>            sizeofsubnetmasks = 10000;
>            bSuccess = RegQueryValueEx(hksub,  /* subkey handle         */
>            "SubNetMask",                      /* value name            */
>             NULL,                             /* must be zero          */
>             NULL,                             /* value type          not required  */
>             (LPBYTE) &SubNetMasks,              /* address of value data */
>             &sizeofsubnetmasks);               /* length of value data  */
>             if(bSuccess != ERROR_SUCCESS)
>               {
>                syslog(LOG_ERR, "Error in RegQueryValueEx fetching SubNetMask parameter: %m");
>                RegCloseKey(hksub);
>                return -1;
>               }
> 
>           RegCloseKey(hksub);
>           /* ok now that we have some addresses and subnet masks go through each one and add to our structure... */
>           /* multi_sz strings are terminated by two \0 in a row */
> 
> 
>         ipptr = IpAddresses;
>         subptr = SubNetMasks;
>         Done = 0;
>         while (!Done)
>         {
>          ifr = (struct ifreq *)ifc_buffer;
>          if (sscanf(ipptr,"%s",oneIpAddress) != EOF)
>            ipptr+= strlen(oneIpAddress) + 1; /* add one for terminator \0 */
>          else Done = 1;
>          
>          if (sscanf(subptr,"%s",oneSubNetMask) != EOF)
>            subptr += strlen(oneSubNetMask) + 1;
>          else Done = 1;
> 
>          /* now add to interface structure */
>          if (!Done)                  
>           {
>            ifr->ifr_addr.sa_family = AF_INET;
>            ((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr.s_addr = inet_addr(oneIpAddress);
>            strcpy(ifr->ifr_mask,oneSubNetMask);
> 
>            if (strlen(servicename) > 15)
>              strncpy(ifr->ifr_name,servicename,15);
>            else strcpy(ifr->ifr_name,servicename);
> 
>            /* now increment pointer */
> 	       ifc_buffer += sizeof (ifr->ifr_name) + sizeof(ifr->ifr_addr) + sizeof(ifr->ifr_mask);
>            ++count;
>            if (((char *)ipptr == '\0') || ((char *)subptr == '\0')) 
>              Done = 1;
>           }
>           
>         }
>            } /* it is a network card */
>         } /* it is/not a temporary ndiswan name */ 
>     } /* end of loop  */
> 
>     /* now reset the length */
>     ifc->ifc_len = count * (sizeof(ifr->ifr_name) + sizeof(ifr->ifr_addr) + sizeof(ifr->ifr_mask));
>     return 0;
> }
> 
> 
> #else // win95 version
> 
>   /* By Leon McCalla to get tcpip bound to netcards on 95*/
>   /* modified by l. kahn */
>   int get_win95_interfaces(ifc)
>   struct ifconf *ifc;
> 
>   {
> 	char *ifc_buffer = ifc->ifc_buf;
> 	struct ifreq *ifr;
> 
>      HKEY hk, dk, rk, ck;                      /* registry key handle */
>      BOOL bSuccess;
>      char realkey[200];
>      DWORD sizeofrealkey = 200;
>      char netkey[50];
>      DWORD sizeofnetkey = 50;
>      char newkey[50];
>      DWORD sizeofnewkey = 50;
>      char driverkey[50];
>      DWORD sizeofdriverkey = 50;
>      char nettype[50];		
>      DWORD sizeofnettype = 50;
>      char subkey[50];
>      DWORD sizeofsubkey = 50;
>      char checkkey[50];
>      DWORD sizeofcheck = 50;
>      int Done = 0;
>      int Done2 = 0;
> 
>      /* these need to be big as they are multi_sz in type and hold all ip addresses and subnet mask for a
>         given interface */
>      char IpAddresses[10000];
>      char *ipptr = IpAddresses;
>      DWORD sizeofipaddresses = 10000;
>      char SubNetMasks[10000];
>      char *subptr = SubNetMasks;
>      DWORD sizeofsubnetmasks = 10000;
> 
>      char oneIpAddress[16];
>      char oneSubNetMask[16];
>      int count = 0;
>      int ipcount = 0;
> 
>     /* now get all the netcard (ie 0001) ..._  values which are bound to tcpip */ 
> 
>     strcpy(newkey,"ENUM\\Network\\MSTCP");
>     bSuccess = RegOpenKey(HKEY_LOCAL_MACHINE,newkey,&hk);
>     if(bSuccess != ERROR_SUCCESS)
>     {
>         syslog(LOG_ERR, "failed to Open MSTCP network Registry key: %m");
>         dprintf(1, (ddt, "Cannot get MSTCP network linkage from registery.\n"));
>         return -1;
>     }
> 
>      while (!Done)
>        {
> 	    sizeofnetkey = 50;
> 	     bSuccess = RegEnumKey(hk, (DWORD)count, (LPTSTR)netkey, sizeofnetkey);
> 	     if(bSuccess == ERROR_NO_MORE_ITEMS)
> 		  {
> 			Done = TRUE;
>                         break;
>                   }
> 	
> 	     if ((bSuccess != ERROR_SUCCESS) && (bSuccess != ERROR_NO_MORE_ITEMS))
> 		   {
>                         syslog(LOG_ERR, "Error in RegEnumKey fetching network card keys from registry: %m");
> 			RegCloseKey(hk);
> 			return -1;
> 		   }
> 
>         ++count;
>      
> 	 /* now the devicedesc here does not specify the dial up so we must get the
>             last part off the key and try the key enum//root//net//netkey   */
> 
>          strcpy(checkkey,"ENUM\\Root\\Net\\");
>          strcat(checkkey,netkey);
> 
>        /* not sure if this works but on my eisa machine these were not there
>           so if they are not there assume they are not temporary .. ie enum\eisa
>           for eisa cards instead of enum\\root but I imagine all ras interfaces are like this
>           above.. so if not there it is not a ras temporary interface */
> 
> 	 // get the check value
> 	 /*check for Dial up adapter*/
>  	 bSuccess = RegOpenKey(HKEY_LOCAL_MACHINE,checkkey,&ck);
>         if(bSuccess != ERROR_SUCCESS)
> 	  {
>            strcpy(nettype,"dummy");
> 	  }
> 
>       else
>       {
>       // now get the value
> 	 sizeofnettype = 50;
> 	 bSuccess = RegQueryValueEx(ck,     /* subkey handle         */
> 	         "DeviceDesc",              /* value name            */
> 		    NULL,                   /* must be zero          */
> 		    NULL,                   /* value type          not required  */
>               (LPBYTE) &nettype,            /* address of value data */
>               &sizeofnettype);              /* length of value data  */
> 
>       RegCloseKey(ck); // not needed anymore either way
>       if(bSuccess != ERROR_SUCCESS)
>           {
>            strcpy(nettype,"dummy");
>           }
>       } // not there
> 
>       // go on
> 	 if (strncmp(strupr(nettype),"DIAL-UP ADAPTER",15) == 0)
>           {
>            /* skip it */
>   	   dprintf(1, (ddt, "Skippping temporary interface [%s]\n",nettype));
>           }
> 
>          else { // is not temporary interface
>             // ok get drivername
> 
> 	// get the Driver value
> 	/*now we have the values so we need to get the driver value for the key */
> 	strcpy(driverkey,"ENUM\\Network\\MSTCP\\");
> 	strcat(driverkey,netkey);
> 
> 
> 	bSuccess = RegOpenKey(HKEY_LOCAL_MACHINE,driverkey,&dk);
> 	if(bSuccess != ERROR_SUCCESS)
> 	  {
>            char temp[300];
>            sprintf(temp,"Can not open key [%s] from the registry \n",driverkey);
>            syslog(LOG_ERR, temp);
>            RegCloseKey(hk);
>            return -1;
> 	   }
> 
>             // ok get drivername
> 		sizeofsubkey = 50;
> 		bSuccess = RegQueryValueEx(dk,     /* subkey handle         */
> 	  	      "Driver",                    /* value name            */
> 		      NULL,                        /* must be zero          */
> 		      NULL,                        /* value type          not required  */
> 		      (LPBYTE) &subkey,            /* address of value data */
> 		      &sizeofsubkey);              /* length of value data  */
> 
>           if(bSuccess != ERROR_SUCCESS)
> 		  {
> 		    syslog(LOG_ERR,"Error in RegQueryValueEx fetching Driver value: %m \n");
> 		    RegCloseKey(dk);
> 		    RegCloseKey(hk);
> 		    return -1;
> 		  }
> 
>           RegCloseKey(dk); //driver key not needed any longer
> 
>           // now open the real key
> 	     strcpy(realkey,"SYSTEM\\CurrentControlSet\\Services\\Class\\");
> 	     strcat(realkey,subkey);
> 	     
> 	     bSuccess = RegOpenKey(HKEY_LOCAL_MACHINE,realkey,&rk);
> 	     if(bSuccess != ERROR_SUCCESS)
> 		 {
> 		   char temp[300];
> 		   sprintf(temp,"Error opening real network key [%s].\n",realkey);
>                    syslog(LOG_ERR, temp);
> 		   RegCloseKey(hk);
>                    return -1;
> 		}
>         
>            sizeofipaddresses = 10000;
>            bSuccess = RegQueryValueEx(rk,     /* subkey handle         */
>                 "IPAddress",                  /* value name            */
>                  NULL,                        /* must be zero          */
>                  NULL,                        /* value type          not required  */
>                  (LPBYTE) &IpAddresses,       /* address of value data */
>                  &sizeofipaddresses);         /* length of value data  */
> 
>            if(bSuccess != ERROR_SUCCESS)
>               {
>                syslog(LOG_ERR,"Error in RegQueryValueEx fetching IPAddress parameter! %m \n");
>                RegCloseKey(rk);
>                RegCloseKey(hk);
>                return -1;
>               }
>               
>            /* ok now get the subnetmask */
>            sizeofsubnetmasks = 10000;
>            bSuccess = RegQueryValueEx(rk,     /* subkey handle         */
>               "IPMask",                       /* value name            */
>                NULL,                          /* must be zero          */
>                NULL,                          /* value type          not required  */
>                (LPBYTE) &SubNetMasks,         /* address of value data */
>                &sizeofsubnetmasks);           /* length of value data  */
>    
>            if(bSuccess != ERROR_SUCCESS)
>               {
>                syslog(LOG_ERR,"Error in RegQueryValueEx fetching IPMask parameter! %m\n");
>                RegCloseKey(rk);
>                RegCloseKey(hk);
>                return -1;
>               }
> 
>           RegCloseKey(rk);
>           /* ok now that we have some addresses and subnet masks go through each one and add to our structure... */
>           /* multi_sz strings are terminated by two \0 in a row */
> 
>         ipptr = IpAddresses;
>         subptr = SubNetMasks;
>         Done2 = 0;
>         while (!Done2)
>         {
>          ifr = (struct ifreq *)ifc_buffer;
>          if (sscanf(ipptr,"%s",oneIpAddress) != EOF)
>            ipptr+= strlen(oneIpAddress) + 1; /* add one for terminator \0 */
>          else Done2 = 1;
>          
>          if (sscanf(subptr,"%s",oneSubNetMask) != EOF)
>            subptr += strlen(oneSubNetMask) + 1;
>          else Done2 = 1;
> 
>          /* now add to interface structure */
>          if (!Done2)                  
>           {
>            ifr->ifr_addr.sa_family = AF_INET;
>            ((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr.s_addr = inet_addr(oneIpAddress);
>            strcpy(ifr->ifr_mask,oneSubNetMask);
> 
>            // subkey is the closest thing to a service name under win95
>            if (strlen(subkey) > 15)
>              strncpy(ifr->ifr_name,subkey,15);
>            else strcpy(ifr->ifr_name,subkey);
> 
>            /* now increment pointer */
> 	       ifc_buffer += sizeof (ifr->ifr_name) + sizeof(ifr->ifr_addr) + sizeof(ifr->ifr_mask);
>            ++ipcount;
>            if (((char *)ipptr == '\0') || ((char *)subptr == '\0')) 
>              Done2 = 1;
>              
>           } // if
> 	    } // not done2 loop
>         } // not temporary interface
>        } // loop (while) through more things bound to MSTCP
> 
>     RegCloseKey(hk); // done with top while so close key
> 
>     /* now reset the length */
>     ifc->ifc_len = ipcount * (sizeof(ifr->ifr_name) + sizeof(ifr->ifr_addr) + sizeof(ifr->ifr_mask));
> 
>     return 0;
>   }
> 
> // ndc_thread ... wait for ndc commands.. works both under nt and win95
> // there will be a ndc95 command
> // l. kahn.. this is needed for win95 port because there are no services and
> // we cannot use sevice api's
> // becuase the damn mailslots sendning more than once due to  how many network
> // transports you have bound we must use and id.. to make sure we are not doing the
> // same command twice..
> // also named pipes do not work.. since win95 does not support them.. so switched
> // to mail slots... also security api's don't work on win95
> // cant use this under nt even though originally designed also to work under nt.. 
> // actually it works under nt but the security doesn't so anyone can shut down your server etc.
> // this is acceptable for win95 where there is no security but not for nt..
> //when monitoring the code on win95 noticed 100% cpu utilization. Apparently the
> //readfile api on a mailslot even with timeout set to infinite does a
> //busy wait... to get around this did a loop with getmailslotinfo and my
> //own sleep statement.... this worked but then decided to try waitforsingleobject
> //(the correct call to use) even though the documentation specifically fails
> //to mention this working on mailslot handles.. appparently it works so
> //using this method..
> // back to using the getmailslotinfo  with sleep solution.. not the prettiest..
> 
> 
> 
> VOID
> ndc_thread(VOID *notUsed)
> {
>     char                 inbuf[120];
>     char                 outbuf[60];
>     BOOL                 ret;
>     BOOL                 bad_code;
>     DWORD                bytesRead;
>     DWORD                bytesWritten;
>     char                 command[40];
>     char                 mbname[20];
>     char                 outname[80];
>     char                 machname[40];
>     int                  len;
>     SOCKET               s;
>     HANDLE               slotHandle;
>     HANDLE               outslot;
>     DWORD                id, lastid;
>     DWORD                wcount;
>     BOOL                 onefound;
>     BOOL                 fResult;
>     
> // only do the event here if win95 as done elsewhere in nt
> #ifdef WIN95
>     
> 		/* create an event object that the control handler function
> 	 	* will signal when it receives the "stop" control code */
> 		if (!(hServDoneEvent = CreateEvent(
>         				NULL,    /* no security attributes */
>         				FALSE,   /* auto-reset event */
>         				FALSE,   /* not-signalled */
>         				NULL))){ /* no name */
> 				syslog(LOG_ERR, "CreateEvent() failed: %m");
> 				return;
>     	}
> 
> #endif
> 
> #ifdef NOWAIT
> 	loopback.sin_family = AF_INET;
> 	loopback.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
> 	loopback.sin_port = local_ns_port;
> #endif
> 
> 
>     // open our mail slot
>     //    
>     slotHandle = CreateMailslot(
>                     "\\\\.\\mailslot\\sd_bind",0,INFINITE,NULL);
> 
>     if (!slotHandle)
>       {
>        syslog(LOG_ERR, "CreateMailSlot for ndc communications failed: %m");
>        exit(1);
>       }
> 
>     // okay, our pipe has been created, let's enter the simple
>     //  processing loop...
>     //
>     
>     id = 0;
>     lastid = 0;
>     while (1) {
> 
> 
>         // bug in readfile here.. under win95 even with timeout set to infinite this is a busy wait
>         // consuming 100% of cpu so try getmail slot info with sleep statement
>         // actually use waitforsingleobject which is the correct way even
>         // though the documentation on this api does not mention mailslots
>         // as a handle you can wait on.. apparently it does become signaled
>         // and can be used. ..
>         
> 
>         onefound = FALSE;
>         wcount = 0;
>         while (!onefound)
> 
>          {
> 
>            fResult = GetMailslotInfo(slotHandle, /* mailslot handle         */ 
>                          (LPDWORD) NULL,              /* no maximum message size */ 
>                          (LPDWORD) NULL,              /* size of next message    */ 
>                          &wcount,                     /* number of messages      */ 
>                          (LPDWORD) NULL);             /* no read time-out        */ 
>  
>            if (!fResult)
>              { 
>                syslog(LOG_ERR,"Error in GetMailSlotInfo: %m");
>                Sleep(5000);
>                continue;
>              } 
> 
>            if (wcount > 0)
>                onefound = TRUE;
>            else Sleep(5000);
> 
>          } // end of one found loop
>          
>         // grab whatever's coming through the slot...
>         //
>         strcpy(inbuf,"                                           ");
>         strcpy(command,"                     ");
>         bad_code = FALSE;
>         bytesRead = 0;
>         ret = ReadFile(
>                     slotHandle,     // file to read from
>                     &inbuf,         // address of input buffer
>                     sizeof(inbuf),  // number of bytes to read
>                     &bytesRead,     // number of bytes read
>                     NULL);          // overlapped stuff, not needed
> 
>         if ((!ret) || (bytesRead == 0))
>            continue;
>             // .. go back and reconnect
>             //
> 
>         // ok now check which mailbox to send message back to either sd_ndc or sd_ndcpl
> 
>           sscanf(inbuf,"%s %s %s %d",machname,mbname,command,&id);
>           // now check if same as last time and if so skip it..
>           
> 	  if (debug > 0)
> 	     { // for debugging
>               char temp[100];
>               sprintf(temp,"NDC remote command \"%s\" from machine %s with id %d reply to %s\n",command,machname,id,mbname);
>  	      dprintf(1, (ddt,temp));
> 	     } 
>           
> 	   if (id == lastid)
>              continue;
> 
>           lastid = id;
>           strcpy(outbuf,"Ok"); // need some return so other pipe stops waiting
> 
>        // start and restart are handled by ndc ...
>        if (strncmp(command,"stop",4) == 0)
>          {
>  #ifdef XSTATS
>             needToExit = 1;
>  #endif
> 
>             was_stopped = 1;
>             doterminate = 1;
>             SetEvent(hServDoneEvent);
>          }
> 
>        else if (strncmp(command,"status",6) == 0)
> 		  { // returning that we are running ok
> 			  char temp[40];
>           
> 			  sprintf(temp,"Query log %s. ",qrylog ? "on":"off");
> 			  strcpy(outbuf,temp);
> 			  
> 			  if (debug > 0) sprintf(temp,"Debug Level %d enabled.",debug);
> 			  else  sprintf(temp,"Debuging Off!");
> 			  strcat(outbuf,temp);
> 			  
>           }
> 
>        else if (strncmp(command,"dumpdb",6) == 0)
>          {
>           needToDoadump = 1;
>          }
> 
>        else if (strncmp(command,"reload",6) == 0)
>          {
> 	  needreload = 1;
>          }
> 
>        else if (strncmp(command,"stats",5) == 0)
>          {
> 	   needStatsDump = 1;
>          }
> 
>        else if (strncmp(command,"trace",5) == 0)
>          {
> 	   debug++;
> 	   if (debug == 1)
> 	     setdebug(1);
> 	   fprintf(ddt, "Debug turned ON, Level %d\n", debug);
>          }
> 
>        else if (strncmp(command,"notrace",7) == 0)
>          {
> 	   setdebug(0);
>          }
> 
>        else if (strncmp(command,"querylog",8) == 0)
>          {
> 	   qrylog = !qrylog;
> 	   syslog(LOG_NOTICE, "querylog %s\n", qrylog ? "on":"off");
>          }
> 
>        else if (strncmp(command,"qrylog",6) == 0)
>          {
> 	   qrylog = !qrylog;
> 	   syslog(LOG_NOTICE, "querylog %s\n", qrylog ? "on":"off");
>          }
> 
>        else
>        {
>  	    syslog(LOG_ERR, "invalid control code: %s", command);
>          bad_code = TRUE;
>        }
>        
> #ifdef NOWAIT
> 
>         // also don't do this for status as nothing is pending
>         if ((!bad_code) && (strncmp(command,"status",6) != 0))
>          {
>  	  
>              	if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
>                  {
> 			    syslog(LOG_ERR, "socket for nowait: %m");
> 		       }
> 
>                else
>                {
>                if (connect(s, (struct sockaddr *)&loopback, sizeof(loopback)) < 0) 
> 				syslog(LOG_ERR,
> 				       "connect for nowait (%s) for failed: %m",
> 				       inet_ntoa(loopback.sin_addr));
> 
>                else 
>                {  
>                  if((len = sendto(s, (const char *)loopbuf, 1, 0, (const struct sockaddr *)&loopback,
> 	             sizeof(struct sockaddr_in))) == SOCKET_ERROR)
> 		        syslog(LOG_ERR, "failed to send the control code immediately: %m");
>                }
>                (void) closesocket(s);
>                }
>          }
> #endif
> 
>           // now open the out mailbox and write response .. if it fails ignore
>           strcpy(outname,"\\\\");
>           strcat(outname,machname);
>           strcat(outname,"\\mailslot\\");
>           strcat(outname,mbname);
>        
>           outslot = CreateFile(outname,GENERIC_WRITE,FILE_SHARE_READ,NULL,OPEN_EXISTING,
>                                FILE_ATTRIBUTE_NORMAL,NULL);
> 
>           if (outslot == INVALID_HANDLE_VALUE)
>             {
>               char temp[200];
>               sprintf(temp,"Cannot open outgoing mailslot: %s ... response was %s !\n",outname,outbuf);
>               syslog(LOG_WARNING,temp);                    
>             }
>           else { // write data
> 
>           ret = WriteFile(
>                     outslot,     // file to write to
>                     &outbuf,         // address of output buffer
>                     strlen(outbuf) + 1, // number of bytes to write
>                     &bytesWritten,  // number of bytes written
>                     NULL);          // overlapped stuff, not needed
> 
>           if (!ret)
>             // failed... go back and reconnect
>             //
>             continue;
>         // close handle...
>         //
>         CloseHandle(outslot);
> 
>        }
>     } // end of loop
> }
> 
> #endif // win95
> 
> 
> #endif /* WINNT */
diff --recurs m:\bind494rel/named/ns_maint.c m:\bind/named/ns_maint.c
22,26c22,26
<  * 	This product includes software developed by the University of
<  * 	California, Berkeley and its contributors.
<  * 4. Neither the name of the University nor the names of its contributors
<  *    may be used to endorse or promote products derived from this software
<  *    without specific prior written permission.
---
>  *      This product includes software developed by the University of
>  *      California, Berkeley and its contributors.
>  * 4. Neither the name of the University nor the names of its contributors
>  *    may be used to endorse or promote products derived from this software
>  *    without specific prior written permission.
28,31c28,31
<  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
<  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
<  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
---
>  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
>  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
>  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
60a61
> #ifndef WINNT
64a66
> #endif
66a69
> #ifndef WINNT
67a71
> #endif
68a73
> #ifndef WINNT
69a75
> #endif
76a83
> #ifndef WINNT
77a85,87
> #else
> # include <sys/utime.h>
> #endif
80,81c90,91
< static int		xfers_running,	/* # of xfers running */
< 			xfers_deferred,	/* # of needed xfers not run yet */
---
> static int              xfers_running,  /* # of xfers running */
> 			xfers_deferred, /* # of needed xfers not run yet */
83c93
< 			alarm_pending,	/* flag */
---
> 			alarm_pending,  /* flag */
86c96
< static void		startxfer __P((struct zoneinfo *)),
---
> static void             startxfer __P((struct zoneinfo *)),
91c101
< #define	qserial_qfull()	(qserials_running == MAXQSERIAL)
---
> #define qserial_qfull() (qserials_running == MAXQSERIAL)
94c104
< static time_t cache_time;
---
> static time_t cache_time = 0;
97c107
< static time_t stats_time;
---
> static time_t stats_time = 0;
98a109,182
> 
> #ifdef WINNT
> /* lgk since timer resolution on nt (at least my box) only goes to 1000 seconds
>  * our method using mmedia times is no good therefore use a thread that
>  * we create that sleeps the timeout period and then when done calls maint_alarm
>  * and exits...
>  * lgk dec. 95 change again to use a waitforsingleobject on an event for the specified
>  * timeout instead of sleep so it can be signaled with a reschedule request..
>  */
>     
> DWORD pending_delay = 0;
> volatile HANDLE rescheduleevent = 0x00;
> DWORD threadid;
> HANDLE threadhandle = 0x00;
> HANDLE threadhandle2 = 0x00;
> static void named_xfer __P((HANDLE *));
> static void CALLBACK maint_alarm __P((UINT,UINT,DWORD,DWORD,DWORD));
> extern CRITICAL_SECTION protected_zp;
> extern CRITICAL_SECTION maint_section;
> volatile BOOLEAN maint_thread_running = FALSE;
> 
> DWORD thread_timer_fx(DWORD timeout)
>   {
> 
>     DWORD rvalue;
> 
>     /* now wait on the handle */
>     rvalue = WaitForSingleObject(rescheduleevent,timeout);
> 
>     /* now check reason we woke up */
>     switch (rvalue)
>      {
> 
>       case WAIT_FAILED:
>         dprintf(1, (ddt, "Wait for thread timer event object failed!\n")); 
>         syslog(LOG_ERR, "Wait for thread timer event object failed!");
>         EnterCriticalSection(&maint_section);
>         maint_thread_running = FALSE;
>         LeaveCriticalSection(&maint_section);
>         ExitThread(0);
>         break;
>       
>       case WAIT_OBJECT_0:
>         dprintf(1, (ddt, "In Maintenance thread... current thread is exiting for reschedule request!\n"));
>         /* don't set thread running to false here as by the time this gets hit and the
>            thread terminates we may overwrite someone else setting it to true */
>         ExitThread(0);
>         break;
> 
>       case WAIT_TIMEOUT:
>         dprintf(1, (ddt, "In Maintenance thread... timer has expired!\n"));
>         break;
>       
>       default:
>         dprintf(1, (ddt, "Unknown return type from WaitForSingleObject in thread_timer_fx (%d)!\n",rvalue));
>         syslog(LOG_ERR, "Unknown return type from WaitForSingleObject in thread_timer_fx (%d)!\n",rvalue);
>         EnterCriticalSection(&maint_section);
>         maint_thread_running = FALSE;
>         LeaveCriticalSection(&maint_section);
>         ExitThread(0);
>         break;
>       
>      }
> 
>     EnterCriticalSection(&maint_section);
>     maint_thread_running = FALSE;
>     LeaveCriticalSection(&maint_section);
>     maint_alarm(0,0,0,0,0);
>     return 0;
> }
> 
> 
> #endif /* WINNT */
> 
112d195
< 
114d196
< 
120a203,205
>                 dprintf(1, (ddt, "debug tt.tv_sec = %d , zp->z_time = %d, zp->z_refresh = %d \n",
>                                  tt.tv_sec,zp->z_time, zp->z_refresh));
>                 dprintf(1, (ddt, "want tv_sec > = z_time and z_refresh > 0 \n"));
144a230
> 				        dprintf(1, (ddt, "calling abort\n"));
167c253,254
< 	if ((cache_time + cache_interval) <= tt.tv_sec) {
---
> 	if ((cache_time + cache_interval) <= tt.tv_sec)
> 	  {
169c256
< 			remove_zone(hashtab, 0, 0);
---
> 		  remove_zone(hashtab, 0, 0);
171c258
< 	}
---
> 	  }
174c261,263
< 	if (stats_time + stats_interval <= tt.tv_sec) {
---
>     dprintf(1, (ddt, "\nns_maint(); stats interval is %d\n",stats_interval));
> 	if (stats_time + stats_interval <= tt.tv_sec)
> 	  {
176c265
< 			ns_logstats();
---
> 		  ns_logstats();
178c267
< 	}
---
> 	  }
181c270
< 		sched_maint();
---
> 	  sched_maint();
192a282
> #ifndef WINNT
194c284,287
< #ifdef	CLEANCACHE
---
> #else
> 	DWORD wDelay;
> #endif
> #ifdef  CLEANCACHE
199c292
< 	static time_t next_alarm;
---
> 	static time_t next_alarm  ;
205c298
<         /*
---
> 	/*
209c302,304
< 	bzero((char *)&ival, sizeof ival);
---
> #ifndef WINNT
> 	bzero((char *)&ival, sizeof (ival));
> #endif
220a316
> #ifndef WINNT
223a320,324
> #else
> 		wDelay = (next_refresh - tt.tv_sec) * 1000;
> 		if ((long) wDelay < (maint_interval * 1000))
> 			wDelay = maint_interval * 1000;
> #endif
226a328
> #ifndef WINNT
229a332,385
> #else
>       /* lgk under my h/w for nt maximum timer values are 1000 seconds... the above values are not for resolution
>        * as the original author supposed but for the minimum and maximum timer values that mm timers supports..
>        * and since they don't supprt 1 hour... the create of the timer object was failing... therefore the only
>        * way I figured out to do this was create a thread that sleeps for the timeout and then waits up and calls
>        * maint alarm... seems to work ok now... 
>        * lgk dec. 95 change again to use a waitforsingleobject on an event for the specified
>        * timeout instead of sleep so it can be signaled with a reschedule request..
>        */
> 
>        /* lgk 12/95 there is a problem here were it tries to reschedule
>           when a timer thread is already running... under nt now see comment above */
> 
>       if (rescheduleevent == 0x00)
>         {
>           if ((rescheduleevent = CreateEvent(NULL,TRUE,FALSE,NULL)) == 0x00)
>             {
>              syslog(LOG_ERR,"Error: Couldn't create the maint. reschedule event object!");
>              dprintf(1, (ddt, "Error: Couldn't create the maint. reschedule event object!"));
>              return;
>             }
>         }
> 
>       /* first check if already one running */
>       EnterCriticalSection(&maint_section);
>       
>       if (maint_thread_running)
>         { /* ok now check if we have a smaller time */
>           dprintf(1,(ddt,"sched_maint: Rescheduling maint. from %d sec to %d sec.\n",pending_delay/1000,wDelay/1000));
>           /* signal other waiting thread to exit */
>           PulseEvent(rescheduleevent);
>         }
> 
>        maint_thread_running = TRUE;
> 
>        if (threadhandle != 0x00)
>          CloseHandle(threadhandle );
>        /* reset the event */
>        ResetEvent(rescheduleevent);   
> 
>        threadhandle = NULL;
>        threadhandle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)thread_timer_fx,(LPVOID)wDelay,0,&threadid);
> 
>        if (threadhandle == NULL)
> 	     {
>            syslog(LOG_ERR, "CreateThread() for maintenance: %m");
> 	     }
> 
>        
>        pending_delay = wDelay;
>  	   dprintf(1, (ddt, "sched_maint: Next interrupt in %d sec\n",wDelay/1000));
>        LeaveCriticalSection(&maint_section);
> 
> #endif
293c449
< 		syslog(LOG_INFO, "qserial_query(%s): sysquery FAILED",
---
> 		syslog(LOG_WARNING, "qserial_query(%s): sysquery FAILED",
295c451
< 		return;		/* XXX - this is bad, we should do something */
---
> 		return;         /* XXX - this is bad, we should do something */
316c472
< 	qp->q_flags &= ~Q_ZSERIAL;	/* keeps us from being called twice */
---
> 	qp->q_flags &= ~Q_ZSERIAL;      /* keeps us from being called twice */
356a513
> #ifndef WINNT
382a540
> #endif
407c565,568
< 	int argc = 0, argc_ns = 0, pid, i;
---
> 	int argc = 0, argc_ns = 0, i;
> #ifdef WINNT
> 	extern char *pathxferddt, *pathxfertrace;
> #endif
414a576,586
> #ifdef WINNT
> 	char *pos;
> 	DWORD xfer_thread_id;
> 	STARTUPINFO sui;
> 	static char CommandLine[NSMAX*(MAXDNAME+1)+20*10];
> 	PROCESS_INFORMATION *proc_info_copy;
>     
> 
> #else
> 	int pid;
> #endif
418c590,598
< 	argv[argc++] = _PATH_XFER;
---
> #ifndef WINNT
> 	argv[argc++] = "_PATH_XFER";
> #else
> #ifndef WIN95
> 	argv[argc++] = "xfer";
> #else
> 	argv[argc++] = "xfer95";
> #endif
> #endif
431c611
<  	if (zp->z_flags & Z_SYSLOGGED)
---
> 	if (zp->z_flags & Z_SYSLOGGED)
445a626
> #ifndef WINNT
446a628,630
> #else
> 		argv[argc++] = pathxferddt;
> #endif
448a633
> #ifndef WINNT
449a635,637
> #else
> 			argv[argc++] = pathxfertrace;
> #endif
477c665
<         }
---
> 	}
480a669,679
> #ifdef WINNT
> 	/* need the arguments in the form of a string not in argv format */
> 	pos = CommandLine;
> 	for (i = 0; i < argc; i++) {
> 		sprintf(pos, argv[i]);
> 		pos += strlen(pos);
> 		*pos++ = ' ';
> 	}
> 	*pos = '\0';
> #endif 
> 
486c685
<         }
---
> 	}
491,497c690,706
< 	holdsigchld();
< 	for (i = 0; i < MAX_XFERS_RUNNING; i++) {
< 		if (xferstatus[i].xfer_pid == 0) {
< 			xferstatus[i].xfer_state = XFER_RUNNING;
< 			break;
< 		}
< 	}
---
> #ifndef WINNT
>    	holdsigchld();
> #else
>     /* make sure we don't have two accessing the same structures */
>     /* lgk use critical section here for this and in endxfer where this is read to make sure that not more
>        than one is trying to start a xfer process at a time */
>     EnterCriticalSection(&protected_zp);
>     proc_info_copy = (PROCESS_INFORMATION *)malloc(sizeof(PROCESS_INFORMATION));
>  
> #endif
>   	for (i = 0; i < MAX_XFERS_RUNNING; i++) {
>   		if (xferstatus[i].xfer_pid == 0) {
>   			xferstatus[i].xfer_state = XFER_RUNNING;
>   			break;
>   		}
>   	}
> #ifndef WINNT
500c709
< 		releasesigchld();
---
>   		releasesigchld();
509c718
< 		_exit(XFER_FAIL);	/* Avoid duplicate buffer flushes. */
---
> 		_exit(XFER_FAIL);       /* Avoid duplicate buffer flushes. */
511,513c720,757
< 	/* Parent. */
< 	xferstatus[i].xfer_pid = pid;  /* XXX - small race condition here if we
< 					* can't hold signals */
---
> #else /* WINNT */
> 	bzero((char *)&sui, sizeof(STARTUPINFO));
> 	sui.cb = sizeof(STARTUPINFO);
> 	if (!CreateProcess(NULL, CommandLine, NULL, NULL, FALSE, DETACHED_PROCESS, NULL,
> 					   NULL, &sui, (LPPROCESS_INFORMATION)proc_info_copy))
>       {
> 	     syslog(LOG_ERR, "CreateProcess() for xfer: %m");
>              LeaveCriticalSection(&protected_zp);
> 	     return;
> 	  }
> 
> 	threadhandle2 = NULL;
> 	threadhandle2 = CreateThread(
> 	         NULL,                                /* no security attributes  */
> 	         0,                                   /* use default stack size  */
> 	         (LPTHREAD_START_ROUTINE) named_xfer, /* thread function         */
> 	         (LPVOID) proc_info_copy,             /* argument to thread function   */
> 	         0,                                   /* use default creation flags    */
> 	         (LPDWORD) &xfer_thread_id);
> 
>     if (threadhandle2 == NULL)
> 	  {
>         syslog(LOG_ERR, "CreateThread() for xfer status: %m");
>         LeaveCriticalSection(&protected_zp);
> 	return;
> 	  }
> 	CloseHandle(threadhandle2); /* no handle to this needed */
> 	
> #endif /* WINNT */
> 	/* parent */
> #ifdef WINNT
> 	dprintf(1, (ddt, "started xfer child %d\n", proc_info_copy->hProcess));
>     zp->z_xferpid = proc_info_copy->hProcess;
>   	xferstatus[i].xfer_pid = (long)proc_info_copy->hProcess;
> #else
> 	zp->z_xferpid = pid;
>   	xferstatus[i].xfer_pid = pid;  /* XXX - small race condition here if we
>   					* can't hold signals */
514a759
> #endif
517c762
< 	zp->z_xferpid = pid;
---
> 
520c765,771
< 	releasesigchld();
---
> 
> #ifdef WINNT
>     LeaveCriticalSection(&protected_zp);
> #else
>   	releasesigchld();
> #endif
>     
527c778
< 	static char ret[sizeof "(4294967296?)"];	/* 2^32 */
---
> 	static char ret[sizeof "(4294967296?)"];        /* 2^32 */
530,531c781,782
< 	case Z_PRIMARY:		return ("primary");
< 	case Z_SECONDARY:	return ("secondary");
---
> 	case Z_PRIMARY:         return ("primary");
> 	case Z_SECONDARY:       return ("secondary");
533c784
< 	case Z_STUB:		return ("stub");
---
> 	case Z_STUB:            return ("stub");
535c786
< 	case Z_CACHE:		return ("cache");
---
> 	case Z_CACHE:           return ("cache");
563c814
<  	fprintf(ddt, ", type = %s", zoneTypeString(zp));
---
> 	fprintf(ddt, ", type = %s", zoneTypeString(zp));
593c844
< #ifdef	CLEANCACHE
---
> #ifdef  CLEANCACHE
663c914
< 				dp = rm_datum(dp, np, pdp);
---
> 			    dp = rm_datum(dp, np, pdp);
769c1020
< 		if (dp->d_rcode)	/* this should not occur */
---
> 		if (dp->d_rcode)        /* this should not occur */
793c1044
< 		nsa = zp->z_xaddr;	/* qserial overrode address */
---
> 		nsa = zp->z_xaddr;      /* qserial overrode address */
797c1048
< 		nsa = zp->z_addr[0];	/* first ns holds zone's xfer limit */
---
> 		nsa = zp->z_addr[0];    /* first ns holds zone's xfer limit */
800c1051
< 		return (-1);		/* probably ENOMEM */
---
> 		return (-1);            /* probably ENOMEM */
804c1055
< 		return (-1);		/* taking more than we have */
---
> 		return (-1);            /* taking more than we have */
809a1061
> 
812a1065
> 
816c1069,1085
< {
---
>    {
> 
> #ifdef WINNT
> 	    TerminateProcess(zp->z_xferpid, (UINT)XFER_KILLED);
> 
> 	    syslog(LOG_WARNING,
> 		"zone transfer timeout for \"%s\"; pid %lu killed",
> 		zp->z_origin, (u_long)zp->z_xferpid);
>              dprintf(1, (ddt, "zone transfer timeout for %s pid %lu killed\n",
> 		zp->z_origin, (u_long)zp->z_xferpid));
> 
> 		zp->z_flags |= Z_XFER_ABORTED;
> 	     ns_retrytime(zp, tt.tv_sec);
>  	     (void) nxfers(zp, -1);        
> 
> #else
> 
821,822c1090,1091
< 			if (xferstatus[i].xfer_pid == zp->z_xferpid) {
< 				xferstatus[i].xfer_pid = 0;
---
> 			if (xferstatus[i].xfer_pid == (long)zp->z_xferpid) {
> 			    xferstatus[i].xfer_pid = 0;
831a1101
> 
838,840c1108,1110
< "zone transfer timeout for \"%s\"; second kill\
< pid %lu - forgetting, processes may accumulate",
< 			       zp->z_origin, (u_long)zp->z_xferpid);
---
>                             "zone transfer timeout for \"%s\"; second kill\
>                              pid %lu - forgetting, processes may accumulate",
> 			     zp->z_origin, (u_long)zp->z_xferpid);
846c1116,1118
< 	} else if (kill(zp->z_xferpid, SIGKILL) == -1) {
---
> 	}
> 
>         else if (kill(zp->z_xferpid, SIGKILL) == -1) {
862c1134,1137
< }
---
> 	
> #endif
>    }
> 
863a1139
> #ifndef WINNT
900a1177,1179
> }
> #endif
> 
902c1181,1182
<  * Finish processing of of finished xfers
---
>  * SIGCHLD signal handler: process exit of xfer's.
>  * (Note: also called when outgoing transfer completes.)
903a1184,1189
> /* the semantics here have changed now we call reapchild when a transfer ends which sets the
>    variable needendxfer ... however under nt since there are no signals endxfer is called
>    directly when a transfer ends... therefore we need to clear out the entry here under 
>    nt, also under nt we determine the pid to clear because it is passed in ... lgk */
> 
> #ifndef WINNT
905a1192,1196
> #else
> void
> endxfer(pid)
> 	HANDLE pid;
> #endif
907,908c1198,1200
<     	register struct zoneinfo *zp;   
< 	int exitstatus, pid, i;
---
>     register struct zoneinfo *zp;
> #ifndef WINNT   
>  	int exitstatus, pid;
913a1206,1209
> #else
> 	DWORD exitstatus;
> #endif
>     int i;
915c1211
< 	gettime(&tt);
---
> gettime(&tt);
917,922c1213,1221
< 	for (i = 0; i < MAX_XFERS_RUNNING; i++) {
< 		if (xferstatus[i].xfer_state != XFER_DONE)
< 			continue;
< 		pid = xferstatus[i].xfer_pid;
< 		status = xferstatus[i].xfer_status;
< 		exitstatus = WIFEXITED(status) ?WEXITSTATUS(status) :0;
---
> /* under Win NT this should not get called unless a transfer has completed 
>  * or aborted
>  */
> #ifndef WINNT
>   	for (i = 0; i < MAX_XFERS_RUNNING; i++) {
>   		if (xferstatus[i].xfer_state != XFER_DONE)
>   			continue;
>   		pid = xferstatus[i].xfer_pid;
>   		status = xferstatus[i].xfer_status;
924c1223,1237
< 		for (zp = zones; zp < &zones[nzones]; zp++) {
---
>     		exitstatus = WIFEXITED(status) ?WEXITSTATUS(status) :0;
> #else
>  
> 	if (!GetExitCodeProcess(pid, &exitstatus))
>           {
> 	    syslog(LOG_ERR, "endxfer: cannot determine return code of the xfer (%d) process: %m",pid);
> 	    dprintf(1, (ddt, "endxfer: cannot determine return code of the xfer (%d) process: %d",pid,GetLastError()));
>             /* lgk new code here if we cannot figure this out dummy it up so it gets rescheduled anyway */
>             /* dont return as previously or the zone does not get rescheduled */
>             exitstatus = XFER_FAIL;
> 	  }
> #endif /* WINNT */
> 
> 		for (zp = zones; zp < &zones[nzones]; zp++)
>                    {
926a1240,1260
>             /* ok found our zone */
> #ifdef WINNT
>             /* regardless of how it terminated if under NT clear it out here
>              * first find the entry 
>              */
>              
>   	         for (i = 0; i < MAX_XFERS_RUNNING; i++) {
> 			    if (xferstatus[i].xfer_pid == (long)pid) {
> 				    xferstatus[i].xfer_status = exitstatus;
>                     xferstatus[i].xfer_state = XFER_IDLE;
> 			    	xferstatus[i].xfer_pid = 0;
> 			    	
> 			   } 
> 		      }
> 		     /* lgk problem is here we cannot close the handle here as it will reuse it and then close it again later
> 		        don't think we need to close this handle anyway as it is the same handle that is closed before the free
> 		        in named_xfer  the problem was that critical sections allow the same thread
> 		        to go into the same critical section more than once and since this handle was
> 		        already closed here it was re-allocated and closed again in named-xfer after the call to endxfer  
> 		     CloseHandle(zp->z_xferpid); */
> #endif
930,931c1264,1266
< 			zp->z_flags &=
< 				~(Z_XFER_RUNNING|Z_XFER_ABORTED|Z_XFER_GONE);
---
>   			zp->z_flags &=
>   				~(Z_XFER_RUNNING|Z_XFER_ABORTED|Z_XFER_GONE);
> #ifndef WINNT
933c1268
< 		 "\nendxfer: child %d zone %s returned status=%d termsig=%d\n",
---
> 		            "\nendxfer: child %d zone %s returned status=%d termsig=%d\n", 
945a1281,1285
> #else /* WINNT */
> 			dprintf(1, (ddt,
> 		            "\nendxfer: child %d zone %s returned status=%d \n", 
> 				    pid, zp->z_origin, exitstatus));
> #endif /* WINNT */
955a1296
>                     dprintf(1, (ddt, "named-xfer for %s ended successfully (child = %d)\n",zp->z_origin,pid));
961,962c1302,1303
< 						syslog(LOG_NOTICE,
< 		      "zoneref: Masters for secondary zone \"%s\" unreachable",
---
> 						syslog(LOG_WARNING,
> 	 	                                        "zoneref: Masters for secondary zone \"%s\" unreachable",
964a1306
>                     dprintf(1, (ddt, "Masters for secondary zone %s unreachable (xfer timed out) (child = %d)\n",zp->z_origin,pid));
967c1309,1313
< 
---
> #ifdef WINNT
> 				case XFER_KILLED:
> 					ns_retrytime(zp, tt.tv_sec);
> 					break;
> #endif
972,974c1318,1319
< 					     "named-xfer for \"%s\" exited %d",
< 						       zp->z_origin,
< 						       exitstatus);
---
> 					         "named-xfer for \"%s\" exited %d",
> 						    zp->z_origin, exitstatus);
978a1324,1325
>                     dprintf(1, (ddt, "(xfer for %s failed in endxfer) (child = %d)\n",zp->z_origin,pid));
>                     syslog(LOG_WARNING, "(xfer for %s failed) (child = %d) - rescheduling!\n",zp->z_origin,pid);
981c1328
< 				}
---
> 				} /*switch*/
983,987c1330,1339
< 			}
< 		}
< 		xferstatus[i].xfer_state = XFER_IDLE;
< 		xferstatus[i].xfer_pid = 0;
< 	}
---
> #ifndef WINNT
> 			} /*if/else*/
> #endif
> 		   } /* inner for */
> 
> #ifndef WINNT
>  	 xferstatus[i].xfer_state = XFER_IDLE;
> 	 xferstatus[i].xfer_pid = 0;
> 	} /* outter for */
> 
988a1341,1342
> #endif
> 
989a1344
> 
1063c1418
<     	register struct zoneinfo *zp;   
---
> 	register struct zoneinfo *zp;   
1101a1457,1537
> 
> 
> #ifdef WINNT
> void CALLBACK maint_alarm (UINT wTimerID, UINT msg,
>     DWORD dwUser, DWORD dw1, DWORD dw2)
> {
> 	int len;
> 	char loopbuf[] = "";
> 	    struct sockaddr_in loopback; 
> 	    needmaint = 1;
> 	dprintf(1, (ddt, "in maint_alarm ...\n"));
> 	printf("in maint_alarm ...\n");
> 
> #ifdef NOWAIT
> 	loopback.sin_family = AF_INET;
> 	loopback.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
> 	loopback.sin_port = htons(NAMESERVER_PORT);
> 	if(len = sendto(datagramq->dq_dfd, loopbuf, 1, 0, (struct sockaddr *)&loopback,
> 		  sizeof(struct sockaddr_in)) == SOCKET_ERROR)
> 		{
> 		syslog(LOG_ERR, "failed to break select for maintenance: %m, maintenance delayed");
> 		syslog(LOG_ERR, "WSA ERRORCODE WAS: %d", WSAGetLastError());
> 		}
> #endif
> 
> 
>     UNREFERENCED_PARAMETER(dw1);
>     UNREFERENCED_PARAMETER(dw2);
>     UNREFERENCED_PARAMETER(dwUser);
>     UNREFERENCED_PARAMETER(msg);
>     UNREFERENCED_PARAMETER(wTimerID);
> }
> 
> void
> named_xfer(PROCESS_INFORMATION *proc_info)
> {
> 	DWORD dwWait;
> 
> 	dwWait = WaitForSingleObject((*proc_info).hProcess, (DWORD) MAX_XFER_TIME * 1000);
> 
> 
>     /* now check reason we woke up */
>     /* remove the return now so let it go into endxfer even if the wait fails so we can resched. the xfer */
>     switch (dwWait)
>      {
> 
>       case WAIT_TIMEOUT:
>            syslog(LOG_ERR, "WaitForSingleObject() on named-xfer process (%d) status timed out!",(*proc_info).hProcess);
>            dprintf(1,(ddt, "WaitForSingleObject() on named-xfer process (%d) status timed out!\n",(*proc_info).hProcess));
> 	       break;
> 
>       case WAIT_FAILED:
>            syslog(LOG_ERR, "WaitForSingleObject() on named-xfer process (%d) status failed: %m",(*proc_info).hProcess);
>            dprintf(1,(ddt, "WaitForSingleObject() on named-xfer process (%d) status failed: %d\n",(*proc_info).hProcess,GetLastError()));
> 	       break;
> 
>       case WAIT_OBJECT_0:
>            /* normal case */
>            break;
>        
>       default:
>         dprintf(1, (ddt, "Unknown return type from WaitForSingleObject on named-xfer (%d) status! (%d)\n",(*proc_info).hProcess,dwWait));
>         syslog(LOG_ERR, "Unknown return type from WaitForSingleObject on named-xfer (%d) status %d:",(*proc_info).hProcess,dwWait);
>         break;
>       
>      }
>     
>     /* lgk new code using critical section to synchronize */
>     EnterCriticalSection(&protected_zp);
>     endxfer((*proc_info).hProcess);
>     /* dont try the close if the wait failed for some reason */
>     /* if we have an extra handle around so be it but if the handle is bad ie wait failed not sure what close will do */
>     if (dwWait == WAIT_OBJECT_0)
>       {
>        CloseHandle((*proc_info).hProcess);
>        CloseHandle((*proc_info).hThread);
>       }
>     free((char *)proc_info);
>     LeaveCriticalSection(&protected_zp);
> }
> #endif /* WINNT */
diff --recurs m:\bind494rel/named/ns_ncache.c m:\bind/named/ns_ncache.c
9,17c9,21
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <sys/file.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <syslog.h>
< #include <errno.h>
< #include <stdio.h>
< #include <resolv.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <sys/file.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
> #include <errno.h>
> #include <stdio.h>
> #include <resolv.h>
33a38
> #ifdef VALIDATE
34a40
> #endif
diff --recurs m:\bind494rel/named/ns_req.c m:\bind/named/ns_req.c
61,70c61,74
< #include <sys/param.h>
< #include <sys/uio.h>
< #include <sys/file.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <fcntl.h>
< #include <syslog.h>
< #include <errno.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/uio.h>
> #include <sys/file.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <fcntl.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
> #include <errno.h>
82a87,97
> #ifdef WINNT
> #define _exit(x) ExitThread(x)
> struct ntxfr {
> 	struct qstream *qsp;
> 	struct namebuf *np;
> 	u_char *soa;
> 	int soalen;
> 	int class;
> };
> #endif
> 
99a115
> #ifndef WINNT
100a117,119
> #else
> static void		fwritemsg __P((SOCKET, u_char *, int)),
> #endif
103a123
> #ifndef WINNT
105a126,129
> #else
> 			doaxfr __P((struct namebuf *, SOCKET,
> 				    struct namebuf *, int)),
> #endif
107a132,134
> #ifdef WINNT
> static void startxfr_child __P((struct ntxfr *));
> #endif
270c297
< 	sortmsgtxt = local(from) == NULL ? "Remote" : "Local";
---
>    	sortmsgtxt = local(from) == NULL ? "Remote" : "Local";
272c299
< 	sortmsgtxt = "(not sorting)";
---
>   	sortmsgtxt = "(not sorting)";
274,276c301,304
< 	dprintf(1, (ddt, "ns_req: answer -> %s fd=%d id=%d size=%d %s\n",
< 		    sin_ntoa(from), (qsp == QSTREAM_NULL) ? dfd : qsp->s_rfd,
< 		    ntohs(hp->id), cp - msg, sortmsgtxt));
---
>   	dprintf(1, (ddt, "ns_req: answer -> %s fd=%d id=%d size=%d %s\n",
>   		    sin_ntoa(from), (qsp == QSTREAM_NULL) ? dfd : qsp->s_rfd,
>   		    ntohs((u_short)hp->id), cp - msg, sortmsgtxt));
> 
464,467c492,495
< 	if ((ntohs(hp->qdcount) != 1)
< 	    || ntohs(hp->ancount) != 0
< 	    || ntohs(hp->nscount) != 0
< 	    || ntohs(hp->arcount) != 0) {
---
> 	if ((ntohs((u_short)  hp->qdcount) != 1)
>  	    || ntohs((u_short) hp->ancount) != 0
>  	    || ntohs((u_short) hp->nscount) != 0
>  	    || ntohs((u_short) hp->arcount) != 0) {
469,472c497,500
< 		hp->qdcount = htons(0);
< 		hp->ancount = htons(0);
< 		hp->nscount = htons(0);
< 		hp->arcount = htons(0);
---
>  		hp->qdcount = htons(0);
>  		hp->ancount = htons(0);
>  		hp->nscount = htons(0);
>  		hp->arcount = htons(0);
555c583
< 		    dname, ntohs(hp->id), type, class));
---
> 		    dname, ntohs((u_short)hp->id), type, class));
693c721
< 	hp->ancount = htons(ntohs(hp->ancount) + (u_int16_t)count);
---
> 	hp->ancount = htons((u_short)(ntohs((u_short)hp->ancount) + (u_int16_t)count));
736a765,766
> #ifndef WINNT
> #endif
783c813
< 			} else if (ntohs(hp->ancount) != 0) {
---
> 			} else if (ntohs((u_short)hp->ancount) != 0) {
984,987c1014,1017
< 	if (ntohs(hp->ancount) != 1
< 	    || ntohs(hp->qdcount) != 0
< 	    || ntohs(hp->nscount) != 0
< 	    || ntohs(hp->arcount) != 0) {
---
> 	if (ntohs((u_short) hp->ancount) != 1
> 	    || ntohs((u_short) hp->qdcount) != 0
> 	    || ntohs((u_short) hp->nscount) != 0
> 	    || ntohs((u_short) hp->arcount) != 0) {
989,992c1019,1022
< 		hp->qdcount = htons(0);
< 		hp->ancount = htons(0);
< 		hp->nscount = htons(0);
< 		hp->arcount = htons(0);
---
>  		hp->qdcount = htons(0);
>  		hp->ancount = htons(0);
>  		hp->nscount = htons(0);
>  		hp->arcount = htons(0);
1126a1157
> #ifndef WINNT
1130a1162,1167
> #else
> fwritemsg(rfd, msg, msglen)
> 	SOCKET rfd;
> 	u_char *msg;
> 	int msglen;
> #endif
1134a1172
> #ifndef WINNT
1136a1175,1178
> #else
> 	if (send(rfd, len, INT16SZ, 0) != INT16SZ ||
> 		send(rfd, msg, msglen, 0) != msglen) {
> #endif
1245c1287,1291
< 		    || dp->d_ttl < (u_int32_t)tt.tv_sec) {
---
> #ifndef WINNT
> 	        || dp->d_ttl < (u_int32_t)tt.tv_sec) {
> #else
>      		|| dp->d_ttl < (int32_t)tt.tv_sec) {
> #endif
1587c1633
< 	hp->nscount = htons(ntohs(hp->nscount) + 1);
---
> 	hp->nscount = htons((u_short)(ntohs((u_short)hp->nscount) + 1));
1601a1648
> #ifndef WINNT
1606a1654,1660
> #else
> doaxfr(np, rfd, top, class)
> 	register struct namebuf *np;
> 	SOCKET rfd;
> 	struct namebuf *top;
> 	int class;		/* Class to transfer */
> #endif
1649a1704
> #ifndef WINNT
1650a1706,1708
> #else
> 		fwritemsg(rfd, msg, n + HFIXEDSZ);
> #endif
1707a1766
> #ifndef WINNT
1708a1768,1770
> #else
>  			fwritemsg(rfd, msg, n + HFIXEDSZ);
> #endif
1739a1802
> #ifndef WINNT
1740a1804,1806
> #else
> 		fwritemsg(rfd, msg, n + HFIXEDSZ);
> #endif
1784a1851
> #ifndef WINNT
1785a1853,1855
> #else
> 			doaxfr(np, rfd, top, class);
> #endif
2023a2094
> #ifndef WINNT
2037a2109,2114
> #else /* WINNT */
> 	HANDLE xfr_thread_handle;
> 	struct ntxfr *xfr_child;
> 	char *xfrbuf;
> 	DWORD id;	
> #endif /* WINNT */
2040a2118
> #ifndef WINNT
2057,2059c2135,2137
< 		close(pipefd[0]);
< 		close(pipefd[1]);
< 		sqrm(qsp);
---
>  		close(pipefd[0]);
>  		close(pipefd[1]);
>  		sqrm(qsp);
2066,2071c2144,2158
< 		close(pipefd[0]);	/* close the read end */
< 		sqrm(qsp);
< 		/* close the write end to release the child */
< 		close(pipefd[1]);
< 		syslog(LOG_DEBUG, "zone transfer of \"%s\" to %s (pid %lu)",
< 		       dname, sin_ntoa(&qsp->s_from), (u_long)pid);
---
>  		close(pipefd[0]);	/* close the read end */
>  		sqrm(qsp);
>  		/* close the write end to release the child */
>  		close(pipefd[1]);
>   		syslog(LOG_DEBUG, "zone transfer of \"%s\" to %s (pid %lu)",
>  		       dname, sin_ntoa(&qsp->s_from), (u_long)pid);
> 		return;
> 	}
> #else
> 	if ((xfr_child = (struct ntxfr *)malloc(sizeof(struct ntxfr))) == NULL) {
> 		syslog(LOG_ERR, "startxfr: malloc: %m");
> 		return;
> 	}
> 	if ((xfrbuf = (u_char *)malloc(BUFSIZ)) == NULL) {
> 		syslog(LOG_ERR, "startxfr: malloc: %m");
2073a2161,2205
> 	xfr_child->qsp = qsp;
> 	xfr_child->np = np;
> 	bcopy(soa, xfrbuf, soalen);
> 	soa[soalen+1] = '\0';
> 	xfr_child->soa = xfrbuf;
> 	xfr_child->soalen = soalen;
> 	xfr_child->class = class;
> 
> 	xfr_thread_handle = CreateThread(NULL, 0,
> 									(LPTHREAD_START_ROUTINE)startxfr_child,
> 									(LPVOID)xfr_child, 0, &id);
> 	if(xfr_thread_handle == NULL)
> 		syslog(LOG_NOTICE, "startxfr(%s -> %s) failing; CreateThread(): %m",
> 		       dname, sin_ntoa(&qsp->s_from));
> 	else
> 		/* probably should store the thread handle and/or thread id
> 		 * and identify and kill a hung outgoing zone transfer thread
> 		 */
> 		syslog(LOG_DEBUG, "zone transfer of \"%s\" to %s (threadId %d)",
> 		       dname, sin_ntoa(&qsp->s_from), id);
>         /* lgk close errant handle here so we don't get too many */
>         CloseHandle(xfr_thread_handle);
> 	return;
> }
> 
> static void
> startxfr_child(pxfr_child)
> 	struct ntxfr *pxfr_child;
> {
> 	DWORD pid;
> #if defined(HAVE_SETVBUF) && !defined(WINNT)
> 	char *buf;
> #endif
> #ifdef SO_SNDBUF
> 	static const int sndbuf = XFER_BUFSIZE * 2;
> #endif
> #ifdef SO_LINGER
> 	static const struct linger ll = { 1, 120 };
> #endif
> 	struct qstream	*qsp = pxfr_child->qsp;
> 	struct namebuf	*np = pxfr_child->np;
> 	u_char		*soa = pxfr_child->soa;
> 	int		soalen = pxfr_child->soalen;
> 	int		class = pxfr_child->class;
> 	int off = 0;
2074a2207,2209
> 	pid = GetCurrentThreadId();
> #endif /* WINNT */
> 
2080a2216
> #ifndef WINNT
2083a2220,2232
>  
>  	close(pipefd[1]);		/* close the write end */
>  	/*
>  	 * Wait for parent to close the write end of the pipe which
>  	 * we'll see as an EOF.  The parent won't close the write end
>  	 * until it has closed the fd we'll be writing to, at which
>  	 * point it will be safe for us to proceed.
>           *
>  	 * We shouldn't get interrupted, but ...
>  	 */
>  	while (read(pipefd[0], &c, 1) == -1 && errno == EINTR)
>  		; /* nothing */
>  	close(pipefd[0]);
2085,2096c2234
< 	close(pipefd[1]);		/* close the write end */
< 	/*
< 	 * Wait for parent to close the write end of the pipe which
< 	 * we'll see as an EOF.  The parent won't close the write end
< 	 * until it has closed the fd we'll be writing to, at which
< 	 * point it will be safe for us to proceed.
<          *
< 	 * We shouldn't get interrupted, but ...
< 	 */
< 	while (read(pipefd[0], &c, 1) == -1 && errno == EINTR)
< 		; /* nothing */
< 	close(pipefd[0]);
---
> #endif
2100a2239,2241
> #ifdef WINNT
> 	(void) SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
> #endif
2102a2244
> #ifndef WINNT
2106a2249
> #endif
2107a2251
> #ifndef WINNT
2113c2257,2264
< #ifdef HAVE_SETVBUF
---
> #else
> 	/* set the socket to be blocking again */
> 	if(ioctlsocket(qsp->s_rfd, FIONBIO, (u_long *)&off) == SOCKET_ERROR) {
> 		syslog(LOG_INFO, "ioctlsocket(rfd, BLOCK): %m");
> 		exit(1);
> 	}
> #endif /* WINNT */
> #if defined(HAVE_SETVBUF) && !defined(WINNT)
2132a2284
> #ifndef WINNT
2133a2286,2289
> #else
> 	fwritemsg(qsp->s_rfd, soa, soalen);
> #endif
> #ifndef WINNT
2134a2291,2294
> #else
> 	doaxfr(np, qsp->s_rfd, np, class);
> #endif
> #ifndef WINNT
2136a2297,2299
> #else
> 	fwritemsg(qsp->s_rfd, soa, soalen);
> #endif
2143a2307
> #ifndef WINNT
2144a2309,2314
> #else
> 	sqrm(qsp);
> #endif /* WINNT */
> #endif /* SO_LINGER */
> #ifdef WINNT
> 	/* endxfer(GetCurrentThread());	*/
2145a2316
> #ifndef WINNT
2146a2318,2320
> #else
> 	ExitThread(0);
> #endif
diff --recurs m:\bind494rel/named/ns_resp.c m:\bind/named/ns_resp.c
61,70c61,74
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <sys/file.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <syslog.h>
< #include <errno.h>
< #include <stdio.h>
< #include <resolv.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <sys/file.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
> #include <errno.h>
> #include <stdio.h>
> #include <resolv.h>
191c195
< 	int restart;	/* flag for processing cname response */
---
> 	int restart; /* flag for processing cname response */
215c219
< 		dprintf(1, (ddt, "DUP? dropped (id %d)\n", ntohs(hp->id)));
---
> 		dprintf(1, (ddt, "DUP? dropped (id %d)\n", ntohs( (u_short) hp->id)));
229,232c233,236
< 	qdcount = ntohs(hp->qdcount);
< 	ancount = ntohs(hp->ancount);
< 	aucount = ntohs(hp->nscount);	/* !!! */
< 	arcount = ntohs(hp->arcount);
---
> 	qdcount = ntohs( (u_short) hp->qdcount);
> 	ancount = ntohs( (u_short) hp->ancount);
> 	aucount = ntohs( (u_short) hp->nscount);	/* !!! */
> 	arcount = ntohs( (u_short) hp->arcount);
508a513
> 
725a731
> #ifdef VALIDATE
726a733
> #endif
817c824
< 		if (i < ancount) {
---
> 		if ( i < ancount ) {
828,829c835,836
< 			else
< 				cname = 1;
---
>   			else
>   				cname = 1;
938c945
< 	if (!restart && ancount && (qtype == T_ANY || !qp->q_cmsglen)) {
---
>    	if (!restart && ancount && (qtype == T_ANY || !qp->q_cmsglen)) {
985c992
< 	if ((!restart || !cname) && qp->q_cmsglen && ancount) {
---
>   	if ((!restart || !cname) && qp->q_cmsglen && ancount) {
988c995
< 		bcopy(qp->q_cmsg, newmsg, newmsglen);
---
>  		bcopy(qp->q_cmsg, newmsg, newmsglen);
1022d1028
< 
1023a1030
> 
1041c1048
< 	hp->ancount = htons(ntohs(hp->ancount) + (u_int16_t)count);
---
>   	hp->ancount = htons((u_short)(ntohs((u_short)hp->ancount) + (u_int16_t)count));
1121a1129
> 
2525,2526c2533,2534
< 					+
< 				0.95 * (int) (dp->d_ttl - tt.tv_sec);
---
> 					+ (int) (
> 				0.95 * (int) (dp->d_ttl - tt.tv_sec));
2742a2751
> 
diff --recurs m:\bind494rel/named/ns_sort.c m:\bind/named/ns_sort.c
61,69c61,73
< #include <sys/param.h>
< #include <sys/types.h>
< #include <sys/socket.h>
< #include <sys/file.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <stdio.h>
< #include <syslog.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/types.h>
> #include <sys/socket.h>
> #include <sys/file.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <stdio.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
diff --recurs m:\bind494rel/named/ns_stats.c m:\bind/named/ns_stats.c
66,72c66,76
< #include <sys/param.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <stdio.h>
< #include <syslog.h>
< #include <errno.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <stdio.h>
> #ifndef WINNT
> #include <syslog.h>
> #endif
> #include <errno.h>
74,75c78,79
< #include "named.h"
< #include "tree.h"
---
> #include "named.h"
> #include "tree.h"
248a253
> #ifndef WINNT
249a255,257
> #else
> 			SetLastError(save);
> #endif
diff --recurs m:\bind494rel/named/ns_validate.c m:\bind/named/ns_validate.c
10,18c10,20
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <sys/file.h>
< 
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< 
< #include <syslog.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <sys/file.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #ifndef WINNT
> #include <arpa/inet.h>
> #include <syslog.h>
> #endif
Only in m:\bind/named: ntif.h
diff --recurs m:\bind494rel/named/pathnames.h m:\bind/named/pathnames.h
61,62c61,63
< #ifdef _PATH_XFER
< # define _PATH_XFER_PREDEFINED	/* probably from Makefile */
---
> 
> #ifdef _PATH_XFER
> # define _PATH_XFER_PREDEFINED	/* probably from Makefile */
65,66c66,81
< #if defined (__sgi) && !defined(_SYSTYPE_SVR4) && !defined(__SYSTYPE_SVR4)
< #define	_PATH_BOOT	"/usr/etc/named.d/named.boot"
---
> #ifdef WINNT
> #define	_PATH_BOOT	"%windir%\\NAMED.BOOT"
> #define	_ALT_PATH_BOOT	"%windir%\\NAMED.INI"
> #ifndef _PATH_XFER
> # define _PATH_XFER	"%windir%\\SYSTEM32\\XFER.EXE"
> #endif
> #ifndef _PATH_PIDFILE
> # define _PATH_PIDFILE	"%windir%\\NAMED.PID"
> #endif
> /* following paths prepended with GetTempPath() */
> #define	_PATH_DEBUG	"NAMED.RUN" 
> #define	_PATH_DUMPFILE	"NAMDUMP.DB"
> #define	_PATH_STATS	"NAMED.STS"
> #define	_PATH_XFERTRACE	"XFER.TRC"
> #define _PATH_XFERDDT	"XFER.DDT"
> #define	_PATH_TMPXFER	"XFER.DDT.XXXXXX"
68c83,87
< #define	_PATH_BOOT	"/etc/named.boot"
---
> 
> #if defined (__sgi) && !defined(_SYSTYPE_SVR4) && !defined(__SYSTYPE_SVR4)
> #define	_PATH_BOOT	"/usr/etc/named.d/named.boot"
> #else
> #define	_PATH_BOOT	"/etc/named.boot"
122a142,143
> 
> #endif /* WINNT */
Only in m:\bind/named: resource.h
Only in m:\bind/named: save.zip
diff --recurs m:\bind494rel/named/storage.c m:\bind/named/storage.c
56,57c56,59
< #include <sys/param.h>
< #include <syslog.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <syslog.h>
> #endif
Only in m:\bind/named: strip.bat
Only in m:\bind/named: versav.c
Only in m:\bind/named: version.c
Only in m:\bind/named: xfer.mak
Only in m:\bind/named: xfer.mdp
Only in m:\bind/named: xfer.ncb
Only in m:\bind/named: xfer.vcp
Only in m:\bind/named: xfer95.mak
Only in m:\bind/named: xfer95.mdp
Only in m:\bind/named: xfer95.ncb
Only in m:\bind: ntbind49326_vc22.zip
Only in m:\bind: ntbind49327.zip
Only in m:\bind: ntbind49332.zip
Only in m:\bind: ntbind493rel.zip
Only in m:\bind: ntbind493relo3.zip
Only in m:\bind: ntbind493relo5.zip
Only in m:\bind: ntbind493relp2.zip
Only in m:\bind: ntbind494arel.zip
Only in m:\bind: ntbind494beta2.zip
Only in m:\bind: ntbind494p1rel.zip
Only in m:\bind: ntbind494rel.zip
Only in m:\bind: ntbind494t3b2.zip
Only in m:\bind: ntbind494t4a.zip
Only in m:\bind: ntbind494t4b.zip
Only in m:\bind: ntbind494t5b.zip
Only in m:\bind: ntdns49326bin_vc22.zip
Only in m:\bind: ntdns493relbin-nongui.zip
Only in m:\bind: ntdns493relbin.zip
Only in m:\bind: ntdns493relbino5.zip
Only in m:\bind: ntdns493relp2bin-nongui.zip
Only in m:\bind: ntdns493relp2bin.zip
Only in m:\bind: ntdns494arelbin-nongui.zip
Only in m:\bind: ntdns494arelbin.zip
Only in m:\bind: ntdns494beta2bin-nongui.zip
Only in m:\bind: ntdns494beta2bin.zip
Only in m:\bind: ntdns494relbin-nongui.zip
Only in m:\bind: ntdns494relbin.zip
Only in m:\bind: ntdns494t3b2bin.zip
Only in m:\bind: ntdns494t4abin-nongui.zip
Only in m:\bind: ntdns494t4abin.zip
Only in m:\bind: ntdns494t4bbin-nongui.zip
Only in m:\bind: ntdns494t4bbin.zip
Only in m:\bind: ntdns494t5bbin-nongui.zip
Only in m:\bind: ntdns494t5bbin.zip
Only in m:\bind: p2c1
Only in m:\bind: p2c2
Only in m:\bind: p2c3.gz
Only in m:\bind: p2c4
Only in m:\bind: page1.html
Only in m:\bind: readme.nt
Only in m:\bind/res: WinRel
diff --recurs m:\bind494rel/res/gethnamaddr.c m:\bind/res/gethnamaddr.c
61,65c61,67
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
67,70c69,72
< #include <stdio.h>
< #include <netdb.h>
< #include <resolv.h>
< #include <ctype.h>
---
> #include <stdio.h>
> #include <netdb.h>
> #include <resolv.h>
> #include <ctype.h>	 
71a74
> #ifndef WINNT
72a76
> #endif
94a99,104
> #ifdef WINNT
> extern char *pathhosts;
> extern int res_paths_initialized;
> extern init_res_paths();
> #endif
> 
110a121
> int inet_pton();
133a145
> #ifndef WINNT
134a147
> #endif
145a159
> #ifndef WINNT
146a161,164
> #else
> 		WSASetLastError(save);
> 		SetLastError(save);
> #endif
190,191c208,209
< 	ancount = ntohs(hp->ancount);
< 	qdcount = ntohs(hp->qdcount);
---
> 	ancount = ntohs( (u_short) hp->ancount);
> 	qdcount = ntohs( (u_short) hp->qdcount);
195a214
> #ifndef WINNT
196a216,218
> #else
> 		WSASetLastError(NO_RECOVERY);
> #endif
200a223
> #ifndef WINNT
201a225,227
> #else
> 		WSASetLastError(NO_RECOVERY);
> #endif
300c326
< 				       AskedForGot, qname, bp);
---
> 				       (char *) AskedForGot, qname, bp);
331c357,361
< 			h_errno = NETDB_SUCCESS;
---
> #ifndef WINNT
>    		       h_errno = NETDB_SUCCESS;
> #else
>  		       WSASetLastError(NETDB_SUCCESS);
> #endif
338c368
< 				       AskedForGot, host.h_name, bp);
---
> 				       (char *)AskedForGot, host.h_name, bp);
404c434,438
< 		h_errno = NETDB_SUCCESS;
---
> #ifndef WINNT
>    		       h_errno = NETDB_SUCCESS;
> #else
>  		       WSASetLastError(NETDB_SUCCESS);
> #endif
407a442
> #ifndef WINNT
408a444,446
> #else
>         WSASetLastError(TRY_AGAIN);
> #endif
413,426d450
< gethostbyname(name)
< 	const char *name;
< {
< 	struct hostent *hp;
< 
< 	if (_res.options & RES_USE_INET6) {
< 		hp = gethostbyname2(name, AF_INET6);
< 		if (hp)
< 			return (hp);
< 	}
< 	return (gethostbyname2(name, AF_INET));
< }
< 
< struct hostent *
437a462
> #ifndef WINNT
438a464,466
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
451a480
> #ifndef WINNT
453a483,486
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> 		SetLastError(WSAEAFNOSUPPORT);
> #endif
482a516
> #ifndef WINNT
483a518,520
> #else
>                     WSASetLastError(HOST_NOT_FOUND);
> #endif
498c535,539
< 				h_errno = NETDB_SUCCESS;
---
> #ifndef WINNT
>    		       h_errno = NETDB_SUCCESS;
> #else
>  		       WSASetLastError(NETDB_SUCCESS);
> #endif
514a556,574
> #ifndef WINNT
> gethostbyname(name)
> #else
> gethostbyname_nt(name)
> #endif
> 	const char *name;
> {
> 	struct hostent *hp;
> 
> 	if (_res.options & RES_USE_INET6) {
> 		hp = gethostbyname2(name, AF_INET6);
> 		if (hp)
> 			return (hp);
> 	}
> 	return (gethostbyname2(name, AF_INET));
> }
> 
> struct hostent *
> #ifndef WINNT
515a576,578
> #else
> gethostbyaddr_nt(addr, len, af)
> #endif
532c595
< 	extern struct hostent *_gethtbyaddr();
---
> extern struct hostent *_gethtbyaddr();
534a598
> #ifndef WINNT
536c600,603
< 		return (NULL);
---
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
> 		return (0);
554a622
> #ifndef WINNT
557c625,629
< 		return (NULL);
---
> #else
>  		SetLastError(WSAEAFNOSUPPORT);
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
> 		return (0);
559a632
> #ifndef WINNT
562c635,639
< 		return (NULL);
---
> #else
>  		SetLastError(WSAEINVAL);
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
> 		return (0);
589c666
< 		return (NULL);
---
> 		return (0);
592c669
< 		return (NULL);	/* h_errno was set by getanswer() */
---
> 		return (0);	/* h_errno was set by getanswer() */
604c681
< 	    if (!(rhp = gethostbyname(hname2))) {
---
> 	    if (!(rhp = gethostbyname_nt(hname2))) {
609c686,690
< 		h_errno = HOST_NOT_FOUND;
---
> #ifndef WINNT
> 					h_errno = HOST_NOT_FOUND;
> #else
>                     WSASetLastError(HOST_NOT_FOUND);
> #endif
620c701,705
< 		h_errno = HOST_NOT_FOUND;
---
> #ifndef WINNT
> 					h_errno = HOST_NOT_FOUND;
> #else
>                     WSASetLastError(HOST_NOT_FOUND);
> #endif
635c720,724
< 	h_errno = NETDB_SUCCESS;
---
> #ifndef WINNT
>    		       h_errno = NETDB_SUCCESS;
> #else
>  		       WSASetLastError(NETDB_SUCCESS);
> #endif
642a732,733
>     
> #ifndef WINNT
644a736,743
> #else
>         if (!res_paths_initialized)
>           init_res_paths();
> 
> 	if (!hostf)
> 		hostf = fopen(pathhosts, "r" );
> #endif
> 
666c765,774
< 	if (!hostf && !(hostf = fopen(_PATH_HOSTS, "r" ))) {
---
> #ifndef WINNT
>  	if (!hostf && !(hostf = fopen(_PATH_HOSTS, "r" ))) {
> #else
>         if (!res_paths_initialized)
>            init_res_paths();
>  
>  	if (!hostf && !(hostf = fopen(pathhosts, "r" ))) {
> #endif
>  
> #ifndef WINNT
667a776,778
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
672c783,787
< 		h_errno = HOST_NOT_FOUND;
---
> #ifndef WINNT
> 					h_errno = HOST_NOT_FOUND;
> #else
>                     WSASetLastError(HOST_NOT_FOUND);
> #endif
727c842,846
< 	h_errno = NETDB_SUCCESS;
---
> #ifndef WINNT
>    		       h_errno = NETDB_SUCCESS;
> #else
>  		       WSASetLastError(NETDB_SUCCESS);
> #endif
diff --recurs m:\bind494rel/res/getnetbyaddr.c m:\bind/res/getnetbyaddr.c
39a40,42
> #ifdef WINNT
> #include "../conf/portability.h"
> #endif
diff --recurs m:\bind494rel/res/getnetbyname.c m:\bind/res/getnetbyname.c
41a42,44
> #ifdef WINNT
> #include "../conf/portability.h"
> #endif
diff --recurs m:\bind494rel/res/getnetent.c m:\bind/res/getnetent.c
49,53c49,55
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
55,58c57,66
< #include <stdio.h>
< #include <resolv.h>
< #include <netdb.h>
< #include <string.h>
---
> #include <stdio.h>
> #include <resolv.h>
> #include <netdb.h>
> #include <string.h>
> #ifdef WINNT
> #include "../conf/portability.h"
> extern char *pathnetworks;
> extern int res_paths_initialized;
> extern init_res_paths();
> #endif
63a72,73
> 
> 
96a107
> #ifndef WINNT
98a110,116
> #else
>        if (!res_paths_initialized)
>          init_res_paths();
> 
> 	if (netf == NULL)
> 		netf = fopen(pathnetworks, "r" );
> #endif
120a139
> #ifndef WINNT
121a141,147
> #else
>        if (!res_paths_initialized)
>          init_res_paths();
> 
> 	if (netf == NULL && (netf = fopen(pathnetworks, "r" )) == NULL)
> #endif
> 
diff --recurs m:\bind494rel/res/getnetnamadr.c m:\bind/res/getnetnamadr.c
47,51c47,53
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
53,56c55,58
< #include <stdio.h>
< #include <netdb.h>
< #include <resolv.h>
< #include <ctype.h>
---
> #include <stdio.h>
> #include <netdb.h>
> #include <resolv.h>
> #include <ctype.h>
59a62
> #ifndef WINNT
60a64,66
> #else
> #include "../conf/portability.h"
> #endif
66c72
< struct netent *_getnetbyaddr __P((long net, int type));
---
> struct netent *_getnetbyaddr __P((u_long net, int type));
122,123c128,129
< 	ancount = ntohs(hp->ancount); /* #/records in the answer section */
< 	qdcount = ntohs(hp->qdcount); /* #/entries in the question section */
---
> 	ancount = ntohs( (u_short) hp->ancount); /* #/records in the answer section */
> 	qdcount = ntohs( (u_short) hp->qdcount); /* #/entries in the question section */
128a135
> #ifndef WINNT
129a137,139
> #else
> 			WSASetLastError(HOST_NOT_FOUND);
> #endif
130a141
> #ifndef WINNT
131a143,145
> #else
> 			WSASetLastError(HOST_NOT_FOUND);
> #endif
198a213
> #ifndef WINNT
199a215,217
> #else
> 	WSASetLastError(TRY_AGAIN);
> #endif
268a287
> #ifndef WINNT
269a289,291
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
diff --recurs m:\bind494rel/res/herror.c m:\bind/res/herror.c
61,69c61,71
< #include <sys/param.h>
< #include <sys/uio.h>
< #include <netdb.h>
< #if defined(BSD) && (BSD >= 199103)
< # include <unistd.h>
< # include <string.h>
< #else
< # include "../conf/portability.h"
< #endif
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/uio.h>
> #endif
> #include <netdb.h>
> #if defined(BSD) && (BSD >= 199103)
> # include <unistd.h>
> # include <string.h>
> #else
> # include "../conf/portability.h"
> #endif
79a82
> #ifndef WINNT
80a84
> #endif
91a96,98
> #ifdef WINNT
> 	char err[50];
> #endif
100a108
> #ifndef WINNT
101a110,114
> #else
> 	/* XXX - map the error number to the corresponding message here */
> 	sprintf(err, "%d", h_errno);
> 	v->iov_base = err;
> #endif
108a122
> #ifndef WINNT
118a133
> #endif
diff --recurs m:\bind494rel/res/hostnamelen.c m:\bind/res/hostnamelen.c
60,62c60,65
< #include <sys/param.h>
< #include <sys/types.h>
< #include <netinet/in.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/types.h>
> #include <netinet/in.h>
> #endif
> 
diff --recurs m:\bind494rel/res/inet_addr.c m:\bind/res/inet_addr.c
61,65c61,67
< #include <sys/param.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <ctype.h>
< #include "../conf/portability.h"
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <ctype.h>
> #include "../conf/portability.h"
67d68
< /* these are compatibility routines, not needed on recent BSD releases */
69,70c70,76
< /*
<  * Ascii internet address interpretation routine.
---
> #ifndef NEED_INETADDR
> int __inet_addr_unneeded__;
> #else
> /* these are compatibility routines, not needed on recent BSD releases */
> 
> /*
>  * Ascii internet address interpretation routine.
82a89
> #endif  /* NEED_INETADDR */
diff --recurs m:\bind494rel/res/inet_ntop.c m:\bind/res/inet_ntop.c
21,30c21,32
< #include <sys/param.h>
< #include <sys/types.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
< #include <string.h>
< #include <errno.h>
< #include <stdio.h>
< #include "../conf/portability.h"
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/types.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
> #include <string.h>
> #include <errno.h>
> #include <stdio.h>
> #include "../conf/portability.h"
66a69
> #ifndef WINNT
67a71,74
> #else
> 		SetLastError(WSAEAFNOSUPPORT);
> 		WSASetLastError(WSAEAFNOSUPPORT);
> #endif
93c100,101
< 	if (SPRINTF((tmp, fmt, src[0], src[1], src[2], src[3])) > size) {
---
> 	if (SPRINTF((tmp, fmt, src[0], src[1], src[2], src[3])) > (int)size) {
> #ifndef WINNT
94a103,106
> #else
> 		SetLastError(ENOSPC);
> 		WSASetLastError(ENOSPC);
> #endif
189c201,202
< 	if ((tp - tmp) > size) {
---
> 	if ((tp - tmp) > (int)size) {
> #ifndef WINNT
190a204,207
> #else
> 		SetLastError(ENOSPC);
> 		WSASetLastError(ENOSPC);
> #endif
diff --recurs m:\bind494rel/res/inet_pton.c m:\bind/res/inet_pton.c
21,29c21,31
< #include <sys/param.h>
< #include <sys/types.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
< #include <string.h>
< #include <errno.h>
< #include "../conf/portability.h"
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/types.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
> #include <string.h>
> #include <errno.h>
> #include "../conf/portability.h"
61a64
> #ifndef WINNT
62a66,68
> #else
>         SetLastError(WSAEAFNOSUPPORT);
> #endif
diff --recurs m:\bind494rel/res/nsap_addr.c m:\bind/res/nsap_addr.c
5,10c5,12
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <ctype.h>
< #include <resolv.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <ctype.h>
> #include <resolv.h>
12c14
< #include "../conf/portability.h"
---
> #include "../conf/portability.h"
14c16
< #if !defined(isxdigit)	/* XXX - could be a function */
---
> #if !defined(isxdigit)	/* XXX - could be a function */
34c36
< 	int maxlen;
---
> 	u_int maxlen;
diff --recurs m:\bind494rel/res/res_comp.c m:\bind/res/res_comp.c
61,62c61,64
< #include <sys/param.h>
< #include <netinet/in.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <netinet/in.h>
> #endif
diff --recurs m:\bind494rel/res/res_data.c m:\bind/res/res_data.c
60,63c60,65
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <sys/time.h>
< #include <netinet/in.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <sys/time.h>
> #include <netinet/in.h>
> #endif /* WINNT */
diff --recurs m:\bind494rel/res/res_debug.c m:\bind/res/res_debug.c
61,66c61,68
< #include <sys/param.h>
< #include <sys/types.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/types.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
68,70c70,72
< #include <stdio.h>
< #include <netdb.h>
< #include <resolv.h>
---
> #include <stdio.h>
> #include <netdb.h>
> #include <resolv.h>
74c76
< # include "../conf/portability.h"
---
> #include "../conf/portability.h"
78c80
< # include "../conf/options.h"
---
> #include "../conf/options.h"
82a85,86
> char * inet_nsap_ntoa();
> const char * inet_ntop();
83a88
> 
180c185
< 	if (n = ntohs(cnt)) {
---
> 	if (n = ntohs( (u_short) cnt)) {
276c281
< 			ntohs(hp->id));
---
> 			ntohs( (u_short) hp->id));
295,298c300,303
< 		fprintf(file, "; Ques: %d", ntohs(hp->qdcount));
< 		fprintf(file, ", Ans: %d", ntohs(hp->ancount));
< 		fprintf(file, ", Auth: %d", ntohs(hp->nscount));
< 		fprintf(file, ", Addit: %d", ntohs(hp->arcount));
---
> 		fprintf(file, "; Ques: %d", ntohs( (u_short) hp->qdcount));
> 		fprintf(file, ", Ans: %d", ntohs( (u_short) hp->ancount));
> 		fprintf(file, ", Auth: %d", ntohs( (u_short) hp->nscount));
> 		fprintf(file, ", Addit: %d", ntohs( (u_short) hp->arcount));
307c312
< 	if (n = ntohs(hp->qdcount)) {
---
> 	if (n = ntohs( (u_short) hp->qdcount)) {
443a449
> #ifndef WINNT
444a451,453
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
1164c1173
< 	if (templ < referencealt) { /* below WGS 84 spheroid */
---
> 	if (templ < (u_int32_t)referencealt) { /* below WGS 84 spheroid */
diff --recurs m:\bind494rel/res/res_init.c m:\bind/res/res_init.c
61,70c61,72
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <sys/time.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
< 
< #include <stdio.h>
< #include <ctype.h>
< #include <resolv.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <sys/time.h>
> #include <netinet/in.h>
> #endif /* WINNT */
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
> 
> #include <stdio.h>
> #include <ctype.h>
> #include <resolv.h>
76c78
< # include "../conf/portability.h"
---
> #include "../conf/portability.h"
78a81,88
> #ifdef WINNT
> #include <netdb.h>
> #include "../conf/portability.h"
> extern char *pathresconf;
> extern int res_paths_initialized;
> extern init_res_paths();
> #endif
> 
168a179,190
> 
> #ifdef WINNT
>  	WORD wVersionRequested;
> 	WSADATA wsaData;
> 
> 	wVersionRequested = MAKEWORD(1,1);
> 	if (WSAStartup(wVersionRequested, &wsaData)) {
> 		syslog(LOG_ERR, "No useable winsock.dll: %m");
> 		return (-1);
> 	}
> #endif /* WINNT */
> 
254a277
> #ifndef WINNT
255a279,285
> #else
>        if (!res_paths_initialized)
>          init_res_paths();
> 
> 	if ((fp = fopen(pathresconf, "r")) != NULL) {
> 
> #endif
diff --recurs m:\bind494rel/res/res_mkquery.c m:\bind/res/res_mkquery.c
61,63c61,65
< #include <sys/param.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
65,70c67,72
< #include <stdio.h>
< #include <netdb.h>
< #include <resolv.h>
< #if defined(BSD) && (BSD >= 199103)
< # include <string.h>
< #else
---
> #include <stdio.h>
> #include <netdb.h>
> #include <resolv.h>
> #if defined(BSD) && (BSD >= 199103)
> # include <string.h>
> #else
101a104
> #ifndef WINNT
102a106,108
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
Only in m:\bind/res: res_nt_misc.c
diff --recurs m:\bind494rel/res/res_query.c m:\bind/res/res_query.c
61,64c61,66
< #include <sys/param.h>
< #include <netinet/in.h>
< #include <arpa/inet.h>
< #include <arpa/nameser.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/inet.h>
> #include <arpa/nameser.h>
66,70c68,72
< #include <stdio.h>
< #include <netdb.h>
< #include <resolv.h>
< #include <ctype.h>
< #include <errno.h>
---
> #include <stdio.h>
> #include <netdb.h>
> #include <resolv.h>
> #include <ctype.h>
> #include <errno.h>
88a91
> #ifndef WINNT
89a93
> #endif
114a119
> #ifndef WINNT
115a121,123
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
129a138
> #ifndef WINNT
130a140,142
> #else
> 		WSASetLastError(NO_RECOVERY);
> #endif
138a151
> #ifndef WINNT
139a153,155
> #else
> 		WSASetLastError(TRY_AGAIN);
> #endif
143c159
< 	if (hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
---
> 	if (hp->rcode != NOERROR || ntohs( (u_short) hp->ancount) == 0) {
147c163
< 			    ntohs(hp->ancount));
---
> 			    ntohs( (u_short) hp->ancount));
150a167
> #ifndef WINNT
151a169,171
> #else
> 			WSASetLastError(HOST_NOT_FOUND);
> #endif
153a174
> #ifndef WINNT
154a176,178
> #else
> 			WSASetLastError(TRY_AGAIN);
> #endif
156a181
> #ifndef WINNT
157a183,185
> #else
> 			WSASetLastError(NO_DATA);
> #endif
162a191
> #ifndef WINNT
163a193,195
> #else
> 			WSASetLastError(NO_RECOVERY);
> #endif
190a223
> #ifndef WINNT
191a225,227
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
193a230
> #ifndef WINNT
195a233,236
> #else
> 	WSASetLastError(HOST_NOT_FOUND);
> 	SetLastError(0);
> #endif
217a259
> #ifndef WINNT
218a261,263
> #else
>                 saved_herrno = WSAGetLastError();
> #endif
254a300
> #ifndef WINNT
255a302,304
> #else
> 				WSASetLastError(TRY_AGAIN);
> #endif
302a352
> #ifndef WINNT
308a359,366
> #else
> 	if (saved_herrno != -1)
> 		WSASetLastError(saved_herrno);
> 	else if (got_nodata)
> 		WSASetLastError(NO_DATA);
> 	else if (got_servfail)
> 		WSASetLastError(TRY_AGAIN);
> #endif
327a386
> #ifndef WINNT
328a388,390
> #else
> 		WSASetLastError(NETDB_INTERNAL);
> #endif
diff --recurs m:\bind494rel/res/res_send.c m:\bind/res/res_send.c
72,78c72,80
< #include <sys/param.h>
< #include <sys/time.h>
< #include <sys/socket.h>
< #include <sys/uio.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/time.h>
> #include <sys/socket.h>
> #include <sys/uio.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
80,81c82,83
< #include <stdio.h>
< #include <netdb.h>
---
> #include <stdio.h>
> #include <netdb.h>
97a100
> #ifndef WINNT
98a102,105
> #else
> static SOCKET s = INVALID_SOCKET;
> typedef char * caddr_t;
> #endif
145a153
> #ifndef WINNT
146a155,158
> #else
> 	WSASetLastError(save);
> 	SetLastError(save);
> #endif
159a172
> #ifndef WINNT
160a174,176
> #else
>  	SetLastError(save);
> #endif
232c248
< 	int qdcount = ntohs(((HEADER*)buf)->qdcount);
---
> 	int qdcount = ntohs( (u_short) ((HEADER*)buf)->qdcount);
269c285
< 	int qdcount = ntohs(((HEADER*)buf1)->qdcount);
---
> 	int qdcount = ntohs( (u_short) ((HEADER*)buf1)->qdcount);
271c287
< 	if (qdcount != ntohs(((HEADER*)buf2)->qdcount))
---
> 	if (qdcount != ntohs( (u_short) ((HEADER*)buf2)->qdcount))
300a317,320
> #ifdef WINNT
> 	int optionValue = SO_SYNCHRONOUS_NONALERT;
> 	DWORD BytesRead;
> #endif
365c385,394
< 
---
> #ifdef WINNT
> 			/* set up things so that subsequent socket()
> 			   calls will open blocking sockets */
> 			if (setsockopt(INVALID_SOCKET, SOL_SOCKET,
> 				  	SO_OPENTYPE, (char *)&optionValue,
> 					sizeof(optionValue)) != NO_ERROR) {
> 						Perror(stderr, "cannot open nonoverlapped socket", errno);
> 						return (-1);
> 			}
> #endif
376a406
> #ifndef WINNT
377a408,410
> #else
> 				if (s == INVALID_SOCKET) {
> #endif
381a415
> #ifndef WINNT
382a417,419
> #else
> 				SetLastError(0);
> #endif
414a452
> #ifndef WINNT
415a454,458
> #else
> 			while (ReadFile((HANDLE)s, (char *)cp, (DWORD)len,
> 				             &BytesRead, NULL) &&
> 				   (n = (int)BytesRead) > 0) {
> #endif
451a495
> #ifndef WINNT
452a497,501
> #else
> 					ReadFile((HANDLE)s, (char *)cp, (DWORD)len,
> 				             &BytesRead, NULL) &&
> 				    (n = (int)BytesRead) > 0) {
> #endif
474a524
> #ifndef WINNT
475a526,530
> #else
> 					if (ReadFile((HANDLE)s, (char *)junk, (DWORD)n,
> 				             &BytesRead, NULL) &&
> 				        (n = (int)BytesRead) > 0)
> #endif
503c558
< 
---
> #ifndef WINNT
504a560,562
> #else
> 			if ((s == INVALID_SOCKET) || vc) {
> #endif
507a566
> #ifndef WINNT
508a568,570
> #else
> 				if (s == INVALID_SOCKET) {
> #endif
532a595
> #ifndef WINNT
557a621
> #endif /* WINNT */
574a639
> #ifndef WINNT
575a641,643
> #else
> 					if (s1 == INVALID_SOCKET)
> #endif
582a651
> #ifndef WINNT
583a653,655
> #else
> 					SetLastError(0);
> #endif
593a666
> #ifndef WINNT
594a668
> #endif
610a685
> #ifndef WINNT
611a687,689
> #else
> 				if (errno == WSAEINTR)
> #endif
626a705
> #ifndef WINNT
627a707,710
> #else
> 			WSASetLastError(0);
> 			SetLastError(0);
> #endif
631a715
> #ifndef WINNT
632a717,719
> #else
> 				Perror(stderr, "recvfrom", WSAGetLastError());
> #endif
756,757c843,845
< 	if (!v_circuit)
< 		if (!gotsomewhere)
---
> 	if (!v_circuit) 
> 		if (!gotsomewhere) {
> #ifndef WINNT
759c847,853
< 		else
---
> #else
> 			WSASetLastError(ECONNREFUSED);
> 			SetLastError(ECONNREFUSED);
> #endif
> 
>      } else {
> #ifndef WINNT
761c855,860
< 	else
---
> #else
> 			WSASetLastError(ETIMEDOUT);
> 			SetLastError(ETIMEDOUT);
> #endif
>   }	else {
> #ifndef WINNT
763c862,866
< 	return (-1);
---
> #else
> 		WSASetLastError(terrno);
> 		SetLastError(terrno);
> #endif
>  }	return (-1);
777a881
> #ifndef WINNT
778a883,885
> #else
> 		s = INVALID_SOCKET;
> #endif
Only in m:\bind/res: resolv.mak
Only in m:\bind/res: resolv.mdp
Only in m:\bind/res: resolv.ncb
Only in m:\bind/res: resolv.vcp
diff --recurs m:\bind494rel/res/sethostent.c m:\bind/res/sethostent.c
39,40c39,42
< #include <sys/param.h>
< #include <netinet/in.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <netinet/in.h>
> #endif
Only in m:\bind/res: strip.bat
Only in m:\bind/shres/netbsd: .cvsignore
Only in m:\bind/shres/netbsd: Letter
Only in m:\bind: t3b-t4a
Only in m:\bind: t4b-t5b
Only in m:\bind/tools: MYDLL.DEF
Only in m:\bind/tools: WinRel
Only in m:\bind/tools: bdlltest.c
Only in m:\bind/tools: bdltest.exe
Only in m:\bind/tools: bdltest.mak
Only in m:\bind/tools: bdltest.vcp
Only in m:\bind/tools: binddll.def
Only in m:\bind/tools: binddll.mak
Only in m:\bind/tools: binddll.mdp
Only in m:\bind/tools: binddll.ncb
Only in m:\bind/tools: binddll.vcp
Only in m:\bind/tools: bindll.c
Only in m:\bind/tools: dig.c.sav
Only in m:\bind/tools: dig_nt.c
Only in m:\bind/tools: instsrv.c
Only in m:\bind/tools: instsrv.mak
Only in m:\bind/tools: instsrv.mdp
Only in m:\bind/tools: instsrv.ncb
Only in m:\bind/tools: instsrv.vcp
Only in m:\bind/tools/nslookup: BOG.WRI
Only in m:\bind/tools/nslookup: WinRel
diff --recurs m:\bind494rel/tools/nslookup/commands.l m:\bind/tools/nslookup/commands.l
210,219c210,219
< ^{WS}*\n				{
< 					    return(1);
< 					}
< ^.*\n					{
< 					    printf("Unrecognized command: %s",
< 							yytext);
< 					    return(1);
< 					}
< \n					{ ; }
< %%
---
> ^{WS}*\n   				{
> 					    return(1);
> 					}
> ^.*\n					{
> 					    printf("Unrecognized command: %s",
> 							yytext);
> 					    return(1);
> 					}
> \n					{ ; }
> %%                                      
diff --recurs m:\bind494rel/tools/nslookup/debug.c m:\bind/tools/nslookup/debug.c
73,82c73,84
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <resolv.h>
< #include <netdb.h>
< #include <stdio.h>
< #include "res.h"
< #include "../../conf/portability.h"
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <resolv.h>
> #include <netdb.h>
> #include <stdio.h>
> #include "res.h"
> #include "../../conf/portability.h"
88a91,99
> char * inet_nsap_ntoa();
> const char * inet_ntop();
> 
> /*
>  *  Forward references
>  */
> 
> void Fprint_query(u_char *msg, u_char *eom, int printHeader, FILE *file);
> 
101a113
> void
106c118
< 	Fprint_query(msg, eom, printHeader,stdout);
---
> 	Fprint_query(msg, eom, printHeader, stdout);
108a121
> void
128c141
< 	    fprintf(file,", id = %d", ntohs(hp->id));
---
> 	    fprintf(file,", id = %d", ntohs( (u_short) hp->id));
144,147c157,160
< 	    fprintf(file,"\n\tquestions = %d", ntohs(hp->qdcount));
< 	    fprintf(file,",  answers = %d", ntohs(hp->ancount));
< 	    fprintf(file,",  authority records = %d", ntohs(hp->nscount));
< 	    fprintf(file,",  additional = %d\n\n", ntohs(hp->arcount));
---
> 	    fprintf(file,"\n\tquestions = %d", ntohs( (u_short) hp->qdcount));
> 	    fprintf(file,",  answers = %d", ntohs( (u_short) hp->ancount));
> 	    fprintf(file,",  authority records = %d", ntohs( (u_short) hp->nscount));
> 	    fprintf(file,",  additional = %d\n\n", ntohs( (u_short) hp->arcount));
153c166
< 	if (n = ntohs(hp->qdcount)) {
---
> 	if (n = ntohs( (u_short) hp->qdcount)) {
171c184
< 	if (n = ntohs(hp->ancount)) {
---
> 	if (n = ntohs( (u_short) hp->ancount)) {
183c196
< 	if (n = ntohs(hp->nscount)) {
---
> 	if (n = ntohs( (u_short) hp->nscount)) {
195c208
< 	if (n = ntohs(hp->arcount)) {
---
> 	if (n = ntohs( (u_short) hp->arcount)) {
556c569
< 					s = getservbyport((int)htons(n),
---
> 					s = getservbyport((int)htons( (u_short) n),
Only in m:\bind/tools/nslookup: dig.c
Only in m:\bind/tools/nslookup: dig.mak
Only in m:\bind/tools/nslookup: dig.mdp
Only in m:\bind/tools/nslookup: dig.ncb
Only in m:\bind/tools/nslookup: dig.vcp
diff --recurs m:\bind494rel/tools/nslookup/getinfo.c m:\bind/tools/nslookup/getinfo.c
74,83c74,86
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <resolv.h>
< #include <stdio.h>
< #include <ctype.h>
< #include "res.h"
< #include "../../conf/portability.h"
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif 
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <resolv.h>
> #include <stdio.h>
> #include <ctype.h>
> #include "res.h"
> #include "../../conf/portability.h"
> 
120a124,132
> /*
>  * Forward references
>  */
> 
> int GetHostDomain(struct in_addr *nsAddrPtr, int queryClass, int queryType, char *name, 
>               char *domain, HostInfo *hostPtr, Boolean isServer);
> static int GetAnswer(struct in_addr	*nsAddrPtr, int queryType, char *msg, int msglen, Boolean iquery, 
>                      register HostInfo	*hostPtr, Boolean isServer);
> 
193,196c205,208
<     qdcount = ntohs(headerPtr->qdcount);
<     ancount = ntohs(headerPtr->ancount);
<     arcount = ntohs(headerPtr->arcount);
<     nscount = ntohs(headerPtr->nscount);
---
>     qdcount = ntohs( (u_short) headerPtr->qdcount);
>     ancount = ntohs( (u_short) headerPtr->ancount);
>     arcount = ntohs( (u_short) headerPtr->arcount);
>     nscount = ntohs( (u_short) headerPtr->nscount);
647c659
< 	}
---
>     }
665a678
> int
diff --recurs m:\bind494rel/tools/nslookup/list.c m:\bind/tools/nslookup/list.c
73,82c73,84
< #include <sys/param.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <resolv.h>
< #include <netdb.h>
< #include <stdio.h>
< #include <limits.h>
< #include <ctype.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <resolv.h>
> #include <netdb.h>
> #include <stdio.h>
> #include <limits.h>
> #include <ctype.h>
100a103,113
> char * inet_nsap_ntoa();
> const char * inet_ntop();
> 
> /*
>  * Forward references
>  */
> 
> int
> PrintListInfo(FILE *file, u_char *msg, u_char *eom, int qtype, char *domain);
> 
> 
313c326,327
< 
---
>     
>   #ifndef WINNT
315a330,335
>   #else
> 
>         if (send(sockFD,(const char *)&len,INT16SZ,0) != INT16SZ  ||
>             send(sockFD,(const char *)&buf,msglen,0) != msglen) {
>   #endif
> 
329c349
< 	    filePtr = OpenFile(cmd, file);
---
> 	    filePtr = AppOpenFile(cmd, file);
442a463
> #ifndef WINNT
443a465,467
> #else
> 	    while ((numRead = recv(sockFD, cp, amtToRead,0)) > 0) {
> #endif
474a499
>         #ifndef WINNT
475a501,504
> #else
> 	    while (amtToRead > 0 && (numRead=recv(sockFD, cp, amtToRead,0)) > 0) {
> 
> #endif
489c518
< 	    numRecords += htons(((HEADER *)answer)->ancount);
---
> 	    numRecords += htons((u_short)((HEADER *)answer)->ancount);
495,534c524,563
< 	    /* Header. */
< 	    cp = answer + HFIXEDSZ;
< 	    /* Question. */
< 	    for (count = ntohs(((HEADER* )answer)->qdcount);
< 		 count > 0;
< 		 count--)
< 		    cp += dn_skipname(cp, answer + len) + QFIXEDSZ;
< 	    /* Answer. */
< 	    for (count = ntohs(((HEADER* )answer)->ancount);
< 		 count > 0;
< 		 count--) {
< 		int type, class, rlen;
< 
< 		n = dn_expand(answer, answer + len, cp,
< 			      dname[soacnt], sizeof dname[0]);
< 		if (n < 0) {
< 		    error = ERR_PRINTING;
< 		    done++;
< 		    break;
< 		}
< 		cp += n;
< 		GETSHORT(type, cp);
< 		GETSHORT(class, cp);
< 		cp += INT32SZ;	/* ttl */
< 		GETSHORT(rlen, cp);
< 		cp += rlen;
< 		if (type == T_SOA && soacnt++ &&
< 		    !strcasecmp(dname[0], dname[1])) {
< 		    done++;
< 		    break;
< 		}
< 	    }
< 	}
< 
< 	if (cmd != NULL) {
< 	    fprintf(stdout, "%sReceived %d answer%s (%d record%s).\n",
< 		(numAnswers >= HASH_SIZE) ? "\n" : "",
< 		numAnswers, (numAnswers != 1) ? "s" : "",
< 		numRecords, (numRecords != 1) ? "s" : "");
< 	}
---
>  	    /* Header. */
>   	    cp = answer + HFIXEDSZ;
>  	    /* Question. */
>  	    for (count = ntohs((u_short)((HEADER* )answer)->qdcount);
>  		 count > 0;
>  		 count--)
>  		    cp += dn_skipname((u_char *)cp, (u_char *)answer + len) + QFIXEDSZ;
>  	    /* Answer. */
>  	    for (count = ntohs((u_short)((HEADER* )answer)->ancount);
>  		 count > 0;
>  		 count--) {
>  		int type, class, rlen;
>  
>  		n = dn_expand(answer, answer + len, cp,
>  			      dname[soacnt], sizeof dname[0]);
>  		if (n < 0) {
>  		    error = ERR_PRINTING;
>  		    done++;
>  		    break;
>  		}
>  		cp += n;
>  		GETSHORT(type, cp);
>  		GETSHORT(class, cp);
>  		cp += INT32SZ;	/* ttl */
>  		GETSHORT(rlen, cp);
>  		cp += rlen;
>  		if (type == T_SOA && soacnt++ &&
>  		    !strcasecmp(dname[0], dname[1])) {
>  		    done++;
>  		    break;
>  		}
>   	    }
>   	}
>   
>   	if (cmd != NULL) {
>  	    fprintf(stdout, "%sReceived %d answer%s (%d record%s).\n",
>   		(numAnswers >= HASH_SIZE) ? "\n" : "",
>  		numAnswers, (numAnswers != 1) ? "s" : "",
>  		numRecords, (numRecords != 1) ? "s" : "");
>   	}
559,560c588,589
< 			ntohs(headerPtr->ancount), ntohs(headerPtr->nscount),
< 			ntohs(headerPtr->arcount));
---
> 			ntohs( (u_short) headerPtr->ancount), ntohs( (u_short) headerPtr->nscount),
> 			ntohs( (u_short) headerPtr->arcount));
566d594
< 
606a635
> int
638c667
<     if (ntohs(headerPtr->ancount) == 0) {
---
>     if (ntohs( (u_short) headerPtr->ancount) == 0) {
640,649c669,678
<     }
<     for (n = ntohs(headerPtr->qdcount); n > 0; n--) {
< 	nameLen = dn_skipname(cp, eom);
< 	if (nameLen < 0)
< 	    return (ERROR);
< 	cp += nameLen + QFIXEDSZ;
<     }
<     for (count = ntohs(headerPtr->ancount); count > 0; count--) {
< 	nameLen = dn_expand(msg, eom, cp, name, sizeof name);
< 	if (nameLen < 0)
---
>       }
>       for (n = ntohs((u_short) headerPtr->qdcount); n > 0; n--) {
>  	nameLen = dn_skipname(cp, eom);
>  	if (nameLen < 0)
>  	    return (ERROR);
>  	cp += nameLen + QFIXEDSZ;
>       }
>       for (count = ntohs((u_short)headerPtr->ancount); count > 0; count--) {
>   	nameLen = dn_expand(msg, eom, cp, name, sizeof name);
>   	if (nameLen < 0)
926a956
> void
961a992
>     #ifndef WINNT
962a994,998
>     #else
>     char f[5000];
>     int numread = 0;
>     int i;
>     #endif
1018c1054
< 	    filePtr = OpenFile(string, file);
---
> 	    filePtr = AppOpenFile(string, file);
1029a1066
> #ifndef WINNT
1031c1068
< 	}
---
>         	}
1034c1071,1078
< 	f = fdopen(sockFD, "r");
---
> #else
>    /* send(sockFD,"/W",3,0); */
>          }
> 	send(sockFD, name, strlen(name),0);
> 	send(sockFD, "\r\n", 2,0);
> 	#endif
> #ifndef WINNT	
> 	f = fdopen(sockFD, "r"); 
1050c1094,1118
< 	if (lastc != '\n') {
---
> #else
>     while ((numread = recv(sockFD,(char *)f,4999,0)) != 0)
>       {
> 
> 	   for (i=0; i<=numread; i++)
>         {
>           c = f[i];
>           switch (c) 
>           {
> 		    case 0210:
> 		    case 0211:
> 		    case 0212:
> 		    case 0214:
> 	  		      c -= 0200;
> 			      break;
> 		    case 0215:
> 			     c = '\n';
> 			     break;
> 	       }
> 	        putc(lastc = c, filePtr);
>       }       
>       }
>  #endif
> 	if (lastc != '\n') 
> 	  {
1052,1053c1120,1121
< 	}
< 	putc('\n', filePtr);
---
> 	  }
> 	  putc('\n', filePtr);
1064a1133
> void
diff --recurs m:\bind494rel/tools/nslookup/main.c m:\bind/tools/nslookup/main.c
82,91c82,95
< #include <sys/param.h>
< #include <netdb.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <resolv.h>
< #include <signal.h>
< #include <setjmp.h>
< #include <ctype.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <netinet/in.h>
> #include <setjmp.h>
> #endif
> #include <netdb.h>
> #ifndef WINNT
> #include <sys/socket.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <resolv.h>
> #include <signal.h>
> #include <ctype.h>
99c103,112
< 
---
>   /* 
>    * Forward references
>    */
>   void Usage();
>   void LocalServer(HostInfo *defaultPtr);
>   int  LookupHost(char *string, Boolean putToFile);
>   void res_re_init();
>   void res_dnsrch(register char *cp);
>   int  SetOption(register char *option);
>   
109a123,125
>   #ifdef WINNT
>   HANDLE hReadWriteEvent = NULL;
>   #endif
143c159
<  * Stuff for Interrupt (control-C) signal handler.
---
>  * Stuff for Interrupt (control-C) signal handler.                    
145a162
> #ifndef WINNT
147d163
< FILE		*filePtr;
149c165,168
< 
---
> #else
> 	char *pathnslookuprc, *pathpagercmd, *pathhelpfile;
> #endif
> FILE		*filePtr;
158a178,203
> #ifdef WINNT
> /* Expand environmental variables in file pathnames */
> /* XXX - Would it be better to store/retrieve pathnames from the registry? */
> void
> expand_paths(void)
> {
> 
> 	pathnslookuprc = (char *)malloc(MAX_PATH);
> 	if (!ExpandEnvironmentStrings(_PATH_NSLOOKUPRC, pathnslookuprc, MAX_PATH)) {
> 		syslog(LOG_ERR, "ExpandEnvironmentStrings(_PATH_NSLOOKUPRC) failed: %m\n");
> 	} else
> 
> 	pathpagercmd = (char *)malloc(MAX_PATH);
> 	if (!ExpandEnvironmentStrings(_PATH_PAGERCMD, pathpagercmd, MAX_PATH)) {
> 		syslog(LOG_ERR, "ExpandEnvironmentStrings(_PATH_PAGERCMD) failed: %m\n");
> 	} else
> 		 
> 	pathhelpfile = (char *)malloc(MAX_PATH);
> 	if (!ExpandEnvironmentStrings(_PATH_HELPFILE, pathhelpfile, MAX_PATH)) {
> 		syslog(LOG_ERR, "ExpandEnvironmentStrings(_PATH_HELPFILE) failed: %m\n");
> 	}
> 
> }
> #endif /* WINNT */
> 
> 
184a230,250
>      
> #ifdef WINNT
> /* lgk moved startup to beginning.. */
> 
> 
> 
> 
> 	hReadWriteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
>    {
>  	WORD wVersionRequested;
> 	WSADATA wsaData;
> 
>         expand_paths();
> 	wVersionRequested = MAKEWORD(1,1);
> 	if (WSAStartup(wVersionRequested, &wsaData)) {
> 		syslog(LOG_ERR, "No useable winsock.dll: %m");
> 		return (-1);
> 	}
> 
>    }
> #endif /* WINNT */
246a313
> #ifndef WINNT
247a315,317
> #else
> 	    hp = gethostbyname_nt(*argv);
> #endif
322a393
> #ifndef WINNT 
323a395,397
> #else
>             pager = pathpagercmd;
> #endif
325d398
< 
329c402
< 
---
> #ifndef WINNT
338c411
< 
---
> #endif
345a419
> 
354a429
> void
362,363c437,439
<     defaultAddr.s_addr = htonl(INADDR_ANY);
<     (void) GetHostInfoByName(&defaultAddr, C_IN, T_A,
---
> #ifndef WINNT
>     defaultAddr.s_addr = htonl(INADDR_ANY); 
>       (void) GetHostInfoByName(&defaultAddr, C_IN, T_A,
364a441,447
> #else /* lgk the 0.0.0.0 doesn't work for nt so set to loopback */
>     defaultAddr.s_addr = htonl(INADDR_LOOPBACK);
>           (void) GetHostInfoByName(&defaultAddr, C_IN, T_A,
> 			     "127.0.0.1", defaultPtr, 1);
> 
> #endif
>   
380a464
> void 
685c769
< 	filePtr = OpenFile(string, file);
---
> 	filePtr = AppOpenFile(string, file);
746c830
< 	filePtr = OpenFile(string, file);
---
> 	filePtr = AppOpenFile(string, file);
934a1019
> void
956a1042
> void
1053c1139
< 
---
> #ifndef WINNT
1054a1141,1145
> #else
> 	sprintf(cmd, "%s < %s", pager, pathhelpfile);
> #endif
> 
>         /* printf("path helpfile = %s ",pathhelpfile); */
1106a1198
> #ifndef WINNT
1107a1200,1202
> #else
> 	(void) strcat(buf, pathnslookuprc);
> #endif
Only in m:\bind/tools/nslookup: nslookup.exe
Only in m:\bind/tools/nslookup: nslookup.mak
Only in m:\bind/tools/nslookup: nslookup.mdp
Only in m:\bind/tools/nslookup: nslookup.ncb
Only in m:\bind/tools/nslookup: nslookup.vcp
Only in m:\bind/tools/nslookup: nslookupnt.zip
diff --recurs m:\bind494rel/tools/nslookup/pathnames.h m:\bind/tools/nslookup/pathnames.h
62,68c62,77
< #define _PATH_PAGERCMD		"more"
< 
< #ifndef _PATH_HELPFILE
< #if defined(BSD) && BSD >= 198810
< #define	_PATH_HELPFILE		"/usr/share/misc/nslookup.help"
< #else
< #define _PATH_HELPFILE		"/usr/lib/nslookup.help"
---
> 
> #ifndef WINNT
> #define _PATH_PAGERCMD		"more"
> #else
> #define _PATH_PAGERCMD		"more"
> #endif
> 
> #ifndef _PATH_HELPFILE
> #if defined(BSD) && BSD >= 198810
> #define	_PATH_HELPFILE		"/usr/share/misc/nslookup.help"
> #else
> #ifdef WINNT
> #define _PATH_HELPFILE		"%windir%\\system32\\nslookup.help"
> #else
> #define _PATH_HELPFILE		"/usr/lib/nslookup.help"
> #endif
Only in m:\bind/tools/nslookup: readme.nt
diff --recurs m:\bind494rel/tools/nslookup/res.h m:\bind/tools/nslookup/res.h
76,78c76,87
< #define TRUE	1
< #define FALSE	0
< typedef int Boolean;
---
> #ifndef _RES_H_
> #define _RES_H_
> 
> #ifdef WINNT
> #include <winsock.h>
> #include "../../conf/portability.h"
> #include <stdio.h>
> #endif
> 
> #define TRUE	1
> #define FALSE	0
> typedef int Boolean;
81,82c90,91
<  *  Define return statuses in addtion to the ones defined in namserv.h
<  *   let SUCCESS be a synonym for NOERROR
---
>  *  Define return statuses in addtion to the ones defined in namserv.h
>  *   let SUCCESS be a synonym for NOERROR
84,85c93,94
<  *	TIME_OUT	- a socket connection timed out.
<  *	NO_INFO		- the server didn't find any info about the host.
---
>  *	TIME_OUT	- a socket connection timed out.
>  *	NO_INFO		- the server didn't find any info about the host.
158c167,173
< extern int  Print_query();
---
> 
> /*
>  * debug.c definitions
>  */
> 
> void Print_query(char *msg, char *eom, int printHeader);
> 
163d177
< extern char *DecodeError();
165c179
< extern char *Malloc();
---
> 
168c182
< extern void PrintHostInfo();
---
> 
170,171d183
< extern void FreeHostInfoPtr();
< extern FILE *OpenFile();
172a185,230
> 
> /*
>  * subr.c definitions
>  */
> 
> char * Malloc(int size);
> void PrintHostInfo(FILE	*file, char	*title, register HostInfo *hp);
> FILE * AppOpenFile(char *string, char *file);
> char * DecodeError(int result);
> int StringToType(char *type, int dflt, FILE *errorfile);
> int StringToClass(char *class, int dflt, FILE *errorfile);
> char * DecodeType(int type);
> 
> 
> /*
>  * getinfo.c definitions
>  */
> 
> static int GetAnswer(struct in_addr *nsAddrPtr, int queryType, char *msg, int msglen,
>                      Boolean iquery, register HostInfo *hostPtr, Boolean isServer);
> int GetHostInfoByName(struct in_addr	*nsAddrPtr, int queryClass, int queryType,
>                       char *name, HostInfo *hostPtr, Boolean isServer);
> int GetHostInfoByAddr(struct in_addr *nsAddrPtr, struct in_addr	*address, HostInfo *hostPtr);
> void FreeHostInfoPtr( register HostInfo *hostPtr);
> 
> 
> /*
>  * send.c definitions
>  */
> 
> int SendRequest(struct in_addr	*nsAddrPtr, char *buf, int buflen,
> 	            char *answer, u_int anslen, int *trueLenPtr);
> 
> 
> /* lgk new definitions */
> extern int SetDefaultServer();
> extern int Finger();
> extern void ViewList();
> extern void ListHosts();
> extern void ListHostsByType();
> extern int SetOption();
> extern int LookupHost();
> extern int LookupHostWithServer();
> extern int yylex();
> 
> #endif /* _RES_H_ */
Only in m:\bind/tools/nslookup: save1
diff --recurs m:\bind494rel/tools/nslookup/send.c m:\bind/tools/nslookup/send.c
77,86c77,87
< 
< #include <sys/param.h>
< #include <sys/time.h>
< #include <sys/socket.h>
< #include <sys/uio.h>
< #include <netinet/in.h>
< #include <stdio.h>
< #include <errno.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <sys/time.h>
> #include <sys/socket.h>
> #include <sys/uio.h>
> #include <netinet/in.h>
> #endif 
> #include <stdio.h>
> #include <errno.h>
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
88d88
< #include "res.h"
89a90,91
> #include "res.h"
> 
239c241
< 			if ((resplen = _getshort((u_char*)cp)) > anslen) {
---
> 			if ( (u_int)(resplen = _getshort((u_char*)cp)) > anslen) {
405a408
> void
diff --recurs m:\bind494rel/tools/nslookup/skip.c m:\bind/tools/nslookup/skip.c
78,83c78,85
< #include <sys/param.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <resolv.h>
< #include <stdio.h>
< #include "../../conf/portability.h"
---
> #ifndef WINNT
> #include <sys/param.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <resolv.h>
> #include <stdio.h>
> #include "../../conf/portability.h"
85c87
< char *res_skip_rr();
---
> char *res_skip_rr();
87c89
< 
---
> 
129c131
< 	if (n = ntohs(hp->qdcount) ) {
---
> 	if (n = ntohs( (u_short) hp->qdcount) ) {
143c145
< 	if (n = ntohs(hp->ancount)) {
---
> 	if (n = ntohs( (u_short) hp->ancount)) {
154c156
< 	if (n = ntohs(hp->nscount)) {
---
> 	if (n = ntohs( (u_short) hp->nscount)) {
165c167
< 	if (n = ntohs(hp->arcount)) {
---
> 	if (n = ntohs( (u_short) hp->arcount)) {
diff --recurs m:\bind494rel/tools/nslookup/subr.c m:\bind/tools/nslookup/subr.c
77,86c77,92
< #include <sys/types.h>
< #include <sys/param.h>
< #include <netdb.h>
< #include <sys/socket.h>
< #include <netinet/in.h>
< #include <arpa/nameser.h>
< #include <arpa/inet.h>
< #include <signal.h>
< #include <setjmp.h>
< #include <stdio.h>
---
> #ifndef WINNT
> #include <sys/types.h>
> #include <sys/param.h>
> #endif
> #include <netdb.h>
> #ifndef WINNT
> #include <sys/socket.h>
> #include <netinet/in.h>
> #endif
> #include <arpa/nameser.h>
> #include <arpa/inet.h>
> #include <signal.h>
> #ifndef WINNT
> #include <setjmp.h>
> #endif
> #include <stdio.h>
114a121
>  #ifndef WINNT
138c145
< 
---
>  #endif
189c196,198
<     { int saveMask;
---
>     { 
>       #ifndef WINNT
> 	  int saveMask;
190a200
>       #endif
191a202
>      #ifndef WINNT
192a204
>      #endif
319c331
<  *  OpenFile --
---
>  *  AppOpenFile --
333c345
< OpenFile(string, file)
---
> AppOpenFile(string, file)
Only in m:\bind/tools/nslookup: winntport.txt
Only in m:\bind/tools/nslookup: yylex.c
